midway-fatcms 0.0.1-beta.13 → 0.0.1-beta.16

package/src/libs/crud-pro/services/CrudProTableMetaService.ts

@@ -1,6 +1,8 @@
 import { CrudProServiceBase } from './CrudProServiceBase';
 import { SqlCfgModel } from '../models/SqlCfgModel';
-import { ITableMeta } from '../interfaces';
+import { IExecuteUnsafeQueryCtx, ITableMeta } from '../interfaces';
+import { SqlDbType } from '../models/keys';
+import { pickAndConvertPgRows } from '../utils/sqlConvert/convertPgType';
 
 class CrudProTableMetaCache {
   private cacheMap: Record<string, ITableMeta> = {};
@@ -42,18 +44,50 @@ class CrudProTableMetaService extends CrudProServiceBase {
       tableColumns: [],
     };
 
-    const baseInfo = {
-      tableName: sqlCfgModel.sqlTable,
-      dbName: sqlCfgModel.sqlDatabase,
+    const baseInfo: IExecuteUnsafeQueryCtx = {
+      sqlTable: sqlCfgModel.sqlTable,
+      sqlDatabase: sqlCfgModel.sqlDatabase,
+      sqlDbType: sqlCfgModel.sqlDbType
     };
 
-    const [tableDescribe] = await this.executeUnsafeQuery(baseInfo, 'describe ' + sqlCfgModel.sqlTable);
-    const tableDescribe2 = JSON.parse(JSON.stringify(tableDescribe));
-    obj.tableColumns = tableDescribe2.map(fieldObj => {
-      return fieldObj['Field'];
-    });
+    obj.tableColumns = await this.loadTableColumnInfo(baseInfo);
+
     return obj;
   }
+
+
+
+  private async loadTableColumnInfo(baseInfo: IExecuteUnsafeQueryCtx): Promise<string[]>{
+   
+    if(baseInfo.sqlDbType === SqlDbType.mysql) {
+      const [tableDescribe] = await this.executeUnsafeQuery(baseInfo, 'describe ' + baseInfo.sqlTable);
+      const tableDescribe2 = JSON.parse(JSON.stringify(tableDescribe));
+      return tableDescribe2.map(fieldObj => {
+        return fieldObj['Field'];
+      });
+    }
+    
+    else if(baseInfo.sqlDbType === SqlDbType.postgres) {
+      const schemaname = 'public';
+      const columnArraySql = `
+      SELECT
+        *
+        FROM information_schema.columns
+        WHERE table_schema = '${schemaname}' and table_name = '${baseInfo.sqlTable}'
+        ORDER BY ordinal_position;
+      `.trim();
+      const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
+      const rows = pickAndConvertPgRows(queryRes)
+      return rows.map(fieldObj => {
+        return fieldObj['column_name'];
+      });
+    }
+
+        
+    throw new Error("暂不支持的数据库类型：" + baseInfo.sqlDbType)
+  }
+
+
 }
 
 export { CrudProTableMetaService };

package/src/libs/crud-pro/utils/DatabaseName.ts

@@ -1,19 +1,45 @@
-import { SqlDbType } from '../models/keys'
+import { SqlDbType } from '../models/keys';
 
 interface IDbTypeAndName {
-  dbType: SqlDbType,
+  dbType: SqlDbType;
   dbName: string;
 }
 
-const SPLIT_CONST = "_________"
+const SPLIT_CONST = '_________';
+
+const PREFIX_MYSQL = `${SqlDbType.mysql}${SPLIT_CONST}`;
+const PREFIX_POSTGRES = `${SqlDbType.postgres}${SPLIT_CONST}`;
+const PREFIX_SQLSERVER = `${SqlDbType.sqlserver}${SPLIT_CONST}`;
 
 function parseDatabaseName(databaseName: string): IDbTypeAndName {
   const dbNameArr = databaseName.split(SPLIT_CONST);
+
+  if (databaseName.startsWith(PREFIX_MYSQL)) {
+    return {
+      dbType: SqlDbType.mysql,
+      dbName: dbNameArr[1],
+    };
+  }
+
+  if (databaseName.startsWith(PREFIX_POSTGRES)) {
+    return {
+      dbType: SqlDbType.postgres,
+      dbName: dbNameArr[1],
+    };
+  }
+
+  if (databaseName.startsWith(PREFIX_SQLSERVER)) {
+    return {
+      dbType: SqlDbType.sqlserver,
+      dbName: dbNameArr[1],
+    };
+  }
+
   if (dbNameArr.length === 1) {
     return {
       dbType: SqlDbType.mysql, // 默认
-      dbName: dbNameArr[0]
-    }
+      dbName: dbNameArr[0],
+    };
   }
 
   if (dbNameArr.length > 1) {
@@ -21,20 +47,14 @@ function parseDatabaseName(databaseName: string): IDbTypeAndName {
     const dbType = dbType0 as any;
     return {
       dbType,
-      dbName
-    }
+      dbName,
+    };
   }
   return null;
 }
 
-
 function toDatabaseNameStr(dbType: SqlDbType, dbName: string): string {
-  return [dbType, dbName].join(SPLIT_CONST)
+  return [dbType, dbName].join(SPLIT_CONST);
 }
 
-
-export {
-  SPLIT_CONST,
-  parseDatabaseName,
-  toDatabaseNameStr
-}
+export { SPLIT_CONST, parseDatabaseName, toDatabaseNameStr };

package/src/libs/global-config/global-config.ts

@@ -20,9 +20,19 @@ interface IGlobalStaticConfig {
   bizUpdateCfgModelForCrudMtd(reqJson: any, cfgModel: any, methodInfo: any, ctx: any): Promise<any>;
 
 
+
+  /**
+   * CrudPro: 业务系统自定义的修改cfgModel。这是最底层的！！全局的！！全局的！！全局的！！！
+   * @param reqJson
+   * @param cfgModel
+   */
+  bizUpdateCfgModelForCrudPro(reqJson: any, cfgModel: any): Promise<any>;
+
+
+
   /**
    * 生成用户的账号ID，业务系统可以生成类似工号的ID
-   * @param userSubmitData 
+   * @param userSubmitData
    */
   generateUserAccountId(userSubmitData: any): Promise<string>;
 
@@ -47,6 +57,7 @@ class GlobalStaticConfig {
     this.configObject = {
       bizUpdateCfgModelForCrudStd: noop,
       bizUpdateCfgModelForCrudMtd: noop,
+      bizUpdateCfgModelForCrudPro: noop,
       generateUserAccountId: null,
       toFatcmsUserAccountId: (bizTableUserId: any) => {
         return bizTableUserId;

package/src/models/AsyncTaskModel.ts

@@ -4,16 +4,16 @@ export interface SysAsyncTaskEntity {
   task_name: string;
   task_description: string | null;
   task_type: string;
-  task_status: TaskStatus;
+  task_status: SysAsyncTaskStatus;
   input_params: any;
   output_result: any | null;
 
   input_file_path: string | null;
-  input_file_format: FileFormat | null;
+  input_file_format: SysAsyncFileFormat | null;
   input_file_size: number | null;
 
   output_file_path: string | null;
-  output_file_format: FileFormat | null;
+  output_file_format: SysAsyncFileFormat | null;
   output_file_size: number | null;
 
   input_total_records: number | null;
@@ -26,15 +26,17 @@ export interface SysAsyncTaskEntity {
   priority: number;
   retry_count: number;
   max_retries: number;
+
   parent_task_id: number | null;
   created_at: Date;
   started_at: Date | null;
-  completed_at: Date | null;
   updated_at: Date;
   expired_at: Date | null;
+  completed_at: Date | null;
+  created_user_session: string;
 }
 
-export enum TaskStatus {
+export enum SysAsyncTaskStatus {
   PENDING = 'PENDING', // 等待中，还未进入排队
   RUNNING = 'RUNNING', // 运行中
   SUCCEEDED = 'SUCCEEDED',
@@ -43,7 +45,7 @@ export enum TaskStatus {
   PAUSED = 'PAUSED', // 暂停
 }
 
-export enum FileFormat {
+export enum SysAsyncFileFormat {
   XLSX = 'xlsx',
   CSV = 'csv',
   JSON = 'json',
@@ -57,17 +59,18 @@ export enum FileFormat {
 }
 
 
-export interface ITaskHandler {
-  execute(ctx: TaskContext): Promise<void>;
+export interface ISysAsyncTaskHandler {
+  execute(asyncTaskContext: SysAsyncTaskContext): Promise<void>;
 }
 
-export interface TaskContext {
+export interface SysAsyncTaskContext {
   task: SysAsyncTaskEntity;
+  updateTaskStatus: ()=>any;
 }
 
-export interface TaskHandlerConfig {
+export interface SysAsyncTaskHandlerConfig {
   taskType: string;
-  handler: ITaskHandler;
+  handler: ISysAsyncTaskHandler;
   maxRetries?: number;
   priority?: number;
   expireSeconds?: number;

package/src/schedule/anonymousContext.ts

@@ -0,0 +1,79 @@
+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;
+
+
+class AnonymousContext {
+  private app: koa.Application;
+
+  setApp(app: koa.Application){
+    this.app = app;
+  }
+
+  getApp(){
+    return this.app;
+  }
+
+
+  async runServiceAtAnonymousContext( runner: RunServiceAtAnonymousContextRunner) {
+    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

@@ -1,73 +1,14 @@
-import * as koa from '@midwayjs/koa';
-import { IScheduleService } from '../interface';
-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 scheduleUserInfo:ISessionInfo = {
-  nickName: 'schedule_user',
-  avatar: '',
-  roleCodes: [],
-  functionCodes: [],
-  loginName: 'schedule_user',
-  sessionId: '',
-  accountId: '',
-  workbenchCode: '',
-  accountType: SYS_ACCOUNT_TYPE,
-};
-
-const scheduleWorkbenchInfo: IWorkbenchEntity = {
-  id: 0,
-  workbench_code: 'schedule_workbench',
-  workbench_name: 'schedule_workbench',
-  workbench_domain: 'schedule_workbench',
-  workbench_desc: 'schedule_workbench',
-  html_content: 'schedule_workbench',
-  status: 1,
-  workbench_type: 0,
-};
-
-async function runScheduleService(app: koa.Application, serviceName: string) {
-  const ctx = app.createAnonymousContext();
-
-  ctx.app = app;
-  ctx.contextLogger = new ContextLogger(ctx as any);
-  ctx.transaction = new Transaction();
-  ctx.userSession = new UserSessionInfo(scheduleUserInfo, true);
-  ctx.workbenchInfo = scheduleWorkbenchInfo;
-
-  try {
-    const serviceObject: IScheduleService = await ctx.requestContext.getAsync(serviceName);
-    if (serviceObject && serviceObject.runBySchedule) {
-      await serviceObject.runBySchedule();
-    } else {
-      ctx.logger.error(`runSchedule error , serviceName = ${serviceName}, 没有找到服务`);
-    }
-  } catch (e) {
-    ctx.logger.error(`runSchedule error , serviceName = ${serviceName}`, e);
-  } finally {
-    await ctx.transaction.releaseTx();
-  }
+import {startScheduleLoop, runScheduleTaskOnce} from './runSchedule'
+import {ANONYMOUS_CONTEXT} from './anonymousContext'
+import {
+  ALL_SCHEDULE_NAMES,
+  SCHEDULE_NAMES,
+} from './scheduleNames'
+
+export {
+  ALL_SCHEDULE_NAMES,
+  SCHEDULE_NAMES,
+  ANONYMOUS_CONTEXT,
+  startScheduleLoop,
+  runScheduleTaskOnce
 }
-
-async function runSchedule(app: koa.Application, serviceList: string[]) {
-  for (let i = 0; i < serviceList.length; i++) {
-    const serviceName = serviceList[i];
-    try {
-      await runScheduleService(app, serviceName);
-    } catch (e) {
-      const ctx = app.createAnonymousContext();
-      ctx.logger.error(`runSchedule error , serviceName = ${serviceName}`, e);
-    }
-  }
-}
-
-async function startSchedule(app: koa.Application, serviceList: string[]) {
-  await runSchedule(app, serviceList);
-  setInterval(() => {
-    runSchedule(app, serviceList);
-  }, 2 * 60 * 1000);
-}
-
-export { startSchedule, runSchedule };

package/src/schedule/runSchedule.ts

@@ -0,0 +1,35 @@
+import * as koa from '@midwayjs/koa';
+import { IScheduleService } from '@/interface';
+import { ANONYMOUS_CONTEXT } from "./anonymousContext";
+
+
+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}, 没有找到服务`);
+    }
+  });
+}
+
+async function runScheduleServiceList(serviceList: string[]) {
+  for (let i = 0; i < serviceList.length; i++) {
+    const serviceName = serviceList[i];
+    try {
+      await runScheduleTaskOnce(serviceName);
+    } catch (e) {
+      ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+    }
+  }
+}
+
+async function startScheduleLoop(serviceList: string[]) {
+  await runScheduleServiceList(serviceList);
+  setInterval(() => {
+    runScheduleServiceList(serviceList);
+  }, 2 * 60 * 1000);
+}
+
+export { startScheduleLoop, runScheduleTaskOnce };

package/src/schedule/scheduleNames.ts

@@ -0,0 +1,20 @@
+
+
+const SCHEDULE_NAMES = {
+  proxyApiLoadService: 'proxyApiLoadService',
+  workbenchService: 'workbenchService',
+  visitStatService: 'visitStatService',
+  asyncTaskRunnerService: 'asyncTaskRunnerService',
+}
+
+const ALL_SCHEDULE_NAMES = [
+  SCHEDULE_NAMES.proxyApiLoadService,
+  SCHEDULE_NAMES.workbenchService,
+  SCHEDULE_NAMES.visitStatService,
+  SCHEDULE_NAMES.asyncTaskRunnerService
+];
+
+export {
+  ALL_SCHEDULE_NAMES,
+  SCHEDULE_NAMES,
+}

package/src/service/asyncTask/AsyncTaskRunnerService.ts

@@ -1,36 +1,47 @@
 import {Inject, Provide} from '@midwayjs/core';
-import {Context} from '@midwayjs/koa';
+import {Context, IMidwayKoaContext} from '@midwayjs/koa';
 import {BaseService} from "@/service/base/BaseService";
 import {IScheduleService} from "@/interface";
 import {CurdProService} from "@/service/curd/CurdProService";
-import {ITaskHandler, SysAsyncTaskEntity, TaskStatus} from "@/models/AsyncTaskModel";
+import {ISysAsyncTaskHandler, SysAsyncTaskEntity, SysAsyncTaskStatus} from "@/models/AsyncTaskModel";
 import {GLOBAL_STATIC_CONFIG} from "@/libs/global-config/global-config";
 import {SystemTables} from "@/models/SystemTables";
 import {KeysOfSimpleSQL} from "@/libs/crud-pro/models/keys";
 import {errorToString} from "@/libs/utils/errorToString";
+import {ANONYMOUS_CONTEXT} from "@/schedule";
 
 
-class AsyncTaskRunner  {
+class AsyncTaskRunner {
   isBusy: boolean = false;
-  taskHandlerMap: Map<string, ITaskHandler> = new Map();
+  taskHandlerMap: Map<string, ISysAsyncTaskHandler> = new Map();
 
   async executeTaskList(taskList: SysAsyncTaskEntity[]) {
     if (!taskList || taskList.length === 0) {
       return;
     }
+
     this.isBusy = true;
 
     for (let i = 0; i < taskList.length; i++) {
       const taskElement = taskList[i];
+
       try {
+        // 任务状态的设置在自定义的执行器里面。
         await this.executeTask(taskElement);
-        taskElement.task_status = TaskStatus.SUCCEEDED;
       } catch (error) {
-        taskElement.task_status = TaskStatus.FAILED;
+        taskElement.task_status = SysAsyncTaskStatus.FAILED;
         taskElement.error_message = errorToString(error)
       }
+
+      try {
+        await this.updateTaskStatus(taskElement);
+      } catch (error) {
+        ANONYMOUS_CONTEXT.getApp().getCoreLogger().error("executeTaskList error", error);
+      }
     }
 
+    this.isBusy = false;
+
   }
 
   private async executeTask(taskElement: SysAsyncTaskEntity) {
@@ -39,18 +50,52 @@ class AsyncTaskRunner  {
     if (!taskHandler) {
       throw new Error('TaskHandler not found , taskType = ' + taskType);
     }
-    await taskHandler.execute({task: taskElement});
+    const updateTaskStatus = () => {
+      return this.updateTaskStatus(taskElement);
+    }
+    await taskHandler.execute({task: taskElement, updateTaskStatus});
+  }
+
+
+  private async updateTaskStatus(taskElement: SysAsyncTaskEntity) {
+    return await ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx: IMidwayKoaContext) => {
+      const curdProService: CurdProService = await ctx.requestContext.getAsync("curdProService");
+      const {SystemDbName, SystemDbType} = GLOBAL_STATIC_CONFIG.getConfig();
+
+      const {id, ...otherTaskProps} = taskElement;
+
+      const res = await curdProService.executeCrudByCfg({
+        condition: {
+          id: id
+        },
+        data: otherTaskProps
+      }, {
+        sqlTable: SystemTables.sys_async_tasks,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+      });
+      return res.getResModel().affected;
+    });
+
+
   }
 }
 
 
-const ASYNC_TASK_RUNNER = new AsyncTaskRunner();
+/**
+ * 业务可以扩展
+ */
+export const ASYNC_TASK_RUNNER = new AsyncTaskRunner();
 
 
+/**
+ * Redis锁
+ */
 const LOCK_KEY_ASYNC_TASK_RUNNER = "LOCK_KEY_ASYNC_TASK_RUNNER"
 
 @Provide()
-export class AsyncTaskRunnerService extends BaseService implements IScheduleService{
+export class AsyncTaskRunnerService extends BaseService implements IScheduleService {
 
   @Inject()
   protected ctx: Context;
@@ -58,31 +103,25 @@ export class AsyncTaskRunnerService extends BaseService implements IScheduleServ
   @Inject()
   private curdProService: CurdProService;
 
-  async runBySchedule () {
-    if (ASYNC_TASK_RUNNER.isBusy) {
-      return Promise.resolve();
-    }
 
-    const lock = await this.redisService.set(LOCK_KEY_ASYNC_TASK_RUNNER, 1,"EX", 3600, "NX");
-    if (lock !== 'OK') {
-      return Promise.resolve();
-    }
+  async fetchPendingTasks(): Promise<void> {
 
-
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const {SystemDbName, SystemDbType} = GLOBAL_STATIC_CONFIG.getConfig();
 
     const queryRes = await this.curdProService.executeCrudByCfg({
       condition: {
-        task_status: TaskStatus.PENDING
+        task_status: SysAsyncTaskStatus.PENDING
       },
+      orderBy: 'id+',
       limit: 10
-    },{
+    }, {
       sqlTable: SystemTables.sys_async_tasks,
       sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
       sqlDatabase: SystemDbName,
       sqlDbType: SystemDbType,
     });
 
+
     const taskList = queryRes.getResRows();
 
     if (taskList.length === 0) {
@@ -98,9 +137,9 @@ export class AsyncTaskRunnerService extends BaseService implements IScheduleServ
         }
       },
       data: {
-        task_status: TaskStatus.RUNNING
+        task_status: SysAsyncTaskStatus.RUNNING
       }
-    },{
+    }, {
       sqlTable: SystemTables.sys_async_tasks,
       sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
       sqlDatabase: SystemDbName,
@@ -108,7 +147,35 @@ export class AsyncTaskRunnerService extends BaseService implements IScheduleServ
     });
 
 
-    ASYNC_TASK_RUNNER.executeTaskList(taskList);
+    ASYNC_TASK_RUNNER.executeTaskList(taskList).then(() => {
+      console.log("ASYNC_TASK_RUNNER finished taskIds ==> " + JSON.stringify(taskIds))
+    })
+
+  }
+
+
+  async runBySchedule() {
+    if (ASYNC_TASK_RUNNER.isBusy) {
+      return Promise.resolve();
+    }
+
+    // 这里的过期时间1分钟即可。fetchPendingTasks函数不可能超过一分钟。
+    // 因为这里只是从数据库中获取一批任务，放到自己的任务队列里。还没触发执行。
+    const lock = await this.redisService.set(LOCK_KEY_ASYNC_TASK_RUNNER, 1, "EX", 60, "NX");
+    if (lock !== 'OK') {
+      return Promise.resolve();
+    }
+
+    try {
+      await this.fetchPendingTasks();
+    } catch (e) {
+      console.error("fetchPendingTasks error", errorToString(e));
+    }
+
+    await this.redisService.del(LOCK_KEY_ASYNC_TASK_RUNNER);
+
     return Promise.resolve();
   }
+
+
 }

package/src/service/asyncTask/AsyncTaskService.ts

@@ -1,7 +1,8 @@
 import {Inject, Provide} from '@midwayjs/core';
 import {Context} from '@midwayjs/koa';
 import {BaseService} from "@/service/base/BaseService";
-import {runSchedule} from "@/schedule";
+import {runScheduleTaskOnce} from "@/schedule";
+import {SCHEDULE_NAMES} from "@/schedule/scheduleNames";
 
 @Provide()
 export class AsyncTaskService extends BaseService {
@@ -9,7 +10,7 @@ export class AsyncTaskService extends BaseService {
   protected ctx: Context;
 
   async startTask() {
-    runSchedule(this.app, ['asyncTaskRunnerService']).then(schedule => {
+    runScheduleTaskOnce(SCHEDULE_NAMES.asyncTaskRunnerService).then(schedule => {
       console.log(schedule);
     })
   }