@chevre/domain 21.2.0-alpha.16 → 21.2.0-alpha.161

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/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);

package/example/src/chevre/searchEventSeats.ts

@@ -1,9 +1,10 @@
 // tslint:disable:no-console
+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() {
@@ -16,11 +17,13 @@ async function main() {
     });
     await client.connect();
 
-    const itemAvailabilityRepo = new chevre.repository.StockHolder(client);
+    const itemAvailabilityRepo = new chevre.repository.StockHolder(client, mongoose.connection);
 
     const result = await itemAvailabilityRepo.searchHolders({
+        project,
         eventId: 'alckc9mlx',
         startDate: new Date(),
+        hasTicketedSeat: true,
         offers: [
             {
                 seatSection: 'Default',

package/example/src/chevre/searchHoldReservations.ts

@@ -0,0 +1,38 @@
+// tslint:disable:no-console
+// import * as redis from 'redis';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: true });
+    const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+        socket: {
+            host: process.env.REDIS_HOST,
+            port: Number(process.env.REDIS_PORT)
+        },
+        password: process.env.REDIS_KEY
+    });
+    await client.connect();
+
+    const stockHolderRepo = new chevre.repository.StockHolder(client, mongoose.connection);
+
+    const holdReservations = await stockHolderRepo.search({
+        limit: 2,
+        page: 2,
+        sort: { 'reservationFor.startDate': chevre.factory.sortType.Ascending }
+    });
+    console.log(holdReservations);
+    console.log(holdReservations.length);
+
+    // const aggregations = await stockHolderRepo.aggregateByReservationFor({
+    //     limit: 100,
+    //     page: 1
+    // });
+    // console.log(aggregations);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchPermissions.ts

@@ -0,0 +1,54 @@
+// 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 memberId = 'xxx';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const memberRepo = new chevre.repository.Member(mongoose.connection);
+    const roleRepo = new chevre.repository.Role(mongoose.connection);
+
+    let now: Date;
+
+    // let now = new Date();
+    // const aggregateRoleNamesResult = await memberRepo.aggregateRoleNames({
+    //     project: { id: { $eq: PROJECT_ID } },
+    //     member: { id: { $eq: memberId } }
+    // });
+
+    // const aggregatePermissionsResult = await roleRepo.aggregatePermissions({
+    //     roleName: {
+    //         $in: aggregateRoleNamesResult.map((r) => r.roleName)
+    //     }
+    // });
+    // console.log('time cost:', moment()
+    //     .diff(now));
+
+    now = new Date();
+    const searchPermissionsResult = await chevre.service.iam.searchPermissions({
+        project: { id: PROJECT_ID },
+        member: { id: memberId }
+    })({
+        member: memberRepo,
+        role: roleRepo
+    });
+    console.log('time cost:', moment()
+        .diff(now));
+
+    console.log(searchPermissionsResult);
+    console.log(searchPermissionsResult.permissions.length);
+
+    // console.log(aggregateRoleNamesResult);
+    // console.log(aggregateRoleNamesResult.length);
+    // console.log(aggregatePermissionsResult);
+    // console.log(aggregatePermissionsResult.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/searchScreeningRooms.ts

@@ -0,0 +1,35 @@
+// 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 placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const rooms = await placeRepo.searchScreeningRooms(
+        {
+            limit: 10,
+            page: 1,
+            $projection: { sectionCount: 1 }
+        },
+        true
+    );
+    console.log('place found', rooms);
+    const filteredRooms = rooms.filter((room) => typeof room.sectionCount === 'number' && room.sectionCount > 1);
+    console.log(filteredRooms.length, 'filteredRooms found');
+
+    const screeningRoom = await placeRepo.findScreeningRoomsByBranchCode({
+        branchCode: { $eq: rooms[0].branchCode },
+        containedInPlace: { id: { $eq: String(rooms[0].containedInPlace?.id) } },
+        useScreeningRoomType: true
+    });
+    console.log('screeningRoom found', screeningRoom);
+}
+
+main()
+    .then(console.log)
+    .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/sendEmailMessage.ts

@@ -61,8 +61,7 @@ async function main() {
             },
             customer: {
                 typeOf: chevre.factory.creativeWorkType.WebApplication,
-                id: 'xxxx',
-                name: '****'
+                id: 'xxxx'
             },
             orderNumber: 'CIN1-3970498-5700993',
             price: 0,

package/example/src/chevre/syncScreeningRooms.ts

@@ -0,0 +1,22 @@
+// 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 placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    await placeRepo.syncScreeningRooms({
+        id: '60409176f60a46000a7a3787',
+        useScreeningRoomType: true
+    });
+    console.log('synced');
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/syncScreeningRoomsAll.ts

@@ -0,0 +1,44 @@
+// 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 placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const cursor = placeRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.placeType.MovieTheater }
+        },
+        {
+            _id: 1,
+            name: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('places found');
+
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const { id, name, project, typeOf } = <Pick<chevre.factory.place.movieTheater.IPlace, 'id' | 'name' | 'project' | 'typeOf'>>
+            doc.toObject();
+
+        console.log('syncing...', project.id, typeOf, id, name.ja, i);
+        await placeRepo.syncScreeningRooms({
+            id,
+            useScreeningRoomType: true
+        });
+        console.log('synced.', project.id, typeOf, id, name.ja, i);
+    });
+
+}
+
+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);