1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Release GenRealPersonVerificationToken GetRealPersonVerificationResult.

Browse Source
This commit is contained in:
sdk-team
2020-12-28 10:01:36 +00:00
parent c5062df7f5
commit b1f19958a7
48 changed files with 3171 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2020-12-28 Version: patch
- Release GenRealPersonVerificationToken GetRealPersonVerificationResult.
2020-12-28 Version: patch
- Add CommodityCode For QueryOrderAPI.

44
facebody/CMakeLists.txt
View File

@@ -21,6 +21,8 @@ set(facebody_public_header
include/alibabacloud/facebody/FacebodyExport.h )
set(facebody_public_header_model
include/alibabacloud/facebody/model/AddBodyTraceRequest.h
include/alibabacloud/facebody/model/AddBodyTraceResult.h
include/alibabacloud/facebody/model/AddFaceRequest.h
include/alibabacloud/facebody/model/AddFaceResult.h
include/alibabacloud/facebody/model/AddFaceEntityRequest.h
@@ -33,8 +35,16 @@ set(facebody_public_header_model
include/alibabacloud/facebody/model/CompareFaceResult.h
include/alibabacloud/facebody/model/CountCrowdRequest.h
include/alibabacloud/facebody/model/CountCrowdResult.h
include/alibabacloud/facebody/model/CreateBodyDbRequest.h
include/alibabacloud/facebody/model/CreateBodyDbResult.h
include/alibabacloud/facebody/model/CreateBodyPersonRequest.h
include/alibabacloud/facebody/model/CreateBodyPersonResult.h
include/alibabacloud/facebody/model/CreateFaceDbRequest.h
include/alibabacloud/facebody/model/CreateFaceDbResult.h
include/alibabacloud/facebody/model/DeleteBodyDbRequest.h
include/alibabacloud/facebody/model/DeleteBodyDbResult.h
include/alibabacloud/facebody/model/DeleteBodyPersonRequest.h
include/alibabacloud/facebody/model/DeleteBodyPersonResult.h
include/alibabacloud/facebody/model/DeleteFaceRequest.h
include/alibabacloud/facebody/model/DeleteFaceResult.h
include/alibabacloud/facebody/model/DeleteFaceDbRequest.h
@@ -75,12 +85,22 @@ set(facebody_public_header_model
include/alibabacloud/facebody/model/FaceMakeupResult.h
include/alibabacloud/facebody/model/FaceTidyupRequest.h
include/alibabacloud/facebody/model/FaceTidyupResult.h
include/alibabacloud/facebody/model/GenRealPersonVerificationTokenRequest.h
include/alibabacloud/facebody/model/GenRealPersonVerificationTokenResult.h
include/alibabacloud/facebody/model/GenerateHumanAnimeStyleRequest.h
include/alibabacloud/facebody/model/GenerateHumanAnimeStyleResult.h
include/alibabacloud/facebody/model/GetBodyPersonRequest.h
include/alibabacloud/facebody/model/GetBodyPersonResult.h
include/alibabacloud/facebody/model/GetFaceEntityRequest.h
include/alibabacloud/facebody/model/GetFaceEntityResult.h
include/alibabacloud/facebody/model/GetRealPersonVerificationResultRequest.h
include/alibabacloud/facebody/model/GetRealPersonVerificationResultResult.h
include/alibabacloud/facebody/model/HandPostureRequest.h
include/alibabacloud/facebody/model/HandPostureResult.h
include/alibabacloud/facebody/model/ListBodyDbsRequest.h
include/alibabacloud/facebody/model/ListBodyDbsResult.h
include/alibabacloud/facebody/model/ListBodyPersonRequest.h
include/alibabacloud/facebody/model/ListBodyPersonResult.h
include/alibabacloud/facebody/model/ListFaceDbsRequest.h
include/alibabacloud/facebody/model/ListFaceDbsResult.h
include/alibabacloud/facebody/model/ListFaceEntitiesRequest.h
@@ -95,6 +115,8 @@ set(facebody_public_header_model
include/alibabacloud/facebody/model/RecognizeFaceResult.h
include/alibabacloud/facebody/model/RecognizePublicFaceRequest.h
include/alibabacloud/facebody/model/RecognizePublicFaceResult.h
include/alibabacloud/facebody/model/SearchBodyTraceRequest.h
include/alibabacloud/facebody/model/SearchBodyTraceResult.h
include/alibabacloud/facebody/model/SearchFaceRequest.h
include/alibabacloud/facebody/model/SearchFaceResult.h
include/alibabacloud/facebody/model/SwapFacialFeaturesRequest.h
@@ -106,6 +128,8 @@ set(facebody_public_header_model
set(facebody_src
src/FacebodyClient.cc
src/model/AddBodyTraceRequest.cc
src/model/AddBodyTraceResult.cc
src/model/AddFaceRequest.cc
src/model/AddFaceResult.cc
src/model/AddFaceEntityRequest.cc
@@ -118,8 +142,16 @@ set(facebody_src
src/model/CompareFaceResult.cc
src/model/CountCrowdRequest.cc
src/model/CountCrowdResult.cc
src/model/CreateBodyDbRequest.cc
src/model/CreateBodyDbResult.cc
src/model/CreateBodyPersonRequest.cc
src/model/CreateBodyPersonResult.cc
src/model/CreateFaceDbRequest.cc
src/model/CreateFaceDbResult.cc
src/model/DeleteBodyDbRequest.cc
src/model/DeleteBodyDbResult.cc
src/model/DeleteBodyPersonRequest.cc
src/model/DeleteBodyPersonResult.cc
src/model/DeleteFaceRequest.cc
src/model/DeleteFaceResult.cc
src/model/DeleteFaceDbRequest.cc
@@ -160,12 +192,22 @@ set(facebody_src
src/model/FaceMakeupResult.cc
src/model/FaceTidyupRequest.cc
src/model/FaceTidyupResult.cc
src/model/GenRealPersonVerificationTokenRequest.cc
src/model/GenRealPersonVerificationTokenResult.cc
src/model/GenerateHumanAnimeStyleRequest.cc
src/model/GenerateHumanAnimeStyleResult.cc
src/model/GetBodyPersonRequest.cc
src/model/GetBodyPersonResult.cc
src/model/GetFaceEntityRequest.cc
src/model/GetFaceEntityResult.cc
src/model/GetRealPersonVerificationResultRequest.cc
src/model/GetRealPersonVerificationResultResult.cc
src/model/HandPostureRequest.cc
src/model/HandPostureResult.cc
src/model/ListBodyDbsRequest.cc
src/model/ListBodyDbsResult.cc
src/model/ListBodyPersonRequest.cc
src/model/ListBodyPersonResult.cc
src/model/ListFaceDbsRequest.cc
src/model/ListFaceDbsResult.cc
src/model/ListFaceEntitiesRequest.cc
@@ -180,6 +222,8 @@ set(facebody_src
src/model/RecognizeFaceResult.cc
src/model/RecognizePublicFaceRequest.cc
src/model/RecognizePublicFaceResult.cc
src/model/SearchBodyTraceRequest.cc
src/model/SearchBodyTraceResult.cc
src/model/SearchFaceRequest.cc
src/model/SearchFaceResult.cc
src/model/SwapFacialFeaturesRequest.cc

88
facebody/include/alibabacloud/facebody/FacebodyClient.h
View File

@@ -22,6 +22,8 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "FacebodyExport.h"
#include "model/AddBodyTraceRequest.h"
#include "model/AddBodyTraceResult.h"
#include "model/AddFaceRequest.h"
#include "model/AddFaceResult.h"
#include "model/AddFaceEntityRequest.h"
@@ -34,8 +36,16 @@
#include "model/CompareFaceResult.h"
#include "model/CountCrowdRequest.h"
#include "model/CountCrowdResult.h"
#include "model/CreateBodyDbRequest.h"
#include "model/CreateBodyDbResult.h"
#include "model/CreateBodyPersonRequest.h"
#include "model/CreateBodyPersonResult.h"
#include "model/CreateFaceDbRequest.h"
#include "model/CreateFaceDbResult.h"
#include "model/DeleteBodyDbRequest.h"
#include "model/DeleteBodyDbResult.h"
#include "model/DeleteBodyPersonRequest.h"
#include "model/DeleteBodyPersonResult.h"
#include "model/DeleteFaceRequest.h"
#include "model/DeleteFaceResult.h"
#include "model/DeleteFaceDbRequest.h"
@@ -76,12 +86,22 @@
#include "model/FaceMakeupResult.h"
#include "model/FaceTidyupRequest.h"
#include "model/FaceTidyupResult.h"
#include "model/GenRealPersonVerificationTokenRequest.h"
#include "model/GenRealPersonVerificationTokenResult.h"
#include "model/GenerateHumanAnimeStyleRequest.h"
#include "model/GenerateHumanAnimeStyleResult.h"
#include "model/GetBodyPersonRequest.h"
#include "model/GetBodyPersonResult.h"
#include "model/GetFaceEntityRequest.h"
#include "model/GetFaceEntityResult.h"
#include "model/GetRealPersonVerificationResultRequest.h"
#include "model/GetRealPersonVerificationResultResult.h"
#include "model/HandPostureRequest.h"
#include "model/HandPostureResult.h"
#include "model/ListBodyDbsRequest.h"
#include "model/ListBodyDbsResult.h"
#include "model/ListBodyPersonRequest.h"
#include "model/ListBodyPersonResult.h"
#include "model/ListFaceDbsRequest.h"
#include "model/ListFaceDbsResult.h"
#include "model/ListFaceEntitiesRequest.h"
@@ -96,6 +116,8 @@
#include "model/RecognizeFaceResult.h"
#include "model/RecognizePublicFaceRequest.h"
#include "model/RecognizePublicFaceResult.h"
#include "model/SearchBodyTraceRequest.h"
#include "model/SearchBodyTraceResult.h"
#include "model/SearchFaceRequest.h"
#include "model/SearchFaceResult.h"
#include "model/SwapFacialFeaturesRequest.h"
@@ -113,6 +135,9 @@ namespace AlibabaCloud
class ALIBABACLOUD_FACEBODY_EXPORT FacebodyClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AddBodyTraceResult> AddBodyTraceOutcome;
typedef std::future<AddBodyTraceOutcome> AddBodyTraceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::AddBodyTraceRequest&, const AddBodyTraceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddBodyTraceAsyncHandler;
typedef Outcome<Error, Model::AddFaceResult> AddFaceOutcome;
typedef std::future<AddFaceOutcome> AddFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::AddFaceRequest&, const AddFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddFaceAsyncHandler;
@@ -131,9 +156,21 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CountCrowdResult> CountCrowdOutcome;
typedef std::future<CountCrowdOutcome> CountCrowdOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::CountCrowdRequest&, const CountCrowdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CountCrowdAsyncHandler;
typedef Outcome<Error, Model::CreateBodyDbResult> CreateBodyDbOutcome;
typedef std::future<CreateBodyDbOutcome> CreateBodyDbOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::CreateBodyDbRequest&, const CreateBodyDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBodyDbAsyncHandler;
typedef Outcome<Error, Model::CreateBodyPersonResult> CreateBodyPersonOutcome;
typedef std::future<CreateBodyPersonOutcome> CreateBodyPersonOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::CreateBodyPersonRequest&, const CreateBodyPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBodyPersonAsyncHandler;
typedef Outcome<Error, Model::CreateFaceDbResult> CreateFaceDbOutcome;
typedef std::future<CreateFaceDbOutcome> CreateFaceDbOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::CreateFaceDbRequest&, const CreateFaceDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFaceDbAsyncHandler;
typedef Outcome<Error, Model::DeleteBodyDbResult> DeleteBodyDbOutcome;
typedef std::future<DeleteBodyDbOutcome> DeleteBodyDbOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DeleteBodyDbRequest&, const DeleteBodyDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteBodyDbAsyncHandler;
typedef Outcome<Error, Model::DeleteBodyPersonResult> DeleteBodyPersonOutcome;
typedef std::future<DeleteBodyPersonOutcome> DeleteBodyPersonOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DeleteBodyPersonRequest&, const DeleteBodyPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteBodyPersonAsyncHandler;
typedef Outcome<Error, Model::DeleteFaceResult> DeleteFaceOutcome;
typedef std::future<DeleteFaceOutcome> DeleteFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DeleteFaceRequest&, const DeleteFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceAsyncHandler;
@@ -194,15 +231,30 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::FaceTidyupResult> FaceTidyupOutcome;
typedef std::future<FaceTidyupOutcome> FaceTidyupOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::FaceTidyupRequest&, const FaceTidyupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FaceTidyupAsyncHandler;
typedef Outcome<Error, Model::GenRealPersonVerificationTokenResult> GenRealPersonVerificationTokenOutcome;
typedef std::future<GenRealPersonVerificationTokenOutcome> GenRealPersonVerificationTokenOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::GenRealPersonVerificationTokenRequest&, const GenRealPersonVerificationTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenRealPersonVerificationTokenAsyncHandler;
typedef Outcome<Error, Model::GenerateHumanAnimeStyleResult> GenerateHumanAnimeStyleOutcome;
typedef std::future<GenerateHumanAnimeStyleOutcome> GenerateHumanAnimeStyleOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::GenerateHumanAnimeStyleRequest&, const GenerateHumanAnimeStyleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateHumanAnimeStyleAsyncHandler;
typedef Outcome<Error, Model::GetBodyPersonResult> GetBodyPersonOutcome;
typedef std::future<GetBodyPersonOutcome> GetBodyPersonOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::GetBodyPersonRequest&, const GetBodyPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBodyPersonAsyncHandler;
typedef Outcome<Error, Model::GetFaceEntityResult> GetFaceEntityOutcome;
typedef std::future<GetFaceEntityOutcome> GetFaceEntityOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::GetFaceEntityRequest&, const GetFaceEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceEntityAsyncHandler;
typedef Outcome<Error, Model::GetRealPersonVerificationResultResult> GetRealPersonVerificationResultOutcome;
typedef std::future<GetRealPersonVerificationResultOutcome> GetRealPersonVerificationResultOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::GetRealPersonVerificationResultRequest&, const GetRealPersonVerificationResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRealPersonVerificationResultAsyncHandler;
typedef Outcome<Error, Model::HandPostureResult> HandPostureOutcome;
typedef std::future<HandPostureOutcome> HandPostureOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::HandPostureRequest&, const HandPostureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HandPostureAsyncHandler;
typedef Outcome<Error, Model::ListBodyDbsResult> ListBodyDbsOutcome;
typedef std::future<ListBodyDbsOutcome> ListBodyDbsOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::ListBodyDbsRequest&, const ListBodyDbsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListBodyDbsAsyncHandler;
typedef Outcome<Error, Model::ListBodyPersonResult> ListBodyPersonOutcome;
typedef std::future<ListBodyPersonOutcome> ListBodyPersonOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::ListBodyPersonRequest&, const ListBodyPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListBodyPersonAsyncHandler;
typedef Outcome<Error, Model::ListFaceDbsResult> ListFaceDbsOutcome;
typedef std::future<ListFaceDbsOutcome> ListFaceDbsOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::ListFaceDbsRequest&, const ListFaceDbsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceDbsAsyncHandler;
@@ -224,6 +276,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RecognizePublicFaceResult> RecognizePublicFaceOutcome;
typedef std::future<RecognizePublicFaceOutcome> RecognizePublicFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::RecognizePublicFaceRequest&, const RecognizePublicFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizePublicFaceAsyncHandler;
typedef Outcome<Error, Model::SearchBodyTraceResult> SearchBodyTraceOutcome;
typedef std::future<SearchBodyTraceOutcome> SearchBodyTraceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::SearchBodyTraceRequest&, const SearchBodyTraceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchBodyTraceAsyncHandler;
typedef Outcome<Error, Model::SearchFaceResult> SearchFaceOutcome;
typedef std::future<SearchFaceOutcome> SearchFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::SearchFaceRequest&, const SearchFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchFaceAsyncHandler;
@@ -241,6 +296,9 @@ namespace AlibabaCloud
FacebodyClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
FacebodyClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~FacebodyClient();
AddBodyTraceOutcome addBodyTrace(const Model::AddBodyTraceRequest &request)const;
void addBodyTraceAsync(const Model::AddBodyTraceRequest& request, const AddBodyTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddBodyTraceOutcomeCallable addBodyTraceCallable(const Model::AddBodyTraceRequest& request) const;
AddFaceOutcome addFace(const Model::AddFaceRequest &request)const;
void addFaceAsync(const Model::AddFaceRequest& request, const AddFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddFaceOutcomeCallable addFaceCallable(const Model::AddFaceRequest& request) const;
@@ -259,9 +317,21 @@ namespace AlibabaCloud
CountCrowdOutcome countCrowd(const Model::CountCrowdRequest &request)const;
void countCrowdAsync(const Model::CountCrowdRequest& request, const CountCrowdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CountCrowdOutcomeCallable countCrowdCallable(const Model::CountCrowdRequest& request) const;
CreateBodyDbOutcome createBodyDb(const Model::CreateBodyDbRequest &request)const;
void createBodyDbAsync(const Model::CreateBodyDbRequest& request, const CreateBodyDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateBodyDbOutcomeCallable createBodyDbCallable(const Model::CreateBodyDbRequest& request) const;
CreateBodyPersonOutcome createBodyPerson(const Model::CreateBodyPersonRequest &request)const;
void createBodyPersonAsync(const Model::CreateBodyPersonRequest& request, const CreateBodyPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateBodyPersonOutcomeCallable createBodyPersonCallable(const Model::CreateBodyPersonRequest& request) const;
CreateFaceDbOutcome createFaceDb(const Model::CreateFaceDbRequest &request)const;
void createFaceDbAsync(const Model::CreateFaceDbRequest& request, const CreateFaceDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateFaceDbOutcomeCallable createFaceDbCallable(const Model::CreateFaceDbRequest& request) const;
DeleteBodyDbOutcome deleteBodyDb(const Model::DeleteBodyDbRequest &request)const;
void deleteBodyDbAsync(const Model::DeleteBodyDbRequest& request, const DeleteBodyDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteBodyDbOutcomeCallable deleteBodyDbCallable(const Model::DeleteBodyDbRequest& request) const;
DeleteBodyPersonOutcome deleteBodyPerson(const Model::DeleteBodyPersonRequest &request)const;
void deleteBodyPersonAsync(const Model::DeleteBodyPersonRequest& request, const DeleteBodyPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteBodyPersonOutcomeCallable deleteBodyPersonCallable(const Model::DeleteBodyPersonRequest& request) const;
DeleteFaceOutcome deleteFace(const Model::DeleteFaceRequest &request)const;
void deleteFaceAsync(const Model::DeleteFaceRequest& request, const DeleteFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteFaceOutcomeCallable deleteFaceCallable(const Model::DeleteFaceRequest& request) const;
@@ -322,15 +392,30 @@ namespace AlibabaCloud
FaceTidyupOutcome faceTidyup(const Model::FaceTidyupRequest &request)const;
void faceTidyupAsync(const Model::FaceTidyupRequest& request, const FaceTidyupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FaceTidyupOutcomeCallable faceTidyupCallable(const Model::FaceTidyupRequest& request) const;
GenRealPersonVerificationTokenOutcome genRealPersonVerificationToken(const Model::GenRealPersonVerificationTokenRequest &request)const;
void genRealPersonVerificationTokenAsync(const Model::GenRealPersonVerificationTokenRequest& request, const GenRealPersonVerificationTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenRealPersonVerificationTokenOutcomeCallable genRealPersonVerificationTokenCallable(const Model::GenRealPersonVerificationTokenRequest& request) const;
GenerateHumanAnimeStyleOutcome generateHumanAnimeStyle(const Model::GenerateHumanAnimeStyleRequest &request)const;
void generateHumanAnimeStyleAsync(const Model::GenerateHumanAnimeStyleRequest& request, const GenerateHumanAnimeStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateHumanAnimeStyleOutcomeCallable generateHumanAnimeStyleCallable(const Model::GenerateHumanAnimeStyleRequest& request) const;
GetBodyPersonOutcome getBodyPerson(const Model::GetBodyPersonRequest &request)const;
void getBodyPersonAsync(const Model::GetBodyPersonRequest& request, const GetBodyPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetBodyPersonOutcomeCallable getBodyPersonCallable(const Model::GetBodyPersonRequest& request) const;
GetFaceEntityOutcome getFaceEntity(const Model::GetFaceEntityRequest &request)const;
void getFaceEntityAsync(const Model::GetFaceEntityRequest& request, const GetFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetFaceEntityOutcomeCallable getFaceEntityCallable(const Model::GetFaceEntityRequest& request) const;
GetRealPersonVerificationResultOutcome getRealPersonVerificationResult(const Model::GetRealPersonVerificationResultRequest &request)const;
void getRealPersonVerificationResultAsync(const Model::GetRealPersonVerificationResultRequest& request, const GetRealPersonVerificationResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetRealPersonVerificationResultOutcomeCallable getRealPersonVerificationResultCallable(const Model::GetRealPersonVerificationResultRequest& request) const;
HandPostureOutcome handPosture(const Model::HandPostureRequest &request)const;
void handPostureAsync(const Model::HandPostureRequest& request, const HandPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HandPostureOutcomeCallable handPostureCallable(const Model::HandPostureRequest& request) const;
ListBodyDbsOutcome listBodyDbs(const Model::ListBodyDbsRequest &request)const;
void listBodyDbsAsync(const Model::ListBodyDbsRequest& request, const ListBodyDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListBodyDbsOutcomeCallable listBodyDbsCallable(const Model::ListBodyDbsRequest& request) const;
ListBodyPersonOutcome listBodyPerson(const Model::ListBodyPersonRequest &request)const;
void listBodyPersonAsync(const Model::ListBodyPersonRequest& request, const ListBodyPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListBodyPersonOutcomeCallable listBodyPersonCallable(const Model::ListBodyPersonRequest& request) const;
ListFaceDbsOutcome listFaceDbs(const Model::ListFaceDbsRequest &request)const;
void listFaceDbsAsync(const Model::ListFaceDbsRequest& request, const ListFaceDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListFaceDbsOutcomeCallable listFaceDbsCallable(const Model::ListFaceDbsRequest& request) const;
@@ -352,6 +437,9 @@ namespace AlibabaCloud
RecognizePublicFaceOutcome recognizePublicFace(const Model::RecognizePublicFaceRequest &request)const;
void recognizePublicFaceAsync(const Model::RecognizePublicFaceRequest& request, const RecognizePublicFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizePublicFaceOutcomeCallable recognizePublicFaceCallable(const Model::RecognizePublicFaceRequest& request) const;
SearchBodyTraceOutcome searchBodyTrace(const Model::SearchBodyTraceRequest &request)const;
void searchBodyTraceAsync(const Model::SearchBodyTraceRequest& request, const SearchBodyTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchBodyTraceOutcomeCallable searchBodyTraceCallable(const Model::SearchBodyTraceRequest& request) const;
SearchFaceOutcome searchFace(const Model::SearchFaceRequest &request)const;
void searchFaceAsync(const Model::SearchFaceRequest& request, const SearchFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchFaceOutcomeCallable searchFaceCallable(const Model::SearchFaceRequest& request) const;

57
facebody/include/alibabacloud/facebody/model/AddBodyTraceRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_ADDBODYTRACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_ADDBODYTRACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT AddBodyTraceRequest : public RpcServiceRequest
{
public:
AddBodyTraceRequest();
~AddBodyTraceRequest();
std::string getExtraData()const;
void setExtraData(const std::string& extraData);
long getPersonId()const;
void setPersonId(long personId);
Array getImages()const;
void setImages(const Array& images);
long getDbId()const;
void setDbId(long dbId);
private:
std::string extraData_;
long personId_;
Array images_;
long dbId_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_ADDBODYTRACEREQUEST_H_

59
facebody/include/alibabacloud/facebody/model/AddBodyTraceResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_FACEBODY_MODEL_ADDBODYTRACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_ADDBODYTRACERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT AddBodyTraceResult : public ServiceResult
{
public:
struct Data
{
long id;
};
AddBodyTraceResult();
explicit AddBodyTraceResult(const std::string &payload);
~AddBodyTraceResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_ADDBODYTRACERESULT_H_

48
facebody/include/alibabacloud/facebody/model/CreateBodyDbRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_CREATEBODYDBREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_CREATEBODYDBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT CreateBodyDbRequest : public RpcServiceRequest
{
public:
CreateBodyDbRequest();
~CreateBodyDbRequest();
std::string getName()const;
void setName(const std::string& name);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_CREATEBODYDBREQUEST_H_

59
facebody/include/alibabacloud/facebody/model/CreateBodyDbResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_FACEBODY_MODEL_CREATEBODYDBRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_CREATEBODYDBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT CreateBodyDbResult : public ServiceResult
{
public:
struct Data
{
long id;
};
CreateBodyDbResult();
explicit CreateBodyDbResult(const std::string &payload);
~CreateBodyDbResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_CREATEBODYDBRESULT_H_

51
facebody/include/alibabacloud/facebody/model/CreateBodyPersonRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_CREATEBODYPERSONREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_CREATEBODYPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT CreateBodyPersonRequest : public RpcServiceRequest
{
public:
CreateBodyPersonRequest();
~CreateBodyPersonRequest();
long getDbId()const;
void setDbId(long dbId);
std::string getName()const;
void setName(const std::string& name);
private:
long dbId_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_CREATEBODYPERSONREQUEST_H_

59
facebody/include/alibabacloud/facebody/model/CreateBodyPersonResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_FACEBODY_MODEL_CREATEBODYPERSONRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_CREATEBODYPERSONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT CreateBodyPersonResult : public ServiceResult
{
public:
struct Data
{
long id;
};
CreateBodyPersonResult();
explicit CreateBodyPersonResult(const std::string &payload);
~CreateBodyPersonResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_CREATEBODYPERSONRESULT_H_

48
facebody/include/alibabacloud/facebody/model/DeleteBodyDbRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_DELETEBODYDBREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEBODYDBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DeleteBodyDbRequest : public RpcServiceRequest
{
public:
DeleteBodyDbRequest();
~DeleteBodyDbRequest();
long getId()const;
void setId(long id);
private:
long id_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEBODYDBREQUEST_H_

53
facebody/include/alibabacloud/facebody/model/DeleteBodyDbResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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_FACEBODY_MODEL_DELETEBODYDBRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEBODYDBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DeleteBodyDbResult : public ServiceResult
{
public:
DeleteBodyDbResult();
explicit DeleteBodyDbResult(const std::string &payload);
~DeleteBodyDbResult();
std::string getMessage()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEBODYDBRESULT_H_

51
facebody/include/alibabacloud/facebody/model/DeleteBodyPersonRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_DELETEBODYPERSONREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEBODYPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DeleteBodyPersonRequest : public RpcServiceRequest
{
public:
DeleteBodyPersonRequest();
~DeleteBodyPersonRequest();
long getPersonId()const;
void setPersonId(long personId);
long getDbId()const;
void setDbId(long dbId);
private:
long personId_;
long dbId_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEBODYPERSONREQUEST_H_

53
facebody/include/alibabacloud/facebody/model/DeleteBodyPersonResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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_FACEBODY_MODEL_DELETEBODYPERSONRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEBODYPERSONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DeleteBodyPersonResult : public ServiceResult
{
public:
DeleteBodyPersonResult();
explicit DeleteBodyPersonResult(const std::string &payload);
~DeleteBodyPersonResult();
std::string getMessage()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEBODYPERSONRESULT_H_

54
facebody/include/alibabacloud/facebody/model/GenRealPersonVerificationTokenRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_GENREALPERSONVERIFICATIONTOKENREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GENREALPERSONVERIFICATIONTOKENREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT GenRealPersonVerificationTokenRequest : public RpcServiceRequest
{
public:
GenRealPersonVerificationTokenRequest();
~GenRealPersonVerificationTokenRequest();
std::string getCertificateNumber()const;
void setCertificateNumber(const std::string& certificateNumber);
std::string getCertificateName()const;
void setCertificateName(const std::string& certificateName);
std::string getMetaInfo()const;
void setMetaInfo(const std::string& metaInfo);
private:
std::string certificateNumber_;
std::string certificateName_;
std::string metaInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GENREALPERSONVERIFICATIONTOKENREQUEST_H_

61
facebody/include/alibabacloud/facebody/model/GenRealPersonVerificationTokenResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* 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_FACEBODY_MODEL_GENREALPERSONVERIFICATIONTOKENRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GENREALPERSONVERIFICATIONTOKENRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT GenRealPersonVerificationTokenResult : public ServiceResult
{
public:
struct Data
{
std::string verificationToken;
};
GenRealPersonVerificationTokenResult();
explicit GenRealPersonVerificationTokenResult(const std::string &payload);
~GenRealPersonVerificationTokenResult();
Data getData()const;
std::string getErrorMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
std::string errorMessage_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GENREALPERSONVERIFICATIONTOKENRESULT_H_

51
facebody/include/alibabacloud/facebody/model/GetBodyPersonRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_GETBODYPERSONREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GETBODYPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT GetBodyPersonRequest : public RpcServiceRequest
{
public:
GetBodyPersonRequest();
~GetBodyPersonRequest();
long getPersonId()const;
void setPersonId(long personId);
long getDbId()const;
void setDbId(long dbId);
private:
long personId_;
long dbId_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GETBODYPERSONREQUEST_H_

69
facebody/include/alibabacloud/facebody/model/GetBodyPersonResult.h Normal file
View File

@@ -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_FACEBODY_MODEL_GETBODYPERSONRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GETBODYPERSONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT GetBodyPersonResult : public ServiceResult
{
public:
struct Data
{
struct Trace
{
std::string extraData;
long id;
};
long traceCount;
long instanceId;
std::vector<Trace> traceList;
long dbId;
long id;
std::string name;
};
GetBodyPersonResult();
explicit GetBodyPersonResult(const std::string &payload);
~GetBodyPersonResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GETBODYPERSONRESULT_H_

51
facebody/include/alibabacloud/facebody/model/GetRealPersonVerificationResultRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_GETREALPERSONVERIFICATIONRESULTREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GETREALPERSONVERIFICATIONRESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT GetRealPersonVerificationResultRequest : public RpcServiceRequest
{
public:
GetRealPersonVerificationResultRequest();
~GetRealPersonVerificationResultRequest();
std::string getVerificationToken()const;
void setVerificationToken(const std::string& verificationToken);
std::string getMaterialHash()const;
void setMaterialHash(const std::string& materialHash);
private:
std::string verificationToken_;
std::string materialHash_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GETREALPERSONVERIFICATIONRESULTREQUEST_H_

63
facebody/include/alibabacloud/facebody/model/GetRealPersonVerificationResultResult.h Normal file
View File

@@ -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_FACEBODY_MODEL_GETREALPERSONVERIFICATIONRESULTRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GETREALPERSONVERIFICATIONRESULTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT GetRealPersonVerificationResultResult : public ServiceResult
{
public:
struct Data
{
bool pass;
std::string materialMatch;
std::string identityInfo;
};
GetRealPersonVerificationResultResult();
explicit GetRealPersonVerificationResultResult(const std::string &payload);
~GetRealPersonVerificationResultResult();
Data getData()const;
std::string getErrorMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
std::string errorMessage_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GETREALPERSONVERIFICATIONRESULTRESULT_H_

51
facebody/include/alibabacloud/facebody/model/ListBodyDbsRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_LISTBODYDBSREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_LISTBODYDBSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT ListBodyDbsRequest : public RpcServiceRequest
{
public:
ListBodyDbsRequest();
~ListBodyDbsRequest();
long getLimit()const;
void setLimit(long limit);
long getOffset()const;
void setOffset(long offset);
private:
long limit_;
long offset_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTBODYDBSREQUEST_H_

65
facebody/include/alibabacloud/facebody/model/ListBodyDbsResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_FACEBODY_MODEL_LISTBODYDBSRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_LISTBODYDBSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT ListBodyDbsResult : public ServiceResult
{
public:
struct Data
{
struct DbListItem
{
long id;
std::string name;
};
long total;
std::vector<DbListItem> dbList;
};
ListBodyDbsResult();
explicit ListBodyDbsResult(const std::string &payload);
~ListBodyDbsResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTBODYDBSRESULT_H_

54
facebody/include/alibabacloud/facebody/model/ListBodyPersonRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_LISTBODYPERSONREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_LISTBODYPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT ListBodyPersonRequest : public RpcServiceRequest
{
public:
ListBodyPersonRequest();
~ListBodyPersonRequest();
long getLimit()const;
void setLimit(long limit);
long getOffset()const;
void setOffset(long offset);
long getDbId()const;
void setDbId(long dbId);
private:
long limit_;
long offset_;
long dbId_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTBODYPERSONREQUEST_H_

68
facebody/include/alibabacloud/facebody/model/ListBodyPersonResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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_FACEBODY_MODEL_LISTBODYPERSONRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_LISTBODYPERSONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT ListBodyPersonResult : public ServiceResult
{
public:
struct Data
{
struct Person
{
long traceCount;
long instanceId;
long dbId;
long id;
std::string name;
};
std::vector<Person> personList;
long total;
};
ListBodyPersonResult();
explicit ListBodyPersonResult(const std::string &payload);
~ListBodyPersonResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTBODYPERSONRESULT_H_

57
facebody/include/alibabacloud/facebody/model/SearchBodyTraceRequest.h Normal file
View File

@@ -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_FACEBODY_MODEL_SEARCHBODYTRACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_SEARCHBODYTRACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT SearchBodyTraceRequest : public RpcServiceRequest
{
public:
SearchBodyTraceRequest();
~SearchBodyTraceRequest();
float getMinScore()const;
void setMinScore(float minScore);
long getLimit()const;
void setLimit(long limit);
Array getImages()const;
void setImages(const Array& images);
long getDbId()const;
void setDbId(long dbId);
private:
float minScore_;
long limit_;
Array images_;
long dbId_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_SEARCHBODYTRACEREQUEST_H_

67
facebody/include/alibabacloud/facebody/model/SearchBodyTraceResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* 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_FACEBODY_MODEL_SEARCHBODYTRACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_SEARCHBODYTRACERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT SearchBodyTraceResult : public ServiceResult
{
public:
struct Data
{
struct Trace
{
float score;
long personId;
long traceId;
long dbId;
std::string extraData;
};
std::vector<Trace> matchList;
};
SearchBodyTraceResult();
explicit SearchBodyTraceResult(const std::string &payload);
~SearchBodyTraceResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_SEARCHBODYTRACERESULT_H_

396
facebody/src/FacebodyClient.cc
View File

@@ -51,6 +51,42 @@ FacebodyClient::FacebodyClient(const std::string & accessKeyId, const std::strin
FacebodyClient::~FacebodyClient()
{}
FacebodyClient::AddBodyTraceOutcome FacebodyClient::addBodyTrace(const AddBodyTraceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddBodyTraceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddBodyTraceOutcome(AddBodyTraceResult(outcome.result()));
else
return AddBodyTraceOutcome(outcome.error());
}
void FacebodyClient::addBodyTraceAsync(const AddBodyTraceRequest& request, const AddBodyTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addBodyTrace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::AddBodyTraceOutcomeCallable FacebodyClient::addBodyTraceCallable(const AddBodyTraceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddBodyTraceOutcome()>>(
[this, request]()
{
return this->addBodyTrace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::AddFaceOutcome FacebodyClient::addFace(const AddFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,78 @@ FacebodyClient::CountCrowdOutcomeCallable FacebodyClient::countCrowdCallable(con
return task->get_future();
}
FacebodyClient::CreateBodyDbOutcome FacebodyClient::createBodyDb(const CreateBodyDbRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateBodyDbOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateBodyDbOutcome(CreateBodyDbResult(outcome.result()));
else
return CreateBodyDbOutcome(outcome.error());
}
void FacebodyClient::createBodyDbAsync(const CreateBodyDbRequest& request, const CreateBodyDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createBodyDb(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::CreateBodyDbOutcomeCallable FacebodyClient::createBodyDbCallable(const CreateBodyDbRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateBodyDbOutcome()>>(
[this, request]()
{
return this->createBodyDb(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::CreateBodyPersonOutcome FacebodyClient::createBodyPerson(const CreateBodyPersonRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateBodyPersonOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateBodyPersonOutcome(CreateBodyPersonResult(outcome.result()));
else
return CreateBodyPersonOutcome(outcome.error());
}
void FacebodyClient::createBodyPersonAsync(const CreateBodyPersonRequest& request, const CreateBodyPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createBodyPerson(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::CreateBodyPersonOutcomeCallable FacebodyClient::createBodyPersonCallable(const CreateBodyPersonRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateBodyPersonOutcome()>>(
[this, request]()
{
return this->createBodyPerson(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::CreateFaceDbOutcome FacebodyClient::createFaceDb(const CreateFaceDbRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +411,78 @@ FacebodyClient::CreateFaceDbOutcomeCallable FacebodyClient::createFaceDbCallable
return task->get_future();
}
FacebodyClient::DeleteBodyDbOutcome FacebodyClient::deleteBodyDb(const DeleteBodyDbRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteBodyDbOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteBodyDbOutcome(DeleteBodyDbResult(outcome.result()));
else
return DeleteBodyDbOutcome(outcome.error());
}
void FacebodyClient::deleteBodyDbAsync(const DeleteBodyDbRequest& request, const DeleteBodyDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteBodyDb(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DeleteBodyDbOutcomeCallable FacebodyClient::deleteBodyDbCallable(const DeleteBodyDbRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteBodyDbOutcome()>>(
[this, request]()
{
return this->deleteBodyDb(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DeleteBodyPersonOutcome FacebodyClient::deleteBodyPerson(const DeleteBodyPersonRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteBodyPersonOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteBodyPersonOutcome(DeleteBodyPersonResult(outcome.result()));
else
return DeleteBodyPersonOutcome(outcome.error());
}
void FacebodyClient::deleteBodyPersonAsync(const DeleteBodyPersonRequest& request, const DeleteBodyPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteBodyPerson(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DeleteBodyPersonOutcomeCallable FacebodyClient::deleteBodyPersonCallable(const DeleteBodyPersonRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteBodyPersonOutcome()>>(
[this, request]()
{
return this->deleteBodyPerson(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DeleteFaceOutcome FacebodyClient::deleteFace(const DeleteFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1023,6 +1203,42 @@ FacebodyClient::FaceTidyupOutcomeCallable FacebodyClient::faceTidyupCallable(con
return task->get_future();
}
FacebodyClient::GenRealPersonVerificationTokenOutcome FacebodyClient::genRealPersonVerificationToken(const GenRealPersonVerificationTokenRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GenRealPersonVerificationTokenOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GenRealPersonVerificationTokenOutcome(GenRealPersonVerificationTokenResult(outcome.result()));
else
return GenRealPersonVerificationTokenOutcome(outcome.error());
}
void FacebodyClient::genRealPersonVerificationTokenAsync(const GenRealPersonVerificationTokenRequest& request, const GenRealPersonVerificationTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, genRealPersonVerificationToken(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::GenRealPersonVerificationTokenOutcomeCallable FacebodyClient::genRealPersonVerificationTokenCallable(const GenRealPersonVerificationTokenRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GenRealPersonVerificationTokenOutcome()>>(
[this, request]()
{
return this->genRealPersonVerificationToken(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::GenerateHumanAnimeStyleOutcome FacebodyClient::generateHumanAnimeStyle(const GenerateHumanAnimeStyleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,6 +1275,42 @@ FacebodyClient::GenerateHumanAnimeStyleOutcomeCallable FacebodyClient::generateH
return task->get_future();
}
FacebodyClient::GetBodyPersonOutcome FacebodyClient::getBodyPerson(const GetBodyPersonRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetBodyPersonOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetBodyPersonOutcome(GetBodyPersonResult(outcome.result()));
else
return GetBodyPersonOutcome(outcome.error());
}
void FacebodyClient::getBodyPersonAsync(const GetBodyPersonRequest& request, const GetBodyPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getBodyPerson(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::GetBodyPersonOutcomeCallable FacebodyClient::getBodyPersonCallable(const GetBodyPersonRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetBodyPersonOutcome()>>(
[this, request]()
{
return this->getBodyPerson(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::GetFaceEntityOutcome FacebodyClient::getFaceEntity(const GetFaceEntityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1095,6 +1347,42 @@ FacebodyClient::GetFaceEntityOutcomeCallable FacebodyClient::getFaceEntityCallab
return task->get_future();
}
FacebodyClient::GetRealPersonVerificationResultOutcome FacebodyClient::getRealPersonVerificationResult(const GetRealPersonVerificationResultRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetRealPersonVerificationResultOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetRealPersonVerificationResultOutcome(GetRealPersonVerificationResultResult(outcome.result()));
else
return GetRealPersonVerificationResultOutcome(outcome.error());
}
void FacebodyClient::getRealPersonVerificationResultAsync(const GetRealPersonVerificationResultRequest& request, const GetRealPersonVerificationResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getRealPersonVerificationResult(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::GetRealPersonVerificationResultOutcomeCallable FacebodyClient::getRealPersonVerificationResultCallable(const GetRealPersonVerificationResultRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetRealPersonVerificationResultOutcome()>>(
[this, request]()
{
return this->getRealPersonVerificationResult(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::HandPostureOutcome FacebodyClient::handPosture(const HandPostureRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1131,6 +1419,78 @@ FacebodyClient::HandPostureOutcomeCallable FacebodyClient::handPostureCallable(c
return task->get_future();
}
FacebodyClient::ListBodyDbsOutcome FacebodyClient::listBodyDbs(const ListBodyDbsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListBodyDbsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListBodyDbsOutcome(ListBodyDbsResult(outcome.result()));
else
return ListBodyDbsOutcome(outcome.error());
}
void FacebodyClient::listBodyDbsAsync(const ListBodyDbsRequest& request, const ListBodyDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listBodyDbs(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::ListBodyDbsOutcomeCallable FacebodyClient::listBodyDbsCallable(const ListBodyDbsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListBodyDbsOutcome()>>(
[this, request]()
{
return this->listBodyDbs(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::ListBodyPersonOutcome FacebodyClient::listBodyPerson(const ListBodyPersonRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListBodyPersonOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListBodyPersonOutcome(ListBodyPersonResult(outcome.result()));
else
return ListBodyPersonOutcome(outcome.error());
}
void FacebodyClient::listBodyPersonAsync(const ListBodyPersonRequest& request, const ListBodyPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listBodyPerson(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::ListBodyPersonOutcomeCallable FacebodyClient::listBodyPersonCallable(const ListBodyPersonRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListBodyPersonOutcome()>>(
[this, request]()
{
return this->listBodyPerson(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::ListFaceDbsOutcome FacebodyClient::listFaceDbs(const ListFaceDbsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1383,6 +1743,42 @@ FacebodyClient::RecognizePublicFaceOutcomeCallable FacebodyClient::recognizePubl
return task->get_future();
}
FacebodyClient::SearchBodyTraceOutcome FacebodyClient::searchBodyTrace(const SearchBodyTraceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchBodyTraceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchBodyTraceOutcome(SearchBodyTraceResult(outcome.result()));
else
return SearchBodyTraceOutcome(outcome.error());
}
void FacebodyClient::searchBodyTraceAsync(const SearchBodyTraceRequest& request, const SearchBodyTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, searchBodyTrace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::SearchBodyTraceOutcomeCallable FacebodyClient::searchBodyTraceCallable(const SearchBodyTraceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchBodyTraceOutcome()>>(
[this, request]()
{
return this->searchBodyTrace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::SearchFaceOutcome FacebodyClient::searchFace(const SearchFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

73
facebody/src/model/AddBodyTraceRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/AddBodyTraceRequest.h>
using AlibabaCloud::Facebody::Model::AddBodyTraceRequest;
AddBodyTraceRequest::AddBodyTraceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "AddBodyTrace")
{
setMethod(HttpRequest::Method::Post);
}
AddBodyTraceRequest::~AddBodyTraceRequest()
{}
std::string AddBodyTraceRequest::getExtraData()const
{
return extraData_;
}
void AddBodyTraceRequest::setExtraData(const std::string& extraData)
{
extraData_ = extraData;
setBodyParameter("ExtraData", extraData);
}
long AddBodyTraceRequest::getPersonId()const
{
return personId_;
}
void AddBodyTraceRequest::setPersonId(long personId)
{
personId_ = personId;
setBodyParameter("PersonId", std::to_string(personId));
}
Array AddBodyTraceRequest::getImages()const
{
return images_;
}
void AddBodyTraceRequest::setImages(const Array& images)
{
images_ = images;
setBodyParameter("Images", std::to_string(images));
}
long AddBodyTraceRequest::getDbId()const
{
return dbId_;
}
void AddBodyTraceRequest::setDbId(long dbId)
{
dbId_ = dbId;
setBodyParameter("DbId", std::to_string(dbId));
}

66
facebody/src/model/AddBodyTraceResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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 <alibabacloud/facebody/model/AddBodyTraceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
AddBodyTraceResult::AddBodyTraceResult() :
ServiceResult()
{}
AddBodyTraceResult::AddBodyTraceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddBodyTraceResult::~AddBodyTraceResult()
{}
void AddBodyTraceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Id"].isNull())
data_.id = std::stol(dataNode["Id"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
std::string AddBodyTraceResult::getMessage()const
{
return message_;
}
AddBodyTraceResult::Data AddBodyTraceResult::getData()const
{
return data_;
}
std::string AddBodyTraceResult::getCode()const
{
return code_;
}

40
facebody/src/model/CreateBodyDbRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/CreateBodyDbRequest.h>
using AlibabaCloud::Facebody::Model::CreateBodyDbRequest;
CreateBodyDbRequest::CreateBodyDbRequest() :
RpcServiceRequest("facebody", "2019-12-30", "CreateBodyDb")
{
setMethod(HttpRequest::Method::Post);
}
CreateBodyDbRequest::~CreateBodyDbRequest()
{}
std::string CreateBodyDbRequest::getName()const
{
return name_;
}
void CreateBodyDbRequest::setName(const std::string& name)
{
name_ = name;
setBodyParameter("Name", name);
}

66
facebody/src/model/CreateBodyDbResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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 <alibabacloud/facebody/model/CreateBodyDbResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
CreateBodyDbResult::CreateBodyDbResult() :
ServiceResult()
{}
CreateBodyDbResult::CreateBodyDbResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateBodyDbResult::~CreateBodyDbResult()
{}
void CreateBodyDbResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Id"].isNull())
data_.id = std::stol(dataNode["Id"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
std::string CreateBodyDbResult::getMessage()const
{
return message_;
}
CreateBodyDbResult::Data CreateBodyDbResult::getData()const
{
return data_;
}
std::string CreateBodyDbResult::getCode()const
{
return code_;
}

51
facebody/src/model/CreateBodyPersonRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/CreateBodyPersonRequest.h>
using AlibabaCloud::Facebody::Model::CreateBodyPersonRequest;
CreateBodyPersonRequest::CreateBodyPersonRequest() :
RpcServiceRequest("facebody", "2019-12-30", "CreateBodyPerson")
{
setMethod(HttpRequest::Method::Post);
}
CreateBodyPersonRequest::~CreateBodyPersonRequest()
{}
long CreateBodyPersonRequest::getDbId()const
{
return dbId_;
}
void CreateBodyPersonRequest::setDbId(long dbId)
{
dbId_ = dbId;
setBodyParameter("DbId", std::to_string(dbId));
}
std::string CreateBodyPersonRequest::getName()const
{
return name_;
}
void CreateBodyPersonRequest::setName(const std::string& name)
{
name_ = name;
setBodyParameter("Name", name);
}

66
facebody/src/model/CreateBodyPersonResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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 <alibabacloud/facebody/model/CreateBodyPersonResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
CreateBodyPersonResult::CreateBodyPersonResult() :
ServiceResult()
{}
CreateBodyPersonResult::CreateBodyPersonResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateBodyPersonResult::~CreateBodyPersonResult()
{}
void CreateBodyPersonResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Id"].isNull())
data_.id = std::stol(dataNode["Id"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
std::string CreateBodyPersonResult::getMessage()const
{
return message_;
}
CreateBodyPersonResult::Data CreateBodyPersonResult::getData()const
{
return data_;
}
std::string CreateBodyPersonResult::getCode()const
{
return code_;
}

40
facebody/src/model/DeleteBodyDbRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/DeleteBodyDbRequest.h>
using AlibabaCloud::Facebody::Model::DeleteBodyDbRequest;
DeleteBodyDbRequest::DeleteBodyDbRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DeleteBodyDb")
{
setMethod(HttpRequest::Method::Post);
}
DeleteBodyDbRequest::~DeleteBodyDbRequest()
{}
long DeleteBodyDbRequest::getId()const
{
return id_;
}
void DeleteBodyDbRequest::setId(long id)
{
id_ = id;
setBodyParameter("Id", std::to_string(id));
}

58
facebody/src/model/DeleteBodyDbResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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 <alibabacloud/facebody/model/DeleteBodyDbResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DeleteBodyDbResult::DeleteBodyDbResult() :
ServiceResult()
{}
DeleteBodyDbResult::DeleteBodyDbResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteBodyDbResult::~DeleteBodyDbResult()
{}
void DeleteBodyDbResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
std::string DeleteBodyDbResult::getMessage()const
{
return message_;
}
std::string DeleteBodyDbResult::getCode()const
{
return code_;
}

51
facebody/src/model/DeleteBodyPersonRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/DeleteBodyPersonRequest.h>
using AlibabaCloud::Facebody::Model::DeleteBodyPersonRequest;
DeleteBodyPersonRequest::DeleteBodyPersonRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DeleteBodyPerson")
{
setMethod(HttpRequest::Method::Post);
}
DeleteBodyPersonRequest::~DeleteBodyPersonRequest()
{}
long DeleteBodyPersonRequest::getPersonId()const
{
return personId_;
}
void DeleteBodyPersonRequest::setPersonId(long personId)
{
personId_ = personId;
setBodyParameter("PersonId", std::to_string(personId));
}
long DeleteBodyPersonRequest::getDbId()const
{
return dbId_;
}
void DeleteBodyPersonRequest::setDbId(long dbId)
{
dbId_ = dbId;
setBodyParameter("DbId", std::to_string(dbId));
}

58
facebody/src/model/DeleteBodyPersonResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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 <alibabacloud/facebody/model/DeleteBodyPersonResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DeleteBodyPersonResult::DeleteBodyPersonResult() :
ServiceResult()
{}
DeleteBodyPersonResult::DeleteBodyPersonResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteBodyPersonResult::~DeleteBodyPersonResult()
{}
void DeleteBodyPersonResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
std::string DeleteBodyPersonResult::getMessage()const
{
return message_;
}
std::string DeleteBodyPersonResult::getCode()const
{
return code_;
}

62
facebody/src/model/GenRealPersonVerificationTokenRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/GenRealPersonVerificationTokenRequest.h>
using AlibabaCloud::Facebody::Model::GenRealPersonVerificationTokenRequest;
GenRealPersonVerificationTokenRequest::GenRealPersonVerificationTokenRequest() :
RpcServiceRequest("facebody", "2019-12-30", "GenRealPersonVerificationToken")
{
setMethod(HttpRequest::Method::Post);
}
GenRealPersonVerificationTokenRequest::~GenRealPersonVerificationTokenRequest()
{}
std::string GenRealPersonVerificationTokenRequest::getCertificateNumber()const
{
return certificateNumber_;
}
void GenRealPersonVerificationTokenRequest::setCertificateNumber(const std::string& certificateNumber)
{
certificateNumber_ = certificateNumber;
setBodyParameter("CertificateNumber", certificateNumber);
}
std::string GenRealPersonVerificationTokenRequest::getCertificateName()const
{
return certificateName_;
}
void GenRealPersonVerificationTokenRequest::setCertificateName(const std::string& certificateName)
{
certificateName_ = certificateName;
setBodyParameter("CertificateName", certificateName);
}
std::string GenRealPersonVerificationTokenRequest::getMetaInfo()const
{
return metaInfo_;
}
void GenRealPersonVerificationTokenRequest::setMetaInfo(const std::string& metaInfo)
{
metaInfo_ = metaInfo;
setBodyParameter("MetaInfo", metaInfo);
}

73
facebody/src/model/GenRealPersonVerificationTokenResult.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/GenRealPersonVerificationTokenResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
GenRealPersonVerificationTokenResult::GenRealPersonVerificationTokenResult() :
ServiceResult()
{}
GenRealPersonVerificationTokenResult::GenRealPersonVerificationTokenResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GenRealPersonVerificationTokenResult::~GenRealPersonVerificationTokenResult()
{}
void GenRealPersonVerificationTokenResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["VerificationToken"].isNull())
data_.verificationToken = dataNode["VerificationToken"].asString();
if(!value["ErrorMessage"].isNull())
errorMessage_ = value["ErrorMessage"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
GenRealPersonVerificationTokenResult::Data GenRealPersonVerificationTokenResult::getData()const
{
return data_;
}
std::string GenRealPersonVerificationTokenResult::getErrorMessage()const
{
return errorMessage_;
}
std::string GenRealPersonVerificationTokenResult::getCode()const
{
return code_;
}
bool GenRealPersonVerificationTokenResult::getSuccess()const
{
return success_;
}

51
facebody/src/model/GetBodyPersonRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/GetBodyPersonRequest.h>
using AlibabaCloud::Facebody::Model::GetBodyPersonRequest;
GetBodyPersonRequest::GetBodyPersonRequest() :
RpcServiceRequest("facebody", "2019-12-30", "GetBodyPerson")
{
setMethod(HttpRequest::Method::Get);
}
GetBodyPersonRequest::~GetBodyPersonRequest()
{}
long GetBodyPersonRequest::getPersonId()const
{
return personId_;
}
void GetBodyPersonRequest::setPersonId(long personId)
{
personId_ = personId;
setParameter("PersonId", std::to_string(personId));
}
long GetBodyPersonRequest::getDbId()const
{
return dbId_;
}
void GetBodyPersonRequest::setDbId(long dbId)
{
dbId_ = dbId;
setParameter("DbId", std::to_string(dbId));
}

84
facebody/src/model/GetBodyPersonResult.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/GetBodyPersonResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
GetBodyPersonResult::GetBodyPersonResult() :
ServiceResult()
{}
GetBodyPersonResult::GetBodyPersonResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetBodyPersonResult::~GetBodyPersonResult()
{}
void GetBodyPersonResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["TraceCount"].isNull())
data_.traceCount = std::stol(dataNode["TraceCount"].asString());
if(!dataNode["InstanceId"].isNull())
data_.instanceId = std::stol(dataNode["InstanceId"].asString());
if(!dataNode["DbId"].isNull())
data_.dbId = std::stol(dataNode["DbId"].asString());
if(!dataNode["Id"].isNull())
data_.id = std::stol(dataNode["Id"].asString());
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
auto allTraceListNode = dataNode["TraceList"]["Trace"];
for (auto dataNodeTraceListTrace : allTraceListNode)
{
Data::Trace traceObject;
if(!dataNodeTraceListTrace["ExtraData"].isNull())
traceObject.extraData = dataNodeTraceListTrace["ExtraData"].asString();
if(!dataNodeTraceListTrace["Id"].isNull())
traceObject.id = std::stol(dataNodeTraceListTrace["Id"].asString());
data_.traceList.push_back(traceObject);
}
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
std::string GetBodyPersonResult::getMessage()const
{
return message_;
}
GetBodyPersonResult::Data GetBodyPersonResult::getData()const
{
return data_;
}
std::string GetBodyPersonResult::getCode()const
{
return code_;
}

51
facebody/src/model/GetRealPersonVerificationResultRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/GetRealPersonVerificationResultRequest.h>
using AlibabaCloud::Facebody::Model::GetRealPersonVerificationResultRequest;
GetRealPersonVerificationResultRequest::GetRealPersonVerificationResultRequest() :
RpcServiceRequest("facebody", "2019-12-30", "GetRealPersonVerificationResult")
{
setMethod(HttpRequest::Method::Post);
}
GetRealPersonVerificationResultRequest::~GetRealPersonVerificationResultRequest()
{}
std::string GetRealPersonVerificationResultRequest::getVerificationToken()const
{
return verificationToken_;
}
void GetRealPersonVerificationResultRequest::setVerificationToken(const std::string& verificationToken)
{
verificationToken_ = verificationToken;
setBodyParameter("VerificationToken", verificationToken);
}
std::string GetRealPersonVerificationResultRequest::getMaterialHash()const
{
return materialHash_;
}
void GetRealPersonVerificationResultRequest::setMaterialHash(const std::string& materialHash)
{
materialHash_ = materialHash;
setBodyParameter("MaterialHash", materialHash);
}

77
facebody/src/model/GetRealPersonVerificationResultResult.cc Normal file
View File

@@ -0,0 +1,77 @@
/*
* 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 <alibabacloud/facebody/model/GetRealPersonVerificationResultResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
GetRealPersonVerificationResultResult::GetRealPersonVerificationResultResult() :
ServiceResult()
{}
GetRealPersonVerificationResultResult::GetRealPersonVerificationResultResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetRealPersonVerificationResultResult::~GetRealPersonVerificationResultResult()
{}
void GetRealPersonVerificationResultResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Pass"].isNull())
data_.pass = dataNode["Pass"].asString() == "true";
if(!dataNode["MaterialMatch"].isNull())
data_.materialMatch = dataNode["MaterialMatch"].asString();
if(!dataNode["IdentityInfo"].isNull())
data_.identityInfo = dataNode["IdentityInfo"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["ErrorMessage"].isNull())
errorMessage_ = value["ErrorMessage"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
GetRealPersonVerificationResultResult::Data GetRealPersonVerificationResultResult::getData()const
{
return data_;
}
std::string GetRealPersonVerificationResultResult::getErrorMessage()const
{
return errorMessage_;
}
std::string GetRealPersonVerificationResultResult::getCode()const
{
return code_;
}
bool GetRealPersonVerificationResultResult::getSuccess()const
{
return success_;
}

51
facebody/src/model/ListBodyDbsRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/ListBodyDbsRequest.h>
using AlibabaCloud::Facebody::Model::ListBodyDbsRequest;
ListBodyDbsRequest::ListBodyDbsRequest() :
RpcServiceRequest("facebody", "2019-12-30", "ListBodyDbs")
{
setMethod(HttpRequest::Method::Get);
}
ListBodyDbsRequest::~ListBodyDbsRequest()
{}
long ListBodyDbsRequest::getLimit()const
{
return limit_;
}
void ListBodyDbsRequest::setLimit(long limit)
{
limit_ = limit;
setParameter("Limit", std::to_string(limit));
}
long ListBodyDbsRequest::getOffset()const
{
return offset_;
}
void ListBodyDbsRequest::setOffset(long offset)
{
offset_ = offset;
setParameter("Offset", std::to_string(offset));
}

76
facebody/src/model/ListBodyDbsResult.cc Normal file
View File

@@ -0,0 +1,76 @@
/*
* 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 <alibabacloud/facebody/model/ListBodyDbsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
ListBodyDbsResult::ListBodyDbsResult() :
ServiceResult()
{}
ListBodyDbsResult::ListBodyDbsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListBodyDbsResult::~ListBodyDbsResult()
{}
void ListBodyDbsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Total"].isNull())
data_.total = std::stol(dataNode["Total"].asString());
auto allDbListNode = dataNode["DbList"]["DbListItem"];
for (auto dataNodeDbListDbListItem : allDbListNode)
{
Data::DbListItem dbListItemObject;
if(!dataNodeDbListDbListItem["Id"].isNull())
dbListItemObject.id = std::stol(dataNodeDbListDbListItem["Id"].asString());
if(!dataNodeDbListDbListItem["Name"].isNull())
dbListItemObject.name = dataNodeDbListDbListItem["Name"].asString();
data_.dbList.push_back(dbListItemObject);
}
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
std::string ListBodyDbsResult::getMessage()const
{
return message_;
}
ListBodyDbsResult::Data ListBodyDbsResult::getData()const
{
return data_;
}
std::string ListBodyDbsResult::getCode()const
{
return code_;
}

62
facebody/src/model/ListBodyPersonRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/ListBodyPersonRequest.h>
using AlibabaCloud::Facebody::Model::ListBodyPersonRequest;
ListBodyPersonRequest::ListBodyPersonRequest() :
RpcServiceRequest("facebody", "2019-12-30", "ListBodyPerson")
{
setMethod(HttpRequest::Method::Get);
}
ListBodyPersonRequest::~ListBodyPersonRequest()
{}
long ListBodyPersonRequest::getLimit()const
{
return limit_;
}
void ListBodyPersonRequest::setLimit(long limit)
{
limit_ = limit;
setParameter("Limit", std::to_string(limit));
}
long ListBodyPersonRequest::getOffset()const
{
return offset_;
}
void ListBodyPersonRequest::setOffset(long offset)
{
offset_ = offset;
setParameter("Offset", std::to_string(offset));
}
long ListBodyPersonRequest::getDbId()const
{
return dbId_;
}
void ListBodyPersonRequest::setDbId(long dbId)
{
dbId_ = dbId;
setParameter("DbId", std::to_string(dbId));
}

82
facebody/src/model/ListBodyPersonResult.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/ListBodyPersonResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
ListBodyPersonResult::ListBodyPersonResult() :
ServiceResult()
{}
ListBodyPersonResult::ListBodyPersonResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListBodyPersonResult::~ListBodyPersonResult()
{}
void ListBodyPersonResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Total"].isNull())
data_.total = std::stol(dataNode["Total"].asString());
auto allPersonListNode = dataNode["PersonList"]["Person"];
for (auto dataNodePersonListPerson : allPersonListNode)
{
Data::Person personObject;
if(!dataNodePersonListPerson["TraceCount"].isNull())
personObject.traceCount = std::stol(dataNodePersonListPerson["TraceCount"].asString());
if(!dataNodePersonListPerson["InstanceId"].isNull())
personObject.instanceId = std::stol(dataNodePersonListPerson["InstanceId"].asString());
if(!dataNodePersonListPerson["DbId"].isNull())
personObject.dbId = std::stol(dataNodePersonListPerson["DbId"].asString());
if(!dataNodePersonListPerson["Id"].isNull())
personObject.id = std::stol(dataNodePersonListPerson["Id"].asString());
if(!dataNodePersonListPerson["Name"].isNull())
personObject.name = dataNodePersonListPerson["Name"].asString();
data_.personList.push_back(personObject);
}
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
std::string ListBodyPersonResult::getMessage()const
{
return message_;
}
ListBodyPersonResult::Data ListBodyPersonResult::getData()const
{
return data_;
}
std::string ListBodyPersonResult::getCode()const
{
return code_;
}

73
facebody/src/model/SearchBodyTraceRequest.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/SearchBodyTraceRequest.h>
using AlibabaCloud::Facebody::Model::SearchBodyTraceRequest;
SearchBodyTraceRequest::SearchBodyTraceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "SearchBodyTrace")
{
setMethod(HttpRequest::Method::Post);
}
SearchBodyTraceRequest::~SearchBodyTraceRequest()
{}
float SearchBodyTraceRequest::getMinScore()const
{
return minScore_;
}
void SearchBodyTraceRequest::setMinScore(float minScore)
{
minScore_ = minScore;
setBodyParameter("MinScore", std::to_string(minScore));
}
long SearchBodyTraceRequest::getLimit()const
{
return limit_;
}
void SearchBodyTraceRequest::setLimit(long limit)
{
limit_ = limit;
setBodyParameter("Limit", std::to_string(limit));
}
Array SearchBodyTraceRequest::getImages()const
{
return images_;
}
void SearchBodyTraceRequest::setImages(const Array& images)
{
images_ = images;
setBodyParameter("Images", std::to_string(images));
}
long SearchBodyTraceRequest::getDbId()const
{
return dbId_;
}
void SearchBodyTraceRequest::setDbId(long dbId)
{
dbId_ = dbId;
setBodyParameter("DbId", std::to_string(dbId));
}

80
facebody/src/model/SearchBodyTraceResult.cc Normal file
View File

@@ -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 <alibabacloud/facebody/model/SearchBodyTraceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
SearchBodyTraceResult::SearchBodyTraceResult() :
ServiceResult()
{}
SearchBodyTraceResult::SearchBodyTraceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchBodyTraceResult::~SearchBodyTraceResult()
{}
void SearchBodyTraceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allMatchListNode = dataNode["MatchList"]["Trace"];
for (auto dataNodeMatchListTrace : allMatchListNode)
{
Data::Trace traceObject;
if(!dataNodeMatchListTrace["Score"].isNull())
traceObject.score = std::stof(dataNodeMatchListTrace["Score"].asString());
if(!dataNodeMatchListTrace["PersonId"].isNull())
traceObject.personId = std::stol(dataNodeMatchListTrace["PersonId"].asString());
if(!dataNodeMatchListTrace["TraceId"].isNull())
traceObject.traceId = std::stol(dataNodeMatchListTrace["TraceId"].asString());
if(!dataNodeMatchListTrace["DbId"].isNull())
traceObject.dbId = std::stol(dataNodeMatchListTrace["DbId"].asString());
if(!dataNodeMatchListTrace["ExtraData"].isNull())
traceObject.extraData = dataNodeMatchListTrace["ExtraData"].asString();
data_.matchList.push_back(traceObject);
}
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
}
std::string SearchBodyTraceResult::getMessage()const
{
return message_;
}
SearchBodyTraceResult::Data SearchBodyTraceResult::getData()const
{
return data_;
}
std::string SearchBodyTraceResult::getCode()const
{
return code_;
}