@chevre/domain 21.2.0-alpha.8 → 21.2.0-alpha.80

package/example/src/chevre/aggregation/aggregateSystem.ts

@@ -6,8 +6,10 @@ import { chevre } from '../../../../lib/index';
 const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
 const AGGREGATE_DAYS = Number(process.env.AGGREGATE_DAYS);
 const AGGREGATE_CLIENT_IDS = (typeof process.env.AGGREGATE_CLIENT_IDS === 'string') ? process.env.AGGREGATE_CLIENT_IDS.split(' ') : [];
+const ONE_DAY_IN_HOURS = 24;
 console.log('AGGREGATE_CLIENT_IDS:', AGGREGATE_CLIENT_IDS);
 
+// tslint:disable-next-line:max-func-body-length
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
@@ -18,94 +20,119 @@ async function main() {
     const actionRepo = new chevre.repository.Action(mongoose.connection);
     const taskRepo = new chevre.repository.Task(mongoose.connection);
 
-    await chevre.service.aggregation.system.aggregatePayMovieTicketAction({
-        aggregationDays: AGGREGATE_DAYS,
-        excludedProjectId: EXCLUDED_PROJECT_ID
+    let result: { aggregationCount: number; aggregateDuration: string };
+
+    result = await chevre.service.aggregation.system.aggregatePlaceOrder({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
+        excludedProjectId: EXCLUDED_PROJECT_ID,
+        clientIds: AGGREGATE_CLIENT_IDS
     })({
         agregation: aggregationRepo,
-        action: actionRepo
+        transaction: transactionRepo
     });
+    console.log('aggregatePlaceOrder processed.', result);
+    // return;
 
-    await chevre.service.aggregation.system.aggregatePayTransaction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateTask({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        assetTransaction: assetTransactionRepo
+        task: taskRepo
     });
+    console.log('aggregateTask processed.', result);
 
-    await chevre.service.aggregation.system.aggregateEvent({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregatePayMovieTicketAction({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        event: eventRepo
+        action: actionRepo
     });
+    console.log('aggregatePayMovieTicketAction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateTask({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregatePayTransaction({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        task: taskRepo
+        assetTransaction: assetTransactionRepo
     });
+    console.log('aggregatePayTransaction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateReserveTransaction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateEvent({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        assetTransaction: assetTransactionRepo
+        event: eventRepo
     });
+    console.log('aggregateEvent processed.', result);
 
-    await chevre.service.aggregation.system.aggregatePlaceOrder({
-        aggregationDays: AGGREGATE_DAYS,
-        excludedProjectId: EXCLUDED_PROJECT_ID,
-        clientIds: AGGREGATE_CLIENT_IDS
+    result = await chevre.service.aggregation.system.aggregateReserveTransaction({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        transaction: transactionRepo
+        assetTransaction: assetTransactionRepo
     });
+    console.log('aggregateReserveTransaction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateAuthorizeOrderAction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateAuthorizeOrderAction({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
         action: actionRepo
     });
+    console.log('aggregateAuthorizeOrderAction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateAuthorizeEventServiceOfferAction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateAuthorizeEventServiceOfferAction({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
         action: actionRepo
     });
+    console.log('aggregateAuthorizeEventServiceOfferAction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateAuthorizePaymentAction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateAuthorizePaymentAction({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
         action: actionRepo
     });
+    console.log('aggregateAuthorizePaymentAction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateUseAction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateUseAction({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
         action: actionRepo
     });
+    console.log('aggregateUseAction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateCheckMovieTicketAction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateCheckMovieTicketAction({
+        aggregateDurationUnit: 'hours',
+        aggregationCount: AGGREGATE_DAYS * ONE_DAY_IN_HOURS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
         action: actionRepo
     });
+    console.log('aggregateCheckMovieTicketAction processed.', result);
 }
 
 main()

package/example/src/chevre/countDelayedTransactions.ts

@@ -0,0 +1,60 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+export async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
+    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+
+    for (const typeOf of [
+        chevre.factory.transactionType.PlaceOrder,
+        chevre.factory.transactionType.ReturnOrder,
+        chevre.factory.transactionType.MoneyTransfer
+    ]) {
+        const count = await transactionRepo.count({
+            typeOf,
+            statuses: [
+                chevre.factory.transactionStatusType.Canceled,
+                chevre.factory.transactionStatusType.Confirmed,
+                chevre.factory.transactionStatusType.Expired
+            ],
+            tasksExportationStatuses: [
+                chevre.factory.transactionTasksExportationStatus.Exporting,
+                chevre.factory.transactionTasksExportationStatus.Unexported
+            ],
+            endThrough: new Date()
+        });
+        console.log('count:', count, typeOf);
+    }
+
+    for (const typeOf of [
+        chevre.factory.assetTransactionType.CancelReservation,
+        chevre.factory.assetTransactionType.MoneyTransfer,
+        chevre.factory.assetTransactionType.Pay,
+        chevre.factory.assetTransactionType.Refund,
+        chevre.factory.assetTransactionType.RegisterService,
+        chevre.factory.assetTransactionType.Reserve
+    ]) {
+        const count = await assetTransactionRepo.count({
+            typeOf,
+            statuses: [
+                chevre.factory.transactionStatusType.Canceled,
+                chevre.factory.transactionStatusType.Confirmed,
+                chevre.factory.transactionStatusType.Expired
+            ],
+            tasksExportationStatuses: [
+                chevre.factory.transactionTasksExportationStatus.Exporting,
+                chevre.factory.transactionTasksExportationStatus.Unexported
+            ],
+            endThrough: new Date()
+        });
+        console.log('count:', count, typeOf);
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/createManyEventsIfNotExist.ts

@@ -197,7 +197,10 @@ async function main() {
         }
     ]);
     console.log(result);
-    console.log('upsertedIds:', (Array.isArray(result?.result.upserted)) ? result?.result.upserted.map((u: any) => u._id) : []);
+    console.log('upsertedIds:', (Array.isArray(result?.getUpsertedIds()))
+        ? result?.getUpsertedIds()
+            .map((u: any) => u._id)
+        : []);
 }
 
 main()

package/example/src/chevre/deleteTasksByName.ts

@@ -1,4 +1,5 @@
 // tslint:disable:no-console
+// import * as moment from 'moment';
 import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
@@ -6,12 +7,19 @@ import { chevre } from '../../../lib/index';
 // const project = { id: String(process.env.PROJECT_ID) };
 
 async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     const taskRepo = new chevre.repository.Task(mongoose.connection);
 
     const result = await taskRepo.deleteByName({
-        name: <any>'deleteAuthorization'
+        name: chevre.factory.taskName.OrderProgramMembership,
+        status: { $eq: chevre.factory.taskStatus.Ready }
+        // runsAt: {
+        //     $gte: moment('2023-05-20T00:00:00Z')
+        //         .toDate(),
+        //     $lte: moment('2023-12-20T00:00:00Z')
+        //         .toDate()
+        // }
     });
 
     console.log('deleted', result);

package/example/src/chevre/importEventsFromCOA.ts

@@ -21,11 +21,10 @@ async function main() {
             id: project.id,
             typeOf: chevre.factory.organizationType.Project
         },
-        locationBranchCode: '120',
-        importFrom: moment()
+        locationBranchCode: '018',
+        importFrom: moment('2023-05-17T02:45:00.214Z')
             .toDate(),
-        importThrough: moment()
-            .add(1, 'day')
+        importThrough: moment('2023-05-20T02:45:00.214Z')
             .toDate(),
         saveMovieTheater: false,
         saveScreeningEventSeries: false

package/example/src/chevre/migrateOrderAdditionalProperties.ts

@@ -0,0 +1,85 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const orderRepo = new chevre.repository.Order(mongoose.connection);
+
+    const cursor = orderRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            // 'project.id': { $ne: EXCLUDED_PROJECT_ID },
+            orderDate: {
+                $gte: moment()
+                    .add(-1, 'months')
+                    .toDate()
+            }
+        },
+        {
+            paymentMethods: 1,
+            project: 1,
+            orderDate: 1
+        }
+    );
+    console.log('movies found');
+
+    const additionalPropertyNames: string[] = [];
+    const projectIds: string[] = [];
+    const unexpextedprojectIds: string[] = [];
+
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const order: chevre.factory.order.IOrder = doc.toObject();
+
+        const additionalPropertyNamesOnOrder = order.paymentMethods.reduce<string[]>(
+            (a, b) => {
+                if (Array.isArray(b.additionalProperty)) {
+                    return [...a, ...b.additionalProperty.map((p) => p.name)];
+                } else {
+                    return a;
+                }
+            },
+            []
+        );
+        if (Array.isArray(additionalPropertyNamesOnOrder) && additionalPropertyNamesOnOrder.length > 0) {
+            console.log(
+                additionalPropertyNamesOnOrder.join(','),
+                additionalPropertyNamesOnOrder.length,
+                'additionalPropertyNamesOnOrder found',
+                order.project.id,
+                order.id,
+                order.orderDate
+            );
+            additionalPropertyNames.push(...additionalPropertyNamesOnOrder);
+            projectIds.push(order.project.id);
+            additionalPropertyNamesOnOrder.forEach((name) => {
+                if (!name.match(/^[a-zA-Z]*$/)) {
+                    // throw new Error(`not matched ${creativeWork.project.id} ${creativeWork.id}`);
+                    unexpextedprojectIds.push(order.project.id);
+                }
+                // tslint:disable-next-line:no-magic-numbers
+                if (name.length < 5) {
+                    // throw new Error(`length matched ${creativeWork.project.id} ${creativeWork.id} ${name}`);
+                    unexpextedprojectIds.push(order.project.id);
+                }
+            });
+        }
+    });
+    console.log(i, 'orders checked');
+    console.log('additionalPropertyNames:', [...new Set(additionalPropertyNames)]);
+    console.log('projectIds:', [...new Set(projectIds)]);
+    console.log('unexpextedprojectIds:', [...new Set(unexpextedprojectIds)]);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/processReserve.ts

@@ -68,7 +68,8 @@ async function main() {
         },
         validateEvent: false,
         validateEventOfferPeriod: false,
-        validateAppliesToMovieTicket: true
+        validateAppliesToMovieTicket: true,
+        disablePendingReservations: true
     })({
         stockHolder: itemAvailabilityRepo,
         event: eventRepo,

package/example/src/chevre/saveTasks.ts

@@ -10,16 +10,19 @@ async function main() {
 
     const taskRepo = new chevre.repository.Task(mongoose.connection);
 
-    const result = await taskRepo.saveMany([{
-        name: chevre.factory.taskName.TriggerWebhook,
-        runsAt: new Date(),
-        data: {},
-        executionResults: [],
-        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
-        numberOfTried: 0,
-        remainingNumberOfTries: 1,
-        status: chevre.factory.taskStatus.Ready
-    }]);
+    const result = await taskRepo.saveMany(
+        [{
+            name: chevre.factory.taskName.TriggerWebhook,
+            runsAt: new Date(),
+            data: {},
+            executionResults: [],
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            numberOfTried: 0,
+            remainingNumberOfTries: 1,
+            status: chevre.factory.taskStatus.Ready
+        }],
+        { emitImmediately: false }
+    );
 
     console.log(result, 'tasks saved');
 }

package/example/src/chevre/searchAbortedTasks.ts

@@ -0,0 +1,36 @@
+// tslint:disable:no-console
+import * as moment from 'moment-timezone';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+
+    const tasks = <chevre.factory.task.ITask<chevre.factory.taskName.ConfirmPayTransaction>[]>await taskRepo.search({
+        // limit: 100,
+        // page: 1,
+        name: {
+            $in: [chevre.factory.taskName.ConfirmPayTransaction]
+            // $nin: [
+            //     chevre.factory.taskName.ImportEventsFromCOA,
+            //     chevre.factory.taskName.ImportEventCapacitiesFromCOA
+            // ]
+        },
+        statuses: [chevre.factory.taskStatus.Aborted],
+        runsFrom: moment('2023-05-02T22:00:00Z')
+            .toDate(),
+        sort: { runsAt: chevre.factory.sortType.Ascending }
+    });
+    console.log(tasks.map((task) => `${task.project.id},${task.id},${task.name},${moment(task.runsAt)
+        .tz('Asia/Tokyo')
+        .format('YYYY-MM-DDTHH:mm:ssZ')},"${task.data.object[0]?.transactionNumber}"`)
+        .join('\n'));
+    console.log(tasks.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchReservationNumbersByOrderNumbers.ts

@@ -4,17 +4,53 @@ import * as mongoose from 'mongoose';
 import { chevre } from '../../../lib/index';
 
 // const project = { id: String(process.env.PROJECT_ID) };
+const orderNumbers = ['TTT9-4703865-8892744', 'TTT9-4703865-8398074', 'SSK6-4815238-3010844'];
 
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI);
 
     const orderRepo = new chevre.repository.Order(mongoose.connection);
 
+    const reservatioForIds = await orderRepo.searchReservationForIdsByOrderNumbers({
+        orderNumber: { $in: orderNumbers }
+    });
+    console.log('reservatioForIds found', reservatioForIds);
+    console.log(reservatioForIds.length, 'reservatioForIds found');
+
     const reservationNumbers = await orderRepo.searchReservationNumbersByOrderNumbers({
-        orderNumber: { $in: ['CIN5-8118459-9364668', 'CIN7-9119652-8987979', 'SSK1-3992448-6733563'] }
+        orderNumber: { $in: orderNumbers }
     });
     console.log('reservationNumbers found', reservationNumbers);
     console.log(reservationNumbers.length, 'reservationNumbers found');
+
+    const offers = await orderRepo.searchAcceptedOffersByOrderNumbers({
+        orderNumber: { $in: orderNumbers }
+    });
+    console.log('offers found', offers);
+    console.log(offers.length, 'offers found');
+
+    const movieTickets: any[] = [];
+    offers.forEach((offer) => {
+        const movieTicketTypeChargeSpecExists = offer.priceSpecification.priceComponent.some((component) => {
+            return component.typeOf === chevre.factory.priceSpecificationType.MovieTicketTypeChargeSpecification;
+        });
+        if (movieTicketTypeChargeSpecExists) {
+            offer.priceSpecification.priceComponent.forEach((component) => {
+                if (component.typeOf === chevre.factory.priceSpecificationType.UnitPriceSpecification) {
+                    if (Array.isArray(component.appliesToMovieTicket)) {
+                        component.appliesToMovieTicket.forEach((appliesToMovieTicket) => {
+                            movieTickets.push({
+                                identifier: appliesToMovieTicket.identifier,
+                                paymentMethodType: appliesToMovieTicket.serviceOutput.typeOf,
+                                offerId: offer.id
+                            });
+                        });
+                    }
+                }
+            });
+        }
+    });
+    console.log('movieTickets found', movieTickets);
 }
 
 main()

package/example/src/chevre/searchSellers.ts

@@ -0,0 +1,22 @@
+// tslint:disable:no-implicit-dependencies no-console
+import { chevre } from '../../../lib/index';
+
+import * as  mongoose from 'mongoose';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const sellerRepo = new chevre.repository.Seller(mongoose.connection);
+    const sellers = await sellerRepo.search({
+        hasMerchantReturnPolicy: { itemCondition: { id: { $eq: '646dc7848b3c1437d43dbfeb' } } }
+    });
+    console.log('sellers:', sellers);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/searchSendEmailActions.ts

@@ -0,0 +1,44 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+
+    const actions = <chevre.factory.action.transfer.send.message.email.IAction[]>await actionRepo.search(
+        {
+            limit: 1000,
+            page: 1,
+            typeOf: { $eq: chevre.factory.actionType.SendAction },
+            object: {
+                typeOf: { $eq: chevre.factory.creativeWorkType.EmailMessage }
+            }
+            // startFrom: moment()
+            //     .add(-20, 'days')
+            //     .toDate(),
+            // startThrough: moment()
+            //     .add(-19, 'days')
+            //     .toDate(),
+        },
+        ['project', '_id', 'object', 'purpose'],
+        []
+    );
+    const maxLenght = Math.max(...actions.map((action) => {
+        return (Array.isArray(action.object)) ? action.object[0].text?.length : action.object.text?.length;
+    }));
+    actions.forEach((action) => {
+        const length = (Array.isArray(action.object)) ? action.object[0].text?.length : action.object.text?.length;
+        if (typeof length !== 'number') {
+            throw new Error(`${action.project.id},${action.id},${action.purpose?.typeOf},${action.purpose?.orderNumber},${action.object.text?.length}`);
+        }
+    });
+    console.log('maxLenght:', maxLenght);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/task/executeTasks.ts

@@ -0,0 +1,26 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+    const result = await taskRepo.executeTasks({
+        now: new Date(),
+        delayInSeconds: 60,
+        limit: 1,
+        name: {
+            $nin: [
+                chevre.factory.taskName.ImportEventCapacitiesFromCOA,
+                chevre.factory.taskName.ImportEventsFromCOA
+            ]
+        }
+    });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

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

@@ -11,7 +11,7 @@ async function main() {
 
     const projectRepo = new chevre.repository.Project(mongoose.connection);
     const productRepo = new chevre.repository.Product(mongoose.connection);
-    const personRepo = new chevre.repository.Person({ userPoolId: chevre.settings.userPoolIdNew });
+    const personRepo = new chevre.repository.Person({ userPoolId: chevre.settings.settings.userPoolIdNew });
 
     const result = await findCreditCard({
         project: { id: project.id },

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

@@ -19,7 +19,7 @@ async function main() {
     });
     await redisClient.connect();
 
-    const personRepo = new chevre.repository.Person({ userPoolId: chevre.settings.userPoolIdNew });
+    const personRepo = new chevre.repository.Person({ userPoolId: chevre.settings.settings.userPoolIdNew });
     const actionRepo = new chevre.repository.Action(mongoose.connection);
     const accountRepo = new chevre.repository.Account(mongoose.connection);
     const accountingReportRepo = new chevre.repository.AccountingReport(mongoose.connection);

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

@@ -0,0 +1,40 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const result = await chevre.service.transaction.returnOrder.start({
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        expiresInSeconds: 60,
+        agent: { id: 'xxx', typeOf: chevre.factory.creativeWorkType.WebApplication },
+        object: {
+            order: [{
+                confirmationNumber: '99916',
+                orderNumber: 'TTT2-8507485-9273468'
+            }],
+            reason: chevre.factory.transaction.returnOrder.Reason.Customer
+        },
+        seller: {
+            id: 'xxx'
+        }
+    })({
+        event: new chevre.repository.Event(mongoose.connection),
+        merchantReturnPolicy: new chevre.repository.MerchantReturnPolicy(mongoose.connection),
+        offer: new chevre.repository.Offer(mongoose.connection),
+        offerItemCondition: new chevre.repository.OfferItemCondition(mongoose.connection),
+        order: new chevre.repository.Order(mongoose.connection),
+        reservation: new chevre.repository.Reservation(mongoose.connection),
+        seller: new chevre.repository.Seller(mongoose.connection),
+        transaction: new chevre.repository.Transaction(mongoose.connection)
+    });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);