@chevre/domain 20.2.0-alpha.8 → 20.2.0

package/example/src/chevre/aggregateEventReservation.ts

@@ -0,0 +1,37 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: <string>process.env.PROJECT_ID };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+    const client = redis.createClient({
+        host: process.env.REDIS_HOST,
+        port: Number(process.env.REDIS_PORT),
+        password: process.env.REDIS_KEY
+    });
+
+    // const now = new Date();
+    await chevre.service.aggregation.event.aggregateScreeningEvent({
+        id: 'alb35u7m4'
+    })({
+        event: new chevre.repository.Event(mongoose.connection),
+        eventAvailability: new chevre.repository.itemAvailability.ScreeningEvent(client),
+        offer: new chevre.repository.Offer(mongoose.connection),
+        offerRateLimit: new chevre.repository.rateLimit.Offer(client),
+        place: new chevre.repository.Place(mongoose.connection),
+        product: new chevre.repository.Product(mongoose.connection),
+        project: new chevre.repository.Project(mongoose.connection),
+        reservation: new chevre.repository.Reservation(mongoose.connection),
+        task: new chevre.repository.Task(mongoose.connection)
+    });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/aggregation/aggregateSystem.ts

@@ -0,0 +1,116 @@
+// tslint:disable:no-console
+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 AGGREGATE_DAYS = Number(process.env.AGGREGATE_DAYS);
+const AGGREGATE_CLIENT_IDS = (typeof process.env.AGGREGATE_CLIENT_IDS === 'string') ? process.env.AGGREGATE_CLIENT_IDS.split(',') : [];
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const aggregationRepo = new chevre.repository.Aggregation(mongoose.connection);
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+    const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+
+    await chevre.service.aggregation.system.aggregatePayMovieTicketAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+    return;
+
+    await chevre.service.aggregation.system.aggregatePayTransaction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        assetTransaction: assetTransactionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateEvent({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        event: eventRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateTask({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        task: taskRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateReserveTransaction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        assetTransaction: assetTransactionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregatePlaceOrder({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID,
+        clientIds: AGGREGATE_CLIENT_IDS
+    })({
+        agregation: aggregationRepo,
+        transaction: transactionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateAuthorizeOrderAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateAuthorizeEventServiceOfferAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateAuthorizePaymentAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateUseAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateCheckMovieTicketAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/attendIfNotAttended.ts

@@ -0,0 +1,22 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const reservationRepo = new chevre.repository.Reservation(mongoose.connection);
+
+    const reservation = await reservationRepo.attendIfNotAttended(
+        {
+            id: '864318975593476-0',
+            now: new Date()
+        }
+    );
+    console.log('event found', reservation);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/createManyEventsIfNotExist.ts

@@ -0,0 +1,209 @@
+// 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 filterName: string = 'eventIdentifier';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+
+    const result = await eventRepo.createManyIfNotExist<chevre.factory.eventType.ScreeningEvent>([
+        {
+            attributes: {
+                additionalProperty: [{
+                    name: filterName,
+                    value: '20230201143000-03'
+                }],
+                project: {
+                    id: PROJECT_ID,
+                    typeOf: chevre.factory.organizationType.Project
+                },
+                typeOf: chevre.factory.eventType.ScreeningEvent,
+                doorTime: moment('2023-02-01T05:00:00.000Z')
+                    .toDate(),
+                startDate: moment('2023-02-01T05:00:00.000Z')
+                    .toDate(),
+                endDate: moment('2023-02-01T06:00:00.000Z')
+                    .toDate(),
+                workPerformed: {
+                    typeOf: chevre.factory.creativeWorkType.Movie,
+                    identifier: '1622100',
+                    id: '5bfb841d5a78d7948369980a',
+                    name: {
+                        en: 'Pet',
+                        ja: 'ペット'
+                    },
+                    duration: 'PT2H3M'
+                },
+                location: {
+                    typeOf: chevre.factory.placeType.ScreeningRoom,
+                    branchCode: '10',
+                    name: {
+                        ja: 'シネマ1',
+                        en: 'CINEMA1'
+                    },
+                    address: {
+                        ja: '7階',
+                        en: '7F'
+                    }
+                },
+                superEvent: {
+                    typeOf: chevre.factory.eventType.ScreeningEventSeries,
+                    project: {
+                        typeOf: chevre.factory.organizationType.Project,
+                        id: 'cinerino'
+                    },
+                    id: '7k9ayl8hc',
+                    videoFormat: [
+                        {
+                            typeOf: '2D',
+                            name: '2D'
+                        }
+                    ],
+                    soundFormat: [],
+                    workPerformed: {
+                        typeOf: chevre.factory.creativeWorkType.Movie,
+                        identifier: '1622100',
+                        id: '5bfb841d5a78d7948369980a',
+                        name: {
+                            en: 'Pet',
+                            ja: 'ペット'
+                        },
+                        duration: 'PT2H3M'
+                    },
+                    location: {
+                        typeOf: chevre.factory.placeType.MovieTheater,
+                        id: '5bfb841d5a78d7948369979a',
+                        branchCode: '118',
+                        name: {
+                            ja: 'シネモーション赤坂 ',
+                            en: 'CineMotion Akasaka'
+                        },
+                        kanaName: 'シネモーションアカサカ'
+                    },
+                    kanaName: 'ペットカナタイトル',
+                    name: {
+                        en: 'PetPetPetPet',
+                        ja: 'ペット'
+                    },
+                    additionalProperty: [
+                        {
+                            name: 'sortNumber',
+                            value: '99'
+                        }
+                    ],
+                    startDate: moment('2020-03-31T15:00:00.000Z')
+                        .toDate(),
+                    endDate: moment('2034-12-01T15:00:00.000Z')
+                        .toDate(),
+                    description: {
+                        en: 'english description',
+                        ja: 'ムビチケ検証用のイベントです。'
+                    },
+                    headline: {
+                        en: 'headlineheadlineheadlineheadlineheadlineheadlineheadline',
+                        ja: 'サブタイトルkanaName'
+                    },
+                    subtitleLanguage: {
+                        typeOf: 'Language',
+                        name: 'Japanese'
+                    }
+                },
+                name: {
+                    en: 'PetPetPetPet',
+                    ja: 'ペット'
+                },
+                eventStatus: chevre.factory.eventStatusType.EventScheduled,
+                offers: {
+                    typeOf: chevre.factory.offerType.Offer,
+                    priceCurrency: chevre.factory.priceCurrency.JPY,
+                    availabilityEnds: moment('2023-02-01T01:20:00.000Z')
+                        .toDate(),
+                    availabilityStarts: moment('2023-01-30T15:00:00.000Z')
+                        .toDate(),
+                    eligibleQuantity: {
+                        typeOf: 'QuantitativeValue',
+                        unitCode: chevre.factory.unitCode.C62,
+                        maxValue: 6,
+                        value: 1
+                    },
+                    itemOffered: {
+                        id: '6308580bdef565000a9aa1fd',
+                        name: {
+                            ja: '通常興行カタログ'
+                        },
+                        serviceOutput: {
+                            typeOf: chevre.factory.reservationType.EventReservation,
+                            reservedTicket: {
+                                typeOf: 'Ticket',
+                                ticketedSeat: {
+                                    typeOf: chevre.factory.placeType.Seat
+                                }
+                            }
+                        },
+                        typeOf: chevre.factory.product.ProductType.EventService,
+                        availableChannel: {
+                            typeOf: 'ServiceChannel',
+                            serviceLocation: {
+                                typeOf: chevre.factory.placeType.ScreeningRoom,
+                                branchCode: '10',
+                                name: {
+                                    ja: 'シネマ1',
+                                    en: 'CINEMA1'
+                                },
+                                containedInPlace: {
+                                    typeOf: chevre.factory.placeType.MovieTheater,
+                                    id: '5bfb841d5a78d7948369979a',
+                                    branchCode: '118',
+                                    name: {
+                                        ja: 'シネモーション赤坂 ',
+                                        en: 'CineMotion Akasaka'
+                                    }
+                                }
+                            }
+                        },
+                        serviceType: {
+                            codeValue: '0001',
+                            id: '5e3361d01dc1ef1a20dd8737',
+                            inCodeSet: {
+                                typeOf: 'CategoryCodeSet',
+                                identifier: chevre.factory.categoryCode.CategorySetIdentifier.ServiceType
+                            },
+                            project: {
+                                typeOf: chevre.factory.organizationType.Project,
+                                id: 'cinerino'
+                            },
+                            typeOf: 'CategoryCode'
+                        }
+                    },
+                    validFrom: moment('2023-01-29T15:00:00.000Z')
+                        .toDate(),
+                    validThrough: moment('2023-02-01T01:20:00.000Z')
+                        .toDate(),
+                    seller: {
+                        typeOf: chevre.factory.organizationType.Corporation,
+                        id: '59d20831e53ebc2b4e774466',
+                        name: {
+                            ja: 'シネモーション赤坂',
+                            en: 'CineMotion Akasaka'
+                        },
+                        makesOffer: []
+                    }
+                }
+            },
+            filter: { name: filterName }
+        }
+    ]);
+    console.log(result);
+    console.log('upsertedIds:', (Array.isArray(result?.result.upserted)) ? result?.result.upserted.map((u: any) => u._id) : []);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/findByOrderNumberAndReservationId.ts

@@ -0,0 +1,20 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const orderRepo = new chevre.repository.Order(mongoose.connection);
+
+    const order = await orderRepo.findByOrderNumberAndReservationId({
+        orderNumber: 'CIN9-4783801-1618274',
+        reservationId: '139787058570943-0'
+    });
+    console.log('order found', order);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/findScreeningRoomsByBranchCode.ts

@@ -0,0 +1,27 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const event = await placeRepo.findScreeningRoomsByBranchCode({
+        branchCode: {
+            $eq: '20'
+        },
+        containedInPlace: {
+            id: {
+                $eq: '5bfb841d5a78d7948369979a'
+            }
+        }
+    });
+    console.log('room found', event);
+
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/importEventsFromCOA.ts

@@ -14,6 +14,7 @@ async function main() {
     const categoryCodeRepo = new chevre.repository.CategoryCode(mongoose.connection);
     const eventRepo = new chevre.repository.Event(mongoose.connection);
     const placeRepo = new chevre.repository.Place(mongoose.connection);
+    const sellerRepo = new chevre.repository.Seller(mongoose.connection);
 
     await chevre.service.event.importFromCOA({
         project: {
@@ -28,7 +29,13 @@ async function main() {
             .toDate(),
         saveMovieTheater: false,
         saveScreeningEventSeries: false
-    })({ action: actionRepo, categoryCode: categoryCodeRepo, event: eventRepo, place: placeRepo });
+    })({
+        action: actionRepo,
+        categoryCode: categoryCodeRepo,
+        event: eventRepo,
+        place: placeRepo,
+        seller: sellerRepo
+    });
     console.log('imported');
 }
 

package/example/src/chevre/migrateEventOffersItemOfferedAvailableChannel.ts

@@ -21,7 +21,8 @@ async function main() {
             typeOf: { $eq: chevre.factory.eventType.ScreeningEvent },
             startDate: {
                 $gte: moment()
-                    .add(-1, 'month')
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-6, 'months')
                     .toDate()
             }
             // _id: { $eq: 'al6aff83w' }

package/example/src/chevre/migrateOwnershipInfos2newUserPool.ts

@@ -55,7 +55,7 @@ async function main() {
     let updateCount = 0;
     await cursor.eachAsync(async (doc) => {
         i += 1;
-        const ownershipInfo = <chevre.factory.ownershipInfo.IOwnershipInfo<chevre.factory.ownershipInfo.IPermit>>doc.toObject();
+        const ownershipInfo = <chevre.factory.ownershipInfo.IOwnershipInfo<chevre.factory.ownershipInfo.IPermitAsGood>>doc.toObject();
 
         const owner = <chevre.factory.person.IPerson>ownershipInfo.ownedBy;
         let iss =

package/example/src/chevre/migrateProjectSubscription.ts

@@ -0,0 +1,51 @@
+// 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 projectRepo = new chevre.repository.Project(mongoose.connection);
+
+    const cursor = projectRepo.getCursor(
+        {
+        },
+        {
+            // _id: 1,
+        }
+    );
+    console.log('projects found');
+
+    let i = 0;
+    let updateCount = 0;
+    // tslint:disable-next-line:max-func-body-length
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const project: chevre.factory.project.IProject = doc.toObject();
+
+        const useEventServiceAsProduct = project.subscription?.useEventServiceAsProduct;
+        const alreadyMigrated = useEventServiceAsProduct === true;
+
+        if (alreadyMigrated) {
+            console.log('already migrated.', project.id, i);
+        } else {
+            console.log(
+                'updating product...', project.id, i);
+            await projectRepo.findByIdAndIUpdate({
+                id: project.id,
+                subscription: { useEventServiceAsProduct: true }
+            });
+            updateCount += 1;
+            console.log('updated...', project.id, i);
+        }
+    });
+    console.log(i, 'projects checked');
+    console.log(updateCount, 'projects updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/ownershipInfosCsv2peopleJson.ts

@@ -132,7 +132,7 @@ function findAccount(params: {
     customer: { id: string };
     now: Date;
 }) {
-    return async (): Promise<chevre.factory.ownershipInfo.IPermit | undefined> => {
+    return async (): Promise<chevre.factory.ownershipInfo.IPermitAsGood | undefined> => {
         const ownershipInfoRepo = new chevre.repository.OwnershipInfo(mongoose.connection);
 
         // let accountOwnershipInfos = await search({
@@ -171,7 +171,7 @@ function findAccount(params: {
             // throw new domain.factory.errors.NotFound('accountOwnershipInfos');
         }
 
-        return <chevre.factory.ownershipInfo.IPermit>ownershipInfos[0].typeOfGood;
+        return <chevre.factory.ownershipInfo.IPermitAsGood>ownershipInfos[0].typeOfGood;
     };
 }
 

package/example/src/chevre/processReserve.ts

@@ -63,6 +63,8 @@ async function main() {
             ],
             reservationFor: { id: 'ckuz8uj0c' }
         },
+        validateEvent: false,
+        validateEventOfferPeriod: false,
         validateAppliesToMovieTicket: true
     })({
         eventAvailability: itemAvailabilityRepo,

package/example/src/chevre/searchEventIds.ts

@@ -0,0 +1,24 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const PROJECT_ID = process.env.PROJECT_ID;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+
+    const ids = await eventRepo.searchIds({
+        typeOf: chevre.factory.eventType.ScreeningEvent,
+        project: { id: { $eq: PROJECT_ID } },
+        id: { $in: ['al6afe7ad', 'al6afe7ae'] }
+    });
+    console.log(ids);
+    console.log(ids.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchEventTicketOffers.ts

@@ -21,9 +21,11 @@ async function main() {
     const offerRateLimitRepo = new chevre.repository.rateLimit.Offer(client);
     const productRepo = new chevre.repository.Product(mongoose.connection);
 
-    const offers = await chevre.service.offer.event.searchEventTicketOffers({
+    const { ticketOffers } = await chevre.service.offer.event.searchEventTicketOffers({
         event: { id: 'al9ew43f5' },
-        onlyValid: true
+        onlyValid: true,
+        sort: true,
+        validateOfferRateLimit: true
         // ...(typeof sellerId === 'string') ? { seller: { id: sellerId } } : undefined,
         // ...(typeof availableAtId === 'string') ? { store: { id: availableAtId } } : undefined
     })({
@@ -33,8 +35,7 @@ async function main() {
         priceSpecification: priceSpecificationRepo,
         product: productRepo
     });
-    // console.log(offers);
-    console.log(offers.length);
+    console.log(ticketOffers.length);
 }
 
 main()