@chevre/domain 22.11.0-alpha.0 → 22.11.0-alpha.10

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

@@ -0,0 +1,55 @@
+// 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 memberRepo = await chevre.repository.Member.createInstance(mongoose.connection);
+
+    const cursor = memberRepo.getCursor(
+        {
+            'member.memberOf.typeOf': { $eq: 'Project' },
+            'member.typeOf': { $eq: 'Person' }
+        },
+        {
+            _id: 1,
+            member: 1,
+            project: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let sellerMemberCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const member = <Pick<chevre.factory.iam.IMember, 'member' | 'project'>>doc.toObject();
+
+        console.log('checking...', member.project.id, member.member?.id, i);
+        const sellerMembers = await memberRepo.projectFieldsByProjectId(
+            { id: member.project.id },
+            {
+                member: {
+                    id: { $eq: member.member.id },
+                    typeOf: { $eq: 'Person' },
+                    memberOf: { typeOf: { $eq: chevre.factory.organizationType.Corporation } }
+                }
+            },
+            ['member']
+        );
+        console.log(sellerMembers.length, 'sellerMember found', member.project.id, member.member?.id, i);
+        if (sellerMembers.length > 0) {
+            sellerMemberCount += 1;
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(sellerMemberCount, 'members sellerMember');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/orders/searchWithUnwoundAcceptedOffers.ts

@@ -0,0 +1,73 @@
+// tslint:disable:no-console
+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) };
+
+async function main() {
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const acceptedOfferRepo = await chevre.repository.AcceptedOffer.createInstance(mongoose.connection);
+
+    startTime = process.hrtime();
+    const result = await acceptedOfferRepo.searchWithUnwoundAcceptedOffers(
+        {
+            project: { id: { $eq: project.id } },
+            limit: 20,
+            page: 12,
+            sort: {
+                orderDate: chevre.factory.sortType.Descending
+            },
+            orderStatuses: [chevre.factory.orderStatus.OrderDelivered],
+            orderDate: {
+                $gte: new Date('2025-06-07T15:00:00.000Z'),
+                $lte: new Date('2025-07-08T01:42:34.654Z')
+            },
+            acceptedOffers: {
+                itemOffered: {
+                    issuedThrough: { typeOf: { $eq: chevre.factory.product.ProductType.EventService } },
+                    reservationFor: {
+                        inSessionFrom: new Date('2025-07-07T15:00:00.000Z'),
+                        inSessionThrough: new Date('2025-07-08T15:00:00.000Z'),
+                        superEvent: {
+                            location: { branchCodes: ['p006'] }
+                        }
+                    }
+                }
+            },
+            seller: { ids: ['62568df4138ef5000b18c8c0'] },
+            provider: { id: { $eq: '62568df4138ef5000b18c8c0' } }
+            // // req.seller.idを考慮(2023-07-19~)
+            // ...(typeof req.seller?.id === 'string') ? { provider: { id: { $eq: req.seller.id } } } : undefined
+        },
+        {
+            confirmationNumber: 1,
+            customer: 1,
+            dateReturned: 1,
+            orderDate: 1,
+            orderNumber: 1,
+            orderStatus: 1,
+            paymentMethods: 1,
+            price: 1,
+            priceCurrency: 1,
+            project: 1,
+            seller: 1
+        },
+        { useLimitAfterSkip: false }
+        // { useLimitAfterSkip: true }
+    );
+    diff = process.hrtime(startTime);
+    console.log(result.map(({ orderNumber, orderDate }) => `${orderDate} ${orderNumber}`));
+    console.log(result.length);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

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.Issuer.createInstance(mongoose.connection);
+    await chevre.repository.Member.createInstance(mongoose.connection);
     console.log('success!');
 }
 

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

@@ -0,0 +1,50 @@
+// 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.AdminInventoryManager
+    ];
+    const permissions = [
+        'iam.members.me.read',
+        'admin.creativeWorks.*',
+        'admin.sellers.eventSeries.*',
+        'admin.sellers.read'
+    ];
+    for (const roleName of roleNames) {
+        const existingRoles = await roleRepo.projectFields(
+            {
+                roleName: { $eq: roleName }
+            },
+            ['roleName']
+        );
+        if (existingRoles.length === 0) {
+            const createResult = await roleRepo.create({
+                roleName: roleName,
+                member: { typeOf: chevre.factory.creativeWorkType.SoftwareApplication },
+                memberOf: { typeOf: chevre.factory.organizationType.Project },
+                permissions: []
+            });
+            console.log('role created.', createResult);
+        }
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

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/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/roles/removePermissionFromAPIRoles.ts

@@ -0,0 +1,46 @@
+// 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 = [
+        'categoryCodes.read',
+        'creativeWorks.read',
+        'events.read',
+        'places.read',
+        'products.read',
+        'sellers.read'
+    ];
+    for (const permission of permissions) {
+        const roles = await roleRepo.projectFields(
+            {
+                permissions: { $eq: permission },
+                roleName: {
+                    $in: [
+                        chevre.factory.role.organizationRole.RoleName.Customer,
+                        chevre.factory.role.organizationRole.RoleName.POS,
+                        chevre.factory.role.organizationRole.RoleName.EventsViewer
+                    ]
+                }
+            },
+            ['roleName']
+        );
+        console.log('roles found.', 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/roles/removePermissionIfExists.ts

@@ -0,0 +1,39 @@
+// 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 = [
+        'tokens',
+        'authorizations.create',
+        'permits.read',
+        'tasks.read',
+        'transactionNumbers.write',
+        'chevre.admin'
+    ];
+    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/settings/addSettings.ts

@@ -0,0 +1,32 @@
+// 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 settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
+
+    const setting = await settingRepo.findOne({ project: { id: { $eq: '*' } } }, ['onOrderStatusChanged']);
+    const useInformReturnAction = (<any>setting)?.onOrderStatusChanged?.useInformReturnAction === true;
+    if (useInformReturnAction) {
+        console.log('already useInformReturnAction:true');
+    } else {
+        // update
+        await settingRepo.updateByProject4migration(
+            { project: { id: { $eq: '*' } } },
+            {
+                $set: {
+                    'onOrderStatusChanged.useInformReturnAction': true
+                }
+            }
+        );
+        console.log('updated.');
+    }
+
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/stockHolder/checkRedisKeyCount.ts

@@ -38,7 +38,6 @@ function countRedisKeyByProject(params: {
             {
                 'project.id': {
                     $eq: params.project.id
-                    // $in: useMongoAsStockHolderProjects
                 },
                 // startDate: {
                 //     $gte: params.now
@@ -93,30 +92,22 @@ function countRedisKeyByProject(params: {
 async function main() {
     const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
     const projectRepo = await chevre.repository.Project.createInstance(mongoose.connection);
-    const settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
+    // const settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
     const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
         client,
         mongoose.connection
     );
 
-    const setting = await settingRepo.findOne(
-        { project: { id: { $eq: '*' } } },
-        ['useMongoAsStockHolderProjects', 'useMongoAsStockHolder']
-    );
-    const useMongoAsStockHolder = setting?.useMongoAsStockHolder === true;
-    let useMongoAsStockHolderProjects =
-        (Array.isArray(setting?.useMongoAsStockHolderProjects)) ? setting?.useMongoAsStockHolderProjects : [];
-    if (useMongoAsStockHolder) {
-        // 全プロジェクト
-        useMongoAsStockHolderProjects = (await projectRepo.projectFields(
-            {
-                // id: { $eq: 'xxx' }
-            },
-            ['id']
-        )).map(({ id }) => id);
-    }
+    let checkingProjects: string[] = [];
+    // 全プロジェクト
+    checkingProjects = (await projectRepo.projectFields(
+        {
+            // id: { $eq: 'xxx' }
+        },
+        ['id']
+    )).map(({ id }) => id);
 
-    useMongoAsStockHolderProjects = useMongoAsStockHolderProjects.filter((id) => id.slice(0, 6) !== 'sskts-');
+    checkingProjects = checkingProjects.filter((id) => id.slice(0, 6) !== 'sskts-');
 
     const results: {
         project: { id: string };
@@ -127,7 +118,7 @@ async function main() {
     const now = moment()
         .add(0, 'days')
         .toDate();
-    for (const projectId of useMongoAsStockHolderProjects) {
+    for (const projectId of checkingProjects) {
         const { checkedCount, redisKeyCount } = await countRedisKeyByProject({
             project: { id: projectId },
             now