@chevre/domain 25.2.0-alpha.9 → 26.0.0-alpha.1

package/lib/chevre/service/assetTransaction/reserveCOA/cancel.js

@@ -3,72 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cancelByAcceptAction = cancelByAcceptAction;
 const factory_1 = require("../../../factory");
 const cancelReservation_1 = require("../../reserveCOA/cancelReservation");
-// /**
-//  * 興行オファー承認アクションからCOA予約を取り消す
-//  */
-// function cancel(
-//     params: {
-//         action: factory.action.authorize.offer.eventService.IAction;
-//     },
-//     options: {
-//         /**
-//          * cancelPendingReservation async?(2025-03-03~)
-//          */
-//         asyncCancelPendingReservation: boolean;
-//     }
-// ): ICancelOperation<void> {
-//     return async (repos: {
-//         action: ActionRepo;
-//         reserveService: COA.service.Reserve;
-//         task: TaskRepo;
-//     }) => {
-//         // object.pendingTransactionに連携内容情報が記録されているので、その情報を元に仮予約を取り消す
-//         let delTmpReserveParams: COA.factory.reserve.IDelTmpReserveArgs | undefined;
-//         // objectに進行中取引情報があれば利用する(2023-09-11~)
-//         const pendingTransaction = params.action.object.pendingTransaction;
-//         if (typeof pendingTransaction?.typeOf === 'string') {
-//             delTmpReserveParams = {
-//                 theaterCode: pendingTransaction.theaterCode,
-//                 dateJouei: pendingTransaction.dateJouei,
-//                 titleCode: pendingTransaction.titleCode,
-//                 titleBranchNum: pendingTransaction.titleBranchNum,
-//                 timeBegin: pendingTransaction.timeBegin,
-//                 tmpReserveNum: pendingTransaction.tmpReserveNum
-//             };
-//         }
-//         if (delTmpReserveParams !== undefined) {
-//             const { asyncCancelPendingReservation } = options;
-//             const object: factory.action.cancel.coaReserve.IObject = {
-//                 ...delTmpReserveParams,
-//                 reservationStatus: factory.reservationStatusType.ReservationPending,
-//                 transactionNumber: delTmpReserveParams.tmpReserveNum,
-//                 typeOf: factory.assetTransactionType.COAReserveTransaction
-//             };
-//             const instrument: factory.action.cancel.coaReserve.IPlaceOrderAsInstrument[] = [params.action.purpose];
-//             if (asyncCancelPendingReservation) {
-//                 // support async(2025-03-03~)
-//                 const data: factory.task.cancelPendingReservation.IPotentialCancelCOAReserveAction = { object, instrument };
-//                 const cancelPendingReservationTask: factory.task.cancelPendingReservation.IAttributes = {
-//                     project: { id: params.action.project.id, typeOf: factory.organizationType.Project },
-//                     name: factory.taskName.CancelPendingReservation,
-//                     status: factory.taskStatus.Ready,
-//                     runsAt: new Date(),
-//                     remainingNumberOfTries: 10,
-//                     numberOfTried: 0,
-//                     executionResults: [],
-//                     data
-//                 };
-//                 await repos.task.saveMany([cancelPendingReservationTask], { emitImmediately: true });
-//             } else {
-//                 await cancelPendingReservation({
-//                     project: { id: params.action.project.id },
-//                     object,
-//                     instrument
-//                 })(repos);
-//             }
-//         }
-//     };
-// }
 /**
  * 興行オファー採用アクションからCOA予約を取り消す
  */
@@ -115,7 +49,7 @@ function cancelByAcceptAction(params, options) {
                         executionResults: [],
                         data
                     };
-                    await repos.task.saveMany([cancelPendingReservationTask], { emitImmediately: true });
+                    await repos.task.saveMany([cancelPendingReservationTask]);
                 }
                 else {
                     await (0, cancelReservation_1.cancelPendingReservation)({

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

@@ -0,0 +1,16 @@
+import type { IExecuteSettings as IMinimumExecuteSettings, INextFunction } from '../eventEmitter/task';
+type IExecuteSettings = IMinimumExecuteSettings;
+type IOperation<T> = (settings: IExecuteSettings) => Promise<T>;
+declare function executeAsyncActionById(params: {
+    /**
+     * タスクID
+     */
+    id: string;
+    executor: {
+        /**
+         * タスク実行者名称
+         */
+        name: string;
+    };
+}, next?: INextFunction): IOperation<void>;
+export { executeAsyncActionById };

package/lib/chevre/service/asyncAction.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAsyncActionById = executeAsyncActionById;
+/**
+ * 非同期アクションサービス
+ */
+const debug_1 = __importDefault(require("debug"));
+const asyncActionHandler_1 = require("./asyncActionHandler");
+const debug = (0, debug_1.default)('chevre-domain:service:task');
+function executeAsyncActionById(params, next) {
+    return async (settings) => {
+        const asyncActionRepo = new (await import('../repo/asyncAction.js')).AsyncActionRepo(settings.connection);
+        const { id, executor } = params;
+        let task = null;
+        try {
+            task = await asyncActionRepo.executeAsyncActionById({
+                id,
+                executor: { name: executor.name }
+            });
+        }
+        catch (error) {
+            /* istanbul ignore next */
+            debug('service.asyncAction.executeAsyncActionById error:', error);
+        }
+        // タスクがなければ終了
+        if (task !== null) {
+            await (0, asyncActionHandler_1.executeAsyncAction)(task, (typeof next === 'function') ? next : undefined)(settings, {
+                executeById: true,
+                executeByName: false
+            });
+        }
+    };
+}

package/lib/chevre/service/asyncActionHandler/onOperationFailed.d.ts

@@ -0,0 +1,15 @@
+import type { IExecutedTask } from '../../eventEmitter/task';
+import type { AsyncActionRepo, IExecutableAsyncAction } from '../../repo/asyncAction';
+/**
+ * タスク実行失敗時処理
+ */
+declare function onOperationFailed(params: {
+    task: IExecutableAsyncAction;
+    now: Date;
+    error: any;
+}): (repos: {
+    asyncAction: AsyncActionRepo;
+}) => Promise<{
+    executedTask: IExecutedTask;
+}>;
+export { onOperationFailed };

package/lib/chevre/service/asyncActionHandler/onOperationFailed.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onOperationFailed = onOperationFailed;
+const factory_1 = require("../../factory");
+/**
+ * タスク実行失敗時処理
+ */
+function onOperationFailed(params) {
+    return async (repos) => {
+        let error = params.error;
+        const { task, now } = params;
+        if (error === null || typeof error !== 'object') {
+            error = { message: String(error) };
+        }
+        const endDate = new Date();
+        // 非同期アクションはワンタイムタスクなのでリトライはありえない
+        // ワンタイムタスクは分析連携しない
+        const result = {
+            executedAt: now,
+            endDate,
+            error: {
+                ...error,
+                code: error.code,
+                message: error.message,
+                name: error.name,
+                stack: error.stack
+            }
+        };
+        await repos.asyncAction.setExecutionResultAndStatus({ id: task.id }, {
+            status: factory_1.factory.taskStatus.Aborted,
+            executionResult: result
+        });
+        const executedTask = {
+            id: task.id,
+            remainingNumberOfTries: 0,
+            name: task.name,
+            status: factory_1.factory.taskStatus.Aborted,
+            executionResult: result
+        };
+        return { executedTask };
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { INextFunction } from '../eventEmitter/task';
+import type { ICallResult, ICallableTaskOperation, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
+import type { IExecutableAsyncAction } from '../repo/asyncAction';
+export declare const taskLoader: {
+    load: (taskName: string) => Promise<{
+        call: ICallableTaskOperation;
+    }>;
+};
+/**
+ * 非同期アクションを実行する
+ */
+declare function executeAsyncAction(task: IExecutableAsyncAction, next?: INextFunction): IOperationExecute<void>;
+export { ICallableTaskOperation, ICallResult, IExecutableTaskKeys, IOperationExecute, executeAsyncAction };

package/lib/chevre/service/asyncActionHandler.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskLoader = void 0;
+exports.executeAsyncAction = executeAsyncAction;
+const debug_1 = __importDefault(require("debug"));
+const moment_1 = __importDefault(require("moment"));
+const factory_1 = require("../factory");
+const onOperationFailed_1 = require("./asyncActionHandler/onOperationFailed");
+const debug = (0, debug_1.default)('chevre-domain:service:asyncActionHandler');
+exports.taskLoader = {
+    load: (taskName) => {
+        return import(`./task/${taskName}.js`);
+    }
+};
+/**
+ * 非同期アクションを実行する
+ */
+function executeAsyncAction(task, next) {
+    const now = new Date();
+    debug('executing an executableTask...', task, now);
+    return async (settings, options) => {
+        const asyncActionRepo = new (await import('../repo/asyncAction.js')).AsyncActionRepo(settings.connection);
+        let executedTask;
+        try {
+            // 期限検証(2024-04-23~)
+            if (task.expires instanceof Date) {
+                const taskExpired = (0, moment_1.default)(now)
+                    .isAfter(task.expires);
+                if (taskExpired) {
+                    throw new factory_1.factory.errors.Internal(`task expired [expires:${task.expires}]`);
+                }
+            }
+            // remainingNumberOfTriesは存在しないので検証不要
+            // remainingNumberOfTries<0ならcallを実行しない(2025-08-04~)
+            // タスク名の関数が定義されていなければ、TypeErrorとなる
+            const { call } = await exports.taskLoader.load(task.name); // testが書きづらいのでtaskLoader経由で呼ぶ
+            const callResult = await call({
+                ...task,
+                numberOfTried: 1, // ひとまず固定でok(2026-07-26~)
+                remainingNumberOfTries: 0 // ひとまず固定でok(2026-07-26~)
+            })(settings, options);
+            const result = {
+                executedAt: now,
+                endDate: new Date(),
+                // enable overwriting task.executionResults.error on Executed(2024-05-29~)
+                error: (callResult?.error instanceof Error)
+                    ? {
+                        ...callResult.error,
+                        message: callResult.error.message
+                    }
+                    : ''
+            };
+            await asyncActionRepo.setExecutionResultAndStatus({ id: task.id }, {
+                status: factory_1.factory.taskStatus.Executed,
+                executionResult: result
+            });
+            executedTask = {
+                id: task.id,
+                remainingNumberOfTries: 0, // one timeの前提なのでひとまず固定で0
+                name: task.name,
+                status: factory_1.factory.taskStatus.Executed,
+                executionResult: result
+            };
+        }
+        catch (error) {
+            const onOperationFailedResult = await (0, onOperationFailed_1.onOperationFailed)({
+                task, now, error,
+            })({ asyncAction: asyncActionRepo });
+            executedTask = onOperationFailedResult.executedTask;
+        }
+        finally {
+            if (typeof next === 'function') {
+                if (executedTask === undefined) {
+                    executedTask = {
+                        id: task.id,
+                        remainingNumberOfTries: 0, // one timeの前提なのでひとまず固定で0
+                        name: task.name,
+                        status: factory_1.factory.taskStatus.Aborted,
+                        executionResult: {} // eslint-disable-line @typescript-eslint/no-explicit-any
+                    };
+                }
+                await next(executedTask)(settings);
+            }
+        }
+    };
+}

package/lib/chevre/service/notification/factory.d.ts

@@ -5,11 +5,9 @@ export interface ILineNotifyMessage {
     subject: string;
     content: string;
 }
-export declare function task2lineNotify(params: {
-    task: factory.task.ITask<factory.taskName>;
-}): ILineNotifyMessage;
 export declare function tasks2lineNotify(params: {
-    tasks: factory.task.ITask<factory.taskName>[];
+    tasks: Pick<factory.task.ITask<factory.taskName>, 'id' | 'executionResults' | 'project' | 'name' | 'runsAt'>[];
+    limit: number;
 }): ILineNotifyMessage;
 export declare function createSendEmailMessageRecipe(params: {
     mailData?: MailData;

package/lib/chevre/service/notification/factory.js

@@ -4,37 +4,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ABORT_REPORT_SUBJECT = void 0;
-exports.task2lineNotify = task2lineNotify;
 exports.tasks2lineNotify = tasks2lineNotify;
 exports.createSendEmailMessageRecipe = createSendEmailMessageRecipe;
 const moment_1 = __importDefault(require("moment"));
 const factory_1 = require("../../factory");
 exports.ABORT_REPORT_SUBJECT = 'tasks aborted';
-function task2lineNotify(params) {
-    const task = params.task;
-    const lastExecutionResult = (task.executionResults.length > 0) ? task.executionResults.slice(-1)[0] : undefined;
-    let lastError = lastExecutionResult?.error;
-    if (typeof lastError === 'string') {
-        lastError = { message: lastError, name: 'Error' };
-    }
-    const lastMessage = `${String(lastError?.name)} ${String(lastError?.message)}`;
-    const content = `project:${task.project?.id}
-id:${task.id}
-name:${task.name}
-runsAt:${(0, moment_1.default)(task.runsAt)
-        .toISOString()}
-lastTriedAt:${(0, moment_1.default)(task.lastTriedAt)
-        .toISOString()}
-numberOfTried:${task.numberOfTried}
-lastMessage:${lastMessage}`;
-    return {
-        subject: exports.ABORT_REPORT_SUBJECT,
-        content: content
-    };
-}
+// function task2lineNotify(params: {
+//     task: factory.task.ITask<factory.taskName>;
+// }): ILineNotifyMessage {
+//     const task = params.task;
+//     const lastExecutionResult = (task.executionResults.length > 0) ? task.executionResults.slice(-1)[0] : undefined;
+//     let lastError = lastExecutionResult?.error;
+//     if (typeof lastError === 'string') {
+//         lastError = { message: lastError, name: 'Error' };
+//     }
+//     const lastMessage = `${String(lastError?.name)} ${String(lastError?.message)}`;
+//     const content = `project:${task.project?.id}
+// id:${task.id}
+// name:${task.name}
+// runsAt:${moment(task.runsAt)
+//             .toISOString()}
+// lastTriedAt:${moment((task.lastTriedAt as Date))
+//             .toISOString()}
+// numberOfTried:${task.numberOfTried}
+// lastMessage:${lastMessage}`;
+//     return {
+//         subject: ABORT_REPORT_SUBJECT,
+//         content: content
+//     };
+// }
 const MAX_LAST_MESSAGE_LENGTH = 60;
 function tasks2lineNotify(params) {
-    const subject = `${params.tasks.length} ${exports.ABORT_REPORT_SUBJECT}`;
+    const abortedTasksCount = (params.tasks.length >= params.limit) ? `over ${params.tasks.length}` : params.tasks.length;
+    const subject = `${abortedTasksCount} ${exports.ABORT_REPORT_SUBJECT}`;
     let content;
     // あまりに通知タスク数が多いケースに対応
     if (params.tasks.length > 10) {

package/lib/chevre/service/notification/notifyAbortedTasksByEmail.d.ts

@@ -1,13 +1,19 @@
-import type { TaskRepo } from '../../repo/task';
+import type { AdminTaskRepo } from '../../repo/adminTask';
 import type { IntegrationSettingRepo } from '../../repo/setting/integration';
+interface INotifyAbortedTasksRepos {
+    adminTask: AdminTaskRepo;
+    integrationSetting: IntegrationSettingRepo;
+}
 /**
  * 中止されたタスクリストをEメールで通知する
  * add(2025-03-13~)
  */
 declare function notifyAbortedTasksByEmail(params: {
     dateAbortedGte: Date;
-}): (repos: {
-    task: TaskRepo;
-    integrationSetting: IntegrationSettingRepo;
-}) => Promise<void>;
-export { notifyAbortedTasksByEmail };
+    dateAbortedLte: Date;
+    /**
+     * 中止タスクがあまりに多いと性能に影響するので、現実的にタスク数を制限する
+     */
+    limit: number;
+}): (repos: INotifyAbortedTasksRepos) => Promise<void>;
+export { notifyAbortedTasksByEmail, INotifyAbortedTasksRepos };

package/lib/chevre/service/notification/notifyAbortedTasksByEmail.js

@@ -16,17 +16,25 @@ const debug = (0, debug_1.default)('chevre-domain:service:notification');
 function notifyAbortedTasksByEmail(params) {
     return async (repos) => {
         const abortedTasksWithoutReport = await repos.integrationSetting.getByKey('abortedTasksWithoutReport');
-        const abortedTasks = await repos.task.projectFields({
+        const abortedTasks = await repos.adminTask.findTasks({
+            limit: params.limit,
+            page: 1,
             status: { $eq: factory_1.factory.taskStatus.Aborted },
-            dateAborted: { $gte: params.dateAbortedGte },
+            dateAborted: {
+                $gte: params.dateAbortedGte,
+                $lte: params.dateAbortedLte,
+            },
             // 中止を報告しないタスク以外にフィルター
             ...(abortedTasksWithoutReport.length > 0)
                 ? { name: { $nin: abortedTasksWithoutReport } }
                 : undefined
-        }, []);
+        }, ['executionResults', 'name', 'project', 'runsAt']);
         if (abortedTasks.length > 0) {
             // 開発者へ報告
-            const message = (0, factory_2.tasks2lineNotify)({ tasks: abortedTasks });
+            const message = (0, factory_2.tasks2lineNotify)({
+                tasks: abortedTasks,
+                limit: params.limit
+            });
             const notifyResult = await (0, notifyByEmail_1.notifyByEmail)({
                 subject: message.subject, content: message.content,
                 logLevel: 'error'

package/lib/chevre/service/offer/event/authorize/factory.d.ts

@@ -1,5 +1,4 @@
 import { factory } from '../../../../factory';
-import { IMinimizedIndividualEvent } from '../../../../factory/event';
 declare function createReserveTransactionStartParams(params: {
     project: {
         id: string;
@@ -13,7 +12,6 @@ declare function createReserveTransactionStartParams(params: {
     transactionNumber: string;
 }): factory.assetTransaction.reserve.IStartParamsWithoutDetail;
 declare function createAuthorizeSeatReservationActionAttributes(params: {
-    event: Pick<IMinimizedIndividualEvent, 'id'>;
     instrument: {
         /**
          * 予約取引番号
@@ -21,8 +19,6 @@ declare function createAuthorizeSeatReservationActionAttributes(params: {
         transactionNumber: string;
     };
     transaction: Pick<factory.transaction.ITransaction<factory.transactionType.PlaceOrder>, 'agent' | 'id' | 'project' | 'seller' | 'typeOf'>;
-}, options: {
-    useLegacyAuthorizeOfferObject: boolean;
 }): factory.action.authorize.offer.eventService.IAttributes;
 declare function acceptedOffers2amount(params: {
     acceptedOffers: Pick<IResultAcceptedOffer, 'priceSpecification' | 'id'>[];
@@ -31,7 +27,9 @@ declare function acceptedOffers2authorizeResult(params: {
     acceptedOffers4result: IResultAcceptedOffer[];
     noOfferSpecified: boolean;
     ticketOffers: factory.product.ITicketOffer[];
-}): factory.action.authorize.offer.eventService.IResult;
+}): factory.action.authorize.offer.eventService.IResult & {
+    onlyPrice?: boolean;
+};
 type IObjectSubReservation = factory.assetTransaction.reserve.IObjectSubReservation;
 export type IResultAcceptedOffer = Omit<factory.order.IOptimizedAcceptedOffer, 'priceSpecification'> & {
     itemOffered: factory.order.IEventReservation;