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

Add a new field named Input to SubmitAIJob api request to set the input file of AI job.

Browse Source
This commit is contained in:
sdk-team
2019-07-18 15:26:41 +08:00
parent 6d801b67b6
commit af8563e7c6
102 changed files with 4200 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG
View File

@@ -1,3 +1,7 @@
2019-07-18 Version 1.36.66
- Add a new field named Input to SubmitAIJob api request to set the input file of AI job.
- Change the field MediaId of SubmitAIJob api to non-mandatory.
2019-07-14 Version 1.36.65
- Modify DBS API DescribeBackupPlanList.

2
VERSION
View File

@@ -1 +1 @@
1.36.65
1.36.66

3
vod/include/alibabacloud/vod/model/AddTranscodeTemplateGroupRequest.h
View File

@@ -41,6 +41,8 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getAppId()const;
void setAppId(const std::string& appId);
std::string getName()const;
void setName(const std::string& name);
long getOwnerId()const;
@@ -54,6 +56,7 @@ namespace AlibabaCloud
std::string transcodeTemplateList_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string appId_;
std::string name_;
long ownerId_;
std::string accessKeyId_;

66
vod/include/alibabacloud/vod/model/AddVodDomainRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_ADDVODDOMAINREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_ADDVODDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT AddVodDomainRequest : public RpcServiceRequest
{
public:
AddVodDomainRequest();
~AddVodDomainRequest();
std::string getSources()const;
void setSources(const std::string& sources);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getScope()const;
void setScope(const std::string& scope);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getCheckUrl()const;
void setCheckUrl(const std::string& checkUrl);
private:
std::string sources_;
std::string securityToken_;
std::string ownerAccount_;
std::string scope_;
std::string domainName_;
long ownerId_;
std::string checkUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_ADDVODDOMAINREQUEST_H_

49
vod/include/alibabacloud/vod/model/AddVodDomainResult.h Normal file
View File

@@ -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_ADDVODDOMAINRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_ADDVODDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT AddVodDomainResult : public ServiceResult
{
public:
AddVodDomainResult();
explicit AddVodDomainResult(const std::string &payload);
~AddVodDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_ADDVODDOMAINRESULT_H_

3
vod/include/alibabacloud/vod/model/AddVodTemplateRequest.h
View File

@@ -43,6 +43,8 @@ namespace AlibabaCloud
void setTemplateConfig(const std::string& templateConfig);
std::string getTemplateType()const;
void setTemplateType(const std::string& templateType);
std::string getAppId()const;
void setAppId(const std::string& appId);
std::string getName()const;
void setName(const std::string& name);
long getOwnerId()const;
@@ -55,6 +57,7 @@ namespace AlibabaCloud
std::string resourceOwnerAccount_;
std::string templateConfig_;
std::string templateType_;
std::string appId_;
std::string name_;
long ownerId_;
std::string subTemplateType_;

3
vod/include/alibabacloud/vod/model/AddWatermarkRequest.h
View File

@@ -39,6 +39,8 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getAppId()const;
void setAppId(const std::string& appId);
std::string getName()const;
void setName(const std::string& name);
std::string getFileUrl()const;
@@ -55,6 +57,7 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string appId_;
std::string name_;
std::string fileUrl_;
long ownerId_;

60
vod/include/alibabacloud/vod/model/BatchSetVodDomainConfigsRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_BATCHSETVODDOMAINCONFIGSREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_BATCHSETVODDOMAINCONFIGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT BatchSetVodDomainConfigsRequest : public RpcServiceRequest
{
public:
BatchSetVodDomainConfigsRequest();
~BatchSetVodDomainConfigsRequest();
std::string getFunctions()const;
void setFunctions(const std::string& functions);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainNames()const;
void setDomainNames(const std::string& domainNames);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string functions_;
std::string securityToken_;
std::string domainNames_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_BATCHSETVODDOMAINCONFIGSREQUEST_H_

49
vod/include/alibabacloud/vod/model/BatchSetVodDomainConfigsResult.h Normal file
View File

@@ -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_BATCHSETVODDOMAINCONFIGSRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_BATCHSETVODDOMAINCONFIGSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT BatchSetVodDomainConfigsResult : public ServiceResult
{
public:
BatchSetVodDomainConfigsResult();
explicit BatchSetVodDomainConfigsResult(const std::string &payload);
~BatchSetVodDomainConfigsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_BATCHSETVODDOMAINCONFIGSRESULT_H_

54
vod/include/alibabacloud/vod/model/BatchStartVodDomainRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_BATCHSTARTVODDOMAINREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_BATCHSTARTVODDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT BatchStartVodDomainRequest : public RpcServiceRequest
{
public:
BatchStartVodDomainRequest();
~BatchStartVodDomainRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainNames()const;
void setDomainNames(const std::string& domainNames);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string securityToken_;
std::string domainNames_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_BATCHSTARTVODDOMAINREQUEST_H_

49
vod/include/alibabacloud/vod/model/BatchStartVodDomainResult.h Normal file
View File

@@ -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_BATCHSTARTVODDOMAINRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_BATCHSTARTVODDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT BatchStartVodDomainResult : public ServiceResult
{
public:
BatchStartVodDomainResult();
explicit BatchStartVodDomainResult(const std::string &payload);
~BatchStartVodDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_BATCHSTARTVODDOMAINRESULT_H_

54
vod/include/alibabacloud/vod/model/BatchStopVodDomainRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_BATCHSTOPVODDOMAINREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_BATCHSTOPVODDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT BatchStopVodDomainRequest : public RpcServiceRequest
{
public:
BatchStopVodDomainRequest();
~BatchStopVodDomainRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainNames()const;
void setDomainNames(const std::string& domainNames);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string securityToken_;
std::string domainNames_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_BATCHSTOPVODDOMAINREQUEST_H_

49
vod/include/alibabacloud/vod/model/BatchStopVodDomainResult.h Normal file
View File

@@ -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_BATCHSTOPVODDOMAINRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_BATCHSTOPVODDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT BatchStopVodDomainResult : public ServiceResult
{
public:
BatchStopVodDomainResult();
explicit BatchStopVodDomainResult(const std::string &payload);
~BatchStopVodDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_BATCHSTOPVODDOMAINRESULT_H_

57
vod/include/alibabacloud/vod/model/DeleteVodDomainRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DELETEVODDOMAINREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_DELETEVODDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DeleteVodDomainRequest : public RpcServiceRequest
{
public:
DeleteVodDomainRequest();
~DeleteVodDomainRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string securityToken_;
std::string ownerAccount_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DELETEVODDOMAINREQUEST_H_

49
vod/include/alibabacloud/vod/model/DeleteVodDomainResult.h Normal file
View File

@@ -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_DELETEVODDOMAINRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_DELETEVODDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DeleteVodDomainResult : public ServiceResult
{
public:
DeleteVodDomainResult();
explicit DeleteVodDomainResult(const std::string &payload);
~DeleteVodDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DELETEVODDOMAINRESULT_H_

57
vod/include/alibabacloud/vod/model/DeleteVodSpecificConfigRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DELETEVODSPECIFICCONFIGREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_DELETEVODSPECIFICCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DeleteVodSpecificConfigRequest : public RpcServiceRequest
{
public:
DeleteVodSpecificConfigRequest();
~DeleteVodSpecificConfigRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getConfigId()const;
void setConfigId(const std::string& configId);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string securityToken_;
std::string configId_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DELETEVODSPECIFICCONFIGREQUEST_H_

49
vod/include/alibabacloud/vod/model/DeleteVodSpecificConfigResult.h Normal file
View File

@@ -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_DELETEVODSPECIFICCONFIGRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_DELETEVODSPECIFICCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DeleteVodSpecificConfigResult : public ServiceResult
{
public:
DeleteVodSpecificConfigResult();
explicit DeleteVodSpecificConfigResult(const std::string &payload);
~DeleteVodSpecificConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DELETEVODSPECIFICCONFIGRESULT_H_

6
vod/include/alibabacloud/vod/model/DescribeVodAIDataRequest.h
View File

@@ -67,6 +67,8 @@ namespace AlibabaCloud
void setApp_ip(const std::string& app_ip);
std::string getPopProduct()const;
void setPopProduct(const std::string& popProduct);
std::string getAIType()const;
void setAIType(const std::string& aIType);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getCallerBid()const;
@@ -81,6 +83,8 @@ namespace AlibabaCloud
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getRegion()const;
@@ -103,6 +107,7 @@ namespace AlibabaCloud
long callerUid_;
std::string app_ip_;
std::string popProduct_;
std::string aIType_;
std::string endTime_;
std::string callerBid_;
long ownerId_;
@@ -110,6 +115,7 @@ namespace AlibabaCloud
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string serviceCode_;
std::string requestId_;
std::string region_;

54
vod/include/alibabacloud/vod/model/DescribeVodCertificateListRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODCERTIFICATELISTREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODCERTIFICATELISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodCertificateListRequest : public RpcServiceRequest
{
public:
DescribeVodCertificateListRequest();
~DescribeVodCertificateListRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODCERTIFICATELISTREQUEST_H_

65
vod/include/alibabacloud/vod/model/DescribeVodCertificateListResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODCERTIFICATELISTRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODCERTIFICATELISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodCertificateListResult : public ServiceResult
{
public:
struct CertificateListModel
{
struct Cert
{
std::string fingerprint;
std::string issuer;
long certId;
std::string certName;
long lastTime;
std::string common;
};
std::vector<Cert> certList;
int count;
};
DescribeVodCertificateListResult();
explicit DescribeVodCertificateListResult(const std::string &payload);
~DescribeVodCertificateListResult();
CertificateListModel getCertificateListModel()const;
protected:
void parse(const std::string &payload);
private:
CertificateListModel certificateListModel_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODCERTIFICATELISTRESULT_H_

117
vod/include/alibabacloud/vod/model/DescribeVodDomainCertificateInfoRequest.h Normal file
View File

@@ -0,0 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCERTIFICATEINFOREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCERTIFICATEINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodDomainCertificateInfoRequest : public RpcServiceRequest
{
public:
DescribeVodDomainCertificateInfoRequest();
~DescribeVodDomainCertificateInfoRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getPopProduct()const;
void setPopProduct(const std::string& popProduct);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
private:
long resourceOwnerId_;
long callerParentId_;
bool proxy_original_security_transport_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
std::string accessKeyId_;
std::string securityToken_;
std::string regionId_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
std::string app_ip_;
std::string popProduct_;
std::string domainName_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string serviceCode_;
std::string requestId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCERTIFICATEINFOREQUEST_H_

63
vod/include/alibabacloud/vod/model/DescribeVodDomainCertificateInfoResult.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCERTIFICATEINFORESULT_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCERTIFICATEINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodDomainCertificateInfoResult : public ServiceResult
{
public:
struct CertInfo
{
std::string status;
std::string certLife;
std::string domainName;
std::string certDomainName;
std::string certOrg;
std::string certType;
std::string certExpireTime;
std::string certName;
std::string serverCertificateStatus;
};
DescribeVodDomainCertificateInfoResult();
explicit DescribeVodDomainCertificateInfoResult(const std::string &payload);
~DescribeVodDomainCertificateInfoResult();
std::vector<CertInfo> getCertInfos()const;
protected:
void parse(const std::string &payload);
private:
std::vector<CertInfo> certInfos_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCERTIFICATEINFORESULT_H_

57
vod/include/alibabacloud/vod/model/DescribeVodDomainConfigsRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCONFIGSREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCONFIGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodDomainConfigsRequest : public RpcServiceRequest
{
public:
DescribeVodDomainConfigsRequest();
~DescribeVodDomainConfigsRequest();
std::string getFunctionNames()const;
void setFunctionNames(const std::string& functionNames);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string functionNames_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCONFIGSREQUEST_H_

63
vod/include/alibabacloud/vod/model/DescribeVodDomainConfigsResult.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCONFIGSRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCONFIGSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodDomainConfigsResult : public ServiceResult
{
public:
struct DomainConfig
{
struct FunctionArg
{
std::string argValue;
std::string argName;
};
std::string status;
std::string functionName;
std::vector<DomainConfig::FunctionArg> functionArgs;
std::string configId;
};
DescribeVodDomainConfigsResult();
explicit DescribeVodDomainConfigsResult(const std::string &payload);
~DescribeVodDomainConfigsResult();
std::vector<DomainConfig> getDomainConfigs()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DomainConfig> domainConfigs_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINCONFIGSRESULT_H_

54
vod/include/alibabacloud/vod/model/DescribeVodDomainDetailRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINDETAILREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINDETAILREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodDomainDetailRequest : public RpcServiceRequest
{
public:
DescribeVodDomainDetailRequest();
~DescribeVodDomainDetailRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINDETAILREQUEST_H_

74
vod/include/alibabacloud/vod/model/DescribeVodDomainDetailResult.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINDETAILRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINDETAILRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodDomainDetailResult : public ServiceResult
{
public:
struct DomainDetail
{
struct Source
{
std::string type;
std::string content;
std::string priority;
int port;
std::string enabled;
};
std::string description;
std::string scope;
std::string domainName;
std::string sSLPub;
std::string gmtModified;
std::string gmtCreated;
std::string certName;
std::vector<Source> sources;
std::string cname;
std::string domainStatus;
std::string weight;
std::string sSLProtocol;
};
DescribeVodDomainDetailResult();
explicit DescribeVodDomainDetailResult(const std::string &payload);
~DescribeVodDomainDetailResult();
DomainDetail getDomainDetail()const;
protected:
void parse(const std::string &payload);
private:
DomainDetail domainDetail_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODDOMAINDETAILRESULT_H_

3
vod/include/alibabacloud/vod/model/DescribeVodDomainUsageDataRequest.h
View File

@@ -89,6 +89,8 @@ namespace AlibabaCloud
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getField()const;
void setField(const std::string& field);
std::string getRequestId()const;
@@ -122,6 +124,7 @@ namespace AlibabaCloud
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string serviceCode_;
std::string field_;
std::string requestId_;

6
vod/include/alibabacloud/vod/model/DescribeVodStorageDataRequest.h
View File

@@ -43,6 +43,8 @@ namespace AlibabaCloud
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getStorage()const;
void setStorage(const std::string& storage);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
@@ -83,6 +85,8 @@ namespace AlibabaCloud
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getRegion()const;
@@ -93,6 +97,7 @@ namespace AlibabaCloud
long callerParentId_;
bool proxy_original_security_transport_;
std::string startTime_;
std::string storage_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
@@ -113,6 +118,7 @@ namespace AlibabaCloud
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string serviceCode_;
std::string requestId_;
std::string region_;

9
vod/include/alibabacloud/vod/model/DescribeVodTranscodeDataRequest.h
View File

@@ -43,6 +43,8 @@ namespace AlibabaCloud
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getStorage()const;
void setStorage(const std::string& storage);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
@@ -69,6 +71,8 @@ namespace AlibabaCloud
void setPopProduct(const std::string& popProduct);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getSpecification()const;
void setSpecification(const std::string& specification);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
@@ -81,6 +85,8 @@ namespace AlibabaCloud
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getRegion()const;
@@ -91,6 +97,7 @@ namespace AlibabaCloud
long callerParentId_;
bool proxy_original_security_transport_;
std::string startTime_;
std::string storage_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
@@ -104,12 +111,14 @@ namespace AlibabaCloud
std::string app_ip_;
std::string popProduct_;
std::string endTime_;
std::string specification_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string serviceCode_;
std::string requestId_;
std::string region_;

78
vod/include/alibabacloud/vod/model/DescribeVodUserDomainsRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODUSERDOMAINSREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODUSERDOMAINSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodUserDomainsRequest : public RpcServiceRequest
{
public:
DescribeVodUserDomainsRequest();
~DescribeVodUserDomainsRequest();
std::string getFuncFilter()const;
void setFuncFilter(const std::string& funcFilter);
bool getCheckDomainShow()const;
void setCheckDomainShow(bool checkDomainShow);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getCdnType()const;
void setCdnType(const std::string& cdnType);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getFuncId()const;
void setFuncId(const std::string& funcId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getDomainStatus()const;
void setDomainStatus(const std::string& domainStatus);
std::string getDomainSearchType()const;
void setDomainSearchType(const std::string& domainSearchType);
private:
std::string funcFilter_;
bool checkDomainShow_;
std::string securityToken_;
std::string cdnType_;
int pageSize_;
std::string domainName_;
long ownerId_;
std::string funcId_;
int pageNumber_;
std::string domainStatus_;
std::string domainSearchType_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODUSERDOMAINSREQUEST_H_

78
vod/include/alibabacloud/vod/model/DescribeVodUserDomainsResult.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_DESCRIBEVODUSERDOMAINSRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_DESCRIBEVODUSERDOMAINSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DescribeVodUserDomainsResult : public ServiceResult
{
public:
struct PageData
{
struct Source
{
std::string type;
std::string content;
std::string priority;
int port;
};
std::string description;
std::string sslProtocol;
std::string domainName;
std::string gmtModified;
std::string cdnType;
std::string gmtCreated;
std::vector<PageData::Source> sources;
std::string cname;
std::string domainStatus;
std::string weight;
std::string sandbox;
};
DescribeVodUserDomainsResult();
explicit DescribeVodUserDomainsResult(const std::string &payload);
~DescribeVodUserDomainsResult();
std::vector<PageData> getDomains()const;
long getTotalCount()const;
long getPageSize()const;
long getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
std::vector<PageData> domains_;
long totalCount_;
long pageSize_;
long pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DESCRIBEVODUSERDOMAINSRESULT_H_

6
vod/include/alibabacloud/vod/model/GetMezzanineInfoResult.h
View File

@@ -32,7 +32,7 @@ namespace AlibabaCloud
class ALIBABACLOUD_VOD_EXPORT GetMezzanineInfoResult : public ServiceResult
{
public:
struct MezzanineInGetMezzanineInfo
struct Mezzanine
{
struct AudioStream
{
@@ -100,12 +100,12 @@ namespace AlibabaCloud
GetMezzanineInfoResult();
explicit GetMezzanineInfoResult(const std::string &payload);
~GetMezzanineInfoResult();
MezzanineInGetMezzanineInfo getMezzanineInGetMezzanineInfo()const;
Mezzanine getMezzanine()const;
protected:
void parse(const std::string &payload);
private:
MezzanineInGetMezzanineInfo mezzanineInGetMezzanineInfo_;
Mezzanine mezzanine_;
};
}

2
vod/include/alibabacloud/vod/model/GetTranscodeTemplateGroupResult.h
View File

@@ -57,6 +57,8 @@ namespace AlibabaCloud
std::string isDefault;
std::string modifyTime;
std::string locked;
std::string appId;
std::string transcodeMode;
std::string transcodeTemplateGroupId;
std::vector<TranscodeTemplate> transcodeTemplateList;
std::string creationTime;

6
vod/include/alibabacloud/vod/model/GetVideoInfoResult.h
View File

@@ -32,7 +32,7 @@ namespace AlibabaCloud
class ALIBABACLOUD_VOD_EXPORT GetVideoInfoResult : public ServiceResult
{
public:
struct VideoInGetVideoInfo
struct Video
{
struct Thumbnail
{
@@ -68,14 +68,14 @@ namespace AlibabaCloud
GetVideoInfoResult();
explicit GetVideoInfoResult(const std::string &payload);
~GetVideoInfoResult();
Video getVideo()const;
std::string getAI()const;
VideoInGetVideoInfo getVideoInGetVideoInfo()const;
protected:
void parse(const std::string &payload);
private:
Video video_;
std::string aI_;
VideoInGetVideoInfo videoInGetVideoInfo_;
};
}

1
vod/include/alibabacloud/vod/model/GetWatermarkResult.h
View File

@@ -37,6 +37,7 @@ namespace AlibabaCloud
std::string isDefault;
std::string fileUrl;
std::string type;
std::string appId;
std::string watermarkId;
std::string creationTime;
std::string watermarkConfig;

4
vod/include/alibabacloud/vod/model/ListLiveRecordVideoResult.h
View File

@@ -34,7 +34,7 @@ namespace AlibabaCloud
public:
struct LiveRecordVideo
{
struct VideoInListLiveRecordVideo
struct Video
{
std::string status;
std::string modifyTime;
@@ -78,7 +78,7 @@ namespace AlibabaCloud
std::string recordStartTime;
std::string domainName;
std::string recordEndTime;
VideoInListLiveRecordVideo videoInListLiveRecordVideo;
Video video;
std::vector<LiveRecordVideo::PlayInfo> playInfoList;
std::string appName;
};

9
vod/include/alibabacloud/vod/model/ListTranscodeTemplateGroupRequest.h
View File

@@ -39,6 +39,12 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getPageNo()const;
void setPageNo(int pageNo);
std::string getAppId()const;
void setAppId(const std::string& appId);
int getPageSize()const;
void setPageSize(int pageSize);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
@@ -47,6 +53,9 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
int pageNo_;
std::string appId_;
int pageSize_;
long ownerId_;
std::string accessKeyId_;

2
vod/include/alibabacloud/vod/model/ListTranscodeTemplateGroupResult.h
View File

@@ -37,7 +37,9 @@ namespace AlibabaCloud
std::string isDefault;
std::string modifyTime;
std::string locked;
std::string appId;
std::string transcodeTemplateGroupId;
std::string transcodeMode;
std::string creationTime;
std::string name;
};

3
vod/include/alibabacloud/vod/model/ListVodTemplateRequest.h
View File

@@ -41,6 +41,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getTemplateType()const;
void setTemplateType(const std::string& templateType);
std::string getAppId()const;
void setAppId(const std::string& appId);
long getOwnerId()const;
void setOwnerId(long ownerId);
@@ -48,6 +50,7 @@ namespace AlibabaCloud
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string templateType_;
std::string appId_;
long ownerId_;
};

1
vod/include/alibabacloud/vod/model/ListVodTemplateResult.h
View File

@@ -36,6 +36,7 @@ namespace AlibabaCloud
{
std::string isDefault;
std::string modifyTime;
std::string appId;
std::string creationTime;
std::string templateConfig;
std::string templateType;

9
vod/include/alibabacloud/vod/model/ListWatermarkRequest.h
View File

@@ -39,6 +39,12 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getPageNo()const;
void setPageNo(int pageNo);
std::string getAppId()const;
void setAppId(const std::string& appId);
int getPageSize()const;
void setPageSize(int pageSize);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
@@ -47,6 +53,9 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
int pageNo_;
std::string appId_;
int pageSize_;
long ownerId_;
std::string accessKeyId_;

1
vod/include/alibabacloud/vod/model/ListWatermarkResult.h
View File

@@ -37,6 +37,7 @@ namespace AlibabaCloud
std::string isDefault;
std::string fileUrl;
std::string type;
std::string appId;
std::string watermarkId;
std::string creationTime;
std::string watermarkConfig;

6
vod/include/alibabacloud/vod/model/RegisterMediaRequest.h
View File

@@ -47,8 +47,8 @@ namespace AlibabaCloud
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 getWorkflowId()const;
void setWorkflowId(const std::string& workflowId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
@@ -59,7 +59,7 @@ namespace AlibabaCloud
std::string resourceOwnerAccount_;
long ownerId_;
std::string registerMetadatas_;
std::string workFlowId_;
std::string workflowId_;
std::string accessKeyId_;
};

4
vod/include/alibabacloud/vod/model/SearchMediaResult.h
View File

@@ -151,7 +151,7 @@ namespace AlibabaCloud
std::string storageLocation;
std::string tags;
};
struct AttachedMediaInSearchMedia
struct AttachedMedia
{
struct Category
{
@@ -177,10 +177,10 @@ namespace AlibabaCloud
std::string storageLocation;
std::string tags;
};
AttachedMedia attachedMedia;
std::string mediaId;
Video video;
std::string creationTime;
AttachedMediaInSearchMedia attachedMediaInSearchMedia;
std::string mediaType;
Audio audio;
Image image;

69
vod/include/alibabacloud/vod/model/SetVodDomainCertificateRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_SETVODDOMAINCERTIFICATEREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_SETVODDOMAINCERTIFICATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT SetVodDomainCertificateRequest : public RpcServiceRequest
{
public:
SetVodDomainCertificateRequest();
~SetVodDomainCertificateRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getSSLPub()const;
void setSSLPub(const std::string& sSLPub);
std::string getCertName()const;
void setCertName(const std::string& certName);
std::string getSSLProtocol()const;
void setSSLProtocol(const std::string& sSLProtocol);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getRegion()const;
void setRegion(const std::string& region);
std::string getSSLPri()const;
void setSSLPri(const std::string& sSLPri);
private:
std::string securityToken_;
std::string sSLPub_;
std::string certName_;
std::string sSLProtocol_;
std::string domainName_;
long ownerId_;
std::string region_;
std::string sSLPri_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_SETVODDOMAINCERTIFICATEREQUEST_H_

49
vod/include/alibabacloud/vod/model/SetVodDomainCertificateResult.h Normal file
View File

@@ -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_SETVODDOMAINCERTIFICATERESULT_H_
#define ALIBABACLOUD_VOD_MODEL_SETVODDOMAINCERTIFICATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT SetVodDomainCertificateResult : public ServiceResult
{
public:
SetVodDomainCertificateResult();
explicit SetVodDomainCertificateResult(const std::string &payload);
~SetVodDomainCertificateResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_SETVODDOMAINCERTIFICATERESULT_H_

3
vod/include/alibabacloud/vod/model/SubmitAIJobRequest.h
View File

@@ -37,6 +37,8 @@ namespace AlibabaCloud
std::string getUserData()const;
void setUserData(const std::string& userData);
std::string getInput()const;
void setInput(const std::string& input);
std::string getResourceOwnerId()const;
void setResourceOwnerId(const std::string& resourceOwnerId);
std::string getTypes()const;
@@ -56,6 +58,7 @@ namespace AlibabaCloud
private:
std::string userData_;
std::string input_;
std::string resourceOwnerId_;
std::string types_;
std::string resourceOwnerAccount_;

3
vod/include/alibabacloud/vod/model/SubmitTranscodeJobsRequest.h
View File

@@ -35,6 +35,8 @@ namespace AlibabaCloud
SubmitTranscodeJobsRequest();
~SubmitTranscodeJobsRequest();
std::string getUserData()const;
void setUserData(const std::string& userData);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getTemplateGroupId()const;
@@ -57,6 +59,7 @@ namespace AlibabaCloud
void setPipelineId(const std::string& pipelineId);
private:
std::string userData_;
long resourceOwnerId_;
std::string templateGroupId_;
std::string resourceOwnerAccount_;

2
vod/include/alibabacloud/vod/model/SubmitTranscodeJobsResult.h
View File

@@ -42,11 +42,13 @@ namespace AlibabaCloud
explicit SubmitTranscodeJobsResult(const std::string &payload);
~SubmitTranscodeJobsResult();
std::vector<TranscodeJob> getTranscodeJobs()const;
std::string getTranscodeTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::vector<TranscodeJob> transcodeJobs_;
std::string transcodeTaskId_;
};
}

60
vod/include/alibabacloud/vod/model/UpdateVodDomainRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VOD_MODEL_UPDATEVODDOMAINREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_UPDATEVODDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT UpdateVodDomainRequest : public RpcServiceRequest
{
public:
UpdateVodDomainRequest();
~UpdateVodDomainRequest();
std::string getTopLevelDomain()const;
void setTopLevelDomain(const std::string& topLevelDomain);
std::string getSources()const;
void setSources(const std::string& sources);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string topLevelDomain_;
std::string sources_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_UPDATEVODDOMAINREQUEST_H_

49
vod/include/alibabacloud/vod/model/UpdateVodDomainResult.h Normal file
View File

@@ -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_UPDATEVODDOMAINRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_UPDATEVODDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT UpdateVodDomainResult : public ServiceResult
{
public:
UpdateVodDomainResult();
explicit UpdateVodDomainResult(const std::string &payload);
~UpdateVodDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_UPDATEVODDOMAINRESULT_H_

30
vod/include/alibabacloud/vod/model/UploadMediaByURLRequest.h
View File

@@ -35,18 +35,10 @@ namespace AlibabaCloud
UploadMediaByURLRequest();
~UploadMediaByURLRequest();
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 getUploadMetadatas()const;
void setUploadMetadatas(const std::string& uploadMetadatas);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getUploadURLs()const;
void setUploadURLs(const std::string& uploadURLs);
std::string getMessageCallback()const;
void setMessageCallback(const std::string& messageCallback);
long getOwnerId()const;
@@ -55,18 +47,32 @@ namespace AlibabaCloud
void setPriority(const std::string& priority);
std::string getStorageLocation()const;
void setStorageLocation(const std::string& storageLocation);
std::string getUserData()const;
void setUserData(const std::string& userData);
std::string getTemplateGroupId()const;
void setTemplateGroupId(const std::string& templateGroupId);
std::string getUploadMetadatas()const;
void setUploadMetadatas(const std::string& uploadMetadatas);
std::string getUploadURLs()const;
void setUploadURLs(const std::string& uploadURLs);
std::string getAppId()const;
void setAppId(const std::string& appId);
std::string getWorkflowId()const;
void setWorkflowId(const std::string& workflowId);
private:
std::string userData_;
long resourceOwnerId_;
std::string templateGroupId_;
std::string uploadMetadatas_;
std::string resourceOwnerAccount_;
std::string uploadURLs_;
std::string messageCallback_;
long ownerId_;
std::string priority_;
std::string storageLocation_;
std::string userData_;
std::string templateGroupId_;
std::string uploadMetadatas_;
std::string uploadURLs_;
std::string appId_;
std::string workflowId_;
};
}

11
vod/src/model/AddTranscodeTemplateGroupRequest.cc
View File

@@ -58,6 +58,17 @@ void AddTranscodeTemplateGroupRequest::setResourceOwnerAccount(const std::string
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AddTranscodeTemplateGroupRequest::getAppId()const
{
return appId_;
}
void AddTranscodeTemplateGroupRequest::setAppId(const std::string& appId)
{
appId_ = appId;
setCoreParameter("AppId", appId);
}
std::string AddTranscodeTemplateGroupRequest::getName()const
{
return name_;

104
vod/src/model/AddVodDomainRequest.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/AddVodDomainRequest.h>
using AlibabaCloud::Vod::Model::AddVodDomainRequest;
AddVodDomainRequest::AddVodDomainRequest() :
RpcServiceRequest("vod", "2017-03-21", "AddVodDomain")
{}
AddVodDomainRequest::~AddVodDomainRequest()
{}
std::string AddVodDomainRequest::getSources()const
{
return sources_;
}
void AddVodDomainRequest::setSources(const std::string& sources)
{
sources_ = sources;
setCoreParameter("Sources", sources);
}
std::string AddVodDomainRequest::getSecurityToken()const
{
return securityToken_;
}
void AddVodDomainRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string AddVodDomainRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AddVodDomainRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
std::string AddVodDomainRequest::getScope()const
{
return scope_;
}
void AddVodDomainRequest::setScope(const std::string& scope)
{
scope_ = scope;
setCoreParameter("Scope", scope);
}
std::string AddVodDomainRequest::getDomainName()const
{
return domainName_;
}
void AddVodDomainRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
long AddVodDomainRequest::getOwnerId()const
{
return ownerId_;
}
void AddVodDomainRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string AddVodDomainRequest::getCheckUrl()const
{
return checkUrl_;
}
void AddVodDomainRequest::setCheckUrl(const std::string& checkUrl)
{
checkUrl_ = checkUrl;
setCoreParameter("CheckUrl", checkUrl);
}

45
vod/src/model/AddVodDomainResult.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/AddVodDomainResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
AddVodDomainResult::AddVodDomainResult() :
ServiceResult()
{}
AddVodDomainResult::AddVodDomainResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddVodDomainResult::~AddVodDomainResult()
{}
void AddVodDomainResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

11
vod/src/model/AddVodTemplateRequest.cc
View File

@@ -69,6 +69,17 @@ void AddVodTemplateRequest::setTemplateType(const std::string& templateType)
setCoreParameter("TemplateType", templateType);
}
std::string AddVodTemplateRequest::getAppId()const
{
return appId_;
}
void AddVodTemplateRequest::setAppId(const std::string& appId)
{
appId_ = appId;
setCoreParameter("AppId", appId);
}
std::string AddVodTemplateRequest::getName()const
{
return name_;

11
vod/src/model/AddWatermarkRequest.cc
View File

@@ -47,6 +47,17 @@ void AddWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwn
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AddWatermarkRequest::getAppId()const
{
return appId_;
}
void AddWatermarkRequest::setAppId(const std::string& appId)
{
appId_ = appId;
setCoreParameter("AppId", appId);
}
std::string AddWatermarkRequest::getName()const
{
return name_;

82
vod/src/model/BatchSetVodDomainConfigsRequest.cc Normal file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/BatchSetVodDomainConfigsRequest.h>
using AlibabaCloud::Vod::Model::BatchSetVodDomainConfigsRequest;
BatchSetVodDomainConfigsRequest::BatchSetVodDomainConfigsRequest() :
RpcServiceRequest("vod", "2017-03-21", "BatchSetVodDomainConfigs")
{}
BatchSetVodDomainConfigsRequest::~BatchSetVodDomainConfigsRequest()
{}
std::string BatchSetVodDomainConfigsRequest::getFunctions()const
{
return functions_;
}
void BatchSetVodDomainConfigsRequest::setFunctions(const std::string& functions)
{
functions_ = functions;
setCoreParameter("Functions", functions);
}
std::string BatchSetVodDomainConfigsRequest::getSecurityToken()const
{
return securityToken_;
}
void BatchSetVodDomainConfigsRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string BatchSetVodDomainConfigsRequest::getDomainNames()const
{
return domainNames_;
}
void BatchSetVodDomainConfigsRequest::setDomainNames(const std::string& domainNames)
{
domainNames_ = domainNames;
setCoreParameter("DomainNames", domainNames);
}
std::string BatchSetVodDomainConfigsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void BatchSetVodDomainConfigsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
long BatchSetVodDomainConfigsRequest::getOwnerId()const
{
return ownerId_;
}
void BatchSetVodDomainConfigsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}

45
vod/src/model/BatchSetVodDomainConfigsResult.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/BatchSetVodDomainConfigsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
BatchSetVodDomainConfigsResult::BatchSetVodDomainConfigsResult() :
ServiceResult()
{}
BatchSetVodDomainConfigsResult::BatchSetVodDomainConfigsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
BatchSetVodDomainConfigsResult::~BatchSetVodDomainConfigsResult()
{}
void BatchSetVodDomainConfigsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

60
vod/src/model/BatchStartVodDomainRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/BatchStartVodDomainRequest.h>
using AlibabaCloud::Vod::Model::BatchStartVodDomainRequest;
BatchStartVodDomainRequest::BatchStartVodDomainRequest() :
RpcServiceRequest("vod", "2017-03-21", "BatchStartVodDomain")
{}
BatchStartVodDomainRequest::~BatchStartVodDomainRequest()
{}
std::string BatchStartVodDomainRequest::getSecurityToken()const
{
return securityToken_;
}
void BatchStartVodDomainRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string BatchStartVodDomainRequest::getDomainNames()const
{
return domainNames_;
}
void BatchStartVodDomainRequest::setDomainNames(const std::string& domainNames)
{
domainNames_ = domainNames;
setCoreParameter("DomainNames", domainNames);
}
long BatchStartVodDomainRequest::getOwnerId()const
{
return ownerId_;
}
void BatchStartVodDomainRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}

45
vod/src/model/BatchStartVodDomainResult.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/BatchStartVodDomainResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
BatchStartVodDomainResult::BatchStartVodDomainResult() :
ServiceResult()
{}
BatchStartVodDomainResult::BatchStartVodDomainResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
BatchStartVodDomainResult::~BatchStartVodDomainResult()
{}
void BatchStartVodDomainResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

60
vod/src/model/BatchStopVodDomainRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/BatchStopVodDomainRequest.h>
using AlibabaCloud::Vod::Model::BatchStopVodDomainRequest;
BatchStopVodDomainRequest::BatchStopVodDomainRequest() :
RpcServiceRequest("vod", "2017-03-21", "BatchStopVodDomain")
{}
BatchStopVodDomainRequest::~BatchStopVodDomainRequest()
{}
std::string BatchStopVodDomainRequest::getSecurityToken()const
{
return securityToken_;
}
void BatchStopVodDomainRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string BatchStopVodDomainRequest::getDomainNames()const
{
return domainNames_;
}
void BatchStopVodDomainRequest::setDomainNames(const std::string& domainNames)
{
domainNames_ = domainNames;
setCoreParameter("DomainNames", domainNames);
}
long BatchStopVodDomainRequest::getOwnerId()const
{
return ownerId_;
}
void BatchStopVodDomainRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}

45
vod/src/model/BatchStopVodDomainResult.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/BatchStopVodDomainResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
BatchStopVodDomainResult::BatchStopVodDomainResult() :
ServiceResult()
{}
BatchStopVodDomainResult::BatchStopVodDomainResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
BatchStopVodDomainResult::~BatchStopVodDomainResult()
{}
void BatchStopVodDomainResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

71
vod/src/model/DeleteVodDomainRequest.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/DeleteVodDomainRequest.h>
using AlibabaCloud::Vod::Model::DeleteVodDomainRequest;
DeleteVodDomainRequest::DeleteVodDomainRequest() :
RpcServiceRequest("vod", "2017-03-21", "DeleteVodDomain")
{}
DeleteVodDomainRequest::~DeleteVodDomainRequest()
{}
std::string DeleteVodDomainRequest::getSecurityToken()const
{
return securityToken_;
}
void DeleteVodDomainRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string DeleteVodDomainRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteVodDomainRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
std::string DeleteVodDomainRequest::getDomainName()const
{
return domainName_;
}
void DeleteVodDomainRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
long DeleteVodDomainRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteVodDomainRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}

45
vod/src/model/DeleteVodDomainResult.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/DeleteVodDomainResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
DeleteVodDomainResult::DeleteVodDomainResult() :
ServiceResult()
{}
DeleteVodDomainResult::DeleteVodDomainResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteVodDomainResult::~DeleteVodDomainResult()
{}
void DeleteVodDomainResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

71
vod/src/model/DeleteVodSpecificConfigRequest.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/DeleteVodSpecificConfigRequest.h>
using AlibabaCloud::Vod::Model::DeleteVodSpecificConfigRequest;
DeleteVodSpecificConfigRequest::DeleteVodSpecificConfigRequest() :
RpcServiceRequest("vod", "2017-03-21", "DeleteVodSpecificConfig")
{}
DeleteVodSpecificConfigRequest::~DeleteVodSpecificConfigRequest()
{}
std::string DeleteVodSpecificConfigRequest::getSecurityToken()const
{
return securityToken_;
}
void DeleteVodSpecificConfigRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string DeleteVodSpecificConfigRequest::getConfigId()const
{
return configId_;
}
void DeleteVodSpecificConfigRequest::setConfigId(const std::string& configId)
{
configId_ = configId;
setCoreParameter("ConfigId", configId);
}
std::string DeleteVodSpecificConfigRequest::getDomainName()const
{
return domainName_;
}
void DeleteVodSpecificConfigRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
long DeleteVodSpecificConfigRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteVodSpecificConfigRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}

45
vod/src/model/DeleteVodSpecificConfigResult.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/DeleteVodSpecificConfigResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
DeleteVodSpecificConfigResult::DeleteVodSpecificConfigResult() :
ServiceResult()
{}
DeleteVodSpecificConfigResult::DeleteVodSpecificConfigResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteVodSpecificConfigResult::~DeleteVodSpecificConfigResult()
{}
void DeleteVodSpecificConfigResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

22
vod/src/model/DescribeVodAIDataRequest.cc
View File

@@ -201,6 +201,17 @@ void DescribeVodAIDataRequest::setPopProduct(const std::string& popProduct)
setCoreParameter("PopProduct", popProduct);
}
std::string DescribeVodAIDataRequest::getAIType()const
{
return aIType_;
}
void DescribeVodAIDataRequest::setAIType(const std::string& aIType)
{
aIType_ = aIType;
setCoreParameter("AIType", aIType);
}
std::string DescribeVodAIDataRequest::getEndTime()const
{
return endTime_;
@@ -278,6 +289,17 @@ void DescribeVodAIDataRequest::setSecurity_transport(bool security_transport)
setCoreParameter("Security_transport", security_transport ? "true" : "false");
}
std::string DescribeVodAIDataRequest::getServiceCode()const
{
return serviceCode_;
}
void DescribeVodAIDataRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setCoreParameter("ServiceCode", serviceCode);
}
std::string DescribeVodAIDataRequest::getRequestId()const
{
return requestId_;

60
vod/src/model/DescribeVodCertificateListRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/DescribeVodCertificateListRequest.h>
using AlibabaCloud::Vod::Model::DescribeVodCertificateListRequest;
DescribeVodCertificateListRequest::DescribeVodCertificateListRequest() :
RpcServiceRequest("vod", "2017-03-21", "DescribeVodCertificateList")
{}
DescribeVodCertificateListRequest::~DescribeVodCertificateListRequest()
{}
std::string DescribeVodCertificateListRequest::getSecurityToken()const
{
return securityToken_;
}
void DescribeVodCertificateListRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string DescribeVodCertificateListRequest::getDomainName()const
{
return domainName_;
}
void DescribeVodCertificateListRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
long DescribeVodCertificateListRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeVodCertificateListRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}

71
vod/src/model/DescribeVodCertificateListResult.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/DescribeVodCertificateListResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
DescribeVodCertificateListResult::DescribeVodCertificateListResult() :
ServiceResult()
{}
DescribeVodCertificateListResult::DescribeVodCertificateListResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeVodCertificateListResult::~DescribeVodCertificateListResult()
{}
void DescribeVodCertificateListResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto certificateListModelNode = value["CertificateListModel"];
if(!certificateListModelNode["Count"].isNull())
certificateListModel_.count = std::stoi(certificateListModelNode["Count"].asString());
auto allCertList = value["CertList"]["Cert"];
for (auto value : allCertList)
{
CertificateListModel::Cert certObject;
if(!value["CertName"].isNull())
certObject.certName = value["CertName"].asString();
if(!value["CertId"].isNull())
certObject.certId = std::stol(value["CertId"].asString());
if(!value["Fingerprint"].isNull())
certObject.fingerprint = value["Fingerprint"].asString();
if(!value["Common"].isNull())
certObject.common = value["Common"].asString();
if(!value["Issuer"].isNull())
certObject.issuer = value["Issuer"].asString();
if(!value["LastTime"].isNull())
certObject.lastTime = std::stol(value["LastTime"].asString());
certificateListModel_.certList.push_back(certObject);
}
}
DescribeVodCertificateListResult::CertificateListModel DescribeVodCertificateListResult::getCertificateListModel()const
{
return certificateListModel_;
}

291
vod/src/model/DescribeVodDomainCertificateInfoRequest.cc Normal file
View File

@@ -0,0 +1,291 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/DescribeVodDomainCertificateInfoRequest.h>
using AlibabaCloud::Vod::Model::DescribeVodDomainCertificateInfoRequest;
DescribeVodDomainCertificateInfoRequest::DescribeVodDomainCertificateInfoRequest() :
RpcServiceRequest("vod", "2017-03-21", "DescribeVodDomainCertificateInfo")
{}
DescribeVodDomainCertificateInfoRequest::~DescribeVodDomainCertificateInfoRequest()
{}
long DescribeVodDomainCertificateInfoRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeVodDomainCertificateInfoRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
long DescribeVodDomainCertificateInfoRequest::getCallerParentId()const
{
return callerParentId_;
}
void DescribeVodDomainCertificateInfoRequest::setCallerParentId(long callerParentId)
{
callerParentId_ = callerParentId;
setCoreParameter("CallerParentId", std::to_string(callerParentId));
}
bool DescribeVodDomainCertificateInfoRequest::getProxy_original_security_transport()const
{
return proxy_original_security_transport_;
}
void DescribeVodDomainCertificateInfoRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
{
proxy_original_security_transport_ = proxy_original_security_transport;
setCoreParameter("Proxy_original_security_transport", proxy_original_security_transport ? "true" : "false");
}
std::string DescribeVodDomainCertificateInfoRequest::getProxy_original_source_ip()const
{
return proxy_original_source_ip_;
}
void DescribeVodDomainCertificateInfoRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
{
proxy_original_source_ip_ = proxy_original_source_ip;
setCoreParameter("Proxy_original_source_ip", proxy_original_source_ip);
}
std::string DescribeVodDomainCertificateInfoRequest::getOwnerIdLoginEmail()const
{
return ownerIdLoginEmail_;
}
void DescribeVodDomainCertificateInfoRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
{
ownerIdLoginEmail_ = ownerIdLoginEmail;
setCoreParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
}
std::string DescribeVodDomainCertificateInfoRequest::getCallerType()const
{
return callerType_;
}
void DescribeVodDomainCertificateInfoRequest::setCallerType(const std::string& callerType)
{
callerType_ = callerType;
setCoreParameter("CallerType", callerType);
}
std::string DescribeVodDomainCertificateInfoRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeVodDomainCertificateInfoRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string DescribeVodDomainCertificateInfoRequest::getSecurityToken()const
{
return securityToken_;
}
void DescribeVodDomainCertificateInfoRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string DescribeVodDomainCertificateInfoRequest::getRegionId()const
{
return regionId_;
}
void DescribeVodDomainCertificateInfoRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeVodDomainCertificateInfoRequest::getRequestContent()const
{
return requestContent_;
}
void DescribeVodDomainCertificateInfoRequest::setRequestContent(const std::string& requestContent)
{
requestContent_ = requestContent;
setCoreParameter("RequestContent", requestContent);
}
std::string DescribeVodDomainCertificateInfoRequest::getCallerBidEmail()const
{
return callerBidEmail_;
}
void DescribeVodDomainCertificateInfoRequest::setCallerBidEmail(const std::string& callerBidEmail)
{
callerBidEmail_ = callerBidEmail;
setCoreParameter("CallerBidEmail", callerBidEmail);
}
std::string DescribeVodDomainCertificateInfoRequest::getCallerUidEmail()const
{
return callerUidEmail_;
}
void DescribeVodDomainCertificateInfoRequest::setCallerUidEmail(const std::string& callerUidEmail)
{
callerUidEmail_ = callerUidEmail;
setCoreParameter("CallerUidEmail", callerUidEmail);
}
long DescribeVodDomainCertificateInfoRequest::getCallerUid()const
{
return callerUid_;
}
void DescribeVodDomainCertificateInfoRequest::setCallerUid(long callerUid)
{
callerUid_ = callerUid;
setCoreParameter("CallerUid", std::to_string(callerUid));
}
std::string DescribeVodDomainCertificateInfoRequest::getApp_ip()const
{
return app_ip_;
}
void DescribeVodDomainCertificateInfoRequest::setApp_ip(const std::string& app_ip)
{
app_ip_ = app_ip;
setCoreParameter("App_ip", app_ip);
}
std::string DescribeVodDomainCertificateInfoRequest::getPopProduct()const
{
return popProduct_;
}
void DescribeVodDomainCertificateInfoRequest::setPopProduct(const std::string& popProduct)
{
popProduct_ = popProduct;
setCoreParameter("PopProduct", popProduct);
}
std::string DescribeVodDomainCertificateInfoRequest::getDomainName()const
{
return domainName_;
}
void DescribeVodDomainCertificateInfoRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
std::string DescribeVodDomainCertificateInfoRequest::getCallerBid()const
{
return callerBid_;
}
void DescribeVodDomainCertificateInfoRequest::setCallerBid(const std::string& callerBid)
{
callerBid_ = callerBid;
setCoreParameter("CallerBid", callerBid);
}
long DescribeVodDomainCertificateInfoRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeVodDomainCertificateInfoRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeVodDomainCertificateInfoRequest::getVersion()const
{
return version_;
}
void DescribeVodDomainCertificateInfoRequest::setVersion(const std::string& version)
{
version_ = version;
setCoreParameter("Version", version);
}
bool DescribeVodDomainCertificateInfoRequest::getProxy_trust_transport_info()const
{
return proxy_trust_transport_info_;
}
void DescribeVodDomainCertificateInfoRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
{
proxy_trust_transport_info_ = proxy_trust_transport_info;
setCoreParameter("Proxy_trust_transport_info", proxy_trust_transport_info ? "true" : "false");
}
bool DescribeVodDomainCertificateInfoRequest::getAk_mfa_present()const
{
return ak_mfa_present_;
}
void DescribeVodDomainCertificateInfoRequest::setAk_mfa_present(bool ak_mfa_present)
{
ak_mfa_present_ = ak_mfa_present;
setCoreParameter("Ak_mfa_present", ak_mfa_present ? "true" : "false");
}
bool DescribeVodDomainCertificateInfoRequest::getSecurity_transport()const
{
return security_transport_;
}
void DescribeVodDomainCertificateInfoRequest::setSecurity_transport(bool security_transport)
{
security_transport_ = security_transport;
setCoreParameter("Security_transport", security_transport ? "true" : "false");
}
std::string DescribeVodDomainCertificateInfoRequest::getServiceCode()const
{
return serviceCode_;
}
void DescribeVodDomainCertificateInfoRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setCoreParameter("ServiceCode", serviceCode);
}
std::string DescribeVodDomainCertificateInfoRequest::getRequestId()const
{
return requestId_;
}
void DescribeVodDomainCertificateInfoRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}

74
vod/src/model/DescribeVodDomainCertificateInfoResult.cc Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/DescribeVodDomainCertificateInfoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
DescribeVodDomainCertificateInfoResult::DescribeVodDomainCertificateInfoResult() :
ServiceResult()
{}
DescribeVodDomainCertificateInfoResult::DescribeVodDomainCertificateInfoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeVodDomainCertificateInfoResult::~DescribeVodDomainCertificateInfoResult()
{}
void DescribeVodDomainCertificateInfoResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allCertInfos = value["CertInfos"]["CertInfo"];
for (auto value : allCertInfos)
{
CertInfo certInfosObject;
if(!value["DomainName"].isNull())
certInfosObject.domainName = value["DomainName"].asString();
if(!value["CertName"].isNull())
certInfosObject.certName = value["CertName"].asString();
if(!value["CertDomainName"].isNull())
certInfosObject.certDomainName = value["CertDomainName"].asString();
if(!value["CertExpireTime"].isNull())
certInfosObject.certExpireTime = value["CertExpireTime"].asString();
if(!value["CertLife"].isNull())
certInfosObject.certLife = value["CertLife"].asString();
if(!value["CertOrg"].isNull())
certInfosObject.certOrg = value["CertOrg"].asString();
if(!value["CertType"].isNull())
certInfosObject.certType = value["CertType"].asString();
if(!value["ServerCertificateStatus"].isNull())
certInfosObject.serverCertificateStatus = value["ServerCertificateStatus"].asString();
if(!value["Status"].isNull())
certInfosObject.status = value["Status"].asString();
certInfos_.push_back(certInfosObject);
}
}
std::vector<DescribeVodDomainCertificateInfoResult::CertInfo> DescribeVodDomainCertificateInfoResult::getCertInfos()const
{
return certInfos_;
}

71
vod/src/model/DescribeVodDomainConfigsRequest.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/DescribeVodDomainConfigsRequest.h>
using AlibabaCloud::Vod::Model::DescribeVodDomainConfigsRequest;
DescribeVodDomainConfigsRequest::DescribeVodDomainConfigsRequest() :
RpcServiceRequest("vod", "2017-03-21", "DescribeVodDomainConfigs")
{}
DescribeVodDomainConfigsRequest::~DescribeVodDomainConfigsRequest()
{}
std::string DescribeVodDomainConfigsRequest::getFunctionNames()const
{
return functionNames_;
}
void DescribeVodDomainConfigsRequest::setFunctionNames(const std::string& functionNames)
{
functionNames_ = functionNames;
setCoreParameter("FunctionNames", functionNames);
}
std::string DescribeVodDomainConfigsRequest::getSecurityToken()const
{
return securityToken_;
}
void DescribeVodDomainConfigsRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string DescribeVodDomainConfigsRequest::getDomainName()const
{
return domainName_;
}
void DescribeVodDomainConfigsRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
long DescribeVodDomainConfigsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeVodDomainConfigsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}

72
vod/src/model/DescribeVodDomainConfigsResult.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/DescribeVodDomainConfigsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
DescribeVodDomainConfigsResult::DescribeVodDomainConfigsResult() :
ServiceResult()
{}
DescribeVodDomainConfigsResult::DescribeVodDomainConfigsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeVodDomainConfigsResult::~DescribeVodDomainConfigsResult()
{}
void DescribeVodDomainConfigsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDomainConfigs = value["DomainConfigs"]["DomainConfig"];
for (auto value : allDomainConfigs)
{
DomainConfig domainConfigsObject;
if(!value["FunctionName"].isNull())
domainConfigsObject.functionName = value["FunctionName"].asString();
if(!value["ConfigId"].isNull())
domainConfigsObject.configId = value["ConfigId"].asString();
if(!value["Status"].isNull())
domainConfigsObject.status = value["Status"].asString();
auto allFunctionArgs = value["FunctionArgs"]["FunctionArg"];
for (auto value : allFunctionArgs)
{
DomainConfig::FunctionArg functionArgsObject;
if(!value["ArgName"].isNull())
functionArgsObject.argName = value["ArgName"].asString();
if(!value["ArgValue"].isNull())
functionArgsObject.argValue = value["ArgValue"].asString();
domainConfigsObject.functionArgs.push_back(functionArgsObject);
}
domainConfigs_.push_back(domainConfigsObject);
}
}
std::vector<DescribeVodDomainConfigsResult::DomainConfig> DescribeVodDomainConfigsResult::getDomainConfigs()const
{
return domainConfigs_;
}

60
vod/src/model/DescribeVodDomainDetailRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/DescribeVodDomainDetailRequest.h>
using AlibabaCloud::Vod::Model::DescribeVodDomainDetailRequest;
DescribeVodDomainDetailRequest::DescribeVodDomainDetailRequest() :
RpcServiceRequest("vod", "2017-03-21", "DescribeVodDomainDetail")
{}
DescribeVodDomainDetailRequest::~DescribeVodDomainDetailRequest()
{}
std::string DescribeVodDomainDetailRequest::getSecurityToken()const
{
return securityToken_;
}
void DescribeVodDomainDetailRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string DescribeVodDomainDetailRequest::getDomainName()const
{
return domainName_;
}
void DescribeVodDomainDetailRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
long DescribeVodDomainDetailRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeVodDomainDetailRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}

89
vod/src/model/DescribeVodDomainDetailResult.cc Normal file
View File

@@ -0,0 +1,89 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/DescribeVodDomainDetailResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
DescribeVodDomainDetailResult::DescribeVodDomainDetailResult() :
ServiceResult()
{}
DescribeVodDomainDetailResult::DescribeVodDomainDetailResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeVodDomainDetailResult::~DescribeVodDomainDetailResult()
{}
void DescribeVodDomainDetailResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto domainDetailNode = value["DomainDetail"];
if(!domainDetailNode["GmtCreated"].isNull())
domainDetail_.gmtCreated = domainDetailNode["GmtCreated"].asString();
if(!domainDetailNode["GmtModified"].isNull())
domainDetail_.gmtModified = domainDetailNode["GmtModified"].asString();
if(!domainDetailNode["DomainStatus"].isNull())
domainDetail_.domainStatus = domainDetailNode["DomainStatus"].asString();
if(!domainDetailNode["Cname"].isNull())
domainDetail_.cname = domainDetailNode["Cname"].asString();
if(!domainDetailNode["DomainName"].isNull())
domainDetail_.domainName = domainDetailNode["DomainName"].asString();
if(!domainDetailNode["Description"].isNull())
domainDetail_.description = domainDetailNode["Description"].asString();
if(!domainDetailNode["SSLProtocol"].isNull())
domainDetail_.sSLProtocol = domainDetailNode["SSLProtocol"].asString();
if(!domainDetailNode["SSLPub"].isNull())
domainDetail_.sSLPub = domainDetailNode["SSLPub"].asString();
if(!domainDetailNode["Scope"].isNull())
domainDetail_.scope = domainDetailNode["Scope"].asString();
if(!domainDetailNode["CertName"].isNull())
domainDetail_.certName = domainDetailNode["CertName"].asString();
if(!domainDetailNode["Weight"].isNull())
domainDetail_.weight = domainDetailNode["Weight"].asString();
auto allSources = value["Sources"]["Source"];
for (auto value : allSources)
{
DomainDetail::Source sourceObject;
if(!value["Content"].isNull())
sourceObject.content = value["Content"].asString();
if(!value["Type"].isNull())
sourceObject.type = value["Type"].asString();
if(!value["Port"].isNull())
sourceObject.port = std::stoi(value["Port"].asString());
if(!value["Enabled"].isNull())
sourceObject.enabled = value["Enabled"].asString();
if(!value["Priority"].isNull())
sourceObject.priority = value["Priority"].asString();
domainDetail_.sources.push_back(sourceObject);
}
}
DescribeVodDomainDetailResult::DomainDetail DescribeVodDomainDetailResult::getDomainDetail()const
{
return domainDetail_;
}

11
vod/src/model/DescribeVodDomainUsageDataRequest.cc
View File

@@ -322,6 +322,17 @@ void DescribeVodDomainUsageDataRequest::setSecurity_transport(bool security_tran
setCoreParameter("Security_transport", security_transport ? "true" : "false");
}
std::string DescribeVodDomainUsageDataRequest::getServiceCode()const
{
return serviceCode_;
}
void DescribeVodDomainUsageDataRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setCoreParameter("ServiceCode", serviceCode);
}
std::string DescribeVodDomainUsageDataRequest::getField()const
{
return field_;

22
vod/src/model/DescribeVodStorageDataRequest.cc
View File

@@ -69,6 +69,17 @@ void DescribeVodStorageDataRequest::setStartTime(const std::string& startTime)
setCoreParameter("StartTime", startTime);
}
std::string DescribeVodStorageDataRequest::getStorage()const
{
return storage_;
}
void DescribeVodStorageDataRequest::setStorage(const std::string& storage)
{
storage_ = storage;
setCoreParameter("Storage", storage);
}
std::string DescribeVodStorageDataRequest::getProxy_original_source_ip()const
{
return proxy_original_source_ip_;
@@ -289,6 +300,17 @@ void DescribeVodStorageDataRequest::setSecurity_transport(bool security_transpor
setCoreParameter("Security_transport", security_transport ? "true" : "false");
}
std::string DescribeVodStorageDataRequest::getServiceCode()const
{
return serviceCode_;
}
void DescribeVodStorageDataRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setCoreParameter("ServiceCode", serviceCode);
}
std::string DescribeVodStorageDataRequest::getRequestId()const
{
return requestId_;

33
vod/src/model/DescribeVodTranscodeDataRequest.cc
View File

@@ -69,6 +69,17 @@ void DescribeVodTranscodeDataRequest::setStartTime(const std::string& startTime)
setCoreParameter("StartTime", startTime);
}
std::string DescribeVodTranscodeDataRequest::getStorage()const
{
return storage_;
}
void DescribeVodTranscodeDataRequest::setStorage(const std::string& storage)
{
storage_ = storage;
setCoreParameter("Storage", storage);
}
std::string DescribeVodTranscodeDataRequest::getProxy_original_source_ip()const
{
return proxy_original_source_ip_;
@@ -212,6 +223,17 @@ void DescribeVodTranscodeDataRequest::setEndTime(const std::string& endTime)
setCoreParameter("EndTime", endTime);
}
std::string DescribeVodTranscodeDataRequest::getSpecification()const
{
return specification_;
}
void DescribeVodTranscodeDataRequest::setSpecification(const std::string& specification)
{
specification_ = specification;
setCoreParameter("Specification", specification);
}
std::string DescribeVodTranscodeDataRequest::getCallerBid()const
{
return callerBid_;
@@ -278,6 +300,17 @@ void DescribeVodTranscodeDataRequest::setSecurity_transport(bool security_transp
setCoreParameter("Security_transport", security_transport ? "true" : "false");
}
std::string DescribeVodTranscodeDataRequest::getServiceCode()const
{
return serviceCode_;
}
void DescribeVodTranscodeDataRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setCoreParameter("ServiceCode", serviceCode);
}
std::string DescribeVodTranscodeDataRequest::getRequestId()const
{
return requestId_;

148
vod/src/model/DescribeVodUserDomainsRequest.cc Normal file
View File

@@ -0,0 +1,148 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/DescribeVodUserDomainsRequest.h>
using AlibabaCloud::Vod::Model::DescribeVodUserDomainsRequest;
DescribeVodUserDomainsRequest::DescribeVodUserDomainsRequest() :
RpcServiceRequest("vod", "2017-03-21", "DescribeVodUserDomains")
{}
DescribeVodUserDomainsRequest::~DescribeVodUserDomainsRequest()
{}
std::string DescribeVodUserDomainsRequest::getFuncFilter()const
{
return funcFilter_;
}
void DescribeVodUserDomainsRequest::setFuncFilter(const std::string& funcFilter)
{
funcFilter_ = funcFilter;
setCoreParameter("FuncFilter", funcFilter);
}
bool DescribeVodUserDomainsRequest::getCheckDomainShow()const
{
return checkDomainShow_;
}
void DescribeVodUserDomainsRequest::setCheckDomainShow(bool checkDomainShow)
{
checkDomainShow_ = checkDomainShow;
setCoreParameter("CheckDomainShow", checkDomainShow ? "true" : "false");
}
std::string DescribeVodUserDomainsRequest::getSecurityToken()const
{
return securityToken_;
}
void DescribeVodUserDomainsRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string DescribeVodUserDomainsRequest::getCdnType()const
{
return cdnType_;
}
void DescribeVodUserDomainsRequest::setCdnType(const std::string& cdnType)
{
cdnType_ = cdnType;
setCoreParameter("CdnType", cdnType);
}
int DescribeVodUserDomainsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeVodUserDomainsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeVodUserDomainsRequest::getDomainName()const
{
return domainName_;
}
void DescribeVodUserDomainsRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
long DescribeVodUserDomainsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeVodUserDomainsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeVodUserDomainsRequest::getFuncId()const
{
return funcId_;
}
void DescribeVodUserDomainsRequest::setFuncId(const std::string& funcId)
{
funcId_ = funcId;
setCoreParameter("FuncId", funcId);
}
int DescribeVodUserDomainsRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeVodUserDomainsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeVodUserDomainsRequest::getDomainStatus()const
{
return domainStatus_;
}
void DescribeVodUserDomainsRequest::setDomainStatus(const std::string& domainStatus)
{
domainStatus_ = domainStatus;
setCoreParameter("DomainStatus", domainStatus);
}
std::string DescribeVodUserDomainsRequest::getDomainSearchType()const
{
return domainSearchType_;
}
void DescribeVodUserDomainsRequest::setDomainSearchType(const std::string& domainSearchType)
{
domainSearchType_ = domainSearchType;
setCoreParameter("DomainSearchType", domainSearchType);
}

111
vod/src/model/DescribeVodUserDomainsResult.cc Normal file
View File

@@ -0,0 +1,111 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/DescribeVodUserDomainsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
DescribeVodUserDomainsResult::DescribeVodUserDomainsResult() :
ServiceResult()
{}
DescribeVodUserDomainsResult::DescribeVodUserDomainsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeVodUserDomainsResult::~DescribeVodUserDomainsResult()
{}
void DescribeVodUserDomainsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDomains = value["Domains"]["PageData"];
for (auto value : allDomains)
{
PageData domainsObject;
if(!value["DomainName"].isNull())
domainsObject.domainName = value["DomainName"].asString();
if(!value["Cname"].isNull())
domainsObject.cname = value["Cname"].asString();
if(!value["CdnType"].isNull())
domainsObject.cdnType = value["CdnType"].asString();
if(!value["DomainStatus"].isNull())
domainsObject.domainStatus = value["DomainStatus"].asString();
if(!value["GmtCreated"].isNull())
domainsObject.gmtCreated = value["GmtCreated"].asString();
if(!value["GmtModified"].isNull())
domainsObject.gmtModified = value["GmtModified"].asString();
if(!value["Description"].isNull())
domainsObject.description = value["Description"].asString();
if(!value["SslProtocol"].isNull())
domainsObject.sslProtocol = value["SslProtocol"].asString();
if(!value["Weight"].isNull())
domainsObject.weight = value["Weight"].asString();
if(!value["Sandbox"].isNull())
domainsObject.sandbox = value["Sandbox"].asString();
auto allSources = value["Sources"]["Source"];
for (auto value : allSources)
{
PageData::Source sourcesObject;
if(!value["Type"].isNull())
sourcesObject.type = value["Type"].asString();
if(!value["Content"].isNull())
sourcesObject.content = value["Content"].asString();
if(!value["Port"].isNull())
sourcesObject.port = std::stoi(value["Port"].asString());
if(!value["Priority"].isNull())
sourcesObject.priority = value["Priority"].asString();
domainsObject.sources.push_back(sourcesObject);
}
domains_.push_back(domainsObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stol(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stol(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stol(value["TotalCount"].asString());
}
std::vector<DescribeVodUserDomainsResult::PageData> DescribeVodUserDomainsResult::getDomains()const
{
return domains_;
}
long DescribeVodUserDomainsResult::getTotalCount()const
{
return totalCount_;
}
long DescribeVodUserDomainsResult::getPageSize()const
{
return pageSize_;
}
long DescribeVodUserDomainsResult::getPageNumber()const
{
return pageNumber_;
}

70
vod/src/model/GetMezzanineInfoResult.cc
View File

@@ -40,39 +40,39 @@ void GetMezzanineInfoResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto mezzanineInGetMezzanineInfoNode = value["Mezzanine"];
if(!mezzanineInGetMezzanineInfoNode["VideoId"].isNull())
mezzanineInGetMezzanineInfo_.videoId = mezzanineInGetMezzanineInfoNode["VideoId"].asString();
if(!mezzanineInGetMezzanineInfoNode["Bitrate"].isNull())
mezzanineInGetMezzanineInfo_.bitrate = mezzanineInGetMezzanineInfoNode["Bitrate"].asString();
if(!mezzanineInGetMezzanineInfoNode["CreationTime"].isNull())
mezzanineInGetMezzanineInfo_.creationTime = mezzanineInGetMezzanineInfoNode["CreationTime"].asString();
if(!mezzanineInGetMezzanineInfoNode["Duration"].isNull())
mezzanineInGetMezzanineInfo_.duration = mezzanineInGetMezzanineInfoNode["Duration"].asString();
if(!mezzanineInGetMezzanineInfoNode["Fps"].isNull())
mezzanineInGetMezzanineInfo_.fps = mezzanineInGetMezzanineInfoNode["Fps"].asString();
if(!mezzanineInGetMezzanineInfoNode["Height"].isNull())
mezzanineInGetMezzanineInfo_.height = std::stol(mezzanineInGetMezzanineInfoNode["Height"].asString());
if(!mezzanineInGetMezzanineInfoNode["Width"].isNull())
mezzanineInGetMezzanineInfo_.width = std::stol(mezzanineInGetMezzanineInfoNode["Width"].asString());
if(!mezzanineInGetMezzanineInfoNode["Size"].isNull())
mezzanineInGetMezzanineInfo_.size = std::stol(mezzanineInGetMezzanineInfoNode["Size"].asString());
if(!mezzanineInGetMezzanineInfoNode["Status"].isNull())
mezzanineInGetMezzanineInfo_.status = mezzanineInGetMezzanineInfoNode["Status"].asString();
if(!mezzanineInGetMezzanineInfoNode["FileURL"].isNull())
mezzanineInGetMezzanineInfo_.fileURL = mezzanineInGetMezzanineInfoNode["FileURL"].asString();
if(!mezzanineInGetMezzanineInfoNode["FileName"].isNull())
mezzanineInGetMezzanineInfo_.fileName = mezzanineInGetMezzanineInfoNode["FileName"].asString();
if(!mezzanineInGetMezzanineInfoNode["CRC64"].isNull())
mezzanineInGetMezzanineInfo_.cRC64 = mezzanineInGetMezzanineInfoNode["CRC64"].asString();
if(!mezzanineInGetMezzanineInfoNode["PreprocessStatus"].isNull())
mezzanineInGetMezzanineInfo_.preprocessStatus = mezzanineInGetMezzanineInfoNode["PreprocessStatus"].asString();
if(!mezzanineInGetMezzanineInfoNode["OutputType"].isNull())
mezzanineInGetMezzanineInfo_.outputType = mezzanineInGetMezzanineInfoNode["OutputType"].asString();
auto mezzanineNode = value["Mezzanine"];
if(!mezzanineNode["VideoId"].isNull())
mezzanine_.videoId = mezzanineNode["VideoId"].asString();
if(!mezzanineNode["Bitrate"].isNull())
mezzanine_.bitrate = mezzanineNode["Bitrate"].asString();
if(!mezzanineNode["CreationTime"].isNull())
mezzanine_.creationTime = mezzanineNode["CreationTime"].asString();
if(!mezzanineNode["Duration"].isNull())
mezzanine_.duration = mezzanineNode["Duration"].asString();
if(!mezzanineNode["Fps"].isNull())
mezzanine_.fps = mezzanineNode["Fps"].asString();
if(!mezzanineNode["Height"].isNull())
mezzanine_.height = std::stol(mezzanineNode["Height"].asString());
if(!mezzanineNode["Width"].isNull())
mezzanine_.width = std::stol(mezzanineNode["Width"].asString());
if(!mezzanineNode["Size"].isNull())
mezzanine_.size = std::stol(mezzanineNode["Size"].asString());
if(!mezzanineNode["Status"].isNull())
mezzanine_.status = mezzanineNode["Status"].asString();
if(!mezzanineNode["FileURL"].isNull())
mezzanine_.fileURL = mezzanineNode["FileURL"].asString();
if(!mezzanineNode["FileName"].isNull())
mezzanine_.fileName = mezzanineNode["FileName"].asString();
if(!mezzanineNode["CRC64"].isNull())
mezzanine_.cRC64 = mezzanineNode["CRC64"].asString();
if(!mezzanineNode["PreprocessStatus"].isNull())
mezzanine_.preprocessStatus = mezzanineNode["PreprocessStatus"].asString();
if(!mezzanineNode["OutputType"].isNull())
mezzanine_.outputType = mezzanineNode["OutputType"].asString();
auto allAudioStreamList = value["AudioStreamList"]["AudioStream"];
for (auto value : allAudioStreamList)
{
MezzanineInGetMezzanineInfo::AudioStream audioStreamObject;
Mezzanine::AudioStream audioStreamObject;
if(!value["Index"].isNull())
audioStreamObject.index = value["Index"].asString();
if(!value["CodecName"].isNull())
@@ -105,12 +105,12 @@ void GetMezzanineInfoResult::parse(const std::string &payload)
audioStreamObject.numFrames = value["NumFrames"].asString();
if(!value["Lang"].isNull())
audioStreamObject.lang = value["Lang"].asString();
mezzanineInGetMezzanineInfo_.audioStreamList.push_back(audioStreamObject);
mezzanine_.audioStreamList.push_back(audioStreamObject);
}
auto allVideoStreamList = value["VideoStreamList"]["VideoStream"];
for (auto value : allVideoStreamList)
{
MezzanineInGetMezzanineInfo::VideoStream videoStreamObject;
Mezzanine::VideoStream videoStreamObject;
if(!value["Index"].isNull())
videoStreamObject.index = value["Index"].asString();
if(!value["CodecName"].isNull())
@@ -155,13 +155,13 @@ void GetMezzanineInfoResult::parse(const std::string &payload)
videoStreamObject.lang = value["Lang"].asString();
if(!value["Rotate"].isNull())
videoStreamObject.rotate = value["Rotate"].asString();
mezzanineInGetMezzanineInfo_.videoStreamList.push_back(videoStreamObject);
mezzanine_.videoStreamList.push_back(videoStreamObject);
}
}
GetMezzanineInfoResult::MezzanineInGetMezzanineInfo GetMezzanineInfoResult::getMezzanineInGetMezzanineInfo()const
GetMezzanineInfoResult::Mezzanine GetMezzanineInfoResult::getMezzanine()const
{
return mezzanineInGetMezzanineInfo_;
return mezzanine_;
}

4
vod/src/model/GetTranscodeTemplateGroupResult.cc
View File

@@ -51,6 +51,10 @@ void GetTranscodeTemplateGroupResult::parse(const std::string &payload)
transcodeTemplateGroup_.isDefault = transcodeTemplateGroupNode["IsDefault"].asString();
if(!transcodeTemplateGroupNode["Locked"].isNull())
transcodeTemplateGroup_.locked = transcodeTemplateGroupNode["Locked"].asString();
if(!transcodeTemplateGroupNode["TranscodeMode"].isNull())
transcodeTemplateGroup_.transcodeMode = transcodeTemplateGroupNode["TranscodeMode"].asString();
if(!transcodeTemplateGroupNode["AppId"].isNull())
transcodeTemplateGroup_.appId = transcodeTemplateGroupNode["AppId"].asString();
if(!transcodeTemplateGroupNode["TranscodeTemplateGroupId"].isNull())
transcodeTemplateGroup_.transcodeTemplateGroupId = transcodeTemplateGroupNode["TranscodeTemplateGroupId"].asString();
auto allTranscodeTemplateList = value["TranscodeTemplateList"]["TranscodeTemplate"];

108
vod/src/model/GetVideoInfoResult.cc
View File

@@ -40,74 +40,74 @@ void GetVideoInfoResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto videoInGetVideoInfoNode = value["Video"];
if(!videoInGetVideoInfoNode["VideoId"].isNull())
videoInGetVideoInfo_.videoId = videoInGetVideoInfoNode["VideoId"].asString();
if(!videoInGetVideoInfoNode["Title"].isNull())
videoInGetVideoInfo_.title = videoInGetVideoInfoNode["Title"].asString();
if(!videoInGetVideoInfoNode["Tags"].isNull())
videoInGetVideoInfo_.tags = videoInGetVideoInfoNode["Tags"].asString();
if(!videoInGetVideoInfoNode["Status"].isNull())
videoInGetVideoInfo_.status = videoInGetVideoInfoNode["Status"].asString();
if(!videoInGetVideoInfoNode["Size"].isNull())
videoInGetVideoInfo_.size = std::stol(videoInGetVideoInfoNode["Size"].asString());
if(!videoInGetVideoInfoNode["Duration"].isNull())
videoInGetVideoInfo_.duration = std::stof(videoInGetVideoInfoNode["Duration"].asString());
if(!videoInGetVideoInfoNode["Description"].isNull())
videoInGetVideoInfo_.description = videoInGetVideoInfoNode["Description"].asString();
if(!videoInGetVideoInfoNode["CreateTime"].isNull())
videoInGetVideoInfo_.createTime = videoInGetVideoInfoNode["CreateTime"].asString();
if(!videoInGetVideoInfoNode["ModifyTime"].isNull())
videoInGetVideoInfo_.modifyTime = videoInGetVideoInfoNode["ModifyTime"].asString();
if(!videoInGetVideoInfoNode["ModificationTime"].isNull())
videoInGetVideoInfo_.modificationTime = videoInGetVideoInfoNode["ModificationTime"].asString();
if(!videoInGetVideoInfoNode["CreationTime"].isNull())
videoInGetVideoInfo_.creationTime = videoInGetVideoInfoNode["CreationTime"].asString();
if(!videoInGetVideoInfoNode["CoverURL"].isNull())
videoInGetVideoInfo_.coverURL = videoInGetVideoInfoNode["CoverURL"].asString();
if(!videoInGetVideoInfoNode["CateId"].isNull())
videoInGetVideoInfo_.cateId = std::stol(videoInGetVideoInfoNode["CateId"].asString());
if(!videoInGetVideoInfoNode["CateName"].isNull())
videoInGetVideoInfo_.cateName = videoInGetVideoInfoNode["CateName"].asString();
if(!videoInGetVideoInfoNode["DownloadSwitch"].isNull())
videoInGetVideoInfo_.downloadSwitch = videoInGetVideoInfoNode["DownloadSwitch"].asString();
if(!videoInGetVideoInfoNode["TemplateGroupId"].isNull())
videoInGetVideoInfo_.templateGroupId = videoInGetVideoInfoNode["TemplateGroupId"].asString();
if(!videoInGetVideoInfoNode["PreprocessStatus"].isNull())
videoInGetVideoInfo_.preprocessStatus = videoInGetVideoInfoNode["PreprocessStatus"].asString();
if(!videoInGetVideoInfoNode["StorageLocation"].isNull())
videoInGetVideoInfo_.storageLocation = videoInGetVideoInfoNode["StorageLocation"].asString();
if(!videoInGetVideoInfoNode["RegionId"].isNull())
videoInGetVideoInfo_.regionId = videoInGetVideoInfoNode["RegionId"].asString();
if(!videoInGetVideoInfoNode["CustomMediaInfo"].isNull())
videoInGetVideoInfo_.customMediaInfo = videoInGetVideoInfoNode["CustomMediaInfo"].asString();
if(!videoInGetVideoInfoNode["AuditStatus"].isNull())
videoInGetVideoInfo_.auditStatus = videoInGetVideoInfoNode["AuditStatus"].asString();
if(!videoInGetVideoInfoNode["AppId"].isNull())
videoInGetVideoInfo_.appId = videoInGetVideoInfoNode["AppId"].asString();
auto videoNode = value["Video"];
if(!videoNode["VideoId"].isNull())
video_.videoId = videoNode["VideoId"].asString();
if(!videoNode["Title"].isNull())
video_.title = videoNode["Title"].asString();
if(!videoNode["Tags"].isNull())
video_.tags = videoNode["Tags"].asString();
if(!videoNode["Status"].isNull())
video_.status = videoNode["Status"].asString();
if(!videoNode["Size"].isNull())
video_.size = std::stol(videoNode["Size"].asString());
if(!videoNode["Duration"].isNull())
video_.duration = std::stof(videoNode["Duration"].asString());
if(!videoNode["Description"].isNull())
video_.description = videoNode["Description"].asString();
if(!videoNode["CreateTime"].isNull())
video_.createTime = videoNode["CreateTime"].asString();
if(!videoNode["ModifyTime"].isNull())
video_.modifyTime = videoNode["ModifyTime"].asString();
if(!videoNode["ModificationTime"].isNull())
video_.modificationTime = videoNode["ModificationTime"].asString();
if(!videoNode["CreationTime"].isNull())
video_.creationTime = videoNode["CreationTime"].asString();
if(!videoNode["CoverURL"].isNull())
video_.coverURL = videoNode["CoverURL"].asString();
if(!videoNode["CateId"].isNull())
video_.cateId = std::stol(videoNode["CateId"].asString());
if(!videoNode["CateName"].isNull())
video_.cateName = videoNode["CateName"].asString();
if(!videoNode["DownloadSwitch"].isNull())
video_.downloadSwitch = videoNode["DownloadSwitch"].asString();
if(!videoNode["TemplateGroupId"].isNull())
video_.templateGroupId = videoNode["TemplateGroupId"].asString();
if(!videoNode["PreprocessStatus"].isNull())
video_.preprocessStatus = videoNode["PreprocessStatus"].asString();
if(!videoNode["StorageLocation"].isNull())
video_.storageLocation = videoNode["StorageLocation"].asString();
if(!videoNode["RegionId"].isNull())
video_.regionId = videoNode["RegionId"].asString();
if(!videoNode["CustomMediaInfo"].isNull())
video_.customMediaInfo = videoNode["CustomMediaInfo"].asString();
if(!videoNode["AuditStatus"].isNull())
video_.auditStatus = videoNode["AuditStatus"].asString();
if(!videoNode["AppId"].isNull())
video_.appId = videoNode["AppId"].asString();
auto allThumbnailList = value["ThumbnailList"]["Thumbnail"];
for (auto value : allThumbnailList)
{
VideoInGetVideoInfo::Thumbnail thumbnailObject;
Video::Thumbnail thumbnailObject;
if(!value["URL"].isNull())
thumbnailObject.uRL = value["URL"].asString();
videoInGetVideoInfo_.thumbnailList.push_back(thumbnailObject);
video_.thumbnailList.push_back(thumbnailObject);
}
auto allSnapshots = videoInGetVideoInfoNode["Snapshots"]["Snapshot"];
auto allSnapshots = videoNode["Snapshots"]["Snapshot"];
for (auto value : allSnapshots)
videoInGetVideoInfo_.snapshots.push_back(value.asString());
video_.snapshots.push_back(value.asString());
if(!value["AI"].isNull())
aI_ = value["AI"].asString();
}
GetVideoInfoResult::Video GetVideoInfoResult::getVideo()const
{
return video_;
}
std::string GetVideoInfoResult::getAI()const
{
return aI_;
}
GetVideoInfoResult::VideoInGetVideoInfo GetVideoInfoResult::getVideoInGetVideoInfo()const
{
return videoInGetVideoInfo_;
}

2
vod/src/model/GetWatermarkResult.cc
View File

@@ -55,6 +55,8 @@ void GetWatermarkResult::parse(const std::string &payload)
watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString();
if(!watermarkInfoNode["WatermarkConfig"].isNull())
watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString();
if(!watermarkInfoNode["AppId"].isNull())
watermarkInfo_.appId = watermarkInfoNode["AppId"].asString();
}

74
vod/src/model/ListLiveRecordVideoResult.cc
View File

@@ -92,44 +92,44 @@ void ListLiveRecordVideoResult::parse(const std::string &payload)
playInfoListObject.jobId = value["JobId"].asString();
liveRecordVideoListObject.playInfoList.push_back(playInfoListObject);
}
auto videoInListLiveRecordVideoNode = value["Video"];
if(!videoInListLiveRecordVideoNode["VideoId"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.videoId = videoInListLiveRecordVideoNode["VideoId"].asString();
if(!videoInListLiveRecordVideoNode["Title"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.title = videoInListLiveRecordVideoNode["Title"].asString();
if(!videoInListLiveRecordVideoNode["Tags"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.tags = videoInListLiveRecordVideoNode["Tags"].asString();
if(!videoInListLiveRecordVideoNode["Status"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.status = videoInListLiveRecordVideoNode["Status"].asString();
if(!videoInListLiveRecordVideoNode["Size"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.size = std::stol(videoInListLiveRecordVideoNode["Size"].asString());
if(!videoInListLiveRecordVideoNode["Privilege"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.privilege = std::stoi(videoInListLiveRecordVideoNode["Privilege"].asString());
if(!videoInListLiveRecordVideoNode["Duration"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.duration = std::stof(videoInListLiveRecordVideoNode["Duration"].asString());
if(!videoInListLiveRecordVideoNode["Description"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.description = videoInListLiveRecordVideoNode["Description"].asString();
if(!videoInListLiveRecordVideoNode["CustomerId"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.customerId = std::stol(videoInListLiveRecordVideoNode["CustomerId"].asString());
if(!videoInListLiveRecordVideoNode["CreateTime"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.createTime = videoInListLiveRecordVideoNode["CreateTime"].asString();
if(!videoInListLiveRecordVideoNode["CreationTime"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.creationTime = videoInListLiveRecordVideoNode["CreationTime"].asString();
if(!videoInListLiveRecordVideoNode["ModifyTime"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.modifyTime = videoInListLiveRecordVideoNode["ModifyTime"].asString();
if(!videoInListLiveRecordVideoNode["CoverURL"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.coverURL = videoInListLiveRecordVideoNode["CoverURL"].asString();
if(!videoInListLiveRecordVideoNode["CateId"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.cateId = std::stoi(videoInListLiveRecordVideoNode["CateId"].asString());
if(!videoInListLiveRecordVideoNode["CateName"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.cateName = videoInListLiveRecordVideoNode["CateName"].asString();
if(!videoInListLiveRecordVideoNode["DownloadSwitch"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.downloadSwitch = videoInListLiveRecordVideoNode["DownloadSwitch"].asString();
if(!videoInListLiveRecordVideoNode["TemplateGroupId"].isNull())
liveRecordVideoListObject.videoInListLiveRecordVideo.templateGroupId = videoInListLiveRecordVideoNode["TemplateGroupId"].asString();
auto allSnapshots = videoInListLiveRecordVideoNode["Snapshots"]["Snapshot"];
auto videoNode = value["Video"];
if(!videoNode["VideoId"].isNull())
liveRecordVideoListObject.video.videoId = videoNode["VideoId"].asString();
if(!videoNode["Title"].isNull())
liveRecordVideoListObject.video.title = videoNode["Title"].asString();
if(!videoNode["Tags"].isNull())
liveRecordVideoListObject.video.tags = videoNode["Tags"].asString();
if(!videoNode["Status"].isNull())
liveRecordVideoListObject.video.status = videoNode["Status"].asString();
if(!videoNode["Size"].isNull())
liveRecordVideoListObject.video.size = std::stol(videoNode["Size"].asString());
if(!videoNode["Privilege"].isNull())
liveRecordVideoListObject.video.privilege = std::stoi(videoNode["Privilege"].asString());
if(!videoNode["Duration"].isNull())
liveRecordVideoListObject.video.duration = std::stof(videoNode["Duration"].asString());
if(!videoNode["Description"].isNull())
liveRecordVideoListObject.video.description = videoNode["Description"].asString();
if(!videoNode["CustomerId"].isNull())
liveRecordVideoListObject.video.customerId = std::stol(videoNode["CustomerId"].asString());
if(!videoNode["CreateTime"].isNull())
liveRecordVideoListObject.video.createTime = videoNode["CreateTime"].asString();
if(!videoNode["CreationTime"].isNull())
liveRecordVideoListObject.video.creationTime = videoNode["CreationTime"].asString();
if(!videoNode["ModifyTime"].isNull())
liveRecordVideoListObject.video.modifyTime = videoNode["ModifyTime"].asString();
if(!videoNode["CoverURL"].isNull())
liveRecordVideoListObject.video.coverURL = videoNode["CoverURL"].asString();
if(!videoNode["CateId"].isNull())
liveRecordVideoListObject.video.cateId = std::stoi(videoNode["CateId"].asString());
if(!videoNode["CateName"].isNull())
liveRecordVideoListObject.video.cateName = videoNode["CateName"].asString();
if(!videoNode["DownloadSwitch"].isNull())
liveRecordVideoListObject.video.downloadSwitch = videoNode["DownloadSwitch"].asString();
if(!videoNode["TemplateGroupId"].isNull())
liveRecordVideoListObject.video.templateGroupId = videoNode["TemplateGroupId"].asString();
auto allSnapshots = videoNode["Snapshots"]["Snapshot"];
for (auto value : allSnapshots)
liveRecordVideoListObject.videoInListLiveRecordVideo.snapshots.push_back(value.asString());
liveRecordVideoListObject.video.snapshots.push_back(value.asString());
liveRecordVideoList_.push_back(liveRecordVideoListObject);
}
if(!value["Total"].isNull())

33
vod/src/model/ListTranscodeTemplateGroupRequest.cc
View File

@@ -47,6 +47,39 @@ void ListTranscodeTemplateGroupRequest::setResourceOwnerAccount(const std::strin
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int ListTranscodeTemplateGroupRequest::getPageNo()const
{
return pageNo_;
}
void ListTranscodeTemplateGroupRequest::setPageNo(int pageNo)
{
pageNo_ = pageNo;
setCoreParameter("PageNo", std::to_string(pageNo));
}
std::string ListTranscodeTemplateGroupRequest::getAppId()const
{
return appId_;
}
void ListTranscodeTemplateGroupRequest::setAppId(const std::string& appId)
{
appId_ = appId;
setCoreParameter("AppId", appId);
}
int ListTranscodeTemplateGroupRequest::getPageSize()const
{
return pageSize_;
}
void ListTranscodeTemplateGroupRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
long ListTranscodeTemplateGroupRequest::getOwnerId()const
{
return ownerId_;

4
vod/src/model/ListTranscodeTemplateGroupResult.cc
View File

@@ -56,6 +56,10 @@ void ListTranscodeTemplateGroupResult::parse(const std::string &payload)
transcodeTemplateGroupListObject.locked = value["Locked"].asString();
if(!value["TranscodeTemplateGroupId"].isNull())
transcodeTemplateGroupListObject.transcodeTemplateGroupId = value["TranscodeTemplateGroupId"].asString();
if(!value["TranscodeMode"].isNull())
transcodeTemplateGroupListObject.transcodeMode = value["TranscodeMode"].asString();
if(!value["AppId"].isNull())
transcodeTemplateGroupListObject.appId = value["AppId"].asString();
transcodeTemplateGroupList_.push_back(transcodeTemplateGroupListObject);
}

11
vod/src/model/ListVodTemplateRequest.cc
View File

@@ -58,6 +58,17 @@ void ListVodTemplateRequest::setTemplateType(const std::string& templateType)
setCoreParameter("TemplateType", templateType);
}
std::string ListVodTemplateRequest::getAppId()const
{
return appId_;
}
void ListVodTemplateRequest::setAppId(const std::string& appId)
{
appId_ = appId;
setCoreParameter("AppId", appId);
}
long ListVodTemplateRequest::getOwnerId()const
{
return ownerId_;

2
vod/src/model/ListVodTemplateResult.cc
View File

@@ -62,6 +62,8 @@ void ListVodTemplateResult::parse(const std::string &payload)
vodTemplateInfoListObject.creationTime = value["CreationTime"].asString();
if(!value["ModifyTime"].isNull())
vodTemplateInfoListObject.modifyTime = value["ModifyTime"].asString();
if(!value["AppId"].isNull())
vodTemplateInfoListObject.appId = value["AppId"].asString();
vodTemplateInfoList_.push_back(vodTemplateInfoListObject);
}

33
vod/src/model/ListWatermarkRequest.cc
View File

@@ -47,6 +47,39 @@ void ListWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOw
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int ListWatermarkRequest::getPageNo()const
{
return pageNo_;
}
void ListWatermarkRequest::setPageNo(int pageNo)
{
pageNo_ = pageNo;
setCoreParameter("PageNo", std::to_string(pageNo));
}
std::string ListWatermarkRequest::getAppId()const
{
return appId_;
}
void ListWatermarkRequest::setAppId(const std::string& appId)
{
appId_ = appId;
setCoreParameter("AppId", appId);
}
int ListWatermarkRequest::getPageSize()const
{
return pageSize_;
}
void ListWatermarkRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
long ListWatermarkRequest::getOwnerId()const
{
return ownerId_;

2
vod/src/model/ListWatermarkResult.cc
View File

@@ -58,6 +58,8 @@ void ListWatermarkResult::parse(const std::string &payload)
watermarkInfosObject.fileUrl = value["FileUrl"].asString();
if(!value["WatermarkConfig"].isNull())
watermarkInfosObject.watermarkConfig = value["WatermarkConfig"].asString();
if(!value["AppId"].isNull())
watermarkInfosObject.appId = value["AppId"].asString();
watermarkInfos_.push_back(watermarkInfosObject);
}

10
vod/src/model/RegisterMediaRequest.cc
View File

@@ -91,15 +91,15 @@ void RegisterMediaRequest::setRegisterMetadatas(const std::string& registerMetad
setCoreParameter("RegisterMetadatas", registerMetadatas);
}
std::string RegisterMediaRequest::getWorkFlowId()const
std::string RegisterMediaRequest::getWorkflowId()const
{
return workFlowId_;
return workflowId_;
}
void RegisterMediaRequest::setWorkFlowId(const std::string& workFlowId)
void RegisterMediaRequest::setWorkflowId(const std::string& workflowId)
{
workFlowId_ = workFlowId;
setCoreParameter("WorkFlowId", workFlowId);
workflowId_ = workflowId;
setCoreParameter("WorkflowId", workflowId);
}
std::string RegisterMediaRequest::getAccessKeyId()const

66
vod/src/model/SearchMediaResult.cc
View File

@@ -269,41 +269,41 @@ void SearchMediaResult::parse(const std::string &payload)
mediaListObject.image.regionId = imageNode["RegionId"].asString();
if(!imageNode["AppId"].isNull())
mediaListObject.image.appId = imageNode["AppId"].asString();
auto attachedMediaInSearchMediaNode = value["AttachedMedia"];
if(!attachedMediaInSearchMediaNode["Title"].isNull())
mediaListObject.attachedMediaInSearchMedia.title = attachedMediaInSearchMediaNode["Title"].asString();
if(!attachedMediaInSearchMediaNode["MediaId"].isNull())
mediaListObject.attachedMediaInSearchMedia.mediaId = attachedMediaInSearchMediaNode["MediaId"].asString();
if(!attachedMediaInSearchMediaNode["Ext"].isNull())
mediaListObject.attachedMediaInSearchMedia.ext = attachedMediaInSearchMediaNode["Ext"].asString();
if(!attachedMediaInSearchMediaNode["CreationTime"].isNull())
mediaListObject.attachedMediaInSearchMedia.creationTime = attachedMediaInSearchMediaNode["CreationTime"].asString();
if(!attachedMediaInSearchMediaNode["ModificationTime"].isNull())
mediaListObject.attachedMediaInSearchMedia.modificationTime = attachedMediaInSearchMediaNode["ModificationTime"].asString();
if(!attachedMediaInSearchMediaNode["Tags"].isNull())
mediaListObject.attachedMediaInSearchMedia.tags = attachedMediaInSearchMediaNode["Tags"].asString();
if(!attachedMediaInSearchMediaNode["BusinessType"].isNull())
mediaListObject.attachedMediaInSearchMedia.businessType = attachedMediaInSearchMediaNode["BusinessType"].asString();
if(!attachedMediaInSearchMediaNode["URL"].isNull())
mediaListObject.attachedMediaInSearchMedia.uRL = attachedMediaInSearchMediaNode["URL"].asString();
if(!attachedMediaInSearchMediaNode["Status"].isNull())
mediaListObject.attachedMediaInSearchMedia.status = attachedMediaInSearchMediaNode["Status"].asString();
if(!attachedMediaInSearchMediaNode["Description"].isNull())
mediaListObject.attachedMediaInSearchMedia.description = attachedMediaInSearchMediaNode["Description"].asString();
if(!attachedMediaInSearchMediaNode["StorageLocation"].isNull())
mediaListObject.attachedMediaInSearchMedia.storageLocation = attachedMediaInSearchMediaNode["StorageLocation"].asString();
if(!attachedMediaInSearchMediaNode["RegionId"].isNull())
mediaListObject.attachedMediaInSearchMedia.regionId = attachedMediaInSearchMediaNode["RegionId"].asString();
if(!attachedMediaInSearchMediaNode["AppId"].isNull())
mediaListObject.attachedMediaInSearchMedia.appId = attachedMediaInSearchMediaNode["AppId"].asString();
if(!attachedMediaInSearchMediaNode["Icon"].isNull())
mediaListObject.attachedMediaInSearchMedia.icon = attachedMediaInSearchMediaNode["Icon"].asString();
if(!attachedMediaInSearchMediaNode["OnlineStatus"].isNull())
mediaListObject.attachedMediaInSearchMedia.onlineStatus = attachedMediaInSearchMediaNode["OnlineStatus"].asString();
auto attachedMediaNode = value["AttachedMedia"];
if(!attachedMediaNode["Title"].isNull())
mediaListObject.attachedMedia.title = attachedMediaNode["Title"].asString();
if(!attachedMediaNode["MediaId"].isNull())
mediaListObject.attachedMedia.mediaId = attachedMediaNode["MediaId"].asString();
if(!attachedMediaNode["Ext"].isNull())
mediaListObject.attachedMedia.ext = attachedMediaNode["Ext"].asString();
if(!attachedMediaNode["CreationTime"].isNull())
mediaListObject.attachedMedia.creationTime = attachedMediaNode["CreationTime"].asString();
if(!attachedMediaNode["ModificationTime"].isNull())
mediaListObject.attachedMedia.modificationTime = attachedMediaNode["ModificationTime"].asString();
if(!attachedMediaNode["Tags"].isNull())
mediaListObject.attachedMedia.tags = attachedMediaNode["Tags"].asString();
if(!attachedMediaNode["BusinessType"].isNull())
mediaListObject.attachedMedia.businessType = attachedMediaNode["BusinessType"].asString();
if(!attachedMediaNode["URL"].isNull())
mediaListObject.attachedMedia.uRL = attachedMediaNode["URL"].asString();
if(!attachedMediaNode["Status"].isNull())
mediaListObject.attachedMedia.status = attachedMediaNode["Status"].asString();
if(!attachedMediaNode["Description"].isNull())
mediaListObject.attachedMedia.description = attachedMediaNode["Description"].asString();
if(!attachedMediaNode["StorageLocation"].isNull())
mediaListObject.attachedMedia.storageLocation = attachedMediaNode["StorageLocation"].asString();
if(!attachedMediaNode["RegionId"].isNull())
mediaListObject.attachedMedia.regionId = attachedMediaNode["RegionId"].asString();
if(!attachedMediaNode["AppId"].isNull())
mediaListObject.attachedMedia.appId = attachedMediaNode["AppId"].asString();
if(!attachedMediaNode["Icon"].isNull())
mediaListObject.attachedMedia.icon = attachedMediaNode["Icon"].asString();
if(!attachedMediaNode["OnlineStatus"].isNull())
mediaListObject.attachedMedia.onlineStatus = attachedMediaNode["OnlineStatus"].asString();
auto allCategories = value["Categories"]["Category"];
for (auto value : allCategories)
{
Media::AttachedMediaInSearchMedia::Category categoryObject;
Media::AttachedMedia::Category categoryObject;
if(!value["CateId"].isNull())
categoryObject.cateId = std::stol(value["CateId"].asString());
if(!value["CateName"].isNull())
@@ -312,7 +312,7 @@ void SearchMediaResult::parse(const std::string &payload)
categoryObject.level = std::stol(value["Level"].asString());
if(!value["ParentId"].isNull())
categoryObject.parentId = std::stol(value["ParentId"].asString());
mediaListObject.attachedMediaInSearchMedia.categories.push_back(categoryObject);
mediaListObject.attachedMedia.categories.push_back(categoryObject);
}
mediaList_.push_back(mediaListObject);
}

115
vod/src/model/SetVodDomainCertificateRequest.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/SetVodDomainCertificateRequest.h>
using AlibabaCloud::Vod::Model::SetVodDomainCertificateRequest;
SetVodDomainCertificateRequest::SetVodDomainCertificateRequest() :
RpcServiceRequest("vod", "2017-03-21", "SetVodDomainCertificate")
{}
SetVodDomainCertificateRequest::~SetVodDomainCertificateRequest()
{}
std::string SetVodDomainCertificateRequest::getSecurityToken()const
{
return securityToken_;
}
void SetVodDomainCertificateRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string SetVodDomainCertificateRequest::getSSLPub()const
{
return sSLPub_;
}
void SetVodDomainCertificateRequest::setSSLPub(const std::string& sSLPub)
{
sSLPub_ = sSLPub;
setCoreParameter("SSLPub", sSLPub);
}
std::string SetVodDomainCertificateRequest::getCertName()const
{
return certName_;
}
void SetVodDomainCertificateRequest::setCertName(const std::string& certName)
{
certName_ = certName;
setCoreParameter("CertName", certName);
}
std::string SetVodDomainCertificateRequest::getSSLProtocol()const
{
return sSLProtocol_;
}
void SetVodDomainCertificateRequest::setSSLProtocol(const std::string& sSLProtocol)
{
sSLProtocol_ = sSLProtocol;
setCoreParameter("SSLProtocol", sSLProtocol);
}
std::string SetVodDomainCertificateRequest::getDomainName()const
{
return domainName_;
}
void SetVodDomainCertificateRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
long SetVodDomainCertificateRequest::getOwnerId()const
{
return ownerId_;
}
void SetVodDomainCertificateRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string SetVodDomainCertificateRequest::getRegion()const
{
return region_;
}
void SetVodDomainCertificateRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}
std::string SetVodDomainCertificateRequest::getSSLPri()const
{
return sSLPri_;
}
void SetVodDomainCertificateRequest::setSSLPri(const std::string& sSLPri)
{
sSLPri_ = sSLPri;
setCoreParameter("SSLPri", sSLPri);
}

45
vod/src/model/SetVodDomainCertificateResult.cc Normal file
View File

@@ -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 <alibabacloud/vod/model/SetVodDomainCertificateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
SetVodDomainCertificateResult::SetVodDomainCertificateResult() :
ServiceResult()
{}
SetVodDomainCertificateResult::SetVodDomainCertificateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SetVodDomainCertificateResult::~SetVodDomainCertificateResult()
{}
void SetVodDomainCertificateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

11
vod/src/model/SubmitAIJobRequest.cc
View File

@@ -36,6 +36,17 @@ void SubmitAIJobRequest::setUserData(const std::string& userData)
setCoreParameter("UserData", userData);
}
std::string SubmitAIJobRequest::getInput()const
{
return input_;
}
void SubmitAIJobRequest::setInput(const std::string& input)
{
input_ = input;
setCoreParameter("Input", input);
}
std::string SubmitAIJobRequest::getResourceOwnerId()const
{
return resourceOwnerId_;

11
vod/src/model/SubmitTranscodeJobsRequest.cc
View File

@@ -25,6 +25,17 @@ SubmitTranscodeJobsRequest::SubmitTranscodeJobsRequest() :
SubmitTranscodeJobsRequest::~SubmitTranscodeJobsRequest()
{}
std::string SubmitTranscodeJobsRequest::getUserData()const
{
return userData_;
}
void SubmitTranscodeJobsRequest::setUserData(const std::string& userData)
{
userData_ = userData;
setCoreParameter("UserData", userData);
}
long SubmitTranscodeJobsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;

7
vod/src/model/SubmitTranscodeJobsResult.cc
View File

@@ -48,6 +48,8 @@ void SubmitTranscodeJobsResult::parse(const std::string &payload)
transcodeJobsObject.jobId = value["JobId"].asString();
transcodeJobs_.push_back(transcodeJobsObject);
}
if(!value["TranscodeTaskId"].isNull())
transcodeTaskId_ = value["TranscodeTaskId"].asString();
}
@@ -56,3 +58,8 @@ std::vector<SubmitTranscodeJobsResult::TranscodeJob> SubmitTranscodeJobsResult::
return transcodeJobs_;
}
std::string SubmitTranscodeJobsResult::getTranscodeTaskId()const
{
return transcodeTaskId_;
}

82
vod/src/model/UpdateVodDomainRequest.cc Normal file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vod/model/UpdateVodDomainRequest.h>
using AlibabaCloud::Vod::Model::UpdateVodDomainRequest;
UpdateVodDomainRequest::UpdateVodDomainRequest() :
RpcServiceRequest("vod", "2017-03-21", "UpdateVodDomain")
{}
UpdateVodDomainRequest::~UpdateVodDomainRequest()
{}
std::string UpdateVodDomainRequest::getTopLevelDomain()const
{
return topLevelDomain_;
}
void UpdateVodDomainRequest::setTopLevelDomain(const std::string& topLevelDomain)
{
topLevelDomain_ = topLevelDomain;
setCoreParameter("TopLevelDomain", topLevelDomain);
}
std::string UpdateVodDomainRequest::getSources()const
{
return sources_;
}
void UpdateVodDomainRequest::setSources(const std::string& sources)
{
sources_ = sources;
setCoreParameter("Sources", sources);
}
std::string UpdateVodDomainRequest::getSecurityToken()const
{
return securityToken_;
}
void UpdateVodDomainRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string UpdateVodDomainRequest::getDomainName()const
{
return domainName_;
}
void UpdateVodDomainRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setCoreParameter("DomainName", domainName);
}
long UpdateVodDomainRequest::getOwnerId()const
{
return ownerId_;
}
void UpdateVodDomainRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}

Some files were not shown because too many files have changed in this diff Show More