@chevre/domain 22.9.0-alpha.54 → 22.9.0-alpha.56

package/example/src/chevre/{aggregateAllEvents2.ts → executeTaskIfExists.ts}

@@ -1,13 +1,10 @@
 // tslint:disable:no-console
-/**
- * イベント集計タスク実行
- */
 import { chevre } from '../../../lib/index';
 
 import * as mongoose from 'mongoose';
 import * as redis from 'redis';
 
-export async function aggregateScreeningEvent() {
+export async function executeTaskIfExists() {
     const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
         socket: {
             port: Number(<string>process.env.REDIS_PORT),
@@ -21,8 +18,8 @@ export async function aggregateScreeningEvent() {
 
     let count = 0;
 
-    const MAX_NUBMER_OF_PARALLEL_TASKS = 10;
-    const INTERVAL_MILLISECONDS = 100;
+    const MAX_NUBMER_OF_PARALLEL_TASKS = 1;
+    const INTERVAL_MILLISECONDS = 1000;
 
     setInterval(
         async () => {
@@ -34,9 +31,21 @@ export async function aggregateScreeningEvent() {
 
             try {
                 console.log('executing...', count);
-                await (await chevre.service.task.createService()).executeByName({
-                    name: chevre.factory.taskName.AggregateScreeningEvent,
-                    executor: { name: 'sample' }
+                await (await chevre.service.task.createService()).executeOneIfExists({
+                    // name: chevre.factory.taskName.AggregateScreeningEvent,
+                    executor: { name: 'sample' },
+                    runsAt: { $lt: new Date() },
+                    name: {
+                        $nin: [
+                            chevre.factory.taskName.DeleteTransaction,
+                            chevre.factory.taskName.ImportEventCapacitiesFromCOA,
+                            chevre.factory.taskName.ImportEventsFromCOA,
+                            chevre.factory.taskName.AcceptCOAOffer,
+                            chevre.factory.taskName.CheckMovieTicket,
+                            chevre.factory.taskName.AuthorizePayment,
+                            chevre.factory.taskName.PublishPaymentUrl
+                        ]
+                    }
                 })({
                     connection: mongoose.connection,
                     redisClient,
@@ -64,7 +73,7 @@ export async function aggregateScreeningEvent() {
     );
 }
 
-aggregateScreeningEvent()
+executeTaskIfExists()
     .then(() => {
         console.log('success!');
     })

package/example/src/chevre/transaction/startExportTasks.ts

@@ -8,9 +8,10 @@ async function main() {
 
     const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
     const result = await transactionRepo.startExportTasks({
-        typeOf: { $in: [chevre.factory.transactionType.PlaceOrder] },
-        status: chevre.factory.transactionStatusType.Confirmed,
-        tasksExportAction: { agent: { name: 'xxx' } }
+        // typeOf: { $in: [chevre.factory.transactionType.PlaceOrder] },
+        status: { $eq: chevre.factory.transactionStatusType.Confirmed },
+        tasksExportAction: { agent: { name: 'xxx' } },
+        endDate: { $lt: new Date() }
     });
     console.log(result);
 }

package/lib/chevre/repo/mongoose/schemas/task.js

@@ -9,16 +9,13 @@ const modelName = 'Task';
 exports.modelName = modelName;
 const schemaDefinition = {
     identifier: String,
-    project: {
-        type: mongoose_1.SchemaTypes.Mixed,
-        required: true
-    },
-    name: String,
-    status: String,
-    runsAt: Date,
-    remainingNumberOfTries: Number,
+    project: { type: mongoose_1.SchemaTypes.Mixed, required: true },
+    name: { type: String, required: true },
+    status: { type: String, required: true },
+    runsAt: { type: Date, required: true },
+    remainingNumberOfTries: { type: Number, required: true },
+    numberOfTried: { type: Number, required: true },
     lastTriedAt: Date,
-    numberOfTried: Number,
     executionResults: [mongoose_1.SchemaTypes.Mixed],
     executor: mongoose_1.SchemaTypes.Mixed,
     data: mongoose_1.SchemaTypes.Mixed,

package/lib/chevre/repo/task.d.ts

@@ -71,12 +71,21 @@ export declare class TaskRepo {
             name: string;
         };
     }): Promise<IExecutableTask<factory.taskName> | null>;
-    executeOneByName<T extends factory.taskName>(params: {
-        name: T;
+    /**
+     * support no name(2025-03-04~)
+     */
+    executeOne(params: {
+        name?: {
+            $eq?: factory.taskName;
+            $nin?: factory.taskName[];
+        };
         executor: {
             name: string;
         };
-    }): Promise<IExecutableTask<T> | null>;
+        runsAt: {
+            $lt: Date;
+        };
+    }): Promise<IExecutableTask<factory.taskName> | null>;
     /**
      * emit OnTaskStatusChanged on delayed tasks
      */

package/lib/chevre/repo/task.js

@@ -395,8 +395,15 @@ class TaskRepo {
             return doc;
         });
     }
-    executeOneByName(params) {
+    /**
+     * support no name(2025-03-04~)
+     */
+    executeOne(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!(params.runsAt.$lt instanceof Date)) {
+                throw new factory.errors.Argument('runsAt.$lt', 'must be Date');
+            }
             const projection = {
                 _id: 0,
                 id: { $toString: '$_id' },
@@ -410,11 +417,13 @@ class TaskRepo {
                 runsAt: 1,
                 expires: 1
             };
-            const doc = yield this.taskModel.findOneAndUpdate({
-                status: { $eq: factory.taskStatus.Ready },
-                runsAt: { $lt: new Date() },
-                name: { $eq: params.name }
-            }, {
+            const nameEq = (_a = params.name) === null || _a === void 0 ? void 0 : _a.$eq;
+            const nameNin = (_b = params.name) === null || _b === void 0 ? void 0 : _b.$nin;
+            const doc = yield this.taskModel.findOneAndUpdate(Object.assign({ status: { $eq: factory.taskStatus.Ready }, runsAt: { $lt: params.runsAt.$lt } }, (typeof nameEq === 'string' || Array.isArray(nameNin))
+                ? {
+                    name: Object.assign(Object.assign({}, (typeof nameEq === 'string') ? { $eq: nameEq } : undefined), (Array.isArray(nameNin)) ? { $nin: nameNin } : undefined)
+                }
+                : undefined), {
                 $set: {
                     status: factory.taskStatus.Running, // 実行中に変更
                     lastTriedAt: new Date(),

package/lib/chevre/repo/transaction.d.ts

@@ -110,18 +110,20 @@ export declare class TransactionRepo {
     /**
      * タスク未エクスポートの取引をひとつ取得してエクスポートを開始する
      */
-    startExportTasks<T extends factory.transactionType>(params: {
-        typeOf?: {
-            $in: T[];
+    startExportTasks(params: {
+        status?: {
+            $eq?: factory.transactionStatusType;
         };
-        status: factory.transactionStatusType;
         id?: string;
         tasksExportAction: {
             agent: {
                 name: string;
             };
         };
-    }): Promise<Pick<factory.transaction.ITransaction<T>, 'id' | 'typeOf'> | null>;
+        endDate: {
+            $lt: Date;
+        };
+    }): Promise<Pick<factory.transaction.ITransaction<factory.transactionType>, 'id' | 'typeOf'> | null>;
     reexportTasksByExportAction(params: {
         intervalInMinutes: number;
     }): Promise<void>;

package/lib/chevre/repo/transaction.js

@@ -553,25 +553,41 @@ class TransactionRepo {
      */
     startExportTasks(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            switch (params.status) {
-                case factory.transactionStatusType.InProgress:
-                    throw new factory.errors.NotImplemented(`status "${params.status}" not implemented on startExportTasks`);
-                default:
-                // no op
+            var _a, _b;
+            const statusEq = (_a = params.status) === null || _a === void 0 ? void 0 : _a.$eq;
+            const endDateLt = (_b = params.endDate) === null || _b === void 0 ? void 0 : _b.$lt;
+            if (typeof statusEq === 'string') {
+                switch (statusEq) {
+                    case factory.transactionStatusType.InProgress:
+                        throw new factory.errors.NotImplemented(`status "${params.status}" not implemented on startExportTasks`);
+                    default:
+                    // no op
+                }
             }
-            const typeOfIn = (_a = params.typeOf) === null || _a === void 0 ? void 0 : _a.$in;
-            return this.transactionModel.findOneAndUpdate(Object.assign(Object.assign(Object.assign({}, (Array.isArray(typeOfIn)) ? { typeOf: { $in: typeOfIn } } : undefined), { status: { $eq: params.status }, 
-                // remove dependency on tasksExportationStatus(2024-06-17~)
-                // tasksExportationStatus: { $eq: factory.transactionTasksExportationStatus.Unexported },
-                'tasksExportAction.actionStatus': {
+            if (!(endDateLt instanceof Date)) {
+                throw new factory.errors.Argument('endDate.$lt', 'must be Date');
+            }
+            // const typeOfIn = params.typeOf?.$in;
+            const sort = {
+                startDate: factory.sortType.Ascending
+            };
+            return this.transactionModel.findOneAndUpdate(Object.assign({ 
+                // ...(Array.isArray(typeOfIn)) ? { typeOf: { $in: typeOfIn } } : undefined,
+                status: Object.assign({}, (typeof statusEq === 'string')
+                    ? { $eq: statusEq }
+                    : {
+                        $in: [
+                            factory.transactionStatusType.Canceled,
+                            factory.transactionStatusType.Confirmed,
+                            factory.transactionStatusType.Expired
+                        ]
+                    }), 'tasksExportAction.actionStatus': {
                     $exists: true,
                     $eq: factory.actionStatusType.PotentialActionStatus
-                } }), (typeof params.id === 'string') ? { _id: { $eq: params.id } } : undefined), {
+                }, endDate: { $exists: true, $lt: endDateLt } }, (typeof params.id === 'string') ? { _id: { $eq: params.id } } : undefined), {
                 'tasksExportAction.actionStatus': factory.actionStatusType.ActiveActionStatus,
                 'tasksExportAction.agent': { name: params.tasksExportAction.agent.name },
                 'tasksExportAction.startDate': new Date()
-                // tasksExportationStatus: factory.transactionTasksExportationStatus.Exporting // discontinue(2024-06-20~)
             }, {
                 new: true,
                 projection: {
@@ -581,6 +597,7 @@ class TransactionRepo {
                     typeOf: 1
                 }
             })
+                .sort(sort)
                 .lean() // 2024-08-26~
                 .exec()
                 // tslint:disable-next-line:no-null-keyword

package/lib/chevre/service/task.d.ts

@@ -47,16 +47,22 @@ declare function executeById(params: {
     };
 }): IOperation<void>;
 /**
- * タスク名でタスクをひとつ実行する
+ * support no name(2025-03-04~)
  */
-declare function executeByName<T extends factory.taskName>(params: {
-    name: T;
+declare function executeOneIfExists(params: {
+    name?: {
+        $eq?: factory.taskName;
+        $nin?: factory.taskName[];
+    };
     executor: {
         /**
          * タスク実行者名称
          */
         name: string;
     };
+    runsAt: {
+        $lt: Date;
+    };
 }): IOperation<void>;
 /**
  * タスクを実行する
@@ -75,4 +81,4 @@ declare function abort(params: {
 declare function notifyAbortedTasks(params: {
     dateAbortedGte: Date;
 }): TaskOperation<void>;
-export { ICallResult, IExecutableTaskKeys, IOperationExecute, executeById, executeByName, execute, abort, notifyAbortedTasks };
+export { ICallResult, IExecutableTaskKeys, IOperationExecute, executeById, executeOneIfExists, execute, abort, notifyAbortedTasks };

package/lib/chevre/service/task.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeById = executeById;
-exports.executeByName = executeByName;
+exports.executeOneIfExists = executeOneIfExists;
 exports.execute = execute;
 exports.abort = abort;
 exports.notifyAbortedTasks = notifyAbortedTasks;
@@ -49,30 +49,29 @@ function executeById(params) {
     });
 }
 /**
- * タスク名でタスクをひとつ実行する
+ * support no name(2025-03-04~)
  */
-function executeByName(params) {
+function executeOneIfExists(params) {
     return (settings) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const taskRepo = new (yield Promise.resolve().then(() => require('../repo/task'))).TaskRepo(settings.connection);
         // 未実行のタスクを取得
         // tslint:disable-next-line:no-null-keyword
         let task = null;
         try {
-            task = yield taskRepo.executeOneByName({
-                name: params.name,
-                executor: { name: params.executor.name }
-            });
+            task = yield taskRepo.executeOne(Object.assign({ executor: { name: params.executor.name }, runsAt: { $lt: params.runsAt.$lt } }, (params.name !== undefined) ? { name: params.name } : undefined));
+            debug('executable task found.', task, params.runsAt.$lt);
         }
         catch (error) {
             // tslint:disable-next-line:no-single-line-block-comment
             /* istanbul ignore next */
-            debug('executeByName error:', error);
+            debug('executeOne error:', error);
         }
         // タスクがなければ終了
         if (task !== null) {
             yield execute(task)(settings, {
                 executeById: false,
-                executeByName: true
+                executeByName: (typeof ((_a = params.name) === null || _a === void 0 ? void 0 : _a.$eq) === 'string')
             });
         }
     });

package/lib/chevre/service/transaction.d.ts

@@ -39,17 +39,13 @@ export type IExportTasksOperation<T> = (repos: {
     task: TaskRepo;
     transaction: TransactionRepo;
 }) => Promise<T>;
-/**
- * ひとつの取引のタスクをエクスポートする
- */
-export declare function exportTasks<T extends factory.transactionType>(params: {
+export declare function exportOneTransactionTasksIfExists(params: {
     /**
      * タスク実行日時バッファ
      */
     runsTasksAfterInSeconds?: number;
-    status: factory.transactionStatusType;
-    typeOf?: {
-        $in: T[];
+    status?: {
+        $eq?: factory.transactionStatusType;
     };
     id?: string;
     tasksExportAction: {
@@ -57,4 +53,7 @@ export declare function exportTasks<T extends factory.transactionType>(params: {
             name: string;
         };
     };
+    endDate: {
+        $lt: Date;
+    };
 }): IExportTasksOperation<void>;

package/lib/chevre/service/transaction.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteTransaction = exports.returnOrder = exports.placeOrder = exports.moneyTransfer = void 0;
 exports.updateAgent = updateAgent;
-exports.exportTasks = exportTasks;
+exports.exportOneTransactionTasksIfExists = exportOneTransactionTasksIfExists;
 /**
  * 取引サービス
  */
@@ -109,16 +109,12 @@ function updateAgent(params) {
         // return newAgent;
     });
 }
-/**
- * ひとつの取引のタスクをエクスポートする
- */
-function exportTasks(params) {
-    return (repos
-    // settings: Settings
-    ) => __awaiter(this, void 0, void 0, function* () {
-        const transaction = yield repos.transaction.startExportTasks(Object.assign(Object.assign({ status: params.status, tasksExportAction: {
+function exportOneTransactionTasksIfExists(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const transaction = yield repos.transaction.startExportTasks(Object.assign(Object.assign({ tasksExportAction: {
                 agent: { name: params.tasksExportAction.agent.name }
-            } }, (params.typeOf !== undefined) ? { typeOf: params.typeOf } : undefined), (typeof params.id === 'string') ? { id: params.id } : undefined));
+            }, endDate: { $lt: params.endDate.$lt } }, (typeof params.id === 'string') ? { id: params.id } : undefined), (typeof ((_a = params.status) === null || _a === void 0 ? void 0 : _a.$eq) === 'string') ? { status: params.status } : undefined));
         if (transaction === null) {
             return;
         }

package/package.json

@@ -112,5 +112,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "22.9.0-alpha.54"
+  "version": "22.9.0-alpha.56"
 }