@chevre/domain 21.2.0-alpha.15 → 21.2.0-alpha.151

package/example/src/chevre/aggregateEventReservation.ts

@@ -22,7 +22,7 @@ async function main() {
         id: String(process.env.EVENT_ID)
     })({
         event: new chevre.repository.Event(mongoose.connection),
-        stockHolder: new chevre.repository.StockHolder(client),
+        stockHolder: new chevre.repository.StockHolder(client, mongoose.connection),
         offer: new chevre.repository.Offer(mongoose.connection),
         offerCatalog: new chevre.repository.OfferCatalog(mongoose.connection),
         offerRateLimit: new chevre.repository.rateLimit.Offer(client),

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

@@ -4,10 +4,13 @@ import * as mongoose from 'mongoose';
 import { chevre } from '../../../../lib/index';
 
 const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+const AGGREGATE_DURATION_UNIT = <'days' | 'hours'>String(process.env.AGGREGATE_DURATION_UNIT);
 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 +21,149 @@ 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,
+    let result: { aggregationCount: number; aggregateDuration: string };
+
+    result = await chevre.service.aggregation.system.aggregateReserveAction({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
         action: actionRepo
     });
+    console.log('aggregateReserveAction processed.', result);
 
-    await chevre.service.aggregation.system.aggregatePayTransaction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateOrderAction({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        assetTransaction: assetTransactionRepo
+        action: actionRepo
     });
+    console.log('aggregateReserveAction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateEvent({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateCancelReservationAction({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        event: eventRepo
+        action: actionRepo
     });
+    console.log('aggregateCancelReservationAction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateTask({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregatePlaceOrder({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID,
+        clientIds: AGGREGATE_CLIENT_IDS
+    })({
+        agregation: aggregationRepo,
+        transaction: transactionRepo
+    });
+    console.log('aggregatePlaceOrder processed.', result);
+    // return;
+
+    result = await chevre.service.aggregation.system.aggregateTask({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
         task: taskRepo
     });
+    console.log('aggregateTask processed.', result);
 
-    await chevre.service.aggregation.system.aggregateReserveTransaction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregatePayMovieTicketAction({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+    console.log('aggregatePayMovieTicketAction processed.', result);
+
+    result = await chevre.service.aggregation.system.aggregatePayTransaction({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
         assetTransaction: assetTransactionRepo
     });
+    console.log('aggregatePayTransaction 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.aggregateEvent({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        transaction: transactionRepo
+        event: eventRepo
+    });
+    console.log('aggregateEvent processed.', result);
+
+    result = await chevre.service.aggregation.system.aggregateReserveTransaction({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        assetTransaction: assetTransactionRepo
     });
+    console.log('aggregateReserveTransaction processed.', result);
 
-    await chevre.service.aggregation.system.aggregateAuthorizeOrderAction({
-        aggregationDays: AGGREGATE_DAYS,
+    result = await chevre.service.aggregation.system.aggregateAuthorizeOrderAction({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         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: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         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: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         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: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         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: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
         action: actionRepo
     });
+    console.log('aggregateCheckMovieTicketAction processed.', result);
 }
 
 main()

package/example/src/chevre/countDelayedTasks.ts

@@ -4,11 +4,16 @@ import * as mongoose from 'mongoose';
 import { chevre } from '../../../lib/index';
 
 export 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 count = await taskRepo.countDelayedTasks({ delayInSeconds: 60 });
+    const count = await taskRepo.countDelayedTasks({
+        delayInSeconds: 60,
+        name: {
+            $nin: [chevre.factory.taskName.OrderProgramMembership]
+        }
+    });
     console.log('count:', count);
 }
 

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/findScreeningRoomsByBranchCode.ts

@@ -8,7 +8,7 @@ async function main() {
 
     const placeRepo = new chevre.repository.Place(mongoose.connection);
 
-    const event = await placeRepo.findScreeningRoomsByBranchCode({
+    const screeningRoom = await placeRepo.findScreeningRoomsByBranchCode({
         branchCode: {
             $eq: '20'
         },
@@ -16,9 +16,10 @@ async function main() {
             id: {
                 $eq: '5bfb841d5a78d7948369979a'
             }
-        }
+        },
+        useScreeningRoomType: true
     });
-    console.log('room found', event);
+    console.log('room found', screeningRoom);
 
 }
 

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/lockStockHolder.ts

@@ -1,10 +1,11 @@
 // tslint:disable:no-console
 import * as moment from 'moment';
+import * as mongoose from 'mongoose';
 import * as redis from 'redis';
 
 import { chevre } from '../../../lib/index';
 
-// const project = { id: String(process.env.PROJECT_ID) };
+const project = { id: String(process.env.PROJECT_ID) };
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
@@ -19,10 +20,12 @@ async function main() {
 
     const startDate = moment('2023-04-18T00:00:00Z');
 
-    const stockHolderRepo = new chevre.repository.StockHolder(client);
+    const stockHolderRepo = new chevre.repository.StockHolder(client, mongoose.connection);
     await stockHolderRepo.lock({
+        project,
         eventId: 'sampleEventId',
         startDate: startDate.toDate(),
+        hasTicketedSeat: true,
         offers: [
             {
                 seatSection: 'sampleSeatSection',

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/migrateScreeningEventSeriesVersion.ts

@@ -0,0 +1,79 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { typeOf: chevre.factory.organizationType.Project, id: String(process.env.PROJECT_ID) };
+
+const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            'project.id': {
+                // $eq: project.id,
+                $ne: EXCLUDED_PROJECT_ID
+            },
+            typeOf: { $eq: chevre.factory.eventType.ScreeningEventSeries },
+            'workPerformed.version': { $exists: false }
+            // _id: { $eq: 'bl7ed6sq9' }
+        },
+        {
+            _id: 1,
+            workPerformed: 1,
+            project: 1,
+            location: 1,
+            startDate: 1,
+            typeOf: 1
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: chevre.factory.event.screeningEventSeries.IEvent = doc.toObject();
+        const version = event.workPerformed.version;
+
+        const alreadyMigrated = typeof version === 'string' && version.length > 0;
+
+        if (alreadyMigrated) {
+            console.log('alreadyMigrated.', event.project.id, event.id, event.startDate, version, i);
+        } else {
+            // 既存施設コンテンツバージョンを検索
+            const { maxVersion } = await eventRepo.aggregateScreeningEventMaxVersion({
+                project: { id: { $eq: event.project.id } },
+                workPerformed: { identifier: { $eq: event.workPerformed.identifier } },
+                location: { branchCode: { $in: [event.location.branchCode] } }
+            });
+            console.log('maxVersion:', maxVersion);
+
+            const newVersion: string = `${Number(maxVersion) + 1}`;
+            console.log('updating event...', event.project.id, event.id, event.startDate, newVersion, i);
+            await eventRepo.updatePartiallyById({
+                id: event.id,
+                attributes: <any>{
+                    typeOf: event.typeOf,
+                    'workPerformed.version': newVersion
+                }
+            });
+            updateCount += 1;
+            console.log('updated.', event.project.id, event.id, event.startDate, newVersion, i);
+        }
+    });
+
+    console.log(i, 'events checked');
+    console.log(updateCount, 'events updated');
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/processPay.ts

@@ -63,7 +63,11 @@ async function main() {
                 name: 'xx'
             }
         },
-        true
+        {
+            useCheckMovieTicketBeforePay: true,
+            useCheckByIdentifierIfNotYet: true,
+            searchTrade4accountId: false
+        }
     )({
         accountingReport: accountingReportRepo,
         action: actionRepo,

package/example/src/chevre/processRegisterMembership.ts

@@ -21,10 +21,14 @@ async function main() {
     const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
 
     // プロダクト検索
-    const products = await productRepo.search({
-        project: { id: { $eq: project.id } },
-        typeOf: { $eq: chevre.factory.product.ProductType.MembershipService }
-    });
+    const products = await productRepo.search(
+        {
+            project: { id: { $eq: project.id } },
+            typeOf: { $eq: chevre.factory.product.ProductType.MembershipService }
+        },
+        [],
+        []
+    );
     console.log(products);
 
     const product = products[0];

package/example/src/chevre/processRegisterPaymentCard.ts

@@ -21,10 +21,14 @@ async function main() {
     const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
 
     // プロダクト検索
-    const products = await productRepo.search({
-        project: { id: { $eq: project.id } },
-        typeOf: { $eq: chevre.factory.product.ProductType.PaymentCard }
-    });
+    const products = await productRepo.search(
+        {
+            project: { id: { $eq: project.id } },
+            typeOf: { $eq: chevre.factory.product.ProductType.PaymentCard }
+        },
+        [],
+        []
+    );
     console.log(products);
 
     const product = products[0];

package/example/src/chevre/processReserve.ts

@@ -30,7 +30,7 @@ async function main() {
     const priceSpecRepo = new chevre.repository.PriceSpecification(mongoose.connection);
     const reservationRepo = new chevre.repository.Reservation(mongoose.connection);
     const eventRepo = new chevre.repository.Event(mongoose.connection);
-    const itemAvailabilityRepo = new chevre.repository.StockHolder(client);
+    const itemAvailabilityRepo = new chevre.repository.StockHolder(client, mongoose.connection);
     const offerRateLimitRepo = new chevre.repository.rateLimit.Offer(client);
 
     const identifier = `CIN${(new Date()).valueOf()}`;
@@ -68,7 +68,10 @@ async function main() {
         },
         validateEvent: false,
         validateEventOfferPeriod: false,
-        validateAppliesToMovieTicket: true
+        validateAppliesToMovieTicket: true,
+        disablePendingReservations: true,
+        stockHoldUntilDaysAfterEventEnd: 31,
+        useHoldStockByTransactionNumber: 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,34 @@
+// 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.ConfirmReserveTransaction>[]>await taskRepo.search({
+        // limit: 100,
+        // page: 1,
+        name: {
+            $in: [chevre.factory.taskName.ConfirmReserveTransaction]
+            // $nin: [
+            //     chevre.factory.taskName.ImportEventsFromCOA,
+            //     chevre.factory.taskName.ImportEventCapacitiesFromCOA
+            // ]
+        },
+        statuses: [chevre.factory.taskStatus.Aborted],
+        runsFrom: moment('2023-06-02T22:00:00Z')
+            .toDate(),
+        sort: { runsAt: chevre.factory.sortType.Ascending }
+    });
+    console.log(tasks.map((task) => `${task.data.object?.transactionNumber}`)
+        .join('\n'));
+    console.log(tasks.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchActions.ts

@@ -0,0 +1,33 @@
+// 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: true });
+
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+    const actions = await actionRepo.search(
+        {
+            typeOf: { $eq: chevre.factory.actionType.CheckAction },
+            // project: { id: { $eq: project.id } },
+            object: {
+                movieTickets: {
+                    identifier: { $eq: '0947524082' },
+                    serviceOutput: { reservationFor: { id: { $eq: 'clhvvbpyn' } } }
+                }
+            }
+        },
+        ['_id'],
+        []
+    );
+    console.log('actions:', actions);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);