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

package/lib/chevre/service/transaction/returnOrder/preStart.js

@@ -0,0 +1,632 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preStart = void 0;
+const createDebug = require("debug");
+const http_status_1 = require("http-status");
+const moment = require("moment-timezone");
+const request = require("request");
+const factory = require("../../../factory");
+const debug = createDebug('chevre-domain:service');
+/**
+ * 返品取引開始前処理
+ */
+function preStart(params) {
+    // tslint:disable-next-line:max-func-body-length
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const now = new Date();
+        const { acceptedOffers, eventIds, offerIds, orders } = yield fixOrders(params)(repos);
+        // sellerはorderから自動取得
+        const sellers = yield repos.seller.search({
+            limit: 1,
+            page: 1,
+            id: { $eq: String(orders[0].seller.id) }
+        }, ['name', 'project', 'hasMerchantReturnPolicy', 'typeOf'], []);
+        const seller = sellers.shift();
+        if (seller === undefined) {
+            throw new factory.errors.NotFound(factory.organizationType.Corporation);
+        }
+        yield validateOrder({ orders })();
+        let offers = [];
+        if (offerIds.length > 0) {
+            offers = yield repos.offer.search({
+                id: { $in: offerIds }
+            });
+        }
+        // イベント開始日時取得
+        let events = [];
+        if (eventIds.length > 0) {
+            events = yield repos.event.search({
+                id: { $in: eventIds },
+                typeOf: factory.eventType.ScreeningEvent
+            }, ['startDate'], []);
+        }
+        let returnPolicies = seller.hasMerchantReturnPolicy;
+        if (!Array.isArray(returnPolicies)) {
+            returnPolicies = [];
+        }
+        // アイテムコンディション取得
+        let offerItemConditions = [];
+        const itemConditionIds = returnPolicies
+            .filter((returnPolicy) => { var _a; return typeof ((_a = returnPolicy.itemCondition) === null || _a === void 0 ? void 0 : _a.id) === 'string'; })
+            .map((returnPolicy) => { var _a; return String((_a = returnPolicy.itemCondition) === null || _a === void 0 ? void 0 : _a.id); });
+        if (itemConditionIds.length > 0) {
+            offerItemConditions = yield repos.offerItemCondition.search({
+                id: { $in: itemConditionIds }
+            });
+        }
+        const policiesByOffer = yield searchPoliciesByOffer({ offers })(repos);
+        const { usedReservationExists } = yield checkUsedReservationExists({ orders })(repos);
+        const { hasMerchantReturnPolicy } = yield repos.project.findById({
+            id: seller.project.id,
+            inclusion: ['hasMerchantReturnPolicy'],
+            exclusion: []
+        });
+        const appliedReturnPolicy = yield findApplicableReturnPolicy({
+            acceptedOffers,
+            events,
+            offerItemConditions,
+            orders,
+            returningDate: now,
+            reason: params.object.reason,
+            returnPolicies,
+            returnPolicySettingsByProject: hasMerchantReturnPolicy,
+            offers,
+            policiesByOffer,
+            usedReservationExists
+        });
+        validateAppliedReturnPolicy({ merchantReturnPolicy: appliedReturnPolicy });
+        // アイテム検証
+        yield validateItems({ orders, reason: params.object.reason })({ order: repos.order, reservation: repos.reservation });
+        const transactionObject = {
+            order: orders.map(({ confirmationNumber, orderNumber }) => ({ confirmationNumber, orderNumber })),
+            returnPolicy: appliedReturnPolicy,
+            reason: params.object.reason
+        };
+        // fix expiresInSeconds(2022-11-30~)
+        let expiresInSeconds;
+        if (typeof params.expiresInSeconds === 'number') {
+            expiresInSeconds = params.expiresInSeconds;
+        }
+        else {
+            throw new factory.errors.ArgumentNull('expiresInSeconds');
+        }
+        return { transactionObject, seller, expiresInSeconds };
+    });
+}
+exports.preStart = preStart;
+function fixOrders(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        if (!Array.isArray(params.object.order)) {
+            params.object.order = [params.object.order];
+        }
+        // ひとまず同時返品可能な注文数を1に限定(2022-04-28~)
+        if (params.object.order.length !== 1) {
+            throw new factory.errors.Argument('object.order', 'number of orders must be 1');
+        }
+        // 注文数を1に限定であれば、findByConfirmationNumberに変更できる(2022-04-28~)
+        const orders = yield repos.order.search({
+            limit: 1,
+            page: 1,
+            project: { id: { $eq: params.project.id } },
+            confirmationNumbers: [params.object.order[0].confirmationNumber],
+            orderNumbers: [params.object.order[0].orderNumber]
+        }, 
+        // positive projectionで検索(2023-12-08~)
+        {
+            confirmationNumber: 1, dateReturned: 1, orderDate: 1, orderNumber: 1, orderStatus: 1,
+            paymentMethods: 1, price: 1, project: 1, seller: 1, typeOf: 1
+        }
+        // {
+        //     // acceptedOffers: 0, // カスタム返品ポリシーに必要
+        //     customer: 0,
+        //     orderedItem: 0
+        //     // paymentMethods: 0 // 適用決済方法検証に必要
+        // }
+        );
+        if (orders.length !== params.object.order.length) {
+            throw new factory.errors.NotFound('Order');
+        }
+        const offerIds = yield repos.acceptedOffer.distinctValues({
+            orderNumber: { $in: [params.object.order[0].orderNumber] }
+        }, 'acceptedOffers.id');
+        const eventIds = yield repos.acceptedOffer.distinctValues({
+            orderNumber: { $in: [params.object.order[0].orderNumber] }
+        }, 'acceptedOffers.itemOffered.reservationFor.id');
+        // const acceptedOffers = await repos.acceptedOffer.searchAcceptedOffersByOrderNumbers({
+        //     orderNumber: { $in: [params.object.order[0].orderNumber] }
+        // });
+        const acceptedOffers = yield repos.acceptedOffer.searchAcceptedOffersByOrderNumber({
+            orderNumber: { $eq: params.object.order[0].orderNumber },
+            project: { id: { $eq: params.project.id } }
+        });
+        return { acceptedOffers, eventIds, offerIds, orders };
+    });
+}
+function validateOrder(__) {
+    return () => __awaiter(this, void 0, void 0, function* () {
+        // returnOrderタスクの処理の中でステータス整合性を担保しているので検証不要(2024-01-10~)
+        // 注文ステータスが配送済の場合のみ受け付け
+        // const allOrdersDelivered = params.orders.every((o) => o.orderStatus === factory.orderStatus.OrderDelivered);
+        // if (!allOrdersDelivered) {
+        //     throw new factory.errors.Argument('Order Number', 'Invalid Order Status');
+        // }
+    });
+}
+function checkUsedReservationExists(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let usedReservationExists = false;
+        // 注文に含まれる予約の状態検証
+        // const reservationNumbers = await repos.acceptedOffer.searchReservationNumbersByOrderNumbers({
+        //     orderNumber: { $in: params.orders.map((order) => order.orderNumber) }
+        // });
+        const reservationNumbers = yield repos.acceptedOffer.distinctValues({
+            orderNumber: { $in: params.orders.map((order) => order.orderNumber) }
+        }, 'acceptedOffers.itemOffered.reservationNumber');
+        if (reservationNumbers.length > 0) {
+            // 使用済の予約がひとつでもあれば不可
+            const existingUsedReservations = yield repos.reservation.search({
+                limit: 1,
+                page: 1,
+                typeOf: factory.reservationType.EventReservation,
+                reservationNumber: { $in: reservationNumbers },
+                attended: true
+            }, { _id: 1 });
+            if (existingUsedReservations.length > 0) {
+                usedReservationExists = true;
+            }
+        }
+        return { usedReservationExists };
+    });
+}
+function validateItems(params) {
+    return (__) => __awaiter(this, void 0, void 0, function* () {
+        if (params.reason === factory.transaction.returnOrder.Reason.Seller) {
+            // 販売者都合の場合、特に検証しない
+            return;
+        }
+        // アイテムコンディション検証へ移行
+        // 注文に含まれる予約の状態検証
+        // const reservationNumbers = await repos.order.searchReservationNumbersByOrderNumbers({
+        //     orderNumber: { $in: params.orders.map((order) => order.orderNumber) }
+        // });
+        // if (reservationNumbers.length > 0) {
+        //     // 使用済の予約がひとつでもあれば不可
+        //     const existingUsedReservations = await repos.reservation.search({
+        //         limit: 1,
+        //         page: 1,
+        //         typeOf: factory.reservationType.EventReservation,
+        //         reservationNumber: { $in: reservationNumbers },
+        //         attended: true
+        //     });
+        //     if (existingUsedReservations.length > 0) {
+        //         throw new factory.errors.Argument('orderNumber', 'some reservations already used');
+        //     }
+        // }
+    });
+}
+function searchPoliciesByOffer(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let merchantReturnPolicyIds = [];
+        params.offers.forEach((offer) => {
+            if (Array.isArray(offer.hasMerchantReturnPolicy) && offer.hasMerchantReturnPolicy.length > 0) {
+                merchantReturnPolicyIds.push(offer.hasMerchantReturnPolicy[0].id);
+            }
+        });
+        merchantReturnPolicyIds = [...new Set(merchantReturnPolicyIds)];
+        let policiesByOffer = [];
+        if (merchantReturnPolicyIds.length > 0) {
+            policiesByOffer = yield repos.merchantReturnPolicy.search({
+                id: { $in: merchantReturnPolicyIds }
+            });
+        }
+        if (merchantReturnPolicyIds.length !== policiesByOffer.length) {
+            throw new factory.errors.NotFound('MerchantReturnPolicy with offers');
+        }
+        return policiesByOffer;
+    });
+}
+function createOrder4returnPolicy(params) {
+    return {
+        orderDate: params.order.orderDate,
+        orderNumber: params.order.orderNumber,
+        price: params.order.price,
+        acceptedOffers: params.order.acceptedOffers.map((o) => {
+            var _a;
+            if (o.itemOffered.typeOf === factory.reservationType.EventReservation) {
+                const reservation = o.itemOffered;
+                const priceComponent = (_a = o.priceSpecification) === null || _a === void 0 ? void 0 : _a.priceComponent;
+                return {
+                    itemOffered: {
+                        additionalProperty: reservation.additionalProperty,
+                        reservationFor: {
+                            doorTime: reservation.reservationFor.doorTime,
+                            endDate: reservation.reservationFor.endDate,
+                            startDate: reservation.reservationFor.startDate
+                            // superEvent: reservation.reservationFor.superEvent
+                        },
+                        reservedTicket: {
+                            ticketedSeat: reservation.reservedTicket.ticketedSeat
+                        }
+                    },
+                    priceSpecification: {
+                        priceComponent: (Array.isArray(priceComponent))
+                            ? priceComponent.map((component) => {
+                                const { accounting, name, priceCurrency, valueAddedTaxIncluded } = component, postingComponent = __rest(component, ["accounting", "name", "priceCurrency", "valueAddedTaxIncluded"]);
+                                return postingComponent;
+                            })
+                            : []
+                    }
+                };
+            }
+            else {
+                return {
+                    priceSpecification: o.priceSpecification
+                };
+            }
+        })
+    };
+}
+const TIMEOUT = 5000;
+function getReturnPolicyByProject(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            request.post({
+                url: params.sameAs,
+                body: {
+                    order: createOrder4returnPolicy({ order: params.order })
+                },
+                json: true,
+                timeout: TIMEOUT
+            }, (error, response, body) => {
+                var _a;
+                if (error instanceof Error) {
+                    reject(error);
+                }
+                else {
+                    switch (response.statusCode) {
+                        case http_status_1.OK:
+                        case http_status_1.CREATED:
+                        case http_status_1.ACCEPTED:
+                        case http_status_1.NO_CONTENT:
+                            if (typeof ((_a = body.restockingFee) === null || _a === void 0 ? void 0 : _a.value) !== 'number') {
+                                reject(new Error('invalid return policy'));
+                            }
+                            else {
+                                resolve({
+                                    typeOf: 'MerchantReturnPolicy',
+                                    restockingFee: {
+                                        currency: factory.priceCurrency.JPY,
+                                        typeOf: 'MonetaryAmount',
+                                        value: body.restockingFee.value
+                                    }
+                                });
+                            }
+                            break;
+                        case http_status_1.NOT_FOUND:
+                            reject(new factory.errors.Argument('Seller', 'has no applicable return policies'));
+                            break;
+                        default:
+                            reject({
+                                statusCode: response.statusCode,
+                                body: body
+                            });
+                    }
+                }
+            });
+        });
+    });
+}
+/**
+ * 販売者の返品ポリシーを確認する
+ */
+// tslint:disable-next-line:max-func-body-length
+function findApplicableReturnPolicy(params) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (params.reason === factory.transaction.returnOrder.Reason.Seller) {
+            // 販売者都合の場合、手数料なしの返金返品ポリシーを適用
+            return {
+                typeOf: 'MerchantReturnPolicy',
+                returnFees: factory.merchantReturnPolicy.ReturnFeesEnumeration.FreeReturn
+            };
+        }
+        const returnPolicies = params.returnPolicies;
+        let applicalbleReturnPolicies = [];
+        if (params.reason === factory.transaction.returnOrder.Reason.Customer) {
+            // プロジェクトの返品ポリシー設定を考慮(2023-11-14~)
+            const returnPolicySameAsByPoject = (_a = params.returnPolicySettingsByProject) === null || _a === void 0 ? void 0 : _a.sameAs;
+            if (typeof returnPolicySameAsByPoject === 'string' && returnPolicySameAsByPoject.length > 0) {
+                const returnPolicyByProject = yield getReturnPolicyByProject({
+                    sameAs: returnPolicySameAsByPoject,
+                    order: Object.assign(Object.assign({}, params.orders[0]), { acceptedOffers: params.acceptedOffers })
+                });
+                applicalbleReturnPolicies.push(returnPolicyByProject);
+            }
+            else {
+                // 適用可能なポリシーにフィルター
+                // tslint:disable-next-line:max-func-body-length
+                applicalbleReturnPolicies = returnPolicies.filter((returnPolicy) => {
+                    return isSellerReturnPolicyApplicable({
+                        returnPolicy,
+                        events: params.events,
+                        offerItemConditions: params.offerItemConditions,
+                        orders: params.orders,
+                        returningDate: params.returningDate,
+                        usedReservationExists: params.usedReservationExists
+                    });
+                });
+            }
+        }
+        // 販売者にポリシーが存在しなければ返品不可
+        if (applicalbleReturnPolicies.length === 0) {
+            throw new factory.errors.Argument('Seller', 'has no applicable return policies');
+        }
+        // オファーの返品ポリシーから返品手数料タイプを決定する
+        const { returnFees, returnFeesMovieTicket } = validateOffersReturnPolicy({
+            acceptedOffers: params.acceptedOffers,
+            offers: params.offers,
+            policiesByOffer: params.policiesByOffer
+        });
+        // restockingFeeが最低のポリシーを自動選択
+        let appliedReturnPolicy = applicalbleReturnPolicies[0];
+        applicalbleReturnPolicies.forEach((returnPolicy) => {
+            var _a, _b;
+            const appliedReturnPolicyRestockingFeeValue = (_a = appliedReturnPolicy.restockingFee) === null || _a === void 0 ? void 0 : _a.value;
+            const restockingFeeValue = (_b = returnPolicy.restockingFee) === null || _b === void 0 ? void 0 : _b.value;
+            const appliedReturnPolicyRestockingFee = (typeof appliedReturnPolicyRestockingFeeValue === 'number')
+                ? appliedReturnPolicyRestockingFeeValue
+                : 0;
+            const restockingFee = (typeof restockingFeeValue === 'number') ? restockingFeeValue : 0;
+            if (restockingFee < appliedReturnPolicyRestockingFee) {
+                appliedReturnPolicy = returnPolicy;
+            }
+        });
+        let appliedItemCondition;
+        const appliedItemConditionId = (_b = appliedReturnPolicy.itemCondition) === null || _b === void 0 ? void 0 : _b.id;
+        if (typeof appliedItemConditionId === 'string') {
+            appliedItemCondition = params.offerItemConditions.find((o) => o.id === appliedItemConditionId);
+            if (appliedItemCondition === undefined) {
+                throw new factory.errors.NotFound('OfferItemCondition');
+            }
+        }
+        return Object.assign({ merchantReturnDays: appliedReturnPolicy.merchantReturnDays, restockingFee: appliedReturnPolicy.restockingFee, returnFees,
+            returnFeesMovieTicket, typeOf: appliedReturnPolicy.typeOf }, (typeof (appliedItemCondition === null || appliedItemCondition === void 0 ? void 0 : appliedItemCondition.typeOf) === 'string') ? { itemCondition: appliedItemCondition } : undefined);
+    });
+}
+// tslint:disable-next-line:cyclomatic-complexity max-func-body-length
+function isSellerReturnPolicyApplicable(params) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const returnPolicy = params.returnPolicy;
+    const returningDate = moment(params.returningDate);
+    let satisfyMerchantReturnDays = false;
+    let satisfyApplicablePaymentMethod = false;
+    let offerItemCondition;
+    const itemConditionId = (_a = returnPolicy.itemCondition) === null || _a === void 0 ? void 0 : _a.id;
+    if (typeof itemConditionId === 'string') {
+        offerItemCondition = params.offerItemConditions.find((o) => o.id === itemConditionId);
+        if (offerItemCondition === undefined) {
+            throw new factory.errors.NotFound('OfferItemCondition');
+        }
+    }
+    const merchantReturnDays = returnPolicy.merchantReturnDays;
+    if (typeof merchantReturnDays === 'number') {
+        // 返品適用日数を確認する
+        const everyOrderApplicable = params.orders.every((order) => {
+            const mustBeReturnedUntil = moment(order.orderDate)
+                .add(merchantReturnDays, 'days');
+            return mustBeReturnedUntil.isSameOrAfter(returningDate);
+        });
+        // 全注文について日数の確認ができれば適用
+        if (everyOrderApplicable) {
+            satisfyMerchantReturnDays = true;
+        }
+    }
+    else {
+        // 日数制限なし
+        satisfyMerchantReturnDays = true;
+    }
+    // 適用決済方法検証(2023-08-08~)
+    const applicablePaymentMethod = returnPolicy.applicablePaymentMethod;
+    if (Array.isArray(applicablePaymentMethod)) {
+        const everyOrderApplicable = params.orders.every((order) => {
+            // 全決済方法区分がapplicablePaymentMethodに含まれれば適用
+            return order.paymentMethods.every((invoice) => {
+                var _a;
+                return typeof ((_a = invoice.paymentMethod) === null || _a === void 0 ? void 0 : _a.identifier) === 'string'
+                    && applicablePaymentMethod.includes(invoice.paymentMethod.identifier);
+            });
+        });
+        // 全注文について確認ができれば適用
+        if (everyOrderApplicable) {
+            satisfyApplicablePaymentMethod = true;
+        }
+    }
+    else {
+        satisfyApplicablePaymentMethod = true;
+    }
+    // イベント開始猶予を検証する(2023-05-22~)
+    let satisfyItemCondition = true;
+    if (offerItemCondition !== undefined) {
+        let satisfyGracePeriodMaxValue = true;
+        let satisfyGracePeriodMinValue = true;
+        // 全イベントについて猶予の確認ができれば適用
+        const gracePeriodMaxValue = (_c = (_b = offerItemCondition.itemOffered.serviceOutput) === null || _b === void 0 ? void 0 : _b.reservationFor.gracePeriodBeforeStart) === null || _c === void 0 ? void 0 : _c.maxValue;
+        const gracePeriodMinValue = (_e = (_d = offerItemCondition.itemOffered.serviceOutput) === null || _d === void 0 ? void 0 : _d.reservationFor.gracePeriodBeforeStart) === null || _e === void 0 ? void 0 : _e.minValue;
+        if (typeof gracePeriodMaxValue === 'number') {
+            satisfyGracePeriodMaxValue = params.events.every((event) => {
+                return moment(event.startDate)
+                    .isSameOrBefore(moment(params.returningDate)
+                    .add(gracePeriodMaxValue, 'seconds'));
+            });
+        }
+        if (typeof gracePeriodMinValue === 'number') {
+            satisfyGracePeriodMinValue = params.events.every((event) => {
+                return moment(event.startDate)
+                    .isAfter(moment(params.returningDate)
+                    .add(gracePeriodMinValue, 'seconds'));
+            });
+        }
+        let satisfyGracePeriodInDaysMax = true;
+        let satisfyGracePeriodInDaysMin = true;
+        const gracePeriodBeforeStartInDaysMax = (_g = (_f = offerItemCondition.itemOffered.serviceOutput) === null || _f === void 0 ? void 0 : _f.reservationFor.gracePeriodBeforeStartInDays) === null || _g === void 0 ? void 0 : _g.max;
+        if (typeof (gracePeriodBeforeStartInDaysMax === null || gracePeriodBeforeStartInDaysMax === void 0 ? void 0 : gracePeriodBeforeStartInDaysMax.period.value) === 'number'
+            && typeof gracePeriodBeforeStartInDaysMax.time === 'string') {
+            satisfyGracePeriodInDaysMax = params.events.every((event) => {
+                const maxDate = moment(event.startDate)
+                    .tz(gracePeriodBeforeStartInDaysMax.timezone)
+                    .startOf('days')
+                    .subtract(gracePeriodBeforeStartInDaysMax.period.value, 'days')
+                    .format('YYYY-MM-DD');
+                const returnMinDate = moment.tz(`${maxDate}T${gracePeriodBeforeStartInDaysMax.time}`, gracePeriodBeforeStartInDaysMax.timezone);
+                debug('returnMinDate:', returnMinDate, 'returningDate:', returningDate);
+                return returnMinDate.isSameOrBefore(moment(returningDate));
+            });
+        }
+        debug('gracePeriodBeforeStartInDaysMax:', gracePeriodBeforeStartInDaysMax);
+        const gracePeriodBeforeStartInDaysMin = (_j = (_h = offerItemCondition.itemOffered.serviceOutput) === null || _h === void 0 ? void 0 : _h.reservationFor.gracePeriodBeforeStartInDays) === null || _j === void 0 ? void 0 : _j.min;
+        if (typeof (gracePeriodBeforeStartInDaysMin === null || gracePeriodBeforeStartInDaysMin === void 0 ? void 0 : gracePeriodBeforeStartInDaysMin.period.value) === 'number'
+            && typeof gracePeriodBeforeStartInDaysMin.time === 'string') {
+            satisfyGracePeriodInDaysMin = params.events.every((event) => {
+                const minDate = moment(event.startDate)
+                    .tz(gracePeriodBeforeStartInDaysMin.timezone)
+                    .startOf('days')
+                    .subtract(gracePeriodBeforeStartInDaysMin.period.value, 'days')
+                    .format('YYYY-MM-DD');
+                const returnMaxDate = moment.tz(`${minDate}T${gracePeriodBeforeStartInDaysMin.time}`, gracePeriodBeforeStartInDaysMin.timezone);
+                debug('returnMaxDate:', returnMaxDate, 'returningDate:', returningDate);
+                return returnMaxDate.isAfter(moment(returningDate));
+            });
+        }
+        debug('satisfyGracePeriodInDaysMin:', satisfyGracePeriodInDaysMin);
+        let satisfyOnlyUnused = true;
+        if (((_k = offerItemCondition.itemOffered.serviceOutput) === null || _k === void 0 ? void 0 : _k.onlyUnused) === true) {
+            if (params.usedReservationExists) {
+                satisfyOnlyUnused = false;
+            }
+        }
+        debug('usedReservationExists:', params.usedReservationExists, 'satisfyOnlyUnused:', satisfyOnlyUnused);
+        satisfyItemCondition = satisfyGracePeriodMaxValue && satisfyGracePeriodMinValue
+            && satisfyGracePeriodInDaysMax && satisfyGracePeriodInDaysMin && satisfyOnlyUnused;
+    }
+    return satisfyMerchantReturnDays && satisfyApplicablePaymentMethod && satisfyItemCondition;
+}
+/**
+ * 注文中のオファーの返品ポリシーを検証
+ */
+function validateOffersReturnPolicy(params) {
+    // オファーに返品ポリシーが設定されているか？
+    const everyOffersHaveReturnPolicy = params.offers.every((offer) => {
+        return Array.isArray(offer.hasMerchantReturnPolicy) && offer.hasMerchantReturnPolicy.length > 0;
+    });
+    if (!everyOffersHaveReturnPolicy) {
+        throw new factory.errors.NotFound('offer.hasMerchantReturnPolicy');
+    }
+    let returnFees;
+    // 返品手数料設定はどうか？
+    const somePolicyWithReturnFeesCustomerResponsibility = params.policiesByOffer.some((policy) => {
+        return policy.customerRemorseReturnFees === factory.merchantReturnPolicy.ReturnFeesEnumeration.ReturnFeesCustomerResponsibility;
+    });
+    const somePolicyWithRestockingFees = params.policiesByOffer.some((policy) => {
+        return policy.customerRemorseReturnFees === factory.merchantReturnPolicy.ReturnFeesEnumeration.RestockingFees;
+    });
+    const everyPolicyWithFreeReturn = params.policiesByOffer.every((policy) => {
+        return policy.customerRemorseReturnFees === factory.merchantReturnPolicy.ReturnFeesEnumeration.FreeReturn;
+    });
+    if (somePolicyWithReturnFeesCustomerResponsibility) {
+        // ひとつでも返金なしがあれば返金なし
+        returnFees = factory.merchantReturnPolicy.ReturnFeesEnumeration.ReturnFeesCustomerResponsibility;
+    }
+    else if (somePolicyWithRestockingFees) {
+        // ひとつでも手数料あり返金があれば手数料あり返金
+        returnFees = factory.merchantReturnPolicy.ReturnFeesEnumeration.RestockingFees;
+    }
+    else if (everyPolicyWithFreeReturn) {
+        // 全ポリシーが手数料なしであれば手数料なし返金
+        returnFees = factory.merchantReturnPolicy.ReturnFeesEnumeration.FreeReturn;
+    }
+    else {
+        throw new factory.errors.NotImplemented('returnFees not defined');
+    }
+    // 決済カード取消ポリシーを確定(2023-05-23~)
+    const returnFeesMovieTicket = [];
+    params.acceptedOffers.forEach((acceptedOffer) => {
+        var _a, _b;
+        const unitPriceOffer = params.offers.find((offer) => offer.id === acceptedOffer.id);
+        if (unitPriceOffer === undefined) {
+            throw new factory.errors.NotFound(`UnitPriceOffer ${acceptedOffer.id}`);
+        }
+        if (!Array.isArray(unitPriceOffer.hasMerchantReturnPolicy) || unitPriceOffer.hasMerchantReturnPolicy.length === 0) {
+            throw new factory.errors.NotFound(`offer.hasMerchantReturnPolicy ${acceptedOffer.id}`);
+        }
+        const hasMerchantReturnPolicy = unitPriceOffer.hasMerchantReturnPolicy[0];
+        const policyByOffer = params.policiesByOffer.find((policy) => policy.id === hasMerchantReturnPolicy.id);
+        if (policyByOffer === undefined) {
+            throw new factory.errors.NotFound(`MerchantReturnPolicy acceptedOffer:${acceptedOffer.id}`);
+        }
+        const movieTicketTypeChargeSpecExists = (_a = acceptedOffer.priceSpecification) === null || _a === void 0 ? void 0 : _a.priceComponent.some((component) => {
+            return component.typeOf === factory.priceSpecificationType.MovieTicketTypeChargeSpecification;
+        });
+        if (movieTicketTypeChargeSpecExists === true) {
+            (_b = acceptedOffer.priceSpecification) === null || _b === void 0 ? void 0 : _b.priceComponent.forEach((component) => {
+                if (component.typeOf === factory.priceSpecificationType.UnitPriceSpecification) {
+                    if (Array.isArray(component.appliesToMovieTicket)) {
+                        component.appliesToMovieTicket.forEach((appliesToMovieTicket) => {
+                            returnFeesMovieTicket.push({
+                                identifier: String(appliesToMovieTicket.identifier),
+                                returnFees: policyByOffer.customerRemorseReturnFeesMovieTicket,
+                                serviceOutput: { typeOf: appliesToMovieTicket.serviceOutput.typeOf }
+                            });
+                        });
+                    }
+                }
+            });
+        }
+    });
+    return { returnFees, returnFeesMovieTicket };
+}
+function validateAppliedReturnPolicy(params) {
+    var _a;
+    const appliedReturnPolicy = params.merchantReturnPolicy;
+    switch (appliedReturnPolicy.returnFees) {
+        case factory.merchantReturnPolicy.ReturnFeesEnumeration.RestockingFees:
+            // 返品ポリシーに返品手数料が定義されていれば、金額設定が必須
+            if (typeof appliedReturnPolicy.restockingFee === 'number') {
+                throw new factory.errors.NotImplemented('restockingFee in type of number not implemented');
+            }
+            else {
+                const returnFeeByPolicy = (_a = appliedReturnPolicy.restockingFee) === null || _a === void 0 ? void 0 : _a.value;
+                if (typeof returnFeeByPolicy !== 'number') {
+                    throw new factory.errors.NotFound('appliedReturnPolicy.restockingFee.value');
+                }
+            }
+            break;
+        case factory.merchantReturnPolicy.ReturnFeesEnumeration.FreeReturn:
+            // 返品手数料設定不要なのでスルー
+            break;
+        case factory.merchantReturnPolicy.ReturnFeesEnumeration.ReturnFeesCustomerResponsibility:
+            // 返金処理なしなのでスルー
+            break;
+        default:
+            throw new factory.errors.NotImplemented(`returnFees of returnPolicy: ${appliedReturnPolicy.returnFees} not implemented`);
+    }
+}

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

@@ -11,7 +11,8 @@ import type { MongoRepository as ReservationRepo } from '../../repo/reservation'
 import type { MongoRepository as SellerRepo } from '../../repo/seller';
 import type { MongoRepository as TaskRepo } from '../../repo/task';
 import type { MongoRepository as TransactionRepo } from '../../repo/transaction';
-export interface IStartOperationRepos {
+import { preStart } from './returnOrder/preStart';
+interface IStartOperationRepos {
     acceptedOffer: AcceptedOfferRepo;
     event: EventRepo;
     merchantReturnPolicy: MerchantReturnPolicyRepo;
@@ -23,19 +24,19 @@ export interface IStartOperationRepos {
     seller: SellerRepo;
     transaction: TransactionRepo;
 }
-export type IStartOperation<T> = (repos: IStartOperationRepos) => Promise<T>;
-export type ITaskAndTransactionOperation<T> = (repos: {
+type IStartOperation<T> = (repos: IStartOperationRepos) => Promise<T>;
+type ITaskAndTransactionOperation<T> = (repos: {
     task: TaskRepo;
     transaction: TransactionRepo;
 }) => Promise<T>;
 /**
  * 返品取引開始
  */
-export declare function start(params: factory.transaction.returnOrder.IStartParamsWithoutDetail): IStartOperation<factory.transaction.returnOrder.ITransaction>;
+declare function start(params: factory.transaction.returnOrder.IStartParamsWithoutDetail): IStartOperation<factory.transaction.returnOrder.ITransaction>;
 /**
  * 取引確定
  */
-export declare function confirm(params: factory.transaction.returnOrder.IConfirmParams & {
+declare function confirm(params: factory.transaction.returnOrder.IConfirmParams & {
     object: {
         order: {
             dateReturned: Date;
@@ -52,10 +53,11 @@ export declare function confirm(params: factory.transaction.returnOrder.IConfirm
  * 複数タスクが生成されます
  * この関数では、取引のタスクエクスポートステータスは見ません
  */
-export declare function exportTasksById(params: {
+declare function exportTasksById(params: {
     id: string;
     /**
      * タスク実行日時バッファ
      */
     runsTasksAfterInSeconds?: number;
 }): ITaskAndTransactionOperation<void>;
+export { preStart, start, confirm, exportTasksById };