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

package/dist/models/bizmodels.d.ts

@@ -0,0 +1,97 @@
+import { IRequestCfgModel, IVisitor } from '../libs/crud-pro/interfaces';
+/**
+ * 实体表公共字段
+ */
+export interface IEntityCommonInfo {
+    id?: number;
+    created_by?: string;
+    modified_by?: string;
+    created_at?: string;
+    modified_at?: string;
+    status?: number;
+}
+export interface ITableBaseInfo {
+    databaseName: string;
+    tableName: string;
+}
+export interface IStdCrudCfgObj {
+    tableBaseInfo: ITableBaseInfo;
+    authSetting: any;
+    actionColumns?: any[];
+    queryFormFields?: any[];
+    tableColumns?: any[];
+    tableFields?: any[];
+    toolbarList?: any[];
+}
+export interface ICrudStdAppInfo {
+    app_code: string;
+    stdCrudCfgObj?: IStdCrudCfgObj;
+    actionsMap?: any;
+    status: number;
+}
+export interface ICrudStdAppInfoForSettingKey extends ICrudStdAppInfo {
+    settingKeyActionCfg?: any;
+    authConfig?: string[];
+    authType?: string;
+}
+export declare enum AccessType {
+    owner = "owner",
+    login = "login",
+    open = "open"
+}
+export declare enum UploadCategoryType {
+    file = "file",
+    assets = "assets"
+}
+export declare class PermFunc {
+    funcCode: string;
+    funcName: string;
+    constructor(funcCode: string, funcName: string);
+}
+export declare class PermRole {
+    roleCode: string;
+    roleName: string;
+    constructor(roleCode: string, roleName: string);
+}
+export declare const CTX_VISITOR_ID = "visitor.accountId";
+export declare const CTX_VISITOR_AVATAR = "visitor.avatar";
+export declare const CTX_VISITOR_NICKNAME = "visitor.nickName";
+export declare const CTX_VISITOR_ACCOUNT_TYPE = "visitor.accountType";
+export declare const CTX_WORKBENCH_CODE = "visitor.workbenchCode";
+export interface IRequestCfgModel2 extends IRequestCfgModel {
+    enableStandardUpdateCfg?: boolean | string[];
+    enableStandardUpdateCfgCondition?: boolean | string[];
+}
+export interface IVisitorExt extends IVisitor {
+    workbenchCode: string;
+    avatar: string;
+    accountType: string;
+}
+export declare const FILE_GET_TYPES: string[];
+/**
+ * fat-design中的TablePro组件的查询参数
+ */
+export interface ITableProQueryParams {
+    condition: any;
+    pageNo: number;
+    pageSize: number;
+    orderBy: string | any;
+}
+export declare enum StdCrudExportInputParamsAppType {
+    STD_CRUD = "STD_CRUD",
+    INNER_HTTP = "INNER_HTTP"
+}
+/**
+ * fat-design中的TablePro组件的查询参数
+ */
+export interface IStdCrudExportInputParams {
+    appType: StdCrudExportInputParamsAppType;
+    appCode?: string;
+    innerHttpUrl?: string;
+    columns?: any[];
+    lastQueryParams: ITableProQueryParams;
+    selectedRowKeys: string[] | number[];
+    headers: any;
+    primaryKey: any;
+    pageSize: number;
+}

package/dist/models/bizmodels.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdCrudExportInputParamsAppType = exports.FILE_GET_TYPES = exports.CTX_WORKBENCH_CODE = exports.CTX_VISITOR_ACCOUNT_TYPE = exports.CTX_VISITOR_NICKNAME = exports.CTX_VISITOR_AVATAR = exports.CTX_VISITOR_ID = exports.PermRole = exports.PermFunc = exports.UploadCategoryType = exports.AccessType = void 0;
+var AccessType;
+(function (AccessType) {
+    AccessType["owner"] = "owner";
+    AccessType["login"] = "login";
+    AccessType["open"] = "open";
+})(AccessType = exports.AccessType || (exports.AccessType = {}));
+var UploadCategoryType;
+(function (UploadCategoryType) {
+    UploadCategoryType["file"] = "file";
+    UploadCategoryType["assets"] = "assets";
+})(UploadCategoryType = exports.UploadCategoryType || (exports.UploadCategoryType = {}));
+class PermFunc {
+    constructor(funcCode, funcName) {
+        this.funcName = funcName;
+        this.funcCode = funcCode;
+    }
+}
+exports.PermFunc = PermFunc;
+class PermRole {
+    constructor(roleCode, roleName) {
+        this.roleName = roleName;
+        this.roleCode = roleCode;
+    }
+}
+exports.PermRole = PermRole;
+exports.CTX_VISITOR_ID = 'visitor.accountId';
+exports.CTX_VISITOR_AVATAR = 'visitor.avatar';
+exports.CTX_VISITOR_NICKNAME = 'visitor.nickName';
+exports.CTX_VISITOR_ACCOUNT_TYPE = 'visitor.accountType';
+exports.CTX_WORKBENCH_CODE = 'visitor.workbenchCode';
+exports.FILE_GET_TYPES = ['thumbnail', 'preview', 'download'];
+var StdCrudExportInputParamsAppType;
+(function (StdCrudExportInputParamsAppType) {
+    StdCrudExportInputParamsAppType["STD_CRUD"] = "STD_CRUD";
+    StdCrudExportInputParamsAppType["INNER_HTTP"] = "INNER_HTTP";
+})(StdCrudExportInputParamsAppType = exports.StdCrudExportInputParamsAppType || (exports.StdCrudExportInputParamsAppType = {}));

package/dist/models/contextLogger.d.ts

@@ -0,0 +1,25 @@
+import { ILogger } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+interface ILoggerContext extends ILogger {
+    log(msg: any, ...args: any[]): void;
+}
+declare const consoleLogger: ILoggerContext;
+/**
+ * 每个Context请求，都会创建一个新的ContextLogger对象
+ */
+declare class ContextLogger implements ILoggerContext {
+    private readonly ctx;
+    private readonly app;
+    private readonly logList;
+    constructor(ctx: Context);
+    getLogList(): any;
+    debug(msg: any, ...args: any[]): void;
+    error(msg: any, ...args: any[]): void;
+    info(msg: any, ...args: any[]): void;
+    warn(msg: any, ...args: any[]): void;
+    log(msg: any, ...args: any[]): void;
+    private appendLogList;
+    private getLogger;
+    getPrefixContextLogger(prefix: string): ILoggerContext;
+}
+export { ContextLogger, consoleLogger, ILoggerContext };

package/dist/models/contextLogger.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleLogger = exports.ContextLogger = void 0;
+const moment = require("moment");
+const fatcms_request_1 = require("../libs/utils/fatcms-request");
+const consoleLogger = {
+    info: (msg, ...args) => {
+        console.info(msg, ...args);
+    },
+    debug: (msg, ...args) => {
+        console.debug(msg, ...args);
+    },
+    error: (msg, ...args) => {
+        console.error(msg, ...args);
+    },
+    warn: (msg, ...args) => {
+        console.warn(msg, ...args);
+    },
+    log: (msg, ...args) => {
+        console.log(msg, ...args);
+    },
+};
+exports.consoleLogger = consoleLogger;
+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 {
+    constructor(ctx) {
+        this.logList = [];
+        this.app = ctx.app;
+        this.ctx = ctx;
+        this.logList = [];
+    }
+    getLogList() {
+        return this.logList;
+    }
+    debug(msg, ...args) {
+        this.getLogger().debug(msg, ...args);
+        this.appendLogList('debug', msg, ...args);
+    }
+    error(msg, ...args) {
+        this.getLogger().error(msg, ...args);
+        this.appendLogList('error', msg, ...args);
+    }
+    info(msg, ...args) {
+        this.getLogger().info(msg, ...args);
+        this.appendLogList('info', msg, ...args);
+    }
+    warn(msg, ...args) {
+        this.getLogger().warn(msg, ...args);
+        this.appendLogList('warn', msg, ...args);
+    }
+    log(msg, ...args) {
+        this.getLogger().info(msg, ...args);
+        this.appendLogList('info', msg, ...args);
+    }
+    appendLogList(level, msg, ...args) {
+        const ctx = this.ctx;
+        if (!(0, fatcms_request_1.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 });
+    }
+    getLogger() {
+        const logger = this.app.getLogger('logger');
+        if (logger) {
+            return logger;
+        }
+        return consoleLogger;
+    }
+    getPrefixContextLogger(prefix) {
+        return {
+            info: (msg, ...args) => {
+                this.info(prefix, msg, ...args);
+            },
+            debug: (msg, ...args) => {
+                this.debug(prefix, msg, ...args);
+            },
+            error: (msg, ...args) => {
+                this.error(prefix, msg, ...args);
+            },
+            warn: (msg, ...args) => {
+                this.warn(prefix, msg, ...args);
+            },
+            log: (msg, ...args) => {
+                this.log(prefix, msg, ...args);
+            },
+        };
+    }
+}
+exports.ContextLogger = ContextLogger;

package/dist/models/devops.d.ts

@@ -0,0 +1,12 @@
+export declare enum CommonStatusEnum {
+    DISABLED = 0,
+    ENABLED = 1
+}
+/**
+ * 业务异常
+ */
+export declare class BizException {
+    message: string;
+    code: string;
+    constructor(message?: string, code?: string);
+}

package/dist/models/devops.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BizException = exports.CommonStatusEnum = void 0;
+// 状态；0 未启用， 1 已启用',
+var CommonStatusEnum;
+(function (CommonStatusEnum) {
+    CommonStatusEnum[CommonStatusEnum["DISABLED"] = 0] = "DISABLED";
+    CommonStatusEnum[CommonStatusEnum["ENABLED"] = 1] = "ENABLED";
+})(CommonStatusEnum = exports.CommonStatusEnum || (exports.CommonStatusEnum = {}));
+/**
+ * 业务异常
+ */
+class BizException {
+    constructor(message, code) {
+        this.message = message;
+        this.code = code || 'BizException';
+    }
+}
+exports.BizException = BizException;

package/dist/models/userSession.d.ts

@@ -0,0 +1,61 @@
+import { KeysOfAuthType } from '../libs/crud-pro/models/keys';
+declare const sessionCookieCfg: {
+    signed: boolean;
+    encrypt: boolean;
+    httpOnly: boolean;
+    maxAge: number;
+};
+declare const SESSION_ID_KEY = "fatcmssessionid";
+declare 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;
+}
+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>;
+}
+declare class UserSessionInfo {
+    private readonly sessionInfo;
+    private readonly superAdmin;
+    constructor(sessionInfo: ISessionInfo, superAdmin?: boolean);
+    getSessionInfo(): ISessionInfo;
+    getSessionValue(key: string): any;
+    isSuperAdmin(): boolean;
+    /**
+     * 是否是我自己的账号
+     * @param accountId
+     */
+    isMySelf(accountId: string): boolean;
+    isLogin(): boolean;
+    hasAnyPermission(funcCodeList: string | string[]): boolean;
+    hasPermission(funcCode: string): boolean;
+    hasAnyRole(roleCodeList: string | string[]): boolean;
+    hasRole(roleCode: string): boolean;
+    isAuthPass(authType: KeysOfAuthType, authConfig: string | string[]): boolean;
+    /**
+     * 批量检查权限
+     * @param params
+     */
+    batchCheckPermission(params: IBatchCheckProps): IBatchCheckRes;
+}
+export { ISessionInfo, UserSessionInfo, SESSION_ID_KEY, SYS_ACCOUNT_TYPE, IConsumerUserInfo, sessionCookieCfg };

package/dist/models/userSession.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionCookieCfg = exports.SYS_ACCOUNT_TYPE = exports.SESSION_ID_KEY = exports.UserSessionInfo = void 0;
+const _ = require("lodash");
+const keys_1 = require("../libs/crud-pro/models/keys");
+const MixinUtils_1 = require("../libs/crud-pro/utils/MixinUtils");
+const exceptions_1 = require("../libs/crud-pro/exceptions");
+const functions_1 = require("../libs/utils/functions");
+const sessionCookieCfg = {
+    signed: true,
+    encrypt: true,
+    httpOnly: true,
+    maxAge: 1000 * 3600 * 24 * 365,
+};
+exports.sessionCookieCfg = sessionCookieCfg;
+const SESSION_ID_KEY = 'fatcmssessionid';
+exports.SESSION_ID_KEY = SESSION_ID_KEY;
+const SYS_ACCOUNT_TYPE = 'fatcms';
+exports.SYS_ACCOUNT_TYPE = SYS_ACCOUNT_TYPE;
+function createEmptySessionInfo(superAdmin) {
+    return {
+        nickName: superAdmin ? 'SA' : '',
+        avatar: '',
+        roleCodes: [],
+        functionCodes: [],
+        loginName: '',
+        sessionId: '',
+        accountId: '',
+        workbenchCode: '',
+        accountType: '',
+    };
+}
+class UserSessionInfo {
+    constructor(sessionInfo, superAdmin) {
+        this.superAdmin = superAdmin === true;
+        if (sessionInfo) {
+            this.sessionInfo = sessionInfo;
+        }
+        else {
+            this.sessionInfo = createEmptySessionInfo(superAdmin);
+        }
+    }
+    getSessionInfo() {
+        return this.sessionInfo;
+    }
+    getSessionValue(key) {
+        return _.get(this.sessionInfo, key);
+    }
+    isSuperAdmin() {
+        return this.superAdmin;
+    }
+    /**
+     * 是否是我自己的账号
+     * @param accountId
+     */
+    isMySelf(accountId) {
+        const s = this.sessionInfo;
+        return s && accountId && s.accountId === accountId;
+    }
+    isLogin() {
+        const s = this.sessionInfo;
+        return !!(s && s.sessionId && s.accountId && s.sessionId.length > 1);
+    }
+    hasAnyPermission(funcCodeList) {
+        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) {
+        if (this.isSuperAdmin()) {
+            return true;
+        }
+        const ss = this.sessionInfo.functionCodes || [];
+        return ss.includes(funcCode);
+    }
+    hasAnyRole(roleCodeList) {
+        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) {
+        if (this.isSuperAdmin()) {
+            return true;
+        }
+        const ss = this.sessionInfo.roleCodes || [];
+        return ss.includes(roleCode);
+    }
+    isAuthPass(authType, authConfig) {
+        if (authType === keys_1.KeysOfAuthType.free || !authType) {
+            return true; // 无需校验
+        }
+        if (!this.isLogin()) {
+            return false;
+        }
+        if (this.isSuperAdmin()) {
+            return true;
+        }
+        if (authType === keys_1.KeysOfAuthType.byFuncCode) {
+            const funcCodes = (0, functions_1.parseStringTrimArray)(authConfig);
+            if (MixinUtils_1.MixinUtils.isEmpty(funcCodes)) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_AUTH_CODE_EMPTY, '缺少权限编码配置');
+            }
+            return this.hasAnyPermission(funcCodes);
+        }
+        if (authType === keys_1.KeysOfAuthType.byRoleCode) {
+            const roleCodes = (0, functions_1.parseStringTrimArray)(authConfig);
+            if (MixinUtils_1.MixinUtils.isEmpty(roleCodes)) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_AUTH_CODE_EMPTY, '缺少角色编码配置');
+            }
+            return this.hasAnyRole(roleCodes);
+        }
+        return true;
+    }
+    /**
+     * 批量检查权限
+     * @param params
+     */
+    batchCheckPermission(params) {
+        const { permissionCodeList, roleCodeList } = params;
+        const permissionCodeResult = {};
+        const roleCodeResult = {};
+        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 };
+    }
+}
+exports.UserSessionInfo = UserSessionInfo;

package/dist/schedule/anonymousContext.d.ts

@@ -0,0 +1,14 @@
+import * as koa from '@midwayjs/koa';
+export declare type RunServiceAtAnonymousContextRunner = (ctx: koa.IMidwayKoaContext) => any;
+export interface RunServiceAtAnonymousContextRes {
+    result: any;
+    error: any;
+}
+declare class AnonymousContext {
+    private app;
+    setApp(app: koa.Application): void;
+    getApp(): koa.IMidwayKoaApplication;
+    runServiceAtAnonymousContext(runner: RunServiceAtAnonymousContextRunner): Promise<RunServiceAtAnonymousContextRes>;
+}
+declare const ANONYMOUS_CONTEXT: AnonymousContext;
+export { ANONYMOUS_CONTEXT };

package/dist/schedule/anonymousContext.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 anonymousUserInfo = {
+    nickName: 'anonymous_user',
+    avatar: '',
+    roleCodes: [],
+    functionCodes: [],
+    loginName: 'anonymous_user',
+    sessionId: '',
+    accountId: '',
+    workbenchCode: '',
+    accountType: userSession_1.SYS_ACCOUNT_TYPE,
+};
+const anonymousWorkbenchInfo = {
+    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,
+};
+class AnonymousContext {
+    setApp(app) {
+        this.app = app;
+    }
+    getApp() {
+        return this.app;
+    }
+    async runServiceAtAnonymousContext(runner) {
+        const app = this.app;
+        const ctx = app.createAnonymousContext();
+        ctx.app = app;
+        ctx.contextLogger = new contextLogger_1.ContextLogger(ctx);
+        ctx.transaction = new Transaction_1.Transaction();
+        ctx.userSession = new userSession_1.UserSessionInfo(anonymousUserInfo, true);
+        ctx.workbenchInfo = anonymousWorkbenchInfo;
+        let result = null;
+        let error = 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();
+exports.ANONYMOUS_CONTEXT = ANONYMOUS_CONTEXT;

package/dist/schedule/index.d.ts

@@ -0,0 +1,4 @@
+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/dist/schedule/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScheduleTaskOnce = exports.SCHEDULE_QUEUE = exports.ANONYMOUS_CONTEXT = exports.INNER_SCHEDULE_INTERVAL = void 0;
+const runSchedule_1 = require("./runSchedule");
+Object.defineProperty(exports, "SCHEDULE_QUEUE", { enumerable: true, get: function () { return runSchedule_1.SCHEDULE_QUEUE; } });
+Object.defineProperty(exports, "runScheduleTaskOnce", { enumerable: true, get: function () { return runSchedule_1.runScheduleTaskOnce; } });
+const anonymousContext_1 = require("./anonymousContext");
+Object.defineProperty(exports, "ANONYMOUS_CONTEXT", { enumerable: true, get: function () { return anonymousContext_1.ANONYMOUS_CONTEXT; } });
+const scheduleNames_1 = require("./scheduleNames");
+Object.defineProperty(exports, "INNER_SCHEDULE_INTERVAL", { enumerable: true, get: function () { return scheduleNames_1.INNER_SCHEDULE_INTERVAL; } });

package/dist/schedule/runSchedule.d.ts

@@ -0,0 +1,12 @@
+declare function runScheduleTaskOnce(serviceName: string): Promise<import("./anonymousContext").RunServiceAtAnonymousContextRes>;
+declare class ScheduleQueue {
+    private scheduleIntervalMap;
+    setScheduleTask(serviceName: string, intervalTime: number): void;
+    removeScheduleTask(serviceName: string): void;
+    private isAlreadyTimeToExecute;
+    private runScheduleTaskOnceCheckTime;
+    private runScheduleServiceList;
+    startScheduleLoop(): Promise<void>;
+}
+declare const SCHEDULE_QUEUE: ScheduleQueue;
+export { SCHEDULE_QUEUE, runScheduleTaskOnce };