midway-fatcms 0.0.3 → 0.0.4

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

@@ -1,68 +1,68 @@
-import { Context } from '@midwayjs/koa';
-import { LRUCache } from 'lru-cache';
-import { ICacheService } from '@/models/bizmodels';
-
-
-
-const LRU_CACHE_MAP = new Map<string, LRUCache<string, any>>();
-
-
-export class MemoryCache implements ICacheService {
-    protected ctx: Context;
-    protected cacheName: string;
-    protected cacheSecond: number;
-
-    constructor(ctx: Context, cacheName: string, cacheSecond:number) {
-        this.ctx = ctx;
-        this.cacheName = cacheName;
-        this.cacheSecond = cacheSecond;
-    }
-
-    private getLruCache(): LRUCache<string, any> {
-        if (!LRU_CACHE_MAP.has(this.cacheName)) {
-            const lruCache = new LRUCache<string, any>({
-                max: 2000,
-                ttl: 1000 * 60 * 60 * 24,
-                ttlAutopurge: true,
-            });
-            LRU_CACHE_MAP.set(this.cacheName, lruCache);
-        }
-        return LRU_CACHE_MAP.get(this.cacheName);
-    }
-
-    async getJsonObject(key: string): Promise<any> {
-        try {
-            const lruCache = this.getLruCache();
-            const saveObj = lruCache.get(key);
-            if (saveObj && saveObj.key === key && saveObj.expireAt > Date.now()) {
-                return saveObj.data;
-            }
-            return null;
-        } catch (error) {
-            return null;
-        }
-    }
-
-
-    async setJsonObject(key: string, obj: any, cacheSecond0: number): Promise<any> {
-        const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
-        const lruCache = this.getLruCache();
-        const saveObj = {
-            data: obj,
-            key,
-            expireAt: Date.now() + cacheSecond * 1000,
-        };
-        lruCache.set(key, saveObj);
-        return true;
-    }
-
-    async removeItem(key: string): Promise<any> {
-        try {
-            const lruCache = this.getLruCache();
-            lruCache.delete(key);
-            return true;
-        } catch (error) {
-            return false;
-        }
-    }
-}
+import { Context } from '@midwayjs/koa';
+import { LRUCache } from 'lru-cache';
+import { ICacheService } from '@/models/bizmodels';
+
+
+
+const LRU_CACHE_MAP = new Map<string, LRUCache<string, any>>();
+
+
+export class MemoryCache implements ICacheService {
+    protected ctx: Context;
+    protected cacheName: string;
+    protected cacheSecond: number;
+
+    constructor(ctx: Context, cacheName: string, cacheSecond:number) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+        this.cacheSecond = cacheSecond;
+    }
+
+    private getLruCache(): LRUCache<string, any> {
+        if (!LRU_CACHE_MAP.has(this.cacheName)) {
+            const lruCache = new LRUCache<string, any>({
+                max: 2000,
+                ttl: 1000 * 60 * 60 * 24,
+                ttlAutopurge: true,
+            });
+            LRU_CACHE_MAP.set(this.cacheName, lruCache);
+        }
+        return LRU_CACHE_MAP.get(this.cacheName);
+    }
+
+    async getJsonObject(key: string): Promise<any> {
+        try {
+            const lruCache = this.getLruCache();
+            const saveObj = lruCache.get(key);
+            if (saveObj && saveObj.key === key && saveObj.expireAt > Date.now()) {
+                return saveObj.data;
+            }
+            return null;
+        } catch (error) {
+            return null;
+        }
+    }
+
+
+    async setJsonObject(key: string, obj: any, cacheSecond0: number): Promise<any> {
+        const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
+        const lruCache = this.getLruCache();
+        const saveObj = {
+            data: obj,
+            key,
+            expireAt: Date.now() + cacheSecond * 1000,
+        };
+        lruCache.set(key, saveObj);
+        return true;
+    }
+
+    async removeItem(key: string): Promise<any> {
+        try {
+            const lruCache = this.getLruCache();
+            lruCache.delete(key);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

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

@@ -1,24 +1,24 @@
-import { ICacheService } from '@/models/bizmodels';
-import { Context } from '@midwayjs/koa';
-
-export class NoneCache implements ICacheService {
-    protected ctx: Context;
-    protected cacheName: string;
-
-    constructor(ctx: Context, cacheName: string) {
-        this.ctx = ctx;
-        this.cacheName = cacheName;
-    }
-
-    async getJsonObject(key: string): Promise<any> {
-       return null;
-    }
-
-    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
-        return true;
-    }
-
-    async removeItem(key: string): Promise<any> {
-       return true;
-    }
-}
+import { ICacheService } from '@/models/bizmodels';
+import { Context } from '@midwayjs/koa';
+
+export class NoneCache implements ICacheService {
+    protected ctx: Context;
+    protected cacheName: string;
+
+    constructor(ctx: Context, cacheName: string) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+    }
+
+    async getJsonObject(key: string): Promise<any> {
+       return null;
+    }
+
+    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+        return true;
+    }
+
+    async removeItem(key: string): Promise<any> {
+       return true;
+    }
+}

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

@@ -1,41 +1,41 @@
-import { Context } from '@midwayjs/koa';
-import { RedisService } from '@midwayjs/redis';
-import { parseJsonObject } from '@/libs/utils/functions';
-import { ICacheService } from '@/models/bizmodels';
-
-export class RedisCache implements ICacheService {
-  protected ctx: Context;
-  protected cacheName: string;
-  protected redisService: RedisService;
-  protected cacheSecond: number;
-
-  constructor(ctx: Context, cacheName: string, redisService: RedisService, cacheSecond: number) {
-    this.ctx = ctx;
-    this.cacheName = cacheName;
-    this.redisService = redisService;
-    this.cacheSecond = cacheSecond;
-  }
-
-  private getCacheKey(key: string): string {
-    return `${this.cacheName}${key}`;
-  }
-
-  async getJsonObject(key: string): Promise<any> {
-    const cacheKey = this.getCacheKey(key);
-    const str = await this.redisService.get(cacheKey);
-    return parseJsonObject(str);
-  }
-
-
-  async setJsonObject(key: string, obj: any, cacheSecond0?: number): Promise<any> {
-    const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
-    const cacheKey = this.getCacheKey(key);
-    const str = JSON.stringify(obj);
-    return this.redisService.set(cacheKey, str, 'EX', cacheSecond);
-  }
-
-  async removeItem(key: string): Promise<any> {
-    const cacheKey = this.getCacheKey(key);
-    return this.redisService.del(cacheKey);
-  }
-}
+import { Context } from '@midwayjs/koa';
+import { RedisService } from '@midwayjs/redis';
+import { parseJsonObject } from '@/libs/utils/functions';
+import { ICacheService } from '@/models/bizmodels';
+
+export class RedisCache implements ICacheService {
+  protected ctx: Context;
+  protected cacheName: string;
+  protected redisService: RedisService;
+  protected cacheSecond: number;
+
+  constructor(ctx: Context, cacheName: string, redisService: RedisService, cacheSecond: number) {
+    this.ctx = ctx;
+    this.cacheName = cacheName;
+    this.redisService = redisService;
+    this.cacheSecond = cacheSecond;
+  }
+
+  private getCacheKey(key: string): string {
+    return `${this.cacheName}${key}`;
+  }
+
+  async getJsonObject(key: string): Promise<any> {
+    const cacheKey = this.getCacheKey(key);
+    const str = await this.redisService.get(cacheKey);
+    return parseJsonObject(str);
+  }
+
+
+  async setJsonObject(key: string, obj: any, cacheSecond0?: number): Promise<any> {
+    const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
+    const cacheKey = this.getCacheKey(key);
+    const str = JSON.stringify(obj);
+    return this.redisService.set(cacheKey, str, 'EX', cacheSecond);
+  }
+
+  async removeItem(key: string): Promise<any> {
+    const cacheKey = this.getCacheKey(key);
+    return this.redisService.del(cacheKey);
+  }
+}

package/src/service/curd/CurdMixByAccountService.ts

@@ -1,177 +1,177 @@
-import { Inject, Provide } from '@midwayjs/core';
-import { Context } from '@midwayjs/koa';
-import * as _ from 'lodash';
-import { CurdProService } from './CurdProService';
-import { HandleExecuteContextType, IExecuteContextHandler } from '@/libs/crud-pro/models/ExecuteContext';
-import { CrudMixUtils, RelatedType, toFatcmsUserAccountIdList } from './CurdMixUtils';
-import { SystemTables } from '@/models/SystemTables';
-import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
-import { ColumnRelation, IRequestCfgModel, IRequestModel } from '@/libs/crud-pro/interfaces';
-import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { CacheNameEnum } from "@/models/bizmodels";
-import { CacheServiceFactory } from "@/service/base/cache/CacheServiceFactory";
-import { isOnlyAscii } from "@/libs/utils/functions";
-
-const dictMixUtils = new CrudMixUtils(RelatedType.accountBasic);
-
-const TMP_CTX_KEY = _.uniqueId('CurdMixByAccountService');
-const TMP_CTX_KEY2 = _.uniqueId('CurdMixByAccountService2');
-
-
-@Provide()
-export class CurdMixByAccountService implements IExecuteContextHandler {
-
-  @Inject()
-  protected ctx: Context;
-
-  @Inject()
-  protected curdProService: CurdProService;
-
-  @Inject()
-  private cacheServiceFactory: CacheServiceFactory;
-
-
-  async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {
-
-    const relations = dictMixUtils.pickColumnRelations(executeContext);
-    if (!relations || relations.length === 0) {
-      return;
-    }
-
-    const isArrayModeMap = new Map<string, boolean>();
-
-    const accountIds = new Set<string>();
-    dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
-      const { sourceColumn } = columnRelation;
-      if (sourceColumn) {
-        const accountId = _.get(row, sourceColumn);
-        if (accountId) {
-          const { isArray, fatcmsUserAccountIdList, fatcmsUserAccountId } = toFatcmsUserAccountIdList(accountId);
-          if (isArray) {
-            isArrayModeMap.set(sourceColumn, true);
-            fatcmsUserAccountIdList.forEach(item => accountIds.add(item));
-          } else if (fatcmsUserAccountId) {
-            accountIds.add(fatcmsUserAccountId);
-          }
-        }
-      }
-    });
-
-    if (accountIds.size === 0) {
-      return;
-    }
-
-    const userInfos = await this.queryUserAccountIdList([...accountIds]);
-    executeContext[TMP_CTX_KEY] = MixinUtils.toNewMap(userInfos, (obj: any) => obj.account_id);
-    executeContext[TMP_CTX_KEY2] = isArrayModeMap;
-  }
-
-
-  private async getFromCache(accountId: string): Promise<any> {
-    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
-    return cacheService.getJsonObject(accountId);
-  }
-
-  private async setToCache(accountId: string, value: any): Promise<any> {
-    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
-    return cacheService.setJsonObject(accountId, value);
-  }
-
-  private filterValidAccountIds(accountIds00: string[]): string[] {
-    return accountIds00.map(item => {
-      if (typeof item === 'number') {
-        return '' + item;
-      }
-      if (typeof item === 'string') {
-        return item.trim();
-      }
-      return null;
-    }).filter((accountId: string) => {
-      return accountId && isOnlyAscii(accountId);
-    });
-  }
-
-  private async queryUserAccountIdList(accountIds00: string[]): Promise<any[]> {
-    const accountIds = this.filterValidAccountIds(accountIds00);
-
-    const resultRowMap = {} as Record<string, any>;
-    for (let i = 0; i < accountIds.length; i++) {
-      const accountId = accountIds[i];
-      const row = await this.getFromCache(accountId);
-      if (row) {
-        resultRowMap[accountId] = row;
-      }
-    }
-
-    const notCachedCodes = accountIds.filter((accountId) => !resultRowMap[accountId]);
-    if (notCachedCodes.length === 0) {
-      return Object.values(resultRowMap);
-    }
-
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    const reqJson: IRequestModel = {
-      columns: ['nick_name', 'avatar', 'account_id'],
-      condition: {
-        account_id: {
-          $in: [...notCachedCodes],
-        },
-      },
-    };
-
-    const cfgModel: IRequestCfgModel = {
-      method: 'UserAccountService.queryAccountBasicInfoByIds',
-      sqlTable: SystemTables.sys_user_account,
-      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
-      sqlDatabase: SystemDbName,
-      sqlDbType: SystemDbType,
-    };
-    const res = await this.curdProService.executeCrudByCfg(reqJson, cfgModel);
-    const rows = res.getResRows();
-    if (Array.isArray(rows) && rows.length > 0) {
-      for (let i = 0; i < rows.length; i++) {
-        const row = rows[i];
-        const { account_id } = row;
-        await this.setToCache(account_id, row);
-        resultRowMap[account_id] = row;
-      }
-    }
-    return Object.values(resultRowMap)
-
-
-  }
-
-
-
-
-  async handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void> {
-    const userInfoMap = executeContext[TMP_CTX_KEY] as Map<string, any>;
-    const isArrayModeMap = executeContext[TMP_CTX_KEY2] as Map<string, boolean>;
-
-    if (!userInfoMap || userInfoMap.size === 0) {
-      return;
-    }
-
-    dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
-      const sourceColumn = columnRelation.sourceColumn;
-      const targetColumns = columnRelation.targetColumns;
-      if (!Array.isArray(targetColumns) || targetColumns.length === 0) {
-        const isArrayMode = isArrayModeMap.get(sourceColumn) || false;
-        if (isArrayMode === true) {
-          columnRelation.targetColumns = [
-            { from: 'nick_name', to: `${sourceColumn}_array_info[$ARRAY_INDEX].nick_name` },
-            { from: 'avatar', to: `${sourceColumn}_array_info[$ARRAY_INDEX].avatar` },
-            { from: 'account_id', to: `${sourceColumn}_array_info[$ARRAY_INDEX].account_id` },
-          ];
-        } else {
-          columnRelation.targetColumns = [
-            { from: 'nick_name', to: `${sourceColumn}_user.nick_name` },
-            { from: 'avatar', to: `${sourceColumn}_user.avatar` },
-            { from: 'account_id', to: `${sourceColumn}_user.account_id` },
-          ];
-        }
-      }
-      dictMixUtils.copyUserInfoToRowNoRelatedCode(row, userInfoMap, columnRelation);
-    });
-  }
-}
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import { CurdProService } from './CurdProService';
+import { HandleExecuteContextType, IExecuteContextHandler } from '@/libs/crud-pro/models/ExecuteContext';
+import { CrudMixUtils, RelatedType, toFatcmsUserAccountIdList } from './CurdMixUtils';
+import { SystemTables } from '@/models/SystemTables';
+import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
+import { ColumnRelation, IRequestCfgModel, IRequestModel } from '@/libs/crud-pro/interfaces';
+import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import { CacheNameEnum } from "@/models/bizmodels";
+import { CacheServiceFactory } from "@/service/base/cache/CacheServiceFactory";
+import { isOnlyAscii } from "@/libs/utils/functions";
+
+const dictMixUtils = new CrudMixUtils(RelatedType.accountBasic);
+
+const TMP_CTX_KEY = _.uniqueId('CurdMixByAccountService');
+const TMP_CTX_KEY2 = _.uniqueId('CurdMixByAccountService2');
+
+
+@Provide()
+export class CurdMixByAccountService implements IExecuteContextHandler {
+
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  protected curdProService: CurdProService;
+
+  @Inject()
+  private cacheServiceFactory: CacheServiceFactory;
+
+
+  async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {
+
+    const relations = dictMixUtils.pickColumnRelations(executeContext);
+    if (!relations || relations.length === 0) {
+      return;
+    }
+
+    const isArrayModeMap = new Map<string, boolean>();
+
+    const accountIds = new Set<string>();
+    dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
+      const { sourceColumn } = columnRelation;
+      if (sourceColumn) {
+        const accountId = _.get(row, sourceColumn);
+        if (accountId) {
+          const { isArray, fatcmsUserAccountIdList, fatcmsUserAccountId } = toFatcmsUserAccountIdList(accountId);
+          if (isArray) {
+            isArrayModeMap.set(sourceColumn, true);
+            fatcmsUserAccountIdList.forEach(item => accountIds.add(item));
+          } else if (fatcmsUserAccountId) {
+            accountIds.add(fatcmsUserAccountId);
+          }
+        }
+      }
+    });
+
+    if (accountIds.size === 0) {
+      return;
+    }
+
+    const userInfos = await this.queryUserAccountIdList([...accountIds]);
+    executeContext[TMP_CTX_KEY] = MixinUtils.toNewMap(userInfos, (obj: any) => obj.account_id);
+    executeContext[TMP_CTX_KEY2] = isArrayModeMap;
+  }
+
+
+  private async getFromCache(accountId: string): Promise<any> {
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
+    return cacheService.getJsonObject(accountId);
+  }
+
+  private async setToCache(accountId: string, value: any): Promise<any> {
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
+    return cacheService.setJsonObject(accountId, value);
+  }
+
+  private filterValidAccountIds(accountIds00: string[]): string[] {
+    return accountIds00.map(item => {
+      if (typeof item === 'number') {
+        return '' + item;
+      }
+      if (typeof item === 'string') {
+        return item.trim();
+      }
+      return null;
+    }).filter((accountId: string) => {
+      return accountId && isOnlyAscii(accountId);
+    });
+  }
+
+  private async queryUserAccountIdList(accountIds00: string[]): Promise<any[]> {
+    const accountIds = this.filterValidAccountIds(accountIds00);
+
+    const resultRowMap = {} as Record<string, any>;
+    for (let i = 0; i < accountIds.length; i++) {
+      const accountId = accountIds[i];
+      const row = await this.getFromCache(accountId);
+      if (row) {
+        resultRowMap[accountId] = row;
+      }
+    }
+
+    const notCachedCodes = accountIds.filter((accountId) => !resultRowMap[accountId]);
+    if (notCachedCodes.length === 0) {
+      return Object.values(resultRowMap);
+    }
+
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const reqJson: IRequestModel = {
+      columns: ['nick_name', 'avatar', 'account_id'],
+      condition: {
+        account_id: {
+          $in: [...notCachedCodes],
+        },
+      },
+    };
+
+    const cfgModel: IRequestCfgModel = {
+      method: 'UserAccountService.queryAccountBasicInfoByIds',
+      sqlTable: SystemTables.sys_user_account,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+      sqlDatabase: SystemDbName,
+      sqlDbType: SystemDbType,
+    };
+    const res = await this.curdProService.executeCrudByCfg(reqJson, cfgModel);
+    const rows = res.getResRows();
+    if (Array.isArray(rows) && rows.length > 0) {
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const { account_id } = row;
+        await this.setToCache(account_id, row);
+        resultRowMap[account_id] = row;
+      }
+    }
+    return Object.values(resultRowMap)
+
+
+  }
+
+
+
+
+  async handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void> {
+    const userInfoMap = executeContext[TMP_CTX_KEY] as Map<string, any>;
+    const isArrayModeMap = executeContext[TMP_CTX_KEY2] as Map<string, boolean>;
+
+    if (!userInfoMap || userInfoMap.size === 0) {
+      return;
+    }
+
+    dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
+      const sourceColumn = columnRelation.sourceColumn;
+      const targetColumns = columnRelation.targetColumns;
+      if (!Array.isArray(targetColumns) || targetColumns.length === 0) {
+        const isArrayMode = isArrayModeMap.get(sourceColumn) || false;
+        if (isArrayMode === true) {
+          columnRelation.targetColumns = [
+            { from: 'nick_name', to: `${sourceColumn}_array_info[$ARRAY_INDEX].nick_name` },
+            { from: 'avatar', to: `${sourceColumn}_array_info[$ARRAY_INDEX].avatar` },
+            { from: 'account_id', to: `${sourceColumn}_array_info[$ARRAY_INDEX].account_id` },
+          ];
+        } else {
+          columnRelation.targetColumns = [
+            { from: 'nick_name', to: `${sourceColumn}_user.nick_name` },
+            { from: 'avatar', to: `${sourceColumn}_user.avatar` },
+            { from: 'account_id', to: `${sourceColumn}_user.account_id` },
+          ];
+        }
+      }
+      dictMixUtils.copyUserInfoToRowNoRelatedCode(row, userInfoMap, columnRelation);
+    });
+  }
+}