@chevre/domain 21.18.0-alpha.2 → 21.18.0-alpha.20

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

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onOrderDelivered = void 0;
+/**
+ * 注文ステータス変更時処理
+ */
+const createDebug = require("debug");
+const factory = require("../../../factory");
+const factory_1 = require("./onOrderDelivered/factory");
+const debug = createDebug('chevre-domain:service:order');
+function onOrderDelivered(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        debug('onOrderStatusChanged called.', params.order.orderNumber, params.order.orderStatus, params.order.orderDate);
+        let tasks = [];
+        switch (params.order.orderStatus) {
+            case factory.orderStatus.OrderDelivered:
+                tasks = [
+                    ...(0, factory_1.createInformTasks)(params.order),
+                    // 取引のpotentialActionsを適用(2023-08-17~)
+                    ...(0, factory_1.createOnOrderSentTasksByTransaction)({
+                        potentialActions: (_e = (_d = (_c = (_b = (_a = params.placeOrderTransaction) === null || _a === void 0 ? void 0 : _a.potentialActions) === null || _b === void 0 ? void 0 : _b.order) === null || _c === void 0 ? void 0 : _c.potentialActions) === null || _d === void 0 ? void 0 : _d.sendOrder) === null || _e === void 0 ? void 0 : _e.potentialActions
+                    })
+                ];
+                // プロダクト登録プロセスロック解除
+                try {
+                    const placeOrderTransaction = params.placeOrderTransaction;
+                    if (typeof (placeOrderTransaction === null || placeOrderTransaction === void 0 ? void 0 : placeOrderTransaction.id) === 'string') {
+                        // 廃止(2023-12-07~)
+                        // プロダクト登録プロセスロック解除(orderからproductIdを抽出する)
+                        // const productIds4unlock = params.order.acceptedOffers
+                        //     .filter((o) => o.itemOffered.typeOf === factory.permit.PermitType.Permit
+                        //         && typeof o.itemOffered.issuedThrough?.id === 'string'
+                        //         && o.itemOffered.issuedThrough.id.length > 0)
+                        //     .map((o) => String((<factory.order.IPermit>o.itemOffered).issuedThrough?.id));
+                        // await Promise.all(productIds4unlock.map(async (productId) => {
+                        //     await processUnlockRegisterMembershipService({
+                        //         agent: { id: String(params.order.customer.id) },
+                        //         product: { id: productId },
+                        //         purpose: { typeOf: placeOrderTransaction.typeOf, id: placeOrderTransaction.id }
+                        //     })(repos);
+                        // }));
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+                break;
+            default:
+                throw new factory.errors.NotImplemented(`${params.order.orderStatus} not implemented`);
+        }
+        yield repos.task.saveMany(tasks, { emitImmediately: true });
+    });
+}
+exports.onOrderDelivered = onOrderDelivered;

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

@@ -0,0 +1,10 @@
+import type { MongoRepository as TaskRepo } from '../../../repo/task';
+import * as factory from '../../../factory';
+declare function onOrderPaymentDue(params: {
+    order: Pick<factory.order.IOrder, 'paymentMethods' | 'project' | 'orderNumber' | 'confirmationNumber' | 'customer' | 'orderDate' | 'seller' | 'typeOf' | 'price' | 'priceCurrency'> & {
+        orderStatus: factory.orderStatus.OrderPaymentDue;
+    };
+}): (repos: {
+    task: TaskRepo;
+}) => Promise<void>;
+export { onOrderPaymentDue };

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

@@ -0,0 +1,103 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onOrderPaymentDue = void 0;
+/**
+ * 注文決済時処理
+ */
+const createDebug = require("debug");
+const factory = require("../../../factory");
+const order_1 = require("../../../factory/order");
+const debug = createDebug('chevre-domain:service:order');
+function onOrderPaymentDue(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        debug('onOrderStatusChanged called.', params.order.orderNumber, params.order.orderStatus, params.order.orderDate);
+        let tasks = [];
+        const maskedCustomer = (0, order_1.createMaskedCustomer)(params.order, { noProfile: true });
+        const simpleOrder = {
+            typeOf: params.order.typeOf,
+            seller: {
+                id: params.order.seller.id,
+                typeOf: params.order.seller.typeOf,
+                name: params.order.seller.name
+            },
+            customer: { typeOf: maskedCustomer.typeOf, id: maskedCustomer.id },
+            orderNumber: params.order.orderNumber,
+            price: params.order.price,
+            priceCurrency: params.order.priceCurrency,
+            orderDate: params.order.orderDate
+        };
+        switch (params.order.orderStatus) {
+            // OrderPaymentDueを追加(2023-08-23~)
+            case factory.orderStatus.OrderPaymentDue:
+                tasks = [
+                    ...yield createConfirmPayTransactionTasks(params.order, simpleOrder)(repos)
+                ];
+                break;
+            default:
+                throw new factory.errors.NotImplemented(`${params.order.orderStatus} not implemented`);
+        }
+        yield repos.task.saveMany(tasks, { emitImmediately: true });
+    });
+}
+exports.onOrderPaymentDue = onOrderPaymentDue;
+function createConfirmPayTransactionTasks(order, simpleOrder) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const taskRunsAt = new Date();
+        const tasks = [];
+        yield Promise.all(order.paymentMethods.map((invoice) => __awaiter(this, void 0, void 0, function* () {
+            // PaymentAutomaticallyAppliedであれば、自動決済処理を実行(2023-08-24~)
+            if (invoice.paymentStatus !== factory.paymentStatusType.PaymentAutomaticallyApplied) {
+                return;
+            }
+            // 冗長なタスク作成を回避
+            const existingTasks = yield repos.task.search({
+                limit: 1,
+                page: 1,
+                project: { id: { $eq: order.project.id } },
+                name: factory.taskName.ConfirmPayTransaction,
+                data: {
+                    object: { transactionNumber: { $eq: invoice.paymentMethodId } },
+                    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 = {
+                    project: order.project,
+                    typeOf: factory.actionType.ConfirmAction,
+                    object: [{ typeOf: factory.assetTransactionType.Pay, transactionNumber: invoice.paymentMethodId }],
+                    agent: order.project,
+                    purpose: Object.assign(Object.assign({}, simpleOrder), { confirmationNumber: order.confirmationNumber }),
+                    instrument: {
+                        typeOf: 'WebAPI',
+                        identifier: factory.action.authorize.paymentMethod.any.ServiceIdentifier.Chevre
+                    },
+                    processOrder: order.orderStatus === factory.orderStatus.OrderPaymentDue,
+                    useOnOrderStatusChanged: true
+                };
+                tasks.push({
+                    project: order.project,
+                    name: factory.taskName.ConfirmPayTransaction,
+                    status: factory.taskStatus.Ready,
+                    runsAt: taskRunsAt,
+                    remainingNumberOfTries: 10,
+                    numberOfTried: 0,
+                    executionResults: [],
+                    data
+                });
+            }
+        })));
+        return tasks;
+    });
+}

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

@@ -0,0 +1,30 @@
+import * as factory from '../../../../factory';
+type IProcessingOrder = factory.order.IOrder & {
+    acceptedOffers: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
+    orderStatus: factory.orderStatus.OrderProcessing;
+};
+type IOrderWithToken = IProcessingOrder & {
+    token?: string;
+};
+declare function getOrderWithToken(params: {
+    order: IProcessingOrder;
+    expiresIn: number;
+}): Promise<IOrderWithToken>;
+declare function createInformTasks(order: IOrderWithToken): factory.task.IAttributes<factory.taskName.TriggerWebhook>[];
+declare function createConfirmReservationActionObject4ChevreByOrder(params: {
+    order: factory.order.IOrder & {
+        acceptedOffers: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
+    };
+}): factory.action.interact.confirm.reservation.IObject<factory.service.webAPI.Identifier.Chevre>[];
+declare function createConfirmReservationActionObject4COAByOrder(params: {
+    order: factory.order.IOrder & {
+        acceptedOffers: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
+    };
+}): factory.action.interact.confirm.reservation.IObject<factory.service.webAPI.Identifier.COA>[];
+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 { IExternalOrder, getOrderWithToken, createInformTasks, createConfirmReservationActionObject4ChevreByOrder, createConfirmReservationActionObject4COAByOrder, createConfirmRegisterServiceActionObjectByOrder };

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

@@ -0,0 +1,227 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfirmRegisterServiceActionObjectByOrder = exports.createConfirmReservationActionObject4COAByOrder = exports.createConfirmReservationActionObject4ChevreByOrder = exports.createInformTasks = exports.getOrderWithToken = void 0;
+const google_libphonenumber_1 = require("google-libphonenumber");
+const jwt = require("jsonwebtoken");
+const util_1 = require("util");
+const credentials_1 = require("../../../../credentials");
+const factory = require("../../../../factory");
+const order_1 = require("../../../../factory/order");
+const reservedAgentIdentifireNames_1 = require("../../../../factory/reservedAgentIdentifireNames");
+const settings_1 = require("../../../../settings");
+const informOrder = (_a = settings_1.settings.onOrderStatusChanged) === null || _a === void 0 ? void 0 : _a.informOrder;
+function getOrderWithToken(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof credentials_1.credentials.hub.clientId !== 'string') {
+            return params.order;
+        }
+        // 最適化(2023-01-31~)
+        const order4token = {
+            typeOf: params.order.typeOf,
+            orderNumber: params.order.orderNumber
+        };
+        const token = yield new Promise((resolve, reject) => {
+            // 所有権を暗号化する
+            jwt.sign(order4token, credentials_1.credentials.jwt.secret, {
+                audience: [credentials_1.credentials.hub.clientId],
+                issuer: credentials_1.credentials.jwt.issuer,
+                expiresIn: params.expiresIn
+            }, (err, encoded) => {
+                if (err instanceof Error) {
+                    reject(err);
+                }
+                else {
+                    if (typeof encoded !== 'string') {
+                        reject(new factory.errors.ServiceUnavailable('order cannot be signed unexpectedly'));
+                    }
+                    else {
+                        resolve(encoded);
+                    }
+                }
+            });
+        });
+        return Object.assign(Object.assign({}, params.order), { 
+            // 注文トークンを情報付加
+            token });
+    });
+}
+exports.getOrderWithToken = getOrderWithToken;
+const ASTERISK_CHARACTER = '*';
+function createInformTasks(order) {
+    const taskRunsAt = new Date();
+    let informTasks = [];
+    if (Array.isArray(informOrder) && informOrder.length > 0) {
+        const order4inform = creteOrder4inform(order);
+        let recipientId = '';
+        recipientId = order.customer.id;
+        informTasks = informOrder.map((informOrderParams) => {
+            var _a, _b;
+            const informActionAttributes = {
+                agent: order.project,
+                object: order4inform,
+                project: order.project,
+                recipient: {
+                    url: (_a = informOrderParams.recipient) === null || _a === void 0 ? void 0 : _a.url,
+                    id: recipientId,
+                    name: (_b = informOrderParams.recipient) === null || _b === void 0 ? void 0 : _b.name,
+                    typeOf: factory.creativeWorkType.WebApplication
+                },
+                typeOf: factory.actionType.InformAction
+            };
+            return {
+                project: order.project,
+                name: factory.taskName.TriggerWebhook,
+                status: factory.taskStatus.Ready,
+                runsAt: taskRunsAt,
+                remainingNumberOfTries: 10,
+                numberOfTried: 0,
+                executionResults: [],
+                data: informActionAttributes
+            };
+        });
+    }
+    return informTasks;
+}
+exports.createInformTasks = createInformTasks;
+function creteOrder4inform(order) {
+    // 冗長な個人情報をmask
+    return Object.assign(Object.assign({ 
+        // whitelistで作成する(2022-07-19~)
+        project: order.project, typeOf: order.typeOf, seller: order.seller, price: order.price, priceCurrency: order.priceCurrency, confirmationNumber: order.confirmationNumber, orderNumber: order.orderNumber, acceptedOffers: order.acceptedOffers, orderStatus: order.orderStatus, orderDate: order.orderDate, 
+        // mask
+        customer: Object.assign(Object.assign({}, (0, order_1.createMaskedCustomer)(order, { noProfile: false })), { additionalProperty: (Array.isArray(order.customer.additionalProperty)) ? order.customer.additionalProperty : [], 
+            // identifierは必要
+            // 予約後を隠蔽(2022-12-24~)
+            identifier: (Array.isArray(order.customer.identifier))
+                ? order.customer.identifier.filter((p) => {
+                    return !reservedAgentIdentifireNames_1.RESERVED_AGENT_IDENTIFIER_NAMES.includes(p.name);
+                })
+                : [] }), 
+        // paymentMethodsに関してもmask(2022-05-30~)
+        paymentMethods: order.paymentMethods.map((p) => {
+            return Object.assign(Object.assign({}, p), (typeof p.accountId === 'string' && p.accountId.length > 0)
+                ? { accountId: ASTERISK_CHARACTER.repeat(p.accountId.length) }
+                : undefined);
+        }) }, (typeof order.token === 'string') ? { token: order.token } : undefined), (typeof order.id === 'string') ? { id: order.id } : undefined);
+}
+function createConfirmReservationActionObject4ChevreByOrder(params) {
+    const chevreReservationNumbers = params.order.acceptedOffers.filter((o) => {
+        var _a;
+        return (o.itemOffered.typeOf === factory.reservationType.EventReservation
+            || o.itemOffered.typeOf === factory.reservationType.BusReservation)
+            && ((_a = o.offeredThrough) === null || _a === void 0 ? void 0 : _a.identifier) === factory.service.webAPI.Identifier.Chevre;
+    })
+        .map((o) => {
+        return o.itemOffered.reservationNumber;
+    });
+    return [...new Set(chevreReservationNumbers)].map((reservationNumber) => {
+        return {
+            potentialActions: {
+                reserve: {
+                    purpose: {
+                        confirmationNumber: params.order.confirmationNumber,
+                        orderNumber: params.order.orderNumber,
+                        typeOf: factory.order.OrderType.Order
+                    }
+                }
+            },
+            transactionNumber: reservationNumber,
+            typeOf: factory.assetTransactionType.Reserve
+        };
+    });
+}
+exports.createConfirmReservationActionObject4ChevreByOrder = createConfirmReservationActionObject4ChevreByOrder;
+function createConfirmReservationActionObject4COAByOrder(params) {
+    // COA予約のみ
+    const coaReservationOffers = params.order.acceptedOffers.filter((o) => {
+        var _a;
+        return o.itemOffered.typeOf === factory.reservationType.EventReservation
+            && ((_a = o.offeredThrough) === null || _a === void 0 ? void 0 : _a.identifier) === factory.service.webAPI.Identifier.COA;
+    });
+    const coaReservationNumbers = [...new Set(coaReservationOffers
+            .map((o) => {
+            return o.itemOffered.reservationNumber;
+        }))];
+    const customer = params.order.customer;
+    // 電話番号のフォーマットを日本人にリーダブルに調整(COAではこのフォーマットで扱うので)
+    const phoneUtil = google_libphonenumber_1.PhoneNumberUtil.getInstance();
+    const phoneNumber = phoneUtil.parse(customer.telephone, 'JP');
+    let telNum = phoneUtil.format(phoneNumber, google_libphonenumber_1.PhoneNumberFormat.NATIONAL);
+    // COAでは数字のみ受け付けるので数字以外を除去
+    telNum = telNum.replace(/[^\d]/g, '');
+    const mailAddr = customer.email;
+    if (mailAddr === undefined) {
+        throw new factory.errors.Argument('order', 'order.customer.email undefined');
+    }
+    return coaReservationNumbers.map((reservationNumber) => {
+        const coaReservations = coaReservationOffers
+            .filter((o) => o.itemOffered.reservationNumber === reservationNumber)
+            .map((o) => {
+            return o.itemOffered;
+        });
+        const coaReservation = coaReservations[0];
+        const reservationForCOAInfo = coaReservation.reservationFor.coaInfo;
+        if (reservationForCOAInfo === undefined) {
+            throw new factory.errors.NotFound('reservationFor.coaInfo');
+        }
+        const totalPrice = coaReservation.reservedTicket.coaReserveAmount;
+        if (totalPrice === undefined) {
+            throw new factory.errors.NotFound('reservedTicket.coaReserveAmount');
+        }
+        const listTicket = coaReservations.map((r) => {
+            var _a;
+            if (typeof ((_a = r.reservedTicket.coaTicketInfo) === null || _a === void 0 ? void 0 : _a.ticketCode) !== 'string') {
+                throw new factory.errors.NotFound('reservedTicket.coaTicketInfo');
+            }
+            // 冗長な属性を排除(2023-03-20~)
+            const { ticketCode, stdPrice, addPrice, spseatAdd1, spseatAdd2, disPrice, salePrice, mvtkAppPrice, ticketCount, spseatKbn, seatNum, addGlasses, kbnEisyahousiki, mvtkNum, mvtkKbnDenshiken, mvtkKbnMaeuriken, mvtkKbnKensyu, mvtkSalesPrice, kbnMgtk } = r.reservedTicket.coaTicketInfo;
+            return {
+                ticketCode, stdPrice, addPrice, spseatAdd1, spseatAdd2,
+                disPrice, salePrice, mvtkAppPrice, ticketCount, spseatKbn,
+                seatNum, addGlasses, kbnEisyahousiki, mvtkNum, mvtkKbnDenshiken,
+                mvtkKbnMaeuriken, mvtkKbnKensyu, mvtkSalesPrice, kbnMgtk
+            };
+        });
+        return {
+            theaterCode: reservationForCOAInfo.theaterCode,
+            dateJouei: reservationForCOAInfo.dateJouei,
+            titleCode: reservationForCOAInfo.titleCode,
+            titleBranchNum: reservationForCOAInfo.titleBranchNum,
+            timeBegin: reservationForCOAInfo.timeBegin,
+            tmpReserveNum: reservationNumber,
+            // tslint:disable-next-line:no-irregular-whitespace
+            reserveName: (0, util_1.format)('%s　%s', customer.familyName, customer.givenName),
+            // tslint:disable-next-line:no-irregular-whitespace
+            reserveNameJkana: (0, util_1.format)('%s　%s', customer.familyName, customer.givenName),
+            telNum: telNum,
+            mailAddr: mailAddr,
+            reserveAmount: totalPrice,
+            listTicket,
+            transactionNumber: reservationNumber,
+            typeOf: 'COAReserveTransaction'
+        };
+    });
+}
+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

@@ -0,0 +1,14 @@
+import type { MongoRepository as TaskRepo } from '../../../repo/task';
+import * as factory from '../../../factory';
+import { IExternalOrder } from './onOrderProcessing/factory';
+type IPlaceOrderTransaction = Pick<factory.transaction.placeOrder.ITransaction, 'id' | 'typeOf' | 'potentialActions'>;
+declare function onOrderProcessing(params: {
+    order: Omit<factory.order.IOrder, 'orderStatus'> & {
+        orderStatus: factory.orderStatus.OrderProcessing;
+        acceptedOffers: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
+    };
+    placeOrderTransaction?: IPlaceOrderTransaction;
+}): (repos: {
+    task: TaskRepo;
+}) => Promise<void>;
+export { IExternalOrder, onOrderProcessing };

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

@@ -0,0 +1,216 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onOrderProcessing = void 0;
+/**
+ * 注文処理時処理
+ */
+const createDebug = require("debug");
+const factory = require("../../../factory");
+const order_1 = require("../../../factory/order");
+const factory_1 = require("./onOrderProcessing/factory");
+const debug = createDebug('chevre-domain:service:order');
+const USE_CONFIRM_REGISTER_SERVICE_TRANSACTION = process.env.USE_CONFIRM_REGISTER_SERVICE_TRANSACTION === '1';
+const TOKEN_EXPIRES_IN = 604800;
+function onOrderProcessing(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        debug('onOrderStatusChanged called.', params.order.orderNumber, params.order.orderStatus, params.order.orderDate);
+        let tasks = [];
+        const maskedCustomer = (0, order_1.createMaskedCustomer)(params.order, { noProfile: true });
+        const simpleOrder = {
+            typeOf: params.order.typeOf,
+            seller: {
+                id: params.order.seller.id,
+                typeOf: params.order.seller.typeOf,
+                name: params.order.seller.name
+            },
+            customer: { typeOf: maskedCustomer.typeOf, id: maskedCustomer.id },
+            orderNumber: params.order.orderNumber,
+            price: params.order.price,
+            priceCurrency: params.order.priceCurrency,
+            orderDate: params.order.orderDate
+        };
+        switch (params.order.orderStatus) {
+            case factory.orderStatus.OrderProcessing:
+                const orderWithToken = yield (0, factory_1.getOrderWithToken)({ order: params.order, expiresIn: TOKEN_EXPIRES_IN });
+                tasks = [
+                    ...(0, factory_1.createInformTasks)(orderWithToken),
+                    ...yield createConfirmRegisterServiceTransactionTasks(params.order, simpleOrder)(repos)
+                ];
+                break;
+            default:
+                throw new factory.errors.NotImplemented(`${params.order.orderStatus} not implemented`);
+        }
+        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);
+                // 冗長なsendOrderタスク作成を回避(2023-08-25~)
+                yield createSendOrderTransactionTaskIfNotExist({
+                    object: params.order,
+                    potentialActions: (_c = (_b = (_a = params.placeOrderTransaction) === null || _a === void 0 ? void 0 : _a.potentialActions) === null || _b === void 0 ? void 0 : _b.order) === null || _c === void 0 ? void 0 : _c.potentialActions
+                })(repos);
+                yield createGivePointAwardTaskIfNotExist({
+                    potentialActions: (_f = (_e = (_d = params.placeOrderTransaction) === null || _d === void 0 ? void 0 : _d.potentialActions) === null || _e === void 0 ? void 0 : _e.order) === null || _f === void 0 ? void 0 : _f.potentialActions
+                })(repos);
+                break;
+            default:
+        }
+    });
+}
+exports.onOrderProcessing = onOrderProcessing;
+// const COA_TASK_DELAY_IN_SECONDS = 0;
+function createConfirmReserveTransactionTasksIfNotExist(order, simpleOrder) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const taskRunsAt = new Date();
+        const taskRunsAt4coa = new Date();
+        // const taskRunsAt4coa = moment(order.orderDate)
+        //     .add(COA_TASK_DELAY_IN_SECONDS, 'seconds')
+        //     .toDate();
+        const confirmObjects = [
+            ...(0, factory_1.createConfirmReservationActionObject4ChevreByOrder)({ order }),
+            ...(0, factory_1.createConfirmReservationActionObject4COAByOrder)({ order })
+        ];
+        yield Promise.all(confirmObjects.map((confirmObject) => __awaiter(this, void 0, void 0, function* () {
+            const data = {
+                project: order.project,
+                typeOf: factory.actionType.ConfirmAction,
+                object: confirmObject,
+                agent: order.project,
+                purpose: simpleOrder,
+                instrument: {
+                    typeOf: 'WebAPI',
+                    identifier: (confirmObject.typeOf === 'COAReserveTransaction')
+                        ? factory.service.webAPI.Identifier.COA
+                        : factory.service.webAPI.Identifier.Chevre
+                }
+            };
+            const confirmReserveTransactionTask = {
+                project: order.project,
+                name: factory.taskName.ConfirmReserveTransaction,
+                status: factory.taskStatus.Ready,
+                runsAt: (confirmObject.typeOf === 'COAReserveTransaction') ? taskRunsAt4coa : taskRunsAt,
+                remainingNumberOfTries: 10,
+                numberOfTried: 0,
+                executionResults: [],
+                data
+            };
+            yield repos.task.createConfirmReserveTransactionTaskIfNotExist(confirmReserveTransactionTask, { emitImmediately: true });
+        })));
+    });
+}
+function createConfirmRegisterServiceTransactionTasks(order, simpleOrder) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const taskRunsAt = new Date();
+        if (USE_CONFIRM_REGISTER_SERVICE_TRANSACTION) {
+            const confirmObjects = (0, factory_1.createConfirmRegisterServiceActionObjectByOrder)({ order });
+            const tasks = [];
+            yield Promise.all(confirmObjects.map((confirmObject) => __awaiter(this, void 0, void 0, function* () {
+                // 冗長なタスク作成を回避
+                const existingTasks = yield 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 = {
+                        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 createSendOrderTransactionTaskIfNotExist(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const now = new Date();
+        const sendOrderByTransaction = (_a = params.potentialActions) === null || _a === void 0 ? void 0 : _a.sendOrder;
+        if (sendOrderByTransaction !== undefined) {
+            const sendOrderTaskData = {
+                project: sendOrderByTransaction.project,
+                object: Object.assign(Object.assign({}, sendOrderByTransaction.object), { confirmationNumber: params.object.confirmationNumber })
+            };
+            const sendOrderTask = {
+                project: sendOrderByTransaction.project,
+                name: factory.taskName.SendOrder,
+                status: factory.taskStatus.Ready,
+                runsAt: now,
+                remainingNumberOfTries: 10,
+                numberOfTried: 0,
+                executionResults: [],
+                data: sendOrderTaskData
+            };
+            yield repos.task.createSendOrderTaskIfNotExist(sendOrderTask, { emitImmediately: true });
+        }
+    });
+}
+function createGivePointAwardTaskIfNotExist(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const now = new Date();
+        const givePointAwardsByTransaction = (_a = params.potentialActions) === null || _a === void 0 ? void 0 : _a.givePointAward;
+        if (Array.isArray(givePointAwardsByTransaction)) {
+            for (const givePointAwardByTransaction of givePointAwardsByTransaction) {
+                let taskIdentifier = `${givePointAwardByTransaction.project.id}:${factory.taskName.GivePointAward}:${Date.now()}`;
+                if (typeof givePointAwardByTransaction.object.identifier === 'string'
+                    && givePointAwardByTransaction.object.identifier.length > 0) {
+                    taskIdentifier = `${givePointAwardByTransaction.project.id}:${factory.taskName.GivePointAward}:${givePointAwardByTransaction.object.identifier}`;
+                }
+                const givePointAwardTask = {
+                    identifier: taskIdentifier,
+                    project: givePointAwardByTransaction.project,
+                    name: factory.taskName.GivePointAward,
+                    status: factory.taskStatus.Ready,
+                    runsAt: now,
+                    remainingNumberOfTries: 10,
+                    numberOfTried: 0,
+                    executionResults: [],
+                    data: givePointAwardByTransaction
+                };
+                // 冗長なgivePointAwardタスク作成を回避(2023-09-01~)
+                yield repos.task.createIfNotExistByIdentifier(givePointAwardTask, { emitImmediately: true });
+            }
+        }
+    });
+}