@chevre/domain 23.1.0-alpha.8 → 23.1.0

package/example/src/chevre/{eventOffer/adminEventOffers.ts → acceptedPaymentMethodOffer/adminAcceptedPaymentMethodOffers.ts}

@@ -9,22 +9,23 @@ const project = { id: String(process.env.PROJECT_ID) };
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const eventOfferRepo = await chevre.repository.EventOffer.createInstance(mongoose.connection);
+    const acceptedPaymentMethodRepo = await chevre.repository.AcceptedPaymentMethod.createInstance(mongoose.connection);
 
     const validFrom = moment()
         .toDate();
     const validThrough = moment(validFrom)
         .add(1, 'hour')
         .toDate();
-    const eventOffer: chevre.factory.eventOffer.IEventOffer = {
+    const settingOffer: Omit<chevre.factory.acceptedPaymentMethodOffer.IAcceptedPaymentMethodOffer, 'id'> = {
         typeOf: chevre.factory.offerType.Offer,
-        identifier: '20251113eventOffer',
+        identifier: '20251202acceptedPaymentMethod',
         itemOffered: {
-            id: '69151228ad580da66c8b5068',
-            typeOf: chevre.factory.eventType.ScreeningEvent
+            id: '7k9ayl8hc',
+            typeOf: chevre.factory.eventType.ScreeningEventSeries
         },
-        availableAtOrFrom: {
-            identifier: 'SmartTheaterTXN'
+        acceptedPaymentMethod: {
+            id: '5f9a52994f3709000abe6417',
+            typeOf: chevre.factory.service.paymentService.PaymentServiceType.MovieTicket
         },
         validFrom,
         validThrough,
@@ -35,10 +36,10 @@ async function main() {
         project: { id: project.id, typeOf: chevre.factory.organizationType.Project }
     };
 
-    let result = await eventOfferRepo.upsertEventOffersByIdentifier(
+    let result = await acceptedPaymentMethodRepo.upsertAcceptedPaymentMethodsByIdentifier(
         [
             {
-                $set: eventOffer,
+                $set: settingOffer,
                 $unset: {}
             }
         ],
@@ -48,10 +49,10 @@ async function main() {
     );
     console.log(result);
 
-    result = await eventOfferRepo.upsertEventOffersByIdentifier(
+    result = await acceptedPaymentMethodRepo.upsertAcceptedPaymentMethodsByIdentifier(
         [
             {
-                $set: eventOffer,
+                $set: settingOffer,
                 $unset: {}
             }
         ],

package/example/src/chevre/actions/checkAcceptPayActions.ts

@@ -0,0 +1,60 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const actionRepo = await chevre.repository.Action.createInstance(mongoose.connection);
+
+    const cursor = actionRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.actionType.AcceptAction },
+            'object.typeOf': { $exists: true, $eq: chevre.factory.assetTransactionType.Pay },
+            startDate: {
+                $gte: moment()
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-3, 'days')
+                    .toDate()
+            }
+        },
+        {
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let ticketTokenCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const acceptAction = <chevre.factory.action.accept.pay.IAction>doc.toObject();
+
+        const ticketTokenByInstrument = acceptAction.instrument?.find((instrument) => instrument.typeOf === 'Ticket')?.ticketToken;
+        if (typeof ticketTokenByInstrument === 'string' && ticketTokenByInstrument !== '') {
+            console.log(
+                ticketTokenByInstrument,
+                ' ticket token exists.',
+                acceptAction.project.id, acceptAction.typeOf, acceptAction.object.typeOf,
+                acceptAction.startDate, acceptAction.identifier, i
+            );
+            ticketTokenCount += 1;
+        } else {
+            console.log(
+                ticketTokenByInstrument,
+                ' ticket token does not exists.',
+                acceptAction.project.id, acceptAction.typeOf, acceptAction.object.typeOf,
+                acceptAction.startDate, acceptAction.identifier, i
+            );
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(ticketTokenCount, 'ticketToken exist');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/assetTransaction/checkPayTransactionsTicketToken.ts

@@ -0,0 +1,67 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
+
+    const cursor = assetTransactionRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.assetTransactionType.Pay },
+            startDate: {
+                $gte: moment()
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-3, 'days')
+                    .toDate()
+            },
+            'object.typeOf': {
+                $exists: true,
+                $in: [
+                    // chevre.factory.service.paymentService.PaymentServiceType.FaceToFace,
+                    // chevre.factory.service.paymentService.PaymentServiceType.MovieTicket,
+                    chevre.factory.service.paymentService.PaymentServiceType.CreditCard
+                ]
+            }
+        },
+        {
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let ticketTokenCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const payTransaction = <chevre.factory.assetTransaction.pay.ITransaction>doc.toObject();
+
+        const ticketTokenByInstrument = payTransaction.instrument?.find((instrument) => instrument.typeOf === 'Ticket')?.ticketToken;
+        if (typeof ticketTokenByInstrument === 'string' && ticketTokenByInstrument !== '') {
+            console.log(
+                ticketTokenByInstrument,
+                ' ticket token exists.',
+                payTransaction.project.id, payTransaction.typeOf, payTransaction.object.typeOf,
+                payTransaction.startDate, payTransaction.transactionNumber, i
+            );
+            ticketTokenCount += 1;
+        } else {
+            console.log(
+                ticketTokenByInstrument,
+                ' ticket token does not exists.',
+                payTransaction.project.id, payTransaction.typeOf, payTransaction.object.typeOf,
+                payTransaction.startDate, payTransaction.transactionNumber, i
+            );
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(ticketTokenCount, 'ticketToken exist');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/assetTransaction/processReserve.ts

@@ -76,8 +76,8 @@ async function main() {
                 reservationFor: {
                     id: EVENT_ID,
                     offers: {
-                        token: OFFER_TOKEN,
-                        identifier: 'LegacyReservation'
+                        // token: OFFER_TOKEN,
+                        // identifier: 'LegacyReservation'
                     }
                 }
             },
@@ -88,7 +88,9 @@ async function main() {
             validateEvent: false,
             validateEventOfferPeriod: true,
             validateAppliesToMovieTicket: true,
-            instrument: [],
+            instrument: [
+                ...(typeof OFFER_TOKEN === 'string') ? [{ ticketToken: OFFER_TOKEN, typeOf: <'Ticket'>'Ticket' }] : []
+            ],
             availableAtOrFrom: { id: APPLICATION_ID }
             // stockHoldUntilDaysAfterEventEnd: STOCK_HOLD_UNTIL_DAYS_AFTER_EVENT_END
         },
@@ -96,6 +98,7 @@ async function main() {
     )(
         {
             advanceBookingRequirement: await chevre.repository.AdvanceBookingRequirement.createInstance(mongoose.connection),
+            authorization: await chevre.repository.Authorization.createInstance(mongoose.connection),
             project: await chevre.repository.Project.createInstance(mongoose.connection),
             stockHolder: await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection }),
             event: await chevre.repository.Event.createInstance(mongoose.connection),
@@ -115,6 +118,7 @@ async function main() {
             seat: await chevre.repository.place.Seat.createInstance(mongoose.connection),
             setting: await chevre.repository.Setting.createInstance(mongoose.connection),
             task: await chevre.repository.Task.createInstance(mongoose.connection),
+            ticket: await chevre.repository.Ticket.createInstance(mongoose.connection),
             assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection)
         },
         new chevre.settings.Settings({

package/example/src/chevre/authorizeEventServiceOffer.ts

@@ -29,10 +29,10 @@ async function main() {
                 reservationFor: {
                     id: 'bmcvkft63',
                     offers: {
-                        validForMemberTier: {
-                            token: 'xx',
-                            isTierOf: { identifier: 'DefaultMemberProgram' }
-                        }
+                        // validForMemberTier: {
+                        //     token: 'xx',
+                        //     isTierOf: { identifier: 'DefaultMemberProgram' }
+                        // }
                     }
 
                 }
@@ -41,7 +41,8 @@ async function main() {
             transaction: { id: 'xxx' },
             validateEventOfferPeriod: true,
             validateEvent: false,
-            store: { id: 'xxx' }
+            store: { id: 'xxx' },
+            instrument: []
         },
         {
             noOfferSpecified: true,

package/example/src/chevre/eventSeries/migrateEventSeriesUnacceptedPaymentMethod.ts

@@ -0,0 +1,93 @@
+// 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 DEFAULT_PAYMENT_METHOD_TYPE_FOR_MOVIE_TICKET = 'MovieTicket';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventSeriesRepo = await chevre.repository.EventSeries.createInstance(mongoose.connection);
+
+    const cursor = eventSeriesRepo.getCursor(
+        {
+            'project.id': { $eq: 'xxx' },
+            'offers.unacceptedPaymentMethod': {
+                $exists: true,
+                $ne: DEFAULT_PAYMENT_METHOD_TYPE_FOR_MOVIE_TICKET
+            },
+            startDate: {
+                $lte: moment()
+                    .add(-1, 'year')
+                    .toDate()
+            }
+            // _id: { $eq: 'bliy11ffa' }
+        },
+        {
+            // _id: 1,
+            // offers: 1,
+            // startDate: 1,
+            // project: 1,
+            // typeOf: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const eventSeries: Pick<
+            chevre.factory.eventSeries.IEvent,
+            'id' | 'offers' | 'startDate' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', eventSeries.project.id, eventSeries.typeOf, eventSeries.id, eventSeries.startDate, i);
+        const unacceptedPaymentMethod = eventSeries.offers?.unacceptedPaymentMethod;
+        const alreadyMigrated = !Array.isArray(unacceptedPaymentMethod)
+            || (Array.isArray(unacceptedPaymentMethod)
+                && unacceptedPaymentMethod.every(
+                    (paymentMethodType) => paymentMethodType === DEFAULT_PAYMENT_METHOD_TYPE_FOR_MOVIE_TICKET
+                ));
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', eventSeries.project.id, eventSeries.typeOf, eventSeries.id, eventSeries.startDate, i);
+        } else {
+            if (Array.isArray(unacceptedPaymentMethod)) {
+                const newUnacceptedPaymentMethod = unacceptedPaymentMethod.filter(
+                    (paymentMethod) => paymentMethod === DEFAULT_PAYMENT_METHOD_TYPE_FOR_MOVIE_TICKET
+                );
+                console.log(
+                    'updating project...',
+                    newUnacceptedPaymentMethod,
+                    eventSeries.project.id, eventSeries.typeOf, eventSeries.id, eventSeries.startDate, i);
+                await eventSeriesRepo.saveEventSeries({
+                    id: eventSeries.id,
+                    attributes: <any>{
+                        ...{
+                            typeOf: eventSeries.typeOf,
+                            'offers.unacceptedPaymentMethod': newUnacceptedPaymentMethod
+                        }
+                    }
+                });
+                updateCount += 1;
+                console.log(
+                    'updated.',
+                    eventSeries.project.id, eventSeries.typeOf, eventSeries.id, eventSeries.startDate, i);
+            }
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/importEventsFromCOA.ts

@@ -37,14 +37,14 @@ async function main() {
             id: project.id,
             typeOf: chevre.factory.organizationType.Project
         },
-        locationBranchCode: '120',
-        importFrom: moment()
+        locationBranchCode: '016',
+        importFrom: moment('2025-12-10T04:45:00.181Z')
             .toDate(),
-        importThrough: moment()
-            .add(1, 'day')
+        importThrough: moment('2025-12-11T04:45:00.181Z')
+            // .add(1, 'day')
             .toDate(),
         saveMovieTheater: false,
-        saveScreeningEventSeries: false,
+        saveScreeningEventSeries: true,
         // saveScreeningEventSeries: true,
         saveScreeningEventSeriesPeriodInMonth: 3
     })({

package/example/src/chevre/member/migrateMemberIdentifier.ts

@@ -53,35 +53,40 @@ async function main() {
         i += 1;
         const iamMember: chevre.factory.iam.IMember = doc.toObject();
 
-        const identifierExists = typeof (<any>iamMember.member).identifier === 'string';
+        const applicationIdentifier = iamMember.member.identifier;
+        const updatingIdentifier = identifierMap.find(({ id }) => id === iamMember.member.id)?.identifier;
+        if (typeof updatingIdentifier !== 'string') {
+            throw new Error(`map not found. ${iamMember.member.name}`);
+        }
+        const identifierExists = typeof applicationIdentifier === 'string';
 
         if (identifierExists) {
+            if (applicationIdentifier !== updatingIdentifier) {
+                throw new Error(`unexpected application identifier. ${iamMember.member.name}`);
+            }
+
             console.log(
                 'identifier exists',
                 iamMember.project.id,
                 iamMember.member.name,
-                (<any>iamMember.member).identifier
+                applicationIdentifier
             );
         } else {
-            const updatingIdentifier = identifierMap.find(({ id }) => id === iamMember.member.id)?.identifier;
-            if (typeof updatingIdentifier !== 'string') {
-                throw new Error(`map not found. ${iamMember.member.name}`);
-            }
             console.log(
                 'migrating identifier...',
                 iamMember.project.id,
                 iamMember.member.name,
                 updatingIdentifier
             );
-            // await memberRepo.updateByMemberId({
-            //     project: { id: iamMember.project.id },
-            //     member: {
-            //         id: iamMember.member.id,
-            //         memberOf: iamMember.member.memberOf,
-            //         identifier: updatingIdentifier
-            //     },
-            //     $unset: {}
-            // });
+            await memberRepo.updateByMemberId({
+                project: { id: iamMember.project.id },
+                member: {
+                    id: iamMember.member.id,
+                    memberOf: iamMember.member.memberOf,
+                    identifier: updatingIdentifier
+                },
+                $unset: {}
+            });
             updated += 1;
         }
     });

package/example/src/chevre/pendingReservation/findEventSeatOffersBySection.ts

@@ -0,0 +1,46 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const { PROJECT_ID } = process.env;
+const formatter = new Intl.NumberFormat('ja-JP');
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    setInterval(
+        async () => {
+            startTime = process.hrtime();
+            const result = await (await chevre.service.offer.createService()).findEventSeatOffersBySection({
+                limit: 100,
+                page: 10,
+                projectId: String(PROJECT_ID),
+                sellerId: '59d20831e53ebc2b4e774466',
+                eventId: '693622f7876e9977c32ae270',
+                /**
+                 * セクションコード
+                 */
+                sectionCode: 'Default'
+            })({
+                event: await chevre.repository.Event.createInstance(mongoose.connection),
+                seat: await chevre.repository.place.Seat.createInstance(mongoose.connection),
+                stockHolder: await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection })
+            });
+            diff = process.hrtime(startTime);
+            // tslint:disable-next-line:no-null-keyword
+            console.dir(result, { depth: null });
+            console.log(result.length, 'results found');
+            console.log('diff:', [diff[0], formatter.format(diff[1])]);
+        },
+        // tslint:disable-next-line:no-magic-numbers
+        1000
+    );
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/place/checkSectionCount.ts

@@ -0,0 +1,27 @@
+// tslint:disable:no-console no-magic-numbers
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const roomRepo = await chevre.repository.place.ScreeningRoom.createInstance(mongoose.connection);
+
+    const rooms = await roomRepo.searchScreeningRooms({
+        $projection: { sectionCount: 1 }
+    });
+    console.log('docs found');
+    console.log(rooms);
+
+    const mutipleSectionRooms = rooms.filter((room) => typeof room.sectionCount === 'number' && room.sectionCount > 1);
+    console.log(mutipleSectionRooms);
+
+    console.log(rooms.length, 'rooms');
+    console.log(mutipleSectionRooms.length, 'mutipleSectionRooms');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/place/findSectionsByRoom.ts

@@ -0,0 +1,50 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+const SCREEN_CODE = '100';
+const MOVIE_THEATER_CODE = '118';
+const SELLER_ID = '59d20831e53ebc2b4e774466';
+
+const formatter = new Intl.NumberFormat('ja-JP');
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const sectionRepo = await chevre.repository.place.Section.createInstance(mongoose.connection);
+
+    setInterval(
+        async () => {
+            startTime = process.hrtime();
+            const seats = await sectionRepo.findSectionsByRoom(
+                {
+                    limit: 10,
+                    page: 1,
+                    projectId: PROJECT_ID,
+                    sellerId: SELLER_ID,
+                    movieTheaterCode: MOVIE_THEATER_CODE,
+                    roomCode: SCREEN_CODE
+                }
+            );
+            diff = process.hrtime(startTime);
+            // tslint:disable-next-line:no-null-keyword
+            console.dir(seats, { depth: null });
+            console.log(seats.length, 'sections found');
+            console.log('diff:', [diff[0], formatter.format(diff[1])]);
+        },
+        // tslint:disable-next-line:no-magic-numbers
+        1000
+    );
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/project/unsetProjectSettings.ts

@@ -0,0 +1,73 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const projectRepo = await chevre.repository.Project.createInstance(mongoose.connection);
+
+    const cursor = projectRepo.getCursor(
+        {
+            _id: {
+                $nin: [
+                    'ttts-development',
+                    'ttts-test',
+                    'ttts-production'
+                ]
+            }
+        },
+        {
+            _id: 1,
+            settings: 1,
+            typeOf: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const project: Pick<chevre.factory.project.IProject, 'id' | 'typeOf' | 'settings'> = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', project.id, i);
+        const includeCustomerAsFindByConfirmationNumberResult = project.settings?.includeCustomerAsFindByConfirmationNumberResult;
+        let alreadyMigrated = true;
+        if (typeof includeCustomerAsFindByConfirmationNumberResult === 'boolean'
+            && includeCustomerAsFindByConfirmationNumberResult === true) {
+            alreadyMigrated = false;
+        }
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', project.id, i);
+        } else {
+            console.log(
+                'updating project...',
+                project.id, i);
+            await projectRepo.unsetUnnecessaryFields({
+                filter: {
+                    _id: { $eq: project.id }
+                },
+                $unset: {
+                    'settings.includeCustomerAsFindByConfirmationNumberResult': 1
+                }
+            });
+            updateCount += 1;
+            console.log(
+                'updated.',
+                project.id, i);
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/reIndex.ts

@@ -11,8 +11,7 @@ mongoose.Model.on('index', (...args) => {
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    await chevre.repository.CategoryCode.createInstance(mongoose.connection);
-    // await chevre.repository.MovieTicketType.createInstance(mongoose.connection);
+    await chevre.repository.EventOffer.createInstance(mongoose.connection);
     console.log('success!');
 }
 

package/example/src/chevre/roles/{addAdminSellerEventIfNotExists.ts → addAdminSellerEventOfferIfNotExists.ts}

@@ -14,7 +14,7 @@ async function main() {
         chevre.factory.role.organizationRole.RoleName.SellersInventoryManager
     ];
     const permissions = [
-        'admin.sellers.events.*'
+        'admin.sellers.eventOffers.*'
     ];
     for (const roleName of roleNames) {
         for (const permission of permissions) {