@chevre/domain 15.65.0-alpha.9 → 20.0.0-alpha.1

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

@@ -0,0 +1,385 @@
+"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.exportTasksById = exports.confirm = exports.start = void 0;
+/**
+ * 返品取引サービス
+ */
+const moment = require("moment");
+const factory = require("../../factory");
+const factory_1 = require("./returnOrder/exportTasks/factory");
+const potentialActions_1 = require("./returnOrder/potentialActions");
+const errorHandler_1 = require("../../errorHandler");
+/**
+ * 返品取引開始
+ */
+function start(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const now = new Date();
+        const { orders, offerIds } = yield fixOrders(params)(repos);
+        // sellerはorderから自動取得
+        const seller = yield repos.seller.findById({ id: String(orders[0].seller.id) }, { additionalProperty: 0, paymentAccepted: 0 });
+        yield validateOrder({ orders })(repos);
+        let offers = [];
+        if (offerIds.length > 0) {
+            offers = yield repos.offer.search({
+                id: { $in: offerIds }
+            });
+        }
+        // tslint:disable-next-line:no-console
+        // console.log('validating ', offers.length, 'offers before starting returnOrder... offerIds:', offerIds);
+        const policiesByOffer = yield searchPoliciesByOffer({ offers })(repos);
+        const appliedReturnPolicy = findApplicableReturnPolicy({
+            orders,
+            returningDate: now,
+            reason: params.object.reason,
+            seller,
+            offers,
+            policiesByOffer
+        });
+        validateAppliedReturnPolicy({ merchantReturnPolicy: appliedReturnPolicy });
+        // アイテム検証
+        yield validateItems({ orders, reason: params.object.reason })({ order: repos.order, reservation: repos.reservation });
+        const transactionObject = {
+            order: orders.map((o) => {
+                return { confirmationNumber: o.confirmationNumber, orderNumber: o.orderNumber };
+            }),
+            returnPolicy: appliedReturnPolicy,
+            reason: params.object.reason
+        };
+        const returnOrderAttributes = {
+            project: params.project,
+            typeOf: factory.transactionType.ReturnOrder,
+            agent: params.agent,
+            seller: {
+                id: String(seller.id),
+                typeOf: seller.typeOf,
+                name: seller.name
+            },
+            object: transactionObject,
+            expires: params.expires
+        };
+        let returnOrderTransaction;
+        try {
+            returnOrderTransaction = yield repos.transaction.start(returnOrderAttributes);
+        }
+        catch (error) {
+            if (error.name === 'MongoError') {
+                // 同一取引に対して返品取引を作成しようとすると、MongoDBでE11000 duplicate key errorが発生する
+                // tslint:disable-next-line:no-single-line-block-comment
+                /* istanbul ignore else */
+                if (error.code === errorHandler_1.MongoErrorCode.DuplicateKey) {
+                    throw new factory.errors.Argument('orderNumber', 'Already returned');
+                }
+            }
+            throw error;
+        }
+        return returnOrderTransaction;
+    });
+}
+exports.start = start;
+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]
+        }, {
+            // 不要な属性は参照しない
+            acceptedOffers: 0,
+            customer: 0,
+            orderedItem: 0
+        });
+        if (orders.length !== params.object.order.length) {
+            throw new factory.errors.NotFound('Order');
+        }
+        const offerIds = yield repos.order.searchAcceptedOfferIds({
+            project: { id: { $eq: params.project.id } },
+            confirmationNumbers: [params.object.order[0].confirmationNumber],
+            orderNumbers: [params.object.order[0].orderNumber]
+        });
+        return { orders, offerIds };
+    });
+}
+function validateOrder(params) {
+    return (__) => __awaiter(this, void 0, void 0, function* () {
+        // 注文ステータスが配送済の場合のみ受け付け
+        const allOrdersDelivered = params.orders.every((o) => o.orderStatus === factory.orderStatus.OrderDelivered);
+        if (!allOrdersDelivered) {
+            throw new factory.errors.Argument('Order Number', 'Invalid Order Status');
+        }
+    });
+}
+function validateItems(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        if (params.reason === factory.transaction.returnOrder.Reason.Seller) {
+            // 販売者都合の場合、特に検証しない
+            return;
+        }
+        // 注文に含まれる予約の状態検証
+        const reservationNumbers = yield repos.order.searchReservationNumbersByOrderNumbers({
+            orderNumber: { $in: params.orders.map((order) => order.orderNumber) }
+        });
+        if (reservationNumbers.length > 0) {
+            // 使用済の予約がひとつでもあれば不可
+            const existingUsedReservations = yield 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 findApplicableReturnPolicy(params) {
+    if (params.reason === factory.transaction.returnOrder.Reason.Seller) {
+        // 販売者都合の場合、手数料なしの返金返品ポリシーを適用
+        return {
+            typeOf: 'MerchantReturnPolicy',
+            returnFees: factory.merchantReturnPolicy.ReturnFeesEnumeration.FreeReturn
+        };
+    }
+    let returnPolicies = params.seller.hasMerchantReturnPolicy;
+    if (!Array.isArray(returnPolicies)) {
+        returnPolicies = [];
+    }
+    const returningDate = moment(params.returningDate);
+    const applicalbleReturnPolicies = [];
+    if (params.reason === factory.transaction.returnOrder.Reason.Customer) {
+        returnPolicies.forEach((returnPolicy) => {
+            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) {
+                    applicalbleReturnPolicies.push(returnPolicy);
+                }
+            }
+            else {
+                // 日数制限なし
+                applicalbleReturnPolicies.push(returnPolicy);
+            }
+        });
+    }
+    // 販売者にポリシーが存在しなければ返品不可
+    if (applicalbleReturnPolicies.length === 0) {
+        throw new factory.errors.Argument('Seller', 'has no applicable return policies');
+    }
+    // オファーの返品ポリシーから返品手数料タイプを決定する
+    const { returnFees } = validateOffersReturnPolicy({ offers: params.offers, policiesByOffer: params.policiesByOffer });
+    return {
+        merchantReturnDays: applicalbleReturnPolicies[0].merchantReturnDays,
+        restockingFee: applicalbleReturnPolicies[0].restockingFee,
+        returnFees,
+        typeOf: 'MerchantReturnPolicy'
+    };
+}
+/**
+ * 注文中のオファーの返品ポリシーを検証
+ */
+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');
+    }
+    // 決済カード取消有無はどうか？
+    return { returnFees };
+}
+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`);
+    }
+}
+/**
+ * 取引確定
+ */
+function confirm(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let transaction = yield repos.transaction.findById({ typeOf: factory.transactionType.ReturnOrder, id: params.id });
+        if (transaction.status === factory.transactionStatusType.Confirmed) {
+            // すでに確定済の場合
+            return transaction.result;
+        }
+        else if (transaction.status === factory.transactionStatusType.Expired) {
+            throw new factory.errors.Argument('transaction', 'Transaction already expired');
+        }
+        else if (transaction.status === factory.transactionStatusType.Canceled) {
+            throw new factory.errors.Argument('transaction', 'Transaction already canceled');
+        }
+        if (typeof ((_a = params.agent) === null || _a === void 0 ? void 0 : _a.id) === 'string' && transaction.agent.id !== params.agent.id) {
+            throw new factory.errors.Forbidden('Transaction not yours');
+        }
+        // ひとまず同時返品可能な注文数を1に限定(2022-04-28~)
+        if (transaction.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: transaction.project.id } },
+            confirmationNumbers: [transaction.object.order[0].confirmationNumber],
+            orderNumbers: [transaction.object.order[0].orderNumber]
+        }, {
+        // 現時点で全属性が必要
+        });
+        // デフォルトEメールメッセージを検索
+        let emailMessageOnOrderReturned;
+        if (repos.emailMessage !== undefined) {
+            const searchEmailMessagesResult = yield repos.emailMessage.search({
+                limit: 1,
+                page: 1,
+                project: { id: { $eq: transaction.project.id } },
+                about: { identifier: { $eq: factory.creativeWork.message.email.AboutIdentifier.OnOrderReturned } }
+            });
+            emailMessageOnOrderReturned = searchEmailMessagesResult.shift();
+        }
+        const result = {};
+        const potentialActions = yield (0, potentialActions_1.createPotentialActions)({
+            dateReturned: params.object.order.dateReturned,
+            orders: orders,
+            potentialActions: params.potentialActions,
+            transaction: transaction,
+            emailMessageOnOrderReturned: emailMessageOnOrderReturned,
+            createReturnReserveActions: params.createReturnReserveActions
+            // useConfirmRefund: params.useConfirmRefund
+        });
+        // ステータス変更
+        transaction = yield repos.transaction.confirm({
+            typeOf: transaction.typeOf,
+            id: transaction.id,
+            authorizeActions: [],
+            result: result,
+            potentialActions: potentialActions
+        });
+        return transaction.result;
+    });
+}
+exports.confirm = confirm;
+/**
+ * 取引のタスクを出力します
+ * 複数タスクが生成されます
+ * この関数では、取引のタスクエクスポートステータスは見ません
+ */
+function exportTasksById(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const transaction = yield repos.transaction.findById({ typeOf: factory.transactionType.ReturnOrder, id: params.id });
+        // タスク実行日時バッファの指定があれば調整
+        let taskRunsAt = new Date();
+        if (typeof params.runsTasksAfterInSeconds === 'number') {
+            taskRunsAt = moment(taskRunsAt)
+                .add(params.runsTasksAfterInSeconds, 'seconds')
+                .toDate();
+        }
+        const taskAttributes = (0, factory_1.createTasks)({
+            transaction,
+            runsAt: taskRunsAt
+        });
+        yield Promise.all(taskAttributes.map((taskAttribute) => __awaiter(this, void 0, void 0, function* () {
+            yield repos.task.save(taskAttribute);
+        })));
+    });
+}
+exports.exportTasksById = exportTasksById;

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

@@ -0,0 +1,8 @@
+import * as factory from '../../factory';
+export declare type IPassportValidator = (params: {
+    passport: factory.waiter.passport.IPassport;
+}) => boolean;
+export declare type IStartParams = (factory.transaction.placeOrder.IStartParamsWithoutDetail | factory.transaction.moneyTransfer.IStartParamsWithoutDetail) & {
+    passportValidator?: IPassportValidator;
+};
+export declare function validateWaiterPassport(params: IStartParams): Promise<factory.waiter.passport.IPassport | undefined>;

package/lib/chevre/service/transaction/validation.js

@@ -0,0 +1,43 @@
+"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.validateWaiterPassport = void 0;
+/**
+ * 取引バリデーション
+ */
+const waiter = require("@waiter/domain");
+const factory = require("../../factory");
+function validateWaiterPassport(params) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        let passport;
+        // WAITER許可証トークンがあれば検証する
+        if (typeof ((_b = (_a = params.object) === null || _a === void 0 ? void 0 : _a.passport) === null || _b === void 0 ? void 0 : _b.token) === 'string') {
+            try {
+                passport = yield waiter.service.passport.verify({
+                    token: params.object.passport.token,
+                    secret: params.object.passport.secret
+                });
+            }
+            catch (error) {
+                throw new factory.errors.Argument('Passport Token', `Invalid token: ${error.message}`);
+            }
+            // 許可証バリデーション
+            if (typeof params.passportValidator === 'function') {
+                if (!params.passportValidator({ passport: passport })) {
+                    throw new factory.errors.Argument('Passport Token', 'Invalid passport');
+                }
+            }
+        }
+        return passport;
+    });
+}
+exports.validateWaiterPassport = validateWaiterPassport;

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

@@ -0,0 +1,58 @@
+import * as factory from '../factory';
+import { MongoRepository as ActionRepo } from '../repo/action';
+import { MongoRepository as AssetTransactionRepo } from '../repo/assetTransaction';
+import { MongoRepository as ReservationRepo } from '../repo/reservation';
+import { MongoRepository as TaskRepo } from '../repo/task';
+import { MongoRepository as TransactionRepo } from '../repo/transaction';
+import * as MoneyTransferTransactionService from './transaction/moneyTransfer';
+import * as PlaceOrderTransactionService from './transaction/placeOrder';
+import * as PlaceOrderInProgressTransactionService from './transaction/placeOrderInProgress';
+import * as ReturnOrderTransactionService from './transaction/returnOrder';
+export declare type ITransactionOperation<T> = (repos: {
+    transaction: TransactionRepo;
+}) => Promise<T>;
+export import moneyTransfer = MoneyTransferTransactionService;
+export import placeOrder = PlaceOrderTransactionService;
+export import placeOrderInProgress = PlaceOrderInProgressTransactionService;
+export import returnOrder = ReturnOrderTransactionService;
+/**
+ * 取引人プロフィール更新
+ */
+export declare function updateAgent(params: {
+    typeOf: factory.transactionType;
+    id: string;
+    agent: factory.transaction.placeOrder.ICustomer & {
+        telephoneRegion?: string;
+    };
+}): ITransactionOperation<factory.transaction.placeOrder.ICustomer>;
+export declare type IExportTasksOperation<T> = (repos: {
+    task: TaskRepo;
+    transaction: TransactionRepo;
+}) => Promise<T>;
+/**
+ * ひとつの取引のタスクをエクスポートする
+ */
+export declare function exportTasks<T extends factory.transactionType>(params: {
+    project?: {
+        id: string;
+        typeOf: factory.organizationType.Project;
+    };
+    /**
+     * タスク実行日時バッファ
+     */
+    runsTasksAfterInSeconds?: number;
+    status: factory.transactionStatusType;
+    typeOf?: {
+        $in: T[];
+    };
+}): IExportTasksOperation<void>;
+/**
+ * 取引に関わるリソースを削除する
+ * 冪等性を確保すること
+ */
+export declare function deleteTransaction(params: factory.task.IData<factory.taskName.DeleteTransaction>): (repos: {
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    reservation: ReservationRepo;
+    transaction: TransactionRepo;
+}) => Promise<void>;