@chevre/domain 21.8.0-alpha.9 → 21.9.0-alpha.0

package/example/src/chevre/countOffers.ts

@@ -0,0 +1,32 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const offerRepo = new chevre.repository.Offer(mongoose.connection);
+
+    const result = await offerRepo.count(
+        {
+            project: { id: { $eq: String(process.env.PROJECT_ID) } },
+            availability: { $eq: chevre.factory.itemAvailability.InStock },
+            id: {
+                // $eq: '1001'
+                // $in: string[];
+            },
+            identifier: {
+                // $eq: '1001'
+                // $in: string[];
+                // $regex: '003'
+            }
+        }
+    );
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/findItemListElementByCatalogId.ts

@@ -0,0 +1,30 @@
+// 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 offerCatalogRepo = new chevre.repository.OfferCatalog(mongoose.connection);
+
+    const catalog = await offerCatalogRepo.findItemListElementById(
+        {
+            id: '0001',
+            project: { id: String(process.env.PROJECT_ID) }
+        }
+    );
+    console.log(catalog);
+    console.log(catalog.itemListElement.length);
+
+    const firstElement = await offerCatalogRepo.findFirstItemListElementById(
+        {
+            id: '0001'
+        }
+    );
+    console.log('firstElement:', firstElement);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/importOffersFromCOA.ts

@@ -16,6 +16,7 @@ async function main() {
 
     const categoryCodeRepo = new chevre.repository.CategoryCode(mongoose.connection);
     const offerRepo = new chevre.repository.Offer(mongoose.connection);
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
     const masterService = new chevre.COA.service.Master(
         {
             endpoint: chevre.credentials.coa.endpoint,
@@ -27,7 +28,12 @@ async function main() {
     await chevre.service.offer.event.importFromCOA({
         project,
         theaterCode: '120'
-    })({ categoryCode: categoryCodeRepo, offer: offerRepo, masterService });
+    })({
+        categoryCode: categoryCodeRepo,
+        offer: offerRepo,
+        task: taskRepo,
+        masterService
+    });
     console.log('imported');
 }
 

package/example/src/chevre/migrateOrderPaymentMethodIdentifier.ts

@@ -0,0 +1,81 @@
+// 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) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const orderRepo = new chevre.repository.Order(mongoose.connection);
+
+    const cursor = orderRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            // orderNumber: { $eq: 'KNR1-3961294-9087043' },
+            orderDate: {
+                $gte: moment()
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-12, 'months')
+                    .toDate()
+                // $lte: moment()
+                //     // tslint:disable-next-line:no-magic-numbers
+                //     .add(-6, 'months')
+                //     .toDate()
+            }
+        },
+        {
+            orderDate: 1,
+            orderNumber: 1,
+            project: 1,
+            paymentMethods: 1
+        }
+    );
+    console.log('orders found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const order: Pick<
+            chevre.factory.order.IOrder,
+            'orderDate' | 'orderNumber' | 'project' | 'paymentMethods'
+        > = doc.toObject();
+
+        const noPayment = order.paymentMethods.length === 0;
+        const alreadyMigrated = order.paymentMethods.every((invoice) => {
+            return typeof invoice.paymentMethod?.identifier === 'string'
+                && invoice.paymentMethod.identifier === invoice.typeOf;
+        });
+
+        if (noPayment) {
+            console.log('noPayment.', order.project.id, order.orderNumber, order.orderDate, i);
+        } else if (alreadyMigrated) {
+            console.log('already exist.', order.project.id, order.orderNumber, order.orderDate, i);
+        } else {
+            console.log('updating...', order.project.id, order.orderNumber, order.orderDate, i);
+            for (const invoice of order.paymentMethods) {
+                await orderRepo.fixPaymentMethodIdentifier({
+                    project: { id: order.project.id },
+                    orderNumber: order.orderNumber,
+                    invoice: {
+                        paymentMethodId: invoice.paymentMethodId,
+                        paymentMethod: { identifier: invoice.typeOf }
+                    }
+                });
+            }
+            updateCount += 1;
+            console.log('updated.', order.project.id, order.orderNumber, order.orderDate, i);
+        }
+    });
+
+    console.log(i, 'orders checked');
+    console.log(updateCount, 'orders updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migratePayTransactionPaymentMethodId.ts

@@ -0,0 +1,72 @@
+// 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) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
+
+    const cursor = assetTransactionRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.assetTransactionType.Pay },
+            // 'object.paymentMethodId': { $exists: false },
+            // 'project.id': { $eq: project.id },
+            startDate: {
+                $gte: moment()
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-12, 'months')
+                    .toDate()
+            }
+        },
+        {
+            typeOf: 1,
+            project: 1,
+            object: 1,
+            transactionNumber: 1,
+            startDate: 1
+        }
+    );
+    console.log('transactions found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const payTransaction: Pick<
+            chevre.factory.assetTransaction.pay.ITransaction,
+            'project' | 'object' | 'transactionNumber' | 'startDate' | 'typeOf'
+        > = doc.toObject();
+
+        const alreadyMigrated = typeof payTransaction.object.paymentMethodId === 'string'
+            && payTransaction.object.paymentMethodId === (<any>payTransaction.object.paymentMethod).paymentMethodId;
+
+        if (alreadyMigrated) {
+            console.log(
+                'already exist.',
+                payTransaction.project.id, payTransaction.typeOf, payTransaction.transactionNumber, payTransaction.startDate, i);
+        } else {
+            const paymentMethodIdentifier = (<any>payTransaction.object.paymentMethod).typeOf;
+            console.log(
+                'updating...',
+                payTransaction.project.id, payTransaction.typeOf, payTransaction.transactionNumber, payTransaction.startDate, i,
+                paymentMethodIdentifier);
+            updateCount += 1;
+            console.log(
+                'updated.',
+                payTransaction.project.id, payTransaction.typeOf, payTransaction.transactionNumber, payTransaction.startDate, i);
+        }
+    });
+
+    console.log(i, 'transactions checked');
+    console.log(updateCount, 'transactions updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migratePayTransactionPaymentMethodIdentifier.ts

@@ -0,0 +1,78 @@
+// 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) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
+
+    const cursor = assetTransactionRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.assetTransactionType.Pay },
+            // 'project.id': { $eq: project.id },
+            startDate: {
+                $gte: moment('2023-05-08T00:00:00Z')
+                    // tslint:disable-next-line:no-magic-numbers
+                    // .add(-12, 'months')
+                    .toDate(),
+                $lte: moment('2023-08-30T21:00:00Z')
+                    .toDate()
+            }
+        },
+        {
+            typeOf: 1,
+            project: 1,
+            object: 1,
+            transactionNumber: 1,
+            startDate: 1
+        }
+    );
+    console.log('transactions found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const payTransaction: Pick<
+            chevre.factory.assetTransaction.pay.ITransaction,
+            'project' | 'object' | 'transactionNumber' | 'startDate' | 'typeOf'
+        > = doc.toObject();
+
+        const alreadyMigrated = payTransaction.object.paymentMethod.identifier
+            === (<any>payTransaction.object.paymentMethod).typeOf;
+
+        if (alreadyMigrated) {
+            console.log(
+                'already exist.',
+                payTransaction.project.id, payTransaction.typeOf, payTransaction.transactionNumber, payTransaction.startDate,
+                i, updateCount);
+        } else {
+            const paymentMethodIdentifier = (<any>payTransaction.object.paymentMethod).typeOf;
+            console.log(
+                'updating...',
+                payTransaction.project.id, payTransaction.typeOf, payTransaction.transactionNumber, payTransaction.startDate, i,
+                paymentMethodIdentifier);
+            await assetTransactionRepo.migratePaymentMethodIdentifier({
+                transactionNumber: payTransaction.transactionNumber,
+                object: { paymentMethod: { identifier: paymentMethodIdentifier } }
+            });
+            updateCount += 1;
+            console.log(
+                'updated.',
+                payTransaction.project.id, payTransaction.typeOf, payTransaction.transactionNumber, payTransaction.startDate, i);
+        }
+    });
+
+    console.log(i, 'transactions checked');
+    console.log(updateCount, 'transactions updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/optimizeCatalogs.ts

@@ -0,0 +1,54 @@
+// 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 offerCatalogRepo = new chevre.repository.OfferCatalog(mongoose.connection);
+
+    const cursor = offerCatalogRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id }
+        },
+        {
+            __v: 0,
+            createdAt: 0,
+            updatedAt: 0
+        }
+    );
+    console.log('catalogs found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const { _id, ...offerCatalog } = <chevre.factory.offerCatalog.IOfferCatalog & { _id: string }>doc.toObject();
+
+        let itemListElementTypeOfEqOffer = false;
+        itemListElementTypeOfEqOffer = offerCatalog.itemListElement.every((element) => element.typeOf === chevre.factory.offerType.Offer);
+        if (!itemListElementTypeOfEqOffer) {
+            throw new Error(`itemListElementTypeOfEqOffer: false. ${offerCatalog.project.id} ${offerCatalog.id}`);
+        }
+
+        const itemOfferedKeys = Object.keys(offerCatalog.itemOffered);
+        console.log(itemOfferedKeys);
+        if (itemOfferedKeys.length > 1) {
+            console.log(itemOfferedKeys, offerCatalog.project.id, offerCatalog.id);
+            updateCount += 1;
+        }
+    });
+
+    console.log(i, 'catalogs checked');
+    console.log(updateCount, 'catalogs synced');
+
+    await offerCatalogRepo.optimizeAll();
+    console.log('optmized');
+}
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/processPay.ts

@@ -43,14 +43,13 @@ async function main() {
                 .toDate(),
             object: {
                 typeOf: chevre.factory.service.paymentService.PaymentServiceType.CreditCard,
-                id: '5f9a6986cc98a1eb13a90285',
+                id: 'xxx',
                 paymentMethod: {
                     amount: 1,
-                    // paymentMethodId?: string;
-                    typeOf: 'CreditCard',
+                    identifier: 'CreditCard',
                     method: '1',
                     creditCard: {
-                        memberId: 'a7909268-a584-425e-8212-d7d10f344093',
+                        memberId: 'xxx',
                         cardSeq: 91
                         // cardPass?: string;
                     }

package/example/src/chevre/publishPermitOwnershipInfoToken.ts

@@ -0,0 +1,56 @@
+// tslint:disable:no-console
+import * as jwt from 'jsonwebtoken';
+import { chevre } from '../../../lib/index';
+
+function getToken(params: {
+    expiresIn: number;
+    payload: chevre.factory.authorization.IOwnershipInfoAsObject;
+}) {
+    return async (__: {}) => {
+        // const now = new Date();
+
+        // const data = authorization.object;
+
+        return new Promise<string>((resolve, reject) => {
+            // 所有権を暗号化する
+            jwt.sign(
+                params.payload,
+                chevre.credentials.jwt.secret,
+                // params.secret,
+                {
+                    issuer: chevre.credentials.jwt.issuer,
+                    // issuer: params.issuer,
+                    expiresIn: params.expiresIn
+                },
+                (err, encoded) => {
+                    if (err instanceof Error) {
+                        reject(err);
+                    } else {
+                        if (typeof encoded !== 'string') {
+                            reject(new chevre.factory.errors.ServiceUnavailable('authorization.object cannot be signed unexpectedly'));
+                        } else {
+                            resolve(encoded);
+                        }
+                    }
+                }
+            );
+        });
+    };
+}
+
+getToken({
+    expiresIn: 2678400,
+    payload: {
+        typeOf: 'OwnershipInfo',
+        id: '',
+        typeOfGood: {
+            typeOf: chevre.factory.permit.PermitType.Permit,
+            identifier: 'xxxxxxxxxxxx',
+            issuedThrough: { id: '64f193ad5e79fe8a06ca3156', typeOf: chevre.factory.service.paymentService.PaymentServiceType.CreditCard }
+        }
+    }
+})({})
+    .then((token) => {
+        console.log('token:', token);
+    })
+    .catch(console.error);

package/example/src/chevre/pullAddOnsFromOffer.ts

@@ -0,0 +1,26 @@
+// 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 offerRepo = new chevre.repository.Offer(mongoose.connection);
+
+    const result = await offerRepo.pullAddOns({
+        project: { id: String(process.env.PROJECT_ID) },
+        addOn: {
+            itemOffered: {
+                id: {
+                    $in: ['xxx']
+                }
+            }
+        }
+    });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/pushIncludedInDataCatalog.ts

@@ -0,0 +1,47 @@
+// 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 aggregateOfferRepo = new chevre.repository.AggregateOffer(mongoose.connection);
+
+    await aggregateOfferRepo.pushIncludedInDataCatalog({
+        project: {
+            id: project.id
+        },
+        id: {
+            $in: ['1001']
+        },
+        $push: {
+            includedInDataCatalog: {
+                $each: [{ id: '0001' }]
+            }
+        }
+    });
+    console.log('pushed');
+
+    // const pullResult = await aggregateOfferRepo.pullIncludedInDataCatalog({
+    //     project: {
+    //         id: project.id
+    //     },
+    //     id: {
+    //         // $nin: ['1001']
+    //     },
+    //     $pull: {
+    //         includedInDataCatalog: {
+    //             $elemMatch: { id: { $eq: '0001' } }
+    //         }
+    //     }
+    // });
+    // console.log('pulled', pullResult);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/searchAggregateOffers.ts

@@ -0,0 +1,48 @@
+// 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 aggregateOfferRepo = new chevre.repository.AggregateOffer(mongoose.connection);
+
+    const offers = await aggregateOfferRepo.search(
+        {
+            limit: 10,
+            // page: 1,
+            project: { id: { $eq: String(process.env.PROJECT_ID) } },
+            availability: { $eq: chevre.factory.itemAvailability.InStock },
+            itemOffered: { typeOf: { $eq: chevre.factory.product.ProductType.EventService } },
+            // identifier: { $eq: '901' },
+            sort: {
+                'priceSpecification.price': 1,
+                identifier: 1
+            }
+        },
+        {
+            id: 1,
+            identifier: 1,
+            name: 1,
+            priceSpecification: 1
+        }
+    );
+    console.log(offers);
+    console.log(offers[0]?.offers);
+    console.log(offers.map((offer) => {
+        return `${offer.project.id} ${(<any>offer).offerCount} ${offer.offers[0].identifier} ${offer.offers[0].name.ja} ${offer.offers[0].priceSpecification.price}`;
+    }));
+    console.log(offers.length);
+
+    const aggregateOfferCount = await aggregateOfferRepo.count({
+        project: { id: { $eq: String(process.env.PROJECT_ID) } },
+        availability: { $eq: chevre.factory.itemAvailability.InStock },
+        itemOffered: { typeOf: { $eq: chevre.factory.product.ProductType.EventService } }
+    });
+    console.log('aggregateOfferCount:', aggregateOfferCount);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchAvaialbleAppliesToMovieTicketByOfferCatalogId.ts

@@ -0,0 +1,26 @@
+// 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 offerRepo = new chevre.repository.Offer(mongoose.connection);
+
+    const result = await offerRepo.searchAvaialbleAppliesToMovieTicketByOfferCatalogId({
+        limit: 10,
+        page: 1,
+        subOfferCatalog: {
+            id: '0001'
+        },
+        excludeAppliesToMovieTicket: false,
+        unacceptedPaymentMethod: []
+    });
+    console.log(result);
+    console.log(result.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchEventTicketOffers.ts

@@ -16,11 +16,12 @@ async function main() {
     });
     await client.connect();
 
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     const eventRepo = new chevre.repository.Event(mongoose.connection);
     const priceSpecificationRepo = new chevre.repository.PriceSpecification(mongoose.connection);
     const offerRepo = new chevre.repository.Offer(mongoose.connection);
+    const offerCatalogRepo = new chevre.repository.OfferCatalog(mongoose.connection);
     const offerRateLimitRepo = new chevre.repository.rateLimit.Offer(client);
     const productRepo = new chevre.repository.Product(mongoose.connection);
 
@@ -29,16 +30,19 @@ async function main() {
         onlyValid: true,
         validateOfferRateLimit: true,
         addSortIndex: true,
+        useIncludeInDataCatalog: true,
         limit: 100,
         page: 1
         // ...(typeof availableAtId === 'string') ? { store: { id: availableAtId } } : undefined
     })({
         event: eventRepo,
         offer: offerRepo,
+        offerCatalog: offerCatalogRepo,
         offerRateLimit: offerRateLimitRepo,
         priceSpecification: priceSpecificationRepo,
         product: productRepo
     });
+    console.log(ticketOffers);
     console.log(ticketOffers.map((o) => o.sortIndex));
     console.log(ticketOffers.length);
 }

package/example/src/chevre/searchEvents.ts

@@ -6,21 +6,23 @@ import { chevre } from '../../../lib/index';
 const PROJECT_ID = process.env.PROJECT_ID;
 
 async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     const eventRepo = new chevre.repository.Event(mongoose.connection);
 
     const events = await eventRepo.search(
         {
-            limit: 100,
-            page: 1,
-            sort: { startDate: 1 },
-            typeOf: chevre.factory.eventType.ScreeningEvent,
+            // limit: 100,
+            // page: 1,
+            // sort: { startDate: 1 },
+            // typeOf: chevre.factory.eventType.ScreeningEvent,
             project: { id: { $eq: PROJECT_ID } },
-            id: { $eq: 'al6aff83y' }
+            id: { $eq: 'al6aff83y' },
+            typeOfIn: [chevre.factory.eventType.Event, chevre.factory.eventType.ScreeningEvent]
         },
         {
-            name: 1
+            _id: 1
+            // name: 1
         }
     );
     console.log(events);