create-pardx-scaffold 0.1.0

package/template/apps/api/libs/infra/utils/crypto.util.ts

@@ -0,0 +1,206 @@
+import * as crypto from 'crypto';
+import * as CryptoJS from 'crypto-js';
+
+export function rsaDecrypt(val: string) {
+  if (!val || typeof val !== 'string') {
+    console.error('[rsaDecrypt] Invalid input:', {
+      val: val?.substring(0, 50),
+    });
+    return '';
+  }
+  try {
+    // 将 base64 编码的加密数据转换为 Buffer
+    const bytes = CryptoJS.AES.decrypt(val, 'qmez2n1llvatr8gczip6uyokpi1wi8ys');
+    const originalText = bytes.toString(CryptoJS.enc.Utf8);
+    if (!originalText || originalText.trim() === '') {
+      console.error('[rsaDecrypt] Decryption result is empty', {
+        inputLength: val.length,
+        inputPreview: val.substring(0, 50),
+      });
+    }
+    return originalText;
+  } catch (error) {
+    console.error('[rsaDecrypt] Decryption failed:', {
+      error: error.message || error,
+      inputLength: val.length,
+      inputPreview: val.substring(0, 50),
+    });
+    return '';
+  }
+}
+
+/**
+ * AES 加密（实际是 AES，但函数名保持与 Vue 代码一致）
+ */
+export function rsaEncrypt(val: string): string {
+  const key = 'qmez2n1llvatr8gczip6uyokpi1wi8ys';
+  const cipher = CryptoJS.AES.encrypt(val, key);
+  return cipher.toString();
+}
+
+/**
+ * 使用 AES 算法解密数据
+ * @param val 加密后的字符串（通常是 Base64 编码）
+ * @param secretKey 密钥（必须是字符串）
+ * @returns 解密后的字符串
+ */
+/**
+ * AES CBC decryption function
+ * @param {string} val - Encrypted data (Base64 encoded string)
+ * @param {string} secretKey - Secret key (string)
+ * @param {string} iv - Initialization vector (string)
+ * @returns {string} - Decrypted data (original text)
+ */
+export function aesCbcDecrypt(val, secretKey, iv) {
+  try {
+    const ivBuffer = CryptoJS.enc.Utf8.parse(iv);
+
+    const decryptedBytes = CryptoJS.AES.decrypt(
+      val,
+      CryptoJS.enc.Utf8.parse(secretKey),
+      {
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7,
+        iv: ivBuffer,
+      },
+    );
+
+    const originalText = decryptedBytes.toString(CryptoJS.enc.Utf8);
+    return originalText;
+  } catch (error) {
+    console.error('Decryption failed:', error);
+    throw new Error('Failed to decrypt data due to an error.');
+  }
+}
+
+/**
+ * AES CBC encryption function
+ * @param {string} plainText - Data to encrypt (string)
+ * @param {string} secretKey - Secret key (string)
+ * @param {string} iv - Initialization vector (string or Buffer)
+ * @returns {string} - Encrypted data (Base64 encoded string)
+ */
+export function aesCbcEncrypt(plainText, secretKey, iv) {
+  const ivBuffer = CryptoJS.enc.Utf8.parse(iv);
+
+  const ciphered = CryptoJS.AES.encrypt(
+    plainText,
+    CryptoJS.enc.Utf8.parse(secretKey),
+    {
+      mode: CryptoJS.mode.CBC,
+      padding: CryptoJS.pad.Pkcs7,
+      iv: ivBuffer,
+    },
+  );
+
+  return ciphered.toString();
+}
+/**
+ * 解密
+ * @param dataStr {string}
+ * @param key {string}
+ * @param iv {string}
+ * @return {string}
+ */
+export function decrypt(dataStr: string, key: string, iv: string): string {
+  try {
+    const decipher = crypto.createDecipheriv('aes-128-cbc', key, iv);
+    decipher.setAutoPadding(true);
+    let decrypted = decipher.update(dataStr, 'base64', 'utf8');
+    try {
+      decrypted += decipher.final('utf8');
+    } catch (err) {
+      console.error('Decryption failed:', err);
+      throw err; // 或者您可以选择返回一个错误消息或空字符串
+    }
+    return decrypted;
+  } catch (err) {
+    console.error('Error in decryption setup:', err);
+    throw err; // 抛出错误或返回错误消息
+  }
+}
+
+/**
+ * 加密
+ * @param dataStr {string}
+ * @param key {string}
+ * @param iv {string} 16位
+ * @return {string}
+ */
+export function encrypt(dataStr: string, key: string, iv: string): string {
+  try {
+    const cipher = crypto.createCipheriv('aes-128-cbc', key, iv);
+    cipher.setAutoPadding(true);
+
+    let encrypted = cipher.update(dataStr, 'utf8', 'base64');
+    encrypted += cipher.final('base64');
+
+    return encrypted;
+  } catch (err) {
+    console.error('Error in encryption:', err);
+    throw new Error('Error encrypting data');
+  }
+}
+
+export function WXBizDataCrypt(appId, sessionKey, encryptedData, iv) {
+  // base64 decode
+  sessionKey = Buffer.from(sessionKey, 'base64');
+  encryptedData = Buffer.from(encryptedData, 'base64');
+  iv = Buffer.from(iv, 'base64');
+
+  let decoded;
+  try {
+    // 解密
+    const decipher = crypto.createDecipheriv('aes-128-cbc', sessionKey, iv);
+    // 设置自动 padding 为 true，删除填充补位
+    decipher.setAutoPadding(true);
+    decoded = decipher.update(encryptedData, 'binary', 'utf8');
+    decoded += decipher.final('utf8');
+    decoded = JSON.parse(decoded);
+  } catch (err) {
+    throw new Error('解密失败');
+  }
+
+  if (decoded.watermark.appid !== appId) {
+    throw new Error('appid 错误');
+  }
+
+  return decoded;
+}
+
+/**
+ * @param {string} algorithm
+ * @param {any} content
+ *  @return {string}
+ */
+export const signEncrypt = (algorithm, content) => {
+  const hash = crypto.createHash(algorithm);
+  hash.update(content);
+  return hash.digest('hex');
+};
+
+/**
+ * @param {any} content
+ *  @return {string}
+ */
+export const sha1 = (content) => signEncrypt('sha1', content);
+
+export const signUrl = (uri: string, key: string): string => {
+  // 使用CryptoJS计算HMAC_SHA1
+  const hash = CryptoJS.HmacSHA1(uri, key);
+
+  const wordArray = hash.words;
+  const sigBytes = hash.sigBytes;
+  const buffer = Buffer.from(wordArray.map((word) => (word >>> 0) & 0xff));
+  // 使用Base64 URL安全的编码
+  const hash_encoded = buffer
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '');
+
+  // 将签名信息添加到URL末尾
+  const signedUrl = `${uri}sig=${hash_encoded}`;
+
+  return signedUrl;
+};

package/template/apps/api/libs/infra/utils/download.ts

@@ -0,0 +1,21 @@
+import * as stream from 'stream';
+import { promisify } from 'util';
+import axios from 'axios';
+import * as fs from 'node:fs';
+
+const finished = promisify(stream.finished);
+
+export async function downloadFile(
+  fileUrl: string,
+  outputLocationPath: string,
+): Promise<any> {
+  const writer = fs.createWriteStream(outputLocationPath);
+  return axios({
+    method: 'GET',
+    url: fileUrl,
+    responseType: 'stream',
+  }).then((response) => {
+    response.data.pipe(writer);
+    return finished(writer); //this is a Promise
+  });
+}

package/template/apps/api/libs/infra/utils/enviroment.util.ts

@@ -0,0 +1,130 @@
+import { FastifyRequest } from 'fastify';
+import { FileEnvType } from '@prisma/client';
+
+export default {
+  getBaseZone() {
+    return process.env?.BASE_ZONE || 'cn';
+  },
+  getNeedSsoLogin() {
+    return process.env?.NEED_SSO_LOGIN || 'true';
+  },
+  getDevDebug() {
+    return process.env?.LOCAL_DEV_DEBUG || 'true';
+  },
+  getDevConnectProdDB() {
+    return process.env?.DEV_USE_PRODDB || 'false';
+  },
+
+  getEnv(): FileEnvType {
+    if (
+      process.env?.NODE_ENV === 'prod' ||
+      process.env?.NODE_ENV === 'production'
+    ) {
+      return FileEnvType.prod;
+    }
+    if (process.env?.NODE_ENV === 'produs') {
+      return FileEnvType.produs;
+    }
+    if (process.env?.NODE_ENV === 'prodap') {
+      return FileEnvType.prodap;
+    }
+    if (process.env?.NODE_ENV === 'test') {
+      return FileEnvType.test;
+    }
+    return FileEnvType.dev;
+  },
+
+  isDevDebug() {
+    return this.isDev() && this.getDevDebug() === 'true';
+  },
+
+  isDevConnectProdDB() {
+    return this.isDevDebug() && this.getDevConnectProdDB() === 'true';
+  },
+
+  isDev() {
+    // return false
+    return this.getEnv() === 'dev';
+  },
+
+  isTest() {
+    return this.getEnv() === 'test';
+  },
+
+  isProduction() {
+    return this.getEnv().startsWith('prod');
+  },
+
+  isCheckSha256() {
+    return this.isProduction();
+  },
+
+  isCnProduction() {
+    return this.getEnv() === 'prod';
+  },
+
+  isApProduction() {
+    return this.getEnv() === 'prodap';
+  },
+
+  checkEnvCanSso() {
+    return ['dev', 'test', 'prod'].indexOf(this.getEnv()) !== -1;
+  },
+
+  isWeChatMiniProgram(req: FastifyRequest) {
+    const userAgent = (req.headers['user-agent'] || '').toLowerCase();
+    return (
+      userAgent.includes('micromessenger') &&
+      (userAgent.includes('miniprogram') ||
+        userAgent.includes('wechatdevtools'))
+    );
+  },
+
+  generateEnvironmentUrls(): {
+    web: string;
+    api: string;
+    internalApi: string;
+    short: string;
+    corsDomains: string[];
+  } {
+    const protocol = this.isProduction() ? 'https' : 'http';
+    const corsDomains = ['*', '*.pardx.ai', '*.pardx.ai'];
+    let domain,
+      subDomain = '',
+      apiSubDomain = '';
+
+    switch (true) {
+      case this.isDev():
+        domain = 'pardx.ai';
+        subDomain = 'www.local';
+        apiSubDomain = 'api.local';
+        break;
+      case this.isTest():
+        domain = 'pardx.ai';
+        subDomain = 'www.test';
+        apiSubDomain = 'api.test';
+        break;
+      case this.isCnProduction():
+        domain = 'pardx.cn';
+        subDomain = 'www';
+        apiSubDomain = 'mp';
+        break;
+      default:
+        domain = 'pardx.ai';
+        subDomain = 'www';
+        apiSubDomain = 'api';
+        break;
+    }
+
+    const web = `${protocol}://${subDomain ? `${subDomain}.` : ''}${domain}/`;
+    let api = `${protocol}://${apiSubDomain ? `${apiSubDomain}.` : ''}${domain}/api`;
+    let internalApi = api;
+    // console.log('techwu api', corsDomains);
+    if (this.isDev()) {
+      api = process.env.API_BASE_URL || api;
+      internalApi = process.env.INTERNAL_API_BASE_URL || api;
+    }
+    const short = `${web}s/`;
+    return { web, api, internalApi, short, corsDomains };
+  },
+};

package/template/apps/api/libs/infra/utils/ffmpeg.util.ts

@@ -0,0 +1,29 @@
+export const isHDR = (ffmpegInfo: any): boolean => {
+  const hdrStandards = {
+    colorPrimaries: ['bt2020', 'smpte2084', 'arib-std-b67'],
+    colorTransfers: ['smpte2084', 'arib-std-b67'],
+  };
+  return ffmpegInfo.streams.some(
+    (stream: any) =>
+      hdrStandards.colorPrimaries.includes(stream.color_primaries) ||
+      hdrStandards.colorTransfers.includes(stream.color_transfer),
+  );
+};
+
+export const getVideoFrameRate = (ffmpegInfo: any): string | undefined => {
+  // 平均帧率
+  let rFrameRate: string | undefined = ffmpegInfo?.streams[0]?.r_frame_rate;
+  if (!rFrameRate) {
+    rFrameRate = ffmpegInfo?.streams[0]?.frame_rate;
+  }
+  if (!rFrameRate) {
+    const nbFrames = ffmpegInfo?.streams[0]?.nb_frames;
+    const duration =
+      ffmpegInfo?.format?.duration || ffmpegInfo?.streams[0]?.duration;
+    if (nbFrames && duration) {
+      rFrameRate =
+        (parseInt(nbFrames) / parseFloat(duration)).toFixed(4) + ':1';
+    }
+  }
+  return rFrameRate;
+};