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

@@ -0,0 +1,83 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+/**
+ * 指定する施設コード
+ */
+const locationBranchCode = '120';
+/**
+ * 指定するタイトルコード
+ */
+const titleCode = '80001';
+/**
+ * 指定するタイトル枝番
+ */
+const titleBranchNum = '0';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const categoryCodeRepo = await chevre.repository.CategoryCode.createInstance(mongoose.connection);
+    const creativeWorkRepo = await chevre.repository.CreativeWork.createInstance(mongoose.connection);
+    const eventSeriesRepo = await chevre.repository.EventSeries.createInstance(mongoose.connection);
+    const movieTheaterRepo = await chevre.repository.place.MovieTheater.createInstance(mongoose.connection);
+
+    const coaAuthClient = new (await chevre.loadCOA()).auth.RefreshToken({
+        endpoint: String(process.env.COA_ENDPOINT),
+        refreshToken: process.env.COA_REFRESH_TOKEN,
+        useFetch: true
+    });
+    const masterService = new (await chevre.loadCOA()).service.Master(
+        {
+            endpoint: String(process.env.COA_ENDPOINT),
+            auth: coaAuthClient
+        },
+        { timeout: 20000 }
+    );
+
+    const movieTheater = (await movieTheaterRepo.projectFields(
+        {
+            limit: 1,
+            page: 1,
+            project: { id: { $eq: project.id } },
+            branchCode: { $eq: locationBranchCode }
+        },
+        ['id', 'typeOf', 'branchCode', 'name', 'kanaName', 'parentOrganization']
+        // []
+    )).shift();
+    if (movieTheater === undefined) {
+        throw new Error('movieTheater not found');
+    }
+    console.log('movieTheater:', movieTheater);
+
+    const result = await (await chevre.service.event.createService()).saveScreeningEventSeries(
+        {
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            seller: { id: movieTheater.parentOrganization.id },
+            movieTheater,
+            locationBranchCode,
+            saveScreeningEventSeries: true,
+            saveScreeningEventSeriesPeriodInMonth: 3
+        },
+        {
+            filterFilmsFromCOA: {
+                titleBranchNum,
+                titleCode
+            }
+        }
+    )({
+        categoryCode: categoryCodeRepo,
+        creativeWork: creativeWorkRepo,
+        eventSeries: eventSeriesRepo,
+        masterService
+    });
+    console.log('result:', result.savedEventsCount, result.screeningEventSerieses.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/event/importEventsFromCOAByTitle.ts

@@ -0,0 +1,148 @@
+// tslint:disable:no-console
+import * as moment from 'moment-timezone';
+import * as mongoose from 'mongoose';
+
+import { createScreeningEventSeriesId } from '../../../../lib/chevre/service/event/saveScreeningEventSeries';
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+/**
+ * 指定する施設コード
+ */
+const locationBranchCode = '120';
+/**
+ * 指定するルームコード
+ */
+const roomCode = '30';
+/**
+ * 指定するタイトルコード
+ */
+const titleCode = '99100';
+/**
+ * 指定するタイトル枝番
+ */
+const titleBranchNum = '0';
+/**
+ * 指定するスケジュールの開始日(日本時間)
+ */
+const importDay = new Date();
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const categoryCodeRepo = await chevre.repository.CategoryCode.createInstance(mongoose.connection);
+    const creativeWorkRepo = await chevre.repository.CreativeWork.createInstance(mongoose.connection);
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const eventSeriesRepo = await chevre.repository.EventSeries.createInstance(mongoose.connection);
+    const movieTheaterRepo = await chevre.repository.place.MovieTheater.createInstance(mongoose.connection);
+    const roomRepo = await chevre.repository.place.ScreeningRoom.createInstance(mongoose.connection);
+
+    const coaAuthClient = new (await chevre.loadCOA()).auth.RefreshToken({
+        endpoint: String(process.env.COA_ENDPOINT),
+        refreshToken: process.env.COA_REFRESH_TOKEN,
+        useFetch: true
+    });
+    const masterService = new (await chevre.loadCOA()).service.Master(
+        {
+            endpoint: String(process.env.COA_ENDPOINT),
+            auth: coaAuthClient
+        },
+        { timeout: 20000 }
+    );
+
+    const movieTheater = (await movieTheaterRepo.projectFields(
+        {
+            limit: 1,
+            page: 1,
+            project: { id: { $eq: project.id } },
+            branchCode: { $eq: locationBranchCode }
+        },
+        ['id', 'typeOf', 'branchCode', 'name', 'kanaName', 'parentOrganization']
+        // []
+    )).shift();
+    if (movieTheater === undefined) {
+        throw new Error('movieTheater not found');
+    }
+    console.log('movieTheater:', movieTheater);
+
+    const screeningRooms = await roomRepo.searchScreeningRooms({
+        project: { id: { $eq: project.id } },
+        containedInPlace: { branchCode: { $eq: movieTheater.branchCode } },
+        branchCode: { $eq: roomCode }
+    });
+    console.log(screeningRooms);
+
+    const eventSeriesId = createScreeningEventSeriesId({
+        theaterCode: locationBranchCode,
+        titleCode,
+        titleBranchNum
+    });
+    const eventSeries = (await eventSeriesRepo.projectEventSeriesFields(
+        {
+            id: { $eq: eventSeriesId },
+            project: { id: { $eq: project.id } }
+        },
+        [
+            'project', 'typeOf', 'eventStatus', 'identifier',
+            'name', 'kanaName', 'alternativeHeadline', 'location',
+            'organizer', 'videoFormat', 'soundFormat', 'workPerformed',
+            'duration', 'endDate', 'startDate', 'coaInfo',
+            'offers', 'additionalProperty'
+        ]
+    )).shift();
+    if (eventSeries === undefined) {
+        throw new Error('eventSeries not found');
+    }
+    console.log(eventSeries);
+
+    const targetImportFrom = moment(importDay)
+        .tz('Asia/Tokyo')
+        .startOf('day');
+    const targetImportThrough = moment(importDay)
+        .tz('Asia/Tokyo')
+        .endOf('day');
+    const begin: string = moment(targetImportFrom)
+        .add(-1, 'day') // 深夜帯スケジュールが前日検索の結果に含まれるため
+        .tz('Asia/Tokyo')
+        .format('YYYYMMDD'); // COAは日本時間で判断
+    const end: string = moment(targetImportThrough)
+        // .add(-1, 'day')
+        .tz('Asia/Tokyo')
+        .format('YYYYMMDD'); // COAは日本時間で判断
+    console.log('importing screening events...', targetImportFrom, targetImportThrough, begin, end);
+
+    const result = await (await chevre.service.event.createService()).saveScreeningEvents(
+        {
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            seller: { id: movieTheater.parentOrganization.id },
+            movieTheater,
+            screeningRooms,
+            screeningEventSerieses: [eventSeries],
+            targetImportFrom: targetImportFrom.toDate(),
+            targetImportThrough: targetImportThrough.toDate(),
+            instrument: {
+                theaterCode: locationBranchCode,
+                begin, // debug(2024-04-24~)
+                end, // debug(2024-04-24~)
+                typeOf: 'WebAPI',
+                identifier: chevre.factory.service.webAPI.Identifier.COA
+            }
+        },
+        {
+            filterSchedulesFromCOA: { titleBranchNum, titleCode, roomCode }
+        }
+    )({
+        categoryCode: categoryCodeRepo,
+        creativeWork: creativeWorkRepo,
+        event: eventRepo,
+        eventSeries: eventSeriesRepo,
+        masterService
+    });
+    console.log('result:', result.length, 'events');
+}
+
+main()
+    .then(console.log)
+    .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);