@chevre/domain 22.11.0-alpha.9 → 22.11.0

package/example/src/chevre/executeTaskIfExists.ts

@@ -1,80 +0,0 @@
-// tslint:disable:no-console
-import { chevre } from '../../../lib/index';
-
-import * as mongoose from 'mongoose';
-import * as redis from 'redis';
-
-export async function executeTaskIfExists() {
-    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
-    });
-    await redisClient.connect();
-
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
-
-    let count = 0;
-
-    const MAX_NUBMER_OF_PARALLEL_TASKS = 1;
-    const INTERVAL_MILLISECONDS = 1000;
-
-    setInterval(
-        async () => {
-            if (count > MAX_NUBMER_OF_PARALLEL_TASKS) {
-                return;
-            }
-
-            count += 1;
-
-            try {
-                console.log('executing...', count);
-                await (await chevre.service.task.createService()).executeOneIfExists({
-                    // name: chevre.factory.taskName.AggregateScreeningEvent,
-                    executor: { name: 'sample' },
-                    runsAt: { $lt: new Date() },
-                    name: {
-                        $nin: [
-                            chevre.factory.taskName.DeleteTransaction,
-                            chevre.factory.taskName.ImportEventCapacitiesFromCOA,
-                            chevre.factory.taskName.ImportEventsFromCOA,
-                            chevre.factory.taskName.AcceptCOAOffer,
-                            chevre.factory.taskName.CheckMovieTicket,
-                            chevre.factory.taskName.AuthorizePayment,
-                            chevre.factory.taskName.PublishPaymentUrl
-                        ]
-                    }
-                })({
-                    connection: mongoose.connection,
-                    redisClient,
-                    credentials: {
-                        sendGrid: await chevre.credentials.SendGrid.createInstance({ apiKey: 'xxx' })
-                    },
-                    settings: new chevre.settings.Settings({
-                        deliverOrderLimit: 1,
-                        abortedTasksWithoutReport: [],
-                        coa: { timeout: 1000 },
-                        gmo: { timeout: 1000, timeoutBackground: 1000, useFetch: true },
-                        movieticketReserve: { timeout: 1000, timeoutCheck: 1000, minIntervalBetweenPayAndRefund: 0 },
-                        numTryConfirmReserveTransaction: 10,
-                        useExperimentalFeature: false
-                    })
-                });
-                console.log('executed', count);
-            } catch (error) {
-                console.error(error);
-            }
-
-            count -= 1;
-        },
-        INTERVAL_MILLISECONDS
-    );
-}
-
-executeTaskIfExists()
-    .then(() => {
-        console.log('success!');
-    })
-    .catch(console.error);

package/example/src/chevre/findExecutableTask.ts

@@ -1,50 +0,0 @@
-// 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) };
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
-
-    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
-
-    setInterval(
-        async () => {
-            const startTime = process.hrtime();
-            const task = await taskRepo.findExecutableOne({
-                name: {
-                    $eq: chevre.factory.taskName.VoidReserveTransaction
-                    // $nin: [
-                    //     chevre.factory.taskName.DeleteTransaction,
-                    //     chevre.factory.taskName.ImportEventCapacitiesFromCOA,
-                    //     chevre.factory.taskName.ImportEventsFromCOA,
-                    //     chevre.factory.taskName.AcceptCOAOffer,
-                    //     chevre.factory.taskName.CheckMovieTicket,
-                    //     chevre.factory.taskName.AuthorizePayment,
-                    //     chevre.factory.taskName.PublishPaymentUrl
-                    // ]
-                },
-                runsAt: {
-                    $lt: moment()
-                        // tslint:disable-next-line:no-magic-numbers
-                        .add(-60, 'seconds')
-                        .toDate()
-                }
-            });
-            const diff = process.hrtime(startTime);
-            console.log(`took ${diff[0]} seconds and ${diff[1]} nanoseconds.`);
-
-            // tslint:disable-next-line:no-null-keyword
-            console.dir(task?.id, { depth: null });
-        },
-        // tslint:disable-next-line:no-magic-numbers
-        1000
-    );
-}
-
-main()
-    .then()
-    .catch(console.error);

package/example/src/chevre/findSetting.ts

@@ -1,79 +0,0 @@
-// tslint:disable:no-console
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../lib/index';
-
-const informOrderUrls = (typeof process.env.INFORM_ORDER_URL === 'string')
-    ? process.env.INFORM_ORDER_URL.split(' ')
-    : [];
-// const informReservationUrls = (typeof process.env.INFORM_RESERVATION_URL === 'string')
-//     ? process.env.INFORM_RESERVATION_URL.split(' ')
-//     : [];
-// const informResourceUrls = (typeof process.env.INFORM_RESOURCE_URL === 'string')
-//     ? process.env.INFORM_RESOURCE_URL.split(',')
-//     : [];
-// const informEvent2aggUrls = (typeof process.env.INFORM_EVENT_AGG_URL === 'string')
-//     ? process.env.INFORM_EVENT_AGG_URL.split(' ')
-//     : [];
-// const userPoolIdOld = process.env.USERPOOL_ID_OLD;
-// const userPoolIdNew = process.env.USERPOOL_ID_NEW;
-// const defaultSenderEmail = process.env.DEFAULT_SENDER_EMAIL;
-
-// tslint:disable-next-line:max-func-body-length
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
-
-    const result = await settingRepo.findOne({}, ['triggerWebhook', 'waiter']);
-    // tslint:disable-next-line:no-null-keyword
-    console.dir(result, { depth: null });
-
-    if (result === null) {
-        if (informOrderUrls.length > 0) {
-            await settingRepo.saveOne({
-                project: { id: '*', typeOf: chevre.factory.organizationType.Project },
-                onOrderStatusChanged: {
-                    informOrder: informOrderUrls
-                        .filter((url) => url.length > 0)
-                        .map((url) => {
-                            return {
-                                recipient: {
-                                    typeOf: chevre.factory.creativeWorkType.WebApplication,
-                                    name: 'Aggregation Service',
-                                    url
-                                }
-                            };
-                        })
-                }
-            });
-            console.log('saved');
-        }
-    } else {
-        const updateResult = await settingRepo.updateByProject(
-            { project: { id: { $eq: '*' } } },
-            {
-                triggerWebhook: {
-                    timeout: 15000,
-                    useFetchAPI: true,
-                    secretKey: String(process.env.TRIGGER_WEBHOOK_SECRET_KEY),
-                    headerIdentifier: String(process.env.TRIGGER_WEBHOOK_HEADER_IDENTIFIER),
-                    retryCountMax: 2,
-                    retryIntervalInMS: 1000
-                },
-                waiter: {
-                    disabled: process.env.WAITER_DISABLED === '1',
-                    passportUnavailable: process.env.WAITER_PASSPORT_UNAVAILABLE === '1',
-                    passportIssuers: String(process.env.WAITER_PASSPORT_ISSUER)
-                        .split(' '),
-                    secret: String(process.env.WAITER_SECRET)
-                }
-            }
-        );
-        console.log('updated', updateResult);
-    }
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

package/example/src/chevre/searchPermissions.ts

@@ -1,46 +0,0 @@
-// 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 memberId = 'xxx';
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
-
-    const memberRepo = await chevre.repository.Member.createInstance(mongoose.connection);
-    const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
-
-    let now: Date;
-
-    now = new Date();
-    const searchPermissionsResult = await (await chevre.service.iam.createService()).searchPermissions({
-        project: { id: PROJECT_ID },
-        member: {
-            id: memberId,
-            memberOf: {
-                id: PROJECT_ID,
-                typeOf: chevre.factory.organizationType.Project
-            }
-        }
-    })({
-        member: memberRepo,
-        role: roleRepo
-    });
-    console.log('time cost:', moment()
-        .diff(now));
-
-    console.log(searchPermissionsResult);
-    console.log(searchPermissionsResult.permissions.length);
-
-    // console.log(aggregateRoleNamesResult);
-    // console.log(aggregateRoleNamesResult.length);
-    // console.log(aggregatePermissionsResult);
-    // console.log(aggregatePermissionsResult.length);
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

package/example/src/chevre/searchProductOffers.ts

@@ -1,29 +0,0 @@
-// tslint:disable:no-console
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../lib/index';
-
-const PROJECT_ID = String(process.env.PROJECT_ID);
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
-
-    const productOfferRepo = await chevre.repository.ProductOffer.createInstance(mongoose.connection);
-
-    const offers = await productOfferRepo.search({
-        project: { id: { $eq: PROJECT_ID } }
-        // seller: { id: { $eq: 'xxx' } }
-    });
-    console.log(offers);
-    console.log(offers.length);
-
-    // await productOfferRepo.deleteOne({
-    //     project: { id: PROJECT_ID },
-    //     seller: { id: 'xxx' },
-    //     itemOffered: { id: 'xxx' }
-    // });
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

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

@@ -1,76 +0,0 @@
-// 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 excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
-
-const client = 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
-})
-    .on('error', (err) => {
-        // eslint-disable-next-line no-console
-        console.error('createDefaultRedisClient: client onError:', err);
-        // reject(err);
-    });
-client.connect();
-mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-// tslint:disable-next-line:max-func-body-length
-async function main() {
-    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
-    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
-        client,
-        mongoose.connection
-    );
-
-    const cursor = eventRepo.getCursor(
-        {
-            'project.id': { $ne: excludedProject.id },
-            startDate: {
-                $gte: moment()
-                    .add(-1, 'days')
-                    .toDate()
-            },
-            typeOf: { $eq: chevre.factory.eventType.ScreeningEvent }
-            // _id: { $eq: 'blyk9q24f' }
-        },
-        {
-            _id: 1,
-            // offers: 1,
-            startDate: 1,
-            project: 1,
-            typeOf: 1
-        }
-    );
-    console.log('events found');
-
-    let i = 0;
-    await cursor.eachAsync(async (doc) => {
-        i += 1;
-        const event: Pick<
-            chevre.factory.event.screeningEvent.IEvent,
-            'id' | 'startDate' | 'project' | 'typeOf'
-        > = doc.toObject();
-
-        console.log(
-            'conflicted?', event.project.id, event.typeOf, event.id, event.startDate, i);
-        await stockHolderRepo.checkIfConflicted({
-            eventId: event.id,
-            startDate: event.startDate
-        });
-    });
-
-    console.log(i, 'events checked');
-}
-
-main()
-    .then()
-    .catch(console.error);

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

@@ -1,186 +0,0 @@
-// tslint:disable:no-console no-magic-numbers
-import * as moment from 'moment';
-import * as mongoose from 'mongoose';
-import * as redis from 'redis';
-import * as util from 'util';
-
-import { chevre } from '../../../../lib/index';
-
-// const project = { id: String(process.env.PROJECT_ID) };
-const { BACKLOG_ISSUE_KEY, BACKLOG_API_KEY, BACKLOG_SPACE_KEY } = process.env;
-const BACKLOG_NOTIFY_URL = `https://${BACKLOG_SPACE_KEY}.backlog.jp/api/v2/issues/${BACKLOG_ISSUE_KEY}/comments?apiKey=${BACKLOG_API_KEY}`;
-
-const client = 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);
-    });
-client.connect();
-mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-function countRedisKeyByProject(params: {
-    project: { id: string };
-    now: Date;
-}) {
-    return async (repos: {
-        event: chevre.repository.Event;
-        stockHolder: chevre.repository.StockHolder;
-    }) => {
-        const cursor = repos.event.getCursor(
-            {
-                'project.id': {
-                    $eq: params.project.id
-                },
-                // startDate: {
-                //     $gte: params.now
-                // },
-                endDate: {
-                    $gte: params.now
-                },
-                typeOf: { $eq: chevre.factory.eventType.ScreeningEvent }
-                // _id: { $eq: 'blyk9q24f' }
-            },
-            {
-                _id: 1,
-                // offers: 1,
-                startDate: 1,
-                project: 1,
-                typeOf: 1
-            }
-        );
-        console.log('events found');
-
-        let i = 0;
-        let redisKeyCount = 0;
-        const eventsWithRedis: string[] = [];
-        await cursor.eachAsync(async (doc) => {
-            i += 1;
-            const event: Pick<
-                chevre.factory.event.screeningEvent.IEvent,
-                'id' | 'startDate' | 'project' | 'typeOf'
-            > = doc.toObject();
-
-            console.log('redisKeyExists?', event.project.id, event.typeOf, event.id, event.startDate, i);
-            const redisKeyExists = await repos.stockHolder.redisKeyExists({
-                eventId: event.id,
-                startDate: event.startDate
-            });
-            console.log('redisKeyExists:', redisKeyExists, event.project.id, event.typeOf, event.id, event.startDate, i);
-
-            if (redisKeyExists) {
-                redisKeyCount += 1;
-                eventsWithRedis.push(event.id);
-            }
-        });
-
-        console.log(i, 'events checked');
-        console.log(redisKeyCount, 'redisKeys found');
-
-        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,
-        mongoose.connection
-    );
-
-    let checkingProjects: string[] = [];
-    // 全プロジェクト
-    checkingProjects = (await projectRepo.projectFields(
-        {
-            // id: { $eq: 'xxx' }
-        },
-        ['id']
-    )).map(({ id }) => id);
-
-    checkingProjects = checkingProjects.filter((id) => id.slice(0, 6) !== 'sskts-');
-
-    const results: {
-        project: { id: string };
-        checkedCount: number;
-        redisKeyCount: number;
-    }[] = [];
-
-    const now = moment()
-        .add(0, 'days')
-        .toDate();
-    for (const projectId of checkingProjects) {
-        const { checkedCount, redisKeyCount } = await countRedisKeyByProject({
-            project: { id: projectId },
-            now
-        })({
-            event: eventRepo,
-            stockHolder: stockHolderRepo
-        });
-        results.push({
-            project: { id: projectId },
-            checkedCount,
-            redisKeyCount
-        });
-        // console.log(eventsWithRedis);
-    }
-
-    const header = util.format(
-        '| %s | %s | %s | %s |\n| %s | %s | %s | %s |',
-        `project                                    `.slice(0, 40),
-        `now                              `.slice(0, 24),
-        `checkedCount                              `.slice(0, 24),
-        `redisKeyCount                              `.slice(0, 24),
-        `----------------------------------------                                    `.slice(0, 40),
-        `------------------------                              `.slice(0, 24),
-        `------------------------                              `.slice(0, 24),
-        `------------------------                              `.slice(0, 24)
-    );
-
-    const text = util.format(
-        '%s\n%s',
-        header,
-        results.map((result) => {
-            return util.format(
-                '| %s | %s | %s | %s |',
-                `${result.project.id}                                    `.slice(0, 40),
-                `${now.toISOString()}                              `.slice(0, 24),
-                `${result.checkedCount}                              `.slice(0, 24),
-                `${result.redisKeyCount}                              `.slice(0, 24)
-            );
-        })
-            .join('\n')
-    );
-    console.log(text);
-
-    // 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()
-    .then()
-    .catch(console.error);

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

@@ -1,96 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment-timezone';
-import * as mongoose from 'mongoose';
-import * as redis from 'redis';
-import { ILockKey } from '../../../../lib/chevre/repo/stockHolderAbstract';
-import { chevre } from '../../../../lib/index';
-
-const client = 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
-})
-    .on('error', (err) => {
-        // eslint-disable-next-line no-console
-        console.error('createDefaultRedisClient: client onError:', err);
-        // reject(err);
-    });
-client.connect();
-mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-const EVENT_ID = 'cm8dwc74c';
-
-async function main() {
-    // 万が一に備えて、保留予約をredis->mongo移行するスクリプト
-    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
-    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
-    // const pendingReservationRepo = await chevre.repository.PendingReservation.createInstance(mongoose.connection);
-    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(client, mongoose.connection);
-
-    const event = await eventRepo.projectEventFieldsById(
-        { id: EVENT_ID },
-        ['startDate', 'organizer', 'project', 'offers']
-    );
-    const hasTicketedSeat = event.offers.itemOffered.serviceOutput?.reservedTicket?.ticketedSeat?.typeOf === chevre.factory.placeType.Seat;
-    const { expireTime, hash } = await stockHolderRepo.migrate2mongoJustInCase({
-        eventId: EVENT_ID,
-        startDate: event.startDate
-        // project: { id: event.project.id },
-        // provider: { id: event.organizer.id }
-    });
-    console.log(expireTime, hash);
-
-    const lockKeys: ILockKey[] = [];
-    const reservationNumbers: string[] = [...new Set(Object.values(hash))];
-    const expires: Date = moment.unix(expireTime)
-        .toDate();
-    console.log('reservationNumbers:', reservationNumbers);
-    console.log('expires:', expires);
-
-    // 予約番号ごとにlockKeyを作成する
-    for (const reservationNumber of reservationNumbers) {
-        const reserveTransaction = (await assetTransactionRepo.search<chevre.factory.assetTransactionType.Reserve>(
-            {
-                limit: 1,
-                page: 1,
-                transactionNumber: { $eq: reservationNumber },
-                typeOf: chevre.factory.assetTransactionType.Reserve,
-                status: { $in: [chevre.factory.transactionStatusType.Confirmed] }
-            },
-            ['object', 'startDate']
-        )).shift();
-        if (reserveTransaction === undefined) {
-            throw new Error(`reserveTransaction not found ${reservationNumber}`);
-        }
-
-        const fields: string[] = Object.keys(hash)
-            .filter((field) => hash[field] === reservationNumber);
-        const lockKey: ILockKey = {
-            project: { id: event.project.id },
-            provider: { id: event.organizer.id },
-            eventId: EVENT_ID,
-            startDate: event.startDate,
-            hasTicketedSeat,
-            offers: fields.map((field) => {
-                const splitedField = field.split(':');
-
-                return {
-                    seatSection: splitedField[0],
-                    seatNumber: splitedField[1]
-                };
-            }),
-            expires,
-            holder: reservationNumber,
-            bookingTime: reserveTransaction.startDate
-        };
-        console.log('lockKey:', lockKey);
-        lockKeys.push(lockKey);
-        // await pendingReservationRepo.lock(lockKey);
-    }
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);