import com.tencentcloudapi.common.Credential;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import com.tencentcloudapi.common.profile.ClientProfile;
import com.tencentcloudapi.vod.v20240718.VodClient;
import com.tencentcloudapi.vod.v20240718.models.CreateStorageCredentialsRequest;
import com.tencentcloudapi.vod.v20240718.models.CreateStorageCredentialsResponse;

import org.json.JSONArray;
import org.json.JSONObject;

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

/​**​
 * Credential helper class for obtaining temporary storage credentials
 */
public class CredentialHelper {
    // Constant definitions
    private static final long APP_ID = 251000000; // Tencent Cloud account APPID
    private static final long SUB_APP_ID = 1234567890; // VOD Professional Edition application APPID
    private static final String BUCKET_ID = "bucketid1"; // VOD Professional Edition bucket ID
    private static final String FILE_KEY = "upload/demo.mp4"; // File KEY in storage after upload
    private static final String REGION = "ap-guangzhou"; // Bucket region

    /​**​
     * Credential object storing temporary credential information
     */
    public static class Cred {
        private final String accessKeyId;
        private final String secretAccessKey;
        private final String sessionToken;

        public Cred(String accessKeyId, String secretAccessKey, String sessionToken) {
            this.accessKeyId = accessKeyId;
            this.secretAccessKey = secretAccessKey;
            this.sessionToken = sessionToken;
        }

        public String getAccessKeyId() {
            return accessKeyId;
        }

        public String getSecretAccessKey() {
            return secretAccessKey;
        }

        public String getSessionToken() {
            return sessionToken;
        }
    }

    /​**​
     * Obtain credentials
     *
     * @return Temporary credential object
     * @throws Exception If credential acquisition fails
     */
    public static Cred getCredential() throws Exception {
        try {
            // 1. Initialize Tencent Cloud API client
            Credential credential = new Credential("SecretId", "SecretKey"); // Tencent Cloud account SecretId and SecretKey
            ClientProfile clientProfile = new ClientProfile(); // Client configuration
            VodClient vodClient = new VodClient(credential, "ap-guangzhou", clientProfile); // Create VodClient object

            // 2. Construct and encode policy
            String policyJson = createPolicyJson();
            String encodedPolicy = URLEncoder.encode(policyJson, StandardCharsets.UTF_8.name());

            // 3. Create and send request
            CreateStorageCredentialsRequest req = new CreateStorageCredentialsRequest();
            req.setSubAppId(SUB_APP_ID); // VOD Professional Edition application APPID
            req.setPolicy(encodedPolicy); // Policy

            // 4. Get response and return credentials
            CreateStorageCredentialsResponse resp = vodClient.CreateStorageCredentials(req);

            return new Cred(
                    resp.getCredentials().getAccessKeyId(),
                    resp.getCredentials().getSecretAccessKey(),
                    resp.getCredentials().getSessionToken());
        } catch (TencentCloudSDKException e) {
            System.err.println("Failed to obtain storage credentials: " + e.getMessage());
            throw new Exception("Failed to obtain storage credentials", e);
        }
    }

    /​**​
     * Create policy JSON string using org.json library
     *
     * @return Policy JSON string
     */
    private static String createPolicyJson() {
        // Build resource path
        String resource = String.format(
                "qcs::vod:%s:uid/%d:prefix//%d/%s/%s",
                REGION,
                APP_ID,
                SUB_APP_ID,
                BUCKET_ID,
                FILE_KEY);

        // Build operation list
        String[] actions = {
                "name/vod:PutObject",
                "name/vod:ListParts",
                "name/vod:PostObject",
                "name/vod:CreateMultipartUpload",
                "name/vod:UploadPart",
                "name/vod:CompleteMultipartUpload",
                "name/vod:AbortMultipartUpload",
                "name/vod:ListMultipartUploads"
        };

        // Build JSON using JSONObject
        JSONObject policy = new JSONObject();
        policy.put("version", "2.0");

        JSONArray statements = new JSONArray();
        JSONObject statement = new JSONObject();

        JSONArray actionArray = new JSONArray();
        for (String action : actions) {
            actionArray.put(action);
        }
        statement.put("action", actionArray);

        statement.put("effect", "allow");

        JSONArray resources = new JSONArray();
        resources.put(resource);
        statement.put("resource", resources);

        statements.put(statement);
        policy.put("statement", statements);

        return policy.toString();
    }
}

#include <tencentcloud/core/TencentCloud.h>
#include <tencentcloud/core/profile/ClientProfile.h>
#include <tencentcloud/core/profile/HttpProfile.h>
#include <tencentcloud/core/Credential.h>
#include <tencentcloud/vod/v20240718/VodClient.h>
#include <tencentcloud/vod/v20240718/model/CreateStorageCredentialsRequest.h>
#include <tencentcloud/vod/v20240718/model/CreateStorageCredentialsResponse.h>
#include <string>
#include <sstream>
#include <iomanip>
#include <iostream>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

const uint64_t APP_ID = 251000000;                // Tencent Cloud account APPID
const uint64_t SUB_APP_ID = 1234567890;           // VOD Professional Edition application APPID
const std::string BUCKET_ID = "bucketid1";        // VOD Professional Edition bucket ID
const std::string REGION = "ap-guangzhou";        // VOD Professional Edition bucket region
const std::string OBJECT_KEY = "upload/demo.mp4"; // File KEY to apply permissions for

// Credential struct
struct Credential
{
    std::string accessKeyId;
    std::string secretAccessKey;
    std::string sessionToken;
};

// URL encoding function
std::string UrlEncode(const std::string &value)
{
    std::ostringstream escaped;
    escaped.fill('0');
    escaped << std::hex;

    for (char c : value)
    {
        if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~')
        {
            escaped << c;
        }
        else
        {
            escaped << std::uppercase;
            escaped << '%' << std::setw(2) << int((unsigned char)c);
            escaped << std::nouppercase;
        }
    }

    return escaped.str();
}

// Obtain credentials
Credential GetCredential()
{
    // Initialize Tencent Cloud SDK
    TencentCloud::InitAPI();

    // Create VOD client
    TencentCloud::Credential credential("SecretId", "SecretKey"); // Fill in Tencent Cloud account SecretId and SecretKey
    TencentCloud::HttpProfile httpProfile;
    TencentCloud::ClientProfile clientProfile;
    clientProfile.SetHttpProfile(httpProfile);

    TencentCloud::Vod::V20240718::VodClient client(credential, "ap-guangzhou", clientProfile);

    // Build policy
    json policy_json = {
        {"statement", {{{"action", {"name/vod:PutObject", "name/vod:ListParts", "name/vod:PostObject", "name/vod:CreateMultipartUpload", "name/vod:UploadPart", "name/vod:CompleteMultipartUpload", "name/vod:AbortMultipartUpload", "name/vod:ListMultipartUploads"}}, {"effect", "allow"}, {"resource", {"qcs::vod:" + REGION + ":uid/" + std::to_string(APP_ID) + ":prefix//" + std::to_string(SUB_APP_ID) + "/" + BUCKET_ID + "/" + OBJECT_KEY}}}}},
        {"version", "2.0"}};
    std::string policy = policy_json.dump();

    // Create request object
    TencentCloud::Vod::V20240718::Model::CreateStorageCredentialsRequest req;
    req.SetSubAppId(SUB_APP_ID);
    req.SetPolicy(UrlEncode(policy));

    // Send request
    auto outcome = client.CreateStorageCredentials(req);
    if (!outcome.IsSuccess())
    {
        std::cerr << "Failed to get storage credentials: " << outcome.GetError().GetErrorMessage() << std::endl;
        TencentCloud::ShutdownAPI();
        exit(1);
    }

    // Extract credentials
    auto response = outcome.GetResult();
    auto creds = response.GetCredentials();

    Credential result;
    result.accessKeyId = creds.GetAccessKeyId();
    result.secretAccessKey = creds.GetSecretAccessKey();
    result.sessionToken = creds.GetSessionToken();

    // Clean up Tencent Cloud SDK
    TencentCloud::ShutdownAPI();

    return result;
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import json
import urllib.parse
from typing import NamedTuple

from tencentcloud.common import credential
from tencentcloud.common.profile import client_profile
from tencentcloud.vod.v20240718 import vod_client, models

# Constant definitions
APP_ID = 251000000  # Tencent Cloud account APPID
SUB_APP_ID = 1234567890  # VOD Professional Edition application APPID
BUCKET_ID = "bucketid1"  # VOD Professional Edition bucket ID
OBJECT_KEY = "upload/demo.mp4"  # File KEY in storage after upload
REGION = "ap-guangzhou"  # Region


class Credential(NamedTuple):
    """Temporary credentials"""
    access_key_id: str
    secret_access_key: str
    session_token: str


def get_credential() -> Credential:
    """Obtain credentials"""
    # 1. Initialize Tencent Cloud API object
    cred = credential.Credential(
        "SecretId",  # Tencent Cloud account SecretId
        "SecretKey",  # Tencent Cloud account SecretKey
    )
    prof = client_profile.ClientProfile()
    vod_cli = vod_client.VodClient(cred, "ap-guangzhou", prof)

    # 2. Construct upload temporary credential request
    policy = {
        "statement": [
            {
                "action": [
                    "name/vod:PutObject",
                    "name/vod:ListParts",
                    "name/vod:PostObject",
                    "name/vod:CreateMultipartUpload",
                    "name/vod:UploadPart",
                    "name/vod:CompleteMultipartUpload",
                    "name/vod:AbortMultipartUpload",
                    "name/vod:ListMultipartUploads",
                ],
                "effect": "allow",
                "resource": [f"qcs::vod:{REGION}:uid/{APP_ID}:prefix//{SUB_APP_ID}/{BUCKET_ID}/{OBJECT_KEY}"],
            }
        ],
        "version": "2.0",
    }

    req = models.CreateStorageCredentialsRequest()
    req.SubAppId = SUB_APP_ID
    req.Policy = urllib.parse.quote(json.dumps(policy))

    # 3. Apply for upload credentials
    resp = vod_cli.CreateStorageCredentials(req)
    creds = resp.Credentials
    return Credential(
        access_key_id=creds.AccessKeyId,
        secret_access_key=creds.SecretAccessKey,
        session_token=creds.SessionToken,
    )