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

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);

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

@@ -1,256 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment-timezone';
-import * as mongoose from 'mongoose';
-import * as redis from 'redis';
-import { chevre } from '../../../../lib/index';
-
-const today = moment()
-    .tz('Asia/Tokyo')
-    .format('YYYYMMDD');
-const project = { id: String(process.env.PROJECT_ID) };
-const providerId = 'sampleProviderId';
-const eventId = `sampleEventId${today}:03`;
-const eventStartDate = new Date('2025-05-01T00:00:00Z');
-const expires = moment(eventStartDate)
-    .add(1, 'week')
-    .toDate();
-const seatSection = 'SampleSectionNameXXXXXXXXXXXXXXXXXXX';
-// tslint:disable-next-line:no-magic-numbers prefer-array-literal
-const allSeatNumbers = [...Array(10000)].map((__, seatKey) => `SampleSeatNumber-${seatKey}`);
-const OPERATION_INTERVAL = 2000;
-// const MAXIMUM_CAPACITY = 10002;
-
-mongoose.Model.on('index', (...args) => {
-    console.error('******** index event emitted. ********\n', args);
-});
-
-async function sleep(waitTime: number): Promise<void> {
-    return new Promise<void>((resolve) => {
-        setTimeout(
-            () => {
-                resolve();
-            },
-            waitTime
-        );
-    });
-}
-
-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 formatter = new Intl.NumberFormat('ja-JP');
-// => "1,000"
-
-// tslint:disable-next-line:max-func-body-length
-async function lockSeatsForcibly(params: {
-    maximumCapacity?: number;
-}) {
-    const { maximumCapacity } = params;
-    let startTime: [number, number] = process.hrtime();
-    let diff: [number, number] = process.hrtime(startTime);
-
-    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
-        client,
-        mongoose.connection
-    );
-
-    startTime = process.hrtime();
-    console.log('counting unavailableOffers...');
-    let countUnavailableOffersResult = await stockHolderRepo.countUnavailableOffers({
-        project: { id: project.id },
-        event: {
-            id: eventId,
-            startDate: eventStartDate,
-            hasTicketedSeat: true
-        }
-    });
-    console.log('countUnavailableOffersResult:', countUnavailableOffersResult);
-    console.log('diff:', [diff[0], formatter.format(diff[1])]);
-
-    await sleep(OPERATION_INTERVAL);
-    startTime = process.hrtime();
-    console.log('counting searching holders...');
-    const searchHoldersResult = await stockHolderRepo.searchHolders({
-        project: { id: project.id },
-        eventId,
-        startDate: eventStartDate,
-        hasTicketedSeat: true,
-        offers: [
-            // tslint:disable-next-line:no-magic-numbers
-            ...allSeatNumbers.slice(0, 100)
-                .map((seatNumber) => ({ seatSection, seatNumber }))
-        ]
-    });
-    diff = process.hrtime(startTime);
-    console.log('searchHoldersResult.length:', searchHoldersResult.length);
-    console.log('diff:', [diff[0], formatter.format(diff[1])]);
-
-    // select 2 seats
-    // tslint:disable-next-line:insecure-random
-    const seatNumber1 = allSeatNumbers[Math.floor(allSeatNumbers.length * Math.random())];
-    const seatNumber2 = allSeatNumbers.filter((seatNumber) => seatNumber !== seatNumber1)[
-        // tslint:disable-next-line:insecure-random
-        Math.floor((allSeatNumbers.length - 1) * Math.random())
-    ];
-
-    const seatNumbers = [seatNumber1, seatNumber2];
-    console.log('seats selected.', seatNumbers);
-
-    let locked = false;
-    while (!locked) {
-        await sleep(OPERATION_INTERVAL);
-        startTime = process.hrtime();
-        const currentHolders: string[] = [];
-        for (const seatNumber of seatNumbers) {
-            const currentHolder = await stockHolderRepo.getHolder({
-                project: { id: project.id },
-                eventId,
-                startDate: eventStartDate,
-                hasTicketedSeat: true,
-                offer: { seatSection, seatNumber }
-            });
-            if (typeof currentHolder === 'string') {
-                currentHolders.push(currentHolder);
-            }
-        }
-        diff = process.hrtime(startTime);
-        console.log('currentHolders:', currentHolders);
-        console.log('diff:', [diff[0], formatter.format(diff[1])]);
-
-        try {
-            await sleep(OPERATION_INTERVAL);
-            const newHolder = Date.now()
-                .toString();
-            const bookingTime = new Date();
-            startTime = process.hrtime();
-            console.log('locking...', newHolder, seatSection, seatNumbers);
-            if (typeof maximumCapacity === 'number') {
-                try {
-                    await stockHolderRepo.lockIfNotLimitExceeded(
-                        {
-                            project: { id: project.id },
-                            provider: { id: providerId },
-                            eventId,
-                            startDate: eventStartDate,
-                            hasTicketedSeat: true,
-                            offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
-                            expires,
-                            holder: newHolder,
-                            bookingTime
-                        },
-                        maximumCapacity
-                    );
-                } catch (error) {
-                    if (error.message === 'maximumAttendeeCapacity exceeded') {
-                        // ok
-                    } else {
-                        throw error;
-                    }
-                }
-            } else {
-                await stockHolderRepo.lock({
-                    project: { id: project.id },
-                    provider: { id: providerId },
-                    eventId,
-                    startDate: eventStartDate,
-                    hasTicketedSeat: true,
-                    offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
-                    expires,
-                    holder: newHolder,
-                    bookingTime
-                });
-            }
-            diff = process.hrtime(startTime);
-            console.log('locked.', newHolder);
-            console.log('diff:', [diff[0], formatter.format(diff[1])]);
-            locked = true;
-        } catch (error) {
-            if (error instanceof chevre.factory.errors.AlreadyInUse) {
-                console.log('lockResult:', error.name, error.message);
-            } else {
-                console.error(error);
-            }
-        }
-
-        await sleep(OPERATION_INTERVAL);
-        for (const currentHolder of currentHolders) {
-            for (const seatNumber of seatNumbers) {
-                startTime = process.hrtime();
-                console.log('unlocking...', currentHolder, seatSection, seatNumber);
-                const unlockResult = await stockHolderRepo.unlock({
-                    project: { id: project.id },
-                    eventId,
-                    startDate: eventStartDate,
-                    hasTicketedSeat: true,
-                    offer: { seatSection, seatNumber },
-                    holder: currentHolder
-                });
-                diff = process.hrtime(startTime);
-                console.log('unlockResult:', unlockResult);
-                console.log('diff:', [diff[0], formatter.format(diff[1])]);
-            }
-        }
-    }
-
-    await sleep(OPERATION_INTERVAL);
-    countUnavailableOffersResult = await stockHolderRepo.countUnavailableOffers({
-        project: { id: project.id },
-        event: {
-            id: eventId,
-            startDate: eventStartDate,
-            hasTicketedSeat: true
-        }
-    });
-    console.log('countUnavailableOffersResult:', countUnavailableOffersResult);
-
-}
-
-async function main() {
-    // tslint:disable-next-line:no-magic-numbers
-    const numLock = (typeof process.argv[2] === 'string') ? Number(process.argv[2]) : 1;
-    // tslint:disable-next-line:no-magic-numbers
-    const maximumCapacity = (typeof process.argv[3] === 'string') ? Number(process.argv[3]) : undefined;
-
-    const LOCK_INTERVAL = 300;
-    let i = 0;
-    let lockedCount = 0;
-    let timeout: NodeJS.Timeout;
-    const processStartDate = new Date();
-    function onSeatsLocked() {
-        lockedCount += 1;
-        console.log(lockedCount, 'lockSeatsForcibly executed!');
-        console.log('processed.', processStartDate, '~', new Date());
-    }
-
-    timeout = setInterval(
-        () => {
-            if (i >= numLock) {
-                clearInterval(timeout);
-
-                return;
-            }
-
-            i += 1;
-            lockSeatsForcibly({ maximumCapacity })
-                .then(onSeatsLocked)
-                .catch(console.error);
-        },
-        LOCK_INTERVAL
-    );
-}
-
-main()
-    .then()
-    .catch(console.error);

package/example/src/chevre/upsertProductsByProductId.ts

@@ -1,100 +0,0 @@
-// tslint:disable:no-console
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../lib/index';
-
-const PROJECT_ID = String(process.env.PROJECT_ID);
-
-// tslint:disable-next-line:max-func-body-length
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
-
-    const result = await productRepo.upsertManyByProductId(
-        [
-            {
-                $set: {
-                    project: {
-                        typeOf: chevre.factory.organizationType.Project,
-                        id: PROJECT_ID
-                    },
-                    typeOf: chevre.factory.product.ProductType.EventService,
-                    productID: '2023122601EventService',
-                    name: {
-                        en: 'xxx',
-                        ja: 'xxx'
-                    },
-                    // hasOfferCatalog: {
-                    //     id: 'blpc770py',
-                    //     typeOf: 'OfferCatalog'
-                    // },
-                    // serviceType: {
-                    //     codeValue: '0001',
-                    //     typeOf: 'CategoryCode',
-                    //     inCodeSet: {
-                    //         identifier: chevre.factory.categoryCode.CategorySetIdentifier.ServiceType,
-                    //         typeOf: 'CategoryCodeSet'
-                    //     }
-                    // },
-                    availableChannel: {
-                        typeOf: 'ServiceChannel',
-                        credentials: {}
-                    },
-                    description: {
-                        en: 'xxx',
-                        ja: 'xxx'
-                    }
-                },
-                $unset: {
-                    hasOfferCatalog: 1,
-                    serviceType: 1
-                }
-            },
-            {
-                $set: {
-                    project: {
-                        typeOf: chevre.factory.organizationType.Project,
-                        id: PROJECT_ID
-                    },
-                    typeOf: chevre.factory.product.ProductType.EventService,
-                    productID: '2023122602EventService',
-                    name: {
-                        en: 'xxx',
-                        ja: 'xxx'
-                    },
-                    hasOfferCatalog: {
-                        // id: 'blpc770py',
-                        typeOf: 'OfferCatalog',
-                        itemListElement: [{ id: 'blpc770py' }]
-                    },
-                    // serviceType: {
-                    //     codeValue: '0001',
-                    //     typeOf: 'CategoryCode',
-                    //     inCodeSet: {
-                    //         identifier: chevre.factory.categoryCode.CategorySetIdentifier.ServiceType,
-                    //         typeOf: 'CategoryCodeSet'
-                    //     }
-                    // },
-                    availableChannel: {
-                        typeOf: 'ServiceChannel',
-                        credentials: {}
-                    },
-                    description: {
-                        en: 'xxx',
-                        ja: 'xxx'
-                    }
-                },
-                $unset: {
-                }
-            }
-        ]
-        // { replace: true }
-    );
-    // tslint:disable-next-line:no-null-keyword
-    console.log(result);
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

package/lib/chevre/adminAuth.d.ts

@@ -1,2 +0,0 @@
-import { auth, chevreAuth, loadChevreAuth } from '@cinerino/sdk';
-export { auth, loadChevreAuth, chevreAuth };

package/lib/chevre/adminAuth.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadChevreAuth = exports.auth = void 0;
-const sdk_1 = require("@cinerino/sdk");
-Object.defineProperty(exports, "auth", { enumerable: true, get: function () { return sdk_1.auth; } });
-Object.defineProperty(exports, "loadChevreAuth", { enumerable: true, get: function () { return sdk_1.loadChevreAuth; } });