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

package/example/src/chevre/aggregateAllEvents2.ts

@@ -71,7 +71,7 @@ export async function aggregateScreeningEvent() {
                         abortedTasksWithoutReport: [],
                         coa: { timeout: 1000 },
                         gmo: { timeout: 1000, timeoutBackground: 1000, useFetch: true },
-                        movieticketReserve: { timeout: 1000, timeoutCheck: 1000 },
+                        movieticketReserve: { timeout: 1000, timeoutCheck: 1000, minIntervalBetweenPayAndRefund: 0 },
                         numTryConfirmReserveTransaction: 10,
                         useAssetTransactionSyncProcessing: true,
                         useExperimentalFeature: false

package/example/src/chevre/aggregateEventPublicFields.ts

@@ -0,0 +1,47 @@
+// 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,
+            includeSellerMakesOffer: false,
+            // 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,101 @@
+// 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)
+            || (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 {
+            if (Array.isArray(originMakesOffer)) {
+                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/migrateProjectMakesOfferAvailableAt.ts

@@ -0,0 +1,85 @@
+// tslint:disable:no-console
+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 projectRepo = await chevre.repository.Project.createInstance(mongoose.connection);
+
+    const cursor = projectRepo.getCursor(
+        {
+            // _id: { $eq: 'cinerino' }
+        },
+        {
+            _id: 1,
+            makesOffer: 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'
+        > & {
+            makesOffer: chevre.factory.project.IMakesOffer[];
+        } = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', project.id, i);
+        const originMakesOffer = project.makesOffer;
+        const alreadyMigrated = !Array.isArray(originMakesOffer)
+            || (Array.isArray(originMakesOffer)
+                && originMakesOffer.every(
+                    ({ availableAtOrFrom }) => !Array.isArray(availableAtOrFrom) && typeof availableAtOrFrom?.id === 'string'
+                ));
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', project.id, i);
+        } else {
+            if (Array.isArray(originMakesOffer)) {
+                const newMakesOffer: chevre.factory.project.IMakesOffer[] = 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...',
+                    project.id, i, newMakesOffer);
+                await projectRepo.updateMakesOfferById({
+                    id: project.id,
+                    makesOffer: newMakesOffer
+                });
+                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/person/cleanUpCognitoUsers.ts

@@ -0,0 +1,89 @@
+// tslint:disable:no-console
+import { CognitoIdentityProvider, UserType } from '@aws-sdk/client-cognito-identity-provider';
+import { fromEnv } from '@aws-sdk/credential-providers';
+import * as moment from 'moment';
+
+import { chevre } from '../../../../lib/index';
+
+export const USERPOOL_ID_OLD = String(process.env.USERPOOL_ID_OLD);
+export const USERPOOL_ID_NEW = String(process.env.USERPOOL_ID_NEW);
+const NEW_USERPOOL_PROVIDER_NAME = 'SSKTS';
+
+// tslint:disable-next-line:max-func-body-length
+async function main(): Promise<void> {
+    const awsCredentials = fromEnv();
+    const cognitoIdentityServiceProvider = new CognitoIdentityProvider({
+        apiVersion: 'latest',
+        region: 'ap-northeast-1',
+        credentials: awsCredentials
+    });
+
+    // create user
+    const newPersonRepo = await chevre.repository.Person.createInstance({
+        userPoolId: USERPOOL_ID_NEW,
+        cognitoIdentityServiceProvider
+    });
+
+    const users: UserType[] = [];
+    let nextToken: string | undefined = '';
+    let page: number = 0;
+    while (typeof nextToken === 'string') {
+        page += 1;
+        console.log('listUsersInGroup processing...', nextToken, page);
+        const listUsersInGroupResult = await newPersonRepo.cognitoIdentityServiceProvider.listUsersInGroup(
+            {
+                Limit: 50,
+                UserPoolId: USERPOOL_ID_NEW,
+                GroupName: 'ap-northeast-1_UWLLyMcjt_SSKTS',
+                ...(typeof nextToken === 'string' && nextToken !== '') ? { NextToken: nextToken } : undefined
+            }
+        );
+        // tslint:disable-next-line:no-null-keyword
+        console.dir(listUsersInGroupResult.Users?.at(0), { depth: null });
+        nextToken = listUsersInGroupResult.NextToken;
+        if (Array.isArray(listUsersInGroupResult.Users)) {
+            users.push(...listUsersInGroupResult.Users);
+        }
+    }
+    console.log('listUsersInGroup processed', nextToken, page);
+    console.log(users.length, 'users found');
+
+    const oneMonthAgo = moment()
+        .add(-1, 'months');
+    for (const user of users) {
+        const isSSKTSMember = user.Username?.startsWith(NEW_USERPOOL_PROVIDER_NAME, 0);
+        if (!isSSKTSMember) {
+            console.error(user);
+            throw new Error('not ssktsMember');
+        }
+
+        const sub = user.Attributes?.find(({ Name }) => Name === 'sub')?.Value;
+        // if (user.Enabled === true && sub === '46686164-2c18-491a-8594-52c944d895e9') {
+        if (user.Enabled === true) {
+            console.log('disabling...', user.Username, sub);
+            // disable link provider
+            const adminDisableUserResult = await newPersonRepo.cognitoIdentityServiceProvider.adminDisableUser({
+                UserPoolId: USERPOOL_ID_NEW,
+                Username: user.Username
+            });
+            console.log('disabled.', user.Username, sub, adminDisableUserResult);
+        } else {
+            if (user.UserLastModifiedDate instanceof Date) {
+                if (moment(user.UserLastModifiedDate)
+                    .isBefore(oneMonthAgo)) {
+                    console.log('adminDeleteUser prossing...', user.Username, sub);
+                    const adminDeleteUserResult = await newPersonRepo.cognitoIdentityServiceProvider.adminDeleteUser({
+                        UserPoolId: USERPOOL_ID_NEW,
+                        Username: user.Username
+                    });
+                    console.log('adminDeleteUser processed.', user.Username, sub, adminDeleteUserResult);
+                }
+            }
+
+        }
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/searchCategoryCodesByAggregate.ts

@@ -20,8 +20,7 @@ async function main() {
             // paymentAccepted: { paymentMethodType: { $eq: 'Cash' } },
             // hasMerchantReturnPolicy: { applicablePaymentMethod: {} }
         },
-        ['_id'],
-        []
+        ['id']
     );
     console.log('categoryCodes found', categoryCodes[0]);
     console.log(categoryCodes.length, 'categoryCodes found');

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/searchSellersByAggregate.ts

@@ -12,15 +12,14 @@ async function main() {
 
     const sellersByAggregate = await sellerRepo.searchByAggregate(
         {
-            limit: 5,
+            limit: 1,
             page: 1,
-            sort: { branchCode: chevre.factory.sortType.Descending },
-            id: { $eq: '59d20831e53ebc2b4e774466' }
+            sort: { branchCode: chevre.factory.sortType.Descending }
+            // id: { $eq: '59d20831e53ebc2b4e774466' }
             // project: { id: { $eq: project.id } }
             // paymentAccepted: { paymentMethodType: { $eq: 'Cash' } },
             // hasMerchantReturnPolicy: { applicablePaymentMethod: {} }
         },
-        [],
         ['hasMerchantReturnPolicy', 'additionalProperty', 'project', 'name', 'typeOf', 'url', 'telephone']
     );
     console.log('sellers found', sellersByAggregate, sellersByAggregate[0]?.hasMerchantReturnPolicy);
@@ -36,8 +35,7 @@ async function main() {
             // paymentAccepted: { paymentMethodType: { $eq: 'Cash' } },
             // hasMerchantReturnPolicy: { applicablePaymentMethod: {} }
         },
-        [],
-        ['hasMerchantReturnPolicy', 'additionalProperty', 'project', 'name', 'typeOf', 'url', 'telephone']
+        ['id', 'typeOf']
     );
     console.log('sellers found', sellers, sellers[0]?.hasMerchantReturnPolicy);
     console.log(sellers.length, 'sellers found');

package/example/src/chevre/unsetUnnecessaryFields.ts

@@ -1,35 +1,33 @@
 // tslint:disable:no-console
+import * as moment from 'moment';
 import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
 
+const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
 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 eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
 
     let updateResult: any;
-    updateResult = await creativeWorkRepo.unsetUnnecessaryFields({
-        filter: {
-            _id: { $exists: true }
-        },
-        $unset: <any>{
-            createdAt: 1,
-            updatedAt: 1,
-            __v: 1
-        }
-    });
-    console.log(updateResult);
-
-    updateResult = await offerItemConditionRepo.unsetUnnecessaryFields({
+    updateResult = await eventRepo.unsetUnnecessaryFields({
         filter: {
-            _id: { $exists: true }
+            'project.id': { $ne: excludedProject.id },
+            'offers.validFrom': { $exists: true },
+            startDate: {
+                $gte: moment()
+                    .add(-1, 'days')
+                    .toDate()
+            }
+            // _id: { $eq: 'blxd1grz3' }
         },
         $unset: <any>{
-            createdAt: 1,
-            updatedAt: 1,
-            __v: 1
+            'offers.availabilityEnds': 1,
+            'offers.availabilityStarts': 1,
+            'offers.validFrom': 1,
+            'offers.validThrough': 1
         }
     });
     console.log(updateResult);