midway-fatcms 0.0.1-beta.73 → 0.0.1-beta.75

package/dist/config/config.default.js

@@ -162,7 +162,13 @@ exports.default = (appInfo) => {
         // 用户会话保持时间，单位秒
         fatcmsUserSessionKeepTimeSecond: 3600 * 24 * 30,
         // 是否启用内置的定时任务
-        fatcmsScheduleService: true,
+        fatcmsScheduleService: {
+            proxyApiLoadService: 2 * 60 * 1000,
+            workbenchService: 60 * 1000,
+            visitStatService: 10 * 60 * 1000,
+            asyncTaskRunnerService: 1000,
+            cacheServiceFactory: 2 * 60 * 1000, // 2分钟重新加载一次,
+        },
         // Excel导出文件的临时目录
         fatcmsExportExcelTmpFilePath: (0, path_1.join)((0, os_1.tmpdir)(), 'fatcms-export-excel'),
         // 在某些场景下，只有一个workbench code。如果启用了此配置，则不再根据域名配置识别Workbench.

package/dist/index.d.ts

@@ -73,6 +73,7 @@ export * from './service/proxyapi/ProxyApiLoadService';
 export * from './service/proxyapi/ProxyApiService';
 export * from './service/asyncTask/AsyncTaskService';
 export * from './service/asyncTask/AsyncTaskRunnerService';
+export * from './schedule/anonymousContext';
 export * from './models/userSession';
 export * from './models/bizmodels';
 export * from './models/SystemEntities';

package/dist/index.js

@@ -91,6 +91,7 @@ __exportStar(require("./service/proxyapi/ProxyApiLoadService"), exports);
 __exportStar(require("./service/proxyapi/ProxyApiService"), exports);
 __exportStar(require("./service/asyncTask/AsyncTaskService"), exports);
 __exportStar(require("./service/asyncTask/AsyncTaskRunnerService"), exports);
+__exportStar(require("./schedule/anonymousContext"), exports);
 __exportStar(require("./models/userSession"), exports);
 __exportStar(require("./models/bizmodels"), exports);
 __exportStar(require("./models/SystemEntities"), exports);

package/dist/schedule/anonymousContext.d.ts

@@ -8,6 +8,7 @@ declare class AnonymousContext {
     private app;
     setApp(app: koa.Application): void;
     getApp(): koa.IMidwayKoaApplication;
+    private createAnonymousContext;
     runServiceAtAnonymousContext(runner: RunServiceAtAnonymousContextRunner): Promise<RunServiceAtAnonymousContextRes>;
 }
 declare const ANONYMOUS_CONTEXT: AnonymousContext;

package/dist/schedule/anonymousContext.js

@@ -4,6 +4,7 @@ exports.ANONYMOUS_CONTEXT = void 0;
 const contextLogger_1 = require("../models/contextLogger");
 const Transaction_1 = require("../libs/crud-pro/models/Transaction");
 const userSession_1 = require("../models/userSession");
+const WorkbenchInfoTools_1 = require("../models/WorkbenchInfoTools");
 const anonymousUserInfo = {
     nickName: 'anonymous_user',
     avatar: '',
@@ -35,7 +36,12 @@ class AnonymousContext {
     getApp() {
         return this.app;
     }
-    async runServiceAtAnonymousContext(runner) {
+    //
+    // async getAsyncService(identifier: any): Promise<any> {
+    //   const ctx: koa.IMidwayKoaContext = this.createAnonymousContext();
+    //   return ctx.requestContext.getAsync(identifier);
+    // }
+    createAnonymousContext() {
         const app = this.app;
         const ctx = app.createAnonymousContext();
         ctx.app = app;
@@ -43,6 +49,11 @@ class AnonymousContext {
         ctx.transaction = new Transaction_1.Transaction();
         ctx.userSession = new userSession_1.UserSessionInfo(anonymousUserInfo, true);
         ctx.workbenchInfo = anonymousWorkbenchInfo;
+        ctx.workbenchInfoTools = new WorkbenchInfoTools_1.WorkbenchInfoTools(ctx.workbenchInfo);
+        return ctx;
+    }
+    async runServiceAtAnonymousContext(runner) {
+        const ctx = this.createAnonymousContext();
         let result = null;
         let error = null;
         try {

package/dist/schedule/scheduleNames.d.ts

@@ -3,11 +3,13 @@ declare const INNER_SCHEDULE_INTERVAL: {
     workbenchService: number;
     visitStatService: number;
     asyncTaskRunnerService: number;
+    cacheServiceFactory: number;
 };
 declare const INNER_SCHEDULE_NAMES: {
     proxyApiLoadService: string;
     workbenchService: string;
     visitStatService: string;
     asyncTaskRunnerService: string;
+    cacheServiceFactory: string;
 };
 export { INNER_SCHEDULE_INTERVAL, INNER_SCHEDULE_NAMES };

package/dist/schedule/scheduleNames.js

@@ -5,7 +5,8 @@ const INNER_SCHEDULE_INTERVAL = {
     proxyApiLoadService: 2 * 60 * 1000,
     workbenchService: 60 * 1000,
     visitStatService: 10 * 60 * 1000,
-    asyncTaskRunnerService: 1000, // 1s可以执行
+    asyncTaskRunnerService: 1000,
+    cacheServiceFactory: 2 * 60 * 1000, // 2分钟重新加载一次,
 };
 exports.INNER_SCHEDULE_INTERVAL = INNER_SCHEDULE_INTERVAL;
 const INNER_SCHEDULE_NAMES = {
@@ -13,5 +14,6 @@ const INNER_SCHEDULE_NAMES = {
     workbenchService: 'workbenchService',
     visitStatService: 'visitStatService',
     asyncTaskRunnerService: 'asyncTaskRunnerService',
+    cacheServiceFactory: 'cacheServiceFactory',
 };
 exports.INNER_SCHEDULE_NAMES = INNER_SCHEDULE_NAMES;

package/dist/service/base/cache/CacheServiceFactory.d.ts

@@ -1,20 +1,23 @@
 import { Context } from '@midwayjs/koa';
 import { CacheNameEnum, ICacheService } from '../../../models/bizmodels';
 import { RedisService } from '@midwayjs/redis';
+import { IScheduleService } from "../../../interface";
 interface IGetJsonObjectCacheParam {
     cacheName: CacheNameEnum;
     cacheKey: string;
     refreshCache?: boolean;
+    scheduleRefresh?: boolean;
     getter: () => Promise<any>;
 }
 interface IRemoveItemCacheParam {
     cacheName: CacheNameEnum;
     cacheKey: string;
 }
-export declare class CacheServiceFactory {
+export declare class CacheServiceFactory implements IScheduleService {
     protected ctx: Context;
     private fatcmsCache;
     protected redisService: RedisService;
+    runBySchedule(): Promise<void>;
     private getCacheService;
     getCacheServiceByName(cacheName: CacheNameEnum): ICacheService;
     getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any>;

package/dist/service/base/cache/CacheServiceFactory.js

@@ -22,7 +22,40 @@ const defaultCacheConfig = {
     cacheLevel: SystemEntities_1.CacheLevelEnum.MEMORY,
     cacheSecond: 60 * 60 * 24 * 7
 };
+const isScheduleBusyTag = { busy: false };
+const SCHEDULE_REFRESH_TASK_MAP = new Map;
 let CacheServiceFactory = class CacheServiceFactory {
+    async runBySchedule() {
+        if (isScheduleBusyTag.busy) {
+            return;
+        }
+        isScheduleBusyTag.busy = true;
+        try {
+            const keys = SCHEDULE_REFRESH_TASK_MAP.keys();
+            for (const key of keys) {
+                const param = SCHEDULE_REFRESH_TASK_MAP.get(key);
+                try {
+                    if (param) {
+                        const { cacheName, cacheKey, getter } = param;
+                        const cacheService = this.getCacheServiceByName(cacheName);
+                        if (cacheService) {
+                            const obj = await getter();
+                            await cacheService.setJsonObject(cacheKey, obj);
+                        }
+                    }
+                }
+                catch (error) {
+                    this.ctx.logger.error(`[CacheServiceFactory]runBySchedule#${param.cacheName}`, error);
+                }
+            }
+        }
+        catch (e) {
+            this.ctx.logger.error(`[CacheServiceFactory]runBySchedule`, e);
+        }
+        finally {
+            isScheduleBusyTag.busy = false;
+        }
+    }
     getCacheService(cacheLevelEnum, cacheName, cacheSecond) {
         switch (cacheLevelEnum) {
             case SystemEntities_1.CacheLevelEnum.CONTEXT:
@@ -50,7 +83,13 @@ let CacheServiceFactory = class CacheServiceFactory {
         return this.getCacheService(cacheLevel, cacheName, cacheSecond);
     }
     async getJsonObjectCache(param) {
-        const { cacheName, cacheKey, refreshCache, getter } = param;
+        const { cacheName, cacheKey, refreshCache, scheduleRefresh, getter } = param;
+        if (scheduleRefresh === true) {
+            const scheduleKey = `${cacheName}_${cacheKey}`;
+            if (!SCHEDULE_REFRESH_TASK_MAP.has(scheduleKey)) {
+                SCHEDULE_REFRESH_TASK_MAP.set(scheduleKey, param);
+            }
+        }
         const cacheService = this.getCacheServiceByName(cacheName);
         let obj = await cacheService.getJsonObject(cacheKey);
         if (!obj || refreshCache === true) {

package/dist/service/curd/CurdMixByLinkToCustomService.js

@@ -8,6 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var CurdMixByLinkToCustomService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CurdMixByLinkToCustomService = void 0;
 const core_1 = require("@midwayjs/core");
@@ -22,6 +23,7 @@ const global_config_1 = require("../../libs/global-config/global-config");
 const bizmodels_1 = require("../../models/bizmodels");
 const CacheServiceFactory_1 = require("../base/cache/CacheServiceFactory");
 const md5 = require("md5");
+const schedule_1 = require("../../schedule");
 const linkToCustomMixUtils = new CurdMixUtils_1.CrudMixUtils(CurdMixUtils_1.RelatedType.linkToCustom);
 const TMP_CTX_KEY = _.uniqueId('CurdMixByLinkToCustomService');
 function toMapObject(rows, fieldsArr) {
@@ -47,7 +49,7 @@ function toMapObject(rows, fieldsArr) {
     }
     return map;
 }
-let CurdMixByLinkToCustomService = class CurdMixByLinkToCustomService {
+let CurdMixByLinkToCustomService = CurdMixByLinkToCustomService_1 = class CurdMixByLinkToCustomService {
     async handleExecuteContextPrepare(executeContext) {
         const relations = linkToCustomMixUtils.pickColumnRelations(executeContext);
         if (!relations || relations.length === 0) {
@@ -83,8 +85,13 @@ let CurdMixByLinkToCustomService = class CurdMixByLinkToCustomService {
         return this.cacheServiceFactory.getJsonObjectCache({
             cacheKey: md5(code),
             cacheName: bizmodels_1.CacheNameEnum.CurdMixByLinkToCustom,
+            scheduleRefresh: true,
             getter: async () => {
-                return await this.queryInfoByLinkToCustomImpl(code);
+                const { result } = await schedule_1.ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx) => {
+                    const service = await ctx.requestContext.getAsync(CurdMixByLinkToCustomService_1);
+                    return await service.queryInfoByLinkToCustomImpl(code);
+                });
+                return result;
             },
         });
     }
@@ -196,7 +203,7 @@ __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", CacheServiceFactory_1.CacheServiceFactory)
 ], CurdMixByLinkToCustomService.prototype, "cacheServiceFactory", void 0);
-CurdMixByLinkToCustomService = __decorate([
+CurdMixByLinkToCustomService = CurdMixByLinkToCustomService_1 = __decorate([
     (0, core_1.Provide)()
 ], CurdMixByLinkToCustomService);
 exports.CurdMixByLinkToCustomService = CurdMixByLinkToCustomService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midway-fatcms",
-  "version": "0.0.1-beta.73",
+  "version": "0.0.1-beta.75",
   "description": "This is a midway component sample",
   "main": "dist/index.js",
   "typings": "index.d.ts",

package/src/config/config.default.ts

@@ -180,7 +180,13 @@ export default (appInfo: any) => {
     fatcmsUserSessionKeepTimeSecond: 3600 * 24 * 30,
 
     // 是否启用内置的定时任务
-    fatcmsScheduleService: true,
+    fatcmsScheduleService: {
+      proxyApiLoadService: 2 * 60 * 1000, // 2分钟重新加载一次,
+      workbenchService: 60 * 1000, // 1分钟重新加载一次,
+      visitStatService: 10 * 60 * 1000, // 10分钟重新加载一次,
+      asyncTaskRunnerService: 1000, // 1s可以执行
+      cacheServiceFactory: 2 * 60 * 1000, // 2分钟重新加载一次,
+    },
 
     // Excel导出文件的临时目录
     fatcmsExportExcelTmpFilePath: join(tmpdir(), 'fatcms-export-excel'),

package/src/index.ts

@@ -73,6 +73,7 @@ export * from './service/proxyapi/ProxyApiLoadService';
 export * from './service/proxyapi/ProxyApiService';
 export * from './service/asyncTask/AsyncTaskService';
 export * from './service/asyncTask/AsyncTaskRunnerService';
+export * from './schedule/anonymousContext'
 export * from './models/userSession';
 export * from './models/bizmodels';
 export * from './models/SystemEntities';

package/src/schedule/anonymousContext.ts

@@ -3,6 +3,7 @@ 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';
+import { WorkbenchInfoTools } from "@/models/WorkbenchInfoTools";
 
 const anonymousUserInfo: ISessionInfo = {
   nickName: 'anonymous_user',
@@ -36,6 +37,7 @@ export interface RunServiceAtAnonymousContextRes {
   error: any;
 }
 
+
 class AnonymousContext {
   private app: koa.Application;
 
@@ -47,16 +49,27 @@ class AnonymousContext {
     return this.app;
   }
 
-  async runServiceAtAnonymousContext(runner: RunServiceAtAnonymousContextRunner): Promise<RunServiceAtAnonymousContextRes> {
+  //
+  // async getAsyncService(identifier: any): Promise<any> {
+  //   const ctx: koa.IMidwayKoaContext = this.createAnonymousContext();
+  //   return ctx.requestContext.getAsync(identifier);
+  // }
+
+  private createAnonymousContext() {
     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;
+    ctx.workbenchInfoTools = new WorkbenchInfoTools(ctx.workbenchInfo);
+    return ctx;
+  }
+
 
+  async runServiceAtAnonymousContext(runner: RunServiceAtAnonymousContextRunner): Promise<RunServiceAtAnonymousContextRes> {
+    const ctx: koa.IMidwayKoaContext = this.createAnonymousContext();
     let result: any = null;
     let error: any = null;
     try {

package/src/schedule/scheduleNames.ts

@@ -3,6 +3,7 @@ const INNER_SCHEDULE_INTERVAL = {
   workbenchService: 60 * 1000, // 1分钟重新加载一次,
   visitStatService: 10 * 60 * 1000, // 10分钟重新加载一次,
   asyncTaskRunnerService: 1000, // 1s可以执行
+  cacheServiceFactory: 2 * 60 * 1000, // 2分钟重新加载一次,
 };
 
 const INNER_SCHEDULE_NAMES = {
@@ -10,6 +11,7 @@ const INNER_SCHEDULE_NAMES = {
   workbenchService: 'workbenchService',
   visitStatService: 'visitStatService',
   asyncTaskRunnerService: 'asyncTaskRunnerService',
+  cacheServiceFactory: 'cacheServiceFactory',
 };
 
 export { INNER_SCHEDULE_INTERVAL, INNER_SCHEDULE_NAMES };

package/src/service/base/cache/CacheServiceFactory.ts

@@ -8,11 +8,13 @@ import { RedisCache } from './RedisCache';
 import { DiskCache } from './DiskCache';
 import { MemoryCache } from './MemoryCache';
 import { NoneCache } from './NoneCache';
+import {IScheduleService} from "@/interface";
 
 interface IGetJsonObjectCacheParam {
     cacheName: CacheNameEnum;
     cacheKey: string;
     refreshCache?: boolean;
+    scheduleRefresh?: boolean;
     getter: () => Promise<any>;
 }
 
@@ -26,8 +28,13 @@ const defaultCacheConfig: IWorkbenchConfigCacheLevel = {
   cacheSecond: 60 * 60 * 24 * 7
 }
 
+const isScheduleBusyTag = { busy : false };
+
+const SCHEDULE_REFRESH_TASK_MAP = new Map<string, IGetJsonObjectCacheParam>;
+
+
 @Provide()
-export class CacheServiceFactory {
+export class CacheServiceFactory implements IScheduleService {
   @Inject()
   protected ctx: Context;
 
@@ -37,6 +44,38 @@ export class CacheServiceFactory {
   @Inject()
   protected redisService: RedisService;
 
+  public async runBySchedule() {
+
+    if (isScheduleBusyTag.busy) {
+      return;
+    }
+    isScheduleBusyTag.busy = true;
+
+    try {
+      const keys = SCHEDULE_REFRESH_TASK_MAP.keys();
+      for (const key of keys) {
+        const param = SCHEDULE_REFRESH_TASK_MAP.get(key);
+        try {
+          if (param) {
+            const {cacheName, cacheKey, getter} = param;
+            const cacheService = this.getCacheServiceByName(cacheName);
+            if (cacheService) {
+              const obj = await getter();
+              await cacheService.setJsonObject(cacheKey, obj);
+            }
+          }
+        } catch (error) {
+          this.ctx.logger.error(`[CacheServiceFactory]runBySchedule#${param.cacheName}`, error);
+        }
+      }
+    } catch (e) {
+      this.ctx.logger.error(`[CacheServiceFactory]runBySchedule`, e);
+    } finally {
+      isScheduleBusyTag.busy = false;
+    }
+
+  }
+
   private getCacheService(cacheLevelEnum: CacheLevelEnum, cacheName: CacheNameEnum, cacheSecond: number): ICacheService {
     switch (cacheLevelEnum) {
       case CacheLevelEnum.CONTEXT:
@@ -66,8 +105,18 @@ export class CacheServiceFactory {
   }
 
 
+
   public async getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any> {
-    const {cacheName, cacheKey, refreshCache, getter} = param;
+    const {cacheName, cacheKey, refreshCache, scheduleRefresh, getter} = param;
+
+    if (scheduleRefresh === true) {
+      const scheduleKey = `${cacheName}_${cacheKey}`;
+      if (!SCHEDULE_REFRESH_TASK_MAP.has(scheduleKey)) {
+        SCHEDULE_REFRESH_TASK_MAP.set(scheduleKey, param);
+      }
+    }
+
+
     const cacheService = this.getCacheServiceByName(cacheName);
     let obj = await cacheService.getJsonObject(cacheKey);
     if (!obj || refreshCache === true) {

package/src/service/curd/CurdMixByLinkToCustomService.ts

@@ -14,6 +14,7 @@ import { IRequestCfgModel2 } from '@/models/bizmodels';
 import { CacheNameEnum} from "@/models/bizmodels";
 import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
 import * as md5 from 'md5';
+import {ANONYMOUS_CONTEXT} from "@/schedule";
 
 const linkToCustomMixUtils = new CrudMixUtils(RelatedType.linkToCustom);
 const TMP_CTX_KEY = _.uniqueId('CurdMixByLinkToCustomService');
@@ -93,12 +94,18 @@ export class CurdMixByLinkToCustomService implements IExecuteContextHandler {
     });
   }
 
+
   public async queryInfoByLinkToCustom(code: string): Promise<Map<string, any>> {
     return this.cacheServiceFactory.getJsonObjectCache({
       cacheKey: md5(code),
       cacheName: CacheNameEnum.CurdMixByLinkToCustom,
+      scheduleRefresh: true,
       getter: async () => {
-        return await this.queryInfoByLinkToCustomImpl(code);
+        const { result } = await ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx: Context) => {
+          const service: CurdMixByLinkToCustomService = await ctx.requestContext.getAsync(CurdMixByLinkToCustomService);
+          return await service.queryInfoByLinkToCustomImpl(code);
+        });
+        return result;
       },
     });
   }