@cinerino/sdk 12.9.0 → 12.10.0

package/example/src/chevre/admin/adminFindEvents.ts

@@ -0,0 +1,36 @@
+// tslint:disable:no-console
+// tslint:disable-next-line:no-implicit-dependencies
+import * as client from '../../../../lib/index';
+import * as auth from '../../auth/authAsAdmin';
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+const SELLER_ID = '59d20831e53ebc2b4e774466';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const authClient = await auth.login();
+    await authClient.refreshAccessToken();
+    const loginTicket = authClient.verifyIdToken({});
+    console.log('username is', loginTicket.getUsername());
+
+    const eventService = await (await client.loadChevreAdmin({
+        endpoint: <string>process.env.CHEVRE_ENDPOINT,
+        auth: authClient
+    })).createEventInstance({
+        project: { id: PROJECT_ID },
+        seller: { id: SELLER_ID }
+    });
+
+    const events = await eventService.findEvents({
+        limit: 10,
+        page: 1,
+        identifiers: ['x', '20251126ABC12345102200']
+    });
+    console.log(events);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/cloud/admin/adminEventsByIdentifier.ts

@@ -125,6 +125,16 @@ async function main() {
     //     }
     // );
     // console.log('updated.');
+
+    // イベントを検索する場合
+    const events = await adminEventService.findEvents({
+        limit: 1,
+        page: 1,
+        identifiers: [identifier]
+    });
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(events, { depth: null });
+    console.log(events.length, 'events found.');
 }
 
 main()

package/example/src/cloud/transaction/processPlaceOrderUsingEventOffer.ts

@@ -0,0 +1,312 @@
+// tslint:disable:no-console no-implicit-dependencies no-magic-numbers
+import * as moment from 'moment';
+import * as client from '../../../../lib/index';
+import { auth } from '../../auth/clientCredentials';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const { EVENT_ID } = process.env;
+const APPLICATION_IDENTIFIER = 'SmartTheaterTXN';
+
+type ISellerMakesOffer = Omit<client.factory.event.screeningEvent.ISellerMakesOffer, 'availableAtOrFrom'> & {
+    availableAtOrFrom?: client.factory.event.screeningEvent.IOfferAvailableAtOrFrom
+    | client.factory.event.screeningEvent.IOfferAvailableAtOrFrom[];
+};
+type ISeller = Omit<client.factory.event.screeningEvent.ISeller, 'makesOffer'> & {
+    makesOffer: ISellerMakesOffer[];
+};
+type IScreeningEventOffer = Omit<client.factory.event.screeningEvent.IOffer, 'seller'> & {
+    seller: ISeller;
+};
+type IScreeningEventExtensibleOffer = Omit<client.factory.event.screeningEvent.IExtensibleEventOffer, 'seller'> & {
+    seller: ISeller;
+};
+type IEvent = Omit<client.factory.event.screeningEvent.IEvent, 'offers'> & {
+    offers?: IScreeningEventOffer | IScreeningEventExtensibleOffer;
+};
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const eventService = new (await client.loadService()).Event({
+        endpoint: <string>process.env.API_ENDPOINT,
+        auth: await auth(),
+        project,
+        seller: { id: '' }
+    });
+
+    const sellerService = new (await client.loadService()).Seller({
+        endpoint: <string>process.env.API_ENDPOINT,
+        auth: await auth(),
+        project
+    });
+
+    const placeOrderService = await (await client.loadCloudTxn({
+        endpoint: <string>process.env.API_TXN_ENDPOINT,
+        auth: await auth()
+    })).createPlaceOrderInstance({
+        project,
+        seller: { id: '' }
+    });
+
+    // 販売劇場検索
+    const searchSellersResult = await sellerService.search({ branchCode: { $eq: '001' } });
+    // tslint:disable-next-line:insecure-random
+    const seller = searchSellersResult.data[Math.floor(searchSellersResult.data.length * Math.random())];
+    if (seller === undefined) {
+        throw new Error('No seller');
+    }
+    console.log('ordering from seller...', (<client.factory.multilingualString>seller.name).ja);
+
+    // イベント検索
+    const searchScreeningEventsResult = await eventService.search({
+        typeOf: client.factory.eventType.ScreeningEvent,
+        inSessionFrom: moment()
+            .toDate(),
+        inSessionThrough: moment()
+            .add(1, 'week')
+            .toDate(),
+        eventStatuses: [client.factory.eventStatusType.EventScheduled],
+        ...(typeof EVENT_ID === 'string') ? { id: { $eq: EVENT_ID } } : undefined
+    });
+    console.log(searchScreeningEventsResult.data.length, 'events found');
+
+    const availableEvents = <IEvent[]>searchScreeningEventsResult.data;
+    if (availableEvents.length === 0) {
+        throw new Error('No available events');
+    }
+
+    console.log('starting transaction...');
+    const transaction = await placeOrderService.start({
+        agent: {
+            identifier: [
+                { name: 'fromSamples', value: 'true' }
+            ]
+        },
+        seller: { id: String(seller.id) },
+        object: {
+            // passport: { token: passportToken }
+        }
+    });
+    console.log('transaction started', transaction.id);
+
+    try {
+        const numEvents = 1;
+        // tslint:disable-next-line:max-line-length
+        const authorizeSeatReservationResults: { price: number }[] = [];
+
+        // tslint:disable-next-line:no-increment-decrement
+        for (let i = 0; i < numEvents; i++) {
+            // イベント決定
+            // tslint:disable-next-line:insecure-random
+            const screeningEvent: IEvent = availableEvents[Math.floor(availableEvents.length * Math.random())];
+            const authorizeSeatReservationResult = await authorizeSeatReservationByEvent({
+                event: screeningEvent,
+                transaction: transaction
+            });
+            authorizeSeatReservationResults.push(authorizeSeatReservationResult);
+        }
+    } catch (error) {
+        console.error(error);
+    }
+
+    await wait(3000);
+
+    console.log('canceling transaction...');
+    await placeOrderService.cancel({ id: transaction.id });
+    console.log('transaction canceled.');
+}
+
+type IAuthorizeReservationAction = Pick<client.factory.action.authorize.offer.eventService.IAction, 'id'> & {
+    result?: {
+        price?: number;
+    };
+};
+
+// tslint:disable-next-line:max-func-body-length
+async function authorizeSeatReservationByEvent(params: {
+    event: IEvent;
+    transaction: Pick<client.factory.transaction.placeOrder.ITransaction, 'id'>;
+}): Promise<{
+    price: number;
+}> {
+    const eventService = new (await client.loadService()).Event({
+        endpoint: <string>process.env.API_ENDPOINT,
+        auth: await auth(),
+        project,
+        seller: { id: '' }
+    });
+
+    const offerService = await (await client.loadCloudTxn({
+        endpoint: <string>process.env.API_TXN_ENDPOINT,
+        auth: await auth()
+    })).createOfferInstance({
+        project,
+        seller: { id: '' }
+    });
+
+    const eventOfferService = await (await client.loadCloudSearch({
+        endpoint: <string>process.env.API_ENDPOINT,
+        auth: await auth()
+    })).createEventOfferInstance({
+        project,
+        seller: { id: '' }
+    });
+    const screeningEvent = params.event;
+    const transaction = params.transaction;
+
+    // 券種検索
+    let ticketOffers = await eventService.searchTicketOffers({
+        event: { id: screeningEvent.id }
+    });
+    console.log('チケットオファーは以下の通りです');
+    console.log(ticketOffers.map((o) => {
+        const unitPriceSpecification = o.priceSpecification.priceComponent
+            .filter((s) => s.typeOf === client.factory.priceSpecificationType.UnitPriceSpecification)
+            .map((s) => `単価:${s.price}/${(<client.factory.priceSpecification.IPriceSpecification<client.factory.priceSpecificationType.UnitPriceSpecification>>s).referenceQuantity.value}`)
+            .join(' ');
+        const categoryCodeCharge = o.priceSpecification.priceComponent
+            .filter((s) => s.typeOf === client.factory.priceSpecificationType.CategoryCodeChargeSpecification)
+            .map((s) => `+${(<client.factory.priceSpecification.IPriceSpecification<client.factory.priceSpecificationType.CategoryCodeChargeSpecification>>s).appliesToCategoryCode[0].codeValue}チャージ:${s.price} ${s.priceCurrency}`)
+            .join(' ');
+
+        return `${o.id} ${(<client.factory.multilingualString>o.name).ja} ${unitPriceSpecification} ${categoryCodeCharge}`;
+    })
+        .join('\n'));
+
+    // 空席検索
+    const searchSeatOffersResult = await eventService.searchSeats({
+        event: { id: screeningEvent.id },
+        limit: 100,
+        page: 1
+    });
+    const seatOffers = searchSeatOffersResult.data;
+    // console.log(seatOffers.length, 'seatOffers found');
+    // const seatOffers = offers[0].containsPlace;
+    console.log(seatOffers.length, 'seatOffers found');
+    const availableSeatOffers
+        = seatOffers.filter((o) => o.offers?.shift()?.availability === client.factory.itemAvailability.InStock);
+    console.log(availableSeatOffers.length, 'availableSeatOffers found');
+    if (availableSeatOffers.length <= 0) {
+        throw new Error('No available seats');
+    }
+
+    // ムビチケ以外のメンバーシップオファーを選択
+    ticketOffers = ticketOffers
+        .filter((offer) => {
+            const movieTicketTypeChargeSpecification = offer.priceSpecification.priceComponent.find(
+                (component) => component.typeOf === client.factory.priceSpecificationType.MovieTicketTypeChargeSpecification
+            );
+
+            return movieTicketTypeChargeSpecification === undefined;
+        });
+
+    const selectedTicketOffer = ticketOffers.shift();
+    if (selectedTicketOffer === undefined) {
+        throw new Error('selectedTicketOffer undefined');
+    }
+    console.log('ticket offer selected', selectedTicketOffer.id, selectedTicketOffer.identifier, selectedTicketOffer.name.ja);
+
+    // 座席をランダムに選択
+    const selectedScreeningRoomSection = String(availableSeatOffers[0].containedInPlace?.branchCode);
+    console.log('screening room section selected', selectedScreeningRoomSection);
+    console.log(selectedScreeningRoomSection);
+    const selectedSeatOffers = availableSeatOffers.slice(0, 1);
+    console.log(selectedSeatOffers.length, 'seats selected');
+
+    /**
+     * 拡張イベントオファー使用の場合のオファーチケットトークン
+     */
+    let ticketToken: string | undefined;
+    // 拡張イベントオファー使用の場合、イベントオファーチケットを発行する
+    if (screeningEvent.offers?.typeOf === client.factory.offerType.AggregateOffer) {
+        // イベントに対するイベントオファー検索
+        await wait(3000);
+        const eventOffers = await eventOfferService.findEventOffers({
+            limit: 20,
+            page: 1,
+            itemOfferedId: screeningEvent.id,
+            availableAtOrFromIdentifier: APPLICATION_IDENTIFIER // 指定のアプリケーションで有効なオファー
+        });
+        console.log(eventOffers.length, 'eventOffers found.', eventOffers);
+
+        // 有効なイベントオファーは？
+        const now = new Date();
+        const validEventOffer = eventOffers.find((eventOffer) => {
+            return moment(eventOffer.validFrom)
+                .isSameOrBefore(now)
+                && moment(eventOffer.validThrough)
+                    .isSameOrAfter(now);
+        });
+        if (validEventOffer === undefined) {
+            throw new Error('有効なイベントオファーが見つかりません');
+        }
+        console.log('有効なイベントオファーが見つかりました', validEventOffer.id, validEventOffer.identifier);
+
+        await wait(3000);
+        // 拡張オファー使用の場合、オファーコードを指定してオファーチケットを発行
+        const issueEventServiceOfferTicketResult = await offerService.issueEventServiceOfferTicket({
+            audience: { id: transaction.id },
+            eventId: screeningEvent.id,
+            eventOfferId: validEventOffer.id // 拡張オファー使用の場合、イベントオファーIDを指定する
+        });
+        console.log('offer ticket issued.', ticketToken);
+        ticketToken = issueEventServiceOfferTicketResult.ticketToken;
+    } else {
+        // no op
+    }
+
+    await wait(3000);
+    console.log('authorizing seat reservation...');
+    const seatReservationAuth = <IAuthorizeReservationAction>await offerService.authorizeEventService({
+        object: {
+            reservationFor: {
+                id: screeningEvent.id
+            },
+            acceptedOffer: selectedSeatOffers.map((o) => {
+                return {
+                    typeOf: selectedTicketOffer.typeOf,
+                    id: String(selectedTicketOffer.id),
+                    itemOffered: {
+                        serviceOutput: {
+                            typeOf: client.factory.reservationType.EventReservation,
+                            reservedTicket: {
+                                typeOf: 'Ticket',
+                                ticketedSeat: {
+                                    typeOf: client.factory.placeType.Seat,
+                                    seatNumber: o.branchCode,
+                                    seatSection: selectedScreeningRoomSection,
+                                    seatRow: ''
+                                }
+                            }
+                        }
+                    }
+                };
+            })
+        },
+        purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder },
+        instrument: [
+            ...(typeof ticketToken === 'string')
+                ? [{ ticketToken, typeOf: <'Ticket'>'Ticket' }] // オファーチケットを指定する
+                : []
+        ]
+    });
+    console.log('seat reservation authorized', seatReservationAuth.id);
+
+    const price = seatReservationAuth.result?.price;
+    // 金額計算
+    if (typeof price !== 'number') {
+        throw new Error('result.price undefined');
+    }
+    console.log('price:', price);
+
+    return { price };
+}
+
+async function wait(waitInMilliseconds: number) {
+    return new Promise((resolve) => setTimeout(resolve, waitInMilliseconds));
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/lib/abstract/chevreAdmin/event.d.ts

@@ -29,6 +29,41 @@ export interface IUpdateEventSellerMakesOfferParamsByIdentifier {
     location?: never;
     superEvent?: never;
 }
+/**
+ * adminイベント検索パラメータ
+ */
+export interface IFindParams {
+    /**
+     * max: 20
+     */
+    limit: number;
+    page: number;
+    /**
+     * イベント識別子リスト
+     * max length: 10
+     */
+    identifiers?: string[];
+}
+/**
+ * adminイベント検索結果
+ */
+export declare type IEventAsFindResult = Pick<factory.event.screeningEvent.IEvent, 'additionalProperty' | 'doorTime' | 'endDate' | 'eventStatus' | 'id' | 'identifier' | 'location' | 'maximumPhysicalAttendeeCapacity' | 'startDate' | 'superEvent' | 'typeOf'> & {
+    offers: {
+        /**
+         * AggregateOfferであれば拡張イベントオファー使用
+         */
+        typeOf: factory.offerType.AggregateOffer | factory.offerType.Offer;
+        /**
+         * 興行
+         */
+        itemOffered: {
+            /**
+             * 興行ID
+             */
+            id: string;
+        };
+    };
+};
 /**
  * イベントサービス
  */
@@ -93,5 +128,9 @@ export declare class EventService extends Service {
             };
         };
     }): Promise<void>;
+    /**
+     * 管理者によるイベント検索(在庫管理ロールが必要です)
+     */
+    findEvents(params: IFindParams): Promise<IEventAsFindResult[]>;
 }
 export {};

package/lib/abstract/chevreAdmin/event.js

@@ -174,6 +174,25 @@ var EventService = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * 管理者によるイベント検索(在庫管理ロールが必要です)
+     */
+    EventService.prototype.findEvents = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetch({
+                        uri: '/events',
+                        method: 'GET',
+                        qs: params,
+                        expectedStatusCodes: [http_status_1.OK]
+                    })
+                        .then(function (response) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, response.json()];
+                    }); }); })];
+            });
+        });
+    };
     return EventService;
 }(service_1.Service));
 exports.EventService = EventService;

package/lib/abstract/cloud/admin/event.d.ts

@@ -1,6 +1,6 @@
 import * as factory from '../../factory';
 import { Service } from '../../service';
-import { ICreateParamsByIdentifier, IUpdateParamsByIdentifier } from '../../chevreAdmin/event';
+import { ICreateParamsByIdentifier, IEventAsFindResult, IFindParams, IUpdateParamsByIdentifier } from '../../chevreAdmin/event';
 declare type ISendEmailMessageOnEventUpdated = Pick<factory.action.transfer.send.message.email.IAttributes, 'purpose' | 'recipient'> & {
     object: factory.action.transfer.send.message.email.IObjectAsEmailMessage;
 };
@@ -39,6 +39,10 @@ export declare class EventService extends Service {
     updateEventsByIdentifier(params: IUpdateParamsByIdentifier[], options: {
         typeOf: factory.eventType.ScreeningEvent;
     }): Promise<void>;
+    /**
+     * 管理者によるイベント検索(在庫管理ロールが必要です)
+     */
+    findEvents(params: IFindParams): Promise<IEventAsFindResult[]>;
     /**
      * イベントステータス更新
      */

package/lib/abstract/cloud/admin/event.js

@@ -136,6 +136,30 @@ var EventService = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * 管理者によるイベント検索(在庫管理ロールが必要です)
+     */
+    EventService.prototype.findEvents = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, auth, endpoint, project, seller, disableAutoRetry, chevreAdmin, eventService;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.options, auth = _a.auth, endpoint = _a.endpoint, project = _a.project, seller = _a.seller, disableAutoRetry = _a.disableAutoRetry;
+                        return [4 /*yield*/, index_1.loadChevreAdmin({ auth: auth, endpoint: endpoint, disableAutoRetry: disableAutoRetry })];
+                    case 1:
+                        chevreAdmin = _b.sent();
+                        return [4 /*yield*/, chevreAdmin.createEventInstance({
+                                project: project,
+                                seller: { id: (typeof (seller === null || seller === void 0 ? void 0 : seller.id) === 'string') ? seller.id : '' }
+                            })];
+                    case 2:
+                        eventService = _b.sent();
+                        return [2 /*return*/, eventService.findEvents(params)];
+                }
+            });
+        });
+    };
     /**
      * イベントステータス更新
      */

package/lib/bundle.js

@@ -3061,6 +3061,25 @@ var EventService = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * 管理者によるイベント検索(在庫管理ロールが必要です)
+     */
+    EventService.prototype.findEvents = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetch({
+                        uri: '/events',
+                        method: 'GET',
+                        qs: params,
+                        expectedStatusCodes: [http_status_1.OK]
+                    })
+                        .then(function (response) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, response.json()];
+                    }); }); })];
+            });
+        });
+    };
     return EventService;
 }(service_1.Service));
 exports.EventService = EventService;
@@ -21807,6 +21826,30 @@ var EventService = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * 管理者によるイベント検索(在庫管理ロールが必要です)
+     */
+    EventService.prototype.findEvents = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, auth, endpoint, project, seller, disableAutoRetry, chevreAdmin, eventService;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.options, auth = _a.auth, endpoint = _a.endpoint, project = _a.project, seller = _a.seller, disableAutoRetry = _a.disableAutoRetry;
+                        return [4 /*yield*/, index_1.loadChevreAdmin({ auth: auth, endpoint: endpoint, disableAutoRetry: disableAutoRetry })];
+                    case 1:
+                        chevreAdmin = _b.sent();
+                        return [4 /*yield*/, chevreAdmin.createEventInstance({
+                                project: project,
+                                seller: { id: (typeof (seller === null || seller === void 0 ? void 0 : seller.id) === 'string') ? seller.id : '' }
+                            })];
+                    case 2:
+                        eventService = _b.sent();
+                        return [2 /*return*/, eventService.findEvents(params)];
+                }
+            });
+        });
+    };
     /**
      * イベントステータス更新
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cinerino/sdk",
-  "version": "12.9.0",
+  "version": "12.10.0",
   "description": "Cinerino SDK",
   "main": "./lib/index.js",
   "browser": {