From 6462c32f5f3783fa28a6bec798e871b5e23dec17 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Thu, 19 Dec 2019 20:45:10 +0800 Subject: [PATCH] Generated 2019-09-28 for reid. --- CHANGELOG | 3 + VERSION | 2 +- reid/CMakeLists.txt | 134 +++++ reid/include/alibabacloud/reid/ReidClient.h | 150 +++++ reid/include/alibabacloud/reid/ReidExport.h | 32 ++ .../model/DescribeBaseStatisticsRequest.h | 60 ++ .../reid/model/DescribeBaseStatisticsResult.h | 98 ++++ .../reid/model/DescribeCursorRequest.h | 51 ++ .../reid/model/DescribeCursorResult.h | 57 ++ .../DescribeCustomerFlowByLocationRequest.h | 69 +++ .../DescribeCustomerFlowByLocationResult.h | 78 +++ .../reid/model/DescribeHeatMapRequest.h | 54 ++ .../reid/model/DescribeHeatMapResult.h | 63 +++ .../reid/model/DescribeImageUrlsRequest.h | 54 ++ .../reid/model/DescribeImageUrlsResult.h | 62 +++ .../reid/model/DescribeOverviewDataRequest.h | 51 ++ .../reid/model/DescribeOverviewDataResult.h | 70 +++ .../model/ImportSpecialPersonnelRequest.h | 69 +++ .../reid/model/ImportSpecialPersonnelResult.h | 62 +++ .../reid/model/ListActionDataRequest.h | 63 +++ .../reid/model/ListActionDataResult.h | 103 ++++ .../alibabacloud/reid/model/ListEmapRequest.h | 48 ++ .../alibabacloud/reid/model/ListEmapResult.h | 64 +++ .../reid/model/ListLocationRequest.h | 48 ++ .../reid/model/ListLocationResult.h | 80 +++ .../reid/model/ListPersonByImageRequest.h | 51 ++ .../reid/model/ListPersonByImageResult.h | 62 +++ .../reid/model/ListStoreRequest.h | 45 ++ .../alibabacloud/reid/model/ListStoreResult.h | 70 +++ .../reid/model/PullActionDataRequest.h | 57 ++ .../reid/model/PullActionDataResult.h | 97 ++++ reid/src/ReidClient.cc | 521 ++++++++++++++++++ .../model/DescribeBaseStatisticsRequest.cc | 84 +++ .../src/model/DescribeBaseStatisticsResult.cc | 147 +++++ reid/src/model/DescribeCursorRequest.cc | 51 ++ reid/src/model/DescribeCursorResult.cc | 72 +++ .../DescribeCustomerFlowByLocationRequest.cc | 117 ++++ .../DescribeCustomerFlowByLocationResult.cc | 130 +++++ reid/src/model/DescribeHeatMapRequest.cc | 62 +++ reid/src/model/DescribeHeatMapResult.cc | 82 +++ reid/src/model/DescribeImageUrlsRequest.cc | 62 +++ reid/src/model/DescribeImageUrlsResult.cc | 80 +++ reid/src/model/DescribeOverviewDataRequest.cc | 51 ++ reid/src/model/DescribeOverviewDataResult.cc | 91 +++ .../model/ImportSpecialPersonnelRequest.cc | 117 ++++ .../src/model/ImportSpecialPersonnelResult.cc | 80 +++ reid/src/model/ListActionDataRequest.cc | 95 ++++ reid/src/model/ListActionDataResult.cc | 160 ++++++ reid/src/model/ListEmapRequest.cc | 40 ++ reid/src/model/ListEmapResult.cc | 84 +++ reid/src/model/ListLocationRequest.cc | 40 ++ reid/src/model/ListLocationResult.cc | 112 ++++ reid/src/model/ListPersonByImageRequest.cc | 51 ++ reid/src/model/ListPersonByImageResult.cc | 80 +++ reid/src/model/ListStoreRequest.cc | 29 + reid/src/model/ListStoreResult.cc | 96 ++++ reid/src/model/PullActionDataRequest.cc | 73 +++ reid/src/model/PullActionDataResult.cc | 139 +++++ 58 files changed, 4752 insertions(+), 1 deletion(-) create mode 100644 reid/CMakeLists.txt create mode 100644 reid/include/alibabacloud/reid/ReidClient.h create mode 100644 reid/include/alibabacloud/reid/ReidExport.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeBaseStatisticsRequest.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeBaseStatisticsResult.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeCursorRequest.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeCursorResult.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationRequest.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationResult.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeHeatMapRequest.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeHeatMapResult.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeImageUrlsRequest.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeImageUrlsResult.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeOverviewDataRequest.h create mode 100644 reid/include/alibabacloud/reid/model/DescribeOverviewDataResult.h create mode 100644 reid/include/alibabacloud/reid/model/ImportSpecialPersonnelRequest.h create mode 100644 reid/include/alibabacloud/reid/model/ImportSpecialPersonnelResult.h create mode 100644 reid/include/alibabacloud/reid/model/ListActionDataRequest.h create mode 100644 reid/include/alibabacloud/reid/model/ListActionDataResult.h create mode 100644 reid/include/alibabacloud/reid/model/ListEmapRequest.h create mode 100644 reid/include/alibabacloud/reid/model/ListEmapResult.h create mode 100644 reid/include/alibabacloud/reid/model/ListLocationRequest.h create mode 100644 reid/include/alibabacloud/reid/model/ListLocationResult.h create mode 100644 reid/include/alibabacloud/reid/model/ListPersonByImageRequest.h create mode 100644 reid/include/alibabacloud/reid/model/ListPersonByImageResult.h create mode 100644 reid/include/alibabacloud/reid/model/ListStoreRequest.h create mode 100644 reid/include/alibabacloud/reid/model/ListStoreResult.h create mode 100644 reid/include/alibabacloud/reid/model/PullActionDataRequest.h create mode 100644 reid/include/alibabacloud/reid/model/PullActionDataResult.h create mode 100644 reid/src/ReidClient.cc create mode 100644 reid/src/model/DescribeBaseStatisticsRequest.cc create mode 100644 reid/src/model/DescribeBaseStatisticsResult.cc create mode 100644 reid/src/model/DescribeCursorRequest.cc create mode 100644 reid/src/model/DescribeCursorResult.cc create mode 100644 reid/src/model/DescribeCustomerFlowByLocationRequest.cc create mode 100644 reid/src/model/DescribeCustomerFlowByLocationResult.cc create mode 100644 reid/src/model/DescribeHeatMapRequest.cc create mode 100644 reid/src/model/DescribeHeatMapResult.cc create mode 100644 reid/src/model/DescribeImageUrlsRequest.cc create mode 100644 reid/src/model/DescribeImageUrlsResult.cc create mode 100644 reid/src/model/DescribeOverviewDataRequest.cc create mode 100644 reid/src/model/DescribeOverviewDataResult.cc create mode 100644 reid/src/model/ImportSpecialPersonnelRequest.cc create mode 100644 reid/src/model/ImportSpecialPersonnelResult.cc create mode 100644 reid/src/model/ListActionDataRequest.cc create mode 100644 reid/src/model/ListActionDataResult.cc create mode 100644 reid/src/model/ListEmapRequest.cc create mode 100644 reid/src/model/ListEmapResult.cc create mode 100644 reid/src/model/ListLocationRequest.cc create mode 100644 reid/src/model/ListLocationResult.cc create mode 100644 reid/src/model/ListPersonByImageRequest.cc create mode 100644 reid/src/model/ListPersonByImageResult.cc create mode 100644 reid/src/model/ListStoreRequest.cc create mode 100644 reid/src/model/ListStoreResult.cc create mode 100644 reid/src/model/PullActionDataRequest.cc create mode 100644 reid/src/model/PullActionDataResult.cc diff --git a/CHANGELOG b/CHANGELOG index c08ad9e77..5463a8511 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2019-12-19 Version 1.36.217 +- Generated 2019-09-28 for `reid`. + 2019-12-19 Version 1.36.216 - DescribeNetworkInterfaces Supports NextToken. diff --git a/VERSION b/VERSION index fee9c6223..5f3d5fce3 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.216 \ No newline at end of file +1.36.217 \ No newline at end of file diff --git a/reid/CMakeLists.txt b/reid/CMakeLists.txt new file mode 100644 index 000000000..8b9d94ce2 --- /dev/null +++ b/reid/CMakeLists.txt @@ -0,0 +1,134 @@ +# +# Copyright 2009-2017 Alibaba Cloud All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include) + +set(reid_public_header + include/alibabacloud/reid/ReidClient.h + include/alibabacloud/reid/ReidExport.h ) + +set(reid_public_header_model + include/alibabacloud/reid/model/DescribeBaseStatisticsRequest.h + include/alibabacloud/reid/model/DescribeBaseStatisticsResult.h + include/alibabacloud/reid/model/DescribeCursorRequest.h + include/alibabacloud/reid/model/DescribeCursorResult.h + include/alibabacloud/reid/model/DescribeCustomerFlowByLocationRequest.h + include/alibabacloud/reid/model/DescribeCustomerFlowByLocationResult.h + include/alibabacloud/reid/model/DescribeHeatMapRequest.h + include/alibabacloud/reid/model/DescribeHeatMapResult.h + include/alibabacloud/reid/model/DescribeImageUrlsRequest.h + include/alibabacloud/reid/model/DescribeImageUrlsResult.h + include/alibabacloud/reid/model/DescribeOverviewDataRequest.h + include/alibabacloud/reid/model/DescribeOverviewDataResult.h + include/alibabacloud/reid/model/ImportSpecialPersonnelRequest.h + include/alibabacloud/reid/model/ImportSpecialPersonnelResult.h + include/alibabacloud/reid/model/ListActionDataRequest.h + include/alibabacloud/reid/model/ListActionDataResult.h + include/alibabacloud/reid/model/ListEmapRequest.h + include/alibabacloud/reid/model/ListEmapResult.h + include/alibabacloud/reid/model/ListLocationRequest.h + include/alibabacloud/reid/model/ListLocationResult.h + include/alibabacloud/reid/model/ListPersonByImageRequest.h + include/alibabacloud/reid/model/ListPersonByImageResult.h + include/alibabacloud/reid/model/ListStoreRequest.h + include/alibabacloud/reid/model/ListStoreResult.h + include/alibabacloud/reid/model/PullActionDataRequest.h + include/alibabacloud/reid/model/PullActionDataResult.h ) + +set(reid_src + src/ReidClient.cc + src/model/DescribeBaseStatisticsRequest.cc + src/model/DescribeBaseStatisticsResult.cc + src/model/DescribeCursorRequest.cc + src/model/DescribeCursorResult.cc + src/model/DescribeCustomerFlowByLocationRequest.cc + src/model/DescribeCustomerFlowByLocationResult.cc + src/model/DescribeHeatMapRequest.cc + src/model/DescribeHeatMapResult.cc + src/model/DescribeImageUrlsRequest.cc + src/model/DescribeImageUrlsResult.cc + src/model/DescribeOverviewDataRequest.cc + src/model/DescribeOverviewDataResult.cc + src/model/ImportSpecialPersonnelRequest.cc + src/model/ImportSpecialPersonnelResult.cc + src/model/ListActionDataRequest.cc + src/model/ListActionDataResult.cc + src/model/ListEmapRequest.cc + src/model/ListEmapResult.cc + src/model/ListLocationRequest.cc + src/model/ListLocationResult.cc + src/model/ListPersonByImageRequest.cc + src/model/ListPersonByImageResult.cc + src/model/ListStoreRequest.cc + src/model/ListStoreResult.cc + src/model/PullActionDataRequest.cc + src/model/PullActionDataResult.cc ) + +add_library(reid ${LIB_TYPE} + ${reid_public_header} + ${reid_public_header_model} + ${reid_src}) + +set_target_properties(reid + PROPERTIES + LINKER_LANGUAGE CXX + ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin + OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}reid + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(reid + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_REID_LIBRARY) +endif() + +target_include_directories(reid + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(reid + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(reid + jsoncpp) + target_include_directories(reid + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(reid + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(reid + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(reid + PRIVATE /usr/include/jsoncpp) + target_link_libraries(reid + jsoncpp) +endif() + +install(FILES ${reid_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/reid) +install(FILES ${reid_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/reid/model) +install(TARGETS reid + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/ReidClient.h b/reid/include/alibabacloud/reid/ReidClient.h new file mode 100644 index 000000000..b70c5168b --- /dev/null +++ b/reid/include/alibabacloud/reid/ReidClient.h @@ -0,0 +1,150 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_REIDCLIENT_H_ +#define ALIBABACLOUD_REID_REIDCLIENT_H_ + +#include +#include +#include +#include +#include "ReidExport.h" +#include "model/DescribeBaseStatisticsRequest.h" +#include "model/DescribeBaseStatisticsResult.h" +#include "model/DescribeCursorRequest.h" +#include "model/DescribeCursorResult.h" +#include "model/DescribeCustomerFlowByLocationRequest.h" +#include "model/DescribeCustomerFlowByLocationResult.h" +#include "model/DescribeHeatMapRequest.h" +#include "model/DescribeHeatMapResult.h" +#include "model/DescribeImageUrlsRequest.h" +#include "model/DescribeImageUrlsResult.h" +#include "model/DescribeOverviewDataRequest.h" +#include "model/DescribeOverviewDataResult.h" +#include "model/ImportSpecialPersonnelRequest.h" +#include "model/ImportSpecialPersonnelResult.h" +#include "model/ListActionDataRequest.h" +#include "model/ListActionDataResult.h" +#include "model/ListEmapRequest.h" +#include "model/ListEmapResult.h" +#include "model/ListLocationRequest.h" +#include "model/ListLocationResult.h" +#include "model/ListPersonByImageRequest.h" +#include "model/ListPersonByImageResult.h" +#include "model/ListStoreRequest.h" +#include "model/ListStoreResult.h" +#include "model/PullActionDataRequest.h" +#include "model/PullActionDataResult.h" + + +namespace AlibabaCloud +{ + namespace Reid + { + class ALIBABACLOUD_REID_EXPORT ReidClient : public RpcServiceClient + { + public: + typedef Outcome DescribeBaseStatisticsOutcome; + typedef std::future DescribeBaseStatisticsOutcomeCallable; + typedef std::function&)> DescribeBaseStatisticsAsyncHandler; + typedef Outcome DescribeCursorOutcome; + typedef std::future DescribeCursorOutcomeCallable; + typedef std::function&)> DescribeCursorAsyncHandler; + typedef Outcome DescribeCustomerFlowByLocationOutcome; + typedef std::future DescribeCustomerFlowByLocationOutcomeCallable; + typedef std::function&)> DescribeCustomerFlowByLocationAsyncHandler; + typedef Outcome DescribeHeatMapOutcome; + typedef std::future DescribeHeatMapOutcomeCallable; + typedef std::function&)> DescribeHeatMapAsyncHandler; + typedef Outcome DescribeImageUrlsOutcome; + typedef std::future DescribeImageUrlsOutcomeCallable; + typedef std::function&)> DescribeImageUrlsAsyncHandler; + typedef Outcome DescribeOverviewDataOutcome; + typedef std::future DescribeOverviewDataOutcomeCallable; + typedef std::function&)> DescribeOverviewDataAsyncHandler; + typedef Outcome ImportSpecialPersonnelOutcome; + typedef std::future ImportSpecialPersonnelOutcomeCallable; + typedef std::function&)> ImportSpecialPersonnelAsyncHandler; + typedef Outcome ListActionDataOutcome; + typedef std::future ListActionDataOutcomeCallable; + typedef std::function&)> ListActionDataAsyncHandler; + typedef Outcome ListEmapOutcome; + typedef std::future ListEmapOutcomeCallable; + typedef std::function&)> ListEmapAsyncHandler; + typedef Outcome ListLocationOutcome; + typedef std::future ListLocationOutcomeCallable; + typedef std::function&)> ListLocationAsyncHandler; + typedef Outcome ListPersonByImageOutcome; + typedef std::future ListPersonByImageOutcomeCallable; + typedef std::function&)> ListPersonByImageAsyncHandler; + typedef Outcome ListStoreOutcome; + typedef std::future ListStoreOutcomeCallable; + typedef std::function&)> ListStoreAsyncHandler; + typedef Outcome PullActionDataOutcome; + typedef std::future PullActionDataOutcomeCallable; + typedef std::function&)> PullActionDataAsyncHandler; + + ReidClient(const Credentials &credentials, const ClientConfiguration &configuration); + ReidClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + ReidClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~ReidClient(); + DescribeBaseStatisticsOutcome describeBaseStatistics(const Model::DescribeBaseStatisticsRequest &request)const; + void describeBaseStatisticsAsync(const Model::DescribeBaseStatisticsRequest& request, const DescribeBaseStatisticsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeBaseStatisticsOutcomeCallable describeBaseStatisticsCallable(const Model::DescribeBaseStatisticsRequest& request) const; + DescribeCursorOutcome describeCursor(const Model::DescribeCursorRequest &request)const; + void describeCursorAsync(const Model::DescribeCursorRequest& request, const DescribeCursorAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeCursorOutcomeCallable describeCursorCallable(const Model::DescribeCursorRequest& request) const; + DescribeCustomerFlowByLocationOutcome describeCustomerFlowByLocation(const Model::DescribeCustomerFlowByLocationRequest &request)const; + void describeCustomerFlowByLocationAsync(const Model::DescribeCustomerFlowByLocationRequest& request, const DescribeCustomerFlowByLocationAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeCustomerFlowByLocationOutcomeCallable describeCustomerFlowByLocationCallable(const Model::DescribeCustomerFlowByLocationRequest& request) const; + DescribeHeatMapOutcome describeHeatMap(const Model::DescribeHeatMapRequest &request)const; + void describeHeatMapAsync(const Model::DescribeHeatMapRequest& request, const DescribeHeatMapAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeHeatMapOutcomeCallable describeHeatMapCallable(const Model::DescribeHeatMapRequest& request) const; + DescribeImageUrlsOutcome describeImageUrls(const Model::DescribeImageUrlsRequest &request)const; + void describeImageUrlsAsync(const Model::DescribeImageUrlsRequest& request, const DescribeImageUrlsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeImageUrlsOutcomeCallable describeImageUrlsCallable(const Model::DescribeImageUrlsRequest& request) const; + DescribeOverviewDataOutcome describeOverviewData(const Model::DescribeOverviewDataRequest &request)const; + void describeOverviewDataAsync(const Model::DescribeOverviewDataRequest& request, const DescribeOverviewDataAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeOverviewDataOutcomeCallable describeOverviewDataCallable(const Model::DescribeOverviewDataRequest& request) const; + ImportSpecialPersonnelOutcome importSpecialPersonnel(const Model::ImportSpecialPersonnelRequest &request)const; + void importSpecialPersonnelAsync(const Model::ImportSpecialPersonnelRequest& request, const ImportSpecialPersonnelAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ImportSpecialPersonnelOutcomeCallable importSpecialPersonnelCallable(const Model::ImportSpecialPersonnelRequest& request) const; + ListActionDataOutcome listActionData(const Model::ListActionDataRequest &request)const; + void listActionDataAsync(const Model::ListActionDataRequest& request, const ListActionDataAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListActionDataOutcomeCallable listActionDataCallable(const Model::ListActionDataRequest& request) const; + ListEmapOutcome listEmap(const Model::ListEmapRequest &request)const; + void listEmapAsync(const Model::ListEmapRequest& request, const ListEmapAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListEmapOutcomeCallable listEmapCallable(const Model::ListEmapRequest& request) const; + ListLocationOutcome listLocation(const Model::ListLocationRequest &request)const; + void listLocationAsync(const Model::ListLocationRequest& request, const ListLocationAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListLocationOutcomeCallable listLocationCallable(const Model::ListLocationRequest& request) const; + ListPersonByImageOutcome listPersonByImage(const Model::ListPersonByImageRequest &request)const; + void listPersonByImageAsync(const Model::ListPersonByImageRequest& request, const ListPersonByImageAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListPersonByImageOutcomeCallable listPersonByImageCallable(const Model::ListPersonByImageRequest& request) const; + ListStoreOutcome listStore(const Model::ListStoreRequest &request)const; + void listStoreAsync(const Model::ListStoreRequest& request, const ListStoreAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListStoreOutcomeCallable listStoreCallable(const Model::ListStoreRequest& request) const; + PullActionDataOutcome pullActionData(const Model::PullActionDataRequest &request)const; + void pullActionDataAsync(const Model::PullActionDataRequest& request, const PullActionDataAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + PullActionDataOutcomeCallable pullActionDataCallable(const Model::PullActionDataRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_REID_REIDCLIENT_H_ diff --git a/reid/include/alibabacloud/reid/ReidExport.h b/reid/include/alibabacloud/reid/ReidExport.h new file mode 100644 index 000000000..03de9220c --- /dev/null +++ b/reid/include/alibabacloud/reid/ReidExport.h @@ -0,0 +1,32 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_REIDEXPORT_H_ +#define ALIBABACLOUD_REID_REIDEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_REID_LIBRARY) +# define ALIBABACLOUD_REID_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_REID_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_REID_EXPORT +#endif + +#endif // !ALIBABACLOUD_REID_REIDEXPORT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeBaseStatisticsRequest.h b/reid/include/alibabacloud/reid/model/DescribeBaseStatisticsRequest.h new file mode 100644 index 000000000..7fa507a96 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeBaseStatisticsRequest.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeBaseStatisticsRequest : public RpcServiceRequest + { + + public: + DescribeBaseStatisticsRequest(); + ~DescribeBaseStatisticsRequest(); + + std::string getDate()const; + void setDate(const std::string& date); + std::string getExtraStatisticTypes()const; + void setExtraStatisticTypes(const std::string& extraStatisticTypes); + long getStoreId()const; + void setStoreId(long storeId); + std::string getSummaryType()const; + void setSummaryType(const std::string& summaryType); + long getLocationId()const; + void setLocationId(long locationId); + + private: + std::string date_; + std::string extraStatisticTypes_; + long storeId_; + std::string summaryType_; + long locationId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeBaseStatisticsResult.h b/reid/include/alibabacloud/reid/model/DescribeBaseStatisticsResult.h new file mode 100644 index 000000000..c6598e347 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeBaseStatisticsResult.h @@ -0,0 +1,98 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSRESULT_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeBaseStatisticsResult : public ServiceResult + { + public: + struct BaseStatisticsItem + { + struct AgeItem + { + int count; + std::string name; + }; + struct StayDistributionItem + { + long startTs; + long endTs; + int count; + }; + struct AgeItem + { + int count; + std::string name; + }; + struct AgeItem + { + int count; + std::string name; + }; + std::vector ageItems; + std::vector stayDistributionItems; + int maleUvCount; + long stayPeriod; + int femaleUvCount; + long locationId; + int newCount; + int onlyBodyUvCount; + std::string time; + std::vector femaleAgeItems; + int oldCount; + std::string summaryType; + long storeId; + std::vector maleAgeItems; + int uvCount; + }; + + + DescribeBaseStatisticsResult(); + explicit DescribeBaseStatisticsResult(const std::string &payload); + ~DescribeBaseStatisticsResult(); + std::string getCursorTime()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + std::vector getBaseStatistics()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string cursorTime_; + std::string errorCode_; + std::string errorMessage_; + std::vector baseStatistics_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSRESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeCursorRequest.h b/reid/include/alibabacloud/reid/model/DescribeCursorRequest.h new file mode 100644 index 000000000..36566e748 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeCursorRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBECURSORREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBECURSORREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeCursorRequest : public RpcServiceRequest + { + + public: + DescribeCursorRequest(); + ~DescribeCursorRequest(); + + long getStoreId()const; + void setStoreId(long storeId); + std::string getTime()const; + void setTime(const std::string& time); + + private: + long storeId_; + std::string time_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBECURSORREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeCursorResult.h b/reid/include/alibabacloud/reid/model/DescribeCursorResult.h new file mode 100644 index 000000000..403614f91 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeCursorResult.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBECURSORRESULT_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBECURSORRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeCursorResult : public ServiceResult + { + public: + + + DescribeCursorResult(); + explicit DescribeCursorResult(const std::string &payload); + ~DescribeCursorResult(); + std::string getErrorCode()const; + std::string getErrorMessage()const; + std::string getCursor()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string errorCode_; + std::string errorMessage_; + std::string cursor_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBECURSORRESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationRequest.h b/reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationRequest.h new file mode 100644 index 000000000..478a512f6 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationRequest.h @@ -0,0 +1,69 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeCustomerFlowByLocationRequest : public RpcServiceRequest + { + + public: + DescribeCustomerFlowByLocationRequest(); + ~DescribeCustomerFlowByLocationRequest(); + + std::string getStartDate()const; + void setStartDate(const std::string& startDate); + long getStoreId()const; + void setStoreId(long storeId); + long getMinCount()const; + void setMinCount(long minCount); + long getParentAmount()const; + void setParentAmount(long parentAmount); + long getMaxCount()const; + void setMaxCount(long maxCount); + std::string getEndDate()const; + void setEndDate(const std::string& endDate); + long getLocationId()const; + void setLocationId(long locationId); + std::string getParentLocationIds()const; + void setParentLocationIds(const std::string& parentLocationIds); + + private: + std::string startDate_; + long storeId_; + long minCount_; + long parentAmount_; + long maxCount_; + std::string endDate_; + long locationId_; + std::string parentLocationIds_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationResult.h b/reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationResult.h new file mode 100644 index 000000000..68e5342bd --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationResult.h @@ -0,0 +1,78 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONRESULT_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeCustomerFlowByLocationResult : public ServiceResult + { + public: + struct CustomerFlowItem + { + long storeId; + float percent; + std::string parentLocationIds; + long locationId; + long count; + std::string locationName; + }; + + + DescribeCustomerFlowByLocationResult(); + explicit DescribeCustomerFlowByLocationResult(const std::string &payload); + ~DescribeCustomerFlowByLocationResult(); + std::vector getCustomerFlowItems()const; + long getStoreId()const; + float getPercent()const; + long getLocationId()const; + std::string getParentLocationIds()const; + std::string getErrorCode()const; + long getCount()const; + std::string getErrorMessage()const; + bool getSuccess()const; + std::string getLocationName()const; + + protected: + void parse(const std::string &payload); + private: + std::vector customerFlowItems_; + long storeId_; + float percent_; + long locationId_; + std::string parentLocationIds_; + std::string errorCode_; + long count_; + std::string errorMessage_; + bool success_; + std::string locationName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONRESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeHeatMapRequest.h b/reid/include/alibabacloud/reid/model/DescribeHeatMapRequest.h new file mode 100644 index 000000000..9c7a622e2 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeHeatMapRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeHeatMapRequest : public RpcServiceRequest + { + + public: + DescribeHeatMapRequest(); + ~DescribeHeatMapRequest(); + + std::string getDate()const; + void setDate(const std::string& date); + long getStoreId()const; + void setStoreId(long storeId); + long getEmapId()const; + void setEmapId(long emapId); + + private: + std::string date_; + long storeId_; + long emapId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeHeatMapResult.h b/reid/include/alibabacloud/reid/model/DescribeHeatMapResult.h new file mode 100644 index 000000000..6dce186ed --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeHeatMapResult.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPRESULT_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeHeatMapResult : public ServiceResult + { + public: + struct HeatMapPoint + { + float x; + float y; + int weight; + }; + + + DescribeHeatMapResult(); + explicit DescribeHeatMapResult(const std::string &payload); + ~DescribeHeatMapResult(); + std::string getErrorCode()const; + std::string getErrorMessage()const; + std::vector getHeatMapPoints()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string errorCode_; + std::string errorMessage_; + std::vector heatMapPoints_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPRESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeImageUrlsRequest.h b/reid/include/alibabacloud/reid/model/DescribeImageUrlsRequest.h new file mode 100644 index 000000000..4fa80ad27 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeImageUrlsRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeImageUrlsRequest : public RpcServiceRequest + { + + public: + DescribeImageUrlsRequest(); + ~DescribeImageUrlsRequest(); + + std::string getOriginUrls()const; + void setOriginUrls(const std::string& originUrls); + long getStoreId()const; + void setStoreId(long storeId); + std::string getObjectKeys()const; + void setObjectKeys(const std::string& objectKeys); + + private: + std::string originUrls_; + long storeId_; + std::string objectKeys_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeImageUrlsResult.h b/reid/include/alibabacloud/reid/model/DescribeImageUrlsResult.h new file mode 100644 index 000000000..10932ff5a --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeImageUrlsResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSRESULT_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeImageUrlsResult : public ServiceResult + { + public: + struct ImageUrl + { + std::string objectKey; + std::string url; + }; + + + DescribeImageUrlsResult(); + explicit DescribeImageUrlsResult(const std::string &payload); + ~DescribeImageUrlsResult(); + std::string getErrorCode()const; + std::vector getUrls()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string errorCode_; + std::vector urls_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSRESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeOverviewDataRequest.h b/reid/include/alibabacloud/reid/model/DescribeOverviewDataRequest.h new file mode 100644 index 000000000..8f8c0e313 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeOverviewDataRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATAREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATAREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeOverviewDataRequest : public RpcServiceRequest + { + + public: + DescribeOverviewDataRequest(); + ~DescribeOverviewDataRequest(); + + std::string getDate()const; + void setDate(const std::string& date); + std::string getStoreIds()const; + void setStoreIds(const std::string& storeIds); + + private: + std::string date_; + std::string storeIds_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATAREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/DescribeOverviewDataResult.h b/reid/include/alibabacloud/reid/model/DescribeOverviewDataResult.h new file mode 100644 index 000000000..c1f5a0e6e --- /dev/null +++ b/reid/include/alibabacloud/reid/model/DescribeOverviewDataResult.h @@ -0,0 +1,70 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATARESULT_H_ +#define ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATARESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT DescribeOverviewDataResult : public ServiceResult + { + public: + struct OverviewDetail + { + float stayDeepAvg; + long uv; + float uvEverySqm; + float uvEverySqmGrowthWOWPercent; + float uvAvg; + float uvWOWPercent; + float stayAvgPeriod; + float stayDeepAvgWOWPercent; + float stayAvgPeriodWOWPercent; + float uvAvgWOWPercent; + }; + + + DescribeOverviewDataResult(); + explicit DescribeOverviewDataResult(const std::string &payload); + ~DescribeOverviewDataResult(); + OverviewDetail getOverviewDetail()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + OverviewDetail overviewDetail_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATARESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ImportSpecialPersonnelRequest.h b/reid/include/alibabacloud/reid/model/ImportSpecialPersonnelRequest.h new file mode 100644 index 000000000..67050f73d --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ImportSpecialPersonnelRequest.h @@ -0,0 +1,69 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ImportSpecialPersonnelRequest : public RpcServiceRequest + { + + public: + ImportSpecialPersonnelRequest(); + ~ImportSpecialPersonnelRequest(); + + long getUkId()const; + void setUkId(long ukId); + std::string getDescription()const; + void setDescription(const std::string& description); + std::string getExternalId()const; + void setExternalId(const std::string& externalId); + std::string getPersonType()const; + void setPersonType(const std::string& personType); + std::string getUrls()const; + void setUrls(const std::string& urls); + std::string getPersonName()const; + void setPersonName(const std::string& personName); + std::string getStoreIds()const; + void setStoreIds(const std::string& storeIds); + std::string getStatus()const; + void setStatus(const std::string& status); + + private: + long ukId_; + std::string description_; + std::string externalId_; + std::string personType_; + std::string urls_; + std::string personName_; + std::string storeIds_; + std::string status_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ImportSpecialPersonnelResult.h b/reid/include/alibabacloud/reid/model/ImportSpecialPersonnelResult.h new file mode 100644 index 000000000..6f6923cb8 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ImportSpecialPersonnelResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELRESULT_H_ +#define ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ImportSpecialPersonnelResult : public ServiceResult + { + public: + struct SpecialPersonnelMap + { + long storeId; + long ukId; + }; + + + ImportSpecialPersonnelResult(); + explicit ImportSpecialPersonnelResult(const std::string &payload); + ~ImportSpecialPersonnelResult(); + std::string getErrorCode()const; + std::string getErrorMessage()const; + std::vector getSpecialPersonnelMaps()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string errorCode_; + std::string errorMessage_; + std::vector specialPersonnelMaps_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELRESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListActionDataRequest.h b/reid/include/alibabacloud/reid/model/ListActionDataRequest.h new file mode 100644 index 000000000..fb98e618f --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListActionDataRequest.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTACTIONDATAREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_LISTACTIONDATAREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListActionDataRequest : public RpcServiceRequest + { + + public: + ListActionDataRequest(); + ~ListActionDataRequest(); + + long getEndTime()const; + void setEndTime(long endTime); + long getStartTime()const; + void setStartTime(long startTime); + long getStoreId()const; + void setStoreId(long storeId); + int getPageNumber()const; + void setPageNumber(int pageNumber); + int getPageSize()const; + void setPageSize(int pageSize); + bool getFilterInvalidData()const; + void setFilterInvalidData(bool filterInvalidData); + + private: + long endTime_; + long startTime_; + long storeId_; + int pageNumber_; + int pageSize_; + bool filterInvalidData_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTACTIONDATAREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListActionDataResult.h b/reid/include/alibabacloud/reid/model/ListActionDataResult.h new file mode 100644 index 000000000..01f55a05e --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListActionDataResult.h @@ -0,0 +1,103 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTACTIONDATARESULT_H_ +#define ALIBABACLOUD_REID_MODEL_LISTACTIONDATARESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListActionDataResult : public ServiceResult + { + public: + struct Action + { + struct ObjectPositionInImage + { + float left; + float top; + float right; + float bottom; + }; + struct PointInMap + { + float x; + float y; + }; + int status; + int facePointNumber; + int stayPeriod; + long leaveTimestamp; + long gmtModified; + long locationId; + std::string imageUrl; + std::string gender; + ObjectPositionInImage objectPositionInImage; + std::string imageType; + long arriveTimestamp; + long gmtCreate; + float score; + long storeId; + PointInMap pointInMap; + std::string locationLayerType; + std::string imageObjectKey; + long ukId; + long inStay; + std::string specialType; + bool stayValid; + long id; + int age; + }; + + + ListActionDataResult(); + explicit ListActionDataResult(const std::string &payload); + ~ListActionDataResult(); + long getTotalCount()const; + int getPageSize()const; + std::vector getActions()const; + int getPageNumber()const; + long getCursorTime()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + long totalCount_; + int pageSize_; + std::vector actions_; + int pageNumber_; + long cursorTime_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTACTIONDATARESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListEmapRequest.h b/reid/include/alibabacloud/reid/model/ListEmapRequest.h new file mode 100644 index 000000000..64fa29c57 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListEmapRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTEMAPREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_LISTEMAPREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListEmapRequest : public RpcServiceRequest + { + + public: + ListEmapRequest(); + ~ListEmapRequest(); + + long getStoreId()const; + void setStoreId(long storeId); + + private: + long storeId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTEMAPREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListEmapResult.h b/reid/include/alibabacloud/reid/model/ListEmapResult.h new file mode 100644 index 000000000..3138b5ec3 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListEmapResult.h @@ -0,0 +1,64 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTEMAPRESULT_H_ +#define ALIBABACLOUD_REID_MODEL_LISTEMAPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListEmapResult : public ServiceResult + { + public: + struct OpenEmap + { + std::string emapUrl; + std::string locationId; + std::string emapId; + std::string name; + }; + + + ListEmapResult(); + explicit ListEmapResult(const std::string &payload); + ~ListEmapResult(); + std::vector getOpenEmaps()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::vector openEmaps_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTEMAPRESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListLocationRequest.h b/reid/include/alibabacloud/reid/model/ListLocationRequest.h new file mode 100644 index 000000000..5888fc27f --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListLocationRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTLOCATIONREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_LISTLOCATIONREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListLocationRequest : public RpcServiceRequest + { + + public: + ListLocationRequest(); + ~ListLocationRequest(); + + long getStoreId()const; + void setStoreId(long storeId); + + private: + long storeId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTLOCATIONREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListLocationResult.h b/reid/include/alibabacloud/reid/model/ListLocationResult.h new file mode 100644 index 000000000..e816a4197 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListLocationResult.h @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTLOCATIONRESULT_H_ +#define ALIBABACLOUD_REID_MODEL_LISTLOCATIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListLocationResult : public ServiceResult + { + public: + struct LocationInfoItem + { + struct RectRoi + { + struct Point + { + float x; + float y; + }; + std::vector points; + }; + int status; + long gmtCreate; + std::vector rectRois; + long storeId; + long parentLocationId; + std::string externalId; + std::string layerType; + long gmtModified; + long locationId; + std::string locationType; + std::string locationName; + }; + + + ListLocationResult(); + explicit ListLocationResult(const std::string &payload); + ~ListLocationResult(); + std::vector getLocationInfoItems()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::vector locationInfoItems_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTLOCATIONRESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListPersonByImageRequest.h b/reid/include/alibabacloud/reid/model/ListPersonByImageRequest.h new file mode 100644 index 000000000..a68614dc3 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListPersonByImageRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGEREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListPersonByImageRequest : public RpcServiceRequest + { + + public: + ListPersonByImageRequest(); + ~ListPersonByImageRequest(); + + long getStoreId()const; + void setStoreId(long storeId); + std::string getImageUrl()const; + void setImageUrl(const std::string& imageUrl); + + private: + long storeId_; + std::string imageUrl_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGEREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListPersonByImageResult.h b/reid/include/alibabacloud/reid/model/ListPersonByImageResult.h new file mode 100644 index 000000000..183c6df96 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListPersonByImageResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGERESULT_H_ +#define ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListPersonByImageResult : public ServiceResult + { + public: + struct PersonSearchResultItem + { + float score; + long ukId; + }; + + + ListPersonByImageResult(); + explicit ListPersonByImageResult(const std::string &payload); + ~ListPersonByImageResult(); + std::vector getPersonSearchResultItems()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::vector personSearchResultItems_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGERESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListStoreRequest.h b/reid/include/alibabacloud/reid/model/ListStoreRequest.h new file mode 100644 index 000000000..b77b45c1b --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListStoreRequest.h @@ -0,0 +1,45 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTSTOREREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_LISTSTOREREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListStoreRequest : public RpcServiceRequest + { + + public: + ListStoreRequest(); + ~ListStoreRequest(); + + + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTSTOREREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/ListStoreResult.h b/reid/include/alibabacloud/reid/model/ListStoreResult.h new file mode 100644 index 000000000..fdcf6d3c5 --- /dev/null +++ b/reid/include/alibabacloud/reid/model/ListStoreResult.h @@ -0,0 +1,70 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_LISTSTORERESULT_H_ +#define ALIBABACLOUD_REID_MODEL_LISTSTORERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT ListStoreResult : public ServiceResult + { + public: + struct OpenStore + { + int status; + std::string storeType; + long gmtCreate; + std::string openingStartTime; + long storeId; + std::string address; + long gmtModified; + std::string openingEndTime; + float sqm; + std::string name; + }; + + + ListStoreResult(); + explicit ListStoreResult(const std::string &payload); + ~ListStoreResult(); + std::vector getStores()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::vector stores_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_LISTSTORERESULT_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/PullActionDataRequest.h b/reid/include/alibabacloud/reid/model/PullActionDataRequest.h new file mode 100644 index 000000000..e8a8a815e --- /dev/null +++ b/reid/include/alibabacloud/reid/model/PullActionDataRequest.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_PULLACTIONDATAREQUEST_H_ +#define ALIBABACLOUD_REID_MODEL_PULLACTIONDATAREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT PullActionDataRequest : public RpcServiceRequest + { + + public: + PullActionDataRequest(); + ~PullActionDataRequest(); + + long getStoreId()const; + void setStoreId(long storeId); + long getEndMessageId()const; + void setEndMessageId(long endMessageId); + int getLimit()const; + void setLimit(int limit); + long getStartMessageId()const; + void setStartMessageId(long startMessageId); + + private: + long storeId_; + long endMessageId_; + int limit_; + long startMessageId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_PULLACTIONDATAREQUEST_H_ \ No newline at end of file diff --git a/reid/include/alibabacloud/reid/model/PullActionDataResult.h b/reid/include/alibabacloud/reid/model/PullActionDataResult.h new file mode 100644 index 000000000..51eff7a0e --- /dev/null +++ b/reid/include/alibabacloud/reid/model/PullActionDataResult.h @@ -0,0 +1,97 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_REID_MODEL_PULLACTIONDATARESULT_H_ +#define ALIBABACLOUD_REID_MODEL_PULLACTIONDATARESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Reid + { + namespace Model + { + class ALIBABACLOUD_REID_EXPORT PullActionDataResult : public ServiceResult + { + public: + struct Action + { + struct ObjectPositionInImage + { + float left; + float top; + float right; + float bottom; + }; + struct PointInMap + { + float x; + float y; + }; + int status; + int facePointNumber; + int stayPeriod; + long leaveTimestamp; + long gmtModified; + long locationId; + std::string imageUrl; + std::string gender; + ObjectPositionInImage objectPositionInImage; + std::string imageType; + long arriveTimestamp; + long gmtCreate; + float score; + long storeId; + PointInMap pointInMap; + std::string locationLayerType; + std::string imageObjectKey; + long ukId; + long inStay; + std::string specialType; + bool stayValid; + long id; + int age; + }; + + + PullActionDataResult(); + explicit PullActionDataResult(const std::string &payload); + ~PullActionDataResult(); + std::vector getActions()const; + long getNextMessageId()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::vector actions_; + long nextMessageId_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_REID_MODEL_PULLACTIONDATARESULT_H_ \ No newline at end of file diff --git a/reid/src/ReidClient.cc b/reid/src/ReidClient.cc new file mode 100644 index 000000000..f9c1d136b --- /dev/null +++ b/reid/src/ReidClient.cc @@ -0,0 +1,521 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud; +using namespace AlibabaCloud::Location; +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +namespace +{ + const std::string SERVICE_NAME = "reid"; +} + +ReidClient::ReidClient(const Credentials &credentials, const ClientConfiguration &configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) +{ + auto locationClient = std::make_shared(credentials, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "1.0.0"); +} + +ReidClient::ReidClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) +{ + auto locationClient = std::make_shared(credentialsProvider, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "1.0.0"); +} + +ReidClient::ReidClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) +{ + auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "1.0.0"); +} + +ReidClient::~ReidClient() +{} + +ReidClient::DescribeBaseStatisticsOutcome ReidClient::describeBaseStatistics(const DescribeBaseStatisticsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeBaseStatisticsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeBaseStatisticsOutcome(DescribeBaseStatisticsResult(outcome.result())); + else + return DescribeBaseStatisticsOutcome(outcome.error()); +} + +void ReidClient::describeBaseStatisticsAsync(const DescribeBaseStatisticsRequest& request, const DescribeBaseStatisticsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeBaseStatistics(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::DescribeBaseStatisticsOutcomeCallable ReidClient::describeBaseStatisticsCallable(const DescribeBaseStatisticsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeBaseStatistics(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::DescribeCursorOutcome ReidClient::describeCursor(const DescribeCursorRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeCursorOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeCursorOutcome(DescribeCursorResult(outcome.result())); + else + return DescribeCursorOutcome(outcome.error()); +} + +void ReidClient::describeCursorAsync(const DescribeCursorRequest& request, const DescribeCursorAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeCursor(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::DescribeCursorOutcomeCallable ReidClient::describeCursorCallable(const DescribeCursorRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeCursor(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::DescribeCustomerFlowByLocationOutcome ReidClient::describeCustomerFlowByLocation(const DescribeCustomerFlowByLocationRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeCustomerFlowByLocationOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeCustomerFlowByLocationOutcome(DescribeCustomerFlowByLocationResult(outcome.result())); + else + return DescribeCustomerFlowByLocationOutcome(outcome.error()); +} + +void ReidClient::describeCustomerFlowByLocationAsync(const DescribeCustomerFlowByLocationRequest& request, const DescribeCustomerFlowByLocationAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeCustomerFlowByLocation(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::DescribeCustomerFlowByLocationOutcomeCallable ReidClient::describeCustomerFlowByLocationCallable(const DescribeCustomerFlowByLocationRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeCustomerFlowByLocation(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::DescribeHeatMapOutcome ReidClient::describeHeatMap(const DescribeHeatMapRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeHeatMapOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeHeatMapOutcome(DescribeHeatMapResult(outcome.result())); + else + return DescribeHeatMapOutcome(outcome.error()); +} + +void ReidClient::describeHeatMapAsync(const DescribeHeatMapRequest& request, const DescribeHeatMapAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeHeatMap(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::DescribeHeatMapOutcomeCallable ReidClient::describeHeatMapCallable(const DescribeHeatMapRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeHeatMap(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::DescribeImageUrlsOutcome ReidClient::describeImageUrls(const DescribeImageUrlsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeImageUrlsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeImageUrlsOutcome(DescribeImageUrlsResult(outcome.result())); + else + return DescribeImageUrlsOutcome(outcome.error()); +} + +void ReidClient::describeImageUrlsAsync(const DescribeImageUrlsRequest& request, const DescribeImageUrlsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeImageUrls(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::DescribeImageUrlsOutcomeCallable ReidClient::describeImageUrlsCallable(const DescribeImageUrlsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeImageUrls(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::DescribeOverviewDataOutcome ReidClient::describeOverviewData(const DescribeOverviewDataRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeOverviewDataOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeOverviewDataOutcome(DescribeOverviewDataResult(outcome.result())); + else + return DescribeOverviewDataOutcome(outcome.error()); +} + +void ReidClient::describeOverviewDataAsync(const DescribeOverviewDataRequest& request, const DescribeOverviewDataAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeOverviewData(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::DescribeOverviewDataOutcomeCallable ReidClient::describeOverviewDataCallable(const DescribeOverviewDataRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeOverviewData(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::ImportSpecialPersonnelOutcome ReidClient::importSpecialPersonnel(const ImportSpecialPersonnelRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ImportSpecialPersonnelOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ImportSpecialPersonnelOutcome(ImportSpecialPersonnelResult(outcome.result())); + else + return ImportSpecialPersonnelOutcome(outcome.error()); +} + +void ReidClient::importSpecialPersonnelAsync(const ImportSpecialPersonnelRequest& request, const ImportSpecialPersonnelAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, importSpecialPersonnel(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::ImportSpecialPersonnelOutcomeCallable ReidClient::importSpecialPersonnelCallable(const ImportSpecialPersonnelRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->importSpecialPersonnel(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::ListActionDataOutcome ReidClient::listActionData(const ListActionDataRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListActionDataOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListActionDataOutcome(ListActionDataResult(outcome.result())); + else + return ListActionDataOutcome(outcome.error()); +} + +void ReidClient::listActionDataAsync(const ListActionDataRequest& request, const ListActionDataAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listActionData(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::ListActionDataOutcomeCallable ReidClient::listActionDataCallable(const ListActionDataRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listActionData(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::ListEmapOutcome ReidClient::listEmap(const ListEmapRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListEmapOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListEmapOutcome(ListEmapResult(outcome.result())); + else + return ListEmapOutcome(outcome.error()); +} + +void ReidClient::listEmapAsync(const ListEmapRequest& request, const ListEmapAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listEmap(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::ListEmapOutcomeCallable ReidClient::listEmapCallable(const ListEmapRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listEmap(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::ListLocationOutcome ReidClient::listLocation(const ListLocationRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListLocationOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListLocationOutcome(ListLocationResult(outcome.result())); + else + return ListLocationOutcome(outcome.error()); +} + +void ReidClient::listLocationAsync(const ListLocationRequest& request, const ListLocationAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listLocation(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::ListLocationOutcomeCallable ReidClient::listLocationCallable(const ListLocationRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listLocation(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::ListPersonByImageOutcome ReidClient::listPersonByImage(const ListPersonByImageRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListPersonByImageOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListPersonByImageOutcome(ListPersonByImageResult(outcome.result())); + else + return ListPersonByImageOutcome(outcome.error()); +} + +void ReidClient::listPersonByImageAsync(const ListPersonByImageRequest& request, const ListPersonByImageAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listPersonByImage(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::ListPersonByImageOutcomeCallable ReidClient::listPersonByImageCallable(const ListPersonByImageRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listPersonByImage(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::ListStoreOutcome ReidClient::listStore(const ListStoreRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListStoreOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListStoreOutcome(ListStoreResult(outcome.result())); + else + return ListStoreOutcome(outcome.error()); +} + +void ReidClient::listStoreAsync(const ListStoreRequest& request, const ListStoreAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listStore(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::ListStoreOutcomeCallable ReidClient::listStoreCallable(const ListStoreRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listStore(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ReidClient::PullActionDataOutcome ReidClient::pullActionData(const PullActionDataRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return PullActionDataOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return PullActionDataOutcome(PullActionDataResult(outcome.result())); + else + return PullActionDataOutcome(outcome.error()); +} + +void ReidClient::pullActionDataAsync(const PullActionDataRequest& request, const PullActionDataAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, pullActionData(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ReidClient::PullActionDataOutcomeCallable ReidClient::pullActionDataCallable(const PullActionDataRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->pullActionData(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/reid/src/model/DescribeBaseStatisticsRequest.cc b/reid/src/model/DescribeBaseStatisticsRequest.cc new file mode 100644 index 000000000..824f05f00 --- /dev/null +++ b/reid/src/model/DescribeBaseStatisticsRequest.cc @@ -0,0 +1,84 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::DescribeBaseStatisticsRequest; + +DescribeBaseStatisticsRequest::DescribeBaseStatisticsRequest() : + RpcServiceRequest("reid", "2019-09-28", "DescribeBaseStatistics") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeBaseStatisticsRequest::~DescribeBaseStatisticsRequest() +{} + +std::string DescribeBaseStatisticsRequest::getDate()const +{ + return date_; +} + +void DescribeBaseStatisticsRequest::setDate(const std::string& date) +{ + date_ = date; + setCoreParameter("Date", date); +} + +std::string DescribeBaseStatisticsRequest::getExtraStatisticTypes()const +{ + return extraStatisticTypes_; +} + +void DescribeBaseStatisticsRequest::setExtraStatisticTypes(const std::string& extraStatisticTypes) +{ + extraStatisticTypes_ = extraStatisticTypes; + setCoreParameter("ExtraStatisticTypes", extraStatisticTypes); +} + +long DescribeBaseStatisticsRequest::getStoreId()const +{ + return storeId_; +} + +void DescribeBaseStatisticsRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + +std::string DescribeBaseStatisticsRequest::getSummaryType()const +{ + return summaryType_; +} + +void DescribeBaseStatisticsRequest::setSummaryType(const std::string& summaryType) +{ + summaryType_ = summaryType; + setCoreParameter("SummaryType", summaryType); +} + +long DescribeBaseStatisticsRequest::getLocationId()const +{ + return locationId_; +} + +void DescribeBaseStatisticsRequest::setLocationId(long locationId) +{ + locationId_ = locationId; + setCoreParameter("LocationId", std::to_string(locationId)); +} + diff --git a/reid/src/model/DescribeBaseStatisticsResult.cc b/reid/src/model/DescribeBaseStatisticsResult.cc new file mode 100644 index 000000000..a0c61d78f --- /dev/null +++ b/reid/src/model/DescribeBaseStatisticsResult.cc @@ -0,0 +1,147 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +DescribeBaseStatisticsResult::DescribeBaseStatisticsResult() : + ServiceResult() +{} + +DescribeBaseStatisticsResult::DescribeBaseStatisticsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeBaseStatisticsResult::~DescribeBaseStatisticsResult() +{} + +void DescribeBaseStatisticsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allBaseStatisticsNode = value["BaseStatistics"]["BaseStatisticsItem"]; + for (auto valueBaseStatisticsBaseStatisticsItem : allBaseStatisticsNode) + { + BaseStatisticsItem baseStatisticsObject; + if(!valueBaseStatisticsBaseStatisticsItem["StoreId"].isNull()) + baseStatisticsObject.storeId = std::stol(valueBaseStatisticsBaseStatisticsItem["StoreId"].asString()); + if(!valueBaseStatisticsBaseStatisticsItem["FemaleUvCount"].isNull()) + baseStatisticsObject.femaleUvCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["FemaleUvCount"].asString()); + if(!valueBaseStatisticsBaseStatisticsItem["OldCount"].isNull()) + baseStatisticsObject.oldCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["OldCount"].asString()); + if(!valueBaseStatisticsBaseStatisticsItem["NewCount"].isNull()) + baseStatisticsObject.newCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["NewCount"].asString()); + if(!valueBaseStatisticsBaseStatisticsItem["SummaryType"].isNull()) + baseStatisticsObject.summaryType = valueBaseStatisticsBaseStatisticsItem["SummaryType"].asString(); + if(!valueBaseStatisticsBaseStatisticsItem["MaleUvCount"].isNull()) + baseStatisticsObject.maleUvCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["MaleUvCount"].asString()); + if(!valueBaseStatisticsBaseStatisticsItem["Time"].isNull()) + baseStatisticsObject.time = valueBaseStatisticsBaseStatisticsItem["Time"].asString(); + if(!valueBaseStatisticsBaseStatisticsItem["LocationId"].isNull()) + baseStatisticsObject.locationId = std::stol(valueBaseStatisticsBaseStatisticsItem["LocationId"].asString()); + if(!valueBaseStatisticsBaseStatisticsItem["StayPeriod"].isNull()) + baseStatisticsObject.stayPeriod = std::stol(valueBaseStatisticsBaseStatisticsItem["StayPeriod"].asString()); + if(!valueBaseStatisticsBaseStatisticsItem["UvCount"].isNull()) + baseStatisticsObject.uvCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["UvCount"].asString()); + if(!valueBaseStatisticsBaseStatisticsItem["OnlyBodyUvCount"].isNull()) + baseStatisticsObject.onlyBodyUvCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["OnlyBodyUvCount"].asString()); + auto allAgeItemsNode = allBaseStatisticsNode["AgeItems"]["AgeItem"]; + for (auto allBaseStatisticsNodeAgeItemsAgeItem : allAgeItemsNode) + { + BaseStatisticsItem::AgeItem ageItemsObject; + if(!allBaseStatisticsNodeAgeItemsAgeItem["Name"].isNull()) + ageItemsObject.name = allBaseStatisticsNodeAgeItemsAgeItem["Name"].asString(); + if(!allBaseStatisticsNodeAgeItemsAgeItem["Count"].isNull()) + ageItemsObject.count = std::stoi(allBaseStatisticsNodeAgeItemsAgeItem["Count"].asString()); + baseStatisticsObject.ageItems.push_back(ageItemsObject); + } + auto allStayDistributionItemsNode = allBaseStatisticsNode["StayDistributionItems"]["StayDistributionItem"]; + for (auto allBaseStatisticsNodeStayDistributionItemsStayDistributionItem : allStayDistributionItemsNode) + { + BaseStatisticsItem::StayDistributionItem stayDistributionItemsObject; + if(!allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["StartTs"].isNull()) + stayDistributionItemsObject.startTs = std::stol(allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["StartTs"].asString()); + if(!allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["EndTs"].isNull()) + stayDistributionItemsObject.endTs = std::stol(allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["EndTs"].asString()); + if(!allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["Count"].isNull()) + stayDistributionItemsObject.count = std::stoi(allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["Count"].asString()); + baseStatisticsObject.stayDistributionItems.push_back(stayDistributionItemsObject); + } + auto allMaleAgeItemsNode = allBaseStatisticsNode["MaleAgeItems"]["AgeItem"]; + for (auto allBaseStatisticsNodeMaleAgeItemsAgeItem : allMaleAgeItemsNode) + { + BaseStatisticsItem::AgeItem maleAgeItemsObject; + if(!allBaseStatisticsNodeMaleAgeItemsAgeItem["Name"].isNull()) + maleAgeItemsObject.name = allBaseStatisticsNodeMaleAgeItemsAgeItem["Name"].asString(); + if(!allBaseStatisticsNodeMaleAgeItemsAgeItem["Count"].isNull()) + maleAgeItemsObject.count = std::stoi(allBaseStatisticsNodeMaleAgeItemsAgeItem["Count"].asString()); + baseStatisticsObject.maleAgeItems.push_back(maleAgeItemsObject); + } + auto allFemaleAgeItemsNode = allBaseStatisticsNode["FemaleAgeItems"]["AgeItem"]; + for (auto allBaseStatisticsNodeFemaleAgeItemsAgeItem : allFemaleAgeItemsNode) + { + BaseStatisticsItem::AgeItem femaleAgeItemsObject; + if(!allBaseStatisticsNodeFemaleAgeItemsAgeItem["Name"].isNull()) + femaleAgeItemsObject.name = allBaseStatisticsNodeFemaleAgeItemsAgeItem["Name"].asString(); + if(!allBaseStatisticsNodeFemaleAgeItemsAgeItem["Count"].isNull()) + femaleAgeItemsObject.count = std::stoi(allBaseStatisticsNodeFemaleAgeItemsAgeItem["Count"].asString()); + baseStatisticsObject.femaleAgeItems.push_back(femaleAgeItemsObject); + } + baseStatistics_.push_back(baseStatisticsObject); + } + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["CursorTime"].isNull()) + cursorTime_ = value["CursorTime"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string DescribeBaseStatisticsResult::getCursorTime()const +{ + return cursorTime_; +} + +std::string DescribeBaseStatisticsResult::getErrorCode()const +{ + return errorCode_; +} + +std::string DescribeBaseStatisticsResult::getErrorMessage()const +{ + return errorMessage_; +} + +std::vector DescribeBaseStatisticsResult::getBaseStatistics()const +{ + return baseStatistics_; +} + +bool DescribeBaseStatisticsResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/DescribeCursorRequest.cc b/reid/src/model/DescribeCursorRequest.cc new file mode 100644 index 000000000..7ce4cfecc --- /dev/null +++ b/reid/src/model/DescribeCursorRequest.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::DescribeCursorRequest; + +DescribeCursorRequest::DescribeCursorRequest() : + RpcServiceRequest("reid", "2019-09-28", "DescribeCursor") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeCursorRequest::~DescribeCursorRequest() +{} + +long DescribeCursorRequest::getStoreId()const +{ + return storeId_; +} + +void DescribeCursorRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + +std::string DescribeCursorRequest::getTime()const +{ + return time_; +} + +void DescribeCursorRequest::setTime(const std::string& time) +{ + time_ = time; + setCoreParameter("Time", time); +} + diff --git a/reid/src/model/DescribeCursorResult.cc b/reid/src/model/DescribeCursorResult.cc new file mode 100644 index 000000000..5f0c0d4cc --- /dev/null +++ b/reid/src/model/DescribeCursorResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +DescribeCursorResult::DescribeCursorResult() : + ServiceResult() +{} + +DescribeCursorResult::DescribeCursorResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeCursorResult::~DescribeCursorResult() +{} + +void DescribeCursorResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Cursor"].isNull()) + cursor_ = value["Cursor"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string DescribeCursorResult::getErrorCode()const +{ + return errorCode_; +} + +std::string DescribeCursorResult::getErrorMessage()const +{ + return errorMessage_; +} + +std::string DescribeCursorResult::getCursor()const +{ + return cursor_; +} + +bool DescribeCursorResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/DescribeCustomerFlowByLocationRequest.cc b/reid/src/model/DescribeCustomerFlowByLocationRequest.cc new file mode 100644 index 000000000..835f1b940 --- /dev/null +++ b/reid/src/model/DescribeCustomerFlowByLocationRequest.cc @@ -0,0 +1,117 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::DescribeCustomerFlowByLocationRequest; + +DescribeCustomerFlowByLocationRequest::DescribeCustomerFlowByLocationRequest() : + RpcServiceRequest("reid", "2019-09-28", "DescribeCustomerFlowByLocation") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeCustomerFlowByLocationRequest::~DescribeCustomerFlowByLocationRequest() +{} + +std::string DescribeCustomerFlowByLocationRequest::getStartDate()const +{ + return startDate_; +} + +void DescribeCustomerFlowByLocationRequest::setStartDate(const std::string& startDate) +{ + startDate_ = startDate; + setCoreParameter("StartDate", startDate); +} + +long DescribeCustomerFlowByLocationRequest::getStoreId()const +{ + return storeId_; +} + +void DescribeCustomerFlowByLocationRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + +long DescribeCustomerFlowByLocationRequest::getMinCount()const +{ + return minCount_; +} + +void DescribeCustomerFlowByLocationRequest::setMinCount(long minCount) +{ + minCount_ = minCount; + setCoreParameter("MinCount", std::to_string(minCount)); +} + +long DescribeCustomerFlowByLocationRequest::getParentAmount()const +{ + return parentAmount_; +} + +void DescribeCustomerFlowByLocationRequest::setParentAmount(long parentAmount) +{ + parentAmount_ = parentAmount; + setCoreParameter("ParentAmount", std::to_string(parentAmount)); +} + +long DescribeCustomerFlowByLocationRequest::getMaxCount()const +{ + return maxCount_; +} + +void DescribeCustomerFlowByLocationRequest::setMaxCount(long maxCount) +{ + maxCount_ = maxCount; + setCoreParameter("MaxCount", std::to_string(maxCount)); +} + +std::string DescribeCustomerFlowByLocationRequest::getEndDate()const +{ + return endDate_; +} + +void DescribeCustomerFlowByLocationRequest::setEndDate(const std::string& endDate) +{ + endDate_ = endDate; + setCoreParameter("EndDate", endDate); +} + +long DescribeCustomerFlowByLocationRequest::getLocationId()const +{ + return locationId_; +} + +void DescribeCustomerFlowByLocationRequest::setLocationId(long locationId) +{ + locationId_ = locationId; + setCoreParameter("LocationId", std::to_string(locationId)); +} + +std::string DescribeCustomerFlowByLocationRequest::getParentLocationIds()const +{ + return parentLocationIds_; +} + +void DescribeCustomerFlowByLocationRequest::setParentLocationIds(const std::string& parentLocationIds) +{ + parentLocationIds_ = parentLocationIds; + setCoreParameter("ParentLocationIds", parentLocationIds); +} + diff --git a/reid/src/model/DescribeCustomerFlowByLocationResult.cc b/reid/src/model/DescribeCustomerFlowByLocationResult.cc new file mode 100644 index 000000000..ecece9157 --- /dev/null +++ b/reid/src/model/DescribeCustomerFlowByLocationResult.cc @@ -0,0 +1,130 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +DescribeCustomerFlowByLocationResult::DescribeCustomerFlowByLocationResult() : + ServiceResult() +{} + +DescribeCustomerFlowByLocationResult::DescribeCustomerFlowByLocationResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeCustomerFlowByLocationResult::~DescribeCustomerFlowByLocationResult() +{} + +void DescribeCustomerFlowByLocationResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allCustomerFlowItemsNode = value["CustomerFlowItems"]["CustomerFlowItem"]; + for (auto valueCustomerFlowItemsCustomerFlowItem : allCustomerFlowItemsNode) + { + CustomerFlowItem customerFlowItemsObject; + if(!valueCustomerFlowItemsCustomerFlowItem["Count"].isNull()) + customerFlowItemsObject.count = std::stol(valueCustomerFlowItemsCustomerFlowItem["Count"].asString()); + if(!valueCustomerFlowItemsCustomerFlowItem["StoreId"].isNull()) + customerFlowItemsObject.storeId = std::stol(valueCustomerFlowItemsCustomerFlowItem["StoreId"].asString()); + if(!valueCustomerFlowItemsCustomerFlowItem["Percent"].isNull()) + customerFlowItemsObject.percent = std::stof(valueCustomerFlowItemsCustomerFlowItem["Percent"].asString()); + if(!valueCustomerFlowItemsCustomerFlowItem["LocationName"].isNull()) + customerFlowItemsObject.locationName = valueCustomerFlowItemsCustomerFlowItem["LocationName"].asString(); + if(!valueCustomerFlowItemsCustomerFlowItem["ParentLocationIds"].isNull()) + customerFlowItemsObject.parentLocationIds = valueCustomerFlowItemsCustomerFlowItem["ParentLocationIds"].asString(); + if(!valueCustomerFlowItemsCustomerFlowItem["LocationId"].isNull()) + customerFlowItemsObject.locationId = std::stol(valueCustomerFlowItemsCustomerFlowItem["LocationId"].asString()); + customerFlowItems_.push_back(customerFlowItemsObject); + } + if(!value["LocationId"].isNull()) + locationId_ = std::stol(value["LocationId"].asString()); + if(!value["ParentLocationIds"].isNull()) + parentLocationIds_ = value["ParentLocationIds"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["LocationName"].isNull()) + locationName_ = value["LocationName"].asString(); + if(!value["Percent"].isNull()) + percent_ = std::stof(value["Percent"].asString()); + if(!value["StoreId"].isNull()) + storeId_ = std::stol(value["StoreId"].asString()); + if(!value["Count"].isNull()) + count_ = std::stol(value["Count"].asString()); + +} + +std::vector DescribeCustomerFlowByLocationResult::getCustomerFlowItems()const +{ + return customerFlowItems_; +} + +long DescribeCustomerFlowByLocationResult::getStoreId()const +{ + return storeId_; +} + +float DescribeCustomerFlowByLocationResult::getPercent()const +{ + return percent_; +} + +long DescribeCustomerFlowByLocationResult::getLocationId()const +{ + return locationId_; +} + +std::string DescribeCustomerFlowByLocationResult::getParentLocationIds()const +{ + return parentLocationIds_; +} + +std::string DescribeCustomerFlowByLocationResult::getErrorCode()const +{ + return errorCode_; +} + +long DescribeCustomerFlowByLocationResult::getCount()const +{ + return count_; +} + +std::string DescribeCustomerFlowByLocationResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool DescribeCustomerFlowByLocationResult::getSuccess()const +{ + return success_; +} + +std::string DescribeCustomerFlowByLocationResult::getLocationName()const +{ + return locationName_; +} + diff --git a/reid/src/model/DescribeHeatMapRequest.cc b/reid/src/model/DescribeHeatMapRequest.cc new file mode 100644 index 000000000..d91ec4aa1 --- /dev/null +++ b/reid/src/model/DescribeHeatMapRequest.cc @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::DescribeHeatMapRequest; + +DescribeHeatMapRequest::DescribeHeatMapRequest() : + RpcServiceRequest("reid", "2019-09-28", "DescribeHeatMap") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeHeatMapRequest::~DescribeHeatMapRequest() +{} + +std::string DescribeHeatMapRequest::getDate()const +{ + return date_; +} + +void DescribeHeatMapRequest::setDate(const std::string& date) +{ + date_ = date; + setCoreParameter("Date", date); +} + +long DescribeHeatMapRequest::getStoreId()const +{ + return storeId_; +} + +void DescribeHeatMapRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + +long DescribeHeatMapRequest::getEmapId()const +{ + return emapId_; +} + +void DescribeHeatMapRequest::setEmapId(long emapId) +{ + emapId_ = emapId; + setCoreParameter("EmapId", std::to_string(emapId)); +} + diff --git a/reid/src/model/DescribeHeatMapResult.cc b/reid/src/model/DescribeHeatMapResult.cc new file mode 100644 index 000000000..7eb701570 --- /dev/null +++ b/reid/src/model/DescribeHeatMapResult.cc @@ -0,0 +1,82 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +DescribeHeatMapResult::DescribeHeatMapResult() : + ServiceResult() +{} + +DescribeHeatMapResult::DescribeHeatMapResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeHeatMapResult::~DescribeHeatMapResult() +{} + +void DescribeHeatMapResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allHeatMapPointsNode = value["HeatMapPoints"]["HeatMapPoint"]; + for (auto valueHeatMapPointsHeatMapPoint : allHeatMapPointsNode) + { + HeatMapPoint heatMapPointsObject; + if(!valueHeatMapPointsHeatMapPoint["Y"].isNull()) + heatMapPointsObject.y = std::stof(valueHeatMapPointsHeatMapPoint["Y"].asString()); + if(!valueHeatMapPointsHeatMapPoint["Weight"].isNull()) + heatMapPointsObject.weight = std::stoi(valueHeatMapPointsHeatMapPoint["Weight"].asString()); + if(!valueHeatMapPointsHeatMapPoint["X"].isNull()) + heatMapPointsObject.x = std::stof(valueHeatMapPointsHeatMapPoint["X"].asString()); + heatMapPoints_.push_back(heatMapPointsObject); + } + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string DescribeHeatMapResult::getErrorCode()const +{ + return errorCode_; +} + +std::string DescribeHeatMapResult::getErrorMessage()const +{ + return errorMessage_; +} + +std::vector DescribeHeatMapResult::getHeatMapPoints()const +{ + return heatMapPoints_; +} + +bool DescribeHeatMapResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/DescribeImageUrlsRequest.cc b/reid/src/model/DescribeImageUrlsRequest.cc new file mode 100644 index 000000000..7f01c80ff --- /dev/null +++ b/reid/src/model/DescribeImageUrlsRequest.cc @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::DescribeImageUrlsRequest; + +DescribeImageUrlsRequest::DescribeImageUrlsRequest() : + RpcServiceRequest("reid", "2019-09-28", "DescribeImageUrls") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeImageUrlsRequest::~DescribeImageUrlsRequest() +{} + +std::string DescribeImageUrlsRequest::getOriginUrls()const +{ + return originUrls_; +} + +void DescribeImageUrlsRequest::setOriginUrls(const std::string& originUrls) +{ + originUrls_ = originUrls; + setCoreParameter("OriginUrls", originUrls); +} + +long DescribeImageUrlsRequest::getStoreId()const +{ + return storeId_; +} + +void DescribeImageUrlsRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + +std::string DescribeImageUrlsRequest::getObjectKeys()const +{ + return objectKeys_; +} + +void DescribeImageUrlsRequest::setObjectKeys(const std::string& objectKeys) +{ + objectKeys_ = objectKeys; + setCoreParameter("ObjectKeys", objectKeys); +} + diff --git a/reid/src/model/DescribeImageUrlsResult.cc b/reid/src/model/DescribeImageUrlsResult.cc new file mode 100644 index 000000000..1542735b0 --- /dev/null +++ b/reid/src/model/DescribeImageUrlsResult.cc @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +DescribeImageUrlsResult::DescribeImageUrlsResult() : + ServiceResult() +{} + +DescribeImageUrlsResult::DescribeImageUrlsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeImageUrlsResult::~DescribeImageUrlsResult() +{} + +void DescribeImageUrlsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allUrlsNode = value["Urls"]["ImageUrl"]; + for (auto valueUrlsImageUrl : allUrlsNode) + { + ImageUrl urlsObject; + if(!valueUrlsImageUrl["ObjectKey"].isNull()) + urlsObject.objectKey = valueUrlsImageUrl["ObjectKey"].asString(); + if(!valueUrlsImageUrl["Url"].isNull()) + urlsObject.url = valueUrlsImageUrl["Url"].asString(); + urls_.push_back(urlsObject); + } + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string DescribeImageUrlsResult::getErrorCode()const +{ + return errorCode_; +} + +std::vector DescribeImageUrlsResult::getUrls()const +{ + return urls_; +} + +std::string DescribeImageUrlsResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool DescribeImageUrlsResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/DescribeOverviewDataRequest.cc b/reid/src/model/DescribeOverviewDataRequest.cc new file mode 100644 index 000000000..81cb4ccb9 --- /dev/null +++ b/reid/src/model/DescribeOverviewDataRequest.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::DescribeOverviewDataRequest; + +DescribeOverviewDataRequest::DescribeOverviewDataRequest() : + RpcServiceRequest("reid", "2019-09-28", "DescribeOverviewData") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeOverviewDataRequest::~DescribeOverviewDataRequest() +{} + +std::string DescribeOverviewDataRequest::getDate()const +{ + return date_; +} + +void DescribeOverviewDataRequest::setDate(const std::string& date) +{ + date_ = date; + setCoreParameter("Date", date); +} + +std::string DescribeOverviewDataRequest::getStoreIds()const +{ + return storeIds_; +} + +void DescribeOverviewDataRequest::setStoreIds(const std::string& storeIds) +{ + storeIds_ = storeIds; + setCoreParameter("StoreIds", storeIds); +} + diff --git a/reid/src/model/DescribeOverviewDataResult.cc b/reid/src/model/DescribeOverviewDataResult.cc new file mode 100644 index 000000000..7d079cd9e --- /dev/null +++ b/reid/src/model/DescribeOverviewDataResult.cc @@ -0,0 +1,91 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +DescribeOverviewDataResult::DescribeOverviewDataResult() : + ServiceResult() +{} + +DescribeOverviewDataResult::DescribeOverviewDataResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeOverviewDataResult::~DescribeOverviewDataResult() +{} + +void DescribeOverviewDataResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto overviewDetailNode = value["OverviewDetail"]; + if(!overviewDetailNode["StayDeepAvgWOWPercent"].isNull()) + overviewDetail_.stayDeepAvgWOWPercent = std::stof(overviewDetailNode["StayDeepAvgWOWPercent"].asString()); + if(!overviewDetailNode["StayDeepAvg"].isNull()) + overviewDetail_.stayDeepAvg = std::stof(overviewDetailNode["StayDeepAvg"].asString()); + if(!overviewDetailNode["UvAvgWOWPercent"].isNull()) + overviewDetail_.uvAvgWOWPercent = std::stof(overviewDetailNode["UvAvgWOWPercent"].asString()); + if(!overviewDetailNode["StayAvgPeriodWOWPercent"].isNull()) + overviewDetail_.stayAvgPeriodWOWPercent = std::stof(overviewDetailNode["StayAvgPeriodWOWPercent"].asString()); + if(!overviewDetailNode["UvEverySqmGrowthWOWPercent"].isNull()) + overviewDetail_.uvEverySqmGrowthWOWPercent = std::stof(overviewDetailNode["UvEverySqmGrowthWOWPercent"].asString()); + if(!overviewDetailNode["UvWOWPercent"].isNull()) + overviewDetail_.uvWOWPercent = std::stof(overviewDetailNode["UvWOWPercent"].asString()); + if(!overviewDetailNode["Uv"].isNull()) + overviewDetail_.uv = std::stol(overviewDetailNode["Uv"].asString()); + if(!overviewDetailNode["UvEverySqm"].isNull()) + overviewDetail_.uvEverySqm = std::stof(overviewDetailNode["UvEverySqm"].asString()); + if(!overviewDetailNode["UvAvg"].isNull()) + overviewDetail_.uvAvg = std::stof(overviewDetailNode["UvAvg"].asString()); + if(!overviewDetailNode["StayAvgPeriod"].isNull()) + overviewDetail_.stayAvgPeriod = std::stof(overviewDetailNode["StayAvgPeriod"].asString()); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +DescribeOverviewDataResult::OverviewDetail DescribeOverviewDataResult::getOverviewDetail()const +{ + return overviewDetail_; +} + +std::string DescribeOverviewDataResult::getErrorCode()const +{ + return errorCode_; +} + +std::string DescribeOverviewDataResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool DescribeOverviewDataResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/ImportSpecialPersonnelRequest.cc b/reid/src/model/ImportSpecialPersonnelRequest.cc new file mode 100644 index 000000000..51036209e --- /dev/null +++ b/reid/src/model/ImportSpecialPersonnelRequest.cc @@ -0,0 +1,117 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::ImportSpecialPersonnelRequest; + +ImportSpecialPersonnelRequest::ImportSpecialPersonnelRequest() : + RpcServiceRequest("reid", "2019-09-28", "ImportSpecialPersonnel") +{ + setMethod(HttpRequest::Method::Post); +} + +ImportSpecialPersonnelRequest::~ImportSpecialPersonnelRequest() +{} + +long ImportSpecialPersonnelRequest::getUkId()const +{ + return ukId_; +} + +void ImportSpecialPersonnelRequest::setUkId(long ukId) +{ + ukId_ = ukId; + setCoreParameter("UkId", std::to_string(ukId)); +} + +std::string ImportSpecialPersonnelRequest::getDescription()const +{ + return description_; +} + +void ImportSpecialPersonnelRequest::setDescription(const std::string& description) +{ + description_ = description; + setCoreParameter("Description", description); +} + +std::string ImportSpecialPersonnelRequest::getExternalId()const +{ + return externalId_; +} + +void ImportSpecialPersonnelRequest::setExternalId(const std::string& externalId) +{ + externalId_ = externalId; + setCoreParameter("ExternalId", externalId); +} + +std::string ImportSpecialPersonnelRequest::getPersonType()const +{ + return personType_; +} + +void ImportSpecialPersonnelRequest::setPersonType(const std::string& personType) +{ + personType_ = personType; + setCoreParameter("PersonType", personType); +} + +std::string ImportSpecialPersonnelRequest::getUrls()const +{ + return urls_; +} + +void ImportSpecialPersonnelRequest::setUrls(const std::string& urls) +{ + urls_ = urls; + setCoreParameter("Urls", urls); +} + +std::string ImportSpecialPersonnelRequest::getPersonName()const +{ + return personName_; +} + +void ImportSpecialPersonnelRequest::setPersonName(const std::string& personName) +{ + personName_ = personName; + setCoreParameter("PersonName", personName); +} + +std::string ImportSpecialPersonnelRequest::getStoreIds()const +{ + return storeIds_; +} + +void ImportSpecialPersonnelRequest::setStoreIds(const std::string& storeIds) +{ + storeIds_ = storeIds; + setCoreParameter("StoreIds", storeIds); +} + +std::string ImportSpecialPersonnelRequest::getStatus()const +{ + return status_; +} + +void ImportSpecialPersonnelRequest::setStatus(const std::string& status) +{ + status_ = status; + setCoreParameter("Status", status); +} + diff --git a/reid/src/model/ImportSpecialPersonnelResult.cc b/reid/src/model/ImportSpecialPersonnelResult.cc new file mode 100644 index 000000000..4545fd824 --- /dev/null +++ b/reid/src/model/ImportSpecialPersonnelResult.cc @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +ImportSpecialPersonnelResult::ImportSpecialPersonnelResult() : + ServiceResult() +{} + +ImportSpecialPersonnelResult::ImportSpecialPersonnelResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ImportSpecialPersonnelResult::~ImportSpecialPersonnelResult() +{} + +void ImportSpecialPersonnelResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allSpecialPersonnelMapsNode = value["SpecialPersonnelMaps"]["SpecialPersonnelMap"]; + for (auto valueSpecialPersonnelMapsSpecialPersonnelMap : allSpecialPersonnelMapsNode) + { + SpecialPersonnelMap specialPersonnelMapsObject; + if(!valueSpecialPersonnelMapsSpecialPersonnelMap["UkId"].isNull()) + specialPersonnelMapsObject.ukId = std::stol(valueSpecialPersonnelMapsSpecialPersonnelMap["UkId"].asString()); + if(!valueSpecialPersonnelMapsSpecialPersonnelMap["StoreId"].isNull()) + specialPersonnelMapsObject.storeId = std::stol(valueSpecialPersonnelMapsSpecialPersonnelMap["StoreId"].asString()); + specialPersonnelMaps_.push_back(specialPersonnelMapsObject); + } + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string ImportSpecialPersonnelResult::getErrorCode()const +{ + return errorCode_; +} + +std::string ImportSpecialPersonnelResult::getErrorMessage()const +{ + return errorMessage_; +} + +std::vector ImportSpecialPersonnelResult::getSpecialPersonnelMaps()const +{ + return specialPersonnelMaps_; +} + +bool ImportSpecialPersonnelResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/ListActionDataRequest.cc b/reid/src/model/ListActionDataRequest.cc new file mode 100644 index 000000000..45ac7fe33 --- /dev/null +++ b/reid/src/model/ListActionDataRequest.cc @@ -0,0 +1,95 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::ListActionDataRequest; + +ListActionDataRequest::ListActionDataRequest() : + RpcServiceRequest("reid", "2019-09-28", "ListActionData") +{ + setMethod(HttpRequest::Method::Post); +} + +ListActionDataRequest::~ListActionDataRequest() +{} + +long ListActionDataRequest::getEndTime()const +{ + return endTime_; +} + +void ListActionDataRequest::setEndTime(long endTime) +{ + endTime_ = endTime; + setCoreParameter("EndTime", std::to_string(endTime)); +} + +long ListActionDataRequest::getStartTime()const +{ + return startTime_; +} + +void ListActionDataRequest::setStartTime(long startTime) +{ + startTime_ = startTime; + setCoreParameter("StartTime", std::to_string(startTime)); +} + +long ListActionDataRequest::getStoreId()const +{ + return storeId_; +} + +void ListActionDataRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + +int ListActionDataRequest::getPageNumber()const +{ + return pageNumber_; +} + +void ListActionDataRequest::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; + setCoreParameter("PageNumber", std::to_string(pageNumber)); +} + +int ListActionDataRequest::getPageSize()const +{ + return pageSize_; +} + +void ListActionDataRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setCoreParameter("PageSize", std::to_string(pageSize)); +} + +bool ListActionDataRequest::getFilterInvalidData()const +{ + return filterInvalidData_; +} + +void ListActionDataRequest::setFilterInvalidData(bool filterInvalidData) +{ + filterInvalidData_ = filterInvalidData; + setCoreParameter("FilterInvalidData", filterInvalidData ? "true" : "false"); +} + diff --git a/reid/src/model/ListActionDataResult.cc b/reid/src/model/ListActionDataResult.cc new file mode 100644 index 000000000..1a3dc8e70 --- /dev/null +++ b/reid/src/model/ListActionDataResult.cc @@ -0,0 +1,160 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +ListActionDataResult::ListActionDataResult() : + ServiceResult() +{} + +ListActionDataResult::ListActionDataResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListActionDataResult::~ListActionDataResult() +{} + +void ListActionDataResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allActionsNode = value["Actions"]["Action"]; + for (auto valueActionsAction : allActionsNode) + { + Action actionsObject; + if(!valueActionsAction["StoreId"].isNull()) + actionsObject.storeId = std::stol(valueActionsAction["StoreId"].asString()); + if(!valueActionsAction["GmtCreate"].isNull()) + actionsObject.gmtCreate = std::stol(valueActionsAction["GmtCreate"].asString()); + if(!valueActionsAction["LeaveTimestamp"].isNull()) + actionsObject.leaveTimestamp = std::stol(valueActionsAction["LeaveTimestamp"].asString()); + if(!valueActionsAction["LocationLayerType"].isNull()) + actionsObject.locationLayerType = valueActionsAction["LocationLayerType"].asString(); + if(!valueActionsAction["StayValid"].isNull()) + actionsObject.stayValid = valueActionsAction["StayValid"].asString() == "true"; + if(!valueActionsAction["Gender"].isNull()) + actionsObject.gender = valueActionsAction["Gender"].asString(); + if(!valueActionsAction["UkId"].isNull()) + actionsObject.ukId = std::stol(valueActionsAction["UkId"].asString()); + if(!valueActionsAction["ArriveTimestamp"].isNull()) + actionsObject.arriveTimestamp = std::stol(valueActionsAction["ArriveTimestamp"].asString()); + if(!valueActionsAction["GmtModified"].isNull()) + actionsObject.gmtModified = std::stol(valueActionsAction["GmtModified"].asString()); + if(!valueActionsAction["ImageType"].isNull()) + actionsObject.imageType = valueActionsAction["ImageType"].asString(); + if(!valueActionsAction["InStay"].isNull()) + actionsObject.inStay = std::stol(valueActionsAction["InStay"].asString()); + if(!valueActionsAction["Status"].isNull()) + actionsObject.status = std::stoi(valueActionsAction["Status"].asString()); + if(!valueActionsAction["Age"].isNull()) + actionsObject.age = std::stoi(valueActionsAction["Age"].asString()); + if(!valueActionsAction["Id"].isNull()) + actionsObject.id = std::stol(valueActionsAction["Id"].asString()); + if(!valueActionsAction["ImageUrl"].isNull()) + actionsObject.imageUrl = valueActionsAction["ImageUrl"].asString(); + if(!valueActionsAction["LocationId"].isNull()) + actionsObject.locationId = std::stol(valueActionsAction["LocationId"].asString()); + if(!valueActionsAction["StayPeriod"].isNull()) + actionsObject.stayPeriod = std::stoi(valueActionsAction["StayPeriod"].asString()); + if(!valueActionsAction["Score"].isNull()) + actionsObject.score = std::stof(valueActionsAction["Score"].asString()); + if(!valueActionsAction["SpecialType"].isNull()) + actionsObject.specialType = valueActionsAction["SpecialType"].asString(); + if(!valueActionsAction["ImageObjectKey"].isNull()) + actionsObject.imageObjectKey = valueActionsAction["ImageObjectKey"].asString(); + if(!valueActionsAction["FacePointNumber"].isNull()) + actionsObject.facePointNumber = std::stoi(valueActionsAction["FacePointNumber"].asString()); + auto objectPositionInImageNode = value["ObjectPositionInImage"]; + if(!objectPositionInImageNode["Bottom"].isNull()) + actionsObject.objectPositionInImage.bottom = std::stof(objectPositionInImageNode["Bottom"].asString()); + if(!objectPositionInImageNode["Left"].isNull()) + actionsObject.objectPositionInImage.left = std::stof(objectPositionInImageNode["Left"].asString()); + if(!objectPositionInImageNode["Top"].isNull()) + actionsObject.objectPositionInImage.top = std::stof(objectPositionInImageNode["Top"].asString()); + if(!objectPositionInImageNode["Right"].isNull()) + actionsObject.objectPositionInImage.right = std::stof(objectPositionInImageNode["Right"].asString()); + auto pointInMapNode = value["PointInMap"]; + if(!pointInMapNode["X"].isNull()) + actionsObject.pointInMap.x = std::stof(pointInMapNode["X"].asString()); + if(!pointInMapNode["Y"].isNull()) + actionsObject.pointInMap.y = std::stof(pointInMapNode["Y"].asString()); + actions_.push_back(actionsObject); + } + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["CursorTime"].isNull()) + cursorTime_ = std::stol(value["CursorTime"].asString()); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stol(value["TotalCount"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + +} + +long ListActionDataResult::getTotalCount()const +{ + return totalCount_; +} + +int ListActionDataResult::getPageSize()const +{ + return pageSize_; +} + +std::vector ListActionDataResult::getActions()const +{ + return actions_; +} + +int ListActionDataResult::getPageNumber()const +{ + return pageNumber_; +} + +long ListActionDataResult::getCursorTime()const +{ + return cursorTime_; +} + +std::string ListActionDataResult::getErrorCode()const +{ + return errorCode_; +} + +std::string ListActionDataResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool ListActionDataResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/ListEmapRequest.cc b/reid/src/model/ListEmapRequest.cc new file mode 100644 index 000000000..4edae4fbc --- /dev/null +++ b/reid/src/model/ListEmapRequest.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::ListEmapRequest; + +ListEmapRequest::ListEmapRequest() : + RpcServiceRequest("reid", "2019-09-28", "ListEmap") +{ + setMethod(HttpRequest::Method::Post); +} + +ListEmapRequest::~ListEmapRequest() +{} + +long ListEmapRequest::getStoreId()const +{ + return storeId_; +} + +void ListEmapRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + diff --git a/reid/src/model/ListEmapResult.cc b/reid/src/model/ListEmapResult.cc new file mode 100644 index 000000000..ef31418c3 --- /dev/null +++ b/reid/src/model/ListEmapResult.cc @@ -0,0 +1,84 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +ListEmapResult::ListEmapResult() : + ServiceResult() +{} + +ListEmapResult::ListEmapResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListEmapResult::~ListEmapResult() +{} + +void ListEmapResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allOpenEmapsNode = value["OpenEmaps"]["OpenEmap"]; + for (auto valueOpenEmapsOpenEmap : allOpenEmapsNode) + { + OpenEmap openEmapsObject; + if(!valueOpenEmapsOpenEmap["LocationId"].isNull()) + openEmapsObject.locationId = valueOpenEmapsOpenEmap["LocationId"].asString(); + if(!valueOpenEmapsOpenEmap["EmapId"].isNull()) + openEmapsObject.emapId = valueOpenEmapsOpenEmap["EmapId"].asString(); + if(!valueOpenEmapsOpenEmap["Name"].isNull()) + openEmapsObject.name = valueOpenEmapsOpenEmap["Name"].asString(); + if(!valueOpenEmapsOpenEmap["EmapUrl"].isNull()) + openEmapsObject.emapUrl = valueOpenEmapsOpenEmap["EmapUrl"].asString(); + openEmaps_.push_back(openEmapsObject); + } + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::vector ListEmapResult::getOpenEmaps()const +{ + return openEmaps_; +} + +std::string ListEmapResult::getErrorCode()const +{ + return errorCode_; +} + +std::string ListEmapResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool ListEmapResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/ListLocationRequest.cc b/reid/src/model/ListLocationRequest.cc new file mode 100644 index 000000000..329717983 --- /dev/null +++ b/reid/src/model/ListLocationRequest.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::ListLocationRequest; + +ListLocationRequest::ListLocationRequest() : + RpcServiceRequest("reid", "2019-09-28", "ListLocation") +{ + setMethod(HttpRequest::Method::Post); +} + +ListLocationRequest::~ListLocationRequest() +{} + +long ListLocationRequest::getStoreId()const +{ + return storeId_; +} + +void ListLocationRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + diff --git a/reid/src/model/ListLocationResult.cc b/reid/src/model/ListLocationResult.cc new file mode 100644 index 000000000..788c4b54f --- /dev/null +++ b/reid/src/model/ListLocationResult.cc @@ -0,0 +1,112 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +ListLocationResult::ListLocationResult() : + ServiceResult() +{} + +ListLocationResult::ListLocationResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListLocationResult::~ListLocationResult() +{} + +void ListLocationResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allLocationInfoItemsNode = value["LocationInfoItems"]["LocationInfoItem"]; + for (auto valueLocationInfoItemsLocationInfoItem : allLocationInfoItemsNode) + { + LocationInfoItem locationInfoItemsObject; + if(!valueLocationInfoItemsLocationInfoItem["ExternalId"].isNull()) + locationInfoItemsObject.externalId = valueLocationInfoItemsLocationInfoItem["ExternalId"].asString(); + if(!valueLocationInfoItemsLocationInfoItem["LocationType"].isNull()) + locationInfoItemsObject.locationType = valueLocationInfoItemsLocationInfoItem["LocationType"].asString(); + if(!valueLocationInfoItemsLocationInfoItem["Status"].isNull()) + locationInfoItemsObject.status = std::stoi(valueLocationInfoItemsLocationInfoItem["Status"].asString()); + if(!valueLocationInfoItemsLocationInfoItem["StoreId"].isNull()) + locationInfoItemsObject.storeId = std::stol(valueLocationInfoItemsLocationInfoItem["StoreId"].asString()); + if(!valueLocationInfoItemsLocationInfoItem["GmtCreate"].isNull()) + locationInfoItemsObject.gmtCreate = std::stol(valueLocationInfoItemsLocationInfoItem["GmtCreate"].asString()); + if(!valueLocationInfoItemsLocationInfoItem["ParentLocationId"].isNull()) + locationInfoItemsObject.parentLocationId = std::stol(valueLocationInfoItemsLocationInfoItem["ParentLocationId"].asString()); + if(!valueLocationInfoItemsLocationInfoItem["GmtModified"].isNull()) + locationInfoItemsObject.gmtModified = std::stol(valueLocationInfoItemsLocationInfoItem["GmtModified"].asString()); + if(!valueLocationInfoItemsLocationInfoItem["LocationName"].isNull()) + locationInfoItemsObject.locationName = valueLocationInfoItemsLocationInfoItem["LocationName"].asString(); + if(!valueLocationInfoItemsLocationInfoItem["LayerType"].isNull()) + locationInfoItemsObject.layerType = valueLocationInfoItemsLocationInfoItem["LayerType"].asString(); + if(!valueLocationInfoItemsLocationInfoItem["LocationId"].isNull()) + locationInfoItemsObject.locationId = std::stol(valueLocationInfoItemsLocationInfoItem["LocationId"].asString()); + auto allRectRoisNode = allLocationInfoItemsNode["RectRois"]["RectRoi"]; + for (auto allLocationInfoItemsNodeRectRoisRectRoi : allRectRoisNode) + { + LocationInfoItem::RectRoi rectRoisObject; + auto allPointsNode = allRectRoisNode["Points"]["Point"]; + for (auto allRectRoisNodePointsPoint : allPointsNode) + { + LocationInfoItem::RectRoi::Point pointsObject; + if(!allRectRoisNodePointsPoint["X"].isNull()) + pointsObject.x = std::stof(allRectRoisNodePointsPoint["X"].asString()); + if(!allRectRoisNodePointsPoint["Y"].isNull()) + pointsObject.y = std::stof(allRectRoisNodePointsPoint["Y"].asString()); + rectRoisObject.points.push_back(pointsObject); + } + locationInfoItemsObject.rectRois.push_back(rectRoisObject); + } + locationInfoItems_.push_back(locationInfoItemsObject); + } + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::vector ListLocationResult::getLocationInfoItems()const +{ + return locationInfoItems_; +} + +std::string ListLocationResult::getErrorCode()const +{ + return errorCode_; +} + +std::string ListLocationResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool ListLocationResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/ListPersonByImageRequest.cc b/reid/src/model/ListPersonByImageRequest.cc new file mode 100644 index 000000000..a163c70a6 --- /dev/null +++ b/reid/src/model/ListPersonByImageRequest.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::ListPersonByImageRequest; + +ListPersonByImageRequest::ListPersonByImageRequest() : + RpcServiceRequest("reid", "2019-09-28", "ListPersonByImage") +{ + setMethod(HttpRequest::Method::Post); +} + +ListPersonByImageRequest::~ListPersonByImageRequest() +{} + +long ListPersonByImageRequest::getStoreId()const +{ + return storeId_; +} + +void ListPersonByImageRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + +std::string ListPersonByImageRequest::getImageUrl()const +{ + return imageUrl_; +} + +void ListPersonByImageRequest::setImageUrl(const std::string& imageUrl) +{ + imageUrl_ = imageUrl; + setCoreParameter("ImageUrl", imageUrl); +} + diff --git a/reid/src/model/ListPersonByImageResult.cc b/reid/src/model/ListPersonByImageResult.cc new file mode 100644 index 000000000..3b2997aeb --- /dev/null +++ b/reid/src/model/ListPersonByImageResult.cc @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +ListPersonByImageResult::ListPersonByImageResult() : + ServiceResult() +{} + +ListPersonByImageResult::ListPersonByImageResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListPersonByImageResult::~ListPersonByImageResult() +{} + +void ListPersonByImageResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allPersonSearchResultItemsNode = value["PersonSearchResultItems"]["PersonSearchResultItem"]; + for (auto valuePersonSearchResultItemsPersonSearchResultItem : allPersonSearchResultItemsNode) + { + PersonSearchResultItem personSearchResultItemsObject; + if(!valuePersonSearchResultItemsPersonSearchResultItem["UkId"].isNull()) + personSearchResultItemsObject.ukId = std::stol(valuePersonSearchResultItemsPersonSearchResultItem["UkId"].asString()); + if(!valuePersonSearchResultItemsPersonSearchResultItem["Score"].isNull()) + personSearchResultItemsObject.score = std::stof(valuePersonSearchResultItemsPersonSearchResultItem["Score"].asString()); + personSearchResultItems_.push_back(personSearchResultItemsObject); + } + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::vector ListPersonByImageResult::getPersonSearchResultItems()const +{ + return personSearchResultItems_; +} + +std::string ListPersonByImageResult::getErrorCode()const +{ + return errorCode_; +} + +std::string ListPersonByImageResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool ListPersonByImageResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/ListStoreRequest.cc b/reid/src/model/ListStoreRequest.cc new file mode 100644 index 000000000..5f900679e --- /dev/null +++ b/reid/src/model/ListStoreRequest.cc @@ -0,0 +1,29 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::ListStoreRequest; + +ListStoreRequest::ListStoreRequest() : + RpcServiceRequest("reid", "2019-09-28", "ListStore") +{ + setMethod(HttpRequest::Method::Post); +} + +ListStoreRequest::~ListStoreRequest() +{} + diff --git a/reid/src/model/ListStoreResult.cc b/reid/src/model/ListStoreResult.cc new file mode 100644 index 000000000..c8a976dfb --- /dev/null +++ b/reid/src/model/ListStoreResult.cc @@ -0,0 +1,96 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +ListStoreResult::ListStoreResult() : + ServiceResult() +{} + +ListStoreResult::ListStoreResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListStoreResult::~ListStoreResult() +{} + +void ListStoreResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allStoresNode = value["Stores"]["OpenStore"]; + for (auto valueStoresOpenStore : allStoresNode) + { + OpenStore storesObject; + if(!valueStoresOpenStore["StoreId"].isNull()) + storesObject.storeId = std::stol(valueStoresOpenStore["StoreId"].asString()); + if(!valueStoresOpenStore["GmtCreate"].isNull()) + storesObject.gmtCreate = std::stol(valueStoresOpenStore["GmtCreate"].asString()); + if(!valueStoresOpenStore["Sqm"].isNull()) + storesObject.sqm = std::stof(valueStoresOpenStore["Sqm"].asString()); + if(!valueStoresOpenStore["Status"].isNull()) + storesObject.status = std::stoi(valueStoresOpenStore["Status"].asString()); + if(!valueStoresOpenStore["Name"].isNull()) + storesObject.name = valueStoresOpenStore["Name"].asString(); + if(!valueStoresOpenStore["OpeningEndTime"].isNull()) + storesObject.openingEndTime = valueStoresOpenStore["OpeningEndTime"].asString(); + if(!valueStoresOpenStore["OpeningStartTime"].isNull()) + storesObject.openingStartTime = valueStoresOpenStore["OpeningStartTime"].asString(); + if(!valueStoresOpenStore["StoreType"].isNull()) + storesObject.storeType = valueStoresOpenStore["StoreType"].asString(); + if(!valueStoresOpenStore["GmtModified"].isNull()) + storesObject.gmtModified = std::stol(valueStoresOpenStore["GmtModified"].asString()); + if(!valueStoresOpenStore["Address"].isNull()) + storesObject.address = valueStoresOpenStore["Address"].asString(); + stores_.push_back(storesObject); + } + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::vector ListStoreResult::getStores()const +{ + return stores_; +} + +std::string ListStoreResult::getErrorCode()const +{ + return errorCode_; +} + +std::string ListStoreResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool ListStoreResult::getSuccess()const +{ + return success_; +} + diff --git a/reid/src/model/PullActionDataRequest.cc b/reid/src/model/PullActionDataRequest.cc new file mode 100644 index 000000000..84aabc5eb --- /dev/null +++ b/reid/src/model/PullActionDataRequest.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Reid::Model::PullActionDataRequest; + +PullActionDataRequest::PullActionDataRequest() : + RpcServiceRequest("reid", "2019-09-28", "PullActionData") +{ + setMethod(HttpRequest::Method::Post); +} + +PullActionDataRequest::~PullActionDataRequest() +{} + +long PullActionDataRequest::getStoreId()const +{ + return storeId_; +} + +void PullActionDataRequest::setStoreId(long storeId) +{ + storeId_ = storeId; + setCoreParameter("StoreId", std::to_string(storeId)); +} + +long PullActionDataRequest::getEndMessageId()const +{ + return endMessageId_; +} + +void PullActionDataRequest::setEndMessageId(long endMessageId) +{ + endMessageId_ = endMessageId; + setCoreParameter("EndMessageId", std::to_string(endMessageId)); +} + +int PullActionDataRequest::getLimit()const +{ + return limit_; +} + +void PullActionDataRequest::setLimit(int limit) +{ + limit_ = limit; + setCoreParameter("Limit", std::to_string(limit)); +} + +long PullActionDataRequest::getStartMessageId()const +{ + return startMessageId_; +} + +void PullActionDataRequest::setStartMessageId(long startMessageId) +{ + startMessageId_ = startMessageId; + setCoreParameter("StartMessageId", std::to_string(startMessageId)); +} + diff --git a/reid/src/model/PullActionDataResult.cc b/reid/src/model/PullActionDataResult.cc new file mode 100644 index 000000000..b11831463 --- /dev/null +++ b/reid/src/model/PullActionDataResult.cc @@ -0,0 +1,139 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Reid; +using namespace AlibabaCloud::Reid::Model; + +PullActionDataResult::PullActionDataResult() : + ServiceResult() +{} + +PullActionDataResult::PullActionDataResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +PullActionDataResult::~PullActionDataResult() +{} + +void PullActionDataResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allActionsNode = value["Actions"]["Action"]; + for (auto valueActionsAction : allActionsNode) + { + Action actionsObject; + if(!valueActionsAction["StoreId"].isNull()) + actionsObject.storeId = std::stol(valueActionsAction["StoreId"].asString()); + if(!valueActionsAction["GmtCreate"].isNull()) + actionsObject.gmtCreate = std::stol(valueActionsAction["GmtCreate"].asString()); + if(!valueActionsAction["LeaveTimestamp"].isNull()) + actionsObject.leaveTimestamp = std::stol(valueActionsAction["LeaveTimestamp"].asString()); + if(!valueActionsAction["LocationLayerType"].isNull()) + actionsObject.locationLayerType = valueActionsAction["LocationLayerType"].asString(); + if(!valueActionsAction["StayValid"].isNull()) + actionsObject.stayValid = valueActionsAction["StayValid"].asString() == "true"; + if(!valueActionsAction["Gender"].isNull()) + actionsObject.gender = valueActionsAction["Gender"].asString(); + if(!valueActionsAction["UkId"].isNull()) + actionsObject.ukId = std::stol(valueActionsAction["UkId"].asString()); + if(!valueActionsAction["ArriveTimestamp"].isNull()) + actionsObject.arriveTimestamp = std::stol(valueActionsAction["ArriveTimestamp"].asString()); + if(!valueActionsAction["GmtModified"].isNull()) + actionsObject.gmtModified = std::stol(valueActionsAction["GmtModified"].asString()); + if(!valueActionsAction["ImageType"].isNull()) + actionsObject.imageType = valueActionsAction["ImageType"].asString(); + if(!valueActionsAction["InStay"].isNull()) + actionsObject.inStay = std::stol(valueActionsAction["InStay"].asString()); + if(!valueActionsAction["Status"].isNull()) + actionsObject.status = std::stoi(valueActionsAction["Status"].asString()); + if(!valueActionsAction["Age"].isNull()) + actionsObject.age = std::stoi(valueActionsAction["Age"].asString()); + if(!valueActionsAction["Id"].isNull()) + actionsObject.id = std::stol(valueActionsAction["Id"].asString()); + if(!valueActionsAction["ImageUrl"].isNull()) + actionsObject.imageUrl = valueActionsAction["ImageUrl"].asString(); + if(!valueActionsAction["LocationId"].isNull()) + actionsObject.locationId = std::stol(valueActionsAction["LocationId"].asString()); + if(!valueActionsAction["StayPeriod"].isNull()) + actionsObject.stayPeriod = std::stoi(valueActionsAction["StayPeriod"].asString()); + if(!valueActionsAction["Score"].isNull()) + actionsObject.score = std::stof(valueActionsAction["Score"].asString()); + if(!valueActionsAction["SpecialType"].isNull()) + actionsObject.specialType = valueActionsAction["SpecialType"].asString(); + if(!valueActionsAction["ImageObjectKey"].isNull()) + actionsObject.imageObjectKey = valueActionsAction["ImageObjectKey"].asString(); + if(!valueActionsAction["FacePointNumber"].isNull()) + actionsObject.facePointNumber = std::stoi(valueActionsAction["FacePointNumber"].asString()); + auto objectPositionInImageNode = value["ObjectPositionInImage"]; + if(!objectPositionInImageNode["Bottom"].isNull()) + actionsObject.objectPositionInImage.bottom = std::stof(objectPositionInImageNode["Bottom"].asString()); + if(!objectPositionInImageNode["Left"].isNull()) + actionsObject.objectPositionInImage.left = std::stof(objectPositionInImageNode["Left"].asString()); + if(!objectPositionInImageNode["Top"].isNull()) + actionsObject.objectPositionInImage.top = std::stof(objectPositionInImageNode["Top"].asString()); + if(!objectPositionInImageNode["Right"].isNull()) + actionsObject.objectPositionInImage.right = std::stof(objectPositionInImageNode["Right"].asString()); + auto pointInMapNode = value["PointInMap"]; + if(!pointInMapNode["X"].isNull()) + actionsObject.pointInMap.x = std::stof(pointInMapNode["X"].asString()); + if(!pointInMapNode["Y"].isNull()) + actionsObject.pointInMap.y = std::stof(pointInMapNode["Y"].asString()); + actions_.push_back(actionsObject); + } + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["NextMessageId"].isNull()) + nextMessageId_ = std::stol(value["NextMessageId"].asString()); + +} + +std::vector PullActionDataResult::getActions()const +{ + return actions_; +} + +long PullActionDataResult::getNextMessageId()const +{ + return nextMessageId_; +} + +std::string PullActionDataResult::getErrorCode()const +{ + return errorCode_; +} + +std::string PullActionDataResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool PullActionDataResult::getSuccess()const +{ + return success_; +} +