@chevre/domain 23.1.0-alpha.3 → 23.1.0-alpha.31

package/example/src/chevre/acceptedPaymentMethodOffer/adminAcceptedPaymentMethodOffers.ts

@@ -0,0 +1,68 @@
+// 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) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const acceptedPaymentMethodRepo = await chevre.repository.AcceptedPaymentMethod.createInstance(mongoose.connection);
+
+    const validFrom = moment()
+        .toDate();
+    const validThrough = moment(validFrom)
+        .add(1, 'hour')
+        .toDate();
+    const settingOffer: Omit<chevre.factory.acceptedPaymentMethodOffer.IAcceptedPaymentMethodOffer, 'id'> = {
+        typeOf: chevre.factory.offerType.Offer,
+        identifier: '20251202acceptedPaymentMethod',
+        itemOffered: {
+            id: '7k9ayl8hc',
+            typeOf: chevre.factory.eventType.ScreeningEventSeries
+        },
+        acceptedPaymentMethod: {
+            id: '5f9a52994f3709000abe6417',
+            typeOf: chevre.factory.service.paymentService.PaymentServiceType.MovieTicket
+        },
+        validFrom,
+        validThrough,
+        seller: {
+            id: '59d20831e53ebc2b4e774466',
+            typeOf: chevre.factory.organizationType.Corporation
+        },
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project }
+    };
+
+    let result = await acceptedPaymentMethodRepo.upsertAcceptedPaymentMethodsByIdentifier(
+        [
+            {
+                $set: settingOffer,
+                $unset: {}
+            }
+        ],
+        {
+            update: false
+        }
+    );
+    console.log(result);
+
+    result = await acceptedPaymentMethodRepo.upsertAcceptedPaymentMethodsByIdentifier(
+        [
+            {
+                $set: settingOffer,
+                $unset: {}
+            }
+        ],
+        {
+            update: true
+        }
+    );
+    console.log(result);
+}
+
+main()
+    .then()
+    .catch(console.error);

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,12 +98,14 @@ 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),
             eventOffer: await chevre.repository.EventOffer.createInstance(mongoose.connection),
             eventSeries: await chevre.repository.EventSeries.createInstance(mongoose.connection),
             issuer: await chevre.repository.Issuer.createInstance(mongoose.connection),
+            member: await chevre.repository.Member.createInstance(mongoose.connection),
             memberProgram: await chevre.repository.MemberProgram.createInstance(mongoose.connection),
             offer: await chevre.repository.Offer.createInstance(mongoose.connection),
             offerCatalog: await chevre.repository.OfferCatalog.createInstance(mongoose.connection),
@@ -114,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,
@@ -57,6 +58,7 @@ async function main() {
             eventOffer: await chevre.repository.EventOffer.createInstance(mongoose.connection),
             eventSeries: await chevre.repository.EventSeries.createInstance(mongoose.connection),
             issuer: await chevre.repository.Issuer.createInstance(mongoose.connection),
+            member: await chevre.repository.Member.createInstance(mongoose.connection),
             memberProgram: await chevre.repository.MemberProgram.createInstance(mongoose.connection),
             stockHolder: await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection }),
             offer: await chevre.repository.Offer.createInstance(mongoose.connection),

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/member/migrateMemberIdentifier.ts

@@ -0,0 +1,99 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+const identifierMap = [
+    {
+        id: '7divuoimobsfgq95tp1csorjqq',
+        identifier: 'SmartTheaterTXNMember'
+    },
+    {
+        id: '51qbjcfr72h62m06vtv5kkhgje',
+        identifier: 'SmartTheaterTXN'
+    },
+    {
+        id: 'ckevmf3fueqcunnideu6artt',
+        identifier: 'SmartTheaterPOS'
+    },
+    {
+        id: '3eo6okferrsdpfd9j2ce1iv9k7',
+        identifier: 'SmartTheaterTVM'
+    }
+];
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const memberRepo = await chevre.repository.Member.createInstance(mongoose.connection);
+
+    const cursor = memberRepo.getCursor(
+        {
+            // typeOf: { $eq: chevre.factory.placeType.ScreeningRoom }
+            'project.id': { $eq: '*' }
+            // 'project.id': { $ne: EXCLUDED_PROJECT_ID },
+        },
+        {
+            project: 1,
+            member: 1
+            // paymentMethods: 1,
+            // project: 1,
+            // orderDate: 1
+        }
+    );
+    console.log('docs found');
+
+    let updated: number = 0;
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const iamMember: chevre.factory.iam.IMember = doc.toObject();
+
+        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,
+                applicationIdentifier
+            );
+        } else {
+            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: {}
+            });
+            updated += 1;
+        }
+    });
+    console.log(i, 'docs checked');
+    console.log('updated:', updated);
+}
+
+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', 'sskts-development',
+                    'ttts-test', 'sskts-test',
+                    'ttts-production', 'sskts-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) {