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

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/assetTransaction/processReserve.ts

@@ -19,7 +19,6 @@ async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     const transactionNumberRepo = await chevre.repository.TransactionNumber.createInstance({
-        redisClient,
         connection: mongoose.connection
     });
     const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);

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.Task.createInstance(mongoose.connection);
     console.log('success!');
 }
 

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

@@ -0,0 +1,132 @@
+// 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 roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    let roleNames = [
+        chevre.factory.role.organizationRole.RoleName.InventoryManager
+    ];
+    let permissions = [
+        'admin.creativeWorks.*',
+        'admin.sellers.eventSeries.*',
+        'admin.customers.read',
+        'admin.offers.read',
+        'admin.offers.create',
+        'admin.offerCatalogs.create',
+        'admin.offerCatalogItems.read',
+        'admin.offerCatalogItems.create',
+        'admin.products.create',
+        'admin.sellers.events.create',
+        'admin.sellers.events.update'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+
+    roleNames = [
+        chevre.factory.role.organizationRole.RoleName.SellersOwner
+    ];
+    permissions = [
+        'admin.sellers.eventSeries.*',
+        'admin.customers.read',
+        'admin.offers.read',
+        'admin.offerCatalogItems.read',
+        'admin.sellers.events.create',
+        'admin.sellers.events.update',
+        'admin.sellers.orders.read',
+        'admin.sellers.reservations.read',
+        'admin.sellers.reservations.useActions.read',
+        'admin.sellers.assetTransactions.cancelReservation.write'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+
+    roleNames = [
+        chevre.factory.role.organizationRole.RoleName.SellersInventoryManager
+    ];
+    permissions = [
+        'admin.sellers.eventSeries.*',
+        'admin.customers.read',
+        'admin.offers.read',
+        'admin.offerCatalogItems.read',
+        'admin.sellers.events.create',
+        'admin.sellers.events.update'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+
+    roleNames = [
+        chevre.factory.role.organizationRole.RoleName.TicketClerk
+    ];
+    permissions = [
+        'admin.customers.read',
+        'admin.offers.read',
+        'admin.sellers.notes.create',
+        'admin.sellers.notes.read',
+        'admin.sellers.notes.update',
+        'admin.sellers.orders.read',
+        'admin.sellers.orders.update',
+        'admin.sellers.reservations.read',
+        'admin.sellers.reservations.useActions.read',
+        'admin.sellers.reservations.useActions.create',
+        'admin.sellers.assetTransactions.cancelReservation.write'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+
+    roleNames = [
+        chevre.factory.role.organizationRole.RoleName.TicketCollector
+    ];
+    permissions = [
+        'admin.sellers.reservations.read',
+        'admin.sellers.reservations.useActions.read',
+        'admin.sellers.reservations.useActions.create'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+
+}
+
+main()
+    .then()
+    .catch(console.error);

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

@@ -0,0 +1,37 @@
+// 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 roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    const roleNames = [
+        chevre.factory.role.organizationRole.RoleName.Customer,
+        chevre.factory.role.organizationRole.RoleName.InventoryManager,
+        chevre.factory.role.organizationRole.RoleName.POS,
+        chevre.factory.role.organizationRole.RoleName.SellersInventoryManager,
+        chevre.factory.role.organizationRole.RoleName.SellersOwner,
+        chevre.factory.role.organizationRole.RoleName.TicketClerk,
+        chevre.factory.role.organizationRole.RoleName.User
+    ];
+    const permissions = [
+        'db.primary.read'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

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

@@ -8,17 +8,50 @@ async function main() {
 
     const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
 
-    const roleNames = [
+    // 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);
+    // }
+    let roleNames = [
+        chevre.factory.role.organizationRole.RoleName.InventoryManager
+    ];
+    let permissions = [
+        'admin.creativeWorks.*'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+
+    roleNames = [
         chevre.factory.role.organizationRole.RoleName.InventoryManager,
         chevre.factory.role.organizationRole.RoleName.SellersOwner,
         chevre.factory.role.organizationRole.RoleName.SellersInventoryManager
     ];
+    permissions = [
+        'admin.sellers.eventSeries.*'
+    ];
     for (const roleName of roleNames) {
-        const result = await roleRepo.addPermissionIfNotExists({
-            roleName: { $eq: roleName },
-            permission: 'eventOffers.*'
-        });
-        console.log(result, roleName);
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
     }
 }
 

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

@@ -0,0 +1,48 @@
+// 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 = [
+        'projectCreator'
+    ];
+    const permissions = [
+        'aggregations.read',
+        'projects.create'
+    ];
+    for (const roleName of roleNames) {
+        const existingRoles = await roleRepo.projectFields(
+            {
+                roleName: { $eq: roleName }
+            },
+            ['roleName']
+        );
+        if (existingRoles.length === 0) {
+            const createResult = await roleRepo.create({
+                roleName: <any>roleName,
+                member: { typeOf: chevre.factory.personType.Person },
+                memberOf: { typeOf: chevre.factory.organizationType.Project },
+                permissions: []
+            });
+            console.log('role created.', createResult);
+        }
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: <any>roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

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);