@chevre/domain 25.2.0-alpha.8 → 26.0.0-alpha.0

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

@@ -1,6 +1,6 @@
 import { factory } from '../../factory';
-import type { IOperationExecute } from '../taskHandler';
+import type { ICallResult, IExecutableTaskKeys, IOperationExecute } from '../taskHandler';
 /**
  * タスク実行関数
  */
-export declare function call(data: factory.task.reserve.IData): IOperationExecute<void>;
+export declare function call(params: Pick<factory.task.reserve.ITask, IExecutableTaskKeys>): IOperationExecute<ICallResult>;

package/lib/chevre/service/task/reserve.js

@@ -11,8 +11,9 @@ const confirmReservation_1 = require("../reserve/confirmReservation");
 /**
  * タスク実行関数
  */
-function call(data) {
+function call(params) {
     return async ({ connection }) => {
+        const { data } = params;
         await (0, confirmReservation_1.confirmReservation)({
             // actionAttributesList: data.actionAttributes,
             potentialReserveAction: data, // optimize(2024-07-01~)

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

@@ -1,6 +1,6 @@
-import type { IOperationExecute } from '../taskHandler';
+import type { ICallResult, IExecutableTaskKeys, IOperationExecute } from '../taskHandler';
 import { factory } from '../../factory';
 /**
  * タスク実行関数
  */
-export declare function call(data: factory.task.IData<factory.taskName.ReturnOrder>): IOperationExecute<void>;
+export declare function call(params: Pick<factory.task.ITask<factory.taskName.ReturnOrder>, IExecutableTaskKeys>): IOperationExecute<ICallResult>;

package/lib/chevre/service/task/returnOrder.js

@@ -12,8 +12,9 @@ const returnOrder_2 = require("../order/returnOrder");
 /**
  * タスク実行関数
  */
-function call(data) {
+function call(params) {
     return async ({ connection }) => {
+        const { data } = params;
         await (0, returnOrder_2.returnOrder)({
             ...data,
             useOnOrderStatusChanged: true

package/lib/chevre/service/task/returnPayTransaction.js

@@ -322,6 +322,6 @@ function onRefund(params) {
             });
         }
         // タスク保管
-        await repos.task.saveMany(taskAttributes, { emitImmediately: true });
+        await repos.task.saveMany(taskAttributes);
     };
 }

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

@@ -1,6 +1,6 @@
-import type { IOperationExecute } from '../taskHandler';
+import type { ICallResult, IExecutableTaskKeys, IOperationExecute } from '../taskHandler';
 import { factory } from '../../factory';
 /**
  * タスク実行関数
  */
-export declare function call(data: factory.task.IData<factory.taskName.SendOrder>): IOperationExecute<void>;
+export declare function call(params: Pick<factory.task.ITask<factory.taskName.SendOrder>, IExecutableTaskKeys>): IOperationExecute<ICallResult>;

package/lib/chevre/service/task/sendOrder.js

@@ -13,8 +13,9 @@ const sendOrder_1 = require("../order/sendOrder");
 /**
  * タスク実行関数
  */
-function call(data) {
+function call(params) {
     return async ({ connection }) => {
+        const { data } = params;
         await (0, sendOrder_1.sendOrder)({
             ...data,
             object: {

package/lib/chevre/service/task/voidPayTransaction.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.call = call;
 const accountingReport_1 = require("../../repo/accountingReport");
-// import { ActionRepo } from '../../repo/action';
 const acceptPay_1 = require("../../repo/action/acceptPay");
 const authorizePaymentMethod_1 = require("../../repo/action/authorizePaymentMethod");
 const assetTransaction_1 = require("../../repo/assetTransaction");
@@ -10,8 +9,8 @@ const paymentService_1 = require("../../repo/paymentService");
 const paymentServiceProvider_1 = require("../../repo/paymentServiceProvider");
 const sellerPaymentAccepted_1 = require("../../repo/sellerPaymentAccepted");
 const task_1 = require("../../repo/task");
+const orderInTransaction_1 = require("../../repo/orderInTransaction");
 const placeOrder_1 = require("../../repo/transaction/placeOrder");
-// import { TransactionRepo } from '../../repo/transaction';
 const any_1 = require("../payment/any");
 /**
  * タスク実行関数
@@ -24,7 +23,6 @@ function call(params) {
             sameAs: { id: params.id }
         })({
             accountingReport: new accountingReport_1.AccountingReportRepo(connection),
-            // action: new ActionRepo(connection),
             acceptPayAction: new acceptPay_1.AcceptPayActionRepo(connection),
             authorizePaymentMethodAction: new authorizePaymentMethod_1.AuthorizePaymentMethodActionRepo(connection),
             assetTransaction: new assetTransaction_1.AssetTransactionRepo(connection),
@@ -32,10 +30,8 @@ function call(params) {
             paymentService: new paymentService_1.PaymentServiceRepo(connection),
             paymentServiceProvider: new paymentServiceProvider_1.PaymentServiceProviderRepo(connection),
             task: new task_1.TaskRepo(connection),
+            orderInTransaction: new orderInTransaction_1.OrderInTransactionRepo(connection),
             placeOrder: new placeOrder_1.PlaceOrderRepo(connection)
-            // transaction: new TransactionRepo(connection)
-        }
-        // settings
-        );
+        });
     };
 }

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

@@ -1,6 +1,6 @@
-import type { IOperationExecute } from '../taskHandler';
+import type { ICallResult, IExecutableTaskKeys, IOperationExecute } from '../taskHandler';
 import { factory } from '../../factory';
 /**
  * タスク実行関数
  */
-export declare function call(data: factory.task.voidPayment.IData): IOperationExecute<void>;
+export declare function call(params: Pick<factory.task.voidPayment.ITask, IExecutableTaskKeys>): IOperationExecute<ICallResult>;

package/lib/chevre/service/task/voidPayment.js

@@ -19,8 +19,9 @@ const voidPaymentByTask_1 = require("./payment/voidPaymentByTask");
 /**
  * タスク実行関数
  */
-function call(data) {
+function call(params) {
     return async ({ connection, redisClient }) => {
+        const { data } = params;
         if (redisClient === undefined) {
             throw new factory_1.factory.errors.Argument('settings', 'redisClient required');
         }

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

@@ -3,4 +3,4 @@ import type { ICallResult, IExecutableTaskKeys, IOperationExecute } from '../tas
 /**
  * タスク実行関数
  */
-export declare function call(params: Pick<factory.task.ITask<factory.taskName.VoidReserveTransaction>, IExecutableTaskKeys>): IOperationExecute<ICallResult>;
+export declare function call(params: Pick<factory.task.voidReserveTransaction.ITask, IExecutableTaskKeys>): IOperationExecute<ICallResult>;

package/lib/chevre/service/taskHandler/onOperationFailed/informTaskIfNeeded.js

@@ -90,7 +90,7 @@ function informTaskIfNeeded(params) {
             const informTasks = createInformTasks({ task, setting, executionEndDate });
             debug('informTaskIfNeeded: creating inform tasks...', JSON.stringify(informTasks));
             if (informTasks.length > 0) {
-                await repos.task.saveMany(informTasks, { emitImmediately: true });
+                await repos.task.saveMany(informTasks);
             }
         }
     };

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

@@ -10,7 +10,7 @@ function onOperationFailed(params) {
     return async (repos) => {
         let error = params.error;
         const { task, now, next } = params;
-        if (typeof error !== 'object') {
+        if (error === null || typeof error !== 'object') {
             error = { message: String(error) };
         }
         const endDate = new Date();

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

@@ -1,9 +1,9 @@
 import type { INextFunction } from '../eventEmitter/task';
 import { factory } from '../factory';
-import type { ICallResult, ICallableTaskOperation, ICallableTaskOperationSimple, IExecutableTask, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
+import type { ICallResult, ICallableTaskOperation, IExecutableTask, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
 export declare const taskLoader: {
     load: (taskName: string) => Promise<{
-        call: ICallableTaskOperationSimple | ICallableTaskOperation;
+        call: ICallableTaskOperation;
     }>;
 };
 /**

package/lib/chevre/service/taskHandler.js

@@ -41,44 +41,43 @@ function executeTask(task, next) {
                 throw new factory_1.factory.errors.Internal(`task remainingNumberOfTries < 0 [remainingNumberOfTries:${remainingNumberOfTries}]`);
             }
             // タスク名の関数が定義されていなければ、TypeErrorとなる
-            let callResult;
-            // const { call } = await import(`./task/${task.name}.js`) as {
-            //     call: ICallableTaskOperationSimple | ICallableTaskOperation;
-            // };
             const { call } = await exports.taskLoader.load(task.name); // testが書きづらいのでtaskLoader経由で呼ぶ
-            switch (task.name) {
-                case factory_1.factory.taskName.AcceptCOAOffer:
-                case factory_1.factory.taskName.AggregateOnSystem:
-                case factory_1.factory.taskName.AuthorizePayment:
-                case factory_1.factory.taskName.CancelPendingReservation:
-                case factory_1.factory.taskName.CheckMovieTicket:
-                case factory_1.factory.taskName.CheckResource:
-                case factory_1.factory.taskName.CreateAccountingReport:
-                case factory_1.factory.taskName.HandleNotification:
-                case factory_1.factory.taskName.ImportEventCapacitiesFromCOA:
-                case factory_1.factory.taskName.ImportEventsFromCOA:
-                case factory_1.factory.taskName.ImportOffersFromCOA:
-                case factory_1.factory.taskName.InvalidatePaymentUrl:
-                case factory_1.factory.taskName.OnAuthorizationCreated:
-                case factory_1.factory.taskName.OnResourceDeleted:
-                case factory_1.factory.taskName.Pay:
-                case factory_1.factory.taskName.PublishPaymentUrl:
-                case factory_1.factory.taskName.Refund:
-                case factory_1.factory.taskName.VoidPayTransaction:
-                case factory_1.factory.taskName.VoidReserveTransaction:
-                case factory_1.factory.taskName.ConfirmPayTransaction:
-                case factory_1.factory.taskName.ConfirmReserveTransaction:
-                case factory_1.factory.taskName.ReturnPayTransaction:
-                case factory_1.factory.taskName.ReturnReserveTransaction:
-                case factory_1.factory.taskName.SendEmailMessage:
-                case factory_1.factory.taskName.SyncResourcesFromCOA:
-                case factory_1.factory.taskName.TriggerWebhook:
-                case factory_1.factory.taskName.UseReservation:
-                    callResult = await call(task)(settings, options);
-                    break;
-                default:
-                    await call(task.data)(settings);
-            }
+            const callResult = await call(task)(settings, options);
+            // ICallableTaskOperationSimpleを廃止(2026-07-22~)
+            // let callResult: ICallResult | undefined;
+            // switch (task.name) {
+            //     case factory.taskName.AcceptCOAOffer:
+            //     case factory.taskName.AggregateOnSystem:
+            //     case factory.taskName.AuthorizePayment:
+            //     case factory.taskName.CancelPendingReservation:
+            //     case factory.taskName.CheckMovieTicket:
+            //     case factory.taskName.CheckResource:
+            //     case factory.taskName.CreateAccountingReport:
+            //     case factory.taskName.HandleNotification:
+            //     case factory.taskName.ImportEventCapacitiesFromCOA:
+            //     case factory.taskName.ImportEventsFromCOA:
+            //     case factory.taskName.ImportOffersFromCOA:
+            //     case factory.taskName.InvalidatePaymentUrl:
+            //     case factory.taskName.OnAuthorizationCreated:
+            //     case factory.taskName.OnResourceDeleted:
+            //     case factory.taskName.Pay:
+            //     case factory.taskName.PublishPaymentUrl:
+            //     case factory.taskName.Refund:
+            //     case factory.taskName.VoidPayTransaction:
+            //     case factory.taskName.VoidReserveTransaction:
+            //     case factory.taskName.ConfirmPayTransaction:
+            //     case factory.taskName.ConfirmReserveTransaction:
+            //     case factory.taskName.ReturnPayTransaction:
+            //     case factory.taskName.ReturnReserveTransaction:
+            //     case factory.taskName.SendEmailMessage:
+            //     case factory.taskName.SyncResourcesFromCOA:
+            //     case factory.taskName.TriggerWebhook:
+            //     case factory.taskName.UseReservation:
+            //         callResult = await (call as ICallableTaskOperation)(task)(settings, options);
+            //         break;
+            //     default:
+            //         await (call as ICallableTaskOperationSimple)(task.data)(settings); // TODO discontinue
+            // }
             const result = {
                 executedAt: now,
                 endDate: new Date(),

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

@@ -0,0 +1,15 @@
+import { factory } from '../../../factory';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+type IAuthorizeOfferAction = factory.action.authorize.offer.eventService.IAction;
+type IAuthorizePaymentAction = factory.action.authorize.paymentMethod.any.IAction;
+export declare function deletePayTransactionsByPlaceOrder(params: {
+    authorizeActions: (IAuthorizeOfferAction | IAuthorizePaymentAction)[];
+    transaction: Pick<factory.transaction.placeOrder.ITransaction, 'project'>;
+}): (repos: {
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<{
+    deletePayTransactionResult: any;
+    deleteRefundResult: any;
+    payTransactionNumbers: string[];
+}>;
+export {};

package/lib/chevre/service/transaction/deleteTransaction/deletePayTransactionsByPlaceOrder.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletePayTransactionsByPlaceOrder = deletePayTransactionsByPlaceOrder;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const factory_1 = require("../../../factory");
+function deletePayTransactionsByPlaceOrder(params) {
+    return async (repos) => {
+        let deletePayTransactionResult;
+        let deleteRefundResult;
+        const authorizeActions = params.authorizeActions;
+        // 決済取引番号を抽出
+        const authorizePaymentActions = authorizeActions
+            .filter((a) => {
+            return a.object.typeOf === factory_1.factory.action.authorize.paymentMethod.any.ResultType.Payment
+                && typeof a.object?.paymentMethodId === 'string'
+                && a.object.paymentMethodId.length > 0;
+        });
+        const payTransactionNumbers = authorizePaymentActions.map((a) => String(a.object.paymentMethodId));
+        if (payTransactionNumbers.length > 0) {
+            // 決済取引を削除(プロジェクトでも絞ること)(2022-06-07~)
+            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
+                project: { id: params.transaction.project.id },
+                transactionNumbers: payTransactionNumbers,
+                typeOf: factory_1.factory.assetTransactionType.Pay
+            });
+            deletePayTransactionResult = {
+                n: deleteAssetTransactionsResult?.n,
+                ok: deleteAssetTransactionsResult?.ok,
+                deletedCount: deleteAssetTransactionsResult?.deletedCount
+            };
+            // 返金取引も削除(2023-05-19~)
+            const refundTransactions = await repos.assetTransaction.search({
+                typeOf: factory_1.factory.assetTransactionType.Refund,
+                object: { paymentMethodId: { $in: payTransactionNumbers } }
+            }, ['transactionNumber'], []);
+            if (refundTransactions.length > 0) {
+                const deleteRefundAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
+                    project: { id: params.transaction.project.id },
+                    transactionNumbers: refundTransactions.map(({ transactionNumber }) => transactionNumber),
+                    typeOf: factory_1.factory.assetTransactionType.Refund
+                });
+                deleteRefundResult = {
+                    n: deleteRefundAssetTransactionsResult?.n,
+                    ok: deleteRefundAssetTransactionsResult?.ok,
+                    deletedCount: deleteRefundAssetTransactionsResult?.deletedCount
+                };
+            }
+        }
+        return { deletePayTransactionResult, deleteRefundResult, payTransactionNumbers };
+    };
+}

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

@@ -0,0 +1,23 @@
+import { factory } from '../../../factory';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { ReservationRepo } from '../../../repo/reservation';
+type IAuthorizeOfferAction = factory.action.authorize.offer.eventService.IAction;
+type IAuthorizePaymentAction = factory.action.authorize.paymentMethod.any.IAction;
+interface IDeleteResult {
+    n?: number;
+    ok?: number;
+    deletedCount?: number;
+}
+export declare function deleteReservationsByPlaceOrder(params: {
+    authorizeActions: (IAuthorizeOfferAction | IAuthorizePaymentAction)[];
+    transaction: Pick<factory.transaction.placeOrder.ITransaction, 'project'>;
+}): (repos: {
+    assetTransaction: AssetTransactionRepo;
+    reservation: ReservationRepo;
+}) => Promise<{
+    deleteResult?: IDeleteResult;
+    deleteReserveTransactionResult?: IDeleteResult;
+    deleteCancelReservationTransactionResult?: IDeleteResult;
+    reserveTransactionNumbers: string[];
+}>;
+export {};

package/lib/chevre/service/transaction/deleteTransaction/deleteReservationsByPlaceOrder.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteReservationsByPlaceOrder = deleteReservationsByPlaceOrder;
+const factory_1 = require("../../../factory");
+function deleteReservationsByPlaceOrder(params) {
+    return async (repos) => {
+        let deleteResult;
+        let deleteReserveTransactionResult;
+        let deleteCancelReservationTransactionResult;
+        const authorizeActions = params.authorizeActions;
+        // 予約取引番号を抽出
+        const authorizeReservationOfferActions = authorizeActions
+            .filter((a) => {
+            return a.object.typeOf === factory_1.factory.action.authorize.offer.eventService.ObjectType.SeatReservation
+                && a.instrument?.transactionNumber === 'string'
+                && a.instrument.transactionNumber.length > 0;
+        });
+        const reserveTransactionNumbers = authorizeReservationOfferActions
+            .map((a) => String(a.instrument?.transactionNumber));
+        if (reserveTransactionNumbers.length > 0) {
+            // 該当予約番号の予約を削除する(プロジェクトでも絞ること)
+            const deleteReservationsResult = await repos.reservation.deleteByReservationNumbers({
+                project: { id: params.transaction.project.id },
+                reservationNumbers: reserveTransactionNumbers
+            });
+            deleteResult = {
+                n: deleteReservationsResult?.n,
+                ok: deleteReservationsResult?.ok,
+                deletedCount: deleteReservationsResult?.deletedCount
+            };
+            // 予約取引を削除(プロジェクトでも絞ること)(2022-06-07~)
+            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
+                project: { id: params.transaction.project.id },
+                transactionNumbers: reserveTransactionNumbers,
+                typeOf: factory_1.factory.assetTransactionType.Reserve
+            });
+            deleteReserveTransactionResult = {
+                n: deleteAssetTransactionsResult?.n,
+                ok: deleteAssetTransactionsResult?.ok,
+                deletedCount: deleteAssetTransactionsResult?.deletedCount
+            };
+            // 予約番号で予約取消取引を検索
+            const deletingCancelReservationTransactions = await repos.assetTransaction.search({
+                project: { id: { $eq: params.transaction.project.id } },
+                object: { reservationNumber: { $in: reserveTransactionNumbers } },
+                typeOf: factory_1.factory.assetTransactionType.CancelReservation
+            }, ['transactionNumber'], []);
+            if (deletingCancelReservationTransactions.length > 0) {
+                // 予約取消取引も削除(2024-04-18~)
+                const deleteCancelReservationResult = await repos.assetTransaction.deleteByTransactionNumber({
+                    project: { id: params.transaction.project.id },
+                    transactionNumbers: deletingCancelReservationTransactions.map(({ transactionNumber }) => String(transactionNumber)),
+                    typeOf: factory_1.factory.assetTransactionType.CancelReservation
+                });
+                deleteCancelReservationTransactionResult = {
+                    n: deleteCancelReservationResult?.n,
+                    ok: deleteCancelReservationResult?.ok,
+                    deletedCount: deleteCancelReservationResult?.deletedCount
+                };
+            }
+        }
+        return { deleteResult, deleteReserveTransactionResult, deleteCancelReservationTransactionResult, reserveTransactionNumbers };
+    };
+}

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

@@ -25,5 +25,5 @@ interface IDeleteTransactionRepos {
  * 取引に関わるリソースを削除する
  * 冪等性を確保すること
  */
-export declare function deleteTransaction(params: factory.task.IData<factory.taskName.DeleteTransaction>): (repos: IDeleteTransactionRepos) => Promise<void>;
+export declare function deleteTransaction(params: factory.task.deleteTransaction.IData): (repos: IDeleteTransactionRepos) => Promise<void>;
 export {};