@chevre/domain 22.10.0-alpha.2 → 22.10.0-alpha.21

package/example/src/chevre/assetTransaction/processReserve.ts

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

package/example/src/chevre/createTaskIfNotExistByAlternateName.ts

@@ -5,7 +5,7 @@ import { chevre } from '../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
 
-chevre.eventEmitter.task.onTaskStatusChanged((event) => {
+chevre.eventEmitter.task.taskEventEmitter.onTaskStatusChanged((event) => {
     console.log('onTaskStatusChanged', event);
 });
 

package/example/src/chevre/eventOffer/adminEventOffers.ts

@@ -0,0 +1,67 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const IDENTIFIER = 'xxx';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    // const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const eventOfferRepo = await chevre.repository.EventOffer.createInstance(mongoose.connection);
+
+    let docs = await eventOfferRepo.projectFields(
+        {
+            project: { id: { $eq: project.id } },
+            identifier: { $eq: IDENTIFIER }
+        },
+        ['availableAtOrFrom', 'identifier', 'itemOffered', 'project', 'validFrom']
+    );
+    console.log('docs:', docs);
+    console.log(docs.length, 'docs found');
+
+    if (docs.length > 0) {
+        await eventOfferRepo.deleteById({
+            project: { id: docs[0].project.id },
+            id: docs[0].id
+        });
+        console.log('deleted', docs[0].id);
+    }
+
+    await eventOfferRepo.save({
+        attributes: {
+            identifier: IDENTIFIER,
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            typeOf: chevre.factory.offerType.Offer,
+            itemOffered: {
+                id: 'xxxxx',
+                typeOf: chevre.factory.eventType.ScreeningEvent
+            },
+            seller: {
+                id: 'xxxxx',
+                typeOf: chevre.factory.organizationType.Organization
+            },
+            availableAtOrFrom: { id: 'xxx' },
+            validFrom: new Date(),
+            validThrough: new Date(),
+            validForMemberTier: { identifier: 'xxx', typeOf: 'MemberProgramTier' }
+        }
+    });
+    console.log('created.');
+
+    docs = await await eventOfferRepo.projectFields(
+        {
+            project: { id: { $eq: project.id } },
+            identifier: { $eq: IDENTIFIER }
+        },
+        ['availableAtOrFrom', 'identifier', 'itemOffered', 'project', 'validFrom']
+    );
+    console.log('docs:', docs);
+    console.log(docs.length, 'docs found');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/findOneAvailableHours.ts

@@ -0,0 +1,39 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(String(process.env.MONGOLAB_URI), { autoIndex: false });
+
+    const availableHourRepo = await chevre.repository.ServiceAvailableHour.createInstance(mongoose.connection);
+
+    const setting = await availableHourRepo.findValidOne(
+        {
+            // now: new Date(),
+            now: moment('2025-05-15T00:00:00Z')
+                .toDate()
+        },
+        ['opens', 'typeOf']
+    );
+    console.log('setting:', setting);
+    const result = await availableHourRepo.saveOne(
+        {
+            // opens: '09:00:00',
+            validFrom: moment('2025-05-19T17:00:00Z')
+                .toDate(),
+            validThrough: moment('2025-05-19T20:00:00Z')
+                .toDate(),
+            typeOf: 'OpeningHoursSpecification'
+        }
+    );
+    console.log('saved', result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch((err) => {
+        console.error(err);
+    });

package/example/src/chevre/issuer/adminMemberProgramTiers.ts

@@ -0,0 +1,55 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const IDENTIFIER = 'DefaultMemberProgram';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const memberProgramRepo = await chevre.repository.MemberProgram.createInstance(mongoose.connection);
+
+    const memberPrograms = await memberProgramRepo.projectMemberPrograms(
+        {
+            project: { id: { $eq: project.id } },
+            identifier: { $eq: IDENTIFIER }
+        }
+    );
+    console.log('docs:', memberPrograms);
+    console.log(memberPrograms.length, 'docs found');
+
+    if (memberPrograms.length > 0) {
+        const memberProgram = memberPrograms[0];
+        await memberProgramRepo.updateOne({
+            project: { id: project.id },
+            identifier: memberProgram.identifier,
+            hostingOrganization: { id: 'xxx' },
+            hasTiers: [
+                { identifier: 'bronze' },
+                { identifier: 'silver' },
+                { identifier: 'gold' }
+            ]
+        });
+        console.log('updated.');
+
+        const tiers = await memberProgramRepo.projectMemberProgramTiers(
+            {
+                limit: 10,
+                page: 1,
+                project: { id: { $eq: project.id } },
+                isTierOf: {
+                    identifier: { $eq: memberProgram.identifier }
+                }
+            }
+        );
+        // tslint:disable-next-line:no-null-keyword
+        console.dir(tiers, { depth: null });
+        console.log(tiers.length, 'tiers found');
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/issuer/renameIssuerIdentifier.ts

@@ -0,0 +1,61 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const NEW_IDENTIFIER = 'DefaultTokenIssuer';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const issuerRepo = await chevre.repository.Issuer.createInstance(mongoose.connection);
+
+    const cursor = issuerRepo.getCursor(
+        {
+            // 'project.id': { $ne: EXCLUDED_PROJECT_ID }
+        },
+        {
+            _id: 1,
+            project: 1,
+            identifier: 1,
+            url: 1,
+            name: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const issuer: chevre.factory.issuer.IIssuer = doc.toObject();
+
+        const alreadyMigrated = issuer.identifier === NEW_IDENTIFIER;
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.',
+                issuer.id, issuer.project.id, issuer.identifier, i);
+        } else {
+            console.log(
+                'updating...',
+                issuer.id, issuer.project.id, issuer.identifier, i);
+            await issuerRepo.renameIssuerIdentifier({
+                id: issuer.id,
+                identifier: NEW_IDENTIFIER
+            });
+            updateCount += 1;
+            console.log(
+                'updated.',
+                issuer.id, issuer.project.id, issuer.identifier, i);
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

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/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.Message.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/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);