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

package/example/src/chevre/maintenance/checkTransactionStatuses.ts

@@ -0,0 +1,105 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const now = new Date();
+    console.log('--------', 'aggregating...', ' --------', now);
+
+    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
+    const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+
+    // {status:"InProgress"}を確認
+    // {"tasksExportAction.actionStatus":{$ne:"CompletedActionStatus"}}を確認
+
+    for (const transactionType of [
+        chevre.factory.transactionType.PlaceOrder,
+        chevre.factory.transactionType.ReturnOrder
+    ]) {
+        const inProgressCount = await transactionRepo.count({
+            limit: 1000,
+            status: { $in: [chevre.factory.transactionStatusType.InProgress] },
+            typeOf: transactionType
+        });
+        console.log(transactionType, 'inProgressCount:', inProgressCount.count, now);
+
+        const unCompletedTasksExportCount = await transactionRepo.count({
+            limit: 1000,
+            tasksExportAction: {
+                actionStatus: {
+                    $in: [
+                        chevre.factory.actionStatusType.ActiveActionStatus,
+                        chevre.factory.actionStatusType.CanceledActionStatus,
+                        chevre.factory.actionStatusType.FailedActionStatus,
+                        chevre.factory.actionStatusType.PotentialActionStatus
+                    ]
+                }
+            },
+            typeOf: transactionType
+        });
+        console.log(transactionType, 'unCompletedTasksExportCount:', unCompletedTasksExportCount.count, now);
+    }
+
+    for (const assetTransactionType of [
+        chevre.factory.assetTransactionType.Pay,
+        chevre.factory.assetTransactionType.Refund,
+        chevre.factory.assetTransactionType.Reserve,
+        chevre.factory.assetTransactionType.CancelReservation
+    ]) {
+        const inProgressCount = await assetTransactionRepo.count({
+            limit: 1000,
+            status: { $in: [chevre.factory.transactionStatusType.InProgress] },
+            typeOf: <any>assetTransactionType
+        });
+        console.log(assetTransactionType, 'inProgressCount:', inProgressCount.count, now);
+
+        const unCompletedTasksExportCount = await assetTransactionRepo.count({
+            limit: 1000,
+            tasksExportAction: {
+                actionStatus: {
+                    $in: [
+                        chevre.factory.actionStatusType.ActiveActionStatus,
+                        chevre.factory.actionStatusType.CanceledActionStatus,
+                        chevre.factory.actionStatusType.FailedActionStatus,
+                        chevre.factory.actionStatusType.PotentialActionStatus
+                    ]
+                }
+            },
+            typeOf: <any>assetTransactionType
+        });
+        console.log(assetTransactionType, 'unCompletedTasksExportCount:', unCompletedTasksExportCount.count, now);
+    }
+
+    const readyTaskCount = await taskRepo.count({
+        limit: 100,
+        statuses: [
+            chevre.factory.taskStatus.Ready,
+            chevre.factory.taskStatus.Running
+        ],
+        name: {
+            $nin: [
+                chevre.factory.taskName.ImportEventCapacitiesFromCOA,
+                chevre.factory.taskName.ImportEventsFromCOA,
+                chevre.factory.taskName.ImportOffersFromCOA
+            ]
+        },
+        runsThrough: now
+    });
+    console.log('readyTaskCount:', readyTaskCount.count, now);
+}
+
+const INTERVAL_MS = 60000;
+// const INTERVAL_MS = 5000;
+setInterval(
+    () => {
+        main()
+            .then()
+            .catch(console.error);
+    },
+    INTERVAL_MS
+);

package/example/src/chevre/migrateIdentities.ts

@@ -11,23 +11,17 @@ async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     const identityRepo = await chevre.repository.Identity.createInstance(mongoose.connection);
-    const memberRepo = await chevre.repository.Member.createInstance(mongoose.connection);
 
-    const cursor = memberRepo.getCursor(
+    const cursor = identityRepo.getCursor(
         {
-            'member.typeOf': {
-                $in: [
-                    chevre.factory.creativeWorkType.WebApplication
-                ]
-            },
-            'project.id': { $ne: '*' }
-            // _id: { $eq: '5f9a4fed4f3709000abe6415' }
+            // _id: { $eq: '67de46777ec0510590b68922' }
         },
         {
             _id: 1,
-            member: 1,
+            about: 1,
             project: 1,
-            typeOf: 1
+            typeOf: 1,
+            issuedBy: 1
         }
     );
     console.log('docs found');
@@ -36,40 +30,33 @@ async function main() {
     let updateCount = 0;
     await cursor.eachAsync(async (doc) => {
         i += 1;
-        const iamMember: Pick<
-            chevre.factory.iam.IMember,
-            'member' | 'project' | 'typeOf'
+        const identity: Pick<
+            chevre.factory.creativeWork.certification.webApplication.ICertification,
+            'about' | 'project' | 'typeOf' | 'id' | 'issuedBy'
         > = doc.toObject();
 
+        const issuedBy = identity.issuedBy;
+        const numIssuedBy = (Array.isArray(identity.issuedBy)) ? identity.issuedBy.length : 1;
+
         // console.log(
-        //     'alreadyMigrated?', iamMember.project.id, iamMember.member.id, i);
-        let alreadyMigrated = false;
-        try {
-            const clientId = iamMember.member.id;
-            const existingIdentity = (await identityRepo.projectFields(
-                {
-                    limit: 1,
-                    page: 1,
-                    project: { id: { $eq: iamMember.project.id } },
-                    about: { id: { $eq: clientId } }
-                },
-                ['issuedBy']
-            )).shift();
-            if (existingIdentity !== undefined) {
-                alreadyMigrated = true;
-            }
-        } catch (error) {
-            // no op
-        }
+        //     'alreadyMigrated?', identity.project.id, identity.about.id, numIssuedBy, i);
+        const alreadyMigrated = Array.isArray(issuedBy);
 
         if (alreadyMigrated) {
-            // console.log(
-            //     'already migrated.', iamMember.project.id, iamMember.member.id, i);
+            console.log(
+                'already migrated.', identity.project.id, identity.about.id, identity.id, numIssuedBy, i);
         } else {
-            const roleNames = iamMember.member.hasRole.map(({ roleName }) => roleName);
+            if (typeof identity.id !== 'string') {
+                throw new Error(`id undefined ${identity.id}`);
+            }
+
+            await identityRepo.updateIssuedBy2array({
+                id: identity.id,
+                issuedBy: [issuedBy]
+            });
             updateCount += 1;
             console.log(
-                'updated.', iamMember.project.id, iamMember.member.id, roleNames, i);
+                'updated.', identity.project.id, identity.about.id, identity.id, numIssuedBy, i);
         }
     });
 

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

package/example/src/chevre/roles/addPermissionIfNotExists.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/addRoleMembers.ts

@@ -0,0 +1,75 @@
+// 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);
+
+    let roleNames = [
+        chevre.factory.role.organizationRole.RoleName.Customer,
+        chevre.factory.role.organizationRole.RoleName.EventsViewer,
+        chevre.factory.role.organizationRole.RoleName.POS
+    ];
+    for (const roleName of roleNames) {
+        const result = await roleRepo.addMember({
+            roleName,
+            member: { typeOf: chevre.factory.creativeWorkType.WebApplication },
+            memberOf: { typeOf: chevre.factory.organizationType.Project }
+        });
+        console.log(result, roleName);
+    }
+
+    roleNames = [
+        chevre.factory.role.organizationRole.RoleName.Server
+    ];
+    for (const roleName of roleNames) {
+        const result = await roleRepo.addMember({
+            roleName,
+            member: { typeOf: chevre.factory.creativeWorkType.SoftwareApplication },
+            memberOf: { typeOf: chevre.factory.organizationType.Project }
+        });
+        console.log(result, roleName);
+    }
+
+    roleNames = [
+        chevre.factory.role.organizationRole.RoleName.Accountant,
+        chevre.factory.role.organizationRole.RoleName.IAMRoleAdmin,
+        chevre.factory.role.organizationRole.RoleName.InventoryManager,
+        chevre.factory.role.organizationRole.RoleName.MemberAdmin,
+        chevre.factory.role.organizationRole.RoleName.Owner,
+        chevre.factory.role.organizationRole.RoleName.PaymentServiceAdmin,
+        chevre.factory.role.organizationRole.RoleName.SellerAdmin,
+        chevre.factory.role.organizationRole.RoleName.TicketClerk,
+        chevre.factory.role.organizationRole.RoleName.TicketCollector,
+        chevre.factory.role.organizationRole.RoleName.User
+    ];
+    for (const roleName of roleNames) {
+        const result = await roleRepo.addMember({
+            roleName,
+            member: { typeOf: chevre.factory.personType.Person },
+            memberOf: { typeOf: chevre.factory.organizationType.Project }
+        });
+        console.log(result, roleName);
+    }
+
+    roleNames = [
+        chevre.factory.role.organizationRole.RoleName.SellersIAMRoleAdmin,
+        chevre.factory.role.organizationRole.RoleName.SellersInventoryManager,
+        chevre.factory.role.organizationRole.RoleName.SellersOwner
+    ];
+    for (const roleName of roleNames) {
+        const result = await roleRepo.addMember({
+            roleName,
+            member: { typeOf: chevre.factory.personType.Person },
+            memberOf: { typeOf: chevre.factory.organizationType.Corporation }
+        });
+        console.log(result, roleName);
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/saveWebSite.ts

@@ -3,7 +3,8 @@ import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
 
-// const project = { id: String(process.env.PROJECT_ID) };
+const project = { id: '*' };
+const WEBSITE_IDENTIFIER = process.env.WEBSITE_IDENTIFIER;
 // const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
 
 // tslint:disable-next-line:max-func-body-length
@@ -12,26 +13,22 @@ async function main() {
 
     const webSiteRepo = await chevre.repository.WebSite.createInstance(mongoose.connection);
 
+    if (typeof WEBSITE_IDENTIFIER !== 'string') {
+        throw new Error('WEBSITE_IDENTIFIER undefined');
+    }
+
     const creatingWebSites: Pick<
         chevre.factory.creativeWork.certification.webSite.ICertification,
         'about' | 'certificationStatus' | 'project' | 'auditDate'
     >[] = [
-            // {
-            //     project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
-            //     about: {
-            //         identifier: 'xxx',
-            //         typeOf: chevre.factory.creativeWorkType.WebSite
-            //     },
-            //     certificationStatus: chevre.factory.CertificationStatusEnumeration.CertificationInactive
-            // },
-            // {
-            //     project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
-            //     about: {
-            //         identifier: 'xxx',
-            //         typeOf: chevre.factory.creativeWorkType.WebSite
-            //     },
-            //     certificationStatus: chevre.factory.CertificationStatusEnumeration.CertificationInactive
-            // }
+            {
+                project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+                about: {
+                    identifier: WEBSITE_IDENTIFIER,
+                    typeOf: chevre.factory.creativeWorkType.WebSite
+                },
+                certificationStatus: chevre.factory.CertificationStatusEnumeration.CertificationInactive
+            }
         ];
     for (const creatingWebSite of creatingWebSites) {
         console.log('updating...', creatingWebSite);

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

@@ -15,7 +15,8 @@ const client = redis.createClient<redis.RedisDefaultModules, Record<string, neve
         port: Number(<string>process.env.REDIS_PORT),
         host: <string>process.env.REDIS_HOST
     },
-    password: <string>process.env.REDIS_KEY
+    password: <string>process.env.REDIS_KEY,
+    name: 'checkRedisKeyCount'
 })
     .on('error', (err) => {
         // eslint-disable-next-line no-console
@@ -39,7 +40,10 @@ function countRedisKeyByProject(params: {
                     $eq: params.project.id
                     // $in: useMongoAsStockHolderProjects
                 },
-                startDate: {
+                // startDate: {
+                //     $gte: params.now
+                // },
+                endDate: {
                     $gte: params.now
                 },
                 typeOf: { $eq: chevre.factory.eventType.ScreeningEvent }
@@ -81,13 +85,14 @@ function countRedisKeyByProject(params: {
         console.log(i, 'events checked');
         console.log(redisKeyCount, 'redisKeys found');
 
-        return { checkedCount: i, redisKeyCount };
+        return { checkedCount: i, redisKeyCount, eventsWithRedis };
     };
 }
 
 // tslint:disable-next-line:max-func-body-length
 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 stockHolderRepo = await chevre.repository.StockHolder.createInstance(
         client,
@@ -96,10 +101,23 @@ async function main() {
 
     const setting = await settingRepo.findOne(
         { project: { id: { $eq: '*' } } },
-        ['useMongoAsStockHolderProjects']
+        ['useMongoAsStockHolderProjects', 'useMongoAsStockHolder']
     );
-    const useMongoAsStockHolderProjects =
+    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);
+    }
+
+    useMongoAsStockHolderProjects = useMongoAsStockHolderProjects.filter((id) => id.slice(0, 6) !== 'sskts-');
+
     const results: {
         project: { id: string };
         checkedCount: number;
@@ -122,15 +140,16 @@ async function main() {
             checkedCount,
             redisKeyCount
         });
+        // console.log(eventsWithRedis);
     }
 
     const header = util.format(
         '| %s | %s | %s | %s |\n| %s | %s | %s | %s |',
-        `project                                    `.slice(0, 24),
+        `project                                    `.slice(0, 40),
         `now                              `.slice(0, 24),
         `checkedCount                              `.slice(0, 24),
         `redisKeyCount                              `.slice(0, 24),
-        `------------------------                                    `.slice(0, 24),
+        `----------------------------------------                                    `.slice(0, 40),
         `------------------------                              `.slice(0, 24),
         `------------------------                              `.slice(0, 24),
         `------------------------                              `.slice(0, 24)
@@ -142,7 +161,7 @@ async function main() {
         results.map((result) => {
             return util.format(
                 '| %s | %s | %s | %s |',
-                `${result.project.id}                                    `.slice(0, 24),
+                `${result.project.id}                                    `.slice(0, 40),
                 `${now.toISOString()}                              `.slice(0, 24),
                 `${result.checkedCount}                              `.slice(0, 24),
                 `${result.redisKeyCount}                              `.slice(0, 24)
@@ -153,20 +172,22 @@ async function main() {
     console.log(text);
 
     // backlogへ通知
-    console.log('notifying on backlog...');
-    await fetch(
-        BACKLOG_NOTIFY_URL,
-        {
-            method: 'POST',
-            headers: new Headers({ 'Content-Type': 'application/json' }),
-            body: JSON.stringify({
-                content: text,
-                notifiedUserId: []
-                // notifiedUserId: users.map((user) => user.id)
-            })
-        }
-    );
-    console.log('posted to backlog.');
+    if (typeof BACKLOG_API_KEY === 'string') {
+        console.log('notifying on backlog...');
+        await fetch(
+            BACKLOG_NOTIFY_URL,
+            {
+                method: 'POST',
+                headers: new Headers({ 'Content-Type': 'application/json' }),
+                body: JSON.stringify({
+                    content: text,
+                    notifiedUserId: []
+                    // notifiedUserId: users.map((user) => user.id)
+                })
+            }
+        );
+        console.log('posted to backlog.');
+    }
 }
 
 main()

package/example/src/chevre/transactionNumber/publishConfimationNumber.ts

@@ -0,0 +1,37 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY,
+    name: 'checkRedisKeyCount'
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+redisClient.connect();
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+async function main() {
+    const confirmationNumberRepo = await chevre.repository.ConfirmationNumber.createInstance({
+        redisClient,
+        connection: mongoose.connection
+    });
+    const result = await confirmationNumberRepo.publish({ orderDate: new Date() });
+    console.log(result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/transactionNumber/publishOrderNumber.ts

@@ -0,0 +1,40 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY,
+    name: 'checkRedisKeyCount'
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+redisClient.connect();
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+async function main() {
+    const orderNumberRepo = await chevre.repository.OrderNumber.createInstance({
+        redisClient,
+        connection: mongoose.connection
+    });
+    const result = await orderNumberRepo.publishByTimestamp({
+        project: { alternateName: 'CIN' },
+        orderDate: new Date()
+    });
+    console.log(result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/transactionNumber/setUseMongo4confirmationNumberFrom.ts

@@ -0,0 +1,45 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY,
+    name: 'checkRedisKeyCount'
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+redisClient.connect();
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+async function main() {
+    const confirmationNumberRepo = await chevre.repository.ConfirmationNumber.createInstance({
+        redisClient,
+        connection: mongoose.connection
+    });
+    const result = await confirmationNumberRepo.setUseMongo4confirmationNumberFrom({
+        // useMongo4confirmationNumberFrom: moment('2025-05-22T23:50:00Z')
+        //     .toDate(),
+        // useMongo4confirmationNumberFrom: moment('2025-05-25T15:00:00Z')
+        //     .toDate()
+        useMongo4confirmationNumberFrom: moment('2025-05-31T15:00:00Z')
+            .toDate()
+    });
+    console.log(result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/transactionNumber/setUseMongo4orderNumberFrom.ts

@@ -0,0 +1,41 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY,
+    name: 'checkRedisKeyCount'
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+redisClient.connect();
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+async function main() {
+    const orderNumberRepo = await chevre.repository.OrderNumber.createInstance({
+        redisClient,
+        connection: mongoose.connection
+    });
+    const result = await orderNumberRepo.setUseMongo4orderNumberFrom({
+        useMongo4orderNumberFrom: moment('2025-06-03T05:00:00Z')
+            .toDate()
+    });
+    console.log(result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);