midway-fatcms 0.0.1-beta.30 → 0.0.1-beta.31

package/dist/schedule/runSchedule.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScheduleTaskOnce = exports.SCHEDULE_QUEUE = void 0;
+const anonymousContext_1 = require("./anonymousContext");
+// 上次执行时间
+const lastExecuteTimeMap = {};
+const DEFAULT_SCHEDULE_INTERVAL = 2 * 60 * 1000;
+async function runScheduleTaskOnce(serviceName) {
+    return await anonymousContext_1.ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx) => {
+        const serviceObject = await ctx.requestContext.getAsync(serviceName);
+        if (serviceObject && serviceObject.runBySchedule) {
+            await serviceObject.runBySchedule();
+        }
+        else {
+            ctx.logger.error(`runSchedule error , serviceName = ${serviceName}, 没有找到服务`);
+        }
+    });
+}
+exports.runScheduleTaskOnce = runScheduleTaskOnce;
+class ScheduleQueue {
+    constructor() {
+        this.scheduleIntervalMap = new Map();
+    }
+    setScheduleTask(serviceName, intervalTime) {
+        this.scheduleIntervalMap.set(serviceName, intervalTime);
+    }
+    removeScheduleTask(serviceName) {
+        this.scheduleIntervalMap.delete(serviceName);
+    }
+    isAlreadyTimeToExecute(serviceName) {
+        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;
+    }
+    async runScheduleTaskOnceCheckTime(serviceName) {
+        // 还没有到可以执行时间
+        if (!this.isAlreadyTimeToExecute(serviceName)) {
+            return;
+        }
+        lastExecuteTimeMap[serviceName] = Date.now();
+        await runScheduleTaskOnce(serviceName);
+    }
+    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) {
+                anonymousContext_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+            }
+        }
+    }
+    async startScheduleLoop() {
+        await this.runScheduleServiceList();
+        setInterval(() => {
+            this.runScheduleServiceList();
+        }, 1000); // 最少1秒执行一次
+    }
+}
+const SCHEDULE_QUEUE = new ScheduleQueue();
+exports.SCHEDULE_QUEUE = SCHEDULE_QUEUE;

package/dist/schedule/scheduleNames.d.ts

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

package/dist/schedule/scheduleNames.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INNER_SCHEDULE_NAMES = exports.INNER_SCHEDULE_INTERVAL = void 0;
+const INNER_SCHEDULE_INTERVAL = {
+    proxyApiLoadService: 2 * 60 * 1000,
+    workbenchService: 60 * 1000,
+    visitStatService: 10 * 60 * 1000,
+    asyncTaskRunnerService: 1000, // 1s可以执行
+};
+exports.INNER_SCHEDULE_INTERVAL = INNER_SCHEDULE_INTERVAL;
+const INNER_SCHEDULE_NAMES = {
+    proxyApiLoadService: 'proxyApiLoadService',
+    workbenchService: 'workbenchService',
+    visitStatService: "visitStatService",
+    asyncTaskRunnerService: "asyncTaskRunnerService",
+};
+exports.INNER_SCHEDULE_NAMES = INNER_SCHEDULE_NAMES;

package/dist/service/AuthService.d.ts

@@ -0,0 +1,70 @@
+import { IConsumerUserInfo, ISessionInfo } from '../models/userSession';
+import { CommonResult } from '../libs/utils/common-dto';
+export declare class AuthService {
+    private ctx;
+    private superAdminList;
+    private curdMixService;
+    private userService;
+    private userSessionService;
+    /**
+     * 明文密码转unsaltedPwd密码
+     * @param plainPwd
+     * @param loginName
+     */
+    toUnsaltedPwd(plainPwd: string, loginName: string): string;
+    /**
+     * front: pw1 = md5(md5(input_pw) + "_" + loginName)
+     * db: pw2 = md5(pwd_salt + pw1)
+     * 检查用户名密码是否正确
+     * @param loginName
+     * @param unsaltedPwd
+     */
+    checkLoginPassword(loginName: string, unsaltedPwd: string): Promise<CommonResult>;
+    /**
+     * 创建一个toC端的UserSession
+     * @param consumerUserInfo
+     */
+    createUserSessionForConsumer(consumerUserInfo: IConsumerUserInfo): Promise<{
+        sessionId: string;
+        loginName: string;
+        accountId: string;
+        nickName: string;
+        avatar: string;
+        workbenchCode: string;
+        accountType: string;
+    }>;
+    /**
+     * 创建一个Session
+     * @param loginName
+     * @param workbenchCode
+     */
+    createUserSession(loginName: string, workbenchCode: string): Promise<{
+        sessionId: string;
+        loginName: string;
+        accountId: any;
+        nickName: any;
+        avatar: any;
+        workbenchCode: string;
+        accountType: string;
+    }>;
+    /**
+     * 获取用户
+     * @param loginName
+     * @private
+     */
+    private queryUserAccountByLoginName;
+    /**
+     * 查询此accountId下关联的角色code列表
+     * @param accountId
+     * @private
+     */
+    private queryUserRoleCodeList;
+    /**
+     * 查询此roleCodeList下面关联的所有功能点列表
+     * @param roleCodeList
+     * @private
+     */
+    private queryFunctionCodeList;
+    removeUserSession(sessionId: string): Promise<any>;
+    refreshSession(sessionInfo: ISessionInfo): Promise<ISessionInfo>;
+}

package/dist/service/AuthService.js

@@ -0,0 +1,251 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const core_1 = require("@midwayjs/core");
+const keys_1 = require("../libs/crud-pro/models/keys");
+const CurdMixService_1 = require("./curd/CurdMixService");
+const md5 = require("md5");
+const UserAccountService_1 = require("./UserAccountService");
+const functions_1 = require("../libs/utils/functions");
+const userSession_1 = require("../models/userSession");
+const SystemTables_1 = require("../models/SystemTables");
+const UserSessionService_1 = require("./UserSessionService");
+const common_dto_1 = require("../libs/utils/common-dto");
+const fatcms_request_1 = require("../libs/utils/fatcms-request");
+const exceptions_1 = require("../libs/crud-pro/exceptions");
+const global_config_1 = require("../libs/global-config/global-config");
+let AuthService = class AuthService {
+    /**
+     * 明文密码转unsaltedPwd密码
+     * @param plainPwd
+     * @param loginName
+     */
+    toUnsaltedPwd(plainPwd, loginName) {
+        const pw2 = md5(md5(plainPwd) + '_' + loginName);
+        return pw2;
+    }
+    /**
+     * front: pw1 = md5(md5(input_pw) + "_" + loginName)
+     * db: pw2 = md5(pwd_salt + pw1)
+     * 检查用户名密码是否正确
+     * @param loginName
+     * @param unsaltedPwd
+     */
+    async checkLoginPassword(loginName, unsaltedPwd) {
+        const message = '用户名或密码错误';
+        const errorCode = 'USERNAME_OR_PASSWORD_IS_INCORRECT';
+        if (!loginName) {
+            return common_dto_1.CommonResult.errorRes(message, errorCode, '!loginName');
+        }
+        if (!unsaltedPwd) {
+            return common_dto_1.CommonResult.errorRes(message, errorCode, '!unsaltedPwd');
+        }
+        const userAccount = await this.queryUserAccountByLoginName(loginName);
+        if (!userAccount) {
+            return common_dto_1.CommonResult.errorRes(message, errorCode, '!userAccount');
+        }
+        if (userAccount.status !== 1) {
+            return common_dto_1.CommonResult.errorRes(message, errorCode, 'userAccount.status !== 1');
+        }
+        if (!userAccount.pwd_md5) {
+            return common_dto_1.CommonResult.errorRes(message, errorCode, '!userAccount.pwd_md5');
+        }
+        const pwd_salt = userAccount.pwd_salt;
+        const pwd_md5 = md5(unsaltedPwd + pwd_salt);
+        if (userAccount['pwd_md5'] !== pwd_md5) {
+            return common_dto_1.CommonResult.errorRes(message, errorCode, "userAccount['pwd_md5'] !== pwd_md5");
+        }
+        return common_dto_1.CommonResult.successRes();
+    }
+    /**
+     * 创建一个toC端的UserSession
+     * @param consumerUserInfo
+     */
+    async createUserSessionForConsumer(consumerUserInfo) {
+        const sessionId = (0, functions_1.createUniqueId)();
+        const sessionInfo = {
+            nickName: consumerUserInfo.nickName,
+            avatar: consumerUserInfo.avatar,
+            roleCodes: [],
+            functionCodes: [],
+            loginName: consumerUserInfo.loginName,
+            sessionId,
+            accountId: consumerUserInfo.accountId,
+            workbenchCode: consumerUserInfo.workbenchCode,
+            accountType: consumerUserInfo.accountType,
+        };
+        await this.userSessionService.saveUserSession(sessionInfo);
+        return {
+            sessionId,
+            loginName: sessionInfo.loginName,
+            accountId: sessionInfo.accountId,
+            nickName: sessionInfo.nickName,
+            avatar: sessionInfo.avatar,
+            workbenchCode: sessionInfo.workbenchCode,
+            accountType: sessionInfo.accountType,
+        };
+    }
+    /**
+     * 创建一个Session
+     * @param loginName
+     * @param workbenchCode
+     */
+    async createUserSession(loginName, workbenchCode) {
+        const userAccount = await this.queryUserAccountByLoginName(loginName);
+        if (!userAccount) {
+            throw new exceptions_1.CommonException('USER_ACCOUNT_NOT_EXIST', '用户账号不存在');
+        }
+        const accountId = userAccount.account_id;
+        const sessionId = (0, functions_1.createUniqueId)();
+        const roleCodes = await this.queryUserRoleCodeList(accountId);
+        const functionCodes = await this.queryFunctionCodeList(roleCodes);
+        const sessionInfo = {
+            nickName: userAccount.nick_name,
+            avatar: userAccount.avatar,
+            roleCodes,
+            functionCodes,
+            loginName,
+            sessionId,
+            accountId,
+            workbenchCode,
+            accountType: userSession_1.SYS_ACCOUNT_TYPE,
+        };
+        await this.userSessionService.saveUserSession(sessionInfo);
+        return {
+            sessionId,
+            loginName,
+            accountId,
+            nickName: userAccount.nick_name,
+            avatar: userAccount.avatar,
+            workbenchCode: sessionInfo.workbenchCode,
+            accountType: sessionInfo.accountType,
+        };
+    }
+    /**
+     * 获取用户
+     * @param loginName
+     * @private
+     */
+    async queryUserAccountByLoginName(loginName) {
+        const superAdminList = this.superAdminList;
+        const findFromSuperAdmin = () => {
+            if (!(0, fatcms_request_1.isEnableSuperAdmin)(this.ctx)) {
+                return null;
+            }
+            if (!Array.isArray(superAdminList)) {
+                return null;
+            }
+            for (let i = 0; i < superAdminList.length; i++) {
+                const element = superAdminList[i];
+                if (element && element.login_name === loginName) {
+                    const nick_name = 'SA' + i;
+                    return {
+                        nick_name: element.nick_name || nick_name,
+                        avatar: '',
+                        account_id: nick_name,
+                        status: 1,
+                        login_name: element.login_name,
+                        pwd_salt: element.pwd_salt,
+                        pwd_md5: element.pwd_md5,
+                    };
+                }
+            }
+        };
+        const superAdmin = findFromSuperAdmin();
+        if (superAdmin) {
+            return superAdmin;
+        }
+        return this.userService.queryUserAccountByLoginName(loginName);
+    }
+    /**
+     * 查询此accountId下关联的角色code列表
+     * @param accountId
+     * @private
+     */
+    async queryUserRoleCodeList(accountId) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res = await this.curdMixService.executeCrudByCfg({
+            condition: { account_id: accountId },
+            limit: 10000,
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_perm_user_role,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        const rows = res.getResModel().rows || [];
+        const roleCodes = rows.map(({ role_code }) => {
+            return role_code;
+        });
+        return [...new Set(roleCodes)];
+    }
+    /**
+     * 查询此roleCodeList下面关联的所有功能点列表
+     * @param roleCodeList
+     * @private
+     */
+    async queryFunctionCodeList(roleCodeList) {
+        if (!roleCodeList || roleCodeList.length === 0) {
+            return [];
+        }
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res = await this.curdMixService.executeCrudByCfg({
+            condition: { role_code: { $in: roleCodeList } },
+            limit: 10000,
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_perm_role_func,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        const rows = res.getResModel().rows || [];
+        const funcCodes = rows.map(({ func_code }) => {
+            return func_code;
+        });
+        return [...new Set(funcCodes)];
+    }
+    async removeUserSession(sessionId) {
+        return this.userSessionService.removeUserSession(sessionId);
+    }
+    async refreshSession(sessionInfo) {
+        const oldSessionId = sessionInfo.sessionId;
+        const sessionId = (0, functions_1.createUniqueId)();
+        const newSessionInfo = { ...sessionInfo, sessionId };
+        await this.userSessionService.saveUserSession(newSessionInfo);
+        await this.removeUserSession(oldSessionId);
+        return newSessionInfo;
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], AuthService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Config)('superAdminList'),
+    __metadata("design:type", Array)
+], AuthService.prototype, "superAdminList", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdMixService_1.CurdMixService)
+], AuthService.prototype, "curdMixService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", UserAccountService_1.UserAccountService)
+], AuthService.prototype, "userService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", UserSessionService_1.UserSessionService)
+], AuthService.prototype, "userSessionService", void 0);
+AuthService = __decorate([
+    (0, core_1.Provide)()
+], AuthService);
+exports.AuthService = AuthService;

package/dist/service/EnumInfoService.d.ts

@@ -0,0 +1,30 @@
+import { Context } from '@midwayjs/koa';
+import { RelatedType } from './curd/CurdMixUtils';
+import { IEnumInfo } from '../libs/utils/parseConfig';
+interface IQueryEnumInfo {
+    type: RelatedType;
+    code: string;
+}
+interface IQueryEnumResult {
+    type: RelatedType;
+    code: string;
+    values: IEnumInfo[];
+}
+export declare class EnumInfoService {
+    ctx: Context;
+    private curdProService;
+    private curdMixByLinkToCustomService;
+    private redisCacheService;
+    queryEnumInfo(codeList: IQueryEnumInfo[], refreshCache: boolean): Promise<IQueryEnumResult[]>;
+    /**
+     * code形如：fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
+     * code形如：fatcms~~~sys_perm_role~~~id,*
+     * 【数据库】~~~【表名】~~~【label】,【value】，【style】
+     * @param code
+     * @private
+     */
+    private queryEnumInfoByLinkToCustom;
+    private queryEnumInfoBySysCfgEnum;
+    private queryEnumInfoItemByDict;
+}
+export {};

package/dist/service/EnumInfoService.js

@@ -0,0 +1,127 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumInfoService = void 0;
+const core_1 = require("@midwayjs/core");
+const keys_1 = require("../libs/crud-pro/models/keys");
+const CurdProService_1 = require("./curd/CurdProService");
+const CurdMixUtils_1 = require("./curd/CurdMixUtils");
+const SystemTables_1 = require("../models/SystemTables");
+const parseConfig_1 = require("../libs/utils/parseConfig");
+const RedisCacheService_1 = require("./base/RedisCacheService");
+const CurdMixByLinkToCustomService_1 = require("./curd/CurdMixByLinkToCustomService");
+const global_config_1 = require("../libs/global-config/global-config");
+const RedisKeys_1 = require("../models/RedisKeys");
+function filterEmpty(e) {
+    return e.label && typeof e.value !== 'undefined';
+}
+let EnumInfoService = class EnumInfoService {
+    async queryEnumInfo(codeList, refreshCache) {
+        const expireSecond = 2 * 60;
+        const result = [];
+        for (let i = 0; i < codeList.length; i++) {
+            const { code, type } = codeList[i];
+            const cacheKey = `${RedisKeys_1.RedisKeys.QUERY_ENUM_INFO_PREFIX}${type}@@${code}`;
+            const emums = refreshCache ? null : await this.redisCacheService.getJsonObject(cacheKey);
+            if (!Array.isArray(emums) || emums.length === 0) {
+                let values;
+                if (type === CurdMixUtils_1.RelatedType.sysCfgEnum) {
+                    values = await this.queryEnumInfoBySysCfgEnum(code);
+                    await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
+                }
+                else if (type === CurdMixUtils_1.RelatedType.dict) {
+                    values = await this.queryEnumInfoItemByDict(code);
+                    await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
+                }
+                else if (type === CurdMixUtils_1.RelatedType.linkToCustom) {
+                    values = await this.queryEnumInfoByLinkToCustom(code);
+                    // await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
+                }
+                result.push({ type, code, values });
+            }
+            else {
+                result.push({ type, code, values: emums });
+            }
+        }
+        return result;
+    }
+    /**
+     * code形如：fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
+     * code形如：fatcms~~~sys_perm_role~~~id,*
+     * 【数据库】~~~【表名】~~~【label】,【value】，【style】
+     * @param code
+     * @private
+     */
+    async queryEnumInfoByLinkToCustom(code) {
+        const cc = await this.curdMixByLinkToCustomService.queryInfoByLinkToCustom(code);
+        if (!cc) {
+            return [];
+        }
+        const keys = [...cc.keys()];
+        return keys.map(value => {
+            const label = cc.get(value);
+            return { label, value };
+        });
+    }
+    async queryEnumInfoBySysCfgEnum(code) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res1 = await this.curdProService.executeCrudByCfg({
+            condition: { config_code: code },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_configs,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        const obj = res1.getOneObj();
+        if (!obj) {
+            return null;
+        }
+        const rows = (0, parseConfig_1.parseConfigContentToEnumInfo)(obj);
+        return rows.map(e => ({ label: e.label, value: e.value, children: e.children })).filter(filterEmpty);
+    }
+    async queryEnumInfoItemByDict(code) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res1 = await this.curdProService.executeCrudByCfg({
+            condition: { dict_code: code },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_data_dict_item,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        const obj = res1.getResRows();
+        if (!obj) {
+            return null;
+        }
+        return obj.map(e => ({ label: e.label, value: e.value })).filter(filterEmpty);
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], EnumInfoService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], EnumInfoService.prototype, "curdProService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdMixByLinkToCustomService_1.CurdMixByLinkToCustomService)
+], EnumInfoService.prototype, "curdMixByLinkToCustomService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", RedisCacheService_1.RedisCacheService)
+], EnumInfoService.prototype, "redisCacheService", void 0);
+EnumInfoService = __decorate([
+    (0, core_1.Provide)()
+], EnumInfoService);
+exports.EnumInfoService = EnumInfoService;

package/dist/service/FileCenterService.d.ts

@@ -0,0 +1,43 @@
+import { Context } from '@midwayjs/koa';
+import { AccessType, UploadCategoryType } from '../models/bizmodels';
+import { BaseService } from './base/BaseService';
+export declare function isImageFile(fileKey: string): boolean;
+interface IUploadFileToOSSOptions {
+    uploadCategoryType: UploadCategoryType;
+    uploadPath: string;
+}
+export declare const PATH_PREFIX = "/ns/gw/file";
+export declare function toDownloadPaths(origin: string, fileKey: string): {
+    downloadPath: string;
+    previewPath: string;
+    thumbnailPath: string;
+    downloadURL: string;
+    previewURL: string;
+    thumbnailURL: string;
+};
+export declare class FileCenterService extends BaseService {
+    protected ctx: Context;
+    private curdMixService;
+    private get fileBD();
+    uploadFileToOSS(files: any, accessType: AccessType, referer: string, options?: IUploadFileToOSSOptions): Promise<{
+        fileKey: string;
+        fileSuffix: string;
+        storagePath: string;
+        storageUrl: any;
+        fileSize: any;
+        filename: any;
+        mimeType: any;
+        name: any;
+        url: any;
+    }>;
+    deleteFile(fileKey: string): Promise<import("../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    private headFile;
+    downloadFile(fileKey: string, streaming: boolean, process: string): Promise<any>;
+    /**
+     * 检查用户下载权限
+     * @param fileInfo
+     * @private
+     */
+    private checkAuthUserDownloadFile;
+}
+export {};