@chevre/domain 22.5.0-alpha.2 → 22.5.0-alpha.20

package/example/src/chevre/aggregateEventPublicFields.ts

@@ -0,0 +1,46 @@
+// 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 eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const result = await eventRepo.aggregatePublicFields<chevre.factory.eventType.ScreeningEvent>(
+        {
+            limit: 10,
+            page: 1,
+            sort: { startDate: chevre.factory.sortType.Ascending },
+            // id: { $eq: 'bm0f0cadu' },
+            typeOf: chevre.factory.eventType.ScreeningEvent,
+            project: { id: { $eq: project.id } },
+            startFrom: new Date(),
+            startThrough: moment()
+                // tslint:disable-next-line:no-magic-numbers
+                .add(3, 'days')
+                .toDate()
+            // availableAtOrFrom: { id: { $eq: '3eo6okferrsdpfd9j2ce1iv9k7' } },
+            // itemOffered: {
+            //     serviceOutput: { reservationFor: { id: { $in: ['bm0f0cadu', 'blco2394l'] } } }
+            // }
+        },
+        ['eventStatus', 'startDate'],
+        {
+            // includeOffers: true,
+            includeOffers: false,
+            sellerMakesOfferAvailableAtIn: ['51qbjcfr72h62m06vtv5kkhgje', 'g']
+        }
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+    console.log(result.length, 'results found');
+    console.log(result.at(0)?.offers?.seller?.makesOffer.length, 'makesOffer found');
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/aggregateEventSellerMakesOffer.ts

@@ -0,0 +1,32 @@
+// tslint:disable:no-console
+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 eventSellerMakesOfferRepo = await chevre.repository.EventSellerMakesOffer.createInstance(mongoose.connection);
+    const result = await eventSellerMakesOfferRepo.aggregateMakesOffer(
+        {
+            limit: 10,
+            page: 1,
+            // id: { $eq: 'bm0f0cadu' },
+            // typeOf: chevre.factory.eventType.ScreeningEvent,
+            project: { id: { $eq: project.id } },
+            availableAtOrFrom: { id: { $eq: '3eo6okferrsdpfd9j2ce1iv9k7' } },
+            itemOffered: {
+                serviceOutput: { reservationFor: { id: { $in: ['bm0f0cadu', 'blco2394l'] } } }
+            }
+        }
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+    console.dir(result.length, 'results found');
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/findReservationByCode.ts

@@ -32,17 +32,18 @@ async function main() {
             authorization: authorizationRepo,
             order: orderRepo,
             ticket: ticketRepo
-        },
-        {
-            jwt: await chevre.credentials.JWT.createInstance({
-                secret: <string>process.env.TOKEN_SECRET,
-                issuers: (typeof process.env.TOKEN_ISSUERS_BY_AUTHORIZATION === 'string')
-                    ? process.env.TOKEN_ISSUERS_BY_AUTHORIZATION.split(' ')
-                    : [],
-                version: (typeof process.env.TOKEN_VERSION === 'string') ? process.env.TOKEN_VERSION : '2024-05-02',
-                payloadTypPrefix: (typeof process.env.TOKEN_PAYLOAD_TYP_PREFIX === 'string') ? process.env.TOKEN_PAYLOAD_TYP_PREFIX : 'chevre'
-            })
         }
+        // {
+        //     jwt: await chevre.credentials.JWT.createInstance({
+        //         secret: <string>process.env.TOKEN_SECRET,
+        //         issuers: (typeof process.env.TOKEN_ISSUERS_BY_AUTHORIZATION === 'string')
+        //             ? process.env.TOKEN_ISSUERS_BY_AUTHORIZATION.split(' ')
+        //             : [],
+        //         version: (typeof process.env.TOKEN_VERSION === 'string') ? process.env.TOKEN_VERSION : '2024-05-02',
+        //         payloadTypPrefix:
+        //             (typeof process.env.TOKEN_PAYLOAD_TYP_PREFIX === 'string') ? process.env.TOKEN_PAYLOAD_TYP_PREFIX : 'chevre'
+        //     })
+        // }
     );
     console.log('verified.');
 

package/example/src/chevre/migrateEventSellerMakesOfferAvailableAt.ts

@@ -0,0 +1,98 @@
+// 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 excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            'project.id': { $ne: excludedProject.id },
+            startDate: {
+                $gte: moment()
+                    .add(-1, 'days')
+                    .toDate()
+            },
+            typeOf: { $eq: chevre.factory.eventType.ScreeningEvent }
+            // _id: { $eq: 'blyk9q24f' }
+        },
+        {
+            _id: 1,
+            offers: 1,
+            startDate: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: Pick<
+            chevre.factory.event.screeningEvent.IEvent,
+            'id' | 'offers' | 'startDate' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', event.project.id, event.typeOf, event.id, event.startDate, i);
+        const originMakesOffer = event.offers.seller.makesOffer;
+        const alreadyMigrated = Array.isArray(originMakesOffer)
+            && originMakesOffer.every(
+                ({ availableAtOrFrom }) => !Array.isArray(availableAtOrFrom) && typeof availableAtOrFrom?.id === 'string'
+            );
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', event.project.id, event.typeOf, event.id, event.startDate, i);
+        } else {
+            const newMakesOffer: chevre.factory.event.screeningEvent.ISellerMakesOffer[] = originMakesOffer.map((offer) => {
+                let newAvailableAtOrFrom: { id: string } | undefined;
+                if (Array.isArray(offer.availableAtOrFrom)) {
+                    newAvailableAtOrFrom = offer.availableAtOrFrom.at(0);
+                }
+                if (newAvailableAtOrFrom === undefined) {
+                    throw new Error('newAvailableAtOrFrom undefined');
+                }
+
+                return {
+                    ...offer,
+                    availableAtOrFrom: newAvailableAtOrFrom
+                };
+            });
+            console.log(
+                'updating project...',
+                event.project.id, event.typeOf, event.id, event.startDate, i);
+            await eventRepo.updatePartiallyById({
+                project: { id: event.project.id },
+                id: event.id,
+                attributes: {
+                    typeOf: event.typeOf,
+                    ...{
+                        'offers.seller.makesOffer': newMakesOffer
+                    }
+                }
+            });
+            updateCount += 1;
+            console.log(
+                'updated.',
+                event.project.id, event.typeOf, event.id, event.startDate, i);
+        }
+    });
+
+    console.log(i, 'events checked');
+    console.log(updateCount, 'events updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/projectFields.ts

@@ -8,15 +8,15 @@ const project = { id: String(process.env.PROJECT_ID) };
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const repo = await chevre.repository.Product.createInstance(mongoose.connection);
+    const repo = await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection);
 
     const docs = await repo.projectFields(
         {
-            limit: 1,
+            limit: 10,
             page: 1,
             project: { id: { $eq: project.id } }
         },
-        ['hasOfferCatalog.id']
+        ['relatedOffer']
     );
     // tslint:disable-next-line:no-null-keyword
     console.dir(docs, { depth: null });

package/example/src/chevre/searchEventHasOfferCatalog.ts

@@ -0,0 +1,43 @@
+// tslint:disable:no-console
+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);
+
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
+
+    const event = (await eventRepo.projectEventFields(
+        {
+            id: { $eq: 'bm0f0cadm' },
+            typeOf: chevre.factory.eventType.ScreeningEvent,
+            project: { id: { $eq: project.id } }
+        },
+        ['offers.itemOffered.id']
+    )).shift();
+    console.log('event:', event);
+    if (event === undefined) {
+        throw new Error('event not found');
+    }
+    const productId = event.offers.itemOffered.id;
+    if (typeof productId !== 'string') {
+        throw new Error('offers.itemOffered.id undefined');
+    }
+    const catalogs = await productRepo.aggregateHasOfferCatalog(
+        {
+            id: productId,
+            limit: 10,
+            page: 1
+        }
+    );
+    console.log(catalogs);
+    console.log(catalogs.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchOfferCatalogItemListElement.ts

@@ -0,0 +1,26 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const PROJECT_ID = process.env.PROJECT_ID;
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+
+    const result = await offerCatalogRepo.searchItemListElement({
+        id: { $in: ['blpj322ni', 'blpc770py', 'xxxx', 'blos0d5gu'] },
+        itemListElement: { id: { $in: ['xxx', '65669285c7b871dba60ed72e', '65669285c7b871dba60ed742', '1008'] } }
+    });
+    console.log(result);
+    console.log(result.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchOfferCatalogItems.ts

@@ -18,10 +18,11 @@ async function main() {
 
     const result = await (await chevre.service.offer.createService()).event.searchOfferCatalogItems({
         event: {
-            id: 'cllkq475u'
+            id: 'bm0f0cadm'
         },
         limit: 10,
-        page: 1
+        page: 1,
+        options: { includedInDataCatalog: { id: 'blpj322ni' } }
     })({
         event: eventRepo,
         offerCatalog: offerCatalogRepo,

package/example/src/chevre/searchProjects.ts

@@ -12,8 +12,7 @@ async function main() {
 
     const project = await projectRepo.findById({
         id: PROJECT_ID,
-        inclusion: [],
-        exclusion: ['settings', 'hasMerchantReturnPolicy']
+        inclusion: ['settings']
     });
     console.log('project:', project);
 
@@ -23,8 +22,7 @@ async function main() {
             page: 1,
             id: { $eq: project.id }
         },
-        ['typeOf'],
-        []
+        ['typeOf']
     );
     console.log(projects);
     console.log(projects.length, 'projects found');

package/example/src/chevre/unsetUnnecessaryFields.ts

@@ -6,30 +6,15 @@ import { chevre } from '../../../lib/index';
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const creativeWorkRepo = await chevre.repository.CreativeWork.createInstance(mongoose.connection);
-    const offerItemConditionRepo = await chevre.repository.OfferItemCondition.createInstance(mongoose.connection);
+    const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
 
     let updateResult: any;
-    updateResult = await creativeWorkRepo.unsetUnnecessaryFields({
+    updateResult = await productRepo.unsetUnnecessaryFields({
         filter: {
-            _id: { $exists: true }
+            'hasOfferCatalog.id': { $exists: true }
         },
-        $unset: <any>{
-            createdAt: 1,
-            updatedAt: 1,
-            __v: 1
-        }
-    });
-    console.log(updateResult);
-
-    updateResult = await offerItemConditionRepo.unsetUnnecessaryFields({
-        filter: {
-            _id: { $exists: true }
-        },
-        $unset: <any>{
-            createdAt: 1,
-            updatedAt: 1,
-            __v: 1
+        $unset: {
+            'hasOfferCatalog.id': 1
         }
     });
     console.log(updateResult);

package/example/src/chevre/upsertManyEventsByAdditionalProperty.ts

@@ -45,8 +45,8 @@ async function main() {
                 },
                 offers: {
                     typeOf: chevre.factory.offerType.Offer,
-                    availabilityEnds: new Date('2024-09-15T11:45:00.000Z'),
-                    availabilityStarts: new Date('2024-09-01T15:00:00.000Z'),
+                    // availabilityEnds: new Date('2024-09-15T11:45:00.000Z'),
+                    // availabilityStarts: new Date('2024-09-01T15:00:00.000Z'),
                     eligibleQuantity: {
                         typeOf: 'QuantitativeValue',
                         unitCode: chevre.factory.unitCode.C62,
@@ -97,8 +97,8 @@ async function main() {
                             typeOf: 'CategoryCode'
                         }
                     },
-                    validFrom: new Date('2024-09-01T15:00:00.000Z'),
-                    validThrough: new Date('2024-09-15T11:45:00.000Z'),
+                    // validFrom: new Date('2024-09-01T15:00:00.000Z'),
+                    // validThrough: new Date('2024-09-15T11:45:00.000Z'),
                     seller: {
                         typeOf: chevre.factory.organizationType.Corporation,
                         id: '59d20831e53ebc2b4e774466',

package/example/src/chevre/upsertProductsByProductId.ts

@@ -64,7 +64,7 @@ async function main() {
                         ja: 'xxx'
                     },
                     hasOfferCatalog: {
-                        id: 'blpc770py',
+                        // id: 'blpc770py',
                         typeOf: 'OfferCatalog',
                         itemListElement: [{ id: 'blpc770py' }]
                     },

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

@@ -70,7 +70,8 @@ interface IAggregateEvent {
     statuses: IStatus[];
 }
 export import IMinimizedIndividualEvent = EventFactory.IMinimizedIndividualEvent;
-type IKeyOfProjection<T extends AvailableEventType> = Exclude<keyof factory.event.IEvent<T>, 'id'> | 'aggregateEntranceGate' | 'aggregateOffer' | 'superEvent.location.id' | 'offers.itemOffered';
+type IKeyOfProjection<T extends AvailableEventType> = Exclude<keyof factory.event.IEvent<T>, 'id'> | 'aggregateEntranceGate' | 'aggregateOffer' | 'superEvent.location.id' | 'offers.itemOffered' | 'offers.itemOffered.id';
+type IKeyOfProjection4publicFields<T extends AvailableEventType> = Exclude<keyof factory.event.IEvent<T>, 'id' | 'offers'>;
 /**
  * minimizedEvent検索時のprojection候補
  * add(2024-07-18~)
@@ -161,6 +162,19 @@ export declare class EventRepo {
      * イベントを検索する(inclusion projection)
      */
     projectEventFields<T extends AvailableEventType>(params: ISearchConditions<T>, inclusion: IKeyOfProjection<T>[]): Promise<Omit<factory.event.IEvent<T>, 'aggregateEntranceGate' | 'aggregateOffer'>[]>;
+    /**
+     * apiで公開属性を検索する(2024-10-13~)
+     */
+    aggregatePublicFields<T extends AvailableEventType>(params: ISearchConditions<T>, inclusion: IKeyOfProjection4publicFields<T>[], options: {
+        /**
+         * offersを属性をprojectするかどうか
+         */
+        includeOffers: boolean;
+        /**
+         * offers.seller.makesOfferをavailableAtOrFromでfilterする
+         */
+        sellerMakesOfferAvailableAtIn?: string[];
+    }): Promise<Omit<factory.event.IEvent<T>, 'aggregateEntranceGate' | 'aggregateOffer'>[]>;
     /**
      * IDのみで検索する
      * projectionなし