@cinerino/sdk 7.3.0-alpha.1 → 8.0.0-alpha.0

package/example/playground/public/lib/bundle.js

@@ -3394,7 +3394,7 @@ var PayAssetTransactionService = /** @class */ (function (_super) {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     /**
-     * 決済方法認証
+     * 決済カード認証
      */
     PayAssetTransactionService.prototype.check = function (params) {
         return __awaiter(this, void 0, void 0, function () {

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

@@ -0,0 +1,461 @@
+// tslint:disable:no-console no-implicit-dependencies no-magic-numbers
+import * as moment from 'moment';
+import * as readline from 'readline';
+import * as client from '../../../../lib/index';
+import { auth } from '../../auth/clientCredentials';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const profile = {
+    email: <string>process.env.TEST_PROFILE_EMAIL,
+    givenName: 'Taro',
+    familyName: 'SDK',
+    name: 'Taro ☆ SDK',
+    telephone: '+819012345678'
+};
+const paymentMethodType = 'CreditCard3DS';
+const paymentServiceId = '664d98376fb87922bd6a4e52';
+// 取引に使用するクレジットカード
+const creditCard: client.factory.paymentMethod.paymentCard.creditCard.IUncheckedCardRaw = {
+    cardNo: '4100000000000100',
+    expire: '2812',
+    cardPass: '123',
+    holderName: 'AA AA'
+};
+
+// 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 paymentService = await (await client.loadCloudPay({
+        endpoint: <string>process.env.API_PAY_ENDPOINT,
+        auth: await auth()
+    })).createPaymentInstance({
+        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<client.factory.eventType.ScreeningEvent>({
+        typeOf: client.factory.eventType.ScreeningEvent,
+        inSessionFrom: moment()
+            .toDate(),
+        inSessionThrough: moment()
+            .add(1, 'week')
+            .toDate()
+    });
+    console.log(searchScreeningEventsResult.data.length, 'events found');
+
+    const availableEvents = searchScreeningEventsResult.data;
+    if (availableEvents.length === 0) {
+        throw new Error('No available events');
+    }
+
+    console.log('starting transaction...');
+    const transaction = await placeOrderService.start({
+        agent: {},
+        seller: { id: String(seller.id) },
+        object: {
+            // passport: { token: passportToken }
+        }
+    });
+    console.log('transaction started', transaction.id);
+
+    try {
+        const numEvents = 1;
+        let amount = 0;
+        // 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 = availableEvents[Math.floor(availableEvents.length * Math.random())];
+            const authorizeSeatReservationResult = await authorizeSeatReservationByEvent({
+                event: screeningEvent,
+                transaction: transaction
+            });
+            amount += Number(authorizeSeatReservationResult.price);
+            authorizeSeatReservationResults.push(authorizeSeatReservationResult);
+        }
+
+        // 決済URL発行
+        const { paymentMethodId, paymentUrl } = await publishPaymentUrlAsyncForcibly({
+            object: {
+                amount,
+                paymentMethod: paymentMethodType,
+                method: '1',
+                creditCard: {
+                    ...creditCard,
+                    retUrl: String(process.env.SECURE_TRAN_RET_URL) // callbackを指定すると3DSとして処理される
+                },
+                issuedThrough: { id: paymentServiceId }
+            },
+            purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+        })({ paymentService });
+        console.log('paymentUrl published.', paymentMethodId, paymentUrl);
+
+        // wait callback...
+        await new Promise<void>((resolve, reject) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+
+            rl.question('callback received?:\n', async () => {
+                try {
+                    console.log('authorizing credit card payment...');
+                    const creditCardPaymentAuth = await authorizeCreditCardAsyncForcibly({
+                        object: {
+                            amount,
+                            // amount: 1, // 間違えてみる
+                            paymentMethod: paymentMethodType,
+                            paymentMethodId, // URL発行時のpaymentMethodIdを指定
+                            method: '1',
+                            creditCard,
+                            issuedThrough: { id: paymentServiceId }
+                        },
+                        purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+                    })({ paymentService });
+                    console.log('credit card payment authorized', creditCardPaymentAuth.id);
+
+                    // tslint:disable-next-line:no-magic-numbers
+                    await wait(3000);
+
+                    console.log('setting customer profile...');
+                    await placeOrderService.setProfile({
+                        id: transaction.id,
+                        agent: profile
+                    });
+                    console.log('customer profile set');
+
+                    await wait(3000);
+
+                    // console.log('voiding credit card auth...');
+                    // await paymentService.voidTransaction({
+                    //     id: creditCardPaymentAuth.id,
+                    //     object: { typeOf: client.factory.service.paymentService.PaymentServiceType.CreditCard },
+                    //     purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+                    // });
+                    // console.log('credit card auth voided');
+                    // await wait(3000);
+                    // return;
+
+                    console.log('confirming transaction...');
+
+                    let confirmResult = await placeOrderService.confirmWithMiminalResponse({ id: transaction.id });
+                    console.log('transaction confirmed', confirmResult);
+
+                    // 何度確定をコールしても冪等
+                    console.log('reconfirming transaction...');
+                    confirmResult = await placeOrderService.confirmWithMiminalResponse({ id: transaction.id });
+                    console.log('transaction reconfirmed', confirmResult);
+                    resolve();
+                } catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    } 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<client.factory.service.webAPI.Identifier.Chevre>,
+    'id'
+> & {
+    result?: {
+        price?: number;
+    };
+};
+
+// tslint:disable-next-line:max-func-body-length
+async function authorizeSeatReservationByEvent(params: {
+    event: client.factory.event.screeningEvent.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 = new (await client.loadService()).Offer({
+        endpoint: <string>process.env.API_ENDPOINT,
+        auth: await auth(),
+        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} ${o.priceCurrency} ${categoryCodeCharge}`;
+    })
+        .join('\n'));
+
+    // 空席検索
+    const searchSeatOffersResult = await eventService.searchSeats({ event: { id: screeningEvent.id } });
+    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');
+
+    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: ''
+                                }
+                            }
+                        }
+                    },
+                    additionalProperty: [{ name: 'sampleName', value: 'sampleValue' }]
+                };
+            })
+        },
+        purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+    });
+    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));
+}
+
+const USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_GIVE_UP_SECONDS = 10;
+const USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_CHECK_INTERVAL_MS = 1000;
+function publishPaymentUrlAsyncForcibly(params: {
+    object: Pick<client.factory.action.authorize.paymentMethod.any.IObjectWithoutDetail, 'amount' | 'creditCard' | 'issuedThrough' | 'paymentMethod' | 'method'>;
+    purpose: {
+        typeOf: client.factory.transactionType.PlaceOrder;
+        id: string;
+    };
+}) {
+    return async (repos: {
+        paymentService: client.cloudPay.service.Payment;
+    }): Promise<client.factory.action.accept.pay.IResult> => {
+        const acceptTask = await repos.paymentService.publishCreditCardPaymentUrlAsync(params);
+        const giveUpPayment = moment()
+            .add(USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_GIVE_UP_SECONDS, 'seconds');
+        let result: client.factory.action.accept.pay.IResult | undefined;
+        let error: { name?: string; message?: string } | undefined;
+
+        // n秒おきに状態確認
+        while (result === undefined && error === undefined) {
+            await wait(USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_CHECK_INTERVAL_MS); // n秒待機
+
+            // タスク作成から一定時間経過すればあきらめる
+            if (moment()
+                .isAfter(giveUpPayment)) {
+                error = new client.factory.errors.GatewayTimeout('action given up');
+                break;
+            }
+
+            const acceptAction = await repos.paymentService.findAcceptPayAction({
+                sameAs: { id: acceptTask.id },
+                purpose: params.purpose
+            });
+
+            // CompletedActionStatusであればタスク完了とみなす
+            if (acceptAction.actionStatus === client.factory.actionStatusType.CompletedActionStatus
+                && acceptAction.result !== undefined) {
+                result = acceptAction.result;
+                break;
+            } else {
+                // 待機続行
+            }
+
+            // エラーが存在すれば、これ以上待機する価値はなし
+            if (acceptAction.error !== undefined) {
+                error = acceptAction.error;
+                break;
+            }
+        }
+
+        if (typeof result?.paymentMethodId === 'string') {
+            return result;
+        }
+
+        throw error;
+    };
+}
+
+function authorizeCreditCardAsyncForcibly(params: {
+    object: Pick<
+        client.factory.action.authorize.paymentMethod.any.IObjectWithoutDetail,
+        'amount' | 'issuedThrough' | 'paymentMethod' | 'creditCard' | 'method' | 'paymentMethodId' | 'name' | 'additionalProperty'
+    >;
+    purpose: {
+        typeOf: client.factory.transactionType.PlaceOrder;
+        id: string;
+    };
+}) {
+    return async (repos: {
+        paymentService: client.cloudPay.service.Payment;
+    }): Promise<{ id: string }> => {
+        // 決済承認タスク作成
+        const authorizeTask = await repos.paymentService.authorizeCreditCardAsync(params);
+        const giveUpPayment = moment()
+            .add(USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_GIVE_UP_SECONDS, 'seconds');
+        let result: { id: string } | undefined;
+        let error: { name?: string; message?: string } | undefined;
+
+        // n秒おきに状態確認
+        while (result === undefined && error === undefined) {
+            await wait(USE_FORCE_AUTHORIZE_PAYMENT_ASYNC_CHECK_INTERVAL_MS); // n秒待機
+
+            // タスク作成から一定時間経過すればあきらめる
+            if (moment()
+                .isAfter(giveUpPayment)) {
+                error = new client.factory.errors.GatewayTimeout('action given up');
+                break;
+            }
+
+            const authorizeAction = await repos.paymentService.findAuthorizeAction({
+                sameAs: { id: authorizeTask.id },
+                object: {
+                    typeOf: client.factory.service.paymentService.PaymentServiceType.CreditCard
+                },
+                purpose: params.purpose
+            });
+
+            // アクションIDが存在し、CompletedActionStatusであればタスク完了とみなす
+            if (typeof authorizeAction.id === 'string') {
+                if (authorizeAction.actionStatus === client.factory.actionStatusType.CompletedActionStatus) {
+                    // ステータス完了であれば決済承認アクションIDを保管
+                    result = { id: authorizeAction.id };
+                    break;
+                } else {
+                    // 待機続行
+                }
+            }
+
+            // エラーが存在すれば、これ以上待機する価値はなし
+            if (authorizeAction.error !== undefined) {
+                error = authorizeAction.error;
+                break;
+            }
+        }
+
+        if (typeof result?.id === 'string') {
+            return result;
+        }
+
+        throw error;
+    };
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/transaction/processPlaceOrderByCreditCard3DS.ts

@@ -88,19 +88,7 @@ async function main() {
     });
     console.log('transaction started', transaction.id);
 
-    // 購入者情報入力時間
-    // tslint:disable-next-line:no-magic-numbers
-    await wait(3000);
-
-    console.log('setting customer profile...');
-    await placeOrderService.setProfile({
-        id: transaction.id,
-        agent: profile
-    });
-    console.log('customer profile set');
-
     try {
-
         const numEvents = 1;
         let amount = 0;
         // tslint:disable-next-line:max-line-length
@@ -159,6 +147,16 @@ async function main() {
                     })({ paymentService });
                     console.log('credit card payment authorized', creditCardPaymentAuth.id);
 
+                    // tslint:disable-next-line:no-magic-numbers
+                    await wait(3000);
+
+                    console.log('setting customer profile...');
+                    await placeOrderService.setProfile({
+                        id: transaction.id,
+                        agent: profile
+                    });
+                    console.log('customer profile set');
+
                     await wait(3000);
 
                     // console.log('voiding credit card auth...');
@@ -173,9 +171,13 @@ async function main() {
 
                     console.log('confirming transaction...');
 
-                    const confirmResult = await placeOrderService.confirmWithMiminalResponse({ id: transaction.id });
-                    console.log('transaction confirmed', confirmResult.order.orderNumber);
+                    let confirmResult = await placeOrderService.confirmWithMiminalResponse({ id: transaction.id });
+                    console.log('transaction confirmed', confirmResult);
 
+                    // 何度確定をコールしても冪等
+                    console.log('reconfirming transaction...');
+                    confirmResult = await placeOrderService.confirmWithMiminalResponse({ id: transaction.id });
+                    console.log('transaction reconfirmed', confirmResult);
                     resolve();
                 } catch (error) {
                     reject(error);

package/example/src/transaction/processPlaceOrderCOAEventByCreditCard.ts

@@ -95,17 +95,6 @@ async function main() {
     });
     console.log('transaction started', transaction.id);
 
-    // 購入者情報入力時間
-    // tslint:disable-next-line:no-magic-numbers
-    await wait(3000);
-
-    console.log('setting customer profile...');
-    await placeOrderService.setProfile({
-        id: transaction.id,
-        agent: profile
-    });
-    console.log('customer profile set');
-
     try {
 
         let amount = 0;
@@ -166,6 +155,16 @@ async function main() {
         // tslint:disable-next-line:no-magic-numbers
         await wait(3000);
 
+        console.log('setting customer profile...');
+        await placeOrderService.setProfile({
+            id: transaction.id,
+            agent: profile
+        });
+        console.log('customer profile set');
+
+        // tslint:disable-next-line:no-magic-numbers
+        await wait(3000);
+
         // 取引を中止する場合はコチラ↓
         // console.log('取引を中止します...');
         // await placeOrderService.cancel({ transactionId: transaction.id });
@@ -233,7 +232,7 @@ async function authorizeSeatReservationByEvent(params: {
         object: {
             event: {
                 id: params.event.id
-                // id: '120162210202406131200920'
+                // id: '120162210202406211200920'
             },
             acceptedOffer: [
                 {

package/example/src/transaction/processPlaceOrderCOAEventByMovieTicket.ts

@@ -179,7 +179,8 @@ async function main() {
                                 }
                             }
                         }
-                    }],
+                    }
+                ],
                 paymentMethod: 'MovieTicket',
                 issuedThrough: { id: PAYMENT_SERVICE_ID }
             },

package/lib/abstract/chevreTxn.d.ts

@@ -45,8 +45,8 @@ export declare namespace service {
 export declare class ChevreTxn {
     options: Pick<IOptions, 'auth' | 'endpoint'>;
     constructor(options: Pick<IOptions, 'auth' | 'endpoint'>);
-    createOfferInstance(params: Pick<IOptions, 'project'> & Pick<IAdditionalOptions, 'seller'>): Promise<OfferService>;
+    createOfferInstance(params: Pick<IOptions, 'project' | 'retryableStatusCodes'> & Pick<IAdditionalOptions, 'seller'>): Promise<OfferService>;
     createMoneyTransferTransactionInstance(params: Pick<IOptions, 'project'> & Pick<IAdditionalOptions, 'seller'>): Promise<MoneyTransferTransactionService>;
-    createPlaceOrderTransactionInstance(params: Pick<IOptions, 'project'> & Pick<IAdditionalOptions, 'seller'>): Promise<PlaceOrderTransactionService>;
-    createReturnOrderTransactionInstance(params: Pick<IOptions, 'project'> & Pick<IAdditionalOptions, 'seller'>): Promise<ReturnOrderTransactionService>;
+    createPlaceOrderTransactionInstance(params: Pick<IOptions, 'project' | 'retryableStatusCodes'> & Pick<IAdditionalOptions, 'seller'>): Promise<PlaceOrderTransactionService>;
+    createReturnOrderTransactionInstance(params: Pick<IOptions, 'project' | 'retryableStatusCodes'> & Pick<IAdditionalOptions, 'seller'>): Promise<ReturnOrderTransactionService>;
 }

package/lib/abstract/cloud/txn/offer.d.ts

@@ -0,0 +1,41 @@
+import type { IAuthorizeEventServiceResult, IMinimalAuthorizeEventServiceResult } from '../../chevreTxn/transaction/placeOrder/factory';
+import * as factory from '../../factory';
+import { IAdditionalOptions, IOptions, Service } from '../../service';
+/**
+ * オファーサービス
+ */
+export declare class OfferService extends Service {
+    constructor(options: Pick<IOptions, 'auth' | 'endpoint' | 'transporter' | 'project' | 'defaultPath' | 'retryableStatusCodes'> & IAdditionalOptions);
+    /**
+     * 興行オファー承認
+     */
+    authorizeEventService(params: {
+        object: factory.action.authorize.offer.eventService.IObjectWithoutDetail<factory.service.webAPI.Identifier.Chevre>;
+        purpose: factory.action.authorize.offer.eventService.IPurpose;
+    }, options?: {
+        /**
+         * レスポンスを最小化する
+         * Promise<IMinimalAuthorizeEventServiceResult>が返ります
+         */
+        expectsMinimalResponse?: boolean;
+        /**
+         * オファー未指定(座席をホールドするのみ)
+         */
+        noOfferSpecified?: boolean;
+    }): Promise<IAuthorizeEventServiceResult | IMinimalAuthorizeEventServiceResult>;
+    /**
+     * 興行オファー承認取消
+     */
+    voidAuthorization(params: {
+        /**
+         * アクションID
+         */
+        id: string;
+        object: {
+            itemOffered: {
+                typeOf: factory.product.ProductType.EventService;
+            };
+        };
+        purpose: factory.action.authorize.offer.eventService.IPurpose;
+    }): Promise<void>;
+}