@chevre/domain 24.0.0-alpha.5 → 24.0.0-alpha.50

package/lib/chevre/service/assetTransaction/cancelReservation/factory.js

@@ -119,23 +119,7 @@ function createPotentialActions(params) {
             transaction.object.reservations.map((reservation) => {
                 // 最適化(2022-06-06~)
                 let cancelObject;
-                if (reservation.typeOf === factory.reservationType.BusReservation) {
-                    cancelObject = {
-                        typeOf: reservation.typeOf,
-                        id: reservation.id,
-                        issuedThrough: {
-                            typeOf: reservation.issuedThrough?.typeOf
-                        },
-                        reservationFor: {
-                            typeOf: reservation.reservationFor.typeOf,
-                            id: String(reservation.reservationFor.id)
-                        },
-                        reservationNumber: reservation.reservationNumber,
-                        // ReservationConfirmed->ReservationCancelledのみ処理されるように保証する
-                        reservationStatus: factory.reservationStatusType.ReservationConfirmed
-                    };
-                }
-                else if (reservation.typeOf === factory.reservationType.EventReservation) {
+                if (reservation.typeOf === factory.reservationType.EventReservation) {
                     cancelObject = {
                         typeOf: reservation.typeOf,
                         id: reservation.id,

package/lib/chevre/service/assetTransaction/cancelReservation/start.d.ts

@@ -18,8 +18,8 @@ export declare function validateStartParams(params: IStartParams): (repos: {
     assetTransaction: AssetTransactionRepo;
 }) => Promise<{
     reserveTransaction: import("@chevre/factory/lib/assetTransaction/reserve").ITransaction | undefined;
-    reservations: (Pick<import("@chevre/factory/lib/reservation/event").IReservation, "id" | "typeOf" | "issuedThrough" | "reservationNumber"> & {
-        reservationFor: Pick<factory.reservation.IReservationFor<factory.reservationType.EventReservation>, "id" | "typeOf">;
+    reservations: (Pick<import("@chevre/factory/lib/reservation/event").IReservation, "id" | "typeOf" | "reservationNumber" | "issuedThrough"> & {
+        reservationFor: Pick<factory.reservation.eventReservation.IReservationFor, "id" | "typeOf">;
     })[] | undefined;
 }>;
 /**

package/lib/chevre/service/assetTransaction/cancelReservation/start.js

@@ -63,7 +63,7 @@ function validateStartParams(params) {
         if (reserveTransaction === undefined) {
             // 予約存在確認
             if (typeof params.object.reservation?.id === 'string') {
-                const reservation = await repos.reservation.projectFieldsById({
+                const reservation = await repos.reservation.findReservationById({
                     id: params.object.reservation.id,
                     inclusion: [
                         'issuedThrough', 'typeOf', 'reservationNumber', 'reservationFor.id', 'reservationFor.typeOf', 'provider', 'reservationStatus'

package/lib/chevre/service/assetTransaction/moneyTransfer.js

@@ -61,8 +61,8 @@ function start(params) {
             throw new factory.errors.NotFound('Product');
         }
         // fromとtoをfix
-        const { fromLocation } = await fixFromLocation(params, product)(repos);
-        const { toLocation } = await fixToLocation(params, product)(repos);
+        const { fromLocation } = await fixFromLocation(params, product)({});
+        const { toLocation } = await fixToLocation(params, product)({});
         const amount = fixMonetaryAmount(params, product);
         // 自動発行廃止(2022-05-17~)
         const transactionNumber = params.transactionNumber;
@@ -202,7 +202,7 @@ function fixFromLocation(params, product) {
         const transactionType = params.object.pendingTransaction?.typeOf;
         switch (transactionType) {
             case factory.account.transactionType.Withdraw:
-            case factory.account.transactionType.Transfer:
+            case factory.account.transactionType.Transfer: {
                 const fromLocationObject = fromLocation;
                 // Permitの存在しない注文口座に対応する
                 const hasNoPermit = fromLocationObject.hasNoPermit === true;
@@ -237,6 +237,7 @@ function fixFromLocation(params, product) {
                     issuedThrough: { id: fromLocationObject.issuedThrough?.id }
                 };
                 break;
+            }
             default:
             // no op
         }
@@ -264,7 +265,7 @@ function fixToLocation(params, product) {
         const transactionType = params.object.pendingTransaction?.typeOf;
         switch (transactionType) {
             case factory.account.transactionType.Deposit:
-            case factory.account.transactionType.Transfer:
+            case factory.account.transactionType.Transfer: {
                 const toLocationObject = toLocation;
                 // Permitの存在しない注文口座に対応する
                 const hasNoPermit = toLocationObject.hasNoPermit === true;
@@ -299,6 +300,7 @@ function fixToLocation(params, product) {
                     issuedThrough: { id: toLocationObject.issuedThrough?.id }
                 };
                 break;
+            }
             default:
             // no op
         }
@@ -408,7 +410,7 @@ function exportTasksById(params) {
                 }
                 break;
             case factory.transactionStatusType.Canceled:
-            case factory.transactionStatusType.Expired:
+            case factory.transactionStatusType.Expired: {
                 const cancelMoneyTransferTaskAttributes = {
                     project: { typeOf: transaction.project.typeOf, id: transaction.project.id },
                     name: factory.taskName.CancelMoneyTransfer,
@@ -423,6 +425,7 @@ function exportTasksById(params) {
                 };
                 taskAttributes.push(cancelMoneyTransferTaskAttributes);
                 break;
+            }
             default:
                 throw new factory.errors.NotImplemented(`Transaction status "${transaction.status}" not implemented.`);
         }

package/lib/chevre/service/assetTransaction/pay/check.d.ts

@@ -1,20 +1,21 @@
 import * as factory from '../../../factory';
 import { Settings } from '../../../settings';
-import type { ActionRepo } from '../../../repo/action';
+import type { CheckMovieTicketActionRepo } from '../../../repo/action/checkMovieTicket';
 import type { CredentialsRepo } from '../../../repo/credentials';
 import type { EventRepo } from '../../../repo/event';
 import type { PaymentServiceRepo } from '../../../repo/paymentService';
 import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
 import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
 import * as MovieTicketPayment from '../../payment/movieTicket';
-export type ICheckOperation<T> = (repos: {
-    action: ActionRepo;
+export interface ICheckRepos {
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
     credentials: CredentialsRepo;
     event: EventRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;
     paymentService: PaymentServiceRepo;
     paymentServiceProvider: PaymentServiceProviderRepo;
-}, settings: Settings) => Promise<T>;
+}
+export type ICheckOperation<T> = (repos: ICheckRepos, settings: Settings) => Promise<T>;
 /**
  * 決済方法認証
  */

package/lib/chevre/service/assetTransaction/pay/confirm.d.ts

@@ -20,5 +20,5 @@ export type IConfirmOperation<T> = (repos: IConfirmRepos) => Promise<T>;
  * 取引確定
  */
 export declare function confirm(params: factory.assetTransaction.pay.IConfirmParams & {
-    options: {};
+    options: Record<string, never>;
 }): IConfirmOperation<void>;

package/lib/chevre/service/assetTransaction/pay/exportTasksById.js

@@ -94,7 +94,7 @@ function exportTasksById(params) {
             data: onAssetTransactionStatusChangedTaskData
         };
         switch (transaction.status) {
-            case factory.transactionStatusType.Confirmed:
+            case factory.transactionStatusType.Confirmed: {
                 const payActions = potentialActions?.pay;
                 if (Array.isArray(payActions) && payActions.length > 0) {
                     const payTasks = payActions.map(({ object, purpose }) => {
@@ -113,6 +113,7 @@ function exportTasksById(params) {
                     taskAttributes.push(...payTasks);
                 }
                 break;
+            }
             case factory.transactionStatusType.Canceled:
                 taskAttributes.push(voidPaymentTasks, onAssetTransactionStatusChangedTask);
                 break;

package/lib/chevre/service/assetTransaction/pay/publishPaymentUrl.d.ts

@@ -1,22 +1,25 @@
 import * as factory from '../../../factory';
 import { Settings } from '../../../settings';
 import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMethod';
-import type { ActionRepo } from '../../../repo/action';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AuthorizeInvoiceActionRepo } from '../../../repo/action/authorizeInvoice';
 import type { EventRepo } from '../../../repo/event';
 import type { EventSeriesRepo } from '../../../repo/eventSeries';
 import type { PaymentServiceRepo } from '../../../repo/paymentService';
 import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
 import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
 import * as CreditCardPayment from '../../payment/creditCard';
-export type IPublishPaymentUrlOperation<T> = (repos: {
+export interface IPublishPaymentUrlRepos {
     acceptedPaymentMethod: AcceptedPaymentMethodRepo;
-    action: ActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
+    acceptPayAction: AcceptPayActionRepo;
     event: EventRepo;
     eventSeries: EventSeriesRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;
     paymentService: PaymentServiceRepo;
     paymentServiceProvider: PaymentServiceProviderRepo;
-}, settings: Settings) => Promise<T>;
+}
+export type IPublishPaymentUrlOperation<T> = (repos: IPublishPaymentUrlRepos, settings: Settings) => Promise<T>;
 export type IPublishPaymentUrlResult = CreditCardPayment.IPaymentAgencyTransaction & {
     paymentMethodId: string;
     paymentUrl: string;

package/lib/chevre/service/assetTransaction/pay/publishPaymentUrl.js

@@ -102,12 +102,12 @@ function publishPaymentUrl(params, options) {
                 : undefined,
             ...(typeof params.identifier === 'string') ? { identifier: params.identifier } : undefined
         };
-        const action = await repos.action.start(actionAttributes);
+        const action = await repos.acceptPayAction.start(actionAttributes);
         let result;
         let recipe;
         try {
             switch (paymentServiceType) {
-                case factory.service.paymentService.PaymentServiceType.CreditCard:
+                case factory.service.paymentService.PaymentServiceType.CreditCard: {
                     const authorizeResult = await CreditCardPayment.authorize({
                         ...params,
                         id: '' // 決済URL発行プロセスにおいては決済取引IDは使用しないので空文字でok
@@ -141,13 +141,14 @@ function publishPaymentUrl(params, options) {
                         result
                     });
                     break;
+                }
                 default:
                     throw new factory.errors.NotImplemented(`Payment service '${paymentServiceType}' not implemented`);
             }
         }
         catch (error) {
             try {
-                await repos.action.giveUp({ typeOf: actionAttributes.typeOf, id: action.id, error });
+                await repos.acceptPayAction.giveUp({ typeOf: actionAttributes.typeOf, id: action.id, error });
             }
             catch (__) {
                 // 失敗したら仕方ない
@@ -158,7 +159,7 @@ function publishPaymentUrl(params, options) {
             paymentMethodId: result.paymentMethodId,
             paymentUrl: result.paymentUrl
         };
-        await repos.action.completeWithVoid({ typeOf: actionAttributes.typeOf, id: action.id, result: actionResult, recipe });
+        await repos.acceptPayAction.completeWithVoid({ typeOf: actionAttributes.typeOf, id: action.id, result: actionResult, recipe });
         return result;
     };
 }

package/lib/chevre/service/assetTransaction/pay/start/factory.js

@@ -83,7 +83,7 @@ function createStartParams(params, options) {
             };
             accountId = ''; // 強制的に空文字化(2024-06-14~)
             break;
-        case factory.service.paymentService.PaymentServiceType.MovieTicket:
+        case factory.service.paymentService.PaymentServiceType.MovieTicket: {
             const specifiedMovieTickets = params.object.paymentMethod?.movieTickets;
             totalPaymentDue = {
                 typeOf: 'MonetaryAmount',
@@ -103,6 +103,7 @@ function createStartParams(params, options) {
                 ? specifiedMovieTickets[0].identifier // 決済カードidentifierは1つのみ許可の前提
                 : '';
             break;
+        }
         default:
         // no op
     }

package/lib/chevre/service/assetTransaction/pay/start/processAuthorize.d.ts

@@ -1,7 +1,10 @@
 import * as factory from '../../../../factory';
 import { Settings } from '../../../../settings';
 import type { AccountingReportRepo } from '../../../../repo/accountingReport';
-import type { ActionRepo } from '../../../../repo/action';
+import type { PayActionRepo } from '../../../../repo/action/pay';
+import type { RefundActionRepo } from '../../../../repo/action/refund';
+import type { CheckMovieTicketActionRepo } from '../../../../repo/action/checkMovieTicket';
+import type { AuthorizeInvoiceActionRepo } from '../../../../repo/action/authorizeInvoice';
 import type { AssetTransactionRepo } from '../../../../repo/assetTransaction';
 import type { CredentialsRepo } from '../../../../repo/credentials';
 import type { EventRepo } from '../../../../repo/event';
@@ -13,7 +16,13 @@ import type { TaskRepo } from '../../../../repo/task';
 import { IPaymentAgencyTransaction } from '../../../payment/creditCard';
 export interface IProcessAuthorizeOperationRepos {
     accountingReport: AccountingReportRepo;
-    action: ActionRepo;
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
     credentials: CredentialsRepo;
     event: EventRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeCreditCard.d.ts

@@ -1,6 +1,6 @@
 import * as factory from '../../../../factory';
 import { Settings } from '../../../../settings';
-import type { ActionRepo } from '../../../../repo/action';
+import type { AuthorizeInvoiceActionRepo } from '../../../../repo/action/authorizeInvoice';
 import type { AssetTransactionRepo } from '../../../../repo/assetTransaction';
 import type { PaymentServiceRepo } from '../../../../repo/paymentService';
 import type { PaymentServiceProviderRepo } from '../../../../repo/paymentServiceProvider';
@@ -21,7 +21,7 @@ export declare function processAuthorizeCreditCard(params: factory.assetTransact
         id?: string;
     };
 }): (repos: {
-    action: ActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;
     paymentService: PaymentServiceRepo;
     paymentServiceProvider: PaymentServiceProviderRepo;

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeMovieTicket.d.ts

@@ -1,7 +1,9 @@
 import * as factory from '../../../../factory';
 import { Settings } from '../../../../settings';
 import type { AccountingReportRepo } from '../../../../repo/accountingReport';
-import type { ActionRepo } from '../../../../repo/action';
+import type { PayActionRepo } from '../../../../repo/action/pay';
+import type { RefundActionRepo } from '../../../../repo/action/refund';
+import type { CheckMovieTicketActionRepo } from '../../../../repo/action/checkMovieTicket';
 import type { AssetTransactionRepo } from '../../../../repo/assetTransaction';
 import type { CredentialsRepo } from '../../../../repo/credentials';
 import type { EventRepo } from '../../../../repo/event';
@@ -31,7 +33,12 @@ export declare function processAuthorizeMovieTicket(params: factory.assetTransac
     };
 }): (repos: {
     accountingReport: AccountingReportRepo;
-    action: ActionRepo;
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
     credentials: CredentialsRepo;
     event: EventRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;

package/lib/chevre/service/assetTransaction/pay/start.d.ts

@@ -2,7 +2,10 @@ import * as factory from '../../../factory';
 import { Settings } from '../../../settings';
 import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMethod';
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
-import type { ActionRepo } from '../../../repo/action';
+import type { PayActionRepo } from '../../../repo/action/pay';
+import type { RefundActionRepo } from '../../../repo/action/refund';
+import type { CheckMovieTicketActionRepo } from '../../../repo/action/checkMovieTicket';
+import type { AuthorizeInvoiceActionRepo } from '../../../repo/action/authorizeInvoice';
 import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
 import type { CredentialsRepo } from '../../../repo/credentials';
 import type { EventRepo } from '../../../repo/event';
@@ -17,7 +20,13 @@ import { IPaymentAgencyTransaction } from '../../payment/creditCard';
 export interface IStartOperationRepos {
     acceptedPaymentMethod: AcceptedPaymentMethodRepo;
     accountingReport: AccountingReportRepo;
-    action: ActionRepo;
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
     credentials: CredentialsRepo;
     event: EventRepo;
     eventSeries: EventSeriesRepo;

package/lib/chevre/service/assetTransaction/refund.d.ts

@@ -1,12 +1,15 @@
 import * as factory from '../../factory';
-import type { ActionRepo } from '../../repo/action';
+import type { PayActionRepo } from '../../repo/action/pay';
 import type { AssetTransactionRepo } from '../../repo/assetTransaction';
 import type { PaymentServiceRepo } from '../../repo/paymentService';
 import type { PotentialActionRepo } from '../../repo/potentialAction';
 import type { ProductRepo } from '../../repo/product';
 import type { TaskRepo } from '../../repo/task';
 export interface IStartOperationRepos {
-    action: ActionRepo;
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+    };
     paymentService: PaymentServiceRepo;
     potentialAction: PotentialActionRepo;
     product: ProductRepo;

package/lib/chevre/service/assetTransaction/refund.js

@@ -54,7 +54,7 @@ function start(params) {
         });
         const paymentServiceType = payTransaction.object.typeOf;
         // PayActionを確認する
-        const payAction = await repos.action.findPayAction({ project: { id: params.project.id }, paymentMethodId });
+        const payAction = await repos.actions.pay.findPayActionByPaymentMethodId({ project: { id: params.project.id }, paymentMethodId });
         if (payAction === undefined) {
             throw new factory.errors.NotFound(factory.actionType.PayAction);
         }

package/lib/chevre/service/assetTransaction/reserve/confirm/factory.d.ts

@@ -3,6 +3,6 @@ declare function createPotentialActions(params: {
     order?: Pick<factory.order.IOrder, 'orderNumber' | 'customer' | 'typeOf'>;
 }): {
     potentialActions: factory.assetTransaction.reserve.IPotentialActions;
-    underName?: factory.reservation.IUnderName<factory.reservationType.EventReservation>;
+    underName?: factory.assetTransaction.reserve.IUnderName;
 };
 export { createPotentialActions };

package/lib/chevre/service/assetTransaction/reserve/start/createSubReservations.js

@@ -421,7 +421,7 @@ function validateProgramMembershipUsed(params) {
                 throw new factory.errors.Argument('acceptedOffer.itemOffered.serviceOutput.programMembershipUsed', `invalid issuedThrough.typeOf: ${issuedThroughTypeOf}`);
             }
             switch (permitIssuedThrough.typeOf) {
-                case factory.service.paymentService.PaymentServiceType.FaceToFace:
+                case factory.service.paymentService.PaymentServiceType.FaceToFace: {
                     // 適用メンバーシップ条件有のオファーであれば、問答無用に受け入れる
                     const eligibleMembershipType = params.availableOffer.eligibleMembershipType?.[0]?.codeValue;
                     if (typeof eligibleMembershipType === 'string') {
@@ -435,8 +435,9 @@ function validateProgramMembershipUsed(params) {
                         };
                     }
                     break;
+                }
                 // 発行サービスがCreditCardのケースに対応(2023-09-01~)
-                case factory.service.paymentService.PaymentServiceType.CreditCard:
+                case factory.service.paymentService.PaymentServiceType.CreditCard: {
                     // 決済サービスのserviceOutputにPermitが存在すれば、設定されたメンバーシップ区分のPermitをprogramMembershipUsedとして適用する
                     let issuedThroughServiceType;
                     if (Array.isArray(permitIssuedThrough.serviceOutput)) {
@@ -460,7 +461,8 @@ function validateProgramMembershipUsed(params) {
                         throw new factory.errors.Argument('acceptedOffer.itemOffered.serviceOutput.programMembershipUsed', 'issuedThrough has no serviceOutput as Permit');
                     }
                     break;
-                case factory.product.ProductType.MembershipService:
+                }
+                case factory.product.ProductType.MembershipService: {
                     // requestedProgramMembershipUsedの発行サービスIDから外部連携設定を取得する
                     const permitService = await createPermitService({ issuedThrough: { id: permitIssuedThrough.id } })(repos);
                     // メンバーシップの存在確認
@@ -492,6 +494,7 @@ function validateProgramMembershipUsed(params) {
                         };
                     }
                     break;
+                }
                 default:
                     throw new factory.errors.Argument('acceptedOffer.itemOffered.serviceOutput.programMembershipUsed', `${permitIssuedThrough.typeOf} not implemented`);
             }

package/lib/chevre/service/assetTransaction/reserve/start/factory/createReservation.d.ts

@@ -2,10 +2,7 @@ import * as factory from '../../../../../factory';
 import { IMinimizedIndividualEvent } from '../../../../../factory/event';
 import { IAcceptedAddOn } from './price';
 type IObjectSubReservation = factory.assetTransaction.reserve.IObjectSubReservation;
-/**
- * 確定時予約のITicket
- */
-type IReservedTicket = Pick<factory.reservation.ITicket, 'identifier' | 'issuedBy' | 'ticketType' | 'ticketedSeat' | 'typeOf'>;
+type IReservedTicket = Pick<factory.assetTransaction.reserve.ISubReservationReservedTicket, 'identifier' | 'issuedBy' | 'ticketType' | 'ticketedSeat' | 'typeOf'>;
 declare function createReservedTicket(params: {
     id: string;
     acceptedOffer: factory.assetTransaction.reserve.IAcceptedTicketOfferWithoutDetail;
@@ -43,14 +40,14 @@ declare function createReservation(params: {
     };
     id: string;
     reservationFor: IMinimizedIndividualEvent;
-    reservedTicket: IReservedTicket;
+    reservedTicket: factory.assetTransaction.reserve.ISubReservationReservedTicket;
     additionalProperty?: factory.propertyValue.IPropertyValue<string>[];
     additionalTicketText?: string;
     ticketOffer: factory.product.ITicketOffer;
     seatPriceComponent: factory.place.seat.IPriceComponent[];
     acceptedAddOns: IAcceptedAddOn[];
-    subReservation?: factory.reservation.ISubReservation<factory.reservationType.EventReservation>[];
-    programMembershipUsed?: factory.reservation.IProgramMembershipUsed<factory.reservationType.EventReservation>;
+    subReservation?: factory.reservation.eventReservation.ISubReservation[];
+    programMembershipUsed?: factory.reservation.IProgramMembershipUsed;
     availableOffer: factory.unitPriceOffer.IUnitPriceOffer;
     appliesToMovieTicket?: factory.assetTransaction.reserve.IAcceptedAppliesToMovieTicket;
     validateAppliesToMovieTicket: boolean;

package/lib/chevre/service/assetTransaction/reserve/start/factory/createReservation.js

@@ -393,46 +393,6 @@ function createReservation(params) {
         };
     }
     else {
-        return {
-            // project: params.project,
-            typeOf: factory.reservationType.BusReservation,
-            id: params.id,
-            // reservationPackage保管に移行(2023-06-06~)
-            // issuedThrough,
-            additionalProperty: params.additionalProperty,
-            // bookingTime: params.reserveDate,
-            // modifiedTime: params.reserveDate,
-            numSeats: 1,
-            price: price4reservation,
-            priceCurrency: factory.priceCurrency.JPY,
-            // reservationNumber: params.reservationNumber,
-            // statusは不要なので削除(2023-07-19~)
-            // reservationStatus: factory.reservationStatusType.ReservationPending,
-            reservedTicket: params.reservedTicket,
-            // underName: {
-            //     typeOf: params.agent.typeOf,
-            //     name: params.agent.name
-            // },
-            // checkedIn: false,
-            // attended: false,
-            ...(typeof params.additionalTicketText === 'string') ? { additionalTicketText: params.additionalTicketText } : undefined,
-            ...(Array.isArray(params.subReservation))
-                ? {
-                    subReservation: params.subReservation.map((r) => {
-                        return {
-                            reservedTicket: {
-                                ticketedSeat: r.reservedTicket.ticketedSeat,
-                                typeOf: 'Ticket'
-                            }
-                        };
-                    })
-                }
-                : undefined,
-            // reservationPackage保管に移行(2023-06-06~)
-            // ...(typeof params.broker?.typeOf === 'string') ? { broker: params.broker } : undefined,
-            ...(typeof params.programMembershipUsed?.identifier === 'string')
-                ? { programMembershipUsed: params.programMembershipUsed }
-                : undefined
-        };
+        throw new factory.errors.NotImplemented(`reservationFor not implemented. typeOf:${params.reservationFor.typeOf}`);
     }
 }

package/lib/chevre/service/assetTransaction/reserve/start/factory/createStartParams.js

@@ -125,17 +125,15 @@ function createIssuedThrough(params) {
             typeOf: 'CategoryCode'
         }
         : undefined;
-    const availableChannel = eventOffers.itemOffered.availableChannel;
-    if (availableChannel === undefined) {
+    if (typeof eventOffers.itemOffered.id !== 'string') {
         // availableChannelは必ず存在するはず
-        throw new factory.errors.NotFound('reservationFor.offers.availableChannel');
+        throw new factory.errors.NotFound('reservationFor.offers.itemOffered.id');
     }
     if (params.reservationFor.typeOf === factory.eventType.ScreeningEvent) {
         const issuedThrough = {
             typeOf: factory.product.ProductType.EventService,
             // 興行IDを追加(2022-09-08~)
             id: eventOffers.itemOffered.id,
-            availableChannel,
             // issuedThrough.serviceTypeを連携
             ...(typeof serviceTypeOfIssuedThrough?.typeOf === 'string') ? { serviceType: serviceTypeOfIssuedThrough } : undefined
         };
@@ -144,16 +142,6 @@ function createIssuedThrough(params) {
         };
     }
     else {
-        const issuedThrough = {
-            typeOf: factory.product.ProductType.Transportation,
-            // 興行IDを追加(2022-09-08~)
-            id: eventOffers.itemOffered.id,
-            availableChannel,
-            // issuedThrough.serviceTypeを連携
-            ...(typeof serviceTypeOfIssuedThrough?.typeOf === 'string') ? { serviceType: serviceTypeOfIssuedThrough } : undefined
-        };
-        return {
-            issuedThrough
-        };
+        throw new factory.errors.NotImplemented(`reservationFor not implemented. typeOf:${params.reservationFor.typeOf}`);
     }
 }

package/lib/chevre/service/assetTransaction/reserve/start/factory/price.d.ts

@@ -14,4 +14,4 @@ export declare function createPrice(params: {
     seatPriceComponent: factory.place.seat.IPriceComponent[];
     acceptedAddOns: IAcceptedAddOn[];
     appliesToMovieTicket?: factory.assetTransaction.reserve.IAcceptedAppliesToMovieTicket;
-}): factory.reservation.IPriceSpecification<factory.reservationType.EventReservation>;
+}): factory.reservation.eventReservation.IPrice;

package/lib/chevre/service/assetTransaction/reserve/start.js

@@ -244,8 +244,10 @@ function searchEventSeatOffers(params) {
         const eventOffers = params.event.offers;
         const reservedSeatsAvailable = eventOffers?.itemOffered.serviceOutput?.reservedTicket?.ticketedSeat !== undefined;
         if (reservedSeatsAvailable) {
-            const roomBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.branchCode);
-            const movieTheaterBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.containedInPlace.branchCode);
+            // const roomBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.branchCode);
+            // const movieTheaterBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.containedInPlace.branchCode);
+            const roomBranchCode = params.event.location.branchCode;
+            const movieTheaterBranchCode = params.event.superEvent.location.branchCode;
             // reimplement using projectSeatsByScreeningRoom
             const seats = await repos.seat.projectSeatsByScreeningRoom({
                 project: { id: { $eq: params.event.project.id } },
@@ -499,11 +501,8 @@ function processLockOfferRateLimit(params) {
                         }
                     },
                     reservationFor: {
-                        startDate: (params.reservationFor.typeOf === factory.eventType.ScreeningEvent)
-                            ? (0, moment_1.default)(params.reservationFor.startDate)
-                                .toDate()
-                            : (0, moment_1.default)(params.reservationFor.departureTime)
-                                .toDate()
+                        startDate: (0, moment_1.default)(params.reservationFor.startDate)
+                            .toDate()
                     },
                     reservationNumber: params.reservationNumber
                 };

package/lib/chevre/service/assetTransaction/reserveCOA/cancel.d.ts

@@ -1,12 +1,24 @@
 import type * as COA from '@motionpicture/coa-service';
 import * as factory from '../../../factory';
 import { ActionRepo } from '../../../repo/action';
+import { AcceptCOAOfferActionRepo } from '../../../repo/action/acceptCOAOffer';
 import { TaskRepo } from '../../../repo/task';
-type ICancelOperation<T> = (repos: {
+interface ICancelRepos {
     action: ActionRepo;
     reserveService: COA.service.Reserve;
     task: TaskRepo;
-}) => Promise<T>;
+}
+type ICancelOperation<T> = (repos: ICancelRepos) => Promise<T>;
+interface ICancelByAcceptActionRepos {
+    action: ActionRepo;
+    acceptCOAOfferAction: AcceptCOAOfferActionRepo;
+    reserveService: COA.service.Reserve;
+    task: TaskRepo;
+}
+type ICancelByAcceptActionOperation<T> = (repos: ICancelByAcceptActionRepos) => Promise<T>;
+/**
+ * 興行オファー承認アクションからCOA予約を取り消す
+ */
 declare function cancel(params: {
     action: factory.action.authorize.offer.eventService.IAction;
 }, options: {
@@ -15,6 +27,9 @@ declare function cancel(params: {
      */
     asyncCancelPendingReservation: boolean;
 }): ICancelOperation<void>;
+/**
+ * 興行オファー採用アクションからCOA予約を取り消す
+ */
 declare function cancelByAcceptAction(params: {
     action: factory.action.accept.coaOffer.IAction;
 }, options: {
@@ -22,5 +37,5 @@ declare function cancelByAcceptAction(params: {
      * cancelPendingReservation async?(2025-03-03~)
      */
     asyncCancelPendingReservation: boolean;
-}): ICancelOperation<void>;
-export { cancel, cancelByAcceptAction };
+}): ICancelByAcceptActionOperation<void>;
+export { ICancelRepos, ICancelByAcceptActionRepos, cancel, cancelByAcceptAction };