@chevre/domain 23.1.0-alpha.9 → 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/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/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

@@ -12,7 +12,6 @@ async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     await chevre.repository.EventOffer.createInstance(mongoose.connection);
-    await chevre.repository.Member.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) {

package/example/src/chevre/stockHolder/findSeatsBySection.ts

@@ -0,0 +1,59 @@
+// 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 seatRepo = await chevre.repository.place.Seat.createInstance(mongoose.connection);
+
+    setInterval(
+        async () => {
+            startTime = process.hrtime();
+            const seats = await seatRepo.findSeatsBySection(
+                {
+                    limit: 100,
+                    page: 100,
+                    projectId: PROJECT_ID,
+                    sellerId: SELLER_ID,
+                    movieTheaterCode: MOVIE_THEATER_CODE,
+                    roomCode: SCREEN_CODE,
+                    sectionCode: 'Default'
+                },
+                {
+                    // branchCode: { $in: ['Z-384'] },
+                    // containedInPlace: {
+                    //     branchCode: {
+                    //         $in: ['Default']
+                    //     }
+                    // }
+                }
+            );
+            diff = process.hrtime(startTime);
+            // tslint:disable-next-line:no-null-keyword
+            console.dir(seats, { depth: null });
+            console.log(seats.length, 'seats 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/stockHolder/searchSeats.ts

@@ -28,8 +28,8 @@ async function main() {
                     'containedInPlace.containedInPlace': 0,
                     'containedInPlace.typeOf': 0,
                     'containedInPlace.name': 0,
-                    typeOf: 0,
-                    additionalProperty: 0
+                    typeOf: 0
+                    // additionalProperty: 0
                 },
                 project: { id: { $eq: PROJECT_ID } },
                 screeningRoom: {

package/lib/chevre/repo/acceptedPaymentMethod.d.ts

@@ -0,0 +1,41 @@
+import type { BulkWriteResult } from 'mongodb';
+import { Connection, FilterQuery } from 'mongoose';
+import * as factory from '../factory';
+import { IDocType } from './mongoose/schemas/acceptedPaymentMethod';
+type IUnset = {
+    [key in keyof IDocType]?: 1;
+};
+type IDocWithId = IDocType & {
+    id: string;
+};
+type IKeyOfProjection = keyof IDocType;
+/**
+ * 対応決済方法リポジトリ
+ */
+export declare class AcceptedPaymentMethodRepo {
+    private readonly acceptedPaymentMethodModel;
+    constructor(connection: Connection);
+    static CREATE_MONGO_CONDITIONS(params: factory.acceptedPaymentMethodOffer.ISearchConditions): FilterQuery<IDocType>[];
+    findAcceptedPaymentMethods(params: factory.acceptedPaymentMethodOffer.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<IDocWithId[]>;
+    /**
+     * オファーコードと提供リソースIDをキーにして冪等置換
+     */
+    upsertAcceptedPaymentMethodsByIdentifier(params: {
+        $set: Pick<IDocType, 'identifier' | 'itemOffered' | 'acceptedPaymentMethod' | 'seller' | 'project' | 'typeOf' | 'validFrom' | 'validThrough'> & {
+            id?: never;
+        };
+        $unset: IUnset;
+    }[], options: {
+        /**
+         * falseの場合setOnInsertのみ
+         * trueの場合setのみ
+         */
+        update: boolean;
+    }): Promise<{
+        bulkWriteResult: BulkWriteResult;
+        modifiedProductOffers: {
+            id: string;
+        }[];
+    } | void>;
+}
+export {};