diff --git a/CHANGELOG b/CHANGELOG index ffb9f6ba7..9aa637a4e 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,8 @@ +2018-11-21 Version: 1.33.2 +1, Add new apis called AddWatermark, UpdateWatermark, DeleteWatermark, ListWatermarks, GetWatermark and SetDefaultWatermark which support watermark feature. +2, Add a new api called RegisterMedia which supports registration of audio and video media files that already exist in the OSS bucket. +3, Add the field named OverrideParams to SubmitTranscodeJobs api request. + 2018-11-16 Version: 1.33.1 1, update version diff --git a/VERSION b/VERSION index 9e9fac324..a5167eb8e 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.33.1 \ No newline at end of file +1.33.2 \ No newline at end of file diff --git a/vod/CMakeLists.txt b/vod/CMakeLists.txt index 1841f2d7d..4588d2941 100755 --- a/vod/CMakeLists.txt +++ b/vod/CMakeLists.txt @@ -61,8 +61,12 @@ set(vod_public_header_model include/alibabacloud/vod/model/SubmitAIVideoCategoryJobResult.h include/alibabacloud/vod/model/DescribeRefreshTasksRequest.h include/alibabacloud/vod/model/DescribeRefreshTasksResult.h + include/alibabacloud/vod/model/DeleteWatermarkRequest.h + include/alibabacloud/vod/model/DeleteWatermarkResult.h include/alibabacloud/vod/model/UpdateCategoryRequest.h include/alibabacloud/vod/model/UpdateCategoryResult.h + include/alibabacloud/vod/model/RegisterMediaRequest.h + include/alibabacloud/vod/model/RegisterMediaResult.h include/alibabacloud/vod/model/ListAIASRJobRequest.h include/alibabacloud/vod/model/ListAIASRJobResult.h include/alibabacloud/vod/model/ListAIVideoCensorJobRequest.h @@ -85,6 +89,10 @@ set(vod_public_header_model include/alibabacloud/vod/model/ListAIJobResult.h include/alibabacloud/vod/model/GetVideoConfigRequest.h include/alibabacloud/vod/model/GetVideoConfigResult.h + include/alibabacloud/vod/model/AddWatermarkRequest.h + include/alibabacloud/vod/model/AddWatermarkResult.h + include/alibabacloud/vod/model/ListWatermarkRequest.h + include/alibabacloud/vod/model/ListWatermarkResult.h include/alibabacloud/vod/model/CreateUploadImageRequest.h include/alibabacloud/vod/model/CreateUploadImageResult.h include/alibabacloud/vod/model/UpdateVideoInfoRequest.h @@ -95,6 +103,8 @@ set(vod_public_header_model include/alibabacloud/vod/model/SearchMediaResult.h include/alibabacloud/vod/model/DescribePlayTopVideosRequest.h include/alibabacloud/vod/model/DescribePlayTopVideosResult.h + include/alibabacloud/vod/model/SetDefaultWatermarkRequest.h + include/alibabacloud/vod/model/SetDefaultWatermarkResult.h include/alibabacloud/vod/model/PushObjectCacheRequest.h include/alibabacloud/vod/model/PushObjectCacheResult.h include/alibabacloud/vod/model/AddCategoryRequest.h @@ -117,6 +127,10 @@ set(vod_public_header_model include/alibabacloud/vod/model/SubmitAIVideoTerrorismRecogJobResult.h include/alibabacloud/vod/model/SearchEditingProjectRequest.h include/alibabacloud/vod/model/SearchEditingProjectResult.h + include/alibabacloud/vod/model/GetWatermarkRequest.h + include/alibabacloud/vod/model/GetWatermarkResult.h + include/alibabacloud/vod/model/UpdateWatermarkRequest.h + include/alibabacloud/vod/model/UpdateWatermarkResult.h include/alibabacloud/vod/model/GetImageInfoRequest.h include/alibabacloud/vod/model/GetImageInfoResult.h include/alibabacloud/vod/model/GetMessageCallbackRequest.h @@ -214,8 +228,12 @@ set(vod_src src/model/SubmitAIVideoCategoryJobResult.cc src/model/DescribeRefreshTasksRequest.cc src/model/DescribeRefreshTasksResult.cc + src/model/DeleteWatermarkRequest.cc + src/model/DeleteWatermarkResult.cc src/model/UpdateCategoryRequest.cc src/model/UpdateCategoryResult.cc + src/model/RegisterMediaRequest.cc + src/model/RegisterMediaResult.cc src/model/ListAIASRJobRequest.cc src/model/ListAIASRJobResult.cc src/model/ListAIVideoCensorJobRequest.cc @@ -238,6 +256,10 @@ set(vod_src src/model/ListAIJobResult.cc src/model/GetVideoConfigRequest.cc src/model/GetVideoConfigResult.cc + src/model/AddWatermarkRequest.cc + src/model/AddWatermarkResult.cc + src/model/ListWatermarkRequest.cc + src/model/ListWatermarkResult.cc src/model/CreateUploadImageRequest.cc src/model/CreateUploadImageResult.cc src/model/UpdateVideoInfoRequest.cc @@ -248,6 +270,8 @@ set(vod_src src/model/SearchMediaResult.cc src/model/DescribePlayTopVideosRequest.cc src/model/DescribePlayTopVideosResult.cc + src/model/SetDefaultWatermarkRequest.cc + src/model/SetDefaultWatermarkResult.cc src/model/PushObjectCacheRequest.cc src/model/PushObjectCacheResult.cc src/model/AddCategoryRequest.cc @@ -270,6 +294,10 @@ set(vod_src src/model/SubmitAIVideoTerrorismRecogJobResult.cc src/model/SearchEditingProjectRequest.cc src/model/SearchEditingProjectResult.cc + src/model/GetWatermarkRequest.cc + src/model/GetWatermarkResult.cc + src/model/UpdateWatermarkRequest.cc + src/model/UpdateWatermarkResult.cc src/model/GetImageInfoRequest.cc src/model/GetImageInfoResult.cc src/model/GetMessageCallbackRequest.cc diff --git a/vod/include/alibabacloud/vod/.DS_Store b/vod/include/alibabacloud/vod/.DS_Store index 9a9388cba..5a3ee1872 100644 Binary files a/vod/include/alibabacloud/vod/.DS_Store and b/vod/include/alibabacloud/vod/.DS_Store differ diff --git a/vod/include/alibabacloud/vod/VodClient.h b/vod/include/alibabacloud/vod/VodClient.h index 5daed5714..2c9ab03de 100755 --- a/vod/include/alibabacloud/vod/VodClient.h +++ b/vod/include/alibabacloud/vod/VodClient.h @@ -62,8 +62,12 @@ #include "model/SubmitAIVideoCategoryJobResult.h" #include "model/DescribeRefreshTasksRequest.h" #include "model/DescribeRefreshTasksResult.h" +#include "model/DeleteWatermarkRequest.h" +#include "model/DeleteWatermarkResult.h" #include "model/UpdateCategoryRequest.h" #include "model/UpdateCategoryResult.h" +#include "model/RegisterMediaRequest.h" +#include "model/RegisterMediaResult.h" #include "model/ListAIASRJobRequest.h" #include "model/ListAIASRJobResult.h" #include "model/ListAIVideoCensorJobRequest.h" @@ -86,6 +90,10 @@ #include "model/ListAIJobResult.h" #include "model/GetVideoConfigRequest.h" #include "model/GetVideoConfigResult.h" +#include "model/AddWatermarkRequest.h" +#include "model/AddWatermarkResult.h" +#include "model/ListWatermarkRequest.h" +#include "model/ListWatermarkResult.h" #include "model/CreateUploadImageRequest.h" #include "model/CreateUploadImageResult.h" #include "model/UpdateVideoInfoRequest.h" @@ -96,6 +104,8 @@ #include "model/SearchMediaResult.h" #include "model/DescribePlayTopVideosRequest.h" #include "model/DescribePlayTopVideosResult.h" +#include "model/SetDefaultWatermarkRequest.h" +#include "model/SetDefaultWatermarkResult.h" #include "model/PushObjectCacheRequest.h" #include "model/PushObjectCacheResult.h" #include "model/AddCategoryRequest.h" @@ -118,6 +128,10 @@ #include "model/SubmitAIVideoTerrorismRecogJobResult.h" #include "model/SearchEditingProjectRequest.h" #include "model/SearchEditingProjectResult.h" +#include "model/GetWatermarkRequest.h" +#include "model/GetWatermarkResult.h" +#include "model/UpdateWatermarkRequest.h" +#include "model/UpdateWatermarkResult.h" #include "model/GetImageInfoRequest.h" #include "model/GetImageInfoResult.h" #include "model/GetMessageCallbackRequest.h" @@ -241,9 +255,15 @@ namespace AlibabaCloud typedef Outcome DescribeRefreshTasksOutcome; typedef std::future DescribeRefreshTasksOutcomeCallable; typedef std::function&)> DescribeRefreshTasksAsyncHandler; + typedef Outcome DeleteWatermarkOutcome; + typedef std::future DeleteWatermarkOutcomeCallable; + typedef std::function&)> DeleteWatermarkAsyncHandler; typedef Outcome UpdateCategoryOutcome; typedef std::future UpdateCategoryOutcomeCallable; typedef std::function&)> UpdateCategoryAsyncHandler; + typedef Outcome RegisterMediaOutcome; + typedef std::future RegisterMediaOutcomeCallable; + typedef std::function&)> RegisterMediaAsyncHandler; typedef Outcome ListAIASRJobOutcome; typedef std::future ListAIASRJobOutcomeCallable; typedef std::function&)> ListAIASRJobAsyncHandler; @@ -277,6 +297,12 @@ namespace AlibabaCloud typedef Outcome GetVideoConfigOutcome; typedef std::future GetVideoConfigOutcomeCallable; typedef std::function&)> GetVideoConfigAsyncHandler; + typedef Outcome AddWatermarkOutcome; + typedef std::future AddWatermarkOutcomeCallable; + typedef std::function&)> AddWatermarkAsyncHandler; + typedef Outcome ListWatermarkOutcome; + typedef std::future ListWatermarkOutcomeCallable; + typedef std::function&)> ListWatermarkAsyncHandler; typedef Outcome CreateUploadImageOutcome; typedef std::future CreateUploadImageOutcomeCallable; typedef std::function&)> CreateUploadImageAsyncHandler; @@ -292,6 +318,9 @@ namespace AlibabaCloud typedef Outcome DescribePlayTopVideosOutcome; typedef std::future DescribePlayTopVideosOutcomeCallable; typedef std::function&)> DescribePlayTopVideosAsyncHandler; + typedef Outcome SetDefaultWatermarkOutcome; + typedef std::future SetDefaultWatermarkOutcomeCallable; + typedef std::function&)> SetDefaultWatermarkAsyncHandler; typedef Outcome PushObjectCacheOutcome; typedef std::future PushObjectCacheOutcomeCallable; typedef std::function&)> PushObjectCacheAsyncHandler; @@ -325,6 +354,12 @@ namespace AlibabaCloud typedef Outcome SearchEditingProjectOutcome; typedef std::future SearchEditingProjectOutcomeCallable; typedef std::function&)> SearchEditingProjectAsyncHandler; + typedef Outcome GetWatermarkOutcome; + typedef std::future GetWatermarkOutcomeCallable; + typedef std::function&)> GetWatermarkAsyncHandler; + typedef Outcome UpdateWatermarkOutcome; + typedef std::future UpdateWatermarkOutcomeCallable; + typedef std::function&)> UpdateWatermarkAsyncHandler; typedef Outcome GetImageInfoOutcome; typedef std::future GetImageInfoOutcomeCallable; typedef std::function&)> GetImageInfoAsyncHandler; @@ -471,9 +506,15 @@ namespace AlibabaCloud DescribeRefreshTasksOutcome describeRefreshTasks(const Model::DescribeRefreshTasksRequest &request)const; void describeRefreshTasksAsync(const Model::DescribeRefreshTasksRequest& request, const DescribeRefreshTasksAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeRefreshTasksOutcomeCallable describeRefreshTasksCallable(const Model::DescribeRefreshTasksRequest& request) const; + DeleteWatermarkOutcome deleteWatermark(const Model::DeleteWatermarkRequest &request)const; + void deleteWatermarkAsync(const Model::DeleteWatermarkRequest& request, const DeleteWatermarkAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteWatermarkOutcomeCallable deleteWatermarkCallable(const Model::DeleteWatermarkRequest& request) const; UpdateCategoryOutcome updateCategory(const Model::UpdateCategoryRequest &request)const; void updateCategoryAsync(const Model::UpdateCategoryRequest& request, const UpdateCategoryAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateCategoryOutcomeCallable updateCategoryCallable(const Model::UpdateCategoryRequest& request) const; + RegisterMediaOutcome registerMedia(const Model::RegisterMediaRequest &request)const; + void registerMediaAsync(const Model::RegisterMediaRequest& request, const RegisterMediaAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RegisterMediaOutcomeCallable registerMediaCallable(const Model::RegisterMediaRequest& request) const; ListAIASRJobOutcome listAIASRJob(const Model::ListAIASRJobRequest &request)const; void listAIASRJobAsync(const Model::ListAIASRJobRequest& request, const ListAIASRJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListAIASRJobOutcomeCallable listAIASRJobCallable(const Model::ListAIASRJobRequest& request) const; @@ -507,6 +548,12 @@ namespace AlibabaCloud GetVideoConfigOutcome getVideoConfig(const Model::GetVideoConfigRequest &request)const; void getVideoConfigAsync(const Model::GetVideoConfigRequest& request, const GetVideoConfigAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetVideoConfigOutcomeCallable getVideoConfigCallable(const Model::GetVideoConfigRequest& request) const; + AddWatermarkOutcome addWatermark(const Model::AddWatermarkRequest &request)const; + void addWatermarkAsync(const Model::AddWatermarkRequest& request, const AddWatermarkAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AddWatermarkOutcomeCallable addWatermarkCallable(const Model::AddWatermarkRequest& request) const; + ListWatermarkOutcome listWatermark(const Model::ListWatermarkRequest &request)const; + void listWatermarkAsync(const Model::ListWatermarkRequest& request, const ListWatermarkAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListWatermarkOutcomeCallable listWatermarkCallable(const Model::ListWatermarkRequest& request) const; CreateUploadImageOutcome createUploadImage(const Model::CreateUploadImageRequest &request)const; void createUploadImageAsync(const Model::CreateUploadImageRequest& request, const CreateUploadImageAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateUploadImageOutcomeCallable createUploadImageCallable(const Model::CreateUploadImageRequest& request) const; @@ -522,6 +569,9 @@ namespace AlibabaCloud DescribePlayTopVideosOutcome describePlayTopVideos(const Model::DescribePlayTopVideosRequest &request)const; void describePlayTopVideosAsync(const Model::DescribePlayTopVideosRequest& request, const DescribePlayTopVideosAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribePlayTopVideosOutcomeCallable describePlayTopVideosCallable(const Model::DescribePlayTopVideosRequest& request) const; + SetDefaultWatermarkOutcome setDefaultWatermark(const Model::SetDefaultWatermarkRequest &request)const; + void setDefaultWatermarkAsync(const Model::SetDefaultWatermarkRequest& request, const SetDefaultWatermarkAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetDefaultWatermarkOutcomeCallable setDefaultWatermarkCallable(const Model::SetDefaultWatermarkRequest& request) const; PushObjectCacheOutcome pushObjectCache(const Model::PushObjectCacheRequest &request)const; void pushObjectCacheAsync(const Model::PushObjectCacheRequest& request, const PushObjectCacheAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; PushObjectCacheOutcomeCallable pushObjectCacheCallable(const Model::PushObjectCacheRequest& request) const; @@ -555,6 +605,12 @@ namespace AlibabaCloud SearchEditingProjectOutcome searchEditingProject(const Model::SearchEditingProjectRequest &request)const; void searchEditingProjectAsync(const Model::SearchEditingProjectRequest& request, const SearchEditingProjectAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; SearchEditingProjectOutcomeCallable searchEditingProjectCallable(const Model::SearchEditingProjectRequest& request) const; + GetWatermarkOutcome getWatermark(const Model::GetWatermarkRequest &request)const; + void getWatermarkAsync(const Model::GetWatermarkRequest& request, const GetWatermarkAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetWatermarkOutcomeCallable getWatermarkCallable(const Model::GetWatermarkRequest& request) const; + UpdateWatermarkOutcome updateWatermark(const Model::UpdateWatermarkRequest &request)const; + void updateWatermarkAsync(const Model::UpdateWatermarkRequest& request, const UpdateWatermarkAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateWatermarkOutcomeCallable updateWatermarkCallable(const Model::UpdateWatermarkRequest& request) const; GetImageInfoOutcome getImageInfo(const Model::GetImageInfoRequest &request)const; void getImageInfoAsync(const Model::GetImageInfoRequest& request, const GetImageInfoAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetImageInfoOutcomeCallable getImageInfoCallable(const Model::GetImageInfoRequest& request) const; diff --git a/vod/include/alibabacloud/vod/model/AddWatermarkRequest.h b/vod/include/alibabacloud/vod/model/AddWatermarkRequest.h new file mode 100755 index 000000000..35161afba --- /dev/null +++ b/vod/include/alibabacloud/vod/model/AddWatermarkRequest.h @@ -0,0 +1,69 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_ADDWATERMARKREQUEST_H_ +#define ALIBABACLOUD_VOD_MODEL_ADDWATERMARKREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT AddWatermarkRequest : public RpcServiceRequest + { + + public: + AddWatermarkRequest(); + ~AddWatermarkRequest(); + + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getName()const; + void setName(const std::string& name); + std::string getFileUrl()const; + void setFileUrl(const std::string& fileUrl); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getType()const; + void setType(const std::string& type); + std::string getWatermarkConfig()const; + void setWatermarkConfig(const std::string& watermarkConfig); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string name_; + std::string fileUrl_; + long ownerId_; + std::string type_; + std::string watermarkConfig_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_ADDWATERMARKREQUEST_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/AddWatermarkResult.h b/vod/include/alibabacloud/vod/model/AddWatermarkResult.h new file mode 100755 index 000000000..8510b220d --- /dev/null +++ b/vod/include/alibabacloud/vod/model/AddWatermarkResult.h @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_ADDWATERMARKRESULT_H_ +#define ALIBABACLOUD_VOD_MODEL_ADDWATERMARKRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT AddWatermarkResult : public ServiceResult + { + public: + struct WatermarkInfo + { + std::string isDefault; + std::string fileUrl; + std::string type; + std::string watermarkId; + std::string creationTime; + std::string watermarkConfig; + std::string name; + }; + + + AddWatermarkResult(); + explicit AddWatermarkResult(const std::string &payload); + ~AddWatermarkResult(); + WatermarkInfo getWatermarkInfo()const; + + protected: + void parse(const std::string &payload); + private: + WatermarkInfo watermarkInfo_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_ADDWATERMARKRESULT_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/DeleteMezzaninesRequest.h b/vod/include/alibabacloud/vod/model/DeleteMezzaninesRequest.h index 7ca55b701..ce68e969c 100755 --- a/vod/include/alibabacloud/vod/model/DeleteMezzaninesRequest.h +++ b/vod/include/alibabacloud/vod/model/DeleteMezzaninesRequest.h @@ -50,7 +50,6 @@ namespace AlibabaCloud long resourceOwnerId_; std::string resourceOwnerAccount_; bool force_; - long resourceRealOwnerId_; long ownerId_; std::string videoIds_; diff --git a/vod/include/alibabacloud/vod/model/DeleteWatermarkRequest.h b/vod/include/alibabacloud/vod/model/DeleteWatermarkRequest.h new file mode 100755 index 000000000..8e9a53d64 --- /dev/null +++ b/vod/include/alibabacloud/vod/model/DeleteWatermarkRequest.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKREQUEST_H_ +#define ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT DeleteWatermarkRequest : public RpcServiceRequest + { + + public: + DeleteWatermarkRequest(); + ~DeleteWatermarkRequest(); + + std::string getWatermarkId()const; + void setWatermarkId(const std::string& watermarkId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string watermarkId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKREQUEST_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/DeleteWatermarkResult.h b/vod/include/alibabacloud/vod/model/DeleteWatermarkResult.h new file mode 100755 index 000000000..fff679410 --- /dev/null +++ b/vod/include/alibabacloud/vod/model/DeleteWatermarkResult.h @@ -0,0 +1,49 @@ +/* + * 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_VOD_MODEL_DELETEWATERMARKRESULT_H_ +#define ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT DeleteWatermarkResult : public ServiceResult + { + public: + + + DeleteWatermarkResult(); + explicit DeleteWatermarkResult(const std::string &payload); + ~DeleteWatermarkResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKRESULT_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/GetVideoListRequest.h b/vod/include/alibabacloud/vod/model/GetVideoListRequest.h index 5e6cce323..cc5f31b8b 100755 --- a/vod/include/alibabacloud/vod/model/GetVideoListRequest.h +++ b/vod/include/alibabacloud/vod/model/GetVideoListRequest.h @@ -55,6 +55,8 @@ namespace AlibabaCloud void setOwnerId(long ownerId); std::string getStatus()const; void setStatus(const std::string& status); + std::string getStorageLocation()const; + void setStorageLocation(const std::string& storageLocation); private: long resourceOwnerId_; @@ -67,6 +69,7 @@ namespace AlibabaCloud std::string startTime_; long ownerId_; std::string status_; + std::string storageLocation_; }; } diff --git a/vod/include/alibabacloud/vod/model/GetVideoListResult.h b/vod/include/alibabacloud/vod/model/GetVideoListResult.h index c47d3d83b..38412e082 100755 --- a/vod/include/alibabacloud/vod/model/GetVideoListResult.h +++ b/vod/include/alibabacloud/vod/model/GetVideoListResult.h @@ -47,6 +47,7 @@ namespace AlibabaCloud std::string cateName; std::string creationTime; std::string coverURL; + std::string storageLocation; std::vector snapshots; std::string tags; }; diff --git a/vod/include/alibabacloud/vod/model/GetWatermarkRequest.h b/vod/include/alibabacloud/vod/model/GetWatermarkRequest.h new file mode 100755 index 000000000..2aafefc0b --- /dev/null +++ b/vod/include/alibabacloud/vod/model/GetWatermarkRequest.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_GETWATERMARKREQUEST_H_ +#define ALIBABACLOUD_VOD_MODEL_GETWATERMARKREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT GetWatermarkRequest : public RpcServiceRequest + { + + public: + GetWatermarkRequest(); + ~GetWatermarkRequest(); + + std::string getWatermarkId()const; + void setWatermarkId(const std::string& watermarkId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string watermarkId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_GETWATERMARKREQUEST_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/GetWatermarkResult.h b/vod/include/alibabacloud/vod/model/GetWatermarkResult.h new file mode 100755 index 000000000..5c7bce67c --- /dev/null +++ b/vod/include/alibabacloud/vod/model/GetWatermarkResult.h @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_GETWATERMARKRESULT_H_ +#define ALIBABACLOUD_VOD_MODEL_GETWATERMARKRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT GetWatermarkResult : public ServiceResult + { + public: + struct WatermarkInfo + { + std::string isDefault; + std::string fileUrl; + std::string type; + std::string watermarkId; + std::string creationTime; + std::string watermarkConfig; + std::string name; + }; + + + GetWatermarkResult(); + explicit GetWatermarkResult(const std::string &payload); + ~GetWatermarkResult(); + WatermarkInfo getWatermarkInfo()const; + + protected: + void parse(const std::string &payload); + private: + WatermarkInfo watermarkInfo_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_GETWATERMARKRESULT_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/ListWatermarkRequest.h b/vod/include/alibabacloud/vod/model/ListWatermarkRequest.h new file mode 100755 index 000000000..98cc6fb35 --- /dev/null +++ b/vod/include/alibabacloud/vod/model/ListWatermarkRequest.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_LISTWATERMARKREQUEST_H_ +#define ALIBABACLOUD_VOD_MODEL_LISTWATERMARKREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT ListWatermarkRequest : public RpcServiceRequest + { + + public: + ListWatermarkRequest(); + ~ListWatermarkRequest(); + + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + long resourceOwnerId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_LISTWATERMARKREQUEST_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/ListWatermarkResult.h b/vod/include/alibabacloud/vod/model/ListWatermarkResult.h new file mode 100755 index 000000000..dbb5a9c7f --- /dev/null +++ b/vod/include/alibabacloud/vod/model/ListWatermarkResult.h @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_LISTWATERMARKRESULT_H_ +#define ALIBABACLOUD_VOD_MODEL_LISTWATERMARKRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT ListWatermarkResult : public ServiceResult + { + public: + struct WatermarkInfo + { + std::string isDefault; + std::string fileUrl; + std::string type; + std::string watermarkId; + std::string creationTime; + std::string watermarkConfig; + std::string name; + }; + + + ListWatermarkResult(); + explicit ListWatermarkResult(const std::string &payload); + ~ListWatermarkResult(); + std::vector getWatermarkInfos()const; + + protected: + void parse(const std::string &payload); + private: + std::vector watermarkInfos_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_LISTWATERMARKRESULT_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/RegisterMediaRequest.h b/vod/include/alibabacloud/vod/model/RegisterMediaRequest.h new file mode 100755 index 000000000..3512bc376 --- /dev/null +++ b/vod/include/alibabacloud/vod/model/RegisterMediaRequest.h @@ -0,0 +1,69 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_REGISTERMEDIAREQUEST_H_ +#define ALIBABACLOUD_VOD_MODEL_REGISTERMEDIAREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT RegisterMediaRequest : public RpcServiceRequest + { + + public: + RegisterMediaRequest(); + ~RegisterMediaRequest(); + + std::string getUserData()const; + void setUserData(const std::string& userData); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getTemplateGroupId()const; + void setTemplateGroupId(const std::string& templateGroupId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getRegisterMetadatas()const; + void setRegisterMetadatas(const std::string& registerMetadatas); + std::string getWorkFlowId()const; + void setWorkFlowId(const std::string& workFlowId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string userData_; + long resourceOwnerId_; + std::string templateGroupId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string registerMetadatas_; + std::string workFlowId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_REGISTERMEDIAREQUEST_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/RegisterMediaResult.h b/vod/include/alibabacloud/vod/model/RegisterMediaResult.h new file mode 100755 index 000000000..93b15b7b7 --- /dev/null +++ b/vod/include/alibabacloud/vod/model/RegisterMediaResult.h @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_REGISTERMEDIARESULT_H_ +#define ALIBABACLOUD_VOD_MODEL_REGISTERMEDIARESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT RegisterMediaResult : public ServiceResult + { + public: + struct RegisteredMedia + { + std::string fileURL; + std::string mediaId; + bool newRegister; + }; + + + RegisterMediaResult(); + explicit RegisterMediaResult(const std::string &payload); + ~RegisterMediaResult(); + std::vector getFailedFileURLs()const; + std::vector getRegisteredMediaList()const; + + protected: + void parse(const std::string &payload); + private: + std::vector failedFileURLs_; + std::vector registeredMediaList_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_REGISTERMEDIARESULT_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/SearchMediaResult.h b/vod/include/alibabacloud/vod/model/SearchMediaResult.h index 6d943db84..82c7d92b2 100755 --- a/vod/include/alibabacloud/vod/model/SearchMediaResult.h +++ b/vod/include/alibabacloud/vod/model/SearchMediaResult.h @@ -81,11 +81,29 @@ namespace AlibabaCloud std::string tags; std::string audioId; }; + struct Image + { + std::string ext; + std::string status; + std::string description; + std::string title; + std::string modificationTime; + long cateId; + std::string cateName; + std::string uRL; + std::string type; + std::string imageId; + std::string creationTime; + std::string regionId; + std::string storageLocation; + std::string tags; + }; std::string mediaId; Video video; std::string creationTime; std::string mediaType; Audio audio; + Image image; }; diff --git a/vod/include/alibabacloud/vod/model/SetDefaultWatermarkRequest.h b/vod/include/alibabacloud/vod/model/SetDefaultWatermarkRequest.h new file mode 100755 index 000000000..cacb90bef --- /dev/null +++ b/vod/include/alibabacloud/vod/model/SetDefaultWatermarkRequest.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKREQUEST_H_ +#define ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT SetDefaultWatermarkRequest : public RpcServiceRequest + { + + public: + SetDefaultWatermarkRequest(); + ~SetDefaultWatermarkRequest(); + + std::string getWatermarkId()const; + void setWatermarkId(const std::string& watermarkId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string watermarkId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKREQUEST_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/SetDefaultWatermarkResult.h b/vod/include/alibabacloud/vod/model/SetDefaultWatermarkResult.h new file mode 100755 index 000000000..b700263f7 --- /dev/null +++ b/vod/include/alibabacloud/vod/model/SetDefaultWatermarkResult.h @@ -0,0 +1,49 @@ +/* + * 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_VOD_MODEL_SETDEFAULTWATERMARKRESULT_H_ +#define ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT SetDefaultWatermarkResult : public ServiceResult + { + public: + + + SetDefaultWatermarkResult(); + explicit SetDefaultWatermarkResult(const std::string &payload); + ~SetDefaultWatermarkResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKRESULT_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/SubmitTranscodeJobsRequest.h b/vod/include/alibabacloud/vod/model/SubmitTranscodeJobsRequest.h index 83ed9f955..7e287998f 100755 --- a/vod/include/alibabacloud/vod/model/SubmitTranscodeJobsRequest.h +++ b/vod/include/alibabacloud/vod/model/SubmitTranscodeJobsRequest.h @@ -43,6 +43,8 @@ namespace AlibabaCloud void setResourceOwnerAccount(const std::string& resourceOwnerAccount); std::string getVideoId()const; void setVideoId(const std::string& videoId); + std::string getOverrideParams()const; + void setOverrideParams(const std::string& overrideParams); long getOwnerId()const; void setOwnerId(long ownerId); std::string getEncryptConfig()const; @@ -57,6 +59,7 @@ namespace AlibabaCloud std::string templateGroupId_; std::string resourceOwnerAccount_; std::string videoId_; + std::string overrideParams_; long ownerId_; std::string encryptConfig_; std::string accessKeyId_; diff --git a/vod/include/alibabacloud/vod/model/UpdateWatermarkRequest.h b/vod/include/alibabacloud/vod/model/UpdateWatermarkRequest.h new file mode 100755 index 000000000..dbe748951 --- /dev/null +++ b/vod/include/alibabacloud/vod/model/UpdateWatermarkRequest.h @@ -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_VOD_MODEL_UPDATEWATERMARKREQUEST_H_ +#define ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT UpdateWatermarkRequest : public RpcServiceRequest + { + + public: + UpdateWatermarkRequest(); + ~UpdateWatermarkRequest(); + + std::string getWatermarkId()const; + void setWatermarkId(const std::string& watermarkId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getName()const; + void setName(const std::string& name); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getWatermarkConfig()const; + void setWatermarkConfig(const std::string& watermarkConfig); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string watermarkId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string name_; + long ownerId_; + std::string watermarkConfig_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKREQUEST_H_ \ No newline at end of file diff --git a/vod/include/alibabacloud/vod/model/UpdateWatermarkResult.h b/vod/include/alibabacloud/vod/model/UpdateWatermarkResult.h new file mode 100755 index 000000000..b11fc24d2 --- /dev/null +++ b/vod/include/alibabacloud/vod/model/UpdateWatermarkResult.h @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKRESULT_H_ +#define ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Vod + { + namespace Model + { + class ALIBABACLOUD_VOD_EXPORT UpdateWatermarkResult : public ServiceResult + { + public: + struct WatermarkInfo + { + std::string isDefault; + std::string fileUrl; + std::string type; + std::string watermarkId; + std::string creationTime; + std::string watermarkConfig; + std::string name; + }; + + + UpdateWatermarkResult(); + explicit UpdateWatermarkResult(const std::string &payload); + ~UpdateWatermarkResult(); + WatermarkInfo getWatermarkInfo()const; + + protected: + void parse(const std::string &payload); + private: + WatermarkInfo watermarkInfo_; + + }; + } + } +} +#endif // !ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKRESULT_H_ \ No newline at end of file diff --git a/vod/src/.DS_Store b/vod/src/.DS_Store index 9a9388cba..787c730e6 100644 Binary files a/vod/src/.DS_Store and b/vod/src/.DS_Store differ diff --git a/vod/src/VodClient.cc b/vod/src/VodClient.cc index 0fca964bd..b3ac6ab1e 100755 --- a/vod/src/VodClient.cc +++ b/vod/src/VodClient.cc @@ -771,6 +771,42 @@ VodClient::DescribeRefreshTasksOutcomeCallable VodClient::describeRefreshTasksCa return task->get_future(); } +VodClient::DeleteWatermarkOutcome VodClient::deleteWatermark(const DeleteWatermarkRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteWatermarkOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteWatermarkOutcome(DeleteWatermarkResult(outcome.result())); + else + return DeleteWatermarkOutcome(outcome.error()); +} + +void VodClient::deleteWatermarkAsync(const DeleteWatermarkRequest& request, const DeleteWatermarkAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteWatermark(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +VodClient::DeleteWatermarkOutcomeCallable VodClient::deleteWatermarkCallable(const DeleteWatermarkRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteWatermark(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + VodClient::UpdateCategoryOutcome VodClient::updateCategory(const UpdateCategoryRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -807,6 +843,42 @@ VodClient::UpdateCategoryOutcomeCallable VodClient::updateCategoryCallable(const return task->get_future(); } +VodClient::RegisterMediaOutcome VodClient::registerMedia(const RegisterMediaRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RegisterMediaOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RegisterMediaOutcome(RegisterMediaResult(outcome.result())); + else + return RegisterMediaOutcome(outcome.error()); +} + +void VodClient::registerMediaAsync(const RegisterMediaRequest& request, const RegisterMediaAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, registerMedia(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +VodClient::RegisterMediaOutcomeCallable VodClient::registerMediaCallable(const RegisterMediaRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->registerMedia(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + VodClient::ListAIASRJobOutcome VodClient::listAIASRJob(const ListAIASRJobRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -878,6 +950,7 @@ VodClient::ListAIVideoCensorJobOutcomeCallable VodClient::listAIVideoCensorJobCa asyncExecute(new Runnable([task]() { (*task)(); })); return task->get_future(); } + VodClient::DescribeRefreshQuotaOutcome VodClient::describeRefreshQuota(const DescribeRefreshQuotaRequest &request) const { @@ -1203,6 +1276,78 @@ VodClient::GetVideoConfigOutcomeCallable VodClient::getVideoConfigCallable(const return task->get_future(); } +VodClient::AddWatermarkOutcome VodClient::addWatermark(const AddWatermarkRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AddWatermarkOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AddWatermarkOutcome(AddWatermarkResult(outcome.result())); + else + return AddWatermarkOutcome(outcome.error()); +} + +void VodClient::addWatermarkAsync(const AddWatermarkRequest& request, const AddWatermarkAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, addWatermark(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +VodClient::AddWatermarkOutcomeCallable VodClient::addWatermarkCallable(const AddWatermarkRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->addWatermark(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +VodClient::ListWatermarkOutcome VodClient::listWatermark(const ListWatermarkRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListWatermarkOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListWatermarkOutcome(ListWatermarkResult(outcome.result())); + else + return ListWatermarkOutcome(outcome.error()); +} + +void VodClient::listWatermarkAsync(const ListWatermarkRequest& request, const ListWatermarkAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listWatermark(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +VodClient::ListWatermarkOutcomeCallable VodClient::listWatermarkCallable(const ListWatermarkRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listWatermark(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + VodClient::CreateUploadImageOutcome VodClient::createUploadImage(const CreateUploadImageRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1383,6 +1528,42 @@ VodClient::DescribePlayTopVideosOutcomeCallable VodClient::describePlayTopVideos return task->get_future(); } +VodClient::SetDefaultWatermarkOutcome VodClient::setDefaultWatermark(const SetDefaultWatermarkRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return SetDefaultWatermarkOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetDefaultWatermarkOutcome(SetDefaultWatermarkResult(outcome.result())); + else + return SetDefaultWatermarkOutcome(outcome.error()); +} + +void VodClient::setDefaultWatermarkAsync(const SetDefaultWatermarkRequest& request, const SetDefaultWatermarkAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setDefaultWatermark(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +VodClient::SetDefaultWatermarkOutcomeCallable VodClient::setDefaultWatermarkCallable(const SetDefaultWatermarkRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setDefaultWatermark(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + VodClient::PushObjectCacheOutcome VodClient::pushObjectCache(const PushObjectCacheRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1779,6 +1960,78 @@ VodClient::SearchEditingProjectOutcomeCallable VodClient::searchEditingProjectCa return task->get_future(); } +VodClient::GetWatermarkOutcome VodClient::getWatermark(const GetWatermarkRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetWatermarkOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetWatermarkOutcome(GetWatermarkResult(outcome.result())); + else + return GetWatermarkOutcome(outcome.error()); +} + +void VodClient::getWatermarkAsync(const GetWatermarkRequest& request, const GetWatermarkAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getWatermark(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +VodClient::GetWatermarkOutcomeCallable VodClient::getWatermarkCallable(const GetWatermarkRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getWatermark(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +VodClient::UpdateWatermarkOutcome VodClient::updateWatermark(const UpdateWatermarkRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateWatermarkOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateWatermarkOutcome(UpdateWatermarkResult(outcome.result())); + else + return UpdateWatermarkOutcome(outcome.error()); +} + +void VodClient::updateWatermarkAsync(const UpdateWatermarkRequest& request, const UpdateWatermarkAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateWatermark(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +VodClient::UpdateWatermarkOutcomeCallable VodClient::updateWatermarkCallable(const UpdateWatermarkRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateWatermark(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + VodClient::GetImageInfoOutcome VodClient::getImageInfo(const GetImageInfoRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/vod/src/model/AddWatermarkRequest.cc b/vod/src/model/AddWatermarkRequest.cc new file mode 100755 index 000000000..2657a2834 --- /dev/null +++ b/vod/src/model/AddWatermarkRequest.cc @@ -0,0 +1,115 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Vod::Model::AddWatermarkRequest; + +AddWatermarkRequest::AddWatermarkRequest() : + RpcServiceRequest("vod", "2017-03-21", "AddWatermark") +{} + +AddWatermarkRequest::~AddWatermarkRequest() +{} + +long AddWatermarkRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void AddWatermarkRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string AddWatermarkRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void AddWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string AddWatermarkRequest::getName()const +{ + return name_; +} + +void AddWatermarkRequest::setName(const std::string& name) +{ + name_ = name; + setParameter("Name", name); +} + +std::string AddWatermarkRequest::getFileUrl()const +{ + return fileUrl_; +} + +void AddWatermarkRequest::setFileUrl(const std::string& fileUrl) +{ + fileUrl_ = fileUrl; + setParameter("FileUrl", fileUrl); +} + +long AddWatermarkRequest::getOwnerId()const +{ + return ownerId_; +} + +void AddWatermarkRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string AddWatermarkRequest::getType()const +{ + return type_; +} + +void AddWatermarkRequest::setType(const std::string& type) +{ + type_ = type; + setParameter("Type", type); +} + +std::string AddWatermarkRequest::getWatermarkConfig()const +{ + return watermarkConfig_; +} + +void AddWatermarkRequest::setWatermarkConfig(const std::string& watermarkConfig) +{ + watermarkConfig_ = watermarkConfig; + setParameter("WatermarkConfig", watermarkConfig); +} + +std::string AddWatermarkRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void AddWatermarkRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/vod/src/model/AddWatermarkResult.cc b/vod/src/model/AddWatermarkResult.cc new file mode 100755 index 000000000..e9f6816a8 --- /dev/null +++ b/vod/src/model/AddWatermarkResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Vod; +using namespace AlibabaCloud::Vod::Model; + +AddWatermarkResult::AddWatermarkResult() : + ServiceResult() +{} + +AddWatermarkResult::AddWatermarkResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AddWatermarkResult::~AddWatermarkResult() +{} + +void AddWatermarkResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto watermarkInfoNode = value["WatermarkInfo"]; + if(!watermarkInfoNode["CreationTime"].isNull()) + watermarkInfo_.creationTime = watermarkInfoNode["CreationTime"].asString(); + if(!watermarkInfoNode["Type"].isNull()) + watermarkInfo_.type = watermarkInfoNode["Type"].asString(); + if(!watermarkInfoNode["IsDefault"].isNull()) + watermarkInfo_.isDefault = watermarkInfoNode["IsDefault"].asString(); + if(!watermarkInfoNode["WatermarkId"].isNull()) + watermarkInfo_.watermarkId = watermarkInfoNode["WatermarkId"].asString(); + if(!watermarkInfoNode["Name"].isNull()) + watermarkInfo_.name = watermarkInfoNode["Name"].asString(); + if(!watermarkInfoNode["FileUrl"].isNull()) + watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString(); + if(!watermarkInfoNode["WatermarkConfig"].isNull()) + watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString(); + +} + +AddWatermarkResult::WatermarkInfo AddWatermarkResult::getWatermarkInfo()const +{ + return watermarkInfo_; +} + diff --git a/vod/src/model/DeleteWatermarkRequest.cc b/vod/src/model/DeleteWatermarkRequest.cc new file mode 100755 index 000000000..84e70d08e --- /dev/null +++ b/vod/src/model/DeleteWatermarkRequest.cc @@ -0,0 +1,82 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Vod::Model::DeleteWatermarkRequest; + +DeleteWatermarkRequest::DeleteWatermarkRequest() : + RpcServiceRequest("vod", "2017-03-21", "DeleteWatermark") +{} + +DeleteWatermarkRequest::~DeleteWatermarkRequest() +{} + +std::string DeleteWatermarkRequest::getWatermarkId()const +{ + return watermarkId_; +} + +void DeleteWatermarkRequest::setWatermarkId(const std::string& watermarkId) +{ + watermarkId_ = watermarkId; + setParameter("WatermarkId", watermarkId); +} + +long DeleteWatermarkRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DeleteWatermarkRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DeleteWatermarkRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long DeleteWatermarkRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteWatermarkRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteWatermarkRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteWatermarkRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/vod/src/model/DeleteWatermarkResult.cc b/vod/src/model/DeleteWatermarkResult.cc new file mode 100755 index 000000000..75521a171 --- /dev/null +++ b/vod/src/model/DeleteWatermarkResult.cc @@ -0,0 +1,45 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Vod; +using namespace AlibabaCloud::Vod::Model; + +DeleteWatermarkResult::DeleteWatermarkResult() : + ServiceResult() +{} + +DeleteWatermarkResult::DeleteWatermarkResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteWatermarkResult::~DeleteWatermarkResult() +{} + +void DeleteWatermarkResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/vod/src/model/GetVideoListRequest.cc b/vod/src/model/GetVideoListRequest.cc index 2cfcf3572..32f754ed9 100755 --- a/vod/src/model/GetVideoListRequest.cc +++ b/vod/src/model/GetVideoListRequest.cc @@ -135,3 +135,14 @@ void GetVideoListRequest::setStatus(const std::string& status) setParameter("Status", status); } +std::string GetVideoListRequest::getStorageLocation()const +{ + return storageLocation_; +} + +void GetVideoListRequest::setStorageLocation(const std::string& storageLocation) +{ + storageLocation_ = storageLocation; + setParameter("StorageLocation", storageLocation); +} + diff --git a/vod/src/model/GetVideoListResult.cc b/vod/src/model/GetVideoListResult.cc index 9d0934123..e702a8828 100755 --- a/vod/src/model/GetVideoListResult.cc +++ b/vod/src/model/GetVideoListResult.cc @@ -72,6 +72,8 @@ void GetVideoListResult::parse(const std::string &payload) videoListObject.cateId = std::stol(value["CateId"].asString()); if(!value["CateName"].isNull()) videoListObject.cateName = value["CateName"].asString(); + if(!value["StorageLocation"].isNull()) + videoListObject.storageLocation = value["StorageLocation"].asString(); auto allSnapshots = value["Snapshots"]["Snapshot"]; for (auto value : allSnapshots) videoListObject.snapshots.push_back(value.asString()); diff --git a/vod/src/model/GetWatermarkRequest.cc b/vod/src/model/GetWatermarkRequest.cc new file mode 100755 index 000000000..aa1491f7d --- /dev/null +++ b/vod/src/model/GetWatermarkRequest.cc @@ -0,0 +1,82 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Vod::Model::GetWatermarkRequest; + +GetWatermarkRequest::GetWatermarkRequest() : + RpcServiceRequest("vod", "2017-03-21", "GetWatermark") +{} + +GetWatermarkRequest::~GetWatermarkRequest() +{} + +std::string GetWatermarkRequest::getWatermarkId()const +{ + return watermarkId_; +} + +void GetWatermarkRequest::setWatermarkId(const std::string& watermarkId) +{ + watermarkId_ = watermarkId; + setParameter("WatermarkId", watermarkId); +} + +long GetWatermarkRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void GetWatermarkRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string GetWatermarkRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void GetWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long GetWatermarkRequest::getOwnerId()const +{ + return ownerId_; +} + +void GetWatermarkRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string GetWatermarkRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void GetWatermarkRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/vod/src/model/GetWatermarkResult.cc b/vod/src/model/GetWatermarkResult.cc new file mode 100755 index 000000000..f8b3f3b42 --- /dev/null +++ b/vod/src/model/GetWatermarkResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Vod; +using namespace AlibabaCloud::Vod::Model; + +GetWatermarkResult::GetWatermarkResult() : + ServiceResult() +{} + +GetWatermarkResult::GetWatermarkResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetWatermarkResult::~GetWatermarkResult() +{} + +void GetWatermarkResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto watermarkInfoNode = value["WatermarkInfo"]; + if(!watermarkInfoNode["CreationTime"].isNull()) + watermarkInfo_.creationTime = watermarkInfoNode["CreationTime"].asString(); + if(!watermarkInfoNode["Type"].isNull()) + watermarkInfo_.type = watermarkInfoNode["Type"].asString(); + if(!watermarkInfoNode["IsDefault"].isNull()) + watermarkInfo_.isDefault = watermarkInfoNode["IsDefault"].asString(); + if(!watermarkInfoNode["WatermarkId"].isNull()) + watermarkInfo_.watermarkId = watermarkInfoNode["WatermarkId"].asString(); + if(!watermarkInfoNode["Name"].isNull()) + watermarkInfo_.name = watermarkInfoNode["Name"].asString(); + if(!watermarkInfoNode["FileUrl"].isNull()) + watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString(); + if(!watermarkInfoNode["WatermarkConfig"].isNull()) + watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString(); + +} + +GetWatermarkResult::WatermarkInfo GetWatermarkResult::getWatermarkInfo()const +{ + return watermarkInfo_; +} + diff --git a/vod/src/model/ListWatermarkRequest.cc b/vod/src/model/ListWatermarkRequest.cc new file mode 100755 index 000000000..e30a73b16 --- /dev/null +++ b/vod/src/model/ListWatermarkRequest.cc @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Vod::Model::ListWatermarkRequest; + +ListWatermarkRequest::ListWatermarkRequest() : + RpcServiceRequest("vod", "2017-03-21", "ListWatermark") +{} + +ListWatermarkRequest::~ListWatermarkRequest() +{} + +long ListWatermarkRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void ListWatermarkRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string ListWatermarkRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void ListWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long ListWatermarkRequest::getOwnerId()const +{ + return ownerId_; +} + +void ListWatermarkRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string ListWatermarkRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ListWatermarkRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/vod/src/model/ListWatermarkResult.cc b/vod/src/model/ListWatermarkResult.cc new file mode 100755 index 000000000..5ef614668 --- /dev/null +++ b/vod/src/model/ListWatermarkResult.cc @@ -0,0 +1,70 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Vod; +using namespace AlibabaCloud::Vod::Model; + +ListWatermarkResult::ListWatermarkResult() : + ServiceResult() +{} + +ListWatermarkResult::ListWatermarkResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListWatermarkResult::~ListWatermarkResult() +{} + +void ListWatermarkResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allWatermarkInfos = value["WatermarkInfos"]["WatermarkInfo"]; + for (auto value : allWatermarkInfos) + { + WatermarkInfo watermarkInfosObject; + if(!value["CreationTime"].isNull()) + watermarkInfosObject.creationTime = value["CreationTime"].asString(); + if(!value["Type"].isNull()) + watermarkInfosObject.type = value["Type"].asString(); + if(!value["IsDefault"].isNull()) + watermarkInfosObject.isDefault = value["IsDefault"].asString(); + if(!value["WatermarkId"].isNull()) + watermarkInfosObject.watermarkId = value["WatermarkId"].asString(); + if(!value["Name"].isNull()) + watermarkInfosObject.name = value["Name"].asString(); + if(!value["FileUrl"].isNull()) + watermarkInfosObject.fileUrl = value["FileUrl"].asString(); + if(!value["WatermarkConfig"].isNull()) + watermarkInfosObject.watermarkConfig = value["WatermarkConfig"].asString(); + watermarkInfos_.push_back(watermarkInfosObject); + } + +} + +std::vector ListWatermarkResult::getWatermarkInfos()const +{ + return watermarkInfos_; +} + diff --git a/vod/src/model/RegisterMediaRequest.cc b/vod/src/model/RegisterMediaRequest.cc new file mode 100755 index 000000000..23df73e7d --- /dev/null +++ b/vod/src/model/RegisterMediaRequest.cc @@ -0,0 +1,115 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Vod::Model::RegisterMediaRequest; + +RegisterMediaRequest::RegisterMediaRequest() : + RpcServiceRequest("vod", "2017-03-21", "RegisterMedia") +{} + +RegisterMediaRequest::~RegisterMediaRequest() +{} + +std::string RegisterMediaRequest::getUserData()const +{ + return userData_; +} + +void RegisterMediaRequest::setUserData(const std::string& userData) +{ + userData_ = userData; + setParameter("UserData", userData); +} + +long RegisterMediaRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void RegisterMediaRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string RegisterMediaRequest::getTemplateGroupId()const +{ + return templateGroupId_; +} + +void RegisterMediaRequest::setTemplateGroupId(const std::string& templateGroupId) +{ + templateGroupId_ = templateGroupId; + setParameter("TemplateGroupId", templateGroupId); +} + +std::string RegisterMediaRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void RegisterMediaRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long RegisterMediaRequest::getOwnerId()const +{ + return ownerId_; +} + +void RegisterMediaRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string RegisterMediaRequest::getRegisterMetadatas()const +{ + return registerMetadatas_; +} + +void RegisterMediaRequest::setRegisterMetadatas(const std::string& registerMetadatas) +{ + registerMetadatas_ = registerMetadatas; + setParameter("RegisterMetadatas", registerMetadatas); +} + +std::string RegisterMediaRequest::getWorkFlowId()const +{ + return workFlowId_; +} + +void RegisterMediaRequest::setWorkFlowId(const std::string& workFlowId) +{ + workFlowId_ = workFlowId; + setParameter("WorkFlowId", workFlowId); +} + +std::string RegisterMediaRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void RegisterMediaRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/vod/src/model/RegisterMediaResult.cc b/vod/src/model/RegisterMediaResult.cc new file mode 100755 index 000000000..91fae4c76 --- /dev/null +++ b/vod/src/model/RegisterMediaResult.cc @@ -0,0 +1,70 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Vod; +using namespace AlibabaCloud::Vod::Model; + +RegisterMediaResult::RegisterMediaResult() : + ServiceResult() +{} + +RegisterMediaResult::RegisterMediaResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RegisterMediaResult::~RegisterMediaResult() +{} + +void RegisterMediaResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allRegisteredMediaList = value["RegisteredMediaList"]["RegisteredMedia"]; + for (auto value : allRegisteredMediaList) + { + RegisteredMedia registeredMediaListObject; + if(!value["MediaId"].isNull()) + registeredMediaListObject.mediaId = value["MediaId"].asString(); + if(!value["FileURL"].isNull()) + registeredMediaListObject.fileURL = value["FileURL"].asString(); + if(!value["NewRegister"].isNull()) + registeredMediaListObject.newRegister = value["NewRegister"].asString() == "true"; + registeredMediaList_.push_back(registeredMediaListObject); + } + auto allFailedFileURLs = value["FailedFileURLs"]["FileURL"]; + for (const auto &item : allFailedFileURLs) + failedFileURLs_.push_back(item.asString()); + +} + +std::vector RegisterMediaResult::getFailedFileURLs()const +{ + return failedFileURLs_; +} + +std::vector RegisterMediaResult::getRegisteredMediaList()const +{ + return registeredMediaList_; +} + diff --git a/vod/src/model/SearchMediaResult.cc b/vod/src/model/SearchMediaResult.cc index d433f39bc..3f1862937 100755 --- a/vod/src/model/SearchMediaResult.cc +++ b/vod/src/model/SearchMediaResult.cc @@ -138,6 +138,35 @@ void SearchMediaResult::parse(const std::string &payload) auto allSpriteSnapshots2 = audioNode["SpriteSnapshots"]["SpriteSnapshot"]; for (auto value : allSpriteSnapshots2) mediaListObject.audio.spriteSnapshots2.push_back(value.asString()); + auto imageNode = value["Image"]; + if(!imageNode["Title"].isNull()) + mediaListObject.image.title = imageNode["Title"].asString(); + if(!imageNode["ImageId"].isNull()) + mediaListObject.image.imageId = imageNode["ImageId"].asString(); + if(!imageNode["CateId"].isNull()) + mediaListObject.image.cateId = std::stol(imageNode["CateId"].asString()); + if(!imageNode["CateName"].isNull()) + mediaListObject.image.cateName = imageNode["CateName"].asString(); + if(!imageNode["Ext"].isNull()) + mediaListObject.image.ext = imageNode["Ext"].asString(); + if(!imageNode["CreationTime"].isNull()) + mediaListObject.image.creationTime = imageNode["CreationTime"].asString(); + if(!imageNode["ModificationTime"].isNull()) + mediaListObject.image.modificationTime = imageNode["ModificationTime"].asString(); + if(!imageNode["Tags"].isNull()) + mediaListObject.image.tags = imageNode["Tags"].asString(); + if(!imageNode["Type"].isNull()) + mediaListObject.image.type = imageNode["Type"].asString(); + if(!imageNode["URL"].isNull()) + mediaListObject.image.uRL = imageNode["URL"].asString(); + if(!imageNode["Status"].isNull()) + mediaListObject.image.status = imageNode["Status"].asString(); + if(!imageNode["Description"].isNull()) + mediaListObject.image.description = imageNode["Description"].asString(); + if(!imageNode["StorageLocation"].isNull()) + mediaListObject.image.storageLocation = imageNode["StorageLocation"].asString(); + if(!imageNode["RegionId"].isNull()) + mediaListObject.image.regionId = imageNode["RegionId"].asString(); mediaList_.push_back(mediaListObject); } if(!value["ScrollToken"].isNull()) diff --git a/vod/src/model/SetDefaultWatermarkRequest.cc b/vod/src/model/SetDefaultWatermarkRequest.cc new file mode 100755 index 000000000..c99588bab --- /dev/null +++ b/vod/src/model/SetDefaultWatermarkRequest.cc @@ -0,0 +1,82 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Vod::Model::SetDefaultWatermarkRequest; + +SetDefaultWatermarkRequest::SetDefaultWatermarkRequest() : + RpcServiceRequest("vod", "2017-03-21", "SetDefaultWatermark") +{} + +SetDefaultWatermarkRequest::~SetDefaultWatermarkRequest() +{} + +std::string SetDefaultWatermarkRequest::getWatermarkId()const +{ + return watermarkId_; +} + +void SetDefaultWatermarkRequest::setWatermarkId(const std::string& watermarkId) +{ + watermarkId_ = watermarkId; + setParameter("WatermarkId", watermarkId); +} + +long SetDefaultWatermarkRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetDefaultWatermarkRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetDefaultWatermarkRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetDefaultWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long SetDefaultWatermarkRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetDefaultWatermarkRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetDefaultWatermarkRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetDefaultWatermarkRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/vod/src/model/SetDefaultWatermarkResult.cc b/vod/src/model/SetDefaultWatermarkResult.cc new file mode 100755 index 000000000..4f0a8ce96 --- /dev/null +++ b/vod/src/model/SetDefaultWatermarkResult.cc @@ -0,0 +1,45 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Vod; +using namespace AlibabaCloud::Vod::Model; + +SetDefaultWatermarkResult::SetDefaultWatermarkResult() : + ServiceResult() +{} + +SetDefaultWatermarkResult::SetDefaultWatermarkResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetDefaultWatermarkResult::~SetDefaultWatermarkResult() +{} + +void SetDefaultWatermarkResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/vod/src/model/SubmitTranscodeJobsRequest.cc b/vod/src/model/SubmitTranscodeJobsRequest.cc index d7881d1e7..f146fa29d 100755 --- a/vod/src/model/SubmitTranscodeJobsRequest.cc +++ b/vod/src/model/SubmitTranscodeJobsRequest.cc @@ -69,6 +69,17 @@ void SubmitTranscodeJobsRequest::setVideoId(const std::string& videoId) setParameter("VideoId", videoId); } +std::string SubmitTranscodeJobsRequest::getOverrideParams()const +{ + return overrideParams_; +} + +void SubmitTranscodeJobsRequest::setOverrideParams(const std::string& overrideParams) +{ + overrideParams_ = overrideParams; + setParameter("OverrideParams", overrideParams); +} + long SubmitTranscodeJobsRequest::getOwnerId()const { return ownerId_; diff --git a/vod/src/model/UpdateWatermarkRequest.cc b/vod/src/model/UpdateWatermarkRequest.cc new file mode 100755 index 000000000..14edd03c3 --- /dev/null +++ b/vod/src/model/UpdateWatermarkRequest.cc @@ -0,0 +1,104 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Vod::Model::UpdateWatermarkRequest; + +UpdateWatermarkRequest::UpdateWatermarkRequest() : + RpcServiceRequest("vod", "2017-03-21", "UpdateWatermark") +{} + +UpdateWatermarkRequest::~UpdateWatermarkRequest() +{} + +std::string UpdateWatermarkRequest::getWatermarkId()const +{ + return watermarkId_; +} + +void UpdateWatermarkRequest::setWatermarkId(const std::string& watermarkId) +{ + watermarkId_ = watermarkId; + setParameter("WatermarkId", watermarkId); +} + +long UpdateWatermarkRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void UpdateWatermarkRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string UpdateWatermarkRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void UpdateWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string UpdateWatermarkRequest::getName()const +{ + return name_; +} + +void UpdateWatermarkRequest::setName(const std::string& name) +{ + name_ = name; + setParameter("Name", name); +} + +long UpdateWatermarkRequest::getOwnerId()const +{ + return ownerId_; +} + +void UpdateWatermarkRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string UpdateWatermarkRequest::getWatermarkConfig()const +{ + return watermarkConfig_; +} + +void UpdateWatermarkRequest::setWatermarkConfig(const std::string& watermarkConfig) +{ + watermarkConfig_ = watermarkConfig; + setParameter("WatermarkConfig", watermarkConfig); +} + +std::string UpdateWatermarkRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void UpdateWatermarkRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/vod/src/model/UpdateWatermarkResult.cc b/vod/src/model/UpdateWatermarkResult.cc new file mode 100755 index 000000000..085e9aee9 --- /dev/null +++ b/vod/src/model/UpdateWatermarkResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Vod; +using namespace AlibabaCloud::Vod::Model; + +UpdateWatermarkResult::UpdateWatermarkResult() : + ServiceResult() +{} + +UpdateWatermarkResult::UpdateWatermarkResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateWatermarkResult::~UpdateWatermarkResult() +{} + +void UpdateWatermarkResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto watermarkInfoNode = value["WatermarkInfo"]; + if(!watermarkInfoNode["CreationTime"].isNull()) + watermarkInfo_.creationTime = watermarkInfoNode["CreationTime"].asString(); + if(!watermarkInfoNode["Type"].isNull()) + watermarkInfo_.type = watermarkInfoNode["Type"].asString(); + if(!watermarkInfoNode["IsDefault"].isNull()) + watermarkInfo_.isDefault = watermarkInfoNode["IsDefault"].asString(); + if(!watermarkInfoNode["WatermarkId"].isNull()) + watermarkInfo_.watermarkId = watermarkInfoNode["WatermarkId"].asString(); + if(!watermarkInfoNode["Name"].isNull()) + watermarkInfo_.name = watermarkInfoNode["Name"].asString(); + if(!watermarkInfoNode["FileUrl"].isNull()) + watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString(); + if(!watermarkInfoNode["WatermarkConfig"].isNull()) + watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString(); + +} + +UpdateWatermarkResult::WatermarkInfo UpdateWatermarkResult::getWatermarkInfo()const +{ + return watermarkInfo_; +} +