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

Add monitor related.

Browse Source
This commit is contained in:
sdk-team
2020-05-25 16:13:07 +08:00
parent 07721caa35
commit 670f1bb324
45 changed files with 2633 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2020-05-25 Version: 1.36.430
- Add monitor related.
2020-05-23 Version: 1.36.429
- Generated 2015-01-01 for `R-kvstore`.
- Add ModifyResourceGroup API.

2
VERSION
View File

@@ -1 +1 @@
1.36.429
1.36.430

36
vcs/CMakeLists.txt
View File

@@ -23,51 +23,83 @@ set(vcs_public_header
set(vcs_public_header_model
include/alibabacloud/vcs/model/AddDeviceRequest.h
include/alibabacloud/vcs/model/AddDeviceResult.h
include/alibabacloud/vcs/model/AddMonitorRequest.h
include/alibabacloud/vcs/model/AddMonitorResult.h
include/alibabacloud/vcs/model/CreateCorpRequest.h
include/alibabacloud/vcs/model/CreateCorpResult.h
include/alibabacloud/vcs/model/DeleteDeviceRequest.h
include/alibabacloud/vcs/model/DeleteDeviceResult.h
include/alibabacloud/vcs/model/GetBodyOptionsRequest.h
include/alibabacloud/vcs/model/GetBodyOptionsResult.h
include/alibabacloud/vcs/model/GetDeviceLiveUrlRequest.h
include/alibabacloud/vcs/model/GetDeviceLiveUrlResult.h
include/alibabacloud/vcs/model/GetDeviceVideoUrlRequest.h
include/alibabacloud/vcs/model/GetDeviceVideoUrlResult.h
include/alibabacloud/vcs/model/GetFaceOptionsRequest.h
include/alibabacloud/vcs/model/GetFaceOptionsResult.h
include/alibabacloud/vcs/model/GetInventoryRequest.h
include/alibabacloud/vcs/model/GetInventoryResult.h
include/alibabacloud/vcs/model/GetMonitorResultRequest.h
include/alibabacloud/vcs/model/GetMonitorResultResult.h
include/alibabacloud/vcs/model/ListCorpsRequest.h
include/alibabacloud/vcs/model/ListCorpsResult.h
include/alibabacloud/vcs/model/ListDevicesRequest.h
include/alibabacloud/vcs/model/ListDevicesResult.h
include/alibabacloud/vcs/model/RecognizeImageRequest.h
include/alibabacloud/vcs/model/RecognizeImageResult.h
include/alibabacloud/vcs/model/SearchBodyRequest.h
include/alibabacloud/vcs/model/SearchBodyResult.h
include/alibabacloud/vcs/model/SearchFaceRequest.h
include/alibabacloud/vcs/model/SearchFaceResult.h
include/alibabacloud/vcs/model/StopMonitorRequest.h
include/alibabacloud/vcs/model/StopMonitorResult.h
include/alibabacloud/vcs/model/UpdateCorpRequest.h
include/alibabacloud/vcs/model/UpdateCorpResult.h
include/alibabacloud/vcs/model/UpdateDeviceRequest.h
include/alibabacloud/vcs/model/UpdateDeviceResult.h )
include/alibabacloud/vcs/model/UpdateDeviceResult.h
include/alibabacloud/vcs/model/UpdateMonitorRequest.h
include/alibabacloud/vcs/model/UpdateMonitorResult.h )
set(vcs_src
src/VcsClient.cc
src/model/AddDeviceRequest.cc
src/model/AddDeviceResult.cc
src/model/AddMonitorRequest.cc
src/model/AddMonitorResult.cc
src/model/CreateCorpRequest.cc
src/model/CreateCorpResult.cc
src/model/DeleteDeviceRequest.cc
src/model/DeleteDeviceResult.cc
src/model/GetBodyOptionsRequest.cc
src/model/GetBodyOptionsResult.cc
src/model/GetDeviceLiveUrlRequest.cc
src/model/GetDeviceLiveUrlResult.cc
src/model/GetDeviceVideoUrlRequest.cc
src/model/GetDeviceVideoUrlResult.cc
src/model/GetFaceOptionsRequest.cc
src/model/GetFaceOptionsResult.cc
src/model/GetInventoryRequest.cc
src/model/GetInventoryResult.cc
src/model/GetMonitorResultRequest.cc
src/model/GetMonitorResultResult.cc
src/model/ListCorpsRequest.cc
src/model/ListCorpsResult.cc
src/model/ListDevicesRequest.cc
src/model/ListDevicesResult.cc
src/model/RecognizeImageRequest.cc
src/model/RecognizeImageResult.cc
src/model/SearchBodyRequest.cc
src/model/SearchBodyResult.cc
src/model/SearchFaceRequest.cc
src/model/SearchFaceResult.cc
src/model/StopMonitorRequest.cc
src/model/StopMonitorResult.cc
src/model/UpdateCorpRequest.cc
src/model/UpdateCorpResult.cc
src/model/UpdateDeviceRequest.cc
src/model/UpdateDeviceResult.cc )
src/model/UpdateDeviceResult.cc
src/model/UpdateMonitorRequest.cc
src/model/UpdateMonitorResult.cc )
add_library(vcs ${LIB_TYPE}
${vcs_public_header}

64
vcs/include/alibabacloud/vcs/VcsClient.h
View File

@@ -24,26 +24,42 @@
#include "VcsExport.h"
#include "model/AddDeviceRequest.h"
#include "model/AddDeviceResult.h"
#include "model/AddMonitorRequest.h"
#include "model/AddMonitorResult.h"
#include "model/CreateCorpRequest.h"
#include "model/CreateCorpResult.h"
#include "model/DeleteDeviceRequest.h"
#include "model/DeleteDeviceResult.h"
#include "model/GetBodyOptionsRequest.h"
#include "model/GetBodyOptionsResult.h"
#include "model/GetDeviceLiveUrlRequest.h"
#include "model/GetDeviceLiveUrlResult.h"
#include "model/GetDeviceVideoUrlRequest.h"
#include "model/GetDeviceVideoUrlResult.h"
#include "model/GetFaceOptionsRequest.h"
#include "model/GetFaceOptionsResult.h"
#include "model/GetInventoryRequest.h"
#include "model/GetInventoryResult.h"
#include "model/GetMonitorResultRequest.h"
#include "model/GetMonitorResultResult.h"
#include "model/ListCorpsRequest.h"
#include "model/ListCorpsResult.h"
#include "model/ListDevicesRequest.h"
#include "model/ListDevicesResult.h"
#include "model/RecognizeImageRequest.h"
#include "model/RecognizeImageResult.h"
#include "model/SearchBodyRequest.h"
#include "model/SearchBodyResult.h"
#include "model/SearchFaceRequest.h"
#include "model/SearchFaceResult.h"
#include "model/StopMonitorRequest.h"
#include "model/StopMonitorResult.h"
#include "model/UpdateCorpRequest.h"
#include "model/UpdateCorpResult.h"
#include "model/UpdateDeviceRequest.h"
#include "model/UpdateDeviceResult.h"
#include "model/UpdateMonitorRequest.h"
#include "model/UpdateMonitorResult.h"
namespace AlibabaCloud
@@ -56,18 +72,33 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::AddDeviceResult> AddDeviceOutcome;
typedef std::future<AddDeviceOutcome> AddDeviceOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::AddDeviceRequest&, const AddDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddDeviceAsyncHandler;
typedef Outcome<Error, Model::AddMonitorResult> AddMonitorOutcome;
typedef std::future<AddMonitorOutcome> AddMonitorOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::AddMonitorRequest&, const AddMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddMonitorAsyncHandler;
typedef Outcome<Error, Model::CreateCorpResult> CreateCorpOutcome;
typedef std::future<CreateCorpOutcome> CreateCorpOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::CreateCorpRequest&, const CreateCorpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCorpAsyncHandler;
typedef Outcome<Error, Model::DeleteDeviceResult> DeleteDeviceOutcome;
typedef std::future<DeleteDeviceOutcome> DeleteDeviceOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::DeleteDeviceRequest&, const DeleteDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDeviceAsyncHandler;
typedef Outcome<Error, Model::GetBodyOptionsResult> GetBodyOptionsOutcome;
typedef std::future<GetBodyOptionsOutcome> GetBodyOptionsOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetBodyOptionsRequest&, const GetBodyOptionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBodyOptionsAsyncHandler;
typedef Outcome<Error, Model::GetDeviceLiveUrlResult> GetDeviceLiveUrlOutcome;
typedef std::future<GetDeviceLiveUrlOutcome> GetDeviceLiveUrlOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetDeviceLiveUrlRequest&, const GetDeviceLiveUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDeviceLiveUrlAsyncHandler;
typedef Outcome<Error, Model::GetDeviceVideoUrlResult> GetDeviceVideoUrlOutcome;
typedef std::future<GetDeviceVideoUrlOutcome> GetDeviceVideoUrlOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetDeviceVideoUrlRequest&, const GetDeviceVideoUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDeviceVideoUrlAsyncHandler;
typedef Outcome<Error, Model::GetFaceOptionsResult> GetFaceOptionsOutcome;
typedef std::future<GetFaceOptionsOutcome> GetFaceOptionsOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetFaceOptionsRequest&, const GetFaceOptionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceOptionsAsyncHandler;
typedef Outcome<Error, Model::GetInventoryResult> GetInventoryOutcome;
typedef std::future<GetInventoryOutcome> GetInventoryOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetInventoryRequest&, const GetInventoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInventoryAsyncHandler;
typedef Outcome<Error, Model::GetMonitorResultResult> GetMonitorResultOutcome;
typedef std::future<GetMonitorResultOutcome> GetMonitorResultOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetMonitorResultRequest&, const GetMonitorResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMonitorResultAsyncHandler;
typedef Outcome<Error, Model::ListCorpsResult> ListCorpsOutcome;
typedef std::future<ListCorpsOutcome> ListCorpsOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::ListCorpsRequest&, const ListCorpsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCorpsAsyncHandler;
@@ -77,15 +108,24 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RecognizeImageResult> RecognizeImageOutcome;
typedef std::future<RecognizeImageOutcome> RecognizeImageOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::RecognizeImageRequest&, const RecognizeImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeImageAsyncHandler;
typedef Outcome<Error, Model::SearchBodyResult> SearchBodyOutcome;
typedef std::future<SearchBodyOutcome> SearchBodyOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::SearchBodyRequest&, const SearchBodyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchBodyAsyncHandler;
typedef Outcome<Error, Model::SearchFaceResult> SearchFaceOutcome;
typedef std::future<SearchFaceOutcome> SearchFaceOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::SearchFaceRequest&, const SearchFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchFaceAsyncHandler;
typedef Outcome<Error, Model::StopMonitorResult> StopMonitorOutcome;
typedef std::future<StopMonitorOutcome> StopMonitorOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::StopMonitorRequest&, const StopMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopMonitorAsyncHandler;
typedef Outcome<Error, Model::UpdateCorpResult> UpdateCorpOutcome;
typedef std::future<UpdateCorpOutcome> UpdateCorpOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::UpdateCorpRequest&, const UpdateCorpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCorpAsyncHandler;
typedef Outcome<Error, Model::UpdateDeviceResult> UpdateDeviceOutcome;
typedef std::future<UpdateDeviceOutcome> UpdateDeviceOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::UpdateDeviceRequest&, const UpdateDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDeviceAsyncHandler;
typedef Outcome<Error, Model::UpdateMonitorResult> UpdateMonitorOutcome;
typedef std::future<UpdateMonitorOutcome> UpdateMonitorOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::UpdateMonitorRequest&, const UpdateMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMonitorAsyncHandler;
VcsClient(const Credentials &credentials, const ClientConfiguration &configuration);
VcsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -94,18 +134,33 @@ namespace AlibabaCloud
AddDeviceOutcome addDevice(const Model::AddDeviceRequest &request)const;
void addDeviceAsync(const Model::AddDeviceRequest& request, const AddDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddDeviceOutcomeCallable addDeviceCallable(const Model::AddDeviceRequest& request) const;
AddMonitorOutcome addMonitor(const Model::AddMonitorRequest &request)const;
void addMonitorAsync(const Model::AddMonitorRequest& request, const AddMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddMonitorOutcomeCallable addMonitorCallable(const Model::AddMonitorRequest& request) const;
CreateCorpOutcome createCorp(const Model::CreateCorpRequest &request)const;
void createCorpAsync(const Model::CreateCorpRequest& request, const CreateCorpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCorpOutcomeCallable createCorpCallable(const Model::CreateCorpRequest& request) const;
DeleteDeviceOutcome deleteDevice(const Model::DeleteDeviceRequest &request)const;
void deleteDeviceAsync(const Model::DeleteDeviceRequest& request, const DeleteDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDeviceOutcomeCallable deleteDeviceCallable(const Model::DeleteDeviceRequest& request) const;
GetBodyOptionsOutcome getBodyOptions(const Model::GetBodyOptionsRequest &request)const;
void getBodyOptionsAsync(const Model::GetBodyOptionsRequest& request, const GetBodyOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetBodyOptionsOutcomeCallable getBodyOptionsCallable(const Model::GetBodyOptionsRequest& request) const;
GetDeviceLiveUrlOutcome getDeviceLiveUrl(const Model::GetDeviceLiveUrlRequest &request)const;
void getDeviceLiveUrlAsync(const Model::GetDeviceLiveUrlRequest& request, const GetDeviceLiveUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetDeviceLiveUrlOutcomeCallable getDeviceLiveUrlCallable(const Model::GetDeviceLiveUrlRequest& request) const;
GetDeviceVideoUrlOutcome getDeviceVideoUrl(const Model::GetDeviceVideoUrlRequest &request)const;
void getDeviceVideoUrlAsync(const Model::GetDeviceVideoUrlRequest& request, const GetDeviceVideoUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetDeviceVideoUrlOutcomeCallable getDeviceVideoUrlCallable(const Model::GetDeviceVideoUrlRequest& request) const;
GetFaceOptionsOutcome getFaceOptions(const Model::GetFaceOptionsRequest &request)const;
void getFaceOptionsAsync(const Model::GetFaceOptionsRequest& request, const GetFaceOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetFaceOptionsOutcomeCallable getFaceOptionsCallable(const Model::GetFaceOptionsRequest& request) const;
GetInventoryOutcome getInventory(const Model::GetInventoryRequest &request)const;
void getInventoryAsync(const Model::GetInventoryRequest& request, const GetInventoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetInventoryOutcomeCallable getInventoryCallable(const Model::GetInventoryRequest& request) const;
GetMonitorResultOutcome getMonitorResult(const Model::GetMonitorResultRequest &request)const;
void getMonitorResultAsync(const Model::GetMonitorResultRequest& request, const GetMonitorResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetMonitorResultOutcomeCallable getMonitorResultCallable(const Model::GetMonitorResultRequest& request) const;
ListCorpsOutcome listCorps(const Model::ListCorpsRequest &request)const;
void listCorpsAsync(const Model::ListCorpsRequest& request, const ListCorpsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListCorpsOutcomeCallable listCorpsCallable(const Model::ListCorpsRequest& request) const;
@@ -115,15 +170,24 @@ namespace AlibabaCloud
RecognizeImageOutcome recognizeImage(const Model::RecognizeImageRequest &request)const;
void recognizeImageAsync(const Model::RecognizeImageRequest& request, const RecognizeImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeImageOutcomeCallable recognizeImageCallable(const Model::RecognizeImageRequest& request) const;
SearchBodyOutcome searchBody(const Model::SearchBodyRequest &request)const;
void searchBodyAsync(const Model::SearchBodyRequest& request, const SearchBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchBodyOutcomeCallable searchBodyCallable(const Model::SearchBodyRequest& 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;
StopMonitorOutcome stopMonitor(const Model::StopMonitorRequest &request)const;
void stopMonitorAsync(const Model::StopMonitorRequest& request, const StopMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopMonitorOutcomeCallable stopMonitorCallable(const Model::StopMonitorRequest& request) const;
UpdateCorpOutcome updateCorp(const Model::UpdateCorpRequest &request)const;
void updateCorpAsync(const Model::UpdateCorpRequest& request, const UpdateCorpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateCorpOutcomeCallable updateCorpCallable(const Model::UpdateCorpRequest& request) const;
UpdateDeviceOutcome updateDevice(const Model::UpdateDeviceRequest &request)const;
void updateDeviceAsync(const Model::UpdateDeviceRequest& request, const UpdateDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateDeviceOutcomeCallable updateDeviceCallable(const Model::UpdateDeviceRequest& request) const;
UpdateMonitorOutcome updateMonitor(const Model::UpdateMonitorRequest &request)const;
void updateMonitorAsync(const Model::UpdateMonitorRequest& request, const UpdateMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateMonitorOutcomeCallable updateMonitorCallable(const Model::UpdateMonitorRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

6
vcs/include/alibabacloud/vcs/model/AddDeviceRequest.h
View File

@@ -41,10 +41,10 @@ namespace AlibabaCloud
void setCorpId(const std::string& corpId);
std::string getGbId()const;
void setGbId(const std::string& gbId);
std::string getBitRate()const;
void setBitRate(const std::string& bitRate);
std::string getDeviceDirection()const;
void setDeviceDirection(const std::string& deviceDirection);
std::string getDeviceRate()const;
void setDeviceRate(const std::string& deviceRate);
std::string getDeviceAddress()const;
void setDeviceAddress(const std::string& deviceAddress);
std::string getDeviceType()const;
@@ -60,8 +60,8 @@ namespace AlibabaCloud
std::string deviceSite_;
std::string corpId_;
std::string gbId_;
std::string bitRate_;
std::string deviceDirection_;
std::string deviceRate_;
std::string deviceAddress_;
std::string deviceType_;
std::string deviceResolution_;

57
vcs/include/alibabacloud/vcs/model/AddMonitorRequest.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_VCS_MODEL_ADDMONITORREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_ADDMONITORREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT AddMonitorRequest : public RpcServiceRequest
{
public:
AddMonitorRequest();
~AddMonitorRequest();
std::string getMonitorType()const;
void setMonitorType(const std::string& monitorType);
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getDescription()const;
void setDescription(const std::string& description);
int getBatchIndicator()const;
void setBatchIndicator(int batchIndicator);
private:
std::string monitorType_;
std::string corpId_;
std::string description_;
int batchIndicator_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_ADDMONITORREQUEST_H_

55
vcs/include/alibabacloud/vcs/model/AddMonitorResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_VCS_MODEL_ADDMONITORRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_ADDMONITORRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT AddMonitorResult : public ServiceResult
{
public:
AddMonitorResult();
explicit AddMonitorResult(const std::string &payload);
~AddMonitorResult();
std::string getMessage()const;
std::string getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_ADDMONITORRESULT_H_

48
vcs/include/alibabacloud/vcs/model/GetBodyOptionsRequest.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_VCS_MODEL_GETBODYOPTIONSREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_GETBODYOPTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetBodyOptionsRequest : public RpcServiceRequest
{
public:
GetBodyOptionsRequest();
~GetBodyOptionsRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
private:
std::string corpId_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETBODYOPTIONSREQUEST_H_

66
vcs/include/alibabacloud/vcs/model/GetBodyOptionsResult.h 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.
*/
#ifndef ALIBABACLOUD_VCS_MODEL_GETBODYOPTIONSRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_GETBODYOPTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetBodyOptionsResult : public ServiceResult
{
public:
struct DataItem
{
struct OptionListItem
{
std::string key;
std::string name;
};
std::vector<DataItem::OptionListItem> optionList;
std::string key;
std::string name;
};
GetBodyOptionsResult();
explicit GetBodyOptionsResult(const std::string &payload);
~GetBodyOptionsResult();
std::string getMessage()const;
std::vector<DataItem> getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<DataItem> data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETBODYOPTIONSRESULT_H_

3
vcs/include/alibabacloud/vcs/model/GetDeviceLiveUrlRequest.h
View File

@@ -39,13 +39,10 @@ namespace AlibabaCloud
void setCorpId(const std::string& corpId);
std::string getGbId()const;
void setGbId(const std::string& gbId);
long getDeviceId()const;
void setDeviceId(long deviceId);
private:
std::string corpId_;
std::string gbId_;
long deviceId_;
};
}

57
vcs/include/alibabacloud/vcs/model/GetDeviceVideoUrlRequest.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_VCS_MODEL_GETDEVICEVIDEOURLREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_GETDEVICEVIDEOURLREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetDeviceVideoUrlRequest : public RpcServiceRequest
{
public:
GetDeviceVideoUrlRequest();
~GetDeviceVideoUrlRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getGbId()const;
void setGbId(const std::string& gbId);
long getEndTime()const;
void setEndTime(long endTime);
long getStartTime()const;
void setStartTime(long startTime);
private:
std::string corpId_;
std::string gbId_;
long endTime_;
long startTime_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETDEVICEVIDEOURLREQUEST_H_

55
vcs/include/alibabacloud/vcs/model/GetDeviceVideoUrlResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_VCS_MODEL_GETDEVICEVIDEOURLRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_GETDEVICEVIDEOURLRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetDeviceVideoUrlResult : public ServiceResult
{
public:
GetDeviceVideoUrlResult();
explicit GetDeviceVideoUrlResult(const std::string &payload);
~GetDeviceVideoUrlResult();
std::string getMessage()const;
std::string getCode()const;
std::string getUrl()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string code_;
std::string url_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETDEVICEVIDEOURLRESULT_H_

48
vcs/include/alibabacloud/vcs/model/GetFaceOptionsRequest.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_VCS_MODEL_GETFACEOPTIONSREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_GETFACEOPTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetFaceOptionsRequest : public RpcServiceRequest
{
public:
GetFaceOptionsRequest();
~GetFaceOptionsRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
private:
std::string corpId_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETFACEOPTIONSREQUEST_H_

66
vcs/include/alibabacloud/vcs/model/GetFaceOptionsResult.h 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.
*/
#ifndef ALIBABACLOUD_VCS_MODEL_GETFACEOPTIONSRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_GETFACEOPTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetFaceOptionsResult : public ServiceResult
{
public:
struct DataItem
{
struct OptionListItem
{
std::string key;
std::string name;
};
std::vector<DataItem::OptionListItem> optionList;
std::string key;
std::string name;
};
GetFaceOptionsResult();
explicit GetFaceOptionsResult(const std::string &payload);
~GetFaceOptionsResult();
std::string getMessage()const;
std::vector<DataItem> getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<DataItem> data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETFACEOPTIONSRESULT_H_

60
vcs/include/alibabacloud/vcs/model/GetMonitorResultRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetMonitorResultRequest : public RpcServiceRequest
{
public:
GetMonitorResultRequest();
~GetMonitorResultRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
long getEndTime()const;
void setEndTime(long endTime);
long getStartTime()const;
void setStartTime(long startTime);
std::string getMinRecordId()const;
void setMinRecordId(const std::string& minRecordId);
std::string getTaskId()const;
void setTaskId(const std::string& taskId);
private:
std::string corpId_;
long endTime_;
long startTime_;
std::string minRecordId_;
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTREQUEST_H_

78
vcs/include/alibabacloud/vcs/model/GetMonitorResultResult.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetMonitorResultResult : public ServiceResult
{
public:
struct Data
{
std::string maxRecordId;
};
struct RecordsItem
{
std::string shotPicUrl;
std::string gbId;
std::string monitorPicUrl;
std::string shotTime;
};
GetMonitorResultResult();
explicit GetMonitorResultResult(const std::string &payload);
~GetMonitorResultResult();
std::string getScore()const;
std::string getMessage()const;
std::string getRightBottomX()const;
std::string getRightBottomY()const;
Data getData()const;
std::string getLeftTopY()const;
std::vector<RecordsItem> getRecords()const;
std::string getCode()const;
std::string getLeftTopX()const;
protected:
void parse(const std::string &payload);
private:
std::string score_;
std::string message_;
std::string rightBottomX_;
std::string rightBottomY_;
Data data_;
std::string leftTopY_;
std::vector<RecordsItem> records_;
std::string code_;
std::string leftTopX_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTRESULT_H_

2
vcs/include/alibabacloud/vcs/model/ListDevicesResult.h
View File

@@ -49,7 +49,7 @@ namespace AlibabaCloud
std::string sipPassword;
std::string deviceType;
std::string deviceAddress;
std::string gBid;
std::string gbId;
std::string bitRate;
std::string deviceSite;
std::string sipServerPort;

66
vcs/include/alibabacloud/vcs/model/SearchBodyRequest.h 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.
*/
#ifndef ALIBABACLOUD_VCS_MODEL_SEARCHBODYREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_SEARCHBODYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT SearchBodyRequest : public RpcServiceRequest
{
public:
SearchBodyRequest();
~SearchBodyRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getGbId()const;
void setGbId(const std::string& gbId);
long getStartTimeStamp()const;
void setStartTimeStamp(long startTimeStamp);
long getEndTimeStamp()const;
void setEndTimeStamp(long endTimeStamp);
int getPageNo()const;
void setPageNo(int pageNo);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getOptionList()const;
void setOptionList(const std::string& optionList);
private:
std::string corpId_;
std::string gbId_;
long startTimeStamp_;
long endTimeStamp_;
int pageNo_;
int pageSize_;
std::string optionList_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_SEARCHBODYREQUEST_H_

74
vcs/include/alibabacloud/vcs/model/SearchBodyResult.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* 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_VCS_MODEL_SEARCHBODYRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_SEARCHBODYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT SearchBodyResult : public ServiceResult
{
public:
struct Data
{
struct Record
{
std::string targetImageUrl;
float score;
float rightBottomX;
float rightBottomY;
std::string gbId;
std::string imageUrl;
float leftTopY;
float leftTopX;
};
int totalCount;
int pageSize;
int totalPage;
int pageNo;
std::vector<Record> records;
};
SearchBodyResult();
explicit SearchBodyResult(const std::string &payload);
~SearchBodyResult();
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_VCS_MODEL_SEARCHBODYRESULT_H_

48
vcs/include/alibabacloud/vcs/model/StopMonitorRequest.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_VCS_MODEL_STOPMONITORREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_STOPMONITORREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT StopMonitorRequest : public RpcServiceRequest
{
public:
StopMonitorRequest();
~StopMonitorRequest();
std::string getTaskId()const;
void setTaskId(const std::string& taskId);
private:
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_STOPMONITORREQUEST_H_

55
vcs/include/alibabacloud/vcs/model/StopMonitorResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_VCS_MODEL_STOPMONITORRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_STOPMONITORRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT StopMonitorResult : public ServiceResult
{
public:
StopMonitorResult();
explicit StopMonitorResult(const std::string &payload);
~StopMonitorResult();
std::string getMessage()const;
std::string getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_STOPMONITORRESULT_H_

6
vcs/include/alibabacloud/vcs/model/UpdateDeviceRequest.h
View File

@@ -41,10 +41,10 @@ namespace AlibabaCloud
void setCorpId(const std::string& corpId);
std::string getGbId()const;
void setGbId(const std::string& gbId);
std::string getBitRate()const;
void setBitRate(const std::string& bitRate);
std::string getDeviceDirection()const;
void setDeviceDirection(const std::string& deviceDirection);
std::string getDeviceRate()const;
void setDeviceRate(const std::string& deviceRate);
std::string getDeviceAddress()const;
void setDeviceAddress(const std::string& deviceAddress);
std::string getDeviceType()const;
@@ -60,8 +60,8 @@ namespace AlibabaCloud
std::string deviceSite_;
std::string corpId_;
std::string gbId_;
std::string bitRate_;
std::string deviceDirection_;
std::string deviceRate_;
std::string deviceAddress_;
std::string deviceType_;
std::string deviceResolution_;

78
vcs/include/alibabacloud/vcs/model/UpdateMonitorRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VCS_MODEL_UPDATEMONITORREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_UPDATEMONITORREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT UpdateMonitorRequest : public RpcServiceRequest
{
public:
UpdateMonitorRequest();
~UpdateMonitorRequest();
std::string getDeviceOperateType()const;
void setDeviceOperateType(const std::string& deviceOperateType);
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getPicList()const;
void setPicList(const std::string& picList);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getRuleName()const;
void setRuleName(const std::string& ruleName);
std::string getPicOperateType()const;
void setPicOperateType(const std::string& picOperateType);
std::string getAttributeName()const;
void setAttributeName(const std::string& attributeName);
std::string getAttributeValueList()const;
void setAttributeValueList(const std::string& attributeValueList);
std::string getDeviceList()const;
void setDeviceList(const std::string& deviceList);
std::string getAttributeOperateType()const;
void setAttributeOperateType(const std::string& attributeOperateType);
std::string getTaskId()const;
void setTaskId(const std::string& taskId);
private:
std::string deviceOperateType_;
std::string corpId_;
std::string picList_;
std::string description_;
std::string ruleName_;
std::string picOperateType_;
std::string attributeName_;
std::string attributeValueList_;
std::string deviceList_;
std::string attributeOperateType_;
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_UPDATEMONITORREQUEST_H_

55
vcs/include/alibabacloud/vcs/model/UpdateMonitorResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_VCS_MODEL_UPDATEMONITORRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_UPDATEMONITORRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT UpdateMonitorResult : public ServiceResult
{
public:
UpdateMonitorResult();
explicit UpdateMonitorResult(const std::string &payload);
~UpdateMonitorResult();
std::string getMessage()const;
std::string getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_UPDATEMONITORRESULT_H_

288
vcs/src/VcsClient.cc
View File

@@ -87,6 +87,42 @@ VcsClient::AddDeviceOutcomeCallable VcsClient::addDeviceCallable(const AddDevice
return task->get_future();
}
VcsClient::AddMonitorOutcome VcsClient::addMonitor(const AddMonitorRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddMonitorOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddMonitorOutcome(AddMonitorResult(outcome.result()));
else
return AddMonitorOutcome(outcome.error());
}
void VcsClient::addMonitorAsync(const AddMonitorRequest& request, const AddMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addMonitor(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::AddMonitorOutcomeCallable VcsClient::addMonitorCallable(const AddMonitorRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddMonitorOutcome()>>(
[this, request]()
{
return this->addMonitor(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::CreateCorpOutcome VcsClient::createCorp(const CreateCorpRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +195,42 @@ VcsClient::DeleteDeviceOutcomeCallable VcsClient::deleteDeviceCallable(const Del
return task->get_future();
}
VcsClient::GetBodyOptionsOutcome VcsClient::getBodyOptions(const GetBodyOptionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetBodyOptionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetBodyOptionsOutcome(GetBodyOptionsResult(outcome.result()));
else
return GetBodyOptionsOutcome(outcome.error());
}
void VcsClient::getBodyOptionsAsync(const GetBodyOptionsRequest& request, const GetBodyOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getBodyOptions(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::GetBodyOptionsOutcomeCallable VcsClient::getBodyOptionsCallable(const GetBodyOptionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetBodyOptionsOutcome()>>(
[this, request]()
{
return this->getBodyOptions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::GetDeviceLiveUrlOutcome VcsClient::getDeviceLiveUrl(const GetDeviceLiveUrlRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -195,6 +267,78 @@ VcsClient::GetDeviceLiveUrlOutcomeCallable VcsClient::getDeviceLiveUrlCallable(c
return task->get_future();
}
VcsClient::GetDeviceVideoUrlOutcome VcsClient::getDeviceVideoUrl(const GetDeviceVideoUrlRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetDeviceVideoUrlOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetDeviceVideoUrlOutcome(GetDeviceVideoUrlResult(outcome.result()));
else
return GetDeviceVideoUrlOutcome(outcome.error());
}
void VcsClient::getDeviceVideoUrlAsync(const GetDeviceVideoUrlRequest& request, const GetDeviceVideoUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getDeviceVideoUrl(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::GetDeviceVideoUrlOutcomeCallable VcsClient::getDeviceVideoUrlCallable(const GetDeviceVideoUrlRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetDeviceVideoUrlOutcome()>>(
[this, request]()
{
return this->getDeviceVideoUrl(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::GetFaceOptionsOutcome VcsClient::getFaceOptions(const GetFaceOptionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetFaceOptionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetFaceOptionsOutcome(GetFaceOptionsResult(outcome.result()));
else
return GetFaceOptionsOutcome(outcome.error());
}
void VcsClient::getFaceOptionsAsync(const GetFaceOptionsRequest& request, const GetFaceOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getFaceOptions(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::GetFaceOptionsOutcomeCallable VcsClient::getFaceOptionsCallable(const GetFaceOptionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetFaceOptionsOutcome()>>(
[this, request]()
{
return this->getFaceOptions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::GetInventoryOutcome VcsClient::getInventory(const GetInventoryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +375,42 @@ VcsClient::GetInventoryOutcomeCallable VcsClient::getInventoryCallable(const Get
return task->get_future();
}
VcsClient::GetMonitorResultOutcome VcsClient::getMonitorResult(const GetMonitorResultRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetMonitorResultOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetMonitorResultOutcome(GetMonitorResultResult(outcome.result()));
else
return GetMonitorResultOutcome(outcome.error());
}
void VcsClient::getMonitorResultAsync(const GetMonitorResultRequest& request, const GetMonitorResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getMonitorResult(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::GetMonitorResultOutcomeCallable VcsClient::getMonitorResultCallable(const GetMonitorResultRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetMonitorResultOutcome()>>(
[this, request]()
{
return this->getMonitorResult(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::ListCorpsOutcome VcsClient::listCorps(const ListCorpsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +519,42 @@ VcsClient::RecognizeImageOutcomeCallable VcsClient::recognizeImageCallable(const
return task->get_future();
}
VcsClient::SearchBodyOutcome VcsClient::searchBody(const SearchBodyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchBodyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchBodyOutcome(SearchBodyResult(outcome.result()));
else
return SearchBodyOutcome(outcome.error());
}
void VcsClient::searchBodyAsync(const SearchBodyRequest& request, const SearchBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, searchBody(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::SearchBodyOutcomeCallable VcsClient::searchBodyCallable(const SearchBodyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchBodyOutcome()>>(
[this, request]()
{
return this->searchBody(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::SearchFaceOutcome VcsClient::searchFace(const SearchFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -375,6 +591,42 @@ VcsClient::SearchFaceOutcomeCallable VcsClient::searchFaceCallable(const SearchF
return task->get_future();
}
VcsClient::StopMonitorOutcome VcsClient::stopMonitor(const StopMonitorRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StopMonitorOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StopMonitorOutcome(StopMonitorResult(outcome.result()));
else
return StopMonitorOutcome(outcome.error());
}
void VcsClient::stopMonitorAsync(const StopMonitorRequest& request, const StopMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, stopMonitor(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::StopMonitorOutcomeCallable VcsClient::stopMonitorCallable(const StopMonitorRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StopMonitorOutcome()>>(
[this, request]()
{
return this->stopMonitor(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::UpdateCorpOutcome VcsClient::updateCorp(const UpdateCorpRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,3 +699,39 @@ VcsClient::UpdateDeviceOutcomeCallable VcsClient::updateDeviceCallable(const Upd
return task->get_future();
}
VcsClient::UpdateMonitorOutcome VcsClient::updateMonitor(const UpdateMonitorRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateMonitorOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateMonitorOutcome(UpdateMonitorResult(outcome.result()));
else
return UpdateMonitorOutcome(outcome.error());
}
void VcsClient::updateMonitorAsync(const UpdateMonitorRequest& request, const UpdateMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateMonitor(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::UpdateMonitorOutcomeCallable VcsClient::updateMonitorCallable(const UpdateMonitorRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateMonitorOutcome()>>(
[this, request]()
{
return this->updateMonitor(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

22
vcs/src/model/AddDeviceRequest.cc
View File

@@ -60,6 +60,17 @@ void AddDeviceRequest::setGbId(const std::string& gbId)
setBodyParameter("GbId", gbId);
}
std::string AddDeviceRequest::getBitRate()const
{
return bitRate_;
}
void AddDeviceRequest::setBitRate(const std::string& bitRate)
{
bitRate_ = bitRate;
setBodyParameter("BitRate", bitRate);
}
std::string AddDeviceRequest::getDeviceDirection()const
{
return deviceDirection_;
@@ -71,17 +82,6 @@ void AddDeviceRequest::setDeviceDirection(const std::string& deviceDirection)
setBodyParameter("DeviceDirection", deviceDirection);
}
std::string AddDeviceRequest::getDeviceRate()const
{
return deviceRate_;
}
void AddDeviceRequest::setDeviceRate(const std::string& deviceRate)
{
deviceRate_ = deviceRate;
setBodyParameter("DeviceRate", deviceRate);
}
std::string AddDeviceRequest::getDeviceAddress()const
{
return deviceAddress_;

73
vcs/src/model/AddMonitorRequest.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/vcs/model/AddMonitorRequest.h>
using AlibabaCloud::Vcs::Model::AddMonitorRequest;
AddMonitorRequest::AddMonitorRequest() :
RpcServiceRequest("vcs", "2020-05-15", "AddMonitor")
{
setMethod(HttpRequest::Method::Post);
}
AddMonitorRequest::~AddMonitorRequest()
{}
std::string AddMonitorRequest::getMonitorType()const
{
return monitorType_;
}
void AddMonitorRequest::setMonitorType(const std::string& monitorType)
{
monitorType_ = monitorType;
setBodyParameter("MonitorType", monitorType);
}
std::string AddMonitorRequest::getCorpId()const
{
return corpId_;
}
void AddMonitorRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string AddMonitorRequest::getDescription()const
{
return description_;
}
void AddMonitorRequest::setDescription(const std::string& description)
{
description_ = description;
setBodyParameter("Description", description);
}
int AddMonitorRequest::getBatchIndicator()const
{
return batchIndicator_;
}
void AddMonitorRequest::setBatchIndicator(int batchIndicator)
{
batchIndicator_ = batchIndicator;
setBodyParameter("BatchIndicator", std::to_string(batchIndicator));
}

65
vcs/src/model/AddMonitorResult.cc 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.
*/
#include <alibabacloud/vcs/model/AddMonitorResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vcs;
using namespace AlibabaCloud::Vcs::Model;
AddMonitorResult::AddMonitorResult() :
ServiceResult()
{}
AddMonitorResult::AddMonitorResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddMonitorResult::~AddMonitorResult()
{}
void AddMonitorResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string AddMonitorResult::getMessage()const
{
return message_;
}
std::string AddMonitorResult::getData()const
{
return data_;
}
std::string AddMonitorResult::getCode()const
{
return code_;
}

40
vcs/src/model/GetBodyOptionsRequest.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/vcs/model/GetBodyOptionsRequest.h>
using AlibabaCloud::Vcs::Model::GetBodyOptionsRequest;
GetBodyOptionsRequest::GetBodyOptionsRequest() :
RpcServiceRequest("vcs", "2020-05-15", "GetBodyOptions")
{
setMethod(HttpRequest::Method::Post);
}
GetBodyOptionsRequest::~GetBodyOptionsRequest()
{}
std::string GetBodyOptionsRequest::getCorpId()const
{
return corpId_;
}
void GetBodyOptionsRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}

83
vcs/src/model/GetBodyOptionsResult.cc Normal file
View File

@@ -0,0 +1,83 @@
/*
* 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/vcs/model/GetBodyOptionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vcs;
using namespace AlibabaCloud::Vcs::Model;
GetBodyOptionsResult::GetBodyOptionsResult() :
ServiceResult()
{}
GetBodyOptionsResult::GetBodyOptionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetBodyOptionsResult::~GetBodyOptionsResult()
{}
void GetBodyOptionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["DataItem"];
for (auto valueDataDataItem : allDataNode)
{
DataItem dataObject;
if(!valueDataDataItem["Key"].isNull())
dataObject.key = valueDataDataItem["Key"].asString();
if(!valueDataDataItem["Name"].isNull())
dataObject.name = valueDataDataItem["Name"].asString();
auto allOptionListNode = allDataNode["OptionList"]["OptionListItem"];
for (auto allDataNodeOptionListOptionListItem : allOptionListNode)
{
DataItem::OptionListItem optionListObject;
if(!allDataNodeOptionListOptionListItem["Key"].isNull())
optionListObject.key = allDataNodeOptionListOptionListItem["Key"].asString();
if(!allDataNodeOptionListOptionListItem["Name"].isNull())
optionListObject.name = allDataNodeOptionListOptionListItem["Name"].asString();
dataObject.optionList.push_back(optionListObject);
}
data_.push_back(dataObject);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string GetBodyOptionsResult::getMessage()const
{
return message_;
}
std::vector<GetBodyOptionsResult::DataItem> GetBodyOptionsResult::getData()const
{
return data_;
}
std::string GetBodyOptionsResult::getCode()const
{
return code_;
}

11
vcs/src/model/GetDeviceLiveUrlRequest.cc
View File

@@ -49,14 +49,3 @@ void GetDeviceLiveUrlRequest::setGbId(const std::string& gbId)
setBodyParameter("GbId", gbId);
}
long GetDeviceLiveUrlRequest::getDeviceId()const
{
return deviceId_;
}
void GetDeviceLiveUrlRequest::setDeviceId(long deviceId)
{
deviceId_ = deviceId;
setBodyParameter("DeviceId", std::to_string(deviceId));
}

73
vcs/src/model/GetDeviceVideoUrlRequest.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/vcs/model/GetDeviceVideoUrlRequest.h>
using AlibabaCloud::Vcs::Model::GetDeviceVideoUrlRequest;
GetDeviceVideoUrlRequest::GetDeviceVideoUrlRequest() :
RpcServiceRequest("vcs", "2020-05-15", "GetDeviceVideoUrl")
{
setMethod(HttpRequest::Method::Post);
}
GetDeviceVideoUrlRequest::~GetDeviceVideoUrlRequest()
{}
std::string GetDeviceVideoUrlRequest::getCorpId()const
{
return corpId_;
}
void GetDeviceVideoUrlRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string GetDeviceVideoUrlRequest::getGbId()const
{
return gbId_;
}
void GetDeviceVideoUrlRequest::setGbId(const std::string& gbId)
{
gbId_ = gbId;
setBodyParameter("GbId", gbId);
}
long GetDeviceVideoUrlRequest::getEndTime()const
{
return endTime_;
}
void GetDeviceVideoUrlRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setBodyParameter("EndTime", std::to_string(endTime));
}
long GetDeviceVideoUrlRequest::getStartTime()const
{
return startTime_;
}
void GetDeviceVideoUrlRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setBodyParameter("StartTime", std::to_string(startTime));
}

65
vcs/src/model/GetDeviceVideoUrlResult.cc 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.
*/
#include <alibabacloud/vcs/model/GetDeviceVideoUrlResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vcs;
using namespace AlibabaCloud::Vcs::Model;
GetDeviceVideoUrlResult::GetDeviceVideoUrlResult() :
ServiceResult()
{}
GetDeviceVideoUrlResult::GetDeviceVideoUrlResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetDeviceVideoUrlResult::~GetDeviceVideoUrlResult()
{}
void GetDeviceVideoUrlResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Url"].isNull())
url_ = value["Url"].asString();
}
std::string GetDeviceVideoUrlResult::getMessage()const
{
return message_;
}
std::string GetDeviceVideoUrlResult::getCode()const
{
return code_;
}
std::string GetDeviceVideoUrlResult::getUrl()const
{
return url_;
}

40
vcs/src/model/GetFaceOptionsRequest.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/vcs/model/GetFaceOptionsRequest.h>
using AlibabaCloud::Vcs::Model::GetFaceOptionsRequest;
GetFaceOptionsRequest::GetFaceOptionsRequest() :
RpcServiceRequest("vcs", "2020-05-15", "GetFaceOptions")
{
setMethod(HttpRequest::Method::Post);
}
GetFaceOptionsRequest::~GetFaceOptionsRequest()
{}
std::string GetFaceOptionsRequest::getCorpId()const
{
return corpId_;
}
void GetFaceOptionsRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}

83
vcs/src/model/GetFaceOptionsResult.cc Normal file
View File

@@ -0,0 +1,83 @@
/*
* 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/vcs/model/GetFaceOptionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vcs;
using namespace AlibabaCloud::Vcs::Model;
GetFaceOptionsResult::GetFaceOptionsResult() :
ServiceResult()
{}
GetFaceOptionsResult::GetFaceOptionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetFaceOptionsResult::~GetFaceOptionsResult()
{}
void GetFaceOptionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["DataItem"];
for (auto valueDataDataItem : allDataNode)
{
DataItem dataObject;
if(!valueDataDataItem["Key"].isNull())
dataObject.key = valueDataDataItem["Key"].asString();
if(!valueDataDataItem["Name"].isNull())
dataObject.name = valueDataDataItem["Name"].asString();
auto allOptionListNode = allDataNode["OptionList"]["OptionListItem"];
for (auto allDataNodeOptionListOptionListItem : allOptionListNode)
{
DataItem::OptionListItem optionListObject;
if(!allDataNodeOptionListOptionListItem["Key"].isNull())
optionListObject.key = allDataNodeOptionListOptionListItem["Key"].asString();
if(!allDataNodeOptionListOptionListItem["Name"].isNull())
optionListObject.name = allDataNodeOptionListOptionListItem["Name"].asString();
dataObject.optionList.push_back(optionListObject);
}
data_.push_back(dataObject);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string GetFaceOptionsResult::getMessage()const
{
return message_;
}
std::vector<GetFaceOptionsResult::DataItem> GetFaceOptionsResult::getData()const
{
return data_;
}
std::string GetFaceOptionsResult::getCode()const
{
return code_;
}

84
vcs/src/model/GetMonitorResultRequest.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/vcs/model/GetMonitorResultRequest.h>
using AlibabaCloud::Vcs::Model::GetMonitorResultRequest;
GetMonitorResultRequest::GetMonitorResultRequest() :
RpcServiceRequest("vcs", "2020-05-15", "GetMonitorResult")
{
setMethod(HttpRequest::Method::Post);
}
GetMonitorResultRequest::~GetMonitorResultRequest()
{}
std::string GetMonitorResultRequest::getCorpId()const
{
return corpId_;
}
void GetMonitorResultRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
long GetMonitorResultRequest::getEndTime()const
{
return endTime_;
}
void GetMonitorResultRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setBodyParameter("EndTime", std::to_string(endTime));
}
long GetMonitorResultRequest::getStartTime()const
{
return startTime_;
}
void GetMonitorResultRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setBodyParameter("StartTime", std::to_string(startTime));
}
std::string GetMonitorResultRequest::getMinRecordId()const
{
return minRecordId_;
}
void GetMonitorResultRequest::setMinRecordId(const std::string& minRecordId)
{
minRecordId_ = minRecordId;
setBodyParameter("MinRecordId", minRecordId);
}
std::string GetMonitorResultRequest::getTaskId()const
{
return taskId_;
}
void GetMonitorResultRequest::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
setBodyParameter("TaskId", taskId);
}

120
vcs/src/model/GetMonitorResultResult.cc Normal file
View File

@@ -0,0 +1,120 @@
/*
* 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/vcs/model/GetMonitorResultResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vcs;
using namespace AlibabaCloud::Vcs::Model;
GetMonitorResultResult::GetMonitorResultResult() :
ServiceResult()
{}
GetMonitorResultResult::GetMonitorResultResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetMonitorResultResult::~GetMonitorResultResult()
{}
void GetMonitorResultResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRecordsNode = value["Records"]["RecordsItem"];
for (auto valueRecordsRecordsItem : allRecordsNode)
{
RecordsItem recordsObject;
if(!valueRecordsRecordsItem["GbId"].isNull())
recordsObject.gbId = valueRecordsRecordsItem["GbId"].asString();
if(!valueRecordsRecordsItem["ShotTime"].isNull())
recordsObject.shotTime = valueRecordsRecordsItem["ShotTime"].asString();
if(!valueRecordsRecordsItem["MonitorPicUrl"].isNull())
recordsObject.monitorPicUrl = valueRecordsRecordsItem["MonitorPicUrl"].asString();
if(!valueRecordsRecordsItem["ShotPicUrl"].isNull())
recordsObject.shotPicUrl = valueRecordsRecordsItem["ShotPicUrl"].asString();
records_.push_back(recordsObject);
}
auto dataNode = value["Data"];
if(!dataNode["MaxRecordId"].isNull())
data_.maxRecordId = dataNode["MaxRecordId"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Score"].isNull())
score_ = value["Score"].asString();
if(!value["LeftTopX"].isNull())
leftTopX_ = value["LeftTopX"].asString();
if(!value["LeftTopY"].isNull())
leftTopY_ = value["LeftTopY"].asString();
if(!value["RightBottomX"].isNull())
rightBottomX_ = value["RightBottomX"].asString();
if(!value["RightBottomY"].isNull())
rightBottomY_ = value["RightBottomY"].asString();
}
std::string GetMonitorResultResult::getScore()const
{
return score_;
}
std::string GetMonitorResultResult::getMessage()const
{
return message_;
}
std::string GetMonitorResultResult::getRightBottomX()const
{
return rightBottomX_;
}
std::string GetMonitorResultResult::getRightBottomY()const
{
return rightBottomY_;
}
GetMonitorResultResult::Data GetMonitorResultResult::getData()const
{
return data_;
}
std::string GetMonitorResultResult::getLeftTopY()const
{
return leftTopY_;
}
std::vector<GetMonitorResultResult::RecordsItem> GetMonitorResultResult::getRecords()const
{
return records_;
}
std::string GetMonitorResultResult::getCode()const
{
return code_;
}
std::string GetMonitorResultResult::getLeftTopX()const
{
return leftTopX_;
}

4
vcs/src/model/ListDevicesResult.cc
View File

@@ -58,8 +58,8 @@ void ListDevicesResult::parse(const std::string &payload)
recordObject.bitRate = dataNodeRecordsRecord["BitRate"].asString();
if(!dataNodeRecordsRecord["CoverImageUrl"].isNull())
recordObject.coverImageUrl = dataNodeRecordsRecord["CoverImageUrl"].asString();
if(!dataNodeRecordsRecord["GBid"].isNull())
recordObject.gBid = dataNodeRecordsRecord["GBid"].asString();
if(!dataNodeRecordsRecord["GbId"].isNull())
recordObject.gbId = dataNodeRecordsRecord["GbId"].asString();
if(!dataNodeRecordsRecord["DeviceAddress"].isNull())
recordObject.deviceAddress = dataNodeRecordsRecord["DeviceAddress"].asString();
if(!dataNodeRecordsRecord["DeviceDirection"].isNull())

106
vcs/src/model/SearchBodyRequest.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* 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/vcs/model/SearchBodyRequest.h>
using AlibabaCloud::Vcs::Model::SearchBodyRequest;
SearchBodyRequest::SearchBodyRequest() :
RpcServiceRequest("vcs", "2020-05-15", "SearchBody")
{
setMethod(HttpRequest::Method::Post);
}
SearchBodyRequest::~SearchBodyRequest()
{}
std::string SearchBodyRequest::getCorpId()const
{
return corpId_;
}
void SearchBodyRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string SearchBodyRequest::getGbId()const
{
return gbId_;
}
void SearchBodyRequest::setGbId(const std::string& gbId)
{
gbId_ = gbId;
setBodyParameter("GbId", gbId);
}
long SearchBodyRequest::getStartTimeStamp()const
{
return startTimeStamp_;
}
void SearchBodyRequest::setStartTimeStamp(long startTimeStamp)
{
startTimeStamp_ = startTimeStamp;
setBodyParameter("StartTimeStamp", std::to_string(startTimeStamp));
}
long SearchBodyRequest::getEndTimeStamp()const
{
return endTimeStamp_;
}
void SearchBodyRequest::setEndTimeStamp(long endTimeStamp)
{
endTimeStamp_ = endTimeStamp;
setBodyParameter("EndTimeStamp", std::to_string(endTimeStamp));
}
int SearchBodyRequest::getPageNo()const
{
return pageNo_;
}
void SearchBodyRequest::setPageNo(int pageNo)
{
pageNo_ = pageNo;
setBodyParameter("PageNo", std::to_string(pageNo));
}
int SearchBodyRequest::getPageSize()const
{
return pageSize_;
}
void SearchBodyRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setBodyParameter("PageSize", std::to_string(pageSize));
}
std::string SearchBodyRequest::getOptionList()const
{
return optionList_;
}
void SearchBodyRequest::setOptionList(const std::string& optionList)
{
optionList_ = optionList;
setBodyParameter("OptionList", optionList);
}

94
vcs/src/model/SearchBodyResult.cc Normal file
View File

@@ -0,0 +1,94 @@
/*
* 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/vcs/model/SearchBodyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vcs;
using namespace AlibabaCloud::Vcs::Model;
SearchBodyResult::SearchBodyResult() :
ServiceResult()
{}
SearchBodyResult::SearchBodyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchBodyResult::~SearchBodyResult()
{}
void SearchBodyResult::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["PageNo"].isNull())
data_.pageNo = std::stoi(dataNode["PageNo"].asString());
if(!dataNode["PageSize"].isNull())
data_.pageSize = std::stoi(dataNode["PageSize"].asString());
if(!dataNode["TotalCount"].isNull())
data_.totalCount = std::stoi(dataNode["TotalCount"].asString());
if(!dataNode["TotalPage"].isNull())
data_.totalPage = std::stoi(dataNode["TotalPage"].asString());
auto allRecordsNode = dataNode["Records"]["Record"];
for (auto dataNodeRecordsRecord : allRecordsNode)
{
Data::Record recordObject;
if(!dataNodeRecordsRecord["GbId"].isNull())
recordObject.gbId = dataNodeRecordsRecord["GbId"].asString();
if(!dataNodeRecordsRecord["ImageUrl"].isNull())
recordObject.imageUrl = dataNodeRecordsRecord["ImageUrl"].asString();
if(!dataNodeRecordsRecord["LeftTopX"].isNull())
recordObject.leftTopX = std::stof(dataNodeRecordsRecord["LeftTopX"].asString());
if(!dataNodeRecordsRecord["LeftTopY"].isNull())
recordObject.leftTopY = std::stof(dataNodeRecordsRecord["LeftTopY"].asString());
if(!dataNodeRecordsRecord["RightBottomX"].isNull())
recordObject.rightBottomX = std::stof(dataNodeRecordsRecord["RightBottomX"].asString());
if(!dataNodeRecordsRecord["RightBottomY"].isNull())
recordObject.rightBottomY = std::stof(dataNodeRecordsRecord["RightBottomY"].asString());
if(!dataNodeRecordsRecord["Score"].isNull())
recordObject.score = std::stof(dataNodeRecordsRecord["Score"].asString());
if(!dataNodeRecordsRecord["TargetImageUrl"].isNull())
recordObject.targetImageUrl = dataNodeRecordsRecord["TargetImageUrl"].asString();
data_.records.push_back(recordObject);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string SearchBodyResult::getMessage()const
{
return message_;
}
SearchBodyResult::Data SearchBodyResult::getData()const
{
return data_;
}
std::string SearchBodyResult::getCode()const
{
return code_;
}

40
vcs/src/model/StopMonitorRequest.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/vcs/model/StopMonitorRequest.h>
using AlibabaCloud::Vcs::Model::StopMonitorRequest;
StopMonitorRequest::StopMonitorRequest() :
RpcServiceRequest("vcs", "2020-05-15", "StopMonitor")
{
setMethod(HttpRequest::Method::Post);
}
StopMonitorRequest::~StopMonitorRequest()
{}
std::string StopMonitorRequest::getTaskId()const
{
return taskId_;
}
void StopMonitorRequest::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
setBodyParameter("TaskId", taskId);
}

65
vcs/src/model/StopMonitorResult.cc 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.
*/
#include <alibabacloud/vcs/model/StopMonitorResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vcs;
using namespace AlibabaCloud::Vcs::Model;
StopMonitorResult::StopMonitorResult() :
ServiceResult()
{}
StopMonitorResult::StopMonitorResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StopMonitorResult::~StopMonitorResult()
{}
void StopMonitorResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Data"].isNull())
data_ = value["Data"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string StopMonitorResult::getMessage()const
{
return message_;
}
std::string StopMonitorResult::getData()const
{
return data_;
}
std::string StopMonitorResult::getCode()const
{
return code_;
}

22
vcs/src/model/UpdateDeviceRequest.cc
View File

@@ -60,6 +60,17 @@ void UpdateDeviceRequest::setGbId(const std::string& gbId)
setBodyParameter("GbId", gbId);
}
std::string UpdateDeviceRequest::getBitRate()const
{
return bitRate_;
}
void UpdateDeviceRequest::setBitRate(const std::string& bitRate)
{
bitRate_ = bitRate;
setBodyParameter("BitRate", bitRate);
}
std::string UpdateDeviceRequest::getDeviceDirection()const
{
return deviceDirection_;
@@ -71,17 +82,6 @@ void UpdateDeviceRequest::setDeviceDirection(const std::string& deviceDirection)
setBodyParameter("DeviceDirection", deviceDirection);
}
std::string UpdateDeviceRequest::getDeviceRate()const
{
return deviceRate_;
}
void UpdateDeviceRequest::setDeviceRate(const std::string& deviceRate)
{
deviceRate_ = deviceRate;
setBodyParameter("DeviceRate", deviceRate);
}
std::string UpdateDeviceRequest::getDeviceAddress()const
{
return deviceAddress_;

150
vcs/src/model/UpdateMonitorRequest.cc Normal file
View File

@@ -0,0 +1,150 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vcs/model/UpdateMonitorRequest.h>
using AlibabaCloud::Vcs::Model::UpdateMonitorRequest;
UpdateMonitorRequest::UpdateMonitorRequest() :
RpcServiceRequest("vcs", "2020-05-15", "UpdateMonitor")
{
setMethod(HttpRequest::Method::Post);
}
UpdateMonitorRequest::~UpdateMonitorRequest()
{}
std::string UpdateMonitorRequest::getDeviceOperateType()const
{
return deviceOperateType_;
}
void UpdateMonitorRequest::setDeviceOperateType(const std::string& deviceOperateType)
{
deviceOperateType_ = deviceOperateType;
setBodyParameter("DeviceOperateType", deviceOperateType);
}
std::string UpdateMonitorRequest::getCorpId()const
{
return corpId_;
}
void UpdateMonitorRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string UpdateMonitorRequest::getPicList()const
{
return picList_;
}
void UpdateMonitorRequest::setPicList(const std::string& picList)
{
picList_ = picList;
setBodyParameter("PicList", picList);
}
std::string UpdateMonitorRequest::getDescription()const
{
return description_;
}
void UpdateMonitorRequest::setDescription(const std::string& description)
{
description_ = description;
setBodyParameter("Description", description);
}
std::string UpdateMonitorRequest::getRuleName()const
{
return ruleName_;
}
void UpdateMonitorRequest::setRuleName(const std::string& ruleName)
{
ruleName_ = ruleName;
setBodyParameter("RuleName", ruleName);
}
std::string UpdateMonitorRequest::getPicOperateType()const
{
return picOperateType_;
}
void UpdateMonitorRequest::setPicOperateType(const std::string& picOperateType)
{
picOperateType_ = picOperateType;
setBodyParameter("PicOperateType", picOperateType);
}
std::string UpdateMonitorRequest::getAttributeName()const
{
return attributeName_;
}
void UpdateMonitorRequest::setAttributeName(const std::string& attributeName)
{
attributeName_ = attributeName;
setBodyParameter("AttributeName", attributeName);
}
std::string UpdateMonitorRequest::getAttributeValueList()const
{
return attributeValueList_;
}
void UpdateMonitorRequest::setAttributeValueList(const std::string& attributeValueList)
{
attributeValueList_ = attributeValueList;
setBodyParameter("AttributeValueList", attributeValueList);
}
std::string UpdateMonitorRequest::getDeviceList()const
{
return deviceList_;
}
void UpdateMonitorRequest::setDeviceList(const std::string& deviceList)
{
deviceList_ = deviceList;
setBodyParameter("DeviceList", deviceList);
}
std::string UpdateMonitorRequest::getAttributeOperateType()const
{
return attributeOperateType_;
}
void UpdateMonitorRequest::setAttributeOperateType(const std::string& attributeOperateType)
{
attributeOperateType_ = attributeOperateType;
setBodyParameter("AttributeOperateType", attributeOperateType);
}
std::string UpdateMonitorRequest::getTaskId()const
{
return taskId_;
}
void UpdateMonitorRequest::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
setBodyParameter("TaskId", taskId);
}

65
vcs/src/model/UpdateMonitorResult.cc 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.
*/
#include <alibabacloud/vcs/model/UpdateMonitorResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vcs;
using namespace AlibabaCloud::Vcs::Model;
UpdateMonitorResult::UpdateMonitorResult() :
ServiceResult()
{}
UpdateMonitorResult::UpdateMonitorResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateMonitorResult::~UpdateMonitorResult()
{}
void UpdateMonitorResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Data"].isNull())
data_ = value["Data"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string UpdateMonitorResult::getMessage()const
{
return message_;
}
std::string UpdateMonitorResult::getData()const
{
return data_;
}
std::string UpdateMonitorResult::getCode()const
{
return code_;
}