@chevre/domain 15.65.0-alpha.9 → 20.0.0-alpha.1

package/example/.gitignore

@@ -1 +0,0 @@
-*.csv

package/example/aggregateAllEvents.js

@@ -1,58 +0,0 @@
-const moment = require('moment');
-const mongoose = require('mongoose');
-const domain = require('../lib/index');
-
-async function main() {
-    await mongoose.connect(process.env.MONGOLAB_URI);
-
-    const eventRepo = new domain.repository.Event(mongoose.connection);
-    const taskRepo = new domain.repository.Task(mongoose.connection);
-
-    const project = {
-        typeOf: 'Project', id: ''
-    };
-
-    const now = new Date();
-
-    const events = await eventRepo.search({
-        typeOf: domain.factory.eventType.ScreeningEvent,
-        project: { id: { $eq: project.id } },
-        startFrom: now
-        // startFrom: moment().add(-1, 'day').toDate(),
-        // startThrough: moment().add(1, 'day').toDate(),
-        // startThrough: now
-    });
-
-    // console.log(events);
-    console.log(events.length);
-    // return;
-
-    const tasks = [];
-    for (const event of events) {
-        const aggregateTask = {
-            name: domain.factory.taskName.AggregateScreeningEvent,
-            project: project,
-            status: domain.factory.taskStatus.Ready,
-            runsAt: new Date(),
-            remainingNumberOfTries: 1,
-            numberOfTried: 0,
-            executionResults: [],
-            data: { typeOf: event.typeOf, id: event.id }
-        };
-        tasks.push(aggregateTask);
-        console.log('task created', event.id);
-    }
-
-    console.log('creating...', tasks.length, 'tasks');
-    const result = await taskRepo.taskModel.insertMany(tasks, { ordered: false, rawResult: true });
-    console.log('result:', { ...result, ops: undefined, insertedIds: undefined });
-}
-
-main()
-    .then(() => {
-        console.log('success!');
-    })
-    .catch((err) => {
-        console.error(err);
-        process.exit(1);
-    });

package/example/aggregateOnProject.js

@@ -1,34 +0,0 @@
-const domain = require('../lib');
-const moment = require('moment-timezone');
-const mongoose = require('mongoose');
-const redis = require('redis');
-
-async function main() {
-    await mongoose.connect(process.env.MONGOLAB_URI);
-
-    const reservationRepo = new domain.repository.Reservation(mongoose.connection);
-    const pojectRepo = new domain.repository.Project(mongoose.connection);
-    const taskRepo = new domain.repository.Task(mongoose.connection);
-
-    await domain.service.aggregation.project.aggregate({
-        project: {
-            id: 'cinerino'
-        },
-        reservationFor: {
-            startFrom: moment()
-                .tz('Asia/Tokyo')
-                .startOf('month')
-                .toDate(),
-            startThrough: moment()
-                .tz('Asia/Tokyo')
-                .endOf('month')
-                .toDate()
-        }
-    })({
-        reservation: reservationRepo,
-        project: pojectRepo,
-        task: taskRepo
-    });
-}
-
-main().then(console.log).catch(console.error);

package/example/aggregateScreeningEvent.js

@@ -1,39 +0,0 @@
-const domain = require('../lib');
-const mongoose = require('mongoose');
-const redis = require('redis');
-
-async function main() {
-    await mongoose.connect(process.env.MONGOLAB_URI);
-
-    const client = redis.createClient({
-        host: process.env.REDIS_HOST,
-        port: process.env.REDIS_PORT,
-        password: process.env.REDIS_KEY
-    });
-
-    const actionRepo = new domain.repository.Action(mongoose.connection);
-    const eventRepo = new domain.repository.Event(mongoose.connection);
-    const offerRepo = new domain.repository.Offer(mongoose.connection);
-    const placeRepo = new domain.repository.Place(mongoose.connection);
-    const reservationRepo = new domain.repository.Reservation(mongoose.connection);
-    const pojectRepo = new domain.repository.Project(mongoose.connection);
-    const taskRepo = new domain.repository.Task(mongoose.connection);
-    const eventAvailabilityRepo = new domain.repository.itemAvailability.ScreeningEvent(client);
-    const offerRateLimitRepo = new domain.repository.rateLimit.Offer(client);
-
-    await domain.service.aggregation.event.aggregateScreeningEvent({
-        id: '201228001001011545'
-    })({
-        action: actionRepo,
-        event: eventRepo,
-        offer: offerRepo,
-        place: placeRepo,
-        reservation: reservationRepo,
-        eventAvailability: eventAvailabilityRepo,
-        offerRateLimit: offerRateLimitRepo,
-        project: pojectRepo,
-        task: taskRepo
-    });
-}
-
-main().then(console.log).catch(console.error);

package/example/assetTransaction/invalidatePaymentUrl.js

@@ -1,83 +0,0 @@
-const domain = require('../../lib');
-const mongoose = require('mongoose');
-const redis = require('redis');
-
-const projectId = 'cinerino';
-const paymentMethodType = 'PayPay';
-
-async function main() {
-    const client = redis.createClient({
-        host: process.env.REDIS_HOST,
-        port: process.env.REDIS_PORT,
-        password: process.env.REDIS_KEY
-    });
-    await mongoose.connect(process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const actionRepo = new domain.repository.Action(mongoose.connection);
-    const productRepo = new domain.repository.Product(mongoose.connection);
-    const projectRepo = new domain.repository.Project(mongoose.connection);
-    const sellerRepo = new domain.repository.Seller(mongoose.connection);
-    const taskRepo = new domain.repository.Task(mongoose.connection);
-    const transactionRepo = new domain.repository.Transaction(mongoose.connection);
-
-    const transactionNumberRepo = new domain.repository.TransactionNumber(client);
-
-    const sellers = await sellerRepo.search({ project: { id: { $eq: projectId } }, limit: 1 });
-    const seller = sellers[0];
-
-    let transactionNumber = await transactionNumberRepo.publishByTimestamp({
-        project: { id: projectId },
-        startDate: new Date()
-    });
-
-    const { paymentMethodId, paymentUrl } = await domain.service.transaction.pay.publishPaymentUrl({
-        project: { id: projectId },
-        typeOf: domain.factory.transactionType.Pay,
-        transactionNumber,
-        agent: { typeOf: 'Person', name: 'サンプル決済者名称' },
-        recipient: { typeOf: seller.typeOf, name: seller.name, id: seller.id },
-        object: {
-            typeOf: domain.factory.service.paymentService.PaymentServiceType.CreditCard,
-            paymentMethod: {
-                typeOf: paymentMethodType,
-                amount: 10,
-                additionalProperty: [],
-                method: "1",
-                creditCard: {
-                    token: 'x'
-                }
-            }
-        }
-    })({
-        product: productRepo,
-        project: projectRepo,
-        seller: sellerRepo,
-    });
-    console.log('published', paymentMethodId, paymentUrl);
-    // return;
-
-    await domain.service.transaction.pay.invalidatePaymentUrl({
-        project: { id: projectId },
-        typeOf: domain.factory.actionType.RefundAction,
-        agent: { typeOf: seller.typeOf, name: seller.name, id: seller.id },
-        recipient: { typeOf: 'Person', name: 'サンプル決済者名称' },
-        object: [{
-            typeOf: domain.factory.service.paymentService.PaymentServiceType.CreditCard,
-            paymentMethod: {
-                typeOf: paymentMethodType,
-                paymentMethodId
-            },
-            refundFee: 0
-        }]
-    })({
-        action: actionRepo,
-        product: productRepo,
-        project: projectRepo,
-        seller: sellerRepo,
-        task: taskRepo,
-        transaction: transactionRepo
-    });
-    console.log('invalidated');
-}
-
-main().then(console.log).catch(console.error);

package/example/assetTransaction/payCreditCard.js

@@ -1,90 +0,0 @@
-const domain = require('../../lib');
-const creditCardPayment = require('../../lib/service/payment/creditCard');
-const mongoose = require('mongoose');
-const redis = require('redis');
-
-const projectId = 'cinerino';
-const paymentMethodType = 'PayPay';
-
-async function main() {
-    const client = redis.createClient({
-        host: process.env.REDIS_HOST,
-        port: process.env.REDIS_PORT,
-        password: process.env.REDIS_KEY
-    });
-    await mongoose.connect(process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const actionRepo = new domain.repository.Action(mongoose.connection);
-    const productRepo = new domain.repository.Product(mongoose.connection);
-    const projectRepo = new domain.repository.Project(mongoose.connection);
-    const sellerRepo = new domain.repository.Seller(mongoose.connection);
-    const taskRepo = new domain.repository.Task(mongoose.connection);
-    const transactionRepo = new domain.repository.Transaction(mongoose.connection);
-
-    const transactionNumberRepo = new domain.repository.TransactionNumber(client);
-
-    const sellers = await sellerRepo.search({ project: { id: { $eq: projectId } }, limit: 1 });
-    const seller = sellers[0];
-
-    const { paymentMethodId, paymentUrl } = await creditCardPayment.payCreditCard({
-        "project": {
-            "typeOf": "Project",
-            "id": "cinerino"
-        },
-        "typeOf": "PayAction",
-        "object": [
-            {
-                "typeOf": "CreditCard",
-                "paymentMethod": {
-                    "additionalProperty": [],
-                    "name": "PayPay",
-                    "paymentMethodId": "581695954601658",
-                    "totalPaymentDue": {
-                        "typeOf": "MonetaryAmount",
-                        "currency": "JPY",
-                        "value": 1800
-                    },
-                    "typeOf": "PayPay",
-                    "accountId": ""
-                }
-            }
-        ],
-        "agent": {
-            "typeOf": "WebApplication",
-        },
-        "potentialActions": {
-        },
-        "recipient": {
-            "name": {
-            },
-            "project": {
-                "id": "cinerino",
-                "typeOf": "Project"
-            },
-            "typeOf": "Corporation"
-        },
-        "purpose": {
-            "project": {
-                "typeOf": "Project",
-                "id": "cinerino"
-            },
-            "typeOf": "Order",
-            "confirmationNumber": "1385",
-            "orderNumber": "CIN4-3019797-2905243",
-            "price": 1800,
-            "priceCurrency": "JPY",
-            "orderDate": "2021-07-27T08:19:36.490Z"
-        }
-    })({
-        action: actionRepo,
-        product: productRepo,
-        project: projectRepo,
-        seller: sellerRepo,
-        task: taskRepo
-
-    });
-    console.log('published', paymentMethodId, paymentUrl);
-
-}
-
-main().then(console.log).catch(console.error);

package/example/assetTransaction/searchGMOTrade.js

@@ -1,24 +0,0 @@
-const domain = require('../../lib');
-const mongoose = require('mongoose');
-
-async function main() {
-    await mongoose.connect(process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const productRepo = new domain.repository.Product(mongoose.connection);
-    const sellerRepo = new domain.repository.Seller(mongoose.connection);
-    const assetTransactionRepo = new domain.repository.AssetTransaction(mongoose.connection);
-
-    const result = await domain.service.transaction.pay.searchGMOTrade({
-        transactionNumber: '020518441863622'
-    })({
-        product: productRepo,
-        seller: sellerRepo,
-        assetTransaction: assetTransactionRepo,
-    });
-    console.log(result);
-    // return;
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

package/example/cleanOwnershipInfos.js

@@ -1,46 +0,0 @@
-const moment = require('moment');
-const mongoose = require('mongoose');
-const domain = require('../');
-
-async function main() {
-    await mongoose.connect(process.env.MONGOLAB_URI);
-
-    const now = new Date();
-
-    const ownershipInfoRepo = new domain.repository.OwnershipInfo(mongoose.connection);
-
-    let result;
-
-    const conditions = {
-        'project.id': {
-            $exists: true,
-            $eq: 'xxx'
-        },
-        ownedFrom: {
-            $exists: true,
-            $lt: now
-        },
-        ownedThrough: {
-            $exists: true,
-            $lt: now
-        },
-        'typeOfGood.typeOf': {
-            $exists: true,
-            $eq: 'ProgramMembership'
-        }
-    };
-    result = await ownershipInfoRepo.ownershipInfoModel.countDocuments(conditions)
-        .exec();
-    result = await ownershipInfoRepo.ownershipInfoModel.deleteMany(conditions)
-        .exec();
-    console.log('ownershipInfos deleted', result);
-
-    // await mongoose.disconnect();
-}
-
-main().then(() => {
-    console.log('success!');
-}).catch((error) => {
-    console.error(error);
-    process.exit(1);
-});

package/example/cleanTasks.js

@@ -1,34 +0,0 @@
-const moment = require('moment');
-const mongoose = require('mongoose');
-const domain = require('../');
-
-async function main() {
-    await mongoose.connect(process.env.MONGOLAB_URI);
-
-    const now = new Date();
-    const startThrough = moment(now)
-        .add(-7, 'days')
-        .toDate();
-
-    console.log('deleting...startThrough:', startThrough);
-
-    const taskRepo = new domain.repository.Task(mongoose.connection);
-
-    let result;
-
-    result = await taskRepo.taskModel.deleteMany({
-        status: { $in: [domain.factory.taskStatus.Aborted, domain.factory.taskStatus.Executed] },
-        runsAt: { $lt: startThrough }
-    })
-        .exec();
-    console.log('tasks deleted', result);
-
-    // await mongoose.disconnect();
-}
-
-main().then(() => {
-    console.log('success!');
-}).catch((error) => {
-    console.error(error);
-    process.exit(1);
-});

package/example/copyRedisKeys.js

@@ -1,96 +0,0 @@
-const domain = require('../lib');
-
-async function main() {
-
-    const client = domain.redis.createClient({
-        host: process.env.REDIS_HOST,
-        port: process.env.REDIS_PORT,
-        password: process.env.REDIS_KEY,
-        tls: { servername: process.env.REDIS_HOST }
-    });
-
-    const newClient = domain.redis.createClient({
-        host: process.env.NEW_REDIS_HOST,
-        port: process.env.NEW_REDIS_PORT,
-        password: process.env.NEW_REDIS_KEY
-    });
-
-    client.keys('chevre:itemAvailability:screeningEvent:*', async (err, reply) => {
-        console.log(err, reply.length, 'keys found');
-        const targetKeys = reply;
-
-        await Promise.all(targetKeys.map(async (targetKey) => {
-            const newKey = targetKey;
-
-            return new Promise((resolve) => {
-                client.hgetall(targetKey, (err, reply) => {
-                    console.log('reply:', reply);
-                    if (err !== null) {
-                        reject(err);
-                    } else {
-                        if (reply !== null) {
-                            client.ttl(targetKey, (ttlErr, ttl) => {
-                                console.log('ttl:', ttl);
-                                const args = Object.keys(reply)
-                                    .reduce(
-                                        (a, b) => {
-                                            return [...a, b, reply[b]];
-                                        },
-                                        []
-                                    );
-                                console.log(args.length, 'args ready');
-
-                                newClient.multi()
-                                    .hmset(newKey, ...args)
-                                    .expire(newKey, ttl)
-                                    .exec((hmsetErr, reply) => {
-                                        console.log('hmset result:', hmsetErr, reply);
-                                        resolve();
-                                    });
-                            });
-                        } else {
-                            console.error('targetKey not found');
-                        }
-                    }
-                });
-            });
-        }))
-    });
-
-    client.keys('chevre:reservationNumber:*', async (err, reply) => {
-        console.log(err, reply.length, 'keys found');
-        const targetKeys = reply;
-
-        await Promise.all(targetKeys.map(async (targetKey) => {
-            const newKey = targetKey;
-
-            return new Promise((resolve) => {
-                client.get(targetKey, (err, reply) => {
-                    console.log('reply:', reply);
-                    if (err !== null) {
-                        reject(err);
-                    } else {
-                        if (reply !== null) {
-                            client.ttl(targetKey, (ttlErr, ttl) => {
-                                console.log('ttl:', ttl);
-                                const args = reply;
-
-                                newClient.multi()
-                                    .set(newKey, args)
-                                    .expire(newKey, ttl)
-                                    .exec((setErr, reply) => {
-                                        console.log('set result:', setErr, reply);
-                                        resolve();
-                                    });
-                            });
-                        } else {
-                            console.error('targetKey not found');
-                        }
-                    }
-                });
-            });
-        }))
-    });
-}
-
-main().then(console.log).catch(console.error);

package/example/createManyTasks.js

@@ -1,42 +0,0 @@
-const chevre = require('../lib/index');
-const mongoose = require('mongoose');
-
-async function main() {
-    await mongoose.connect(process.env.MONGOLAB_URI);
-
-    const taskRepo = new chevre.repository.Task(mongoose.connection);
-
-    const result = await taskRepo.saveMany([
-        {
-            project: { typeOf: 'Project', id: 'cinerino' },
-            name: 'aggregateScreeningEvent',
-            status: 'Ready',
-            runsAt: new Date(),
-            remainingNumberOfTries: 1,
-            numberOfTried: 0,
-            executionResults: [],
-            data: {
-                id: 'eventId'
-            }
-        },
-        {
-            project: { typeOf: 'Project', id: 'cinerino' },
-            name: 'aggregateScreeningEvent',
-            status: 'Ready',
-            runsAt: new Date(),
-            remainingNumberOfTries: 1,
-            numberOfTried: 0,
-            executionResults: [],
-            data: {
-                id: 'eventId'
-            }
-        }
-    ]);
-
-    console.log(result);
-    console.log(result.length, 'saved');
-}
-
-main()
-    .then()
-    .catch(console.error);

package/example/createSeats.js

@@ -1,48 +0,0 @@
-const fs = require('fs');
-
-const columns = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W'];
-const rows = [
-    { column: 'A', min: 4, max: 22 },
-    { column: 'B', min: 4, max: 22 },
-    { column: 'C', min: 3, max: 23 },
-    { column: 'D', min: 3, max: 23 },
-    { column: 'E', min: 3, max: 23 },
-    { column: 'F', min: 2, max: 24 },
-    { column: 'G', min: 2, max: 24 },
-    { column: 'H', min: 1, max: 24 },
-    { column: 'I', min: 1, max: 24 },
-    { column: 'J', min: 1, max: 24 },
-    { column: 'K', min: 1, max: 24 },
-    { column: 'L', min: 1, max: 24 },
-    { column: 'M', min: 1, max: 24 },
-    { column: 'N', min: 1, max: 24 },
-    { column: 'O', min: 1, max: 24 },
-    { column: 'P', min: 1, max: 24 },
-    { column: 'Q', min: 1, max: 24 },
-    { column: 'R', min: 1, max: 24 },
-    { column: 'S', min: 4, max: 21 },
-    { column: 'T', min: 4, max: 21 },
-    { column: 'U', min: 4, max: 21 },
-    { column: 'V', min: 1, max: 24 },
-    { column: 'W', min: 1, max: 24 },
-];
-
-const seats = [];
-columns.forEach((column) => {
-    const row = rows.find((r) => r.column === column);
-
-    const seatsByRow = [];
-    for (let i = row.min; i <= row.max; i++) {
-        seatsByRow.push(
-            {
-                branchCode: `${column}-${i}`,
-                typeOf: 'Seat'
-            }
-        );
-    }
-
-    seats.push(...seatsByRow);
-});
-
-console.log(seats);
-fs.writeFileSync(`${__dirname}/createSeatsResult.json`, JSON.stringify(seats, null, '    '));