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

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

@@ -0,0 +1,143 @@
+/**
+ * 進行中注文取引サービス
+ */
+import * as factory from '../../factory';
+import { MongoRepository as ActionRepo } from '../../repo/action';
+import { RedisRepository as ConfirmationNumberRepo } from '../../repo/confirmationNumber';
+import { MongoRepository as EmailMessageRepo } from '../../repo/emailMessage';
+import { RedisRepository as OrderNumberRepo } from '../../repo/orderNumber';
+import { MongoRepository as ProjectRepo } from '../../repo/project';
+import { MongoRepository as SellerRepo } from '../../repo/seller';
+import { MongoRepository as TransactionRepo } from '../../repo/transaction';
+import { IPassportValidator as IWaiterPassportValidator } from './validation';
+export declare const POINT_AWARD_IDENTIFIER_NAME = "pointAwardIdentifiers";
+export interface IStartOperationRepos {
+    seller: SellerRepo;
+    transaction: TransactionRepo;
+}
+export declare type IStartOperation<T> = (repos: IStartOperationRepos) => Promise<T>;
+export interface IConfirmOperationRepos {
+    action: ActionRepo;
+    emailMessage?: EmailMessageRepo;
+    project: ProjectRepo;
+    transaction: TransactionRepo;
+    orderNumber: OrderNumberRepo;
+    confirmationNumber: ConfirmationNumberRepo;
+}
+export declare type IConfirmOperation<T> = (repos: IConfirmOperationRepos) => Promise<T>;
+export declare type IPassportValidator = IWaiterPassportValidator;
+export declare type IStartParams = factory.transaction.placeOrder.IStartParamsWithoutDetail & {
+    passportValidator?: IPassportValidator;
+    broker?: factory.order.IBroker;
+    validateSeller?: boolean;
+};
+/**
+ * 取引開始
+ */
+export declare function start(params: IStartParams): IStartOperation<factory.transaction.placeOrder.ITransaction>;
+export declare type IOrderURLGenerator = (order: factory.order.IOrder) => string;
+export declare type IResultOrderParams = factory.transaction.placeOrder.IResultOrderParams & {
+    /**
+     * 注文日時
+     */
+    orderDate: Date;
+    /**
+     * 注文確認URLのカスタム指定
+     */
+    url?: string | IOrderURLGenerator;
+    /**
+     * 注文アイテム数
+     */
+    numItems?: {
+        maxValue?: number;
+        minValue?: number;
+    };
+};
+export declare type IConfirmParams = factory.transaction.placeOrder.IConfirmParams & {
+    project: {
+        id: string;
+    };
+    result: {
+        order: IResultOrderParams;
+    };
+    /**
+     * confirmPayActionをchevreへ完全移行後に廃止
+     */
+    createConfirmPayActions: boolean;
+    /**
+     * confirmReserveActionをchevreへ完全移行後に廃止
+     */
+    createConfirmReserveActions: boolean;
+};
+/**
+ * 注文取引を確定する
+ */
+export declare function confirm(params: IConfirmParams): IConfirmOperation<factory.transaction.placeOrder.IResult>;
+/**
+ * 未発行であれば、注文の確認番号を発行して取引に保管する
+ */
+export declare function publishConfirmationNumberIfNotExist(params: {
+    /**
+     * 取引ID
+     */
+    id: string;
+    object: {
+        orderDate: Date;
+    };
+}): (repos: {
+    transaction: TransactionRepo;
+    confirmationNumber: ConfirmationNumberRepo;
+}) => Promise<string>;
+/**
+ * 未発行であれば、注文番号を発行して取引に保管する
+ */
+export declare function publishOrderNumberIfNotExist(params: {
+    /**
+     * 取引ID
+     */
+    id: string;
+    object: {
+        orderDate: Date;
+    };
+}): (repos: {
+    project: ProjectRepo;
+    transaction: TransactionRepo;
+    orderNumber: OrderNumberRepo;
+}) => Promise<string>;
+/**
+ * インセンティブ承認
+ */
+export declare function authorizeAward(params: {
+    transaction: {
+        id: string;
+    };
+    agent: {
+        id: string;
+    };
+    object?: {
+        potentialActions?: {
+            givePointAwardParams?: factory.transaction.placeOrder.IGivePointAwardParams[];
+        };
+    };
+}): (repos: {
+    transaction: TransactionRepo;
+}) => Promise<void>;
+/**
+ * インセンティブ承認を取り消す
+ */
+export declare function voidAward(params: {
+    /**
+     * 取引進行者
+     */
+    agent: {
+        id: string;
+    };
+    /**
+     * 取引
+     */
+    transaction: {
+        id: string;
+    };
+}): (repos: {
+    transaction: TransactionRepo;
+}) => Promise<void>;

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

@@ -0,0 +1,354 @@
+"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.voidAward = exports.authorizeAward = exports.publishOrderNumberIfNotExist = exports.publishConfirmationNumberIfNotExist = exports.confirm = exports.start = exports.POINT_AWARD_IDENTIFIER_NAME = void 0;
+/**
+ * 進行中注文取引サービス
+ */
+const factory = require("../../factory");
+const factory_1 = require("./placeOrderInProgress/factory");
+const potentialActions_1 = require("./placeOrderInProgress/potentialActions");
+const result_1 = require("./placeOrderInProgress/result");
+const validation_1 = require("./placeOrderInProgress/validation");
+const validateSeller_1 = require("./placeOrderInProgress/validation/validateSeller");
+const validation_2 = require("./validation");
+const errorHandler_1 = require("../../errorHandler");
+exports.POINT_AWARD_IDENTIFIER_NAME = 'pointAwardIdentifiers';
+/**
+ * 取引開始
+ */
+function start(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const seller = yield repos.seller.findById({ id: params.seller.id });
+        // 販売者オファー検証(2022-10-14~)
+        if (params.validateSeller === true) {
+            (0, validateSeller_1.validateSeller)({ seller, clientUser: params.object.clientUser });
+        }
+        const passport = yield (0, validation_2.validateWaiterPassport)(params);
+        // 取引ファクトリーで新しい進行中取引オブジェクトを作成
+        const startParams = (0, factory_1.createStartParams)(params, passport, seller, params.broker);
+        let transaction;
+        try {
+            transaction = yield repos.transaction.start(startParams);
+        }
+        catch (error) {
+            if (error.name === 'MongoError') {
+                // no op
+            }
+            throw error;
+        }
+        return transaction;
+    });
+}
+exports.start = start;
+/**
+ * 注文取引を確定する
+ */
+function confirm(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        // 確認番号を事前発行
+        yield publishConfirmationNumberIfNotExist({
+            id: params.id,
+            object: { orderDate: params.result.order.orderDate }
+        })(repos);
+        let transaction = yield repos.transaction.findById({
+            typeOf: factory.transactionType.PlaceOrder,
+            id: params.id
+        });
+        if (transaction.status === factory.transactionStatusType.Confirmed) {
+            // すでに確定済の場合
+            return transaction.result;
+        }
+        else if (transaction.status === factory.transactionStatusType.Expired) {
+            throw new factory.errors.Argument('transactionId', 'Transaction already expired');
+        }
+        else if (transaction.status === factory.transactionStatusType.Canceled) {
+            throw new factory.errors.Argument('transactionId', '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');
+        }
+        // 取引に対する全ての承認アクションをマージ
+        transaction.object.authorizeActions = yield searchAuthorizeActions(params)(repos);
+        // 注文番号を発行
+        const orderNumber = yield publishOrderNumberIfNotExist({
+            id: transaction.id,
+            object: { orderDate: params.result.order.orderDate }
+        })(repos);
+        const result = yield createResult(Object.assign(Object.assign({}, params), { orderNumber, transaction: transaction }))();
+        // デフォルトEメールメッセージを検索
+        let emailMessageOnOrderSent;
+        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.OnOrderSent } }
+            });
+            emailMessageOnOrderSent = searchEmailMessagesResult.shift();
+        }
+        // ポストアクションを作成
+        const potentialActions = yield (0, potentialActions_1.createPotentialActions)({
+            order: result.order,
+            potentialActions: params.potentialActions,
+            transaction: transaction,
+            emailMessage: emailMessageOnOrderSent,
+            createConfirmPayActions: params.createConfirmPayActions,
+            createConfirmReserveActions: params.createConfirmReserveActions
+        });
+        // ステータス変更
+        try {
+            transaction = yield repos.transaction.confirm({
+                typeOf: transaction.typeOf,
+                id: transaction.id,
+                authorizeActions: transaction.object.authorizeActions,
+                result: result,
+                potentialActions: potentialActions
+            });
+        }
+        catch (error) {
+            if (error.name === 'MongoError') {
+                // 万が一同一注文番号で確定しようとすると、MongoDBでE11000 duplicate key errorが発生する
+                // message: 'E11000 duplicate key error collection: prodttts.transactions index:result.order.orderNumber_1 dup key:...',
+                if (error.code === errorHandler_1.MongoErrorCode.DuplicateKey) {
+                    throw new factory.errors.AlreadyInUse('transaction', ['result.order.orderNumber']);
+                }
+            }
+            throw error;
+        }
+        // 万が一処理が想定通りでない場合orderNumberが存在しない
+        if (typeof ((_b = transaction.result) === null || _b === void 0 ? void 0 : _b.order.typeOf) !== 'string') {
+            throw new factory.errors.ServiceUnavailable('transaction.result not found');
+        }
+        return transaction.result;
+    });
+}
+exports.confirm = confirm;
+/**
+ * 未発行であれば、注文の確認番号を発行して取引に保管する
+ */
+function publishConfirmationNumberIfNotExist(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let transaction = yield repos.transaction.findInProgressById({
+            typeOf: factory.transactionType.PlaceOrder,
+            id: params.id
+        });
+        // すでに発行済であれば何もしない
+        if (typeof transaction.object.confirmationNumber === 'string') {
+            return transaction.object.confirmationNumber;
+        }
+        // 確認番号を発行
+        const confirmationNumber = (yield repos.confirmationNumber.publish({
+            orderDate: params.object.orderDate
+        })).toString();
+        // 取引に存在しなければ保管
+        yield repos.transaction.saveConfirmationNumberIfNotExist({
+            id: transaction.id,
+            confirmationNumber
+        });
+        // 確認番号を取引から再取得
+        transaction = yield repos.transaction.findInProgressById({
+            typeOf: factory.transactionType.PlaceOrder,
+            id: params.id
+        });
+        // 万が一処理が想定通りでない場合confirmationNumberが存在しない
+        if (typeof transaction.object.confirmationNumber !== 'string') {
+            throw new factory.errors.ServiceUnavailable('transaction.object.confirmationNumber not found');
+        }
+        return transaction.object.confirmationNumber;
+    });
+}
+exports.publishConfirmationNumberIfNotExist = publishConfirmationNumberIfNotExist;
+/**
+ * 未発行であれば、注文番号を発行して取引に保管する
+ */
+function publishOrderNumberIfNotExist(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let transaction = yield repos.transaction.findInProgressById({
+            typeOf: factory.transactionType.PlaceOrder,
+            id: params.id
+        });
+        // すでに発行済であれば何もしない
+        if (typeof transaction.object.orderNumber === 'string') {
+            return transaction.object.orderNumber;
+        }
+        // 注文番号を発行
+        const project = yield repos.project.findById({ id: transaction.project.id });
+        if (typeof project.alternateName !== 'string') {
+            throw new factory.errors.NotFound('project.alternateName');
+        }
+        const orderNumber = yield repos.orderNumber.publishByTimestamp({
+            project: { alternateName: project.alternateName },
+            orderDate: params.object.orderDate
+        });
+        // 取引に存在しなければ保管
+        yield repos.transaction.saveOrderNumberIfNotExist({
+            id: transaction.id,
+            orderNumber
+        });
+        // 注文番号を取引から再取得
+        transaction = yield repos.transaction.findInProgressById({
+            typeOf: factory.transactionType.PlaceOrder,
+            id: params.id
+        });
+        // 万が一処理が想定通りでない場合orderNumberが存在しない
+        if (typeof transaction.object.orderNumber !== 'string') {
+            throw new factory.errors.ServiceUnavailable('transaction.object.orderNumber not found');
+        }
+        return transaction.object.orderNumber;
+    });
+}
+exports.publishOrderNumberIfNotExist = publishOrderNumberIfNotExist;
+function createResult(params) {
+    return () => __awaiter(this, void 0, void 0, function* () {
+        const transaction = params.transaction;
+        // 取引の確定条件が全て整っているかどうか確認
+        (0, validation_1.validateTransaction)(transaction);
+        // 注文作成
+        const order = (0, result_1.createOrder)({
+            orderNumber: params.orderNumber,
+            transaction: transaction,
+            orderDate: params.result.order.orderDate,
+            orderStatus: factory.orderStatus.OrderProcessing,
+            isGift: false
+        });
+        (0, validation_1.validateEventOffers)({
+            transaction: transaction,
+            order: order
+        });
+        // 注文アイテム数制限確認
+        (0, validation_1.validateNumItems)({
+            order: order,
+            result: params.result
+        });
+        (0, validation_1.validatePaymentMethods)({ order });
+        // 確認番号を発行
+        const { confirmationNumber, identifier, url } = yield createConfirmationNumber({
+            order: order,
+            transaction: transaction,
+            result: params.result
+        })();
+        order.confirmationNumber = confirmationNumber;
+        order.identifier = identifier;
+        order.url = url;
+        return { order };
+    });
+}
+function searchAuthorizeActions(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 取引に対する全ての承認アクションをマージ
+        let authorizeActions = yield repos.action.searchByPurpose({
+            typeOf: factory.actionType.AuthorizeAction,
+            purpose: {
+                typeOf: factory.transactionType.PlaceOrder,
+                id: params.id
+            }
+        });
+        // 万が一このプロセス中に他処理が発生してもそれらを無視するように、endDateでフィルタリング
+        authorizeActions = authorizeActions.filter((a) => (a.endDate !== undefined && a.endDate < params.result.order.orderDate));
+        return authorizeActions;
+    });
+}
+function createConfirmationNumber(params) {
+    return () => __awaiter(this, void 0, void 0, function* () {
+        const confirmationNumber = params.transaction.object.confirmationNumber;
+        let url = '';
+        let identifier = [];
+        // 取引に確認番号が保管されていなければ、確認番号を発行
+        if (typeof confirmationNumber !== 'string') {
+            // 事前に発行済なはずなので、ありえないフロー
+            throw new factory.errors.ServiceUnavailable('object.confirmationNumber undefined');
+        }
+        // URLの指定があれば上書き
+        // tslint:disable-next-line:no-single-line-block-comment
+        /* istanbul ignore if */
+        if (typeof params.result.order.url === 'string') {
+            url = params.result.order.url;
+        }
+        else /* istanbul ignore next */ if (typeof params.result.order.url === 'function') {
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore next */
+            url = params.result.order.url(params.order);
+        }
+        // 識別子の指定があれば上書き
+        identifier = [
+            ...(Array.isArray(params.result.order.identifier)) ? params.result.order.identifier : [],
+            // 取引に指定があれば追加
+            ...(Array.isArray(params.transaction.object.identifier)) ? params.transaction.object.identifier : []
+        ];
+        return { confirmationNumber, url, identifier };
+    });
+}
+/**
+ * インセンティブ承認
+ */
+function authorizeAward(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const transaction = yield repos.transaction.findInProgressById({
+            typeOf: factory.transactionType.PlaceOrder,
+            id: params.transaction.id
+        });
+        // tslint:disable-next-line:no-single-line-block-comment
+        /* istanbul ignore if: please write tests */
+        if (transaction.agent.id !== params.agent.id) {
+            throw new factory.errors.Forbidden('Transaction not yours');
+        }
+        if (transaction.agent.typeOf !== factory.personType.Person) {
+            throw new factory.errors.Forbidden('Membership required');
+        }
+        // いったん特典リセット
+        yield voidAward(params)(repos);
+        const givePointAwardParams = (_b = (_a = params.object) === null || _a === void 0 ? void 0 : _a.potentialActions) === null || _b === void 0 ? void 0 : _b.givePointAwardParams;
+        if (Array.isArray(givePointAwardParams)) {
+            const pointAwardIdentifiers = givePointAwardParams.map((g) => { var _a; return String((_a = g.object) === null || _a === void 0 ? void 0 : _a.identifier); });
+            // 取引にインセンティブ付与アクションパラメータを保管する
+            yield repos.transaction.findByIdAndUpdate({
+                id: transaction.id,
+                update: {
+                    $set: {
+                        'object.potentialActions.givePointAward': givePointAwardParams
+                    },
+                    // order.identifierに入金識別子を保管する
+                    $push: { 'object.identifier': { name: exports.POINT_AWARD_IDENTIFIER_NAME, value: JSON.stringify(pointAwardIdentifiers) } }
+                }
+            });
+        }
+    });
+}
+exports.authorizeAward = authorizeAward;
+/**
+ * インセンティブ承認を取り消す
+ */
+function voidAward(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const transaction = yield repos.transaction.findInProgressById({
+            typeOf: factory.transactionType.PlaceOrder,
+            id: params.transaction.id
+        });
+        // tslint:disable-next-line:no-single-line-block-comment
+        /* istanbul ignore if */
+        if (transaction.agent.id !== params.agent.id) {
+            throw new factory.errors.Forbidden('Transaction not yours');
+        }
+        yield repos.transaction.findByIdAndUpdate({
+            id: transaction.id,
+            update: {
+                $unset: {
+                    'object.potentialActions.givePointAward': 1
+                },
+                $pull: { 'object.identifier': { name: exports.POINT_AWARD_IDENTIFIER_NAME } }
+            }
+        });
+    });
+}
+exports.voidAward = voidAward;

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

@@ -0,0 +1,8 @@
+import * as factory from '../../../../factory';
+/**
+ * 取引のタスクを作成する
+ */
+export declare function createTasks(params: {
+    transaction: factory.transaction.ITransaction<factory.transactionType.ReturnOrder>;
+    runsAt: Date;
+}): factory.task.IAttributes<factory.taskName>[];

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTasks = void 0;
+const moment = require("moment");
+const factory = require("../../../../factory");
+const settings_1 = require("../../../../settings");
+/**
+ * 取引のタスクを作成する
+ */
+function createTasks(params) {
+    var _a;
+    const taskAttributes = [];
+    const transaction = params.transaction;
+    const taskRunsAt = params.runsAt;
+    // 取引削除タスクを作成(取引ステータスによってrunsAtを調整)
+    let deleteAt = moment(transaction.endDate)
+        .add(settings_1.TRANSACTION_CONFIRMED_STORAGE_PERIOD_IN_DAYS, 'days')
+        .toDate();
+    switch (transaction.status) {
+        case factory.transactionStatusType.Confirmed:
+            break;
+        case factory.transactionStatusType.Canceled:
+        case factory.transactionStatusType.Expired:
+            deleteAt = moment(transaction.endDate)
+                .add(settings_1.TRANSACTION_CANCELED_STORAGE_PERIOD_IN_DAYS, 'days')
+                .toDate();
+            break;
+        default:
+    }
+    const deleteTransactionTask = {
+        project: transaction.project,
+        name: factory.taskName.DeleteTransaction,
+        status: factory.taskStatus.Ready,
+        runsAt: deleteAt,
+        remainingNumberOfTries: 3,
+        numberOfTried: 0,
+        executionResults: [],
+        data: {
+            object: transaction
+        }
+    };
+    taskAttributes.push(deleteTransactionTask);
+    switch (transaction.status) {
+        case factory.transactionStatusType.Confirmed:
+            const returnOrderPotentialActions = (_a = transaction.potentialActions) === null || _a === void 0 ? void 0 : _a.returnOrder;
+            if (Array.isArray(returnOrderPotentialActions)) {
+                // 返品タスク
+                const returnOrderTask = returnOrderPotentialActions.map((r) => {
+                    return {
+                        project: transaction.project,
+                        name: factory.taskName.ReturnOrder,
+                        status: factory.taskStatus.Ready,
+                        runsAt: taskRunsAt,
+                        remainingNumberOfTries: 10,
+                        numberOfTried: 0,
+                        executionResults: [],
+                        data: r
+                    };
+                });
+                taskAttributes.push(...returnOrderTask);
+            }
+            break;
+        case factory.transactionStatusType.Expired:
+            // 特にタスクなし
+            break;
+        default:
+            throw new factory.errors.NotImplemented(`Transaction status "${transaction.status}" not implemented.`);
+    }
+    return taskAttributes;
+}
+exports.createTasks = createTasks;

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

@@ -0,0 +1,6 @@
+import * as factory from '../../../../factory';
+export declare type WebAPIIdentifier = factory.service.webAPI.Identifier;
+export declare function createReturnMoneyTransferActions(params: {
+    order: factory.order.IOrder;
+    returnOrderActionParams?: factory.transaction.returnOrder.IReturnOrderActionParams;
+}): Promise<factory.task.IData<factory.taskName.ReturnMoneyTransfer>[]>;

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

@@ -0,0 +1,81 @@
+"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.createReturnMoneyTransferActions = void 0;
+const factory = require("../../../../factory");
+const order_1 = require("../../../../factory/order");
+function createReturnMoneyTransferActions(params) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const order = params.order;
+        const returnMoneyTransferActions = [];
+        const purpose = {
+            project: order.project,
+            typeOf: order.typeOf,
+            seller: order.seller,
+            // mask
+            customer: (0, order_1.createMaskedCustomer)(order),
+            confirmationNumber: order.confirmationNumber,
+            orderNumber: order.orderNumber,
+            price: order.price,
+            priceCurrency: order.priceCurrency,
+            orderDate: order.orderDate
+        };
+        // 注文アイテムから返却アクションを作成する
+        const acceptedOffers = (Array.isArray(order.acceptedOffers)) ? order.acceptedOffers : [];
+        for (const acceptedOffer of acceptedOffers) {
+            if (acceptedOffer.itemOffered.typeOf === factory.actionType.MoneyTransfer) {
+                const moneyTransfer = acceptedOffer.itemOffered;
+                const transactionNumber = String((_b = (_a = moneyTransfer.object) === null || _a === void 0 ? void 0 : _a.pendingTransaction) === null || _b === void 0 ? void 0 : _b.transactionNumber);
+                const returnMoneyTransferAction = {
+                    project: order.project,
+                    typeOf: factory.actionType.ReturnAction,
+                    object: {
+                        project: order.project,
+                        typeOf: factory.actionType.MoneyTransfer,
+                        actionStatus: factory.actionStatusType.CompletedActionStatus,
+                        startDate: order.orderDate,
+                        id: '',
+                        amount: moneyTransfer.amount,
+                        object: {
+                            typeOf: factory.account.transactionType.Deposit,
+                            // いったんtransactionNumberさえあれば返却可能
+                            transactionNumber
+                        },
+                        agent: order.project,
+                        recipient: {
+                            typeOf: order.customer.typeOf,
+                            id: order.customer.id,
+                            name: String(order.customer.name)
+                        },
+                        fromLocation: {},
+                        toLocation: {},
+                        purpose: {}
+                    },
+                    agent: order.project,
+                    recipient: {
+                        // project: { typeOf: transaction.project.typeOf, id: transaction.project.id },
+                        typeOf: order.seller.typeOf,
+                        id: order.seller.id,
+                        name: order.seller.name
+                        // url: order.seller.url
+                    },
+                    potentialActions: {},
+                    purpose,
+                    instrument: { typeOf: 'WebAPI', identifier: factory.service.webAPI.Identifier.Chevre }
+                };
+                returnMoneyTransferActions.push(returnMoneyTransferAction);
+            }
+        }
+        return returnMoneyTransferActions;
+    });
+}
+exports.createReturnMoneyTransferActions = createReturnMoneyTransferActions;

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

@@ -0,0 +1,6 @@
+import * as factory from '../../../../factory';
+export declare function createReturnPaymentMethodActions(params: {
+    order: factory.order.IOrder;
+    returnOrderActionParams?: factory.transaction.returnOrder.IReturnOrderActionParams;
+    transaction: factory.transaction.returnOrder.ITransaction;
+}): Promise<factory.action.transfer.returnAction.paymentMethod.IAttributes[]>;