midway-fatcms 0.0.1-beta.1

package/src/service/FileCenterService.ts

@@ -0,0 +1,394 @@
+import { Provide, Inject } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as mime from 'mime-types';
+import * as md5 from 'md5';
+import * as fs from 'fs';
+import * as util from 'util';
+import { BizException } from '../models/devops';
+import { CurdMixService } from './curd/CurdMixService';
+import { KeysOfSimpleSQL, KeysOfValidators } from '../libs/crud-pro/models/keys';
+import { AccessType, IEntityCommonInfo, UploadCategoryType } from '../models/bizmodels';
+import { IRequestCfgModel } from '../libs/crud-pro/interfaces';
+import { BaseService } from './base/BaseService';
+import {SystemDbName, SystemDbType} from '../models/SystemTables';
+
+function getSuffix(s: string): string {
+  if (s) {
+    const indexOf = s.lastIndexOf('.');
+    if (indexOf > 0) {
+      return s.substring(indexOf); //'.jpg'
+    }
+  }
+  return '';
+}
+
+function getDateTimeString() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = now.getMonth() + 1;
+  const day = now.getDate();
+  return [year, month, day]
+    .map(num => {
+      if (num < 10) {
+        return '0' + num;
+      }
+      return num;
+    })
+    .join('');
+}
+
+function generateFileKey(filename: string, sessionId: string, fileStat: any) {
+  const fileStatString = JSON.stringify(fileStat);
+  const date = getDateTimeString();
+  const fileSuffix = getSuffix(filename).toLowerCase();
+  const fileKey = md5(`${filename}${sessionId}${fileStatString}${Math.random()}`) + Date.now() + fileSuffix;
+  const storagePath = `upload/${date}/${fileKey}`;
+
+  return {
+    fileKey,
+    fileSuffix,
+    storagePath,
+  };
+}
+
+function getAssetsContentType(filename: string): string {
+  if (filename.endsWith('.css')) {
+    return 'text/css';
+  }
+  if (filename.endsWith('.txt')) {
+    return 'text/plain';
+  }
+  if (filename.endsWith('.js') || filename.endsWith('.cjs')) {
+    return 'application/javascript';
+  }
+  if (filename.endsWith('.html')) {
+    return 'text/html';
+  }
+  const contentType = mime.lookup(filename);
+  if (contentType && typeof contentType === 'string') {
+    return contentType;
+  }
+  return 'application/octet-stream';
+}
+
+
+// JPG、PNG、BMP、GIF、WebP、TIFF
+export function isImageFile(fileKey: string) {
+  const fileKey1 = fileKey.toLowerCase();
+  const suffix = ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp', '.tiff'];
+  for (let i = 0; i < suffix.length; i++) {
+    const suffix1 = suffix[i];
+    if (fileKey1.endsWith(suffix1)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+interface IFileInfo extends IEntityCommonInfo {
+  file_key: string;
+  file_name: string;
+  file_size: number;
+  file_type: string;
+  file_suffix: string;
+  file_desc: string;
+  storage_path: string;
+  storage_url: string;
+  storage_engine: string;
+  access_type: string;
+  referer: string;
+}
+
+class FileDB {
+  private curdMixService: CurdMixService;
+
+  constructor(curdMixService: CurdMixService) {
+    this.curdMixService = curdMixService;
+  }
+
+  async getFileInfo(fileKey: string): Promise<IFileInfo> {
+    const condition: any = { file_key: fileKey };
+    const cfgModel: IRequestCfgModel = {
+      sqlTable: 'sys_file',
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+      sqlDatabase: SystemDbName,
+      sqlDdType: SystemDbType,
+      validateCfg: {
+        'condition.file_key': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+      },
+    };
+
+    const res = await this.curdMixService.executeCrudByCfg({ condition }, cfgModel);
+    return res.getOneObj();
+  }
+
+  async saveFileInfo(fileInfo: IFileInfo) {
+    const cfgModel = {
+      sqlTable: 'sys_file',
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT,
+      sqlDatabase: SystemDbName,
+      sqlDdType: SystemDbType,
+    };
+    return await this.curdMixService.executeCrudByCfg(
+      {
+        data: fileInfo,
+        condition: {
+          file_key: fileInfo.file_key,
+        },
+      },
+      cfgModel
+    );
+  }
+
+  async saveAssetsLog(fileInfo: IFileInfo) {
+    const cfgModel = {
+      sqlTable: 'sys_assets_log',
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT,
+      sqlDatabase: SystemDbName,
+      sqlDdType: SystemDbType,
+    };
+    return await this.curdMixService.executeCrudByCfg({ data: fileInfo }, cfgModel);
+  }
+
+  async deleteFileInfo(id: number) {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable: 'sys_file',
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_DELETE,
+      sqlDatabase: SystemDbName,
+      sqlDdType: SystemDbType,
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.NUMBER],
+      },
+    };
+    return await this.curdMixService.executeCrudByCfg({ condition: { id } }, cfgModel);
+  }
+}
+
+interface IUploadFileToOSSOptions {
+  uploadCategoryType: UploadCategoryType;
+  uploadPath: string;
+}
+
+
+
+export const PATH_PREFIX = '/ns/gw/file';
+
+export function toDownloadPaths(origin: string, fileKey: string) {
+  const downloadPath = `${PATH_PREFIX}/get/download/${fileKey}`;
+  const previewPath = `${PATH_PREFIX}/get/preview/${fileKey}`;
+  const thumbnailPath = `${PATH_PREFIX}/get/thumbnail/${fileKey}`;
+
+  return {
+    downloadPath,
+    previewPath,
+    thumbnailPath,
+    downloadURL: `${origin}${downloadPath}`,
+    previewURL: `${origin}${previewPath}`,
+    thumbnailURL: `${origin}${thumbnailPath}`,
+  };
+}
+
+
+function toUploadOriginByReferer(referer: string): string {
+  try {
+    if (!referer || !referer.startsWith('http')) {
+      return '';
+    }
+    const urlObj = new URL(referer);
+    const pathname = urlObj.pathname;
+    if (pathname.startsWith('/ns/app/doc-editor/')) {
+      return 'doc-editor';
+    }
+    if (pathname.startsWith('/pages/devops/file-manage')) {
+      return  'file-manage';
+    }
+  } catch (error) {
+    console.error('toUploadOriginByReferer', error);
+  }
+  return '';
+}
+
+
+@Provide()
+export class FileCenterService extends BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private curdMixService: CurdMixService;
+
+  private get fileBD(): FileDB {
+    return new FileDB(this.curdMixService);
+  }
+
+  public async uploadFileToOSS(files: any, accessType: AccessType, referer: string, options?: IUploadFileToOSSOptions) {
+    if (!files || files.length === 0) {
+      throw new BizException('没有选中任何文件');
+    }
+    if (files.length > 1) {
+      throw new BizException('每次只能上传一个文件');
+    }
+
+    const file = files[0]; // 每次只能上传一个文件
+    const { mimeType, filename, data: fileData } = file;
+    this.logInfo('[FileCenterService]uploadFileToOSS', file);
+
+    const statAsync = util.promisify(fs.stat);
+
+    const fileStat = await statAsync(fileData);
+
+    this.logInfo('[FileCenterService]uploadFileToOSS fileStat', fileStat);
+
+    const sessionId = this.ctx.userSession.getSessionInfo().sessionId;
+
+    let fileSuffix = getSuffix(filename).toLowerCase();
+    let fileKey: string, storagePath: string, result: any;
+    const isAssets = options && options.uploadCategoryType === UploadCategoryType.assets;
+    if (isAssets) {
+      const uploadPath = options.uploadPath;
+      storagePath = `assets/${uploadPath}`;
+      fileKey = storagePath;
+      result = await this.getPublicOSSService().put(storagePath, fileData, {
+        mime: mimeType,
+        headers: {
+          'Content-Type': getAssetsContentType(filename),
+        },
+      });
+    } else {
+      const generated = generateFileKey(filename, sessionId, fileStat);
+      fileKey = generated.fileKey;
+      fileSuffix = generated.fileSuffix;
+      storagePath = generated.storagePath;
+      result = await this.getPrivateOSSService().put(storagePath, fileData, {
+        mime: mimeType,
+        headers: {
+          'Content-Type': getAssetsContentType(filename),
+          'Content-Disposition': `attachment; filename="${encodeURI(filename)}"`,
+        },
+      });
+    }
+
+    const uploadOrigin = toUploadOriginByReferer(referer);
+
+    const saveInfo = {
+      file_key: fileKey,
+      file_name: filename,
+      file_size: fileStat.size,
+      file_type: file.mimeType,
+      file_suffix: fileSuffix,
+      file_desc: '',
+      storage_path: storagePath,
+      storage_url: result.url,
+      storage_engine: 'AliYunOSS',
+      access_type: accessType,
+      referer: referer,
+      upload_origin: uploadOrigin,
+    };
+
+    if (isAssets) {
+      await this.fileBD.saveAssetsLog(saveInfo);
+    } else {
+      await this.fileBD.saveFileInfo(saveInfo);
+    }
+
+    return {
+      fileKey,
+      fileSuffix,
+      storagePath,
+      storageUrl: result.url,
+      fileSize: result.res.size,
+      filename: file.filename,
+      mimeType: file.mimeType,
+      name: result.name,
+      url: result.url,
+    };
+  }
+
+  public async deleteFile(fileKey: string) {
+    const fileInfo = await this.fileBD.getFileInfo(fileKey);
+    if (!fileInfo || fileInfo.status !== 1) {
+      throw new BizException('文件不存在');
+    }
+    const storagePath = fileInfo.storage_path;
+    const res = await this.getPrivateOSSService().delete(storagePath);
+    this.logInfo('deleteFile', res);
+
+    return await this.fileBD.deleteFileInfo(fileInfo.id);
+  }
+
+  private async headFile(path: string) {
+    try {
+      return await this.getPrivateOSSService().head(path);
+    } catch (error) {
+      if (error.code !== 'NoSuchKey') {
+        this.logError('[FILE_CHECK_ERROR]', error);
+      }
+      return false;
+    }
+  }
+
+  public async downloadFile(fileKey: string, streaming: boolean, process: string): Promise<any> {
+    const fileInfo = await this.fileBD.getFileInfo(fileKey);
+    if (!fileInfo || fileInfo.status !== 1) {
+      throw new BizException('文件不存在');
+    }
+
+    await this.checkAuthUserDownloadFile(fileInfo);
+
+    const storagePath = fileInfo.storage_path;
+
+    const header = await this.headFile(storagePath);
+    if (!header) {
+      throw new BizException('文件不存在或者已过期');
+    }
+
+    const urlParam: any = {};
+    urlParam.expires = 60;
+    if (process) {
+      urlParam.process = process;
+    }
+    try {
+      if (streaming) {
+        const { res, stream } = await this.getPrivateOSSService().getStream(storagePath, urlParam);
+        return { res, stream, downloadURL: null };
+      } else {
+        const downloadURL = this.getPrivateOSSService().signatureUrl(storagePath, urlParam);
+        return { res: null, stream: null, downloadURL };
+      }
+    } catch (e) {
+      this.logError('ossService ==> ', storagePath);
+      throw e;
+    }
+  }
+
+  /**
+   * 检查用户下载权限
+   * @param fileInfo
+   * @private
+   */
+  private async checkAuthUserDownloadFile(fileInfo: IFileInfo) {
+    const userSession = this.ctx.userSession;
+    if (userSession.isSuperAdmin()) {
+      return 'OK';
+    }
+
+    const access_type = fileInfo.access_type;
+    if (access_type === AccessType.open) {
+      return 'OK';
+    }
+
+    if (access_type === AccessType.owner) {
+      if (!userSession.isMySelf(fileInfo.created_by)) {
+        throw new BizException('您没有访问此文件的权限');
+      }
+    }
+
+    if (access_type === AccessType.login) {
+      if (!userSession.isLogin()) {
+        throw new BizException('您当前未登录，您没有访问此文件的权限');
+      }
+    }
+
+    return 'OK';
+  }
+}

package/src/service/SysConfigService.ts

@@ -0,0 +1,34 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { KeysOfSimpleSQL} from "../libs/crud-pro/models/keys";
+import {SystemDbName, SystemDbType, SystemTables} from "../models/SystemTables";
+import {BaseService} from "./base/BaseService";
+import {CurdProService} from "./curd/CurdProService";
+
+@Provide()
+export class SysConfigService extends BaseService {
+  @Inject()
+  ctx: Context;
+
+  @Inject()
+  private curdProService: CurdProService;
+
+  async getSysConfigOne(config_code: string): Promise<any> {
+    if (!config_code){
+      throw new Error('[getSysConfigOne] config_code required');
+    }
+    const res1 = await this.curdProService.executeCrudByCfg(
+      {
+        condition: { config_code },
+      },
+      {
+        sqlTable: SystemTables.sys_configs,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+        sqlDatabase: SystemDbName,
+        sqlDdType: SystemDbType,
+      }
+    );
+    return res1.getOneObj();
+  }
+
+}

package/src/service/UserAccountService.ts

@@ -0,0 +1,100 @@
+import * as md5 from 'md5';
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { KeysOfSimpleSQL } from '../libs/crud-pro/models/keys';
+import { CurdMixService } from './curd/CurdMixService';
+import { createUniqueId } from '../libs/utils/functions';
+import { CommonException, Exceptions } from '../libs/crud-pro/exceptions';
+import { IRequestCfgModel, IRequestModel } from '../libs/crud-pro/interfaces';
+import {SystemDbName, SystemDbType, SystemTables} from '../models/SystemTables';
+import { CommonResult } from '../libs/utils/common-dto';
+
+@Provide()
+export class UserAccountService {
+  @Inject()
+  ctx: Context;
+  @Inject()
+  private curdMixService: CurdMixService;
+
+  /**
+   * 查询用户: 根据loginName查询
+   * @param loginName
+   */
+  public async queryUserAccountByLoginName(loginName: string) {
+    const query = await this.curdMixService.executeCrudByCfg(
+      {
+        condition: { login_name: loginName },
+      },
+      {
+        method: 'UserAccountService.queryUserAccountByLoginName',
+        sqlTable: SystemTables.sys_user_account,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+        sqlDatabase: SystemDbName,
+        sqlDdType: SystemDbType,
+      }
+    );
+    const { row } = query.getResModel();
+    return row;
+  }
+
+  /**
+   * 查询基本信息：根据accountId数组
+   * @param accountIdList
+   * @param columns
+   */
+  public async queryAccountBasicInfoByIds(accountIdList: any[], columns: string[]): Promise<any[]> {
+    if (!accountIdList || accountIdList.length === 0) {
+      return [];
+    }
+
+    const accountIds = accountIdList.map(userId => {
+      return `${userId}`;
+    });
+
+    const cfgModel: IRequestCfgModel = {
+      method: 'UserAccountService.queryAccountBasicInfoByIds',
+      sqlTable: SystemTables.sys_user_account,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+      sqlDatabase: SystemDbName,
+      sqlDdType: SystemDbType,
+    };
+
+    const reqJson: IRequestModel = {
+      columns: columns,
+      condition: {
+        account_id: {
+          $in: accountIds,
+        },
+      },
+    };
+
+    const res = await this.curdMixService.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResRows();
+  }
+
+  /**
+   * 修改密码
+   * @param loginName
+   * @param unsaltedPwd
+   */
+  public async chgUserPassword(loginName: any, unsaltedPwd: any) {
+    if (!loginName) {
+      throw new CommonException(Exceptions.OTHER_EXCEPTION, 'loginName不存在');
+    }
+    const pwd_salt = createUniqueId();
+    const pwd_md5 = md5(unsaltedPwd + pwd_salt);
+    const res1 = await this.curdMixService.executeCrudByCfg(
+      {
+        data: { pwd_md5: pwd_md5, pwd_salt: pwd_salt },
+        condition: { login_name: loginName },
+      },
+      {
+        sqlTable: SystemTables.sys_user_account,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
+        sqlDatabase: SystemDbName,
+        sqlDdType: SystemDbType,
+      }
+    );
+    return CommonResult.successRes(res1.getResModel());
+  }
+}

package/src/service/UserSessionService.ts

@@ -0,0 +1,81 @@
+import {Inject, Provide} from '@midwayjs/core';
+import {Context} from '@midwayjs/koa';
+import {parseJsonObject} from '../libs/utils/functions';
+import {ISessionInfo, SESSION_ID_KEY, sessionCookieCfg} from '../models/userSession';
+import {RedisCacheService} from "./base/RedisCacheService";
+
+
+function pickUserAvatar(avatar: any): string {
+  if (!avatar) {
+    return null;
+  }
+  if (typeof avatar === 'string') {
+    if (avatar.startsWith('http') || avatar.startsWith('/')) {
+      return avatar;
+    }
+    const obj = parseJsonObject(avatar);
+    if (!obj) {
+      return null;
+    }
+    if (Array.isArray(obj)) {
+      return pickUserAvatar(obj[0]);
+    }
+    return pickUserAvatar(obj);
+  }
+
+  if (avatar && avatar.imgURL) {
+    return avatar.imgURL;
+  }
+  if (avatar && avatar.downloadURL) {
+    return avatar.downloadURL;
+  }
+  return null;
+}
+
+
+const SESSION_KEEP_TIME_SECOND: number = 3600 * 24 * 30;
+
+const toCacheKey = (sessionId: string)=>{
+  return `UserSession@@${sessionId}`;
+}
+
+@Provide()
+export class UserSessionService {
+  @Inject()
+  private ctx: Context;
+
+  @Inject()
+  private redisCacheService: RedisCacheService
+
+
+  public async saveUserSession(sessionInfo: ISessionInfo) {
+    sessionInfo.avatar = pickUserAvatar(sessionInfo.avatar);
+    const sessionId = sessionInfo.sessionId;
+    await this.redisCacheService.setJsonObject(toCacheKey(sessionId), sessionInfo, SESSION_KEEP_TIME_SECOND)
+  }
+
+  /**
+   * 移除Session
+   * @param sessionId
+   */
+  public async removeUserSession(sessionId: string) {
+    return await this.redisCacheService.removeItem(toCacheKey(sessionId))
+  }
+
+  private async getCurrentUserSessionForMiddleware1(sessionId: string): Promise<ISessionInfo> {
+    if (!sessionId) {
+      return null;
+    }
+    return await this.redisCacheService.getJsonObject(toCacheKey(sessionId))
+  }
+
+  /**
+   * 专门给中间件点调用的
+   */
+  public async getCurrentUserSessionForMiddleware(): Promise<ISessionInfo> {
+    const cookies = this.ctx.cookies;
+    const sessionId = cookies.get(SESSION_ID_KEY, sessionCookieCfg);
+    return this.getCurrentUserSessionForMiddleware1(sessionId);
+  }
+
+}