@chevre/domain 21.8.0-alpha.4 → 21.8.0-alpha.41

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/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,75 @@
+// 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;
+        try {
+            const aggregateOffer = await offerRepo.findAggregateOfferById({
+                project: { id: unitPriceOffer.project.id },
+                id: String(unitPriceOffer.id)
+            });
+            const offerByAggregateOffer = aggregateOffer.offers.shift();
+            // alreadyMigrated = true;
+            console.log(unitPriceOffer, offerByAggregateOffer);
+            if (util.isDeepStrictEqual(unitPriceOffer, offerByAggregateOffer)) {
+                alreadyMigrated = true;
+            }
+        } catch (error) {
+            // no op
+        }
+
+        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/searchOffersByCatalog.ts

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

package/example/src/chevre/searchOffersFromAggregateOffer.ts

@@ -0,0 +1,167 @@
+// 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: true });
+
+    const offerRepo = new chevre.repository.Offer(mongoose.connection);
+
+    const offers = await offerRepo.search(
+        {
+            limit: 10,
+            page: 1,
+            sort: {
+                'priceSpecification.price': 1,
+                identifier: 1
+            },
+            project: { id: { $eq: String(process.env.PROJECT_ID) } },
+            availability: { $eq: chevre.factory.itemAvailability.InStock },
+            itemOffered: {
+                typeOf: {
+                    // $eq: chevre.factory.product.ProductType.EventService
+                }
+            },
+            addOn: {
+                itemOffered: {
+                    /**
+                     * アドオンプロダクトID
+                     */
+                    id: {
+                        // $eq: ''
+                    }
+                }
+            },
+            availableAtOrFrom: {
+                id: {
+                    // $eq: ''
+                    // $in: string[]
+                }
+            },
+            eligibleMembershipType: {
+                /**
+                 * 適用メンバーシップ区分
+                 */
+                codeValue: {
+                    // $eq: 'Permit'
+                }
+            },
+            eligibleMonetaryAmount: {
+                /**
+                 * 適用通貨区分
+                 */
+                currency: {
+                    // $eq: 'Point'
+                }
+            },
+            eligibleSeatingType: {
+                /**
+                 * 適用座席区分
+                 */
+                codeValue: {
+                    // $eq: ''
+                }
+            },
+            hasMerchantReturnPolicy: {
+                id: {
+                    // $eq: ''
+                }
+            },
+            id: {
+                // $eq: '1001'
+                // $in: string[];
+            },
+            identifier: {
+                // $eq: '1001'
+                // $in: string[];
+                // $regex: '003'
+            },
+            name: {
+                // $regex: ''
+            },
+            priceSpecification: {
+                appliesToMovieTicket: {
+                    /**
+                     * 適用決済カード区分
+                     */
+                    serviceType: {
+                        /**
+                         * 適用決済カード区分が存在するかどうか
+                         */
+                        // $exists: boolean;
+                        // $eq: '01'
+                    },
+                    serviceOutput: {
+                        /**
+                         * 適用決済方法タイプ
+                         */
+                        typeOf: {
+                            // $eq: ''
+                            // $nin: string[];
+                        }
+                    }
+                },
+                price: {
+                    // $gte: 2000,
+                    // $lte: 2000
+                },
+                referenceQuantity: {
+                    value: {
+                        // $eq: 2
+                    }
+                },
+                accounting: {
+                    accountsReceivable: {
+                        // $gte: 1800,
+                        // $lte: 100
+                    },
+                    operatingRevenue: {
+                        codeValue: {
+                            // $eq: ''
+                            // $in: string[];
+                        }
+                    }
+                }
+            },
+            category: {
+                codeValue: {
+                    // $in: ['1']
+                }
+            }
+            /**
+             * 有効期間設定がない、あるいは、有効期間内
+             */
+            // onlyValid: true
+            // additionalProperty: {
+            //     $all: [
+            //         {
+            //             $elemMatch: {
+            //                 name: { $eq: 'nameForPrinting' },
+            //                 value: { $in: ['General'] }
+            //             }
+            //         }
+            //     ]
+            // }
+        },
+        {
+            id: 1,
+            identifier: 1,
+            name: 1,
+            alternateName: 1,
+            priceSpecification: 1,
+            project: 1
+        }
+    );
+    console.log(offers);
+    console.log(offers.map((offer) => {
+        return `${offer.project?.id} ${offer.identifier} ${offer.priceSpecification?.price} ${offer.name?.ja} ${offer.id}`;
+    }));
+    console.log(offers.length);
+    console.log('USE_AGGREGATE_OFFERS_AS_PRIMARY:', process.env.USE_AGGREGATE_OFFERS_AS_PRIMARY);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/sync2aggregateOffer.ts

@@ -0,0 +1,27 @@
+// 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.sync2aggregateOffer({
+        id: {
+            $in: ['1001']
+        },
+        project: {
+            id: String(process.env.PROJECT_ID)
+        },
+        isDeleted: false,
+        typeOf: chevre.factory.offerType.AggregateOffer
+    });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);