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

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/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/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.6",
+    "@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.6"
+  "version": "27.1.0-alpha.7"
 }