@chevre/domain 22.11.0-alpha.4 → 22.11.0-alpha.40

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

@@ -18,11 +18,18 @@ 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) } }
+            });
+        }
     };
 }
 
@@ -41,12 +48,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: []
+            }
         },
         {
             customer: 1,
@@ -79,11 +90,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 +103,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/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/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.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);