@chevre/domain 21.8.0-alpha.6 → 21.8.0-alpha.60

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,23 @@
+// 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);
+}
+
+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/migrateAggregateOffers.ts

@@ -0,0 +1,89 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+import * as util from 'util';
+
+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 offerRepo = new chevre.repository.Offer(mongoose.connection);
+
+    const cursor = offerRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id }
+        },
+        {
+            __v: 0,
+            createdAt: 0,
+            updatedAt: 0,
+            offers: 0,
+            availableAddOn: 0
+        }
+    );
+    console.log('offers found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const { _id, ...unitPriceOffer } =
+            <chevre.factory.unitPriceOffer.IUnitPriceOffer & { _id: string }>doc.toObject();
+
+        let alreadyMigrated = false;
+        const aggregateOffer = await offerRepo.findAggregateOfferById({
+            project: { id: unitPriceOffer.project.id },
+            id: String(unitPriceOffer.id)
+        });
+        let offerByAggregateOffer = aggregateOffer.offers.shift();
+        // alreadyMigrated = true;
+        console.log(unitPriceOffer, offerByAggregateOffer);
+
+        // 比較のために補完
+        if (offerByAggregateOffer !== undefined) {
+            offerByAggregateOffer = {
+                ...offerByAggregateOffer,
+                additionalProperty: (Array.isArray(offerByAggregateOffer.additionalProperty))
+                    ? offerByAggregateOffer.additionalProperty : [],
+                addOn: (Array.isArray(offerByAggregateOffer.addOn))
+                    ? offerByAggregateOffer.addOn : [],
+                availableAtOrFrom: (Array.isArray(offerByAggregateOffer.availableAtOrFrom))
+                    ? offerByAggregateOffer.availableAtOrFrom : []
+            };
+            // delete (<any>offerByAggregateOffer).$unset;
+        }
+
+        if (util.isDeepStrictEqual(unitPriceOffer, offerByAggregateOffer)) {
+            alreadyMigrated = true;
+        } else {
+            console.error(unitPriceOffer, offerByAggregateOffer);
+            throw new Error('not matched');
+        }
+
+        if (alreadyMigrated) {
+            console.log('already exist.', unitPriceOffer.project.id, unitPriceOffer.id, unitPriceOffer.identifier, i);
+        } else {
+            console.log('updating...', unitPriceOffer.project.id, unitPriceOffer.id, unitPriceOffer.identifier, i);
+            // await offerRepo.saveSyncTask({
+            //     project: { id: unitPriceOffer.project.id },
+            //     id: { $in: [String(unitPriceOffer.id)] },
+            //     identifier: { $in: [] },
+            //     isDeleted: false,
+            //     typeOf: chevre.factory.offerType.Offer,
+            //     options: { emitImmediately: false }
+            // });
+            updateCount += 1;
+            console.log('updated.', unitPriceOffer.project.id, unitPriceOffer.id, unitPriceOffer.identifier, i);
+        }
+    });
+
+    console.log(i, 'offers checked');
+    console.log(updateCount, 'offers updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

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/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/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/searchEventTicketOffers.ts

@@ -30,7 +30,8 @@ async function main() {
         validateOfferRateLimit: true,
         addSortIndex: true,
         limit: 100,
-        page: 1
+        page: 1,
+        useOffersAsPrimaryForcible: false
         // ...(typeof availableAtId === 'string') ? { store: { id: availableAtId } } : undefined
     })({
         event: eventRepo,
@@ -39,6 +40,7 @@ async function main() {
         priceSpecification: priceSpecificationRepo,
         product: productRepo
     });
+    console.log(ticketOffers);
     console.log(ticketOffers.map((o) => o.sortIndex));
     console.log(ticketOffers.length);
 }

package/example/src/chevre/searchEvents.ts

@@ -12,15 +12,17 @@ async function main() {
 
     const events = await eventRepo.search(
         {
-            limit: 100,
-            page: 1,
-            sort: { startDate: 1 },
-            typeOf: chevre.factory.eventType.ScreeningEvent,
-            project: { id: { $eq: PROJECT_ID } },
-            id: { $eq: 'al6aff83y' }
+            // limit: 100,
+            // page: 1,
+            // sort: { startDate: 1 },
+            // typeOf: chevre.factory.eventType.ScreeningEvent,
+            // project: { id: { $eq: PROJECT_ID } },
+            id: { $eq: 'al6aff83y' },
+            typeOfIn: [chevre.factory.eventType.Event, chevre.factory.eventType.ScreeningEvent]
         },
         {
-            name: 1
+            _id: 1
+            // name: 1
         }
     );
     console.log(events);

package/example/src/chevre/searchOffersByCatalog.ts

@@ -10,17 +10,21 @@ async function main() {
     const offerRepo = new chevre.repository.Offer(mongoose.connection);
 
     const { offers } = await offerRepo.findOffersByOfferCatalogId({
-        ids: ['al96nqj7z', 'xxx', '1001'],
-        // ids: ['xx', 'xxx'],
+        limit: 100,
+        page: 1,
+        // ids: ['xx', 'xxx', '1001', '901'],
         offerCatalog: {
             id: '0001'
-            // id: 'xxx'
         },
         excludeAppliesToMovieTicket: false,
-        sort: true
+        useOffersAsPrimaryForcible: false
     });
-    console.log(offers.map((o) => o.id));
+    // console.log(offers);
+    console.log(offers.map((offer) => {
+        return `${offer.project?.id} ${offer.identifier} ${offer.priceSpecification?.price} ${offer.name?.ja} ${offer.id} ${offer.offerIndex}`;
+    }));
     console.log(offers.length);
+    console.log('USE_AGGREGATE_OFFERS_AS_PRIMARY:', process.env.USE_AGGREGATE_OFFERS_AS_PRIMARY);
 }
 
 main()