后端集成

const Koa = require('koa')
const Router = require('koa-router')

const app = new Koa()
const router = new Router()

// 示例请求路由代码，后续会将其用正式路由替换
router.get('/hello', (ctx, next) => {
    ctx.body = 'world'
})

app.use(router.routes())
app.listen(80)

const tencentcloud = require("tencentcloud-sdk-nodejs");
const CmeClient = tencentcloud.cme.v20191029.Client;

// 实际编码中，请填准备工作中创建的智能创作的平台 Id
const config = { 
    platform: "test",
    secretId: "SecretId", // 用户的 SecretId，建议使用子账号密钥，授权遵循最小权限指引，降低使用风险。子账号密钥获取可参考https://cloud.tencent.com/document/product/598/37140
    secretKey: "SecretKey", // 用户的 SecretKey，建议使用子账号密钥，授权遵循最小权限指引，降低使用风险。子账号密钥获取可参考https://cloud.tencent.com/document/product/598/37140
}

const clientConfig = {
    credential: {
        // 需要传入准备工作中获取的 SecretId，SecretKey，此处还需注意密钥对的保密
        secretId: config.secretId,
        secretKey: config.secretKey,
    },
    region: "",
    profile: {
        httpProfile: {
            // 智能创作 API 接口调用域名，固定
            endpoint: "cme.tencentcloudapi.com",
        },
    }
};


const client = new CmeClient(clientConfig);

const querystring = require("querystring")
const crypto = require('crypto')

router.get('/CreateProject', async (ctx, next) => {
    // 1. 解析请求参数
    const userId = ctx.cookies.get('UserId');
    const name = ctx.query.Name;
    console.log(ctx.query);
    const aspectRatio = ctx.query.AspectRatio;
    const fileIdList = ctx.query.InitFileIdList.split(',');

    // 2. 调用智能创作服务端API创建项目
    const createProjectResult = await doCreateProject({
      userId,
      name,
      aspectRatio,
    });
    if (createProjectResult.Code !== 'Success') {
      ctx.body = {
          Code: "InternalError",
          Message: '服务器内部错误。',
      };
      return;
    }

    const projectId = createProjectResult.Data.ProjectId;

    // 3. 导入媒体到项目，目前导入媒体到项目失败没有返回失败，业务可根据实际情况重新导入或者直接返回失败并删除已经创建项目，暂时不考虑失败的场景，请业务自行处理
    await doImportMediasToProject(projectId, fileIdList);

    // 4. 生成签名
    const signature = genOpenProjectSign(userId, projectId);

    // 5. 应答
    ctx.body = {
        Code: "Success",
        Message: "成功",
        Data: {
          ProjectId: projectId,
          Signature: signature,
        }
    };
})

// 根据请求参数，组装到智能创作创建项目的参数
function buildCreateProjectParams(params) {
  const createProjectReq = new CmeModel.CreateProjectRequest();
  // 项目名称
  createProjectReq.Name = params.name;
  // 项目类别，固定为VIDEO_EDIT
  createProjectReq.Category = 'VIDEO_EDIT';
  // 视频宽高比，导出视频的宽边与高边的比例，使用接口参数指定的视频导出宽高比。如何视频的宽边为480像素, 高边为720像素，则宽高比为6:9
  createProjectReq.AspectRatio = params.aspectRatio;
  // 平台，填写准备工作中创建的平台Id
  createProjectReq.Platform = config.platform;
  // 项目模式，固定为Default
  createProjectReq.Mode = 'Default';

  // 项目归属，目前仅支持归属个人的项目
  const owner = new CmeModel.Entity();
  // 用户 Id，使用当前调用的用户Id，用于区分权限。可通过参数指定或者后台指定
  owner.Id = params.userId;
  // 项目归属类型，目前仅支持个人项目
  owner.Type = "PERSON";
  createProjectReq.Owner = owner;

  return createProjectReq;
}

// 到智能创作创建项目
function doCreateProject(params) {
  return new Promise((resolve, reject) => {
    client.CreateProject(buildCreateProjectParams(params), (err, response) => {
      if (err) {
        // 调用失败，打印日志
        console.error(err);
        reject({
          Code: "InternalError",
          Message: '系统错误。'
        });
      } else {
        // 成功
        console.debug('response', response);
        const resp = {
          Code: "Success",
          Message: "成功",
          Data: {
            ProjectId: response.ProjectId,
          }
        };
        resolve(resp);
      }
    });
  });
}

// 根据请求参数，组装到智能创作导入媒体到项目中的请求参数
function buildImportMediaToProjectParams(projectId, vodFileId) {
  const importMediaToProjectReq = new CmeModel.ImportMediaToProjectRequest();
  // 平台，填写准备工作中创建的平台Id
  importMediaToProjectReq.Platform = config.platform;
  // 项目Id
  importMediaToProjectReq.ProjectId = projectId;
  // 媒体来源，这里使用云点播文件固定为'VOD'，其它方式请参见文档
  importMediaToProjectReq.SourceType = 'VOD';
  // 云点播FileId
  importMediaToProjectReq.VodFileId = vodFileId;
  // 预处理参数，如里视频不能在浏览器直接播放(非h264 编辑、格式非mp4/m3u8/webm)需要添加此参数
  importMediaToProjectReq.PreProcessDefinition = 10;

  return importMediaToProjectReq;
}

// 将媒体导入到智能创作
function doImportMediasToProject(projectId, initFileIdList) {
  for (let i = 0; i < initFileIdList.length; ++i) {
    // 这里示例中单个文件导出失败没有返回错误，业务可根据实际情况做处理
    const vodFileId = initFileIdList[i];
    doImportOneMediaToProject(projectId, vodFileId);
  }
}

// 将单个点播文件导入到智能创作
function doImportOneMediaToProject(projectId, vodFileId) {
  return new Promise((resolve, reject) => {
    client.ImportMediaToProject(buildImportMediaToProjectParams(projectId, vodFileId), (err, response) =>  {
      if (err) {
        // 请求失败，打印日志
        console.error(err, response);
        reject({
          Code: "InternalError",
          Message: '系统错误。'
        });
      } else {
        // 请求正常返回，打印response对象
        console.log(response.to_json_string());
        resolve({
          Code: "Success",
          Message: "成功"
        });
      }
    });
  });
}

genOpenProjectSign(userId, projectId) {
  const current = parseInt((new Date()).getTime() / 1000);
  const expired = current + 86400;  // 签名有效期：1天，正常有效期从签发到使用时有效即可，建议下发较短有效期的签名

  const args = {
    // 需要传入准备工作中获取的 SecretId
    secretId: config.secretId,
    currentTimeStamp: current,
    expireTime: expired,
    random: Math.round(Math.random() * Math.pow(2, 32)),
    platform: config.platform,
    projectId,
    userId,
    action: 'OpenProject',
  };

   return genSha1Sign(args);
}

function genSha1Sign(args) {
  const original = querystring.stringify(args);
  const originalBuffer = Buffer.from(original, 'utf8');

  const hmac = crypto.createHmac('sha1', config.secretKey);
  const hmacBuffer = hmac.update(originalBuffer).digest();

  const signature = Buffer.concat([hmacBuffer, originalBuffer]).toString('base64');

  return signature
}

router.get('/ExportVideo', async (ctx, next) => {
    // 1. 解析请求参数
    const userId = ctx.cookies.get('UserId');
    const name = ctx.query.Name;
    const projectId = ctx.query.ProjectId;
    const definition = ctx.query.Definition;

    // 2. 调用智能创作服务端 API 发起导出任务
    const resp = await doExportVideoEditProject({
      userId,
      name,
      projectId,
      definition,
    });

    // 4. 应答
    ctx.body = resp;
})


// 根据请求参数，组装到智能创作发起导出视频的参数
function buildExportVideoEditProjectParams(params) {
  const exportVideoEditProjectReq = new CmeModel.ExportVideoEditProjectRequest();
  // 平台，填写准备工作中创建的平台Id
  exportVideoEditProjectReq.Platform = config.platform;
  // 导出模板 Id，具体请参见接口文档。此处填接口传递给服务端的参数
  exportVideoEditProjectReq.Definition = 10;
  exportVideoEditProjectReq.ProjectId = params.projectId;
  // 导出目标，此处为导出视频到云点播为例，固定填VOD。可以根据官网API文档选择导出到智能创作媒资
  exportVideoEditProjectReq.ExportDestination = 'VOD';
  const vodExportInfo = new CmeModel.VODExportInfo();
  // 导出的视频名称，填接口传递给服务端的参数
  if (params.name) {
    vodExportInfo.Name = params.name;
  } else {
    vodExportInfo.Name = 'test';
  }
  exportVideoEditProjectReq.VODExportInfo = vodExportInfo;
  exportVideoEditProjectReq.Operator = params.userId;

  return exportVideoEditProjectReq;
}

// 到智能创作发起导出任务
function doExportVideoEditProject(params) {
  return new Promise((resolve, reject) => {
    client.ExportVideoEditProject(buildExportVideoEditProjectParams(params), (err, response) => {
      if (err) {
        // 请求异常，打印错误信息
        console.error(err);
        reject({
          Code: "InternalError",
          Message: '系统错误。'
        });
      } else {
        // 请求正常返回，打印response对象
        console.log(response.to_json_string());
        resolve({
          Code: "Success",
          Message: "成功",
          Data: {
            TaskId: response.TaskId,
          }
        });
      }
    });
  });
}


router.get('/GetTaskInfo', async (ctx, next) => {
    // 1. 解析请求参数
    const userId = ctx.cookies.get('UserId');
    const taskId = ctx.query.TaskId;

    // 2. 调用智能创作服务端 API 获取导出任务结果
    const resp = await doGetTaskInfo({ userId, taskId });

    // 3. 应答
    ctx.body = resp;
})

// 根据请求参数，组装到智能创作获取导出结果的参数
function buildGetTaskInfoParams(params) {
  const describeTaskDetailReq = new CmeModel.DescribeTaskDetailRequest();
  // 平台，填写准备工作中创建的平台Id
  describeTaskDetailReq.Platform = config.platform;
  // 项目Id，填参数传递到服务端的项目Id
  describeTaskDetailReq.TaskId = params.taskId;
  // 操作者，可通过操作者来鉴权
  describeTaskDetailReq.Operator = params.userId;

  return describeTaskDetailReq;
}

// 到智能创作获取任务信息
function doGetTaskInfo(params) {
  return new Promise((resolve, reject) => {
    client.DescribeTaskDetail(buildGetTaskInfoParams(params), (err, response) => {
      if (err) {
        // 调用失败，打日志
        console.log(err);
        reject({
          Code: "InternalError",
          Message: '系统错误。'
        });
      } else {
        console.log(response.to_json_string());

        const result = {
          Status: response.Status, // 任务状态，只状态为 'SUCCESS' 才算成功
          Progress: response.Progress,
          ErrorCode: response.ErrCode,
          ErrMsg: response.ErrMsg,
        };
        if (response.VideoEditProjectOutput && response.VideoEditProjectOutput.URL) {
          // 导出的视频播放URL
          result.FileUrl = response.VideoEditProjectOutput.URL;
          // 导出的视频的云点播FileId
          result.FileId = response.VideoEditProjectOutput.VodFileId;
        }
        resolve({
          Code: "Success",
          Message: "成功",
          Data: result
        });
      }
    });
  });
}