@cinerino/sdk 7.0.0-alpha.7 → 7.0.0-alpha.8

package/example/src/chevre/transaction/processPlaceOrderCOA.ts

@@ -3,7 +3,11 @@ import * as moment from 'moment';
 import * as client from '../../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
-
+const creditCard = {
+    cardNo: '4111111111111111',
+    expire: '2612',
+    holderName: 'AA BB'
+};
 const profile = {
     email: <string>process.env.TEST_PROFILE_EMAIL,
     givenName: 'Taro',
@@ -11,9 +15,254 @@ const profile = {
     name: 'Taro ☆ SDK',
     telephone: '+819012345678'
 };
+const ASYNC_ACTION_GIVEUP_SEC = 10;
+const ASYNC_ACTION_CHECK_INTERVAL_MS = 1000;
+const SELLER_ID = '5d0abf30ac3fb200198ebb2c';
+const EVENT_ID = '120162210202405271202250';
+
+function authorizeOfferAsync(params: {
+    /**
+     * 承認アクションID
+     */
+    originalAuthorizeAction?: string;
+    purpose: { id: string };
+}) {
+    // tslint:disable-next-line:max-func-body-length
+    return async (repos: {
+        offerService: client.chevreTxc.service.Offer;
+    }): Promise<{
+        /**
+         * 承認アクションID
+         */
+        id: string;
+        result: {
+            price?: Number;
+            responseBody: { tmpReserveNum: string };
+        };
+    }> => {
+        console.log('creating accept task..,');
+        const acceptTask = await repos.offerService.acceptOffer(
+            {
+                object: {
+                    event: { id: EVENT_ID },
+                    acceptedOffer: [{
+                        seatSection: '   ',
+                        seatNumber: 'ｂ－８',
+                        ticketInfo: {
+                            ticketCode: '171',
+                            mvtkAppPrice: 0,
+                            ticketCount: 1,
+                            addGlasses: 0,
+                            kbnEisyahousiki: '00',
+                            mvtkNum: '',
+                            mvtkKbnDenshiken: '00',
+                            mvtkKbnMaeuriken: '00',
+                            mvtkKbnKensyu: '00',
+                            mvtkSalesPrice: 0,
+                            kbnMgtk: ''
+                        }
+                    }],
+                    appliesToSurfrock: {
+                        identifier: '',
+                        serviceOutput: { typeOf: '' }
+                    }
+                },
+                purpose: { id: params.purpose.id, typeOf: client.factory.transactionType.PlaceOrder },
+                ...(typeof params.originalAuthorizeAction === 'string')
+                    ? { potentialActions: { id: params.originalAuthorizeAction } }
+                    : undefined
+            }
+        );
+        console.log('acceptTask created,', acceptTask);
+
+        const giveUpPayment = moment()
+            .add(ASYNC_ACTION_GIVEUP_SEC, 'seconds');
+        let result: { id: string } | undefined;
+        let error: any;
+
+        // n秒おきに状態確認
+        while (result === undefined && error === undefined) {
+            // n秒待機
+            await wait(ASYNC_ACTION_CHECK_INTERVAL_MS);
+
+            // タスク作成から一定時間経過すればあきらめる
+            if (moment()
+                .isAfter(giveUpPayment)) {
+                error = new Error('action gaven up');
+                break;
+            }
+
+            const acceptAction = await repos.offerService.findAcceptAction({
+                sameAs: { id: acceptTask.id },
+                purpose: { id: params.purpose.id, typeOf: client.factory.transactionType.PlaceOrder }
+            });
+            console.log('acceptAction:,', acceptAction);
+
+            if (typeof acceptAction.id === 'string') {
+                if (acceptAction.actionStatus === client.factory.actionStatusType.CompletedActionStatus) {
+                    // ステータス完了であれば決済承認アクションIDを保管
+                    result = { id: acceptAction.id };
+                    break;
+                } else {
+                    // 待機続行
+                }
+            }
+
+            // エラーが存在すれば、これ以上待機する価値はなし
+            if (acceptAction.error !== undefined) {
+                error = acceptAction.error;
+                break;
+            }
+        }
+
+        if (typeof result?.id === 'string') {
+            console.log('offer accepted.', result);
+
+            // tslint:disable-next-line:no-magic-numbers
+            await wait(3000);
+            console.log('authorizing by acceptAction...', result.id);
+
+            return repos.offerService.authorizeEventServiceByCOA({
+                acceptAction: { id: result.id },
+                purpose: { id: params.purpose.id, typeOf: client.factory.transactionType.PlaceOrder }
+            });
+        }
+
+        throw error;
+    };
+}
+
+function voidAuthorizeOfferAsync(params: {
+    /**
+     * 承認アクションID
+     */
+    originalAuthorizeAction: string;
+    purpose: { id: string };
+}) {
+    return async (repos: {
+        offerService: client.chevreTxc.service.Offer;
+    }): Promise<void> => {
+        console.log('creating accept task..,');
+        const voidTask = await repos.offerService.voidAuthorizationByCOA(
+            {
+                id: params.originalAuthorizeAction,
+                purpose: { id: params.purpose.id, typeOf: client.factory.transactionType.PlaceOrder }
+            }
+        );
+        console.log('voidTask created,', voidTask);
+
+        const giveUpPayment = moment()
+            .add(ASYNC_ACTION_GIVEUP_SEC, 'seconds');
+        let result: { status: client.factory.taskStatus } | undefined;
+        let error: any;
+
+        // n秒おきに状態確認
+        while (result === undefined && error === undefined) {
+            // n秒待機
+            await wait(ASYNC_ACTION_CHECK_INTERVAL_MS);
+
+            // タスク作成から一定時間経過すればあきらめる
+            if (moment()
+                .isAfter(giveUpPayment)) {
+                error = new Error('action gaven up');
+                break;
+            }
+
+            const voidTaskWithStatus = await repos.offerService.findVoidTask({
+                actionId: params.originalAuthorizeAction,
+                taskId: voidTask.id,
+                purpose: { id: params.purpose.id, typeOf: client.factory.transactionType.PlaceOrder }
+            });
+            console.log('voidTaskWithStatus:,', voidTaskWithStatus);
+
+            if (voidTaskWithStatus.status === client.factory.taskStatus.Executed) {
+                // ステータス完了であれば決済承認アクションIDを保管
+                result = voidTaskWithStatus;
+                break;
+            } else {
+                // 待機続行
+            }
+        }
+
+        if (typeof result?.status === 'string') {
+            console.log('voidTask executed.', result);
+
+            return;
+        }
+
+        throw error;
+    };
+}
+
+function authorizeCreditCardAsync(params: {
+    object: {
+        amount: number;
+        paymentMethod: string;
+        method: string;
+        creditCard: typeof creditCard;
+        issuedThrough: { id: string };
+    };
+    purpose: { id: string; typeOf: client.factory.transactionType.PlaceOrder };
+}) {
+    return async (repos: {
+        paymentService: client.chevrePay.service.Payment;
+    }): Promise<{
+        /**
+         * 承認アクションID
+         */
+        id: string;
+    }> => {
+        // 決済承認タスク作成
+        const authorizeTask = await repos.paymentService.authorizeCreditCard(params, { async: true });
+        const giveUpPayment = moment()
+            .add(ASYNC_ACTION_GIVEUP_SEC, 'seconds');
+        let result: { id: string } | undefined;
+        let error: any;
+
+        // n秒おきに状態確認
+        while (result === undefined && error === undefined) {
+            // n秒待機
+            await wait(ASYNC_ACTION_CHECK_INTERVAL_MS);
+
+            // タスク作成から一定時間経過すればあきらめる
+            if (moment()
+                .isAfter(giveUpPayment)) {
+                error = new Error('action gaven up');
+                break;
+            }
 
-// export type IAuthorizeReservationAction
-//     = client.factory.action.authorize.offer.eventService.IAction<client.factory.service.webAPI.Identifier.Chevre>;
+            const authorizeAction = await repos.paymentService.findAuthorizeAction({
+                sameAs: { id: authorizeTask.id },
+                object: {
+                    typeOf: client.factory.service.paymentService.PaymentServiceType.CreditCard
+                },
+                purpose: params.purpose
+            });
+
+            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;
+    };
+}
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
@@ -24,7 +273,6 @@ async function main() {
         scopes: [],
         state: ''
     });
-
     const placeOrderService = await (await client.loadChevreTxn({
         endpoint: `${<string>process.env.CHEVRE_ENDPOINT}/txn`,
         auth: authClient
@@ -32,166 +280,114 @@ async function main() {
         project,
         seller: { id: '' }
     });
-    const offerService = await (await client.loadChevreTxncoa({
-        endpoint: `${<string>process.env.CHEVRE_ENDPOINT}/txncoa`,
+    const offerService = await (await client.loadChevreTxc({
+        endpoint: `${<string>process.env.CHEVRE_ENDPOINT}/txc`,
         auth: authClient
     })).createOfferInstance({
         project,
         seller: { id: '' }
     });
+    const paymentService = await (await client.loadChevrePay({
+        endpoint: `${<string>process.env.CHEVRE_ENDPOINT}/pay`,
+        auth: authClient
+    })).createPaymentInstance({
+        project,
+        seller: { id: '' }
+    });
 
     console.log('starting transaction...');
     const transaction = await placeOrderService.start({
         agent: {},
-        seller: {
-            id: '5d0abf30ac3fb200198ebb2c'
-        },
+        seller: { id: SELLER_ID },
         object: {
             // passport: { token: passportToken }
         }
     });
     console.log('transaction started', transaction.id);
 
-    // 購入者情報入力時間
-    // tslint:disable-next-line:no-magic-numbers
-    await wait(5000);
-
-    console.log('creating accept task..,');
-    const acceptTask = await offerService.acceptOffer({
-        object: {
-            event: { id: '120162210202405231202250' },
-            acceptedOffer: [{
-                seatSection: '   ',
-                seatNumber: 'ｂ－３４',
-                ticketInfo: {
-                    ticketCode: '171',
-                    mvtkAppPrice: 0,
-                    ticketCount: 1,
-                    addGlasses: 0,
-                    kbnEisyahousiki: '00',
-                    mvtkNum: '',
-                    mvtkKbnDenshiken: '00',
-                    mvtkKbnMaeuriken: '00',
-                    mvtkKbnKensyu: '00',
-                    mvtkSalesPrice: 0,
-                    kbnMgtk: ''
-                }
-            }],
-            appliesToSurfrock: {
-                identifier: '',
-                serviceOutput: { typeOf: '' }
-            }
-        },
-        purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
-    });
-    console.log('acceptTask created,', acceptTask);
-
-    const giveUpPayment = moment()
-        .add(10, 'seconds');
-    let result: { id: string } | undefined;
-    let error: any;
-
-    // n秒おきに状態確認
-    while (result === undefined && error === undefined) {
-        // n秒待機
-        await new Promise<void>((resolveWait) => {
-            setTimeout(
-                () => { resolveWait(); },
-                1000
-            );
-        });
-
-        // タスク作成から一定時間経過すればあきらめる
-        if (moment()
-            .isAfter(giveUpPayment)) {
-            error = new client.factory.errors.GatewayTimeout('action gaven up');
-            break;
-        }
-
-        const acceptAction = await offerService.findAcceptAction({
-            sameAs: { id: acceptTask.id },
-            purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
-        });
-        console.log('acceptAction:,', acceptAction);
-
-        if (typeof acceptAction.id === 'string') {
-            if (acceptAction.actionStatus === client.factory.actionStatusType.CompletedActionStatus) {
-                // ステータス完了であれば決済承認アクションIDを保管
-                result = { id: acceptAction.id };
-                break;
-            } else {
-                // 待機続行
-            }
-        }
+    try {
+        // tslint:disable-next-line:no-magic-numbers
+        await wait(3000);
+        let authorizeOfferAction = await authorizeOfferAsync({ purpose: { id: transaction.id } })({ offerService });
+        console.log('offer authorized', authorizeOfferAction.id);
 
-        // エラーが存在すれば、これ以上待機する価値はなし
-        if (acceptAction.error !== undefined) {
-            error = acceptAction.error;
-            break;
-        }
-    }
-
-    if (typeof result?.id === 'string') {
-        // no op
-        // return result;
-    } else {
-        throw error;
-    }
-    console.log('acceptAcion.result:', result);
+        // 変更
+        await wait(3000);
+        authorizeOfferAction = await authorizeOfferAsync({
+            purpose: { id: transaction.id },
+            originalAuthorizeAction: authorizeOfferAction.id
+        })({ offerService });
+        console.log('offer authorized', authorizeOfferAction.id);
 
-    // 購入者情報入力時間
-    // tslint:disable-next-line:no-magic-numbers
-    await wait(5000);
+        // オファー承認取消
+        await wait(3000);
+        await voidAuthorizeOfferAsync({
+            purpose: { id: transaction.id },
+            originalAuthorizeAction: authorizeOfferAction.id
+        })({ offerService });
+        console.log('authorization voided', authorizeOfferAction.id);
 
-    console.log('authorizing by acceptAction...', result.id);
+        // オファー再承認
+        await wait(3000);
+        authorizeOfferAction = await authorizeOfferAsync({ purpose: { id: transaction.id } })({ offerService });
+        console.log('offer authorized', authorizeOfferAction.id);
 
-    const settingProfile: client.factory.person.IProfile = {
-        givenName: profile.givenName,
-        familyName: profile.familyName,
-        telephone: profile.telephone,
-        email: profile.email
-    };
-    console.log('setting customer profile...');
-    await placeOrderService.setProfile({ id: transaction.id, agent: settingProfile });
-    console.log('customer profile set');
+        // 決済承認
+        await wait(3000);
+        console.log('authorizing credit card payment...');
+        const authorizePayment = await authorizeCreditCardAsync({
+            object: {
+                amount: Number(authorizeOfferAction.result.price),
+                paymentMethod: 'CreditCard',
+                method: '1',
+                creditCard,
+                issuedThrough: { id: '5f9a6986cc98a1eb13a90285' }
+            },
+            purpose: { id: transaction.id, typeOf: client.factory.transactionType.PlaceOrder }
+        })({ paymentService });
+        console.log('credit card payment authorized', authorizePayment.id);
 
-    // 購入情報確認時間
-    // tslint:disable-next-line:no-magic-numbers
-    await wait(5000);
+        // tslint:disable-next-line:no-magic-numbers
+        await wait(3000);
+        const settingProfile: client.factory.person.IProfile = {
+            givenName: profile.givenName,
+            familyName: profile.familyName,
+            telephone: profile.telephone,
+            email: profile.email
+        };
+        console.log('setting customer profile...');
+        await placeOrderService.setProfile({ id: transaction.id, agent: settingProfile });
+        console.log('customer profile set');
 
-    await placeOrderService.updateObject({
-        id: transaction.id,
-        object: { name: 'order from samples' }
-    });
-
-    // 取引を中止する場合はコチラ↓
-    // console.log('取引を中止します...');
-    // await placeOrderService.cancel({ id: transaction.id });
-    // console.log('取引を中止しました。');
+        // tslint:disable-next-line:no-magic-numbers
+        await wait(3000);
+        await placeOrderService.updateObject({
+            id: transaction.id,
+            object: { name: 'order from samples' }
+        });
 
-    console.log('confirming transaction...');
-    await new Promise<void>(async (resolve, reject) => {
-        setTimeout(
-            () => {
-                reject(new Error('confirming process took too long'));
-            },
-            5000
-        );
+        console.log('confirming transaction...');
         const confirmResult = await placeOrderService.confirm({
             id: transaction.id,
             sendEmailMessage: true,
             expectsMinimalResponse: true
-            // expectsReservationIds: true
         });
-        const order = confirmResult.order;
         console.log('transaction confirmed', confirmResult);
-        console.log('transaction confirmed', order.orderNumber);
-        resolve();
-    });
+    } catch (error) {
+        console.error(error);
+
+        // tslint:disable-next-line:no-magic-numbers
+        await wait(3000);
+        await placeOrderService.cancel({ id: transaction.id });
+        console.log('transaction canceled');
+    }
 }
 
 async function wait(waitInMilliseconds: number) {
-    return new Promise((resolve) => setTimeout(resolve, waitInMilliseconds));
+    return new Promise((resolve) => {
+        console.log('waiting...', waitInMilliseconds);
+        setTimeout(resolve, waitInMilliseconds);
+    });
 }
 
 main()

package/lib/abstract/{chevreTxncoa → chevreTxc}/offer.d.ts

@@ -1,54 +1,6 @@
 import * as factory from '../factory';
 import { Service } from '../service';
 import { IAuthorizeCOAEventServiceResult } from '../chevreTxn/transaction/placeOrder/factory';
-export interface IPurpose {
-    typeOf: factory.transactionType;
-    id: string;
-}
-export declare enum FlgMember {
-    /**
-     * 非会員
-     */
-    NonMember = "0",
-    /**
-     * 会員
-     */
-    Member = "1"
-}
-export interface ICOAPointOffer {
-    /**
-     * オファーID
-     */
-    id: string;
-    /**
-     * オファーコード
-     */
-    identifier: string;
-    /**
-     * チケットコード
-     */
-    ticketCode: string;
-    /**
-     * チケット名
-     */
-    ticketName: string;
-    /**
-     * チケット名(カナ)
-     */
-    ticketNameKana: string;
-    /**
-     * チケット名(英)
-     */
-    ticketNameEng: string;
-    /**
-     * ポイント購入の場合の消費ポイント
-     */
-    usePoint: number;
-    /**
-     * 会員用フラグ
-     */
-    flgMember?: FlgMember;
-}
 interface IAppliesToSurfrock {
     identifier: string;
     serviceOutput: {
@@ -56,7 +8,7 @@ interface IAppliesToSurfrock {
     };
 }
 /**
- * オファーサービス
+ * COAオファーサービス
  */
 export declare class OfferService extends Service {
     acceptOffer(params: {
@@ -77,6 +29,12 @@ export declare class OfferService extends Service {
             appliesToSurfrock?: IAppliesToSurfrock;
         };
         purpose: factory.action.authorize.offer.eventService.IPurpose;
+        potentialActions?: {
+            /**
+             * 仮予約済の場合、承認アクションIDを指定
+             */
+            id?: string;
+        };
     }): Promise<{
         /**
          * task id
@@ -87,7 +45,7 @@ export declare class OfferService extends Service {
         sameAs: {
             id: string;
         };
-        purpose: IPurpose;
+        purpose: factory.action.authorize.offer.eventService.IPurpose;
     }): Promise<{
         /**
          * 採用アクションID
@@ -106,7 +64,7 @@ export declare class OfferService extends Service {
         };
     }>;
     /**
-     * 興行オファー承認
+     * 興行オファー承認(変更含む)
      */
     authorizeEventServiceByCOA(params: {
         acceptAction: {
@@ -118,45 +76,29 @@ export declare class OfferService extends Service {
         purpose: factory.action.authorize.offer.eventService.IPurpose;
     }): Promise<IAuthorizeCOAEventServiceResult>;
     /**
-     * 興行オファー承認取消
+     * 興行オファー承認取消(非同期)
      */
     voidAuthorizationByCOA(params: {
         /**
          * 承認アクションID
          */
         id: string;
+        purpose: factory.action.authorize.offer.eventService.IPurpose;
+    }): Promise<{
         /**
-         * token
+         * task ID
          */
-        purpose: string;
-        purposeRaw: string;
-    }): Promise<{
-        theaterCode?: string;
-        dateJouei?: string;
-        titleCode?: string;
-        titleBranchNum?: string;
-        timeBegin?: string;
-        tmpReserveNum?: string;
+        id: string;
     }>;
     /**
-     * 興行オファー承認変更
+     * 興行オファー承認取消タスク検索
      */
-    updateEventServiceByCOA(params: {
-        /**
-         * 承認アクションID
-         */
-        id: string;
-        object: {
-            acceptedOffer: factory.action.authorize.offer.eventService.IAcceptedOfferBeforeAuthorize4COA[];
-            event: {
-                id: string;
-            };
-        };
-        /**
-         * token
-         */
-        purpose: string;
-        purposeRaw: string;
-    }): Promise<IAuthorizeCOAEventServiceResult>;
+    findVoidTask(params: {
+        taskId: string;
+        actionId: string;
+        purpose: factory.action.authorize.offer.eventService.IPurpose;
+    }): Promise<{
+        status: factory.taskStatus;
+    }>;
 }
 export {};