@chevre/domain 21.20.0-alpha.56 → 21.20.0-alpha.57

package/lib/chevre/service/offer/product.d.ts

@@ -4,6 +4,7 @@ import type { MongoRepository as ActionRepo } from '../../repo/action';
 import type { MongoRepository as AssetTransactionRepo } from '../../repo/assetTransaction';
 import type { MongoRepository as OfferRepo } from '../../repo/offer';
 import type { MongoRepository as OfferCatalogRepo } from '../../repo/offerCatalog';
+import type { MongoRepository as OrderInTransactionRepo } from '../../repo/orderInTransaction';
 import type { RedisRepository as OrderNumberRepo } from '../../repo/orderNumber';
 import type { MongoRepository as OwnershipInfoRepo } from '../../repo/ownershipInfo';
 import type { MongoRepository as ProductRepo } from '../../repo/product';
@@ -19,6 +20,7 @@ export interface IAuthorizeOperationRepos {
     assetTransaction: AssetTransactionRepo;
     offer: OfferRepo;
     offerCatalog: OfferCatalogRepo;
+    orderInTransaction: OrderInTransactionRepo;
     orderNumber: OrderNumberRepo;
     ownershipInfo: OwnershipInfoRepo;
     product: ProductRepo;

package/lib/chevre/service/offer/product.js

@@ -16,6 +16,7 @@ const accountTransactionIdentifier_1 = require("../../factory/accountTransaction
 const availableProductTypes_1 = require("../../factory/availableProductTypes");
 const RegisterServiceTransaction = require("../assetTransaction/registerService");
 const placeOrderInProgress_1 = require("../transaction/placeOrderInProgress");
+const any_1 = require("./any");
 const factory_1 = require("./product/factory");
 const searchProductOffers_1 = require("./product/searchProductOffers");
 exports.ERROR_MESSAGE_ALREADY_REGISTERED = 'Already registered';
@@ -121,6 +122,7 @@ function authorize(params) {
         acceptedOffer = yield createServiceOutputIdentifier({ acceptedOffer, product })(repos);
         let requestBody;
         let responseBody;
+        let result;
         // まず取引番号発行
         const { transactionNumber } = yield repos.transactionNumber.publishByTimestamp({
             startDate: new Date()
@@ -134,14 +136,8 @@ function authorize(params) {
         const action = yield repos.action.start(actionAttributes);
         try {
             // 会員の場合のみ排他ロック
-            if (params.agent.typeOf === factory.personType.Person) {
-                // 廃止(2023-12-07~)
-                // await processLockRegisterMembershipService({
-                //     agent: params.agent,
-                //     product: product,
-                //     purpose: { typeOf: transaction.typeOf, id: transaction.id }
-                // })(repos);
-            }
+            // if (params.agent.typeOf === factory.personType.Person) {
+            // }
             // サービス登録開始
             const startParams = (0, factory_1.createRegisterServiceStartParams)({
                 project: { typeOf: factory.organizationType.Project, id: params.project.id },
@@ -151,7 +147,12 @@ function authorize(params) {
             });
             requestBody = startParams;
             responseBody = yield RegisterServiceTransaction.start(startParams)(repos);
-            // responseBody = await repos.registerServiceTransaction.start(startParams);
+            result = (0, factory_1.createResult)({ project: action.project, requestBody, responseBody, acceptedOffer });
+            yield (0, any_1.acceptOffer)({
+                project: transaction.project,
+                purpose: { id: transaction.id },
+                acceptedOffers: result.acceptedOffers
+            })(repos);
         }
         catch (error) {
             try {
@@ -160,21 +161,8 @@ function authorize(params) {
             catch (__) {
                 // no op
             }
-            try {
-                // 廃止(2023-12-07~)
-                // await processUnlockRegisterMembershipService({
-                //     agent: params.agent,
-                //     product: { id: String(product.id) },
-                //     purpose: { typeOf: transaction.typeOf, id: transaction.id }
-                // })(repos);
-            }
-            catch (error) {
-                // 失敗したら仕方ない
-            }
             throw error;
         }
-        // アクションを完了
-        const result = (0, factory_1.createResult)({ project: action.project, requestBody, responseBody, acceptedOffer });
         return yield repos.action.complete({ typeOf: action.typeOf, id: action.id, result: result });
     });
 }

package/lib/chevre/service/order/onAssetTransactionStatusChanged.js

@@ -100,6 +100,23 @@ function onAssetTransactionStatusChanged(params) {
                             }
                         }
                         break;
+                    case factory.assetTransactionType.RegisterService:
+                        if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
+                            const deliverable = yield isDeliverable({
+                                project: { id: params.project.id },
+                                orderNumber,
+                                assetTransactionType: params.object.typeOf
+                            })(repos);
+                            if (deliverable) {
+                                yield processing2inTransit({
+                                    project: { id: params.project.id },
+                                    // confirmationNumber,
+                                    orderNumber,
+                                    useOnOrderStatusChanged: params.useOnOrderStatusChanged
+                                })(repos);
+                            }
+                        }
+                        break;
                     default:
                     // no op
                 }
@@ -235,7 +252,8 @@ function paymentDue2Processing(params) {
             yield (0, onOrderStatusChanged_1.onOrderProcessing)({
                 order: Object.assign(Object.assign({}, order), { acceptedOffers,
                     numAcceptedOffers,
-                    moneyTransferTransactionNumbers, orderStatus: factory.orderStatus.OrderProcessing // 強制的にOrderProcessingとして処理する
+                    moneyTransferTransactionNumbers, itemOfferedTypeOf: itemOfferedTypeOfs[0], // 1つしかない前提
+                    serialNumbers, orderStatus: factory.orderStatus.OrderProcessing // 強制的にOrderProcessingとして処理する
                  }),
                 placeOrderTransaction
             })({
@@ -297,8 +315,10 @@ function isDeliverable(params) {
     return (repos) => __awaiter(this, void 0, void 0, function* () {
         let allReserveTransactionConfirmed = false;
         let allMoneyTransferTransactionConfirmed = false;
+        let allRegisterServiceTransactionConfirmed = false;
         if (params.assetTransactionType === factory.assetTransactionType.Reserve) {
             allMoneyTransferTransactionConfirmed = true;
+            allRegisterServiceTransactionConfirmed = true;
             // 注文のreservationNumberを取得
             const reservationNumbers = yield repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.itemOffered.reservationNumber');
             if (reservationNumbers.length > 0) {
@@ -317,8 +337,9 @@ function isDeliverable(params) {
         }
         else if (params.assetTransactionType === factory.assetTransactionType.MoneyTransfer) {
             allReserveTransactionConfirmed = true;
+            allRegisterServiceTransactionConfirmed = true;
             // 注文のMoneyTransferTransaction.transactionNumberを取得
-            const moneyTransferTransactionNumbers = yield repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.itemOffered.object.pendingTransaction.transactionNumber');
+            const moneyTransferTransactionNumbers = yield repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
             if (moneyTransferTransactionNumbers.length > 0) {
                 debug('is deliverable?...', params.orderNumber, 'moneyTransferTransactionNumbers:', moneyTransferTransactionNumbers);
                 const referencedMoneyTransferTransactions = yield repos.assetTransaction.search({
@@ -334,7 +355,25 @@ function isDeliverable(params) {
                 allMoneyTransferTransactionConfirmed = true;
             }
         }
-        return allReserveTransactionConfirmed && allMoneyTransferTransactionConfirmed;
+        else if (params.assetTransactionType === factory.assetTransactionType.RegisterService) {
+            allReserveTransactionConfirmed = true;
+            allMoneyTransferTransactionConfirmed = true;
+            const registerServiceTransactionNumbers = yield repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
+            if (registerServiceTransactionNumbers.length > 0) {
+                const referencedRegisterServiceTransactions = yield repos.assetTransaction.search({
+                    project: { id: { $eq: params.project.id } },
+                    typeOf: factory.assetTransactionType.RegisterService,
+                    transactionNumber: { $in: registerServiceTransactionNumbers }
+                }, ['status']);
+                allRegisterServiceTransactionConfirmed =
+                    referencedRegisterServiceTransactions.length === registerServiceTransactionNumbers.length
+                        && referencedRegisterServiceTransactions.every(({ status }) => status === factory.transactionStatusType.Confirmed);
+            }
+            else {
+                allRegisterServiceTransactionConfirmed = true;
+            }
+        }
+        return allReserveTransactionConfirmed && allMoneyTransferTransactionConfirmed && allRegisterServiceTransactionConfirmed;
     });
 }
 function processing2inTransit(params) {

package/lib/chevre/service/order/onOrderStatusChanged/onOrderDelivered/factory.js

@@ -50,28 +50,26 @@ function creteOrder4inform(order) {
  */
 function createOnOrderSentTasksByTransaction(params) {
     const potentialActions = params.potentialActions;
-    const now = new Date();
+    // const now = new Date();
     const taskAttributes = [];
-    // tslint:disable-next-line:no-single-line-block-comment
-    /* istanbul ignore else */
     if (potentialActions !== undefined) {
-        if (Array.isArray(potentialActions.registerService)) {
-            taskAttributes.push(...potentialActions.registerService.map((a) => {
-                return {
-                    project: a.project,
-                    name: factory.taskName.ConfirmRegisterService,
-                    status: factory.taskStatus.Ready,
-                    runsAt: now,
-                    remainingNumberOfTries: 10,
-                    numberOfTried: 0,
-                    executionResults: [],
-                    data: a
-                };
-            }));
-        }
+        // サービス登録廃止(2024-01-30~)
+        // if (Array.isArray(potentialActions.registerService)) {
+        //     taskAttributes.push(...potentialActions.registerService.map(
+        //         (a): factory.task.IAttributes<factory.taskName.ConfirmRegisterService> => {
+        //             return {
+        //                 project: a.project,
+        //                 name: factory.taskName.ConfirmRegisterService,
+        //                 status: factory.taskStatus.Ready,
+        //                 runsAt: now, // なるはやで実行
+        //                 remainingNumberOfTries: 10,
+        //                 numberOfTried: 0,
+        //                 executionResults: [],
+        //                 data: a
+        //             };
+        //         }));
+        // }
         // 通貨転送廃止(2024-01-29~)
-        // tslint:disable-next-line:no-single-line-block-comment
-        /* istanbul ignore else */
         // if (Array.isArray(potentialActions.moneyTransfer)) {
         //     taskAttributes.push(...potentialActions.moneyTransfer.map(
         //         (a): factory.task.IAttributes<factory.taskName.ConfirmMoneyTransfer> => {

package/lib/chevre/service/order/onOrderStatusChanged/onOrderProcessing/factory.d.ts

@@ -15,10 +15,5 @@ declare function createConfirmReservationActionObject4COAByOrder(params: {
         acceptedOffers: IAcceptedOffer[];
     };
 }): factory.task.confirmReserveTransaction.IObject4COAOptimized[];
-declare function createConfirmRegisterServiceActionObjectByOrder(params: {
-    order: factory.order.IOrder & {
-        acceptedOffers: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
-    };
-}): factory.action.interact.confirm.registerService.IObject[];
 type IExternalOrder = Pick<factory.order.IOrder, 'project' | 'typeOf' | 'seller' | 'customer' | 'confirmationNumber' | 'orderNumber' | 'price' | 'priceCurrency' | 'orderDate' | 'name' | 'orderStatus' | 'orderedItem' | 'paymentMethods'>;
-export { IAcceptedOffer, IExternalOrder, createInformTasks, createConfirmReservationActionObject4ChevreByOrder, createConfirmReservationActionObject4COAByOrder, createConfirmRegisterServiceActionObjectByOrder };
+export { IAcceptedOffer, IExternalOrder, createInformTasks, createConfirmReservationActionObject4ChevreByOrder, createConfirmReservationActionObject4COAByOrder };

package/lib/chevre/service/order/onOrderStatusChanged/onOrderProcessing/factory.js

@@ -1,7 +1,7 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConfirmRegisterServiceActionObjectByOrder = exports.createConfirmReservationActionObject4COAByOrder = exports.createConfirmReservationActionObject4ChevreByOrder = exports.createInformTasks = void 0;
+exports.createConfirmReservationActionObject4COAByOrder = exports.createConfirmReservationActionObject4ChevreByOrder = exports.createInformTasks = void 0;
 const google_libphonenumber_1 = require("google-libphonenumber");
 const util_1 = require("util");
 const factory = require("../../../../factory");
@@ -167,15 +167,3 @@ function createConfirmReservationActionObject4COAByOrder(params) {
     });
 }
 exports.createConfirmReservationActionObject4COAByOrder = createConfirmReservationActionObject4COAByOrder;
-function createConfirmRegisterServiceActionObjectByOrder(params) {
-    // いったん保留
-    const chevreTransactionNumbers = [];
-    return [...new Set(chevreTransactionNumbers)].map((transactionNumber) => {
-        return {
-            endDate: params.order.orderDate,
-            transactionNumber,
-            typeOf: factory.assetTransactionType.RegisterService
-        };
-    });
-}
-exports.createConfirmRegisterServiceActionObjectByOrder = createConfirmRegisterServiceActionObjectByOrder;

package/lib/chevre/service/order/onOrderStatusChanged/onOrderProcessing.d.ts

@@ -8,6 +8,8 @@ declare function onOrderProcessing(params: {
         acceptedOffers: IAcceptedOffer[];
         numAcceptedOffers: number;
         moneyTransferTransactionNumbers: string[];
+        itemOfferedTypeOf: factory.order.IItemOffered['typeOf'];
+        serialNumbers: string[];
     };
     placeOrderTransaction?: IPlaceOrderTransaction;
 }): (repos: {

package/lib/chevre/service/order/onOrderStatusChanged/onOrderProcessing.js

@@ -45,7 +45,6 @@ function onOrderProcessing(params) {
             case factory.orderStatus.OrderProcessing:
                 tasks = [
                     ...(0, factory_1.createInformTasks)(params.order)
-                    // ...await createConfirmRegisterServiceTransactionTasks(params.order, simpleOrder)(repos) // ひとまず保留
                 ];
                 break;
             default:
@@ -54,9 +53,17 @@ function onOrderProcessing(params) {
         yield repos.task.saveMany(tasks, { emitImmediately: true });
         switch (params.order.orderStatus) {
             case factory.orderStatus.OrderProcessing:
-                // 冗長なconfirmReserveTransactionタスク作成を回避(2023-08-25~)
-                yield createConfirmReserveTransactionTasksIfNotExist(params.order, simpleOrder)(repos);
-                yield createConfirmMoneyTransferTasksIfNotExist(params.order, simpleOrder)(repos);
+                if (params.order.itemOfferedTypeOf === factory.actionType.MoneyTransfer) {
+                    yield createConfirmMoneyTransferTasksIfNotExist(params.order, simpleOrder)(repos);
+                }
+                else if (params.order.itemOfferedTypeOf === factory.reservationType.BusReservation
+                    || params.order.itemOfferedTypeOf === factory.reservationType.EventReservation) {
+                    // 冗長なconfirmReserveTransactionタスク作成を回避(2023-08-25~)
+                    yield createConfirmReserveTransactionTasksIfNotExist(params.order, simpleOrder)(repos);
+                }
+                else if (params.order.itemOfferedTypeOf === factory.permit.PermitType.Permit) {
+                    yield createConfirmRegisterServiceTasksIfNotExist(params.order, simpleOrder)(repos);
+                }
                 yield createGivePointAwardTaskIfNotExist({
                     potentialActions: (_h = (_g = (_f = params.placeOrderTransaction) === null || _f === void 0 ? void 0 : _f.potentialActions) === null || _g === void 0 ? void 0 : _g.order) === null || _h === void 0 ? void 0 : _h.potentialActions
                 })(repos);
@@ -111,7 +118,7 @@ function createConfirmReserveTransactionTasksIfNotExist(order, simpleOrder) {
 function createConfirmMoneyTransferTasksIfNotExist(order, simpleOrder) {
     return (repos) => __awaiter(this, void 0, void 0, function* () {
         const taskRunsAt = new Date();
-        yield Promise.all(order.moneyTransferTransactionNumbers.map((moneyTransferTransactionNumber) => __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(order.serialNumbers.map((moneyTransferTransactionNumber) => __awaiter(this, void 0, void 0, function* () {
             const data = {
                 project: order.project,
                 typeOf: factory.actionType.ConfirmAction,
@@ -124,7 +131,7 @@ function createConfirmMoneyTransferTasksIfNotExist(order, simpleOrder) {
                 purpose: simpleOrder
             };
             const taskIdentifier = util.format('%s:%s:%s:%s:%s:%s', data.project.id, factory.taskName.ConfirmMoneyTransfer, data.purpose.typeOf, simpleOrder.orderNumber, data.object.typeOf, data.object.transactionNumber);
-            const confirmReserveTransactionTask = {
+            const confirmMoneyTransferTransactionTask = {
                 identifier: taskIdentifier,
                 project: order.project,
                 name: factory.taskName.ConfirmMoneyTransfer,
@@ -135,71 +142,41 @@ function createConfirmMoneyTransferTasksIfNotExist(order, simpleOrder) {
                 executionResults: [],
                 data
             };
-            yield repos.task.createIfNotExistByIdentifier(confirmReserveTransactionTask, { emitImmediately: true });
+            yield repos.task.createIfNotExistByIdentifier(confirmMoneyTransferTransactionTask, { emitImmediately: true });
+        })));
+    });
+}
+function createConfirmRegisterServiceTasksIfNotExist(order, simpleOrder) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const taskRunsAt = new Date();
+        yield Promise.all(order.serialNumbers.map((registerServiceTransactionNumber) => __awaiter(this, void 0, void 0, function* () {
+            const data = {
+                project: order.project,
+                typeOf: factory.actionType.ConfirmAction,
+                object: {
+                    endDate: order.orderDate,
+                    transactionNumber: registerServiceTransactionNumber,
+                    typeOf: factory.assetTransactionType.RegisterService
+                },
+                agent: order.project,
+                purpose: simpleOrder
+            };
+            const taskIdentifier = util.format('%s:%s:%s:%s:%s:%s', data.project.id, factory.taskName.ConfirmRegisterService, data.purpose.typeOf, simpleOrder.orderNumber, data.object.typeOf, data.object.transactionNumber);
+            const confirmRegisterServiceTask = {
+                identifier: taskIdentifier,
+                project: order.project,
+                name: factory.taskName.ConfirmRegisterService,
+                status: factory.taskStatus.Ready,
+                runsAt: taskRunsAt,
+                remainingNumberOfTries: 10,
+                numberOfTried: 0,
+                executionResults: [],
+                data
+            };
+            yield repos.task.createIfNotExistByIdentifier(confirmRegisterServiceTask, { emitImmediately: true });
         })));
     });
 }
-// function createConfirmRegisterServiceTransactionTasks(
-//     order: factory.order.IOrder & {
-//         acceptedOffers: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
-//     },
-//     simpleOrder: factory.order.ISimpleOrder
-// ) {
-//     return async (repos: {
-//         task: TaskRepo;
-//     }): Promise<factory.task.IAttributes<factory.taskName.ConfirmRegisterServiceTransaction>[]> => {
-//         const taskRunsAt = new Date();
-//         if (USE_CONFIRM_REGISTER_SERVICE_TRANSACTION) {
-//             const confirmObjects = createConfirmRegisterServiceActionObjectByOrder({ order });
-//             const tasks: factory.task.IAttributes<factory.taskName.ConfirmRegisterServiceTransaction>[] = [];
-//             await Promise.all(confirmObjects.map(async (confirmObject) => {
-//                 // 冗長なタスク作成を回避
-//                 const existingTasks = await repos.task.search(
-//                     {
-//                         limit: 1,
-//                         page: 1,
-//                         project: { id: { $eq: order.project.id } },
-//                         name: factory.taskName.ConfirmReserveTransaction,
-//                         data: {
-//                             object: { transactionNumber: { $eq: confirmObject.transactionNumber } },
-//                             purpose: { orderNumber: { $eq: order.orderNumber } }
-//                         }
-//                     },
-//                     {
-//                         data: 0, executionResults: 0, name: 0, numberOfTried: 0,
-//                         remainingNumberOfTries: 0, runsAt: 0, status: 0
-//                     }
-//                 );
-//                 if (existingTasks.length === 0) {
-//                     const data: factory.task.IData<factory.taskName.ConfirmRegisterServiceTransaction> = {
-//                         project: order.project,
-//                         typeOf: factory.actionType.ConfirmAction,
-//                         object: confirmObject,
-//                         agent: order.project,
-//                         purpose: simpleOrder,
-//                         instrument: {
-//                             typeOf: 'WebAPI',
-//                             identifier: factory.service.webAPI.Identifier.Chevre
-//                         }
-//                     };
-//                     tasks.push({
-//                         project: order.project,
-//                         name: factory.taskName.ConfirmRegisterServiceTransaction,
-//                         status: factory.taskStatus.Ready,
-//                         runsAt: taskRunsAt,
-//                         remainingNumberOfTries: 10,
-//                         numberOfTried: 0,
-//                         executionResults: [],
-//                         data
-//                     });
-//                 }
-//             }));
-//             return tasks;
-//         } else {
-//             return [];
-//         }
-//     };
-// }
 function createGivePointAwardTaskIfNotExist(params) {
     return (repos) => __awaiter(this, void 0, void 0, function* () {
         var _a;

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

@@ -12,6 +12,6 @@ export declare function confirmRegisterServiceTransaction(params: factory.action
     assetTransaction: AssetTransactionRepo;
     task: TaskRepo;
 }) => Promise<void>;
-export declare function onRegistered(__: factory.action.interact.confirm.registerService.IAttributes): (repos: {
+export declare function onRegistered(params: factory.action.interact.confirm.registerService.IAttributes): (repos: {
     task: TaskRepo;
 }) => Promise<void>;

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

@@ -83,17 +83,39 @@ function confirmRegisterServiceTransaction(params) {
     });
 }
 exports.confirmRegisterServiceTransaction = confirmRegisterServiceTransaction;
-function onRegistered(__) {
+function onRegistered(params) {
     return (repos) => __awaiter(this, void 0, void 0, function* () {
         const taskAttributes = [];
-        // 次のメンバーシップ注文タスクを作成
-        // 廃止(2023-08-18~)
-        // const orderProgramMembershipTasks = actionAttributes.potentialActions?.orderProgramMembership;
-        // if (Array.isArray(orderProgramMembershipTasks)) {
-        //     taskAttributes.push(...orderProgramMembershipTasks);
-        // }
         // タスク保管
         yield repos.task.saveMany(taskAttributes, { emitImmediately: true });
+        if (params.purpose.typeOf === factory.order.OrderType.Order) {
+            // タスク冪等作成
+            const onAssetTransactionStatusChangedTaskData = {
+                project: { id: params.project.id, typeOf: factory.organizationType.Project },
+                object: {
+                    typeOf: params.object.typeOf,
+                    transactionNumber: params.object.transactionNumber,
+                    status: factory.transactionStatusType.Confirmed
+                },
+                purpose: {
+                    confirmationNumber: '',
+                    orderNumber: params.purpose.orderNumber,
+                    typeOf: factory.order.OrderType.Order
+                },
+                useOnOrderStatusChanged: true
+            };
+            const onAssetTransactionStatusChangedTask = {
+                project: { id: params.project.id, typeOf: factory.organizationType.Project },
+                name: factory.taskName.OnAssetTransactionStatusChanged,
+                status: factory.taskStatus.Ready,
+                runsAt: new Date(),
+                remainingNumberOfTries: 10,
+                numberOfTried: 0,
+                executionResults: [],
+                data: onAssetTransactionStatusChangedTaskData
+            };
+            yield repos.task.createOnAssetTransactionStatusChangedTaskIfNotExist(onAssetTransactionStatusChangedTask, { emitImmediately: true });
+        }
     });
 }
 exports.onRegistered = onRegistered;

package/lib/chevre/service/transaction/placeOrderInProgress/potentialActions.js

@@ -12,40 +12,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPotentialActions = void 0;
 const givePointAward_1 = require("./potentialActions/givePointAward");
 // import { createMoneyTransferActions } from './potentialActions/moneyTransfer';
-const registerService_1 = require("./potentialActions/registerService");
+// import { createRegisterServiceActions } from './potentialActions/registerService';
 const sendEmailMessage_1 = require("./potentialActions/sendEmailMessage");
-// import { createMaskedCustomer } from '../../../factory/order';
 /**
  * 取引のポストアクションを作成する
  */
 function createPotentialActions(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const registerServiceActions = yield (0, registerService_1.createRegisterServiceActions)(params);
+        // const registerServiceActions = await createRegisterServiceActions(params);
         // 通貨転送アクション
         // const moneyTransferActions = await createMoneyTransferActions(params);
         // ポイントインセンティブに対する承認アクションの分だけ、ポイントインセンティブ付与アクションを作成する
         const givePointAwardActions = yield (0, givePointAward_1.createGivePointAwardActions)(params);
         // 注文配送メール送信設定
         const sendEmailMessageActions = yield (0, sendEmailMessage_1.createSendEmailMessageActions)(params);
-        // const maskedCustomer = createMaskedCustomer(params.order, { noProfile: true });
-        // const simpleOrder: factory.order.ISimpleOrder = {
-        //     typeOf: params.order.typeOf,
-        //     seller: {
-        //         id: params.order.seller.id,
-        //         typeOf: params.order.seller.typeOf,
-        //         name: params.order.seller.name
-        //     },
-        //     // mask
-        //     customer: { typeOf: maskedCustomer.typeOf, id: maskedCustomer.id },
-        //     orderNumber: params.order.orderNumber,
-        //     price: params.order.price,
-        //     priceCurrency: params.order.priceCurrency,
-        //     orderDate: params.order.orderDate
-        // };
         const sendOrderActionAttributes = {
             potentialActions: {
                 // moneyTransfer: moneyTransferActions, // 廃止(2024-01-29~)
-                registerService: registerServiceActions,
+                // registerService: registerServiceActions, // 廃止(2024-01-30~)
                 sendEmailMessage: sendEmailMessageActions
             }
         };

package/package.json

@@ -10,7 +10,7 @@
   ],
   "dependencies": {
     "@aws-sdk/credential-providers": "3.433.0",
-    "@chevre/factory": "4.352.0-alpha.13",
+    "@chevre/factory": "4.352.0-alpha.14",
     "@cinerino/sdk": "5.9.0-alpha.2",
     "@motionpicture/coa-service": "9.3.0-alpha.4",
     "@motionpicture/gmo-service": "5.3.0-alpha.2",
@@ -111,5 +111,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "21.20.0-alpha.56"
+  "version": "21.20.0-alpha.57"
 }