@chevre/domain 22.11.0-alpha.9 → 22.12.0-alpha.0

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

@@ -7,6 +7,9 @@ import { chevre } from '../../../../lib/index';
 
 const PROJECT_ID = String(process.env.PROJECT_ID);
 const AGGREGATE_PERIOD_IN_DAYS = 365;
+const AGGREGATE_ORDER_CLIENT_IDS = (typeof process.env.AGGREGATE_ORDER_CLIENT_IDS === 'string')
+    ? process.env.AGGREGATE_ORDER_CLIENT_IDS.split(' ')
+    : [];
 
 function createAggregation(params: {
     order: Pick<chevre.factory.order.IOrder, 'customer' | 'orderDate' | 'orderNumber' | 'project'>;
@@ -18,17 +21,24 @@ function createAggregation(params: {
     }) => {
         const { order, orderDateGte, orderDateLte } = params;
 
-        return repos.order.aggregateOrderOfCustomer({
-            project: { id: { $eq: PROJECT_ID } },
-            orderDate: { $gte: orderDateGte, $lte: orderDateLte },
-            customer: { email: { $eq: String(order.customer.email) } }
-        });
+        if (PROJECT_ID === '*') {
+            return repos.order.aggregateOrderOfCustomerGlobally({
+                orderDate: { $gte: orderDateGte, $lte: orderDateLte },
+                customer: { email: { $eq: String(order.customer.email) } }
+            });
+        } else {
+            return repos.order.aggregateOrderOfCustomerByProject({
+                project: { id: { $eq: PROJECT_ID } },
+                orderDate: { $gte: orderDateGte, $lte: orderDateLte },
+                customer: { email: { $eq: String(order.customer.email) } }
+            });
+        }
     };
 }
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false, appName: 'sample' });
 
     const aggregateOrderRepo = await chevre.repository.AggregateOrder.createInstance(mongoose.connection);
     const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
@@ -41,12 +51,16 @@ async function main() {
 
     const cursor = orderRepo.getCursor(
         {
-            'project.id': { $eq: PROJECT_ID },
+            ...(PROJECT_ID !== '*') ? { 'project.id': { $eq: PROJECT_ID } } : undefined,
             orderDate: {
                 $gte: orderDateGte,
                 $lte: orderDateLte
             },
-            typeOf: { $eq: chevre.factory.order.OrderType.Order }
+            typeOf: { $eq: chevre.factory.order.OrderType.Order },
+            'customer.id': { // exclude pos,tvm
+                $exists: true,
+                $in: AGGREGATE_ORDER_CLIENT_IDS
+            }
         },
         {
             customer: 1,
@@ -79,11 +93,11 @@ async function main() {
         if (typeof email === 'string') {
             console.log(
                 'aggregating...',
-                order.project.id, order.orderNumber, order.orderDate, i);
+                order.project.id, order.orderNumber, email, order.orderDate, i);
             const aggregateResult = await createAggregation({ order, orderDateGte, orderDateLte })({ order: orderRepo });
             await aggregateOrderRepo.save(
                 {
-                    project: order.project,
+                    project: { id: PROJECT_ID, typeOf: chevre.factory.organizationType.Project },
                     identifier: email,
                     typeOf: chevre.factory.personType.Person
                 },
@@ -92,7 +106,7 @@ async function main() {
             updateCount += 1;
             console.log(
                 'aggregated.',
-                order.project.id, order.orderNumber, order.orderDate, i);
+                order.project.id, order.orderNumber, email, order.orderDate, i);
 
             const sumGraceTime = (typeof aggregateResult.aggregation.sumGraceTime === 'number')
                 ? aggregateResult.aggregation.sumGraceTime

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

@@ -0,0 +1,34 @@
+// tslint:disable:no-console
+// import * as fs from 'fs';
+import * as moment from 'moment-timezone';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const AGGREGATE_PERIOD_IN_DAYS = 365;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false, appName: 'sample' });
+
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+
+    const orderDateLte: Date = moment()
+        .toDate();
+    const orderDateGte: Date = moment(orderDateLte)
+        .add(-AGGREGATE_PERIOD_IN_DAYS, 'days')
+        .toDate();
+
+    console.log('aggregating...');
+    const result = await orderRepo.aggregateOrderOfCustomerGlobally({
+        orderDate: { $gte: orderDateGte, $lte: orderDateLte },
+        customer: { email: { $eq: 'ilovegadd@gmail.com' } }
+    });
+    console.log(result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

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

@@ -0,0 +1,41 @@
+// 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 taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+
+    const aggregateDate = new Date();
+    const runsFrom: Date = moment(aggregateDate)
+        .utc()
+        // .tz('Asia/Tokyo')
+        .add(-1, 'days')
+        .startOf('days')
+        .toDate();
+    const runsThrough: Date = moment(aggregateDate)
+        .utc()
+        // .tz('Asia/Tokyo')
+        .add(-1, 'days')
+        .endOf('days')
+        .toDate();
+
+    const result = await taskRepo.aggregateTask({
+        project: {
+            id: { $ne: 'sskts-development' }
+        },
+        runsFrom,
+        runsThrough
+    });
+    console.dir(result, { depth: null });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/checkCustomerAttributesLength.ts

@@ -0,0 +1,109 @@
+// 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 MAX_LENGTH = 50;
+const CHECK_DAYS = 60;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+
+    const cursor = orderRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.order.OrderType.Order },
+            orderDate: {
+                $gte: moment()
+                    .add(-CHECK_DAYS, 'days')
+                    .toDate()
+            }
+            // _id: { $eq: '67de46777ec0510590b68922' }
+        },
+        {
+            customer: 1,
+            project: 1,
+            orderDate: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let exceededCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const order: Pick<
+            chevre.factory.order.IOrder,
+            'customer' | 'project' | 'orderDate'
+        > = doc.toObject();
+
+        const attributesNames: (keyof chevre.factory.order.ICustomer)[] = [
+            'address',
+            'age',
+            'email',
+            'givenName',
+            'familyName',
+            'gender',
+            'name',
+            'url',
+            'telephone'
+        ];
+
+        const maxLengthNotExceeded = attributesNames.every((attributesName) => {
+            const attributesValue = order.customer[attributesName];
+            if (attributesValue === undefined) {
+                return true;
+            }
+            if (typeof attributesValue !== 'string') {
+                throw new Error(`${attributesName}: ${attributesValue} must be string. ${order.project.id}`);
+            }
+
+            return attributesValue.length <= MAX_LENGTH;
+        });
+
+        if (maxLengthNotExceeded) {
+            // no op
+            process.stdout.write('-');
+        } else {
+            exceededCount += 1;
+            console.log('\n');
+            console.log('maxLengthExceeded.', order.project.id, order.customer, order.orderDate, i);
+        }
+    });
+
+    console.log('\n');
+    console.log(i, 'docs checked');
+    console.log(exceededCount, 'docs exceeded');
+
+    // let result: any;
+    // const attributesNames = [
+    //     // 'customer.address',
+    //     // 'customer.age',
+    //     'customer.email',
+    //     'customer.givenName',
+    //     'customer.familyName'
+    //     // 'customer.gender',
+    //     // 'customer.name',
+    //     // 'customer.url',
+    // ];
+    // for (const attributesName of attributesNames) {
+    //     console.log('how is', attributesName, '?');
+    //     result = await orderRepo.checkCustomerAttributesLength({
+    //         attributesName,
+    //         length: MAX_LENGTH
+    //     });
+    //     // tslint:disable-next-line:no-null-keyword
+    //     console.dir(result, { depth: null });
+    //     console.log('how is', attributesName, '?', result.length, 'results found');
+    // }
+}
+
+main()
+    .then(() => {
+        console.log('\n');
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/notifyAbortedTasksByEmail.ts

@@ -30,7 +30,7 @@ async function main() {
         ]
     });
 
-    const result = await (await chevre.service.task.createService()).notifyAbortedTasksByEmail({
+    const result = await (await chevre.service.notification.createService()).notifyAbortedTasksByEmail({
         dateAbortedGte: moment()
             // tslint:disable-next-line:no-magic-numbers
             .add(-10, 'days')

package/example/src/chevre/reIndex.ts

@@ -11,7 +11,7 @@ mongoose.Model.on('index', (...args) => {
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    await chevre.repository.Member.createInstance(mongoose.connection);
+    await chevre.repository.AggregateOrder.createInstance(mongoose.connection);
     console.log('success!');
 }
 

package/example/src/chevre/roles/addEventOfferPermissionIfNotExists.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, { autoIndex: false });
+
+    const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    const roleNames = [
+        chevre.factory.role.organizationRole.RoleName.InventoryManager,
+        chevre.factory.role.organizationRole.RoleName.SellersOwner,
+        chevre.factory.role.organizationRole.RoleName.SellersInventoryManager
+    ];
+    for (const roleName of roleNames) {
+        const result = await roleRepo.addPermissionIfNotExists({
+            roleName: { $eq: roleName },
+            permission: 'eventOffers.*'
+        });
+        console.log(result, roleName);
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/roles/{addAdminInventoryManagerRole.ts → addProjectCreatorRole.ts}

@@ -9,13 +9,11 @@ async function main() {
     const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
 
     const roleNames = [
-        chevre.factory.role.organizationRole.RoleName.AdminInventoryManager
+        'projectCreator'
     ];
     const permissions = [
-        'iam.members.me.read',
-        'admin.creativeWorks.*',
-        'admin.sellers.eventSeries.*',
-        'admin.sellers.read'
+        'aggregations.read',
+        'projects.create'
     ];
     for (const roleName of roleNames) {
         const existingRoles = await roleRepo.projectFields(
@@ -26,8 +24,8 @@ async function main() {
         );
         if (existingRoles.length === 0) {
             const createResult = await roleRepo.create({
-                roleName: roleName,
-                member: { typeOf: chevre.factory.creativeWorkType.SoftwareApplication },
+                roleName: <any>roleName,
+                member: { typeOf: chevre.factory.personType.Person },
                 memberOf: { typeOf: chevre.factory.organizationType.Project },
                 permissions: []
             });
@@ -35,7 +33,7 @@ async function main() {
         }
         for (const permission of permissions) {
             const result = await roleRepo.addPermissionIfNotExists({
-                roleName: { $eq: roleName },
+                roleName: { $eq: <any>roleName },
                 permission
             });
             console.log('permission added.', result, roleName);

package/example/src/chevre/roles/assignGlobalRoles.ts

@@ -0,0 +1,72 @@
+// tslint:disable:no-console
+import type { CognitoIdentityProvider as CognitoIdentityServiceProvider } from '@aws-sdk/client-cognito-identity-provider';
+import * as mongoose from 'mongoose';
+
+import { IGlobalMember } from '../../../../lib/chevre/repo/mongoose/schemas/member/global';
+import { chevre } from '../../../../lib/index';
+
+const { PROJECT_CREATOR_SUB } = process.env;
+
+let cognitoIdentityServiceProvider: CognitoIdentityServiceProvider | undefined;
+
+async function main() {
+    if (typeof PROJECT_CREATOR_SUB !== 'string') {
+        throw new Error('PROJECT_CREATOR_SUB setting required');
+    }
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const memberRepo = await chevre.repository.Member.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');
+    }
+
+    let globalMember: IGlobalMember;
+
+    if (cognitoIdentityServiceProvider === undefined) {
+        const { CognitoIdentityProvider } = await import('@aws-sdk/client-cognito-identity-provider');
+        const { fromEnv } = await import('@aws-sdk/credential-providers');
+        cognitoIdentityServiceProvider = new CognitoIdentityProvider({
+            apiVersion: 'latest',
+            region: 'ap-northeast-1',
+            credentials: fromEnv()
+        });
+    }
+    const personRepo = await chevre.repository.Person.createInstance({
+        userPoolId: setting.userPoolIdNew,
+        cognitoIdentityServiceProvider
+    });
+    const profile = await personRepo.findById({ userId: PROJECT_CREATOR_SUB });
+    const memberName = (typeof profile.givenName === 'string' && typeof profile.familyName === 'string')
+        ? `${profile.givenName} ${profile.familyName}`
+        : profile.memberOf?.membershipNumber;
+
+    globalMember = {
+        typeOf: chevre.factory.role.RoleType.OrganizationRole,
+        member: {
+            typeOf: chevre.factory.personType.Person,
+            id: profile.id,
+            name: memberName,
+            username: profile.memberOf?.membershipNumber,
+            hasRole: [{
+                typeOf: chevre.factory.role.RoleType.OrganizationRole,
+                roleName: <any>'projectCreator'
+            }]
+        }
+    };
+    console.log(profile, globalMember);
+
+    const existingGlobalMemberRoles = await memberRepo.findGlobalRoleNamesByMember({ member: { id: { $eq: globalMember.member.id } } });
+    console.log('existingGlobalMemberRoles:', existingGlobalMemberRoles);
+
+    // 権限作成
+    await memberRepo.createGlobalMember([globalMember]);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/roles/findPermissions.ts

@@ -0,0 +1,84 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const formatter = new Intl.NumberFormat('ja-JP');
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+const memberId = 'b3640a78-babd-4da4-81d3-7dcf4881a4a5';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const memberRepo = await chevre.repository.Member.createInstance(mongoose.connection);
+    const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+    let result: any;
+
+    startTime = process.hrtime();
+    result = await (await chevre.service.iam.createService()).findProjectPermissionsByMember({
+        project: { id: PROJECT_ID },
+        member: {
+            id: memberId,
+            memberOf: {
+                id: PROJECT_ID,
+                typeOf: chevre.factory.organizationType.Project
+            }
+        }
+    })({
+        member: memberRepo,
+        role: roleRepo
+    });
+    diff = process.hrtime(startTime);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    console.log(result.roleNames.length, 'roleNames found');
+    console.log(result.permissions.length, 'permissions found');
+
+    startTime = process.hrtime();
+    result = await (await chevre.service.iam.createService()).findProjectPermissionsByMember({
+        project: { id: PROJECT_ID },
+        member: {
+            id: memberId,
+            memberOf: {
+                id: PROJECT_ID,
+                typeOf: chevre.factory.organizationType.Project
+            }
+        }
+    })({
+        member: memberRepo,
+        role: roleRepo
+    });
+    diff = process.hrtime(startTime);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    console.log(result.roleNames.length, 'roleNames found');
+    console.log(result.permissions.length, 'permissions found');
+
+    startTime = process.hrtime();
+    result = await (await chevre.service.iam.createService()).findProjectPermissionsByMember({
+        project: { id: PROJECT_ID },
+        member: {
+            id: memberId,
+            memberOf: {
+                id: PROJECT_ID,
+                typeOf: chevre.factory.organizationType.Project
+            }
+        }
+    })({
+        member: memberRepo,
+        role: roleRepo
+    });
+    diff = process.hrtime(startTime);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    console.log(result.roleNames.length, 'roleNames found');
+    console.log(result.permissions.length, 'permissions found');
+
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/roles/findRoleNames.ts

@@ -0,0 +1,117 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const formatter = new Intl.NumberFormat('ja-JP');
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+const memberId = 'xxx';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const memberRepo = await chevre.repository.Member.createInstance(mongoose.connection);
+
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+    let result: any;
+
+    // startTime = process.hrtime();
+    // result = await memberRepo.aggregateRoleNames({
+    //     project: { id: { $eq: PROJECT_ID } },
+    //     member: {
+    //         id: { $eq: memberId },
+    //         memberOf: {
+    //             id: { $eq: PROJECT_ID },
+    //             typeOf: { $eq: chevre.factory.organizationType.Project }
+    //         }
+    //     }
+    // });
+    // diff = process.hrtime(startTime);
+    // console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    // console.log(result.length, 'result found');
+
+    // startTime = process.hrtime();
+    // result = await memberRepo.aggregateRoleNames({
+    //     project: { id: { $eq: PROJECT_ID } },
+    //     member: {
+    //         id: { $eq: memberId },
+    //         memberOf: {
+    //             id: { $eq: PROJECT_ID },
+    //             typeOf: { $eq: chevre.factory.organizationType.Project }
+    //         }
+    //     }
+    // });
+    // diff = process.hrtime(startTime);
+    // console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    // console.log(result.length, 'result found');
+
+    // startTime = process.hrtime();
+    // result = await memberRepo.aggregateRoleNames({
+    //     project: { id: { $eq: PROJECT_ID } },
+    //     member: {
+    //         id: { $eq: memberId },
+    //         memberOf: {
+    //             id: { $eq: PROJECT_ID },
+    //             typeOf: { $eq: chevre.factory.organizationType.Project }
+    //         }
+    //     }
+    // });
+    // diff = process.hrtime(startTime);
+    // console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    // console.log(result.length, 'result found');
+    // console.log(result);
+
+    startTime = process.hrtime();
+    result = await memberRepo.findRoleNamesByMember({
+        project: { id: { $eq: PROJECT_ID } },
+        member: {
+            id: { $eq: memberId },
+            memberOf: {
+                id: { $eq: PROJECT_ID },
+                typeOf: { $eq: chevre.factory.organizationType.Project }
+            }
+        }
+    });
+    diff = process.hrtime(startTime);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    console.log(result.length, 'result found');
+
+    startTime = process.hrtime();
+    result = await memberRepo.findRoleNamesByMember({
+        project: { id: { $eq: PROJECT_ID } },
+        member: {
+            id: { $eq: memberId },
+            memberOf: {
+                id: { $eq: PROJECT_ID },
+                typeOf: { $eq: chevre.factory.organizationType.Project }
+            }
+        }
+    });
+    diff = process.hrtime(startTime);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    console.log(result.length, 'result found');
+
+    startTime = process.hrtime();
+    result = await memberRepo.findRoleNamesByMember({
+        project: { id: { $eq: PROJECT_ID } },
+        member: {
+            id: { $eq: memberId },
+            memberOf: {
+                id: { $eq: PROJECT_ID },
+                typeOf: { $eq: chevre.factory.organizationType.Project }
+            }
+        }
+    });
+    diff = process.hrtime(startTime);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    console.log(result.length, 'result found');
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/roles/removeConsolePermissionIfExists.ts

@@ -0,0 +1,38 @@
+// 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, { autoIndex: false });
+
+    const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    const permissions = [
+        'assetTransactions.cancelReservation.write',
+        'orders.read',
+        'orders.update',
+        'reservations.attended',
+        'reservations.read'
+    ];
+    for (const permission of permissions) {
+        const roles = await roleRepo.projectFields(
+            {
+                permissions: { $eq: permission }
+            },
+            ['roleName']
+        );
+        console.log(roles, permission);
+        for (const { roleName } of roles) {
+            const result = await roleRepo.removePermissionIfExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission removed.', permission, result, roleName);
+        }
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/searchEventSeats.ts

@@ -17,7 +17,7 @@ async function main() {
     });
     await client.connect();
 
-    const itemAvailabilityRepo = await chevre.repository.StockHolder.createInstance(client, mongoose.connection);
+    const itemAvailabilityRepo = await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection });
 
     const result = await itemAvailabilityRepo.searchHolders({
         project,