midway-fatcms 0.0.1-beta.55 → 0.0.1-beta.56

package/src/models/contextLogger.ts

@@ -0,0 +1,132 @@
+import { ILogger } from '@midwayjs/core';
+import * as koa from '@midwayjs/koa';
+import { Context } from '@midwayjs/koa';
+import * as moment from 'moment';
+
+import { isEnableDebug } from '../libs/utils/fatcms-request';
+
+interface ILoggerContext extends ILogger {
+  log(msg: any, ...args: any[]): void;
+}
+
+const consoleLogger: ILoggerContext = {
+  info: (msg: any, ...args: any[]) => {
+    console.info(msg, ...args);
+  },
+  debug: (msg: any, ...args: any[]) => {
+    console.debug(msg, ...args);
+  },
+  error: (msg: any, ...args: any[]) => {
+    console.error(msg, ...args);
+  },
+  warn: (msg: any, ...args: any[]) => {
+    console.warn(msg, ...args);
+  },
+  log: (msg: any, ...args: any[]) => {
+    console.log(msg, ...args);
+  },
+};
+
+function getCallerInfo() {
+  // 创建一个新的 Error 对象
+  const error = new Error();
+  // 获取调用栈信息
+  const stack = error.stack.split('\n');
+  // 跳过前几行
+  const callerLine = stack[4];
+  // 提取文件名和行号
+  const match = callerLine.match(/at\s+(.*)\s+\((.*):(\d+):(\d+)\)/);
+  if (match) {
+    return {
+      functionName: match[1],
+      fileName: match[2],
+      lineNumber: parseInt(match[3]),
+      columnNumber: parseInt(match[4]),
+    };
+  }
+  return null;
+}
+
+/**
+ * 每个Context请求，都会创建一个新的ContextLogger对象
+ */
+class ContextLogger implements ILoggerContext {
+  private readonly ctx: Context;
+  private readonly app: koa.Application;
+  private readonly logList: any = [];
+
+  constructor(ctx: Context) {
+    this.app = ctx.app;
+    this.ctx = ctx;
+    this.logList = [];
+  }
+
+  getLogList() {
+    return this.logList;
+  }
+
+  debug(msg: any, ...args: any[]): void {
+    this.getLogger().debug(msg, ...args);
+    this.appendLogList('debug', msg, ...args);
+  }
+
+  error(msg: any, ...args: any[]): void {
+    this.getLogger().error(msg, ...args);
+    this.appendLogList('error', msg, ...args);
+  }
+
+  info(msg: any, ...args: any[]): void {
+    this.getLogger().info(msg, ...args);
+    this.appendLogList('info', msg, ...args);
+  }
+
+  warn(msg: any, ...args: any[]): void {
+    this.getLogger().warn(msg, ...args);
+    this.appendLogList('warn', msg, ...args);
+  }
+
+  log(msg: any, ...args: any[]): void {
+    this.getLogger().info(msg, ...args);
+    this.appendLogList('info', msg, ...args);
+  }
+
+  private appendLogList(level: string, msg: string, ...args: any[]) {
+    const ctx = this.ctx;
+    if (!isEnableDebug(ctx)) {
+      return;
+    }
+    const time = moment().format('YYYY-MM-DD HH:mm:ss.SSS');
+    const caller = getCallerInfo();
+    this.logList.push({ level, msg, args, caller, time });
+  }
+
+  private getLogger(): ILogger {
+    const logger = this.app.getLogger('logger');
+    if (logger) {
+      return logger;
+    }
+    return consoleLogger;
+  }
+
+  public getPrefixContextLogger(prefix: string): ILoggerContext {
+    return {
+      info: (msg: any, ...args: any[]) => {
+        this.info(prefix, msg, ...args);
+      },
+      debug: (msg: any, ...args: any[]) => {
+        this.debug(prefix, msg, ...args);
+      },
+      error: (msg: any, ...args: any[]) => {
+        this.error(prefix, msg, ...args);
+      },
+      warn: (msg: any, ...args: any[]) => {
+        this.warn(prefix, msg, ...args);
+      },
+      log: (msg: any, ...args: any[]) => {
+        this.log(prefix, msg, ...args);
+      },
+    };
+  }
+}
+
+export { ContextLogger, consoleLogger, ILoggerContext };

package/src/models/devops.ts

@@ -0,0 +1,17 @@
+// 状态；0 未启用， 1 已启用',
+export enum CommonStatusEnum {
+  DISABLED = 0,
+  ENABLED = 1,
+}
+
+/**
+ * 业务异常
+ */
+export class BizException {
+  public message: string;
+  public code: string;
+  constructor(message?: string, code?: string) {
+    this.message = message;
+    this.code = code || 'BizException';
+  }
+}

package/src/models/userSession.ts

@@ -0,0 +1,217 @@
+import * as _ from 'lodash';
+import { KeysOfAuthType } from '@/libs/crud-pro/models/keys';
+import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
+import { CommonException, Exceptions } from '@/libs/crud-pro/exceptions';
+import { parseStringTrimArray } from '@/libs/utils/functions';
+
+const sessionCookieCfg = {
+  signed: true,
+  encrypt: true,
+  httpOnly: true,
+  maxAge: 1000 * 3600 * 24 * 365,
+};
+
+const SESSION_ID_KEY = 'fatcmssessionid';
+const SYS_ACCOUNT_TYPE = 'fatcms';
+
+interface ISessionInfo {
+  nickName: string;
+  avatar: string;
+  roleCodes: string[];
+  functionCodes: string[];
+  loginName: string;
+  sessionId: string;
+  accountId: string;
+  workbenchCode: string;
+  accountType: string;
+  bizExt?: any;
+}
+
+interface IConsumerUserInfo {
+  workbenchCode: string;
+  accountType: string;
+  accountId: string;
+  nickName: string;
+  loginName: string;
+  avatar: string;
+}
+
+interface IBatchCheckProps {
+  permissionCodeList?: string[];
+  roleCodeList?: string[];
+}
+
+interface IBatchCheckRes {
+  permissionCodeResult: Record<string, boolean>;
+  roleCodeResult: Record<string, boolean>;
+}
+
+function createEmptySessionInfo(superAdmin: boolean): ISessionInfo {
+  return {
+    nickName: superAdmin ? 'SA' : '',
+    avatar: '',
+    roleCodes: [],
+    functionCodes: [],
+    loginName: '',
+    sessionId: '',
+    accountId: '',
+    workbenchCode: '',
+    accountType: '',
+  };
+}
+
+class UserSessionInfo {
+  private readonly sessionInfo: ISessionInfo;
+
+  // 是否是超级管理员；拥有一切权限。紧急情况下使用
+  private readonly superAdmin: boolean;
+  constructor(sessionInfo: ISessionInfo, superAdmin?: boolean) {
+    this.superAdmin = superAdmin === true;
+    if (sessionInfo) {
+      this.sessionInfo = sessionInfo;
+    } else {
+      this.sessionInfo = createEmptySessionInfo(superAdmin);
+    }
+  }
+
+  getSessionInfo(): ISessionInfo {
+    return this.sessionInfo;
+  }
+
+  getSessionValue(key: string): any {
+    return _.get(this.sessionInfo, key);
+  }
+
+  isSuperAdmin(): boolean {
+    return this.superAdmin;
+  }
+
+  /**
+   * 是否是我自己的账号
+   * @param accountId
+   */
+  isMySelf(accountId: string): boolean {
+    const s = this.sessionInfo;
+    return s && accountId && s.accountId === accountId;
+  }
+
+  isLogin(): boolean {
+    const s = this.sessionInfo;
+    return !!(s && s.sessionId && s.accountId && s.sessionId.length > 1);
+  }
+
+  hasAnyPermission(funcCodeList: string | string[]): boolean {
+    if (this.isSuperAdmin()) {
+      return true;
+    }
+    if (typeof funcCodeList === 'string') {
+      return this.hasPermission(funcCodeList);
+    }
+
+    if (Array.isArray(funcCodeList)) {
+      for (let i = 0; i < funcCodeList.length; i++) {
+        const funcCode = funcCodeList[i];
+        if (this.hasPermission(funcCode)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+
+  hasPermission(funcCode: string): boolean {
+    if (this.isSuperAdmin()) {
+      return true;
+    }
+    const ss = this.sessionInfo.functionCodes || [];
+    return ss.includes(funcCode);
+  }
+
+  hasAnyRole(roleCodeList: string | string[]): boolean {
+    if (this.isSuperAdmin()) {
+      return true;
+    }
+    if (typeof roleCodeList === 'string') {
+      return this.hasRole(roleCodeList);
+    }
+
+    if (Array.isArray(roleCodeList)) {
+      for (let i = 0; i < roleCodeList.length; i++) {
+        const funcCode = roleCodeList[i];
+        if (this.hasRole(funcCode)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+
+  hasRole(roleCode: string): boolean {
+    if (this.isSuperAdmin()) {
+      return true;
+    }
+    const ss = this.sessionInfo.roleCodes || [];
+    return ss.includes(roleCode);
+  }
+
+  isAuthPass(authType: KeysOfAuthType, authConfig: string | string[]): boolean {
+    if (authType === KeysOfAuthType.free || !authType) {
+      return true; // 无需校验
+    }
+    if (!this.isLogin()) {
+      return false;
+    }
+    if (this.isSuperAdmin()) {
+      return true;
+    }
+
+    if (authType === KeysOfAuthType.byFuncCode) {
+      const funcCodes = parseStringTrimArray(authConfig);
+      if (MixinUtils.isEmpty(funcCodes)) {
+        throw new CommonException(Exceptions.CFG_AUTH_CODE_EMPTY, '缺少权限编码配置');
+      }
+      return this.hasAnyPermission(funcCodes);
+    }
+
+    if (authType === KeysOfAuthType.byRoleCode) {
+      const roleCodes = parseStringTrimArray(authConfig);
+      if (MixinUtils.isEmpty(roleCodes)) {
+        throw new CommonException(Exceptions.CFG_AUTH_CODE_EMPTY, '缺少角色编码配置');
+      }
+      return this.hasAnyRole(roleCodes);
+    }
+
+    return true;
+  }
+
+  /**
+   * 批量检查权限
+   * @param params
+   */
+  batchCheckPermission(params: IBatchCheckProps): IBatchCheckRes {
+    const { permissionCodeList, roleCodeList } = params;
+    const permissionCodeResult: Record<string, boolean> = {};
+    const roleCodeResult: Record<string, boolean> = {};
+
+    if (Array.isArray(permissionCodeList)) {
+      for (let i = 0; i < permissionCodeList.length; i++) {
+        const permissionCode = permissionCodeList[i];
+        if (permissionCode && typeof permissionCode === 'string') {
+          permissionCodeResult[permissionCode] = this.hasPermission(permissionCode);
+        }
+      }
+    }
+
+    if (Array.isArray(roleCodeList)) {
+      for (let i = 0; i < roleCodeList.length; i++) {
+        const roleCode = roleCodeList[i];
+        if (roleCode && typeof roleCode === 'string') {
+          roleCodeResult[roleCode] = this.hasRole(roleCode);
+        }
+      }
+    }
+    return { permissionCodeResult, roleCodeResult };
+  }
+}
+
+export { ISessionInfo, UserSessionInfo, SESSION_ID_KEY, SYS_ACCOUNT_TYPE, IConsumerUserInfo, sessionCookieCfg };

package/src/schedule/anonymousContext.ts

@@ -0,0 +1,73 @@
+import * as koa from '@midwayjs/koa';
+import { ContextLogger } from '@/models/contextLogger';
+import { Transaction } from '@/libs/crud-pro/models/Transaction';
+import { ISessionInfo, SYS_ACCOUNT_TYPE, UserSessionInfo } from '@/models/userSession';
+import { IWorkbenchEntity } from '@/models/SystemEntities';
+
+const anonymousUserInfo: ISessionInfo = {
+  nickName: 'anonymous_user',
+  avatar: '',
+  roleCodes: [],
+  functionCodes: [],
+  loginName: 'anonymous_user',
+  sessionId: '',
+  accountId: '',
+  workbenchCode: '',
+  accountType: SYS_ACCOUNT_TYPE,
+};
+
+const anonymousWorkbenchInfo: IWorkbenchEntity = {
+  id: 0,
+  workbench_code: 'anonymous_workbench',
+  workbench_name: 'anonymous_workbench',
+  workbench_domain: 'anonymous_workbench',
+  workbench_desc: 'anonymous_workbench',
+  html_content: 'anonymous_workbench',
+  status: 1,
+  workbench_type: 0,
+};
+
+export type RunServiceAtAnonymousContextRunner = (ctx: koa.IMidwayKoaContext) => any;
+export interface RunServiceAtAnonymousContextRes {
+  result: any;
+  error: any;
+}
+
+class AnonymousContext {
+  private app: koa.Application;
+
+  setApp(app: koa.Application) {
+    this.app = app;
+  }
+
+  getApp() {
+    return this.app;
+  }
+
+  async runServiceAtAnonymousContext(runner: RunServiceAtAnonymousContextRunner): Promise<RunServiceAtAnonymousContextRes> {
+    const app = this.app;
+    const ctx: koa.IMidwayKoaContext = app.createAnonymousContext();
+
+    ctx.app = app;
+    ctx.contextLogger = new ContextLogger(ctx as any);
+    ctx.transaction = new Transaction();
+    ctx.userSession = new UserSessionInfo(anonymousUserInfo, true);
+    ctx.workbenchInfo = anonymousWorkbenchInfo;
+
+    let result: any = null;
+    let error: any = null;
+    try {
+      result = await runner(ctx);
+    } catch (e) {
+      error = e;
+      ctx.logger.error('runServiceAtAnonymousContext error ', e);
+    } finally {
+      await ctx.transaction.releaseTx();
+    }
+    return { result: result, error: error };
+  }
+}
+
+const ANONYMOUS_CONTEXT = new AnonymousContext();
+
+export { ANONYMOUS_CONTEXT };

package/src/schedule/index.ts

@@ -0,0 +1,12 @@
+import {SCHEDULE_QUEUE, runScheduleTaskOnce} from './runSchedule'
+import {ANONYMOUS_CONTEXT} from './anonymousContext'
+import {
+  INNER_SCHEDULE_INTERVAL
+} from './scheduleNames'
+
+export {
+  INNER_SCHEDULE_INTERVAL,
+  ANONYMOUS_CONTEXT,
+  SCHEDULE_QUEUE,
+  runScheduleTaskOnce
+}

package/src/schedule/runSchedule.ts

@@ -0,0 +1,82 @@
+import * as koa from '@midwayjs/koa';
+import {IScheduleService} from '@/interface';
+import {ANONYMOUS_CONTEXT} from "./anonymousContext";
+
+
+// 上次执行时间
+const lastExecuteTimeMap = {};
+
+const DEFAULT_SCHEDULE_INTERVAL = 2 * 60 * 1000;
+
+
+async function runScheduleTaskOnce(serviceName: string) {
+  return await ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx: koa.IMidwayKoaContext) => {
+    const serviceObject: IScheduleService = await ctx.requestContext.getAsync(serviceName);
+    if (serviceObject && serviceObject.runBySchedule) {
+      await serviceObject.runBySchedule();
+    } else {
+      ctx.logger.error(`runSchedule error , serviceName = ${serviceName}, 没有找到服务`);
+    }
+  });
+}
+
+
+class ScheduleQueue {
+  private scheduleIntervalMap: Map<string, number> = new Map();
+
+  public setScheduleTask(serviceName: string, intervalTime: number) {
+    this.scheduleIntervalMap.set(serviceName, intervalTime);
+  }
+
+  public removeScheduleTask(serviceName: string) {
+    this.scheduleIntervalMap.delete(serviceName);
+  }
+
+  private isAlreadyTimeToExecute(serviceName: string): boolean {
+    if (!lastExecuteTimeMap[serviceName]) {
+      return true; // 可以执行
+    }
+    const intervalTime1 = this.scheduleIntervalMap.get(serviceName);
+    const intervalTime = intervalTime1 || DEFAULT_SCHEDULE_INTERVAL; // 时间间隔
+    const lastExecuteTime = lastExecuteTimeMap[serviceName];
+    return (Date.now() - lastExecuteTime) >= intervalTime;
+  }
+
+
+  private async runScheduleTaskOnceCheckTime(serviceName: string) {
+    // 还没有到可以执行时间
+    if (!this.isAlreadyTimeToExecute(serviceName)) {
+      return;
+    }
+    lastExecuteTimeMap[serviceName] = Date.now();
+    await runScheduleTaskOnce(serviceName);
+  }
+
+  private async runScheduleServiceList() {
+    const serviceListKeys = this.scheduleIntervalMap.keys();
+    const serviceList = [...serviceListKeys];
+    for (let i = 0; i < serviceList.length; i++) {
+      const serviceName = serviceList[i];
+      try {
+        await this.runScheduleTaskOnceCheckTime(serviceName);
+      } catch (e) {
+        ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+      }
+    }
+  }
+
+
+  public async startScheduleLoop() {
+    await this.runScheduleServiceList();
+    setInterval(() => {
+      this.runScheduleServiceList();
+    }, 1000); // 最少1秒执行一次
+  }
+
+
+}
+
+
+const SCHEDULE_QUEUE = new ScheduleQueue();
+
+export {SCHEDULE_QUEUE, runScheduleTaskOnce};

package/src/schedule/scheduleNames.ts

@@ -0,0 +1,21 @@
+
+const INNER_SCHEDULE_INTERVAL = {
+  proxyApiLoadService: 2 * 60 * 1000, // 2分钟重新加载一次,
+  workbenchService: 60 * 1000, // 1分钟重新加载一次,
+  visitStatService: 10 * 60 * 1000, // 10分钟重新加载一次,
+  asyncTaskRunnerService: 1000, // 1s可以执行
+}
+
+const INNER_SCHEDULE_NAMES = {
+  proxyApiLoadService: 'proxyApiLoadService',
+  workbenchService: 'workbenchService',
+  visitStatService: "visitStatService",
+  asyncTaskRunnerService: "asyncTaskRunnerService",
+}
+
+
+
+export {
+  INNER_SCHEDULE_INTERVAL,
+  INNER_SCHEDULE_NAMES
+}