@chevre/domain 27.1.0-alpha.5 → 27.1.0-alpha.7

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

@@ -158,18 +158,6 @@ class ReturnOrderRepo {
             id: { $toString: '$_id' },
             ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
         };
-        // let projection: { [key in (IKeyOfProjection<T> | '__v' | 'createdAt' | 'updatedAt')]?: AnyExpression } = {};
-        // if (Array.isArray(params.inclusion) && params.inclusion.length > 0) {
-        //     params.inclusion.forEach((field) => {
-        //         projection[field] = 1;
-        //     });
-        // } else {
-        //     projection = {
-        //         __v: 0,
-        //         createdAt: 0,
-        //         updatedAt: 0
-        //     };
-        // }
         const query = this.transactionModel.find((conditions.length > 0) ? { $and: conditions } : {})
             .select(projection);
         if (typeof params.limit === 'number' && params.limit > 0) {
@@ -243,18 +231,6 @@ class ReturnOrderRepo {
             id: { $toString: '$_id' },
             ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
         };
-        // let projection: { [key in (IKeyOfProjection<T> | '__v' | 'createdAt' | 'updatedAt')]?: AnyExpression } = {};
-        // if (Array.isArray(inclusion) && inclusion.length > 0) {
-        //     inclusion.forEach((field) => {
-        //         projection[field] = 1;
-        //     });
-        // } else {
-        //     projection = {
-        //         __v: 0,
-        //         createdAt: 0,
-        //         updatedAt: 0
-        //     };
-        // }
         const doc = await this.transactionModel.findOne({
             _id: { $eq: params.id },
             typeOf: { $eq: params.typeOf }

package/lib/chevre/repo/transaction/returnOrderInProgress.d.ts

@@ -0,0 +1,19 @@
+import type { RedisClientType } from '@redis/client';
+import { factory } from '../../factory';
+import type { IStartedTransaction } from './returnOrder';
+/**
+ * 返品取引リポジトリ
+ */
+export declare class ReturnOrderInProgressRepo {
+    private static readonly KEY_PREFIX;
+    private readonly redisClient;
+    constructor(redisClient: RedisClientType);
+    /**
+     * 取引を開始する
+     */
+    startReturnOrder(params: factory.transaction.IStartParams<factory.transactionType.ReturnOrder>): Promise<IStartedTransaction>;
+    findReturnOrderById(params: {
+        typeOf: factory.transactionType.ReturnOrder;
+        id: string;
+    }): Promise<factory.transaction.ITransaction<factory.transactionType.ReturnOrder>>;
+}

package/lib/chevre/repo/transaction/returnOrderInProgress.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnOrderInProgressRepo = void 0;
+const moment_1 = __importDefault(require("moment"));
+const factory_1 = require("../../factory");
+/**
+ * 返品取引リポジトリ
+ */
+class ReturnOrderInProgressRepo {
+    static KEY_PREFIX = `txn:${factory_1.factory.transaction.returnOrder}`;
+    redisClient;
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    /**
+     * 取引を開始する
+     */
+    async startReturnOrder(params) {
+        const status = factory_1.factory.transactionStatusType.InProgress;
+        const tasksExportAction = { actionStatus: factory_1.factory.actionStatusType.PotentialActionStatus };
+        const startDate = new Date();
+        let expires;
+        const { typeOf } = params;
+        // expiresInSecondsの指定があれば優先して適用する(2022-11-25~)
+        if (typeof params.expiresInSeconds === 'number' && params.expiresInSeconds > 0) {
+            expires = (0, moment_1.default)(startDate)
+                .add(params.expiresInSeconds, 'seconds')
+                .toDate();
+        }
+        else {
+            throw new factory_1.factory.errors.ArgumentNull('expiresInSeconds');
+        }
+        const { agent, project, object, seller } = params;
+        const creatingTransaction = {
+            status, startDate, expires, typeOf, tasksExportAction,
+            agent, project, seller, object
+        };
+        const id = `${ReturnOrderInProgressRepo.KEY_PREFIX}:${startDate.getTime()}`;
+        const result = await this.redisClient.set(id, JSON.stringify(creatingTransaction), {
+            expiration: { type: 'PXAT', value: expires.getTime() },
+            condition: 'NX'
+        });
+        // 成功時は 'OK' が返り、既に存在した場合は null が返る
+        if (result !== 'OK') {
+            throw new factory_1.factory.errors.AlreadyInUse(factory_1.factory.transactionType.ReturnOrder, []);
+        }
+        return { expires, id, startDate, status };
+    }
+    async findReturnOrderById(params) {
+        let transaction;
+        const transactionJson = await this.redisClient.get(params.id);
+        if (typeof transactionJson !== 'string') {
+            throw new factory_1.factory.errors.NotFound(factory_1.factory.transactionType.ReturnOrder);
+        }
+        try {
+            transaction = JSON.parse(transactionJson);
+            transaction = {
+                ...transaction,
+                startDate: (0, moment_1.default)(transaction.startDate)
+                    .toDate(),
+                expires: (0, moment_1.default)(transaction.expires)
+                    .toDate(),
+                id: params.id
+            };
+        }
+        catch (error) {
+            console.error('transaction parse error:', error);
+            throw error;
+        }
+        return transaction;
+    }
+}
+exports.ReturnOrderInProgressRepo = ReturnOrderInProgressRepo;

package/lib/chevre/repository.d.ts

@@ -114,6 +114,7 @@ import type { TicketRepo } from './repo/ticket';
 import type { TransactionRepo } from './repo/transaction';
 import type { PlaceOrderRepo } from './repo/transaction/placeOrder';
 import type { ReturnOrderRepo } from './repo/transaction/returnOrder';
+import type { ReturnOrderInProgressRepo } from './repo/transaction/returnOrderInProgress';
 import type { TransactionNumberRepo } from './repo/transactionNumber';
 import type { TransactionProcessRepo } from './repo/transactionProcess';
 import type { WebSiteRepo } from './repo/webSite';
@@ -607,6 +608,10 @@ export declare namespace transaction {
     namespace ReturnOrder {
         function createInstance(...params: ConstructorParameters<typeof ReturnOrderRepo>): Promise<ReturnOrderRepo>;
     }
+    type ReturnOrderInProgress = ReturnOrderInProgressRepo;
+    namespace ReturnOrderInProgress {
+        function createInstance(...params: ConstructorParameters<typeof ReturnOrderInProgressRepo>): Promise<ReturnOrderInProgressRepo>;
+    }
 }
 export type TransactionNumber = TransactionNumberRepo;
 export declare namespace TransactionNumber {

package/lib/chevre/repository.js

@@ -1299,6 +1299,17 @@ var transaction;
         }
         ReturnOrder.createInstance = createInstance;
     })(ReturnOrder = transaction.ReturnOrder || (transaction.ReturnOrder = {}));
+    let ReturnOrderInProgress;
+    (function (ReturnOrderInProgress) {
+        let repo;
+        async function createInstance(...params) {
+            if (repo === undefined) {
+                repo = (await import('./repo/transaction/returnOrderInProgress.js')).ReturnOrderInProgressRepo;
+            }
+            return new repo(...params);
+        }
+        ReturnOrderInProgress.createInstance = createInstance;
+    })(ReturnOrderInProgress = transaction.ReturnOrderInProgress || (transaction.ReturnOrderInProgress = {}));
 })(transaction || (exports.transaction = transaction = {}));
 var TransactionNumber;
 (function (TransactionNumber) {

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

@@ -3,7 +3,7 @@ import type { SettingRepo } from '../../../repo/setting';
 import type { TaskRepo } from '../../../repo/task';
 import { factory } from '../../../factory';
 import { IReturnAction } from './onOrderReturned/factory';
-type IReturnOrderTransaction = Pick<factory.transaction.returnOrder.ITransaction, 'id' | 'typeOf' | 'potentialActions'>;
+type IReturnOrderTransaction = Pick<factory.transaction.returnOrder.ITransaction, 'typeOf' | 'potentialActions' | 'object'>;
 declare function onOrderReturned(params: {
     order: Pick<factory.order.IOrder, 'project' | 'typeOf' | 'orderNumber' | 'dateReturned' | 'id' | 'customer' | 'returner' | 'seller' | 'price' | 'priceCurrency' | 'orderDate'> & {
         orderStatus: factory.orderStatus.OrderReturned;

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

@@ -223,6 +223,10 @@ function createReturnPayTransactionTasks(order, returnOrderTransaction) {
     const returnPayActionsByReturnOrderTransaction = returnOrderPotentialActions?.returnPaymentMethod;
     if (Array.isArray(returnPayActionsByReturnOrderTransaction)) {
         tasks.push(...returnPayActionsByReturnOrderTransaction.map((a) => {
+            const data = {
+                ...a,
+                returnOrderTransaction: { object: returnOrderTransaction.object } // 返品取引廃止のために、必要な属性を拡張(2026-09-05~)
+            };
             return {
                 project: order.project,
                 name: factory_1.factory.taskName.ReturnPayTransaction,
@@ -231,7 +235,7 @@ function createReturnPayTransactionTasks(order, returnOrderTransaction) {
                 remainingNumberOfTries: 10,
                 numberOfTried: 0,
                 executionResults: [],
-                data: a
+                data
             };
         }));
     }

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

@@ -15,6 +15,7 @@ declare function returnOrder(params: {
         id: string;
     };
     useOnOrderStatusChanged: boolean;
+    returnOrderTransaction?: Pick<factory.transaction.returnOrder.ITransaction, 'object' | 'potentialActions' | 'typeOf'>;
 }): (repos: {
     acceptedOffer: AcceptedOfferRepo;
     actions: {

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

@@ -44,19 +44,25 @@ function returnOrder(params) {
                 // OrderDeliveredへの処理が進行中と考えられるので、ひとまず失敗させてリトライに期待
                 throw new factory_1.factory.errors.Argument('object.orderNumber', `orderStatus not returnable: ${order.orderStatus}`);
         }
-        // 返品取引検索
-        const returnOrderTransactions = await repos.returnOrder.findReturnOrderTransactions({
-            limit: 1,
-            page: 1,
-            project: { id: { $eq: order.project.id } },
-            typeOf: factory_1.factory.transactionType.ReturnOrder,
-            statuses: [factory_1.factory.transactionStatusType.Confirmed],
-            object: { order: { orderNumbers: [orderNumber] } },
-            inclusion: ['typeOf', 'potentialActions', 'object']
-        });
-        const returnOrderTransaction = returnOrderTransactions.shift();
-        if (returnOrderTransaction === undefined) {
-            throw new factory_1.factory.errors.NotFound(factory_1.factory.transactionType.ReturnOrder);
+        let returnOrderTransaction;
+        if (params.returnOrderTransaction !== undefined) {
+            returnOrderTransaction = params.returnOrderTransaction;
+        }
+        else {
+            // 互換性維持対応としての返品取引検索(2026-09-05~)
+            const returnOrderTransactions = await repos.returnOrder.findReturnOrderTransactions({
+                limit: 1,
+                page: 1,
+                project: { id: { $eq: order.project.id } },
+                typeOf: factory_1.factory.transactionType.ReturnOrder,
+                statuses: [factory_1.factory.transactionStatusType.Confirmed],
+                object: { order: { orderNumbers: [orderNumber] } },
+                inclusion: ['typeOf', 'potentialActions', 'object']
+            });
+            returnOrderTransaction = returnOrderTransactions.shift();
+            if (returnOrderTransaction === undefined) {
+                throw new factory_1.factory.errors.NotFound(factory_1.factory.transactionType.ReturnOrder);
+            }
         }
         const simpleOrder = {
             typeOf: order.typeOf,

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

@@ -0,0 +1,6 @@
+import { factory } from '../../factory';
+import type { ICallResult, IExecutableTaskKeys, IOperationExecute } from '../taskHandler';
+/**
+ * タスク実行関数
+ */
+export declare function call(params: Pick<factory.task.confirmReturnOrder.ITask, IExecutableTaskKeys>): IOperationExecute<ICallResult>;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.call = call;
+const factory_1 = require("../../factory");
+const task_1 = require("../../repo/task");
+/**
+ * タスク実行関数
+ */
+function call(params) {
+    return async ({ connection }) => {
+        const { data } = params;
+        await exportTasksById({
+            transaction: data
+        })({
+            task: new task_1.TaskRepo(connection),
+        });
+    };
+}
+function exportTasksById(params) {
+    return async (repos) => {
+        const { transaction } = params;
+        const taskRunsAt = new Date();
+        await repos.task.saveMany(createImmediateTasks({ transaction, taskRunsAt }));
+    };
+}
+function createImmediateTasks(params) {
+    const taskAttributes = [];
+    const transaction = params.transaction;
+    const taskRunsAt = params.taskRunsAt;
+    const returnOrderPotentialActions = transaction.potentialActions?.returnOrder;
+    if (Array.isArray(returnOrderPotentialActions)) {
+        // 返品タスク
+        const returnOrderTask = returnOrderPotentialActions.map((r) => {
+            const { object, potentialActions, typeOf } = transaction;
+            const returnOrderTaskData = {
+                agent: r.agent,
+                object: r.object,
+                project: transaction.project,
+                typeOf: r.typeOf,
+                returnOrderTransaction: { object, potentialActions, typeOf } // add(2026-09-05~)
+            };
+            return {
+                project: transaction.project,
+                name: factory_1.factory.taskName.ReturnOrder,
+                status: factory_1.factory.taskStatus.Ready,
+                runsAt: taskRunsAt,
+                remainingNumberOfTries: 10,
+                numberOfTried: 0,
+                executionResults: [],
+                data: returnOrderTaskData
+            };
+        });
+        taskAttributes.push(...returnOrderTask);
+    }
+    return taskAttributes;
+}

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

@@ -57,7 +57,8 @@ function call(params) {
     return async ({ connection }) => {
         await returnPayTransaction({
             ...params.data,
-            sameAs: { id: params.id }
+            sameAs: { id: params.id },
+            project: { id: params.project.id }
         })({
             actions: {
                 pay: new pay_1.PayActionRepo(connection),
@@ -86,8 +87,6 @@ function task2actionAttributes(params) {
     const purpose = {
         typeOf: order.typeOf,
         orderNumber: order.orderNumber,
-        // price: order.price,
-        // priceCurrency: order.priceCurrency,
         orderDate: order.orderDate
     };
     return {
@@ -101,7 +100,7 @@ function task2actionAttributes(params) {
         ...(typeof sameAs?.id === 'string') ? { sameAs: { id: sameAs.id, typeOf: 'Task' } } : undefined
     };
 }
-function fixOrderAndTransaction(params) {
+function fixOrderAndTransaction(params, project) {
     return async (repos) => {
         const paymentMethodId = params.object.paymentMethodId;
         // objectから注文を特定する(2024-06-19~)
@@ -115,19 +114,25 @@ function fixOrderAndTransaction(params) {
         }
         // const orderNumber = params.purpose.orderNumber;
         const orderNumber = orderByPaymentMethodId.orderNumber;
-        const returnOrderTransaction = (await repos.returnOrder.findReturnOrderTransactions({
-            limit: 1,
-            page: 1,
-            typeOf: factory_1.factory.transactionType.ReturnOrder,
-            object: { order: { orderNumbers: [orderNumber] } },
-            inclusion: ['object', 'project']
-        })).shift();
-        if (returnOrderTransaction === undefined) {
-            throw new factory_1.factory.errors.NotFound(factory_1.factory.transactionType.ReturnOrder);
+        let returnOrderTransaction;
+        if (params.returnOrderTransaction !== undefined) {
+            returnOrderTransaction = params.returnOrderTransaction;
+        }
+        else {
+            returnOrderTransaction = (await repos.returnOrder.findReturnOrderTransactions({
+                limit: 1,
+                page: 1,
+                typeOf: factory_1.factory.transactionType.ReturnOrder,
+                object: { order: { orderNumbers: [orderNumber] } },
+                inclusion: ['object']
+            })).shift();
+            if (returnOrderTransaction === undefined) {
+                throw new factory_1.factory.errors.NotFound(factory_1.factory.transactionType.ReturnOrder);
+            }
         }
         const order = await repos.order.projectFieldsByOrderNumber({
             orderNumber,
-            project: { id: returnOrderTransaction.project.id },
+            project: { id: project.id },
             inclusion: ['seller', 'project', 'dateReturned', 'typeOf', 'price', 'priceCurrency', 'orderNumber', 'orderDate', 'customer']
         });
         return { order, returnOrderTransaction };
@@ -138,7 +143,7 @@ function fixOrderAndTransaction(params) {
  */
 function returnPayTransaction(taskData) {
     return async (repos) => {
-        const { order, returnOrderTransaction } = await fixOrderAndTransaction(taskData)(repos);
+        const { order, returnOrderTransaction } = await fixOrderAndTransaction(taskData, { id: taskData.project.id })(repos);
         const paymentServiceType = taskData.object.issuedThrough?.typeOf;
         if (typeof paymentServiceType !== 'string' || paymentServiceType.length === 0) {
             throw new factory_1.factory.errors.ArgumentNull('object.issuedThrough.typeOf');

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

@@ -21,12 +21,14 @@ function createImmediateTasks(params) {
             if (Array.isArray(returnOrderPotentialActions)) {
                 // 返品タスク
                 const returnOrderTask = returnOrderPotentialActions.map((r) => {
+                    const { object, potentialActions, typeOf } = transaction;
                     // data最適化(2023-08-22~)
                     const returnOrderTaskData = {
                         agent: r.agent,
                         object: r.object,
                         project: transaction.project,
-                        typeOf: r.typeOf
+                        typeOf: r.typeOf,
+                        returnOrderTransaction: { object, potentialActions, typeOf } // add(2026-09-05~)
                     };
                     return {
                         project: transaction.project,

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

@@ -14,6 +14,7 @@ import type { SettingRepo } from '../../repo/setting';
 import type { ScheduledTaskRepo } from '../../repo/scheduledTask';
 import type { TaskRepo } from '../../repo/task';
 import type { IStartedTransaction, ReturnOrderRepo } from '../../repo/transaction/returnOrder';
+import type { ReturnOrderInProgressRepo } from '../../repo/transaction/returnOrderInProgress';
 import { preStart } from './returnOrder/preStart';
 interface IStartOperationRepos {
     acceptedOffer: AcceptedOfferRepo;
@@ -27,6 +28,7 @@ interface IStartOperationRepos {
     seller: SellerRepo;
     sellerReturnPolicy: SellerReturnPolicyRepo;
     returnOrder: ReturnOrderRepo;
+    returnOrderInProgress: ReturnOrderInProgressRepo;
 }
 type IStartOperation<T> = (repos: IStartOperationRepos) => Promise<T>;
 interface IExportTasksByIdRepos {
@@ -39,13 +41,17 @@ type ITaskAndTransactionOperation<T> = (repos: IExportTasksByIdRepos) => Promise
 /**
  * 返品取引開始
  */
-declare function start(params: factory.transaction.returnOrder.IStartParamsWithoutDetail): IStartOperation<IStartedTransaction>;
+declare function start(params: factory.transaction.returnOrder.IStartParamsWithoutDetail, options: {
+    useConfirmReturnOrderTask: boolean;
+}): IStartOperation<IStartedTransaction>;
 interface IConfirmRepos {
     acceptedOffer: AcceptedOfferRepo;
     message: MessageRepo;
     order: OrderRepo;
     setting: SettingRepo;
     returnOrder: ReturnOrderRepo;
+    returnOrderInProgress: ReturnOrderInProgressRepo;
+    task: TaskRepo;
 }
 /**
  * 取引確定
@@ -56,6 +62,8 @@ declare function confirm(params: factory.transaction.returnOrder.IConfirmParams
             dateReturned: Date;
         };
     };
+}, options: {
+    useConfirmReturnOrderTask: boolean;
 }): (repos: IConfirmRepos) => Promise<import("@chevre/factory/lib/chevre/transaction/returnOrder").IResult | undefined>;
 /**
  * 取引のタスクを出力します

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

@@ -20,8 +20,9 @@ const errorHandler_1 = require("../../errorHandler");
 /**
  * 返品取引開始
  */
-function start(params) {
+function start(params, options) {
     return async (repos) => {
+        const { useConfirmReturnOrderTask } = options;
         const { transactionObject, expiresInSeconds, seller } = await (0, preStart_1.preStart)(params)(repos);
         const returnOrderAttributes = {
             project: params.project,
@@ -36,15 +37,20 @@ function start(params) {
             expiresInSeconds
         };
         let returnOrderTransaction;
-        try {
-            returnOrderTransaction = await repos.returnOrder.startReturnOrder(returnOrderAttributes);
+        if (useConfirmReturnOrderTask) {
+            returnOrderTransaction = await repos.returnOrderInProgress.startReturnOrder(returnOrderAttributes);
         }
-        catch (error) {
-            if (await (0, errorHandler_1.isMongoDuplicateError)(error)) {
-                // 同一取引に対して返品取引を作成しようとすると、MongoDBでE11000 duplicate key errorが発生する
-                throw new factory_1.factory.errors.Argument('orderNumber', 'Already returned');
+        else {
+            try {
+                returnOrderTransaction = await repos.returnOrder.startReturnOrder(returnOrderAttributes);
+            }
+            catch (error) {
+                if (await (0, errorHandler_1.isMongoDuplicateError)(error)) {
+                    // 同一取引に対して返品取引を作成しようとすると、MongoDBでE11000 duplicate key errorが発生する
+                    throw new factory_1.factory.errors.Argument('orderNumber', 'Already returned');
+                }
+                throw error;
             }
-            throw error;
         }
         return returnOrderTransaction;
     };
@@ -78,18 +84,25 @@ function saveMessagesIfNeeded(params) {
 /**
  * 取引確定
  */
-function confirm(params) {
+function confirm(params, options) {
     return async (repos) => {
-        const transaction = await repos.returnOrder.findReturnOrderById({ typeOf: factory_1.factory.transactionType.ReturnOrder, id: params.id }, ['typeOf', 'status', 'project', 'agent', 'object', 'result']);
-        if (transaction.status === factory_1.factory.transactionStatusType.Confirmed) {
-            // すでに確定済の場合
-            return transaction.result;
-        }
-        else if (transaction.status === factory_1.factory.transactionStatusType.Expired) {
-            throw new factory_1.factory.errors.Argument('transaction', 'Transaction already expired');
+        const { useConfirmReturnOrderTask } = options;
+        let transaction;
+        if (useConfirmReturnOrderTask) {
+            transaction = await repos.returnOrderInProgress.findReturnOrderById({ typeOf: factory_1.factory.transactionType.ReturnOrder, id: params.id });
         }
-        else if (transaction.status === factory_1.factory.transactionStatusType.Canceled) {
-            throw new factory_1.factory.errors.Argument('transaction', 'Transaction already canceled');
+        else {
+            transaction = await repos.returnOrder.findReturnOrderById({ typeOf: factory_1.factory.transactionType.ReturnOrder, id: params.id }, ['typeOf', 'status', 'project', 'agent', 'object', 'result', 'startDate']);
+            if (transaction.status === factory_1.factory.transactionStatusType.Confirmed) {
+                // すでに確定済の場合
+                return transaction.result;
+            }
+            else if (transaction.status === factory_1.factory.transactionStatusType.Expired) {
+                throw new factory_1.factory.errors.Argument('transaction', 'Transaction already expired');
+            }
+            else if (transaction.status === factory_1.factory.transactionStatusType.Canceled) {
+                throw new factory_1.factory.errors.Argument('transaction', 'Transaction already canceled');
+            }
         }
         if (typeof params.agent?.id === 'string' && transaction.agent.id !== params.agent.id) {
             throw new factory_1.factory.errors.Forbidden('Transaction not yours');
@@ -110,18 +123,6 @@ function confirm(params) {
                 'orderedItem', 'paymentMethods', 'price', 'priceCurrency', 'project', 'seller', 'typeOf'
             ]
         });
-        // discontinue emailMessageRepo
-        // // デフォルトEメールメッセージを検索
-        // let emailMessageOnOrderReturned: factory.creativeWork.message.email.ICreativeWork | undefined;
-        // if (repos.emailMessage !== undefined) {
-        //     const searchEmailMessagesResult = await 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 setting = await repos.setting.findOne({ project: { id: { $eq: '*' } } }, ['defaultSenderEmail']);
         if (typeof setting?.defaultSenderEmail !== 'string') {
             throw new factory_1.factory.errors.NotFound('setting.defaultSenderEmail');
@@ -141,12 +142,38 @@ function confirm(params) {
             project: { id: transaction.project.id },
             order: { orderNumber: returningOrders[0].orderNumber }, seller: { id: returningOrders[0].seller.id }, emailMessages
         })(repos);
-        // ステータス変更
-        await repos.returnOrder.confirmReturnOrder({
-            typeOf: transaction.typeOf,
-            id: transaction.id,
-            result, potentialActions
-        });
+        if (useConfirmReturnOrderTask) {
+            // タスク作成
+            const endDate = new Date();
+            const task = {
+                project: transaction.project,
+                name: factory_1.factory.taskName.ConfirmReturnOrder,
+                status: factory_1.factory.taskStatus.Ready,
+                runsAt: endDate,
+                remainingNumberOfTries: 10,
+                numberOfTried: 0,
+                executionResults: [],
+                data: {
+                    typeOf: transaction.typeOf,
+                    id: transaction.id,
+                    agent: transaction.agent,
+                    startDate: transaction.startDate,
+                    object: transaction.object,
+                    project: transaction.project,
+                    potentialActions,
+                    endDate
+                }
+            };
+            await repos.task.saveMany([task]);
+        }
+        else {
+            // ステータス変更
+            await repos.returnOrder.confirmReturnOrder({
+                typeOf: transaction.typeOf,
+                id: transaction.id,
+                result, potentialActions
+            });
+        }
         return result;
     };
 }

package/package.json

@@ -11,7 +11,7 @@
   "dependencies": {
     "@aws-sdk/client-cognito-identity-provider": "3.1090.0",
     "@aws-sdk/credential-providers": "3.1090.0",
-    "@chevre/factory": "10.5.0-alpha.3",
+    "@chevre/factory": "10.5.0-alpha.7",
     "@motionpicture/coa-service": "10.0.0",
     "@motionpicture/gmo-service": "6.1.0-alpha.0",
     "@sendgrid/client": "8.1.4",
@@ -88,5 +88,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "27.1.0-alpha.5"
+  "version": "27.1.0-alpha.7"
 }