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

package/lib/chevre/service/offer/any.d.ts

@@ -0,0 +1,29 @@
+import * as factory from '../../factory';
+import type { MongoRepository as OrderInTransactionRepo } from '../../repo/orderInTransaction';
+import type { RedisRepository as OrderNumberRepo } from '../../repo/orderNumber';
+import type { MongoRepository as ProjectRepo } from '../../repo/project';
+import type { MongoRepository as TransactionRepo } from '../../repo/transaction';
+interface IAcceptOfferOperationRepos {
+    orderInTransaction: OrderInTransactionRepo;
+    orderNumber: OrderNumberRepo;
+    project: ProjectRepo;
+    transaction: TransactionRepo;
+}
+type IAcceptOfferOperation<T> = (repos: IAcceptOfferOperationRepos) => Promise<T>;
+type IAuthorizeOfferAction = factory.action.authorize.offer.eventService.IAction<factory.service.webAPI.Identifier>;
+export declare function acceptOffer(params: {
+    project: {
+        id: string;
+    };
+    purpose: {
+        id: string;
+    };
+    acceptedOffers: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
+}): IAcceptOfferOperation<void>;
+export declare function voidAcceptedOffer(params: {
+    authorizeActions: IAuthorizeOfferAction[];
+    orderNumber: string;
+}): (repos: {
+    orderInTransaction: OrderInTransactionRepo;
+}) => Promise<void>;
+export {};

package/lib/chevre/service/offer/any.js

@@ -0,0 +1,55 @@
+"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.voidAcceptedOffer = exports.acceptOffer = void 0;
+const createDebug = require("debug");
+const factory = require("../../factory");
+const placeOrderInProgress_1 = require("../transaction/placeOrderInProgress");
+const debug = createDebug('chevre-domain:service:offer');
+function acceptOffer(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const now = new Date();
+        const orderNumber = yield (0, placeOrderInProgress_1.publishOrderNumberIfNotExist)({
+            project: { id: params.project.id },
+            id: params.purpose.id,
+            object: { orderDate: now }
+        })(repos);
+        yield repos.orderInTransaction.acceptOffer({
+            orderNumber,
+            project: { id: params.project.id, typeOf: factory.organizationType.Project },
+            acceptedOffers: params.acceptedOffers
+        });
+    });
+}
+exports.acceptOffer = acceptOffer;
+function voidAcceptedOffer(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const { authorizeActions, orderNumber } = params;
+        let reservationNumbers = [];
+        authorizeActions.forEach((authorizeAction) => {
+            var _a;
+            const reserveTransactionNumberByAction = (_a = authorizeAction.object.pendingTransaction) === null || _a === void 0 ? void 0 : _a.transactionNumber;
+            if (typeof reserveTransactionNumberByAction === 'string') {
+                reservationNumbers.push(reserveTransactionNumberByAction);
+            }
+        });
+        reservationNumbers = [...new Set(reservationNumbers)];
+        debug('removing acceptedOffers from PlaceOrder...', orderNumber, reservationNumbers);
+        if (reservationNumbers.length > 0) {
+            const result = yield repos.orderInTransaction.voidAcceptedOfferByReservationNumber({
+                orderNumber,
+                acceptedOffers: { reservationNumber: { $in: reservationNumbers } }
+            });
+            debug('acceptedOffers removed from PlaceOrder.', result);
+        }
+    });
+}
+exports.voidAcceptedOffer = voidAcceptedOffer;

package/lib/chevre/service/offer/event/authorize.d.ts

@@ -5,6 +5,8 @@ import type { MongoRepository as EventRepo } from '../../../repo/event';
 import type { MongoRepository as OfferRepo } from '../../../repo/offer';
 import type { MongoRepository as OfferCatalogRepo } from '../../../repo/offerCatalog';
 import type { MongoRepository as OfferCatalogItemRepo } from '../../../repo/offerCatalogItem';
+import type { MongoRepository as OrderInTransactionRepo } from '../../../repo/orderInTransaction';
+import type { RedisRepository as OrderNumberRepo } from '../../../repo/orderNumber';
 import type { MongoRepository as PaymentServiceRepo } from '../../../repo/paymentService';
 import type { MongoRepository as PlaceRepo } from '../../../repo/place';
 import type { MongoRepository as PriceSpecificationRepo } from '../../../repo/priceSpecification';
@@ -27,6 +29,8 @@ interface IAuthorizeRepos {
     offerCatalog: OfferCatalogRepo;
     offerCatalogItem: OfferCatalogItemRepo;
     offerRateLimit: OfferRateLimitRepo;
+    orderInTransaction: OrderInTransactionRepo;
+    orderNumber: OrderNumberRepo;
     paymentService: PaymentServiceRepo;
     place: PlaceRepo;
     priceSpecification: PriceSpecificationRepo;
@@ -69,5 +73,8 @@ declare function authorize(params: {
      * オファーID指定なしに座席をおさえる場合true
      */
     noOfferSpecified: boolean;
+    options: {
+        useCreateOrderOnOfferAccepted: boolean;
+    };
 }): IAuthorizeOperation<IAuthorizeOfferAction>;
 export { authorize };

package/lib/chevre/service/offer/event/authorize.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.authorize = void 0;
 const factory = require("../../../factory");
+const any_1 = require("../any");
 const defaultOffer_1 = require("./defaultOffer");
 const processStartReserve4chevre_1 = require("./processStartReserve4chevre");
 const searchEventTicketOffers_1 = require("./searchEventTicketOffers");
@@ -73,6 +74,16 @@ function authorize(params) {
                         stockHoldUntilDaysAfterEventEnd: params.stockHoldUntilDaysAfterEventEnd
                     })(repos);
                     acceptedOffers4result = processStartReserveResult.acceptedOffers4result;
+                    // add orderInTransaction(2024-01-15~)
+                    if (!noOfferSpecified) {
+                        if (params.options.useCreateOrderOnOfferAccepted) {
+                            yield (0, any_1.acceptOffer)({
+                                project: transaction.project,
+                                purpose: { id: transaction.id },
+                                acceptedOffers: acceptedOffers4result
+                            })(repos);
+                        }
+                    }
                     break;
                 default:
                     throw new factory.errors.Argument('Event', `Unknown booking service '${bookingServiceIdentifire}'`);

package/lib/chevre/service/offer/event/cancel.d.ts

@@ -1,6 +1,7 @@
 import * as factory from '../../../factory';
 import type { MongoRepository as ActionRepo } from '../../../repo/action';
 import type { MongoRepository as AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { MongoRepository as OrderInTransactionRepo } from '../../../repo/orderInTransaction';
 import type { RedisRepository as OfferRateLimitRepo } from '../../../repo/rateLimit/offer';
 import type { MongoRepository as ReservationRepo } from '../../../repo/reservation';
 import type { StockHolderRepository as StockHolderRepo } from '../../../repo/stockHolder';
@@ -11,6 +12,7 @@ interface ICancelRepos {
     assetTransaction: AssetTransactionRepo;
     stockHolder: StockHolderRepo;
     offerRateLimit: OfferRateLimitRepo;
+    orderInTransaction: OrderInTransactionRepo;
     reservation: ReservationRepo;
     task: TaskRepo;
     transaction: TransactionRepo;

package/lib/chevre/service/offer/event/cancel.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cancel = void 0;
 const factory = require("../../../factory");
 const ReserveTransactionService = require("../../assetTransaction/reserve");
+const any_1 = require("../any");
 /**
  * イベントオファー承認取消(apiから実行)
  * 特定の承認アクションについて処理する
@@ -28,12 +29,22 @@ function cancel(params) {
         }
         // MongoDBでcompleteステータスであるにも関わらず、Chevreでは削除されている、というのが最悪の状況
         // それだけは回避するためにMongoDBを先に変更
-        const action = yield repos.action.cancel({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+        yield repos.action.cancelWithVoid({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+        const action = yield repos.action.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
         switch (action.instrument.identifier) {
             case factory.service.webAPI.Identifier.COA:
                 // 実質使用する予定なしなので廃止(2022-05-12~)
                 throw new factory.errors.NotImplemented(`booking service '${action.instrument.identifier}' not implemented`);
             default:
+                // add orderInTransaction(2024-01-15~)
+                // USE_CREATE_ORDER_ON_OFFER_ACCEPTEDの場合、orderNumber発行済のはず
+                const orderNumberByTransaction = transaction.object.orderNumber;
+                if (typeof orderNumberByTransaction === 'string') {
+                    yield (0, any_1.voidAcceptedOffer)({
+                        authorizeActions: [action],
+                        orderNumber: orderNumberByTransaction
+                    })(repos);
+                }
                 const transactionNumber = (_a = action.object.pendingTransaction) === null || _a === void 0 ? void 0 : _a.transactionNumber;
                 if (typeof transactionNumber === 'string') {
                     // すでに取消済であったとしても、すべて取消処理(actionStatusに関係なく)

package/lib/chevre/service/offer/event/voidTransaction.d.ts

@@ -1,6 +1,7 @@
 import * as factory from '../../../factory';
 import type { MongoRepository as ActionRepo } from '../../../repo/action';
 import type { MongoRepository as AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { MongoRepository as OrderInTransactionRepo } from '../../../repo/orderInTransaction';
 import type { RedisRepository as OfferRateLimitRepo } from '../../../repo/rateLimit/offer';
 import type { MongoRepository as ReservationRepo } from '../../../repo/reservation';
 import type { StockHolderRepository as StockHolderRepo } from '../../../repo/stockHolder';
@@ -12,6 +13,7 @@ interface IVoidTransactionRepos {
     assetTransaction: AssetTransactionRepo;
     stockHolder: StockHolderRepo;
     offerRateLimit: OfferRateLimitRepo;
+    orderInTransaction: OrderInTransactionRepo;
     reservation: ReservationRepo;
     task: TaskRepo;
     transaction: TransactionRepo;

package/lib/chevre/service/offer/event/voidTransaction.js

@@ -15,6 +15,7 @@ const http_status_1 = require("http-status");
 const credentials_1 = require("../../../credentials");
 const factory = require("../../../factory");
 const ReserveTransactionService = require("../../assetTransaction/reserve");
+const any_1 = require("../any");
 const coaAuthClient = new COA.auth.RefreshToken({
     endpoint: credentials_1.credentials.coa.endpoint,
     refreshToken: credentials_1.credentials.coa.refreshToken
@@ -30,7 +31,7 @@ function voidTransaction(params) {
         const transaction = yield repos.transaction.findById({
             typeOf: params.purpose.typeOf,
             id: params.purpose.id,
-            inclusion: ['_id', 'typeOf', 'status']
+            inclusion: ['_id', 'typeOf', 'status', 'object.orderNumber']
         });
         // 興行オファー承認アクション検索
         let authorizeActions = yield repos.action.searchByPurpose({
@@ -41,9 +42,6 @@ function voidTransaction(params) {
             },
             object: { typeOf: { $eq: factory.action.authorize.offer.eventService.ObjectType.SeatReservation } }
         });
-        // .then((actions) => actions
-        //     .filter((a) => a.object.typeOf === factory.action.authorize.offer.eventService.ObjectType.SeatReservation)
-        // );
         switch (transaction.status) {
             case factory.transactionStatusType.InProgress:
                 throw new factory.errors.NotImplemented(`${transaction.status} not implemented`);
@@ -59,8 +57,17 @@ function voidTransaction(params) {
             default:
             // no op
         }
+        // add orderInTransaction(2024-01-15~)
+        // USE_CREATE_ORDER_ON_OFFER_ACCEPTEDの場合、orderNumber発行済のはず
+        const orderNumberByTransaction = transaction.object.orderNumber;
+        if (typeof orderNumberByTransaction === 'string') {
+            yield (0, any_1.voidAcceptedOffer)({
+                authorizeActions,
+                orderNumber: orderNumberByTransaction
+            })(repos);
+        }
         yield Promise.all(authorizeActions.map((action) => __awaiter(this, void 0, void 0, function* () {
-            yield repos.action.cancel({ typeOf: action.typeOf, id: action.id });
+            yield repos.action.cancelWithVoid({ typeOf: action.typeOf, id: action.id });
             switch (action.instrument.identifier) {
                 case exports.WebAPIIdentifier.COA:
                     yield processVoidTransaction4coa({

package/lib/chevre/service/offer/eventServiceByCOA/authorize.d.ts

@@ -0,0 +1,48 @@
+import type { MongoRepository as ActionRepo } from '../../../repo/action';
+import type { MongoRepository as CategoryCodeRepo } from '../../../repo/categoryCode';
+import type { MongoRepository as EventRepo } from '../../../repo/event';
+import type { MongoRepository as OfferRepo } from '../../../repo/offer';
+import type { MongoRepository as OrderInTransactionRepo } from '../../../repo/orderInTransaction';
+import type { RedisRepository as OrderNumberRepo } from '../../../repo/orderNumber';
+import type { MongoRepository as ProjectRepo } from '../../../repo/project';
+import type { MongoRepository as TransactionRepo } from '../../../repo/transaction';
+import { IAcceptedOfferBeforeAuthorize4COA } from './validateAcceptedOffers';
+import * as factory from '../../../factory';
+export import WebAPIIdentifier = factory.service.webAPI.Identifier;
+export type IAuthorizeActionResult = factory.action.authorize.offer.eventService.IResult<WebAPIIdentifier.COA>;
+export interface IAuthorizeRepos {
+    action: ActionRepo;
+    categoryCode: CategoryCodeRepo;
+    event: EventRepo;
+    offer: OfferRepo;
+    orderInTransaction: OrderInTransactionRepo;
+    orderNumber: OrderNumberRepo;
+    project: ProjectRepo;
+    transaction: TransactionRepo;
+}
+export type IAuthorizeOperation<T> = (repos: IAuthorizeRepos) => Promise<T>;
+export type IAuthorizeOfferAction = factory.action.authorize.offer.eventService.IAction<WebAPIIdentifier.COA>;
+/**
+ * COA興行オファー承認
+ */
+export declare function authorize(params: {
+    object: {
+        acceptedOffer: IAcceptedOfferBeforeAuthorize4COA[];
+        event: {
+            id: string;
+        };
+    };
+    agent: {
+        id: string;
+    };
+    transaction: {
+        id: string;
+    };
+    result: {
+        requestBody: factory.action.authorize.offer.eventService.IRequestBody<WebAPIIdentifier.COA>;
+        responseBody: factory.action.authorize.offer.eventService.IResponseBody<WebAPIIdentifier.COA>;
+    };
+    options: {
+        useCreateOrderOnOfferAccepted: boolean;
+    };
+}): IAuthorizeOperation<IAuthorizeOfferAction>;

package/lib/chevre/service/offer/eventServiceByCOA/authorize.js

@@ -0,0 +1,133 @@
+"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.authorize = exports.WebAPIIdentifier = void 0;
+const moment = require("moment");
+const any_1 = require("../any");
+const factory_1 = require("./factory");
+const validateAcceptedOffers_1 = require("./validateAcceptedOffers");
+const factory = require("../../../factory");
+exports.WebAPIIdentifier = factory.service.webAPI.Identifier;
+/**
+ * COA興行オファー承認
+ */
+function authorize(params) {
+    // tslint:disable-next-line:max-func-body-length
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const transaction = yield repos.transaction.findInProgressById({
+            typeOf: factory.transactionType.PlaceOrder,
+            id: params.transaction.id
+        });
+        if (transaction.agent.id !== params.agent.id) {
+            throw new factory.errors.Forbidden('Transaction not yours');
+        }
+        let screeningEvent;
+        let acceptedOffers;
+        const pendingTransaction = {
+            theaterCode: params.result.requestBody.theaterCode,
+            dateJouei: params.result.requestBody.dateJouei,
+            titleCode: params.result.requestBody.titleCode,
+            titleBranchNum: params.result.requestBody.titleBranchNum,
+            timeBegin: params.result.requestBody.timeBegin,
+            tmpReserveNum: params.result.responseBody.tmpReserveNum,
+            transactionNumber: params.result.responseBody.tmpReserveNum,
+            typeOf: 'COAReserveTransaction'
+        };
+        try {
+            // イベント取得属性最適化(2023-01-23~)
+            screeningEvent =
+                yield repos.event.findMinimizedIndividualEventById({ id: params.object.event.id });
+            const availablePaymentMethodTypes = yield repos.categoryCode.search({
+                project: { id: { $eq: transaction.project.id } },
+                inCodeSet: { identifier: { $eq: factory.categoryCode.CategorySetIdentifier.PaymentMethodType } }
+            }, [], []);
+            const seatingTypes = yield repos.categoryCode.search({
+                project: { id: { $eq: transaction.project.id } },
+                inCodeSet: { identifier: { $eq: factory.categoryCode.CategorySetIdentifier.SeatingType } }
+            }, [], []);
+            const videoFormatTypes = yield repos.categoryCode.search({
+                project: { id: { $eq: transaction.project.id } },
+                inCodeSet: { identifier: { $eq: factory.categoryCode.CategorySetIdentifier.VideoFormatType } }
+            }, [], []);
+            // COA仮予約後にリクエストが来る前提
+            const validateAcceptedOffersResult = yield (0, validateAcceptedOffers_1.validateAcceptedOffers)({
+                object: params.object,
+                project: { id: transaction.project.id },
+                screeningEvent,
+                availablePaymentMethodTypes,
+                seatingTypes,
+                videoFormatTypes
+            })(repos);
+            acceptedOffers = validateAcceptedOffersResult.acceptedOffers;
+        }
+        catch (error) {
+            // アクション開始前に例外がthrowされてもCOA仮予約を取り消す機会をつくるためにFailedアクションを作成する(2023-09-12~)
+            const failedActionAttributes = (0, factory_1.createAuthorizeSeatReservationActionAttributes)({
+                acceptedOffers: [],
+                event: { id: params.object.event.id, typeOf: factory.eventType.ScreeningEvent },
+                transaction,
+                pendingTransaction
+            });
+            const failedAction = yield repos.action.start(failedActionAttributes);
+            yield repos.action.giveUp({ typeOf: failedAction.typeOf, id: failedAction.id, error });
+            throw error;
+        }
+        let result;
+        // 承認アクションを開始
+        const actionAttributes = (0, factory_1.createAuthorizeSeatReservationActionAttributes)({
+            acceptedOffers,
+            event: screeningEvent,
+            transaction,
+            pendingTransaction
+        });
+        const action = yield repos.action.start(actionAttributes);
+        try {
+            // 座席仮予約からオファー情報を生成する
+            const { price, eligibleMonetaryAmount } = (0, factory_1.offers2resultPrice)(acceptedOffers);
+            const acceptedOffers4result = (0, factory_1.responseBody2acceptedOffers4result)({
+                responseBody: params.result.responseBody,
+                object: action.object,
+                event: screeningEvent,
+                seller: transaction.seller,
+                bookingTime: moment(action.startDate)
+                    .toDate(),
+                totalPrice: price
+            });
+            result = {
+                price: price,
+                priceCurrency: factory.priceCurrency.JPY,
+                amount: eligibleMonetaryAmount,
+                requestBody: params.result.requestBody,
+                responseBody: params.result.responseBody,
+                acceptedOffers: acceptedOffers4result
+            };
+            // add orderInTransaction(2024-01-15~)
+            if (params.options.useCreateOrderOnOfferAccepted) {
+                yield (0, any_1.acceptOffer)({
+                    project: transaction.project,
+                    purpose: { id: transaction.id },
+                    acceptedOffers: acceptedOffers4result
+                })(repos);
+            }
+        }
+        catch (error) {
+            try {
+                yield repos.action.giveUp({ typeOf: action.typeOf, id: action.id, error });
+            }
+            catch (__) {
+                // no op
+            }
+            throw error;
+        }
+        return yield repos.action.complete({ typeOf: action.typeOf, id: action.id, result });
+    });
+}
+exports.authorize = authorize;

package/lib/chevre/service/offer/eventServiceByCOA/cancel.d.ts

@@ -0,0 +1,39 @@
+import type { MongoRepository as ActionRepo } from '../../../repo/action';
+import type { MongoRepository as OrderInTransactionRepo } from '../../../repo/orderInTransaction';
+import type { MongoRepository as TransactionRepo } from '../../../repo/transaction';
+import * as factory from '../../../factory';
+export import WebAPIIdentifier = factory.service.webAPI.Identifier;
+interface ICancelResult {
+    theaterCode: string;
+    dateJouei: string;
+    titleCode: string;
+    titleBranchNum: string;
+    timeBegin: string;
+    tmpReserveNum: string;
+}
+/**
+ * COA興行オファー承認取消
+ */
+export declare function cancel(params: {
+    /**
+     * 承認アクションID
+     */
+    id: string;
+    /**
+     * 取引進行者
+     */
+    agent: {
+        id: string;
+    };
+    /**
+     * 取引
+     */
+    transaction: {
+        id: string;
+    };
+}): (repos: {
+    action: ActionRepo;
+    orderInTransaction: OrderInTransactionRepo;
+    transaction: TransactionRepo;
+}) => Promise<ICancelResult | undefined>;
+export {};

package/lib/chevre/service/offer/eventServiceByCOA/cancel.js

@@ -0,0 +1,58 @@
+"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.cancel = exports.WebAPIIdentifier = void 0;
+const factory = require("../../../factory");
+const any_1 = require("../any");
+exports.WebAPIIdentifier = factory.service.webAPI.Identifier;
+/**
+ * COA興行オファー承認取消
+ */
+function cancel(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const transaction = yield repos.transaction.findInProgressById({
+            typeOf: factory.transactionType.PlaceOrder,
+            id: params.transaction.id
+        });
+        if (transaction.agent.id !== params.agent.id) {
+            throw new factory.errors.Forbidden('Transaction not yours');
+        }
+        // 取引内のアクションかどうか確認
+        const action = yield repos.action.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+        if (action.purpose.typeOf !== transaction.typeOf || action.purpose.id !== transaction.id) {
+            throw new factory.errors.Argument('Transaction', 'Action not found in the transaction');
+        }
+        yield repos.action.cancelWithVoid({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+        // add orderInTransaction(2024-01-15~)
+        // USE_CREATE_ORDER_ON_OFFER_ACCEPTEDの場合、orderNumber発行済のはず
+        const orderNumberByTransaction = transaction.object.orderNumber;
+        if (typeof orderNumberByTransaction === 'string') {
+            yield (0, any_1.voidAcceptedOffer)({
+                authorizeActions: [action],
+                orderNumber: orderNumberByTransaction
+            })(repos);
+        }
+        let cancelResult;
+        const actionResult = action.result;
+        if ((actionResult === null || actionResult === void 0 ? void 0 : actionResult.requestBody) !== undefined && actionResult.responseBody !== undefined) {
+            cancelResult = {
+                theaterCode: actionResult.requestBody.theaterCode,
+                dateJouei: actionResult.requestBody.dateJouei,
+                titleCode: actionResult.requestBody.titleCode,
+                titleBranchNum: actionResult.requestBody.titleBranchNum,
+                timeBegin: actionResult.requestBody.timeBegin,
+                tmpReserveNum: actionResult.responseBody.tmpReserveNum
+            };
+        }
+        return cancelResult;
+    });
+}
+exports.cancel = cancel;

package/lib/chevre/service/offer/eventServiceByCOA/changeOffers.d.ts

@@ -0,0 +1,25 @@
+import { IAuthorizeOfferAction, IAuthorizeOperation } from './authorize';
+import { IAcceptedOfferBeforeAuthorize4COA } from './validateAcceptedOffers';
+import * as factory from '../../../factory';
+export import WebAPIIdentifier = factory.service.webAPI.Identifier;
+/**
+ * COA興行オファー承認のオファーを変更
+ */
+export declare function changeOffers(params: {
+    id: string;
+    object: {
+        acceptedOffer: IAcceptedOfferBeforeAuthorize4COA[];
+        event: {
+            id: string;
+        };
+    };
+    agent: {
+        id: string;
+    };
+    transaction: {
+        id: string;
+    };
+    options: {
+        useCreateOrderOnOfferAccepted: boolean;
+    };
+}): IAuthorizeOperation<IAuthorizeOfferAction>;