@chevre/domain 22.7.0-alpha.8 → 22.7.0

package/example/src/chevre/aggregateOfferCatalogItemList.ts

@@ -0,0 +1,36 @@
+// tslint:disable:no-console
+/**
+ * イベント集計タスク実行
+ */
+import { chevre } from '../../../lib/index';
+
+import * as mongoose from 'mongoose';
+
+export async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+    const offerCatalogItemRepo = await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection);
+
+    const result = await offerCatalogRepo.aggregateItemList({ itemListElement: { typeOf: { $eq: chevre.factory.offerType.Offer } } });
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+
+    const result2 = await offerCatalogRepo.aggregateItemList({ itemListElement: { typeOf: { $eq: 'OfferCatalog' } } });
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result2, { depth: null });
+
+    const result3 = await offerCatalogItemRepo.aggregateItemList({ itemListElement: { typeOf: { $eq: chevre.factory.offerType.Offer } } });
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result3, { depth: null });
+
+    const result4 = await offerCatalogItemRepo.aggregateItemList({ itemListElement: { typeOf: { $eq: 'OfferCatalog' } } });
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result4, { depth: null });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

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

@@ -39,7 +39,7 @@ async function main() {
             },
             sort: { 'reservationFor.startDate': 1 }
         },
-        ['aggregateEntranceGate', 'aggregateOffer']
+        ['aggregateOffer']
     );
     console.log('aggregateReservations:', aggregateReservations);
     console.log('aggregateReservations:', aggregateReservations.map(({ id }) => id));

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

@@ -21,7 +21,7 @@ async function main() {
                 typeOf: chevre.factory.eventType.ScreeningEvent
             }
         },
-        ['aggregateEntranceGate', 'aggregateOffer']
+        ['aggregateOffer']
     );
     console.log('aggregateReservations:', aggregateReservations);
 }

package/example/src/chevre/deleteDiscontinuedPeople.ts

@@ -0,0 +1,153 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+import { call as deletePerson } from '../../../lib/chevre/service/task/deletePerson';
+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 settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
+    const setting = await settingRepo.findOne({ project: { id: { $eq: '*' } } }, ['userPoolIdNew']);
+    if (typeof setting?.userPoolIdNew !== 'string') {
+        throw new chevre.factory.errors.NotFound('setting.userPoolIdNew');
+    }
+
+    const DISCONTINUE_PEOPLE_PROJECT = process.env.USE_DISCONTINUE_PEOPLE_PROJECT;
+    if (typeof DISCONTINUE_PEOPLE_PROJECT === 'string' && DISCONTINUE_PEOPLE_PROJECT.length > 0) {
+        const ownershipInfoRepo = await chevre.repository.OwnershipInfo.createInstance(mongoose.connection);
+        // const deletingOwnershipInfos = (await ownershipInfoRepo.projectFields({
+        //     limit: NUM_TASKS,
+        //     page: 1,
+        //     sort: { ownedFrom: chevre.factory.sortType.Ascending },
+        //     project: { id: { $eq: DISCONTINUE_PEOPLE_PROJECT } },
+        //     ownedBy: {
+        //         typeOf: { $eq: chevre.factory.personType.Person }
+        //     },
+        //     typeOfGood: {
+        //         issuedThrough: {
+        //             typeOf: {
+        //                 $eq: chevre.factory.product.ProductType.EventService
+        //             }
+        //         }
+        //     }
+        // }));
+        // console.log(deletingOwnershipInfos.length, 'deletingOwnershipInfos found');
+
+        const cursor = ownershipInfoRepo.getCursor(
+            {
+                // sort: { ownedFrom: chevre.factory.sortType.Ascending },
+                'project.id': { $eq: DISCONTINUE_PEOPLE_PROJECT },
+                'ownedBy.typeOf': {
+                    $exists: true,
+                    $eq: chevre.factory.personType.Person
+                },
+                'typeOfGood.issuedThrough.typeOf': {
+                    $exists: true,
+                    $eq: chevre.factory.product.ProductType.EventService
+                },
+                ownedFrom: {
+                    $lte: moment('2024-02-25T00:00:00Z')
+                        .toDate()
+                }
+            },
+            {
+                _id: 1,
+                ownedBy: 1,
+                ownedFrom: 1,
+                project: 1
+            }
+        );
+        console.log('docs found');
+
+        const runsAt: Date = new Date();
+        const userPoolId: string = setting.userPoolIdNew;
+
+        let i = 0;
+        // tslint:disable-next-line:max-func-body-length
+        await cursor.eachAsync(async (doc) => {
+            i += 1;
+
+            const deletingOwnershipInfo: Pick<
+                chevre.factory.ownershipInfo.IOwnershipInfo<any>,
+                'id' | 'ownedBy' | 'ownedFrom' | 'project'
+            > = doc.toObject();
+            const personId: string = (Array.isArray(deletingOwnershipInfo.ownedBy))
+                ? deletingOwnershipInfo.ownedBy[0]?.id
+                : deletingOwnershipInfo.ownedBy.id;
+            console.log(deletingOwnershipInfo);
+
+            console.log(
+                'deleting person...',
+                personId, deletingOwnershipInfo.project.id, deletingOwnershipInfo.id, deletingOwnershipInfo.ownedFrom, i
+            );
+            try {
+                await deletePerson({
+                    id: '',
+                    project: { typeOf: chevre.factory.organizationType.Project, id: DISCONTINUE_PEOPLE_PROJECT },
+                    name: chevre.factory.taskName.DeletePerson,
+                    status: chevre.factory.taskStatus.Ready,
+                    runsAt,
+                    remainingNumberOfTries: 10,
+                    numberOfTried: 0,
+                    data: {
+                        id: personId,
+                        agent: {
+                            id: DISCONTINUE_PEOPLE_PROJECT,
+                            typeOf: chevre.factory.organizationType.Project,
+                            name: 'example'
+                        },
+                        physically: true,
+                        userPoolId,
+                        migrate: false,
+                        useUsernameAsGMOMemberId: true,
+                        paymentMethodType4creditCard: 'CreditCard',
+                        executeBackground: true
+                    }
+                })(
+                    {
+                        connection: mongoose.connection,
+                        settings: new chevre.settings.Settings({
+                            abortedTasksWithoutReport: [],
+                            numTryConfirmReserveTransaction: 10,
+                            deliverOrderLimit: 1,
+                            coa: {
+                                timeout: 20000
+                            },
+                            gmo: {
+                                timeout: 5000,
+                                timeoutBackground: 5000,
+                                useFetch: true
+                            },
+                            movieticketReserve: {
+                                timeout: 1000,
+                                timeoutCheck: 1000,
+                                minIntervalBetweenPayAndRefund: 1000,
+                                credentialsExpireInSeconds: 1000
+                            },
+                            useExperimentalFeature: false
+                        }),
+                        credentials: <any>{}
+                    },
+                    {
+                        executeById: false,
+                        executeByName: true
+                    }
+                );
+                console.log(
+                    'deleted',
+                    personId, deletingOwnershipInfo.project.id, deletingOwnershipInfo.id, deletingOwnershipInfo.ownedFrom, i
+                );
+            } catch (error) {
+                // no op
+            }
+        });
+
+        console.log(i, 'docs checked');
+    }
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/deleteDiscontinuedPeopleByFetch.ts

@@ -0,0 +1,38 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+
+const TIMEOUT_MS = 5000;
+const INTERVAL_MS = 3000;
+
+let i = 0;
+setInterval(
+    async () => {
+        i += 1;
+        try {
+            const url = String(process.env.DISCONTINUE_PEOPLE_URL);
+            const res = await fetch(
+                url,
+                {
+                    signal: AbortSignal.timeout(TIMEOUT_MS),
+                    method: 'GET'
+                }
+            );
+            const result = await res.text();
+            console.log('result', result, i);
+            console.log('res.status', res.status, i);
+        } catch (err) {
+            console.error(err);
+            if (err.name === 'TimeoutError') {
+                console.error('Timeout: It took more than 5 seconds to get the result!');
+            } else if (err.name === 'AbortError') {
+                console.error('Fetch aborted by user action (browser stop button, closing tab, etc.');
+            } else if (err.name === 'TypeError') {
+                console.error('AbortSignal.timeout() method is not supported');
+            } else {
+                // A network error, or some other problem.
+                console.error(`Error: type: ${err.name}, message: ${err.message}`);
+            }
+        }
+    },
+    INTERVAL_MS
+);

package/example/src/chevre/findJWTSetting.ts

@@ -0,0 +1,19 @@
+// 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 jwtSettingRepo = await chevre.repository.setting.JWT.createInstance(mongoose.connection);
+
+    const result = await jwtSettingRepo.findDefault();
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/person/checkUserPoolClients.ts

@@ -0,0 +1,119 @@
+// tslint:disable:no-console
+import { CognitoIdentityProvider, ListUserPoolClientsCommandOutput, UserPoolClientDescription } from '@aws-sdk/client-cognito-identity-provider';
+import { fromEnv } from '@aws-sdk/credential-providers';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const USERPOOL_PROVIDER_NAME = (typeof process.env.DISCONTINUE_PEOPLE_USERPOOL_PROVIDER_NAME === 'string')
+    ? process.env.DISCONTINUE_PEOPLE_USERPOOL_PROVIDER_NAME
+    : 'SSKTS';
+
+// tslint:disable-next-line:max-func-body-length
+async function main(): Promise<void> {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
+    const setting = await settingRepo.findOne({ project: { id: { $eq: '*' } } }, ['userPoolIdNew']);
+    if (typeof setting?.userPoolIdNew !== 'string') {
+        throw new chevre.factory.errors.NotFound('setting.userPoolIdNew');
+    }
+    const userPoolId: string = setting.userPoolIdNew;
+
+    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: userPoolId,
+        cognitoIdentityServiceProvider
+    });
+
+    const clients: UserPoolClientDescription[] = [];
+    let nextToken: string | undefined = '';
+    let page: number = 0;
+    while (typeof nextToken === 'string') {
+        // tslint:disable-next-line:no-magic-numbers
+        if (page > 1) {
+            break;
+        }
+
+        page += 1;
+        console.log('listUserPoolClients processing...', nextToken, page);
+        const listUserPoolClientsResult =
+            <ListUserPoolClientsCommandOutput>await newPersonRepo.cognitoIdentityServiceProvider.listUserPoolClients(
+                {
+                    MaxResults: 50,
+                    UserPoolId: userPoolId,
+                    ...(typeof nextToken === 'string' && nextToken !== '') ? { NextToken: nextToken } : undefined
+                }
+            );
+        // tslint:disable-next-line:no-null-keyword
+        console.dir(listUserPoolClientsResult.UserPoolClients?.at(0), { depth: null });
+        nextToken = listUserPoolClientsResult.NextToken;
+        if (Array.isArray(listUserPoolClientsResult.UserPoolClients)) {
+            clients.push(...listUserPoolClientsResult.UserPoolClients);
+        }
+    }
+    console.log('listUsersInGroup processed', nextToken, page);
+    console.log(clients.length, 'users found');
+
+    let i = 0;
+    let providerSupportedCount = 0;
+    for (const client of clients) {
+        i += 1;
+
+        const ClientId = client.ClientId;
+
+        // disable link provider
+        const describeUserPoolClientResult = await newPersonRepo.cognitoIdentityServiceProvider.describeUserPoolClient({
+            UserPoolId: userPoolId,
+            ClientId
+        });
+        const codeFlowAllowed = describeUserPoolClientResult.UserPoolClient?.AllowedOAuthFlows?.some(
+            (flow) => flow !== 'client_credentials'
+        );
+        if (codeFlowAllowed) {
+            const providerSupported = describeUserPoolClientResult.UserPoolClient?.SupportedIdentityProviders?.some(
+                (provider) => provider === USERPOOL_PROVIDER_NAME
+            );
+            if (providerSupported) {
+                providerSupportedCount += 1;
+                console.log(
+                    'describeUserPoolClientResult:',
+                    describeUserPoolClientResult.UserPoolClient?.AllowedOAuthFlows,
+                    describeUserPoolClientResult.UserPoolClient?.AllowedOAuthScopes,
+                    describeUserPoolClientResult.UserPoolClient?.SupportedIdentityProviders,
+                    describeUserPoolClientResult.UserPoolClient?.ClientName,
+                    ClientId, i
+                );
+            } else {
+                console.log(
+                    'describeUserPoolClientResult:',
+                    describeUserPoolClientResult.UserPoolClient?.AllowedOAuthFlows,
+                    describeUserPoolClientResult.UserPoolClient?.SupportedIdentityProviders,
+                    describeUserPoolClientResult.UserPoolClient?.ClientName,
+                    ClientId, i
+                );
+            }
+        } else {
+            console.log(
+                'describeUserPoolClientResult:',
+                describeUserPoolClientResult.UserPoolClient?.AllowedOAuthFlows,
+                describeUserPoolClientResult.UserPoolClient?.ClientName,
+                ClientId, i
+            );
+        }
+    }
+
+    console.log(clients.length, 'clients processed');
+    console.log(providerSupportedCount, 'clients supported');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/person/cleanUpCognitoUsers.ts

@@ -1,17 +1,28 @@
 // tslint:disable:no-console
-import { CognitoIdentityProvider, UserType } from '@aws-sdk/client-cognito-identity-provider';
+import { CognitoIdentityProvider, ListUsersInGroupCommandOutput, UserType } from '@aws-sdk/client-cognito-identity-provider';
 import { fromEnv } from '@aws-sdk/credential-providers';
 import * as moment from 'moment';
+import * as mongoose from 'mongoose';
 
 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 USER_GROUP_NAME = String(process.env.USER_GROUP_NAME); // 'ap-northeast-1_XXXXXXXXX_SSKTS',
-const NEW_USERPOOL_PROVIDER_NAME = 'SSKTS';
+const USERPOOL_PROVIDER_NAME = (typeof process.env.DISCONTINUE_PEOPLE_USERPOOL_PROVIDER_NAME === 'string')
+    ? process.env.DISCONTINUE_PEOPLE_USERPOOL_PROVIDER_NAME
+    : 'SSKTS';
 
 // tslint:disable-next-line:max-func-body-length
 async function main(): Promise<void> {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+    const settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
+    const setting = await settingRepo.findOne({ project: { id: { $eq: '*' } } }, ['userPoolIdNew']);
+    if (typeof setting?.userPoolIdNew !== 'string') {
+        throw new chevre.factory.errors.NotFound('setting.userPoolIdNew');
+    }
+    const userPoolId: string = setting.userPoolIdNew;
+    const USER_GROUP_NAME = `${userPoolId}_${USERPOOL_PROVIDER_NAME}`; // 'ap-northeast-1_XXXXXXXXX_SSKTS',
+
     const awsCredentials = fromEnv();
     const cognitoIdentityServiceProvider = new CognitoIdentityProvider({
         apiVersion: 'latest',
@@ -21,7 +32,7 @@ async function main(): Promise<void> {
 
     // create user
     const newPersonRepo = await chevre.repository.Person.createInstance({
-        userPoolId: USERPOOL_ID_NEW,
+        userPoolId: userPoolId,
         cognitoIdentityServiceProvider
     });
 
@@ -29,12 +40,17 @@ async function main(): Promise<void> {
     let nextToken: string | undefined = '';
     let page: number = 0;
     while (typeof nextToken === 'string') {
+        // tslint:disable-next-line:no-magic-numbers
+        // if (page > 1000) {
+        //     break;
+        // }
+
         page += 1;
         console.log('listUsersInGroup processing...', nextToken, page);
-        const listUsersInGroupResult = await newPersonRepo.cognitoIdentityServiceProvider.listUsersInGroup(
+        const listUsersInGroupResult = <ListUsersInGroupCommandOutput>await newPersonRepo.cognitoIdentityServiceProvider.listUsersInGroup(
             {
                 Limit: 50,
-                UserPoolId: USERPOOL_ID_NEW,
+                UserPoolId: userPoolId,
                 GroupName: USER_GROUP_NAME,
                 ...(typeof nextToken === 'string' && nextToken !== '') ? { NextToken: nextToken } : undefined
             }
@@ -49,42 +65,76 @@ async function main(): Promise<void> {
     console.log('listUsersInGroup processed', nextToken, page);
     console.log(users.length, 'users found');
 
-    const oneMonthAgo = moment()
-        .add(-1, 'months');
+    const someMonthsAgo = moment()
+        // tslint:disable-next-line:no-magic-numbers
+        .add(-3, 'months');
+    let i = 0;
     for (const user of users) {
-        const isSSKTSMember = user.Username?.startsWith(NEW_USERPOOL_PROVIDER_NAME, 0);
+        i += 1;
+        const isSSKTSMember = user.Username?.startsWith(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);
+
+        // 注文が存在しなければ削除
+        console.log('searching orders...', user.Username, sub, i);
+        const existingOrders = await orderRepo.projectFields(
+            {
+                limit: 1,
+                page: 1,
+                customer: { ids: [String(sub)] }
+            },
+            { inclusion: ['orderNumber'] }
+        );
+        console.log(existingOrders.length, 'existingOrders found', user.Username, sub, i);
+
+        if (existingOrders.length > 0) {
+            continue;
         } else {
             if (user.UserLastModifiedDate instanceof Date) {
                 if (moment(user.UserLastModifiedDate)
-                    .isBefore(oneMonthAgo)) {
+                    .isBefore(someMonthsAgo)) {
                     console.log('adminDeleteUser prossing...', user.Username, sub);
                     const adminDeleteUserResult = await newPersonRepo.cognitoIdentityServiceProvider.adminDeleteUser({
-                        UserPoolId: USERPOOL_ID_NEW,
+                        UserPoolId: userPoolId,
                         Username: user.Username
                     });
                     console.log('adminDeleteUser processed.', user.Username, sub, adminDeleteUserResult);
                 }
             }
 
+            // if (user.Enabled === true) {
+            //     console.log('disabling...', user.Username, sub);
+            //     // disable link provider
+            //     const adminDisableUserResult = await newPersonRepo.cognitoIdentityServiceProvider.adminDisableUser({
+            //         UserPoolId: userPoolId,
+            //         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: userPoolId,
+            //                 Username: user.Username
+            //             });
+            //             console.log('adminDeleteUser processed.', user.Username, sub, adminDeleteUserResult);
+            //         }
+            //     }
+            // }
         }
     }
+
+    console.log(users.length, 'users processed');
 }
 
 main()
-    .then()
+    .then(() => {
+        console.log('success!');
+    })
     .catch(console.error);