@chevre/domain 21.29.0-alpha.9 → 21.29.0

package/example/src/chevre/migrateCancelReservationObject.ts

@@ -0,0 +1,71 @@
+// 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 assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
+
+    const cursor = assetTransactionRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.assetTransactionType.CancelReservation }
+            // 'project.id': { $ne: EXCLUDED_PROJECT_ID }
+        },
+        {}
+    );
+    console.log('assetTransactions found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const assetTransaction: chevre.factory.assetTransaction.cancelReservation.ITransaction = doc.toObject();
+
+        const alreadyMigrated = assetTransaction.object.typeOf === chevre.factory.reservationType.ReservationPackage
+            && typeof assetTransaction.object.reservationNumber === 'string'
+            && assetTransaction.object.reservationNumber.length > 0;
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.',
+                assetTransaction.project.id, assetTransaction.typeOf, assetTransaction.transactionNumber, assetTransaction.startDate, i);
+        } else {
+            let reservationNumber: string | undefined;
+            if (typeof assetTransaction.object.transaction?.transactionNumber === 'string') {
+                reservationNumber = assetTransaction.object.transaction.transactionNumber;
+            } else if (typeof assetTransaction.object.reservations?.[0].reservationNumber === 'string') {
+                reservationNumber = assetTransaction.object.reservations[0].reservationNumber;
+            }
+            if (typeof reservationNumber !== 'string') {
+                console.error(
+                    'reservationNumber not found.',
+                    assetTransaction.project.id,
+                    assetTransaction.typeOf, assetTransaction.transactionNumber, assetTransaction.startDate, i);
+                throw new Error('reservationNumber not found');
+            }
+            console.log(
+                'updating assetTransaction...',
+                assetTransaction.project.id,
+                assetTransaction.typeOf, assetTransaction.transactionNumber, assetTransaction.startDate, reservationNumber, i);
+            await assetTransactionRepo.migrateObjectReservationNumber({
+                id: assetTransaction.id,
+                object: { reservationNumber }
+            });
+            updateCount += 1;
+            console.log(
+                'updated.',
+                assetTransaction.project.id,
+                assetTransaction.typeOf, assetTransaction.transactionNumber, assetTransaction.startDate, i);
+        }
+    });
+
+    console.log(i, 'assetTransactions checked');
+    console.log(updateCount, 'assetTransactions updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/{migrateOrderAcceptedOfferSerialNumber.ts → migrateOrderAcceptedOfferReservedTicketIdentifier.ts}

@@ -6,7 +6,15 @@ import { chevre } from '../../../lib/index';
 
 // const project = { id: String(process.env.PROJECT_ID) };
 
-// tslint:disable-next-line:max-func-body-length
+function createReservedTicketIdentifier(offer: chevre.factory.order.IAcceptedOffer<chevre.factory.order.IReservation>) {
+    let reservedTicketIdentifierShouldBe = `${offer.itemOffered.reservationFor.id}:${offer.itemOffered.id}`;
+    if (typeof offer.itemOffered.reservedTicket.ticketedSeat?.seatNumber === 'string') {
+        reservedTicketIdentifierShouldBe = `${offer.itemOffered.reservationFor.id}:${offer.itemOffered.reservedTicket.ticketedSeat.seatSection}:${offer.itemOffered.reservedTicket.ticketedSeat.seatNumber}`;
+    }
+
+    return reservedTicketIdentifierShouldBe;
+}
+
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
@@ -15,19 +23,14 @@ async function main() {
 
     const cursor = orderRepo.getCursor(
         {
-            // 'acceptedOffers.serialNumber': { $exists: false },
-            'acceptedOffers.itemOffered.reservationNumber': { $exists: true },
+            'acceptedOffers.itemOffered.typeOf': { $exists: true, $eq: chevre.factory.reservationType.EventReservation },
             // 'project.id': { $eq: project.id },
-            // orderNumber: { $eq: 'KOB1-3749861-4732433' },
+            // orderNumber: { $eq: 'ASK8-6367700-4398526' },
             orderDate: {
                 $gte: moment()
                     // tslint:disable-next-line:no-magic-numbers
-                    .add(-12, 'months')
+                    .add(-13, 'months')
                     .toDate()
-                // $lte: moment()
-                //     // tslint:disable-next-line:no-magic-numbers
-                //     .add(-6, 'months')
-                //     .toDate()
             }
         },
         {
@@ -45,27 +48,35 @@ async function main() {
         i += 1;
         const order: Pick<
             chevre.factory.order.IOrder,
-            'orderDate' | 'orderNumber' | 'project' | 'paymentMethods'
+            'orderDate' | 'orderNumber' | 'project'
         > & {
             acceptedOffers: chevre.factory.order.IAcceptedOffer<chevre.factory.order.IReservation>[];
         } = doc.toObject();
 
         const alreadyMigrated = order.acceptedOffers.every((offer) => {
-            return typeof offer.serialNumber === 'string'
-                && offer.serialNumber.length > 0
-                && offer.itemOffered.reservationNumber === offer.serialNumber;
+            const reservedTicketIdentifierShouldBe = createReservedTicketIdentifier(offer);
+
+            return typeof offer.itemOffered.reservedTicket.identifier === 'string'
+                && offer.itemOffered.reservedTicket.identifier.length > 0
+                && offer.itemOffered.reservedTicket.identifier === reservedTicketIdentifierShouldBe;
         });
 
         if (alreadyMigrated) {
             console.log('already exist.', order.project.id, order.orderNumber, order.orderDate, i);
         } else {
             for (const offer of order.acceptedOffers) {
-                console.log('updating...', order.project.id, order.orderNumber, order.orderDate, offer.itemOffered.reservationNumber, i);
-                await acceptedOfferRepo.fixSerialNumber({
+                const reservedTicketIdentifierShouldBe = createReservedTicketIdentifier(offer);
+                console.log(
+                    'updating...',
+                    order.project.id, order.orderNumber, order.orderDate, offer.itemOffered.id, reservedTicketIdentifierShouldBe, i);
+                await acceptedOfferRepo.fixReservedTicketIdentifier({
                     project: { id: order.project.id },
                     orderNumber: order.orderNumber,
                     acceptedOffers: {
-                        serialNumber: offer.itemOffered.reservationNumber
+                        itemOffered: {
+                            id: offer.itemOffered.id,
+                            reservedTicket: { identifier: reservedTicketIdentifierShouldBe }
+                        }
                     }
                 });
             }

package/example/src/chevre/migratePayTransactionReservedTicketIdentifier.ts

@@ -0,0 +1,95 @@
+// 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) };
+
+function createReservedTicketIdentifier(movieTicket: chevre.factory.action.trade.pay.IMovieTicket) {
+    return `${movieTicket.serviceOutput.reservationFor.id}:${movieTicket.serviceOutput.reservedTicket.ticketedSeat.seatSection}:${movieTicket.serviceOutput.reservedTicket.ticketedSeat.seatNumber}`;
+}
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
+
+    const cursor = assetTransactionRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.assetTransactionType.Pay },
+            startDate: {
+                $gte: moment()
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-3, 'months')
+                    .toDate()
+            }
+            // 'project.id': { $eq: project.id },
+            // transactionNumber: { $exists: true, $eq: '642463069394964' }
+        },
+        {
+            startDate: 1,
+            transactionNumber: 1,
+            project: 1,
+            object: 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,
+            'startDate' | 'transactionNumber' | 'project' | 'object'
+        > = doc.toObject();
+
+        const movieTicketsInTransaction = payTransaction.object.paymentMethod.movieTickets;
+        const alreadyMigrated = (!Array.isArray(movieTicketsInTransaction)) || movieTicketsInTransaction.every((movieTicket) => {
+            const reservedTicketIdentifierShouldBe = createReservedTicketIdentifier(movieTicket);
+
+            return typeof movieTicket.serviceOutput.reservedTicket.identifier === 'string'
+                && movieTicket.serviceOutput.reservedTicket.identifier.length > 0
+                && movieTicket.serviceOutput.reservedTicket.identifier === reservedTicketIdentifierShouldBe;
+        });
+
+        if (alreadyMigrated) {
+            console.log('already exist.', payTransaction.project.id, payTransaction.transactionNumber, payTransaction.startDate, i);
+        } else {
+            const newMovieTickets: chevre.factory.action.trade.pay.IMovieTicket[] = movieTicketsInTransaction.map((movieTicket) => {
+                return {
+                    ...movieTicket,
+                    serviceOutput: {
+                        ...movieTicket.serviceOutput,
+                        reservedTicket: {
+                            ...movieTicket.serviceOutput.reservedTicket,
+                            identifier: createReservedTicketIdentifier(movieTicket)
+                        }
+                    }
+                };
+            });
+            console.log(
+                'updating...',
+                payTransaction.project.id, payTransaction.transactionNumber, payTransaction.startDate,
+                newMovieTickets, i);
+            // console.dir(newMovieTickets, { depth: null });
+            await assetTransactionRepo.fixReservedTicketIdentifier({
+                project: { id: payTransaction.project.id },
+                transactionNumber: payTransaction.transactionNumber,
+                object: {
+                    paymentMethod: { movieTickets: newMovieTickets }
+                }
+            });
+            updateCount += 1;
+            console.log('updated.', payTransaction.project.id, payTransaction.transactionNumber, payTransaction.startDate, i);
+        }
+    });
+
+    console.log(i, 'transactions checked');
+    console.log(updateCount, 'transactions updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/searchAssetTransactions.ts

@@ -0,0 +1,38 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const indexes = await mongoose.connection.db.collection('assetTransactions')
+        .indexes();
+    // console.log(indexes);
+    console.log(indexes.length, 'indexes found');
+
+    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
+
+    const assetTransactions = await assetTransactionRepo.search<chevre.factory.assetTransactionType.CancelReservation>(
+        {
+            limit: 10,
+            project: { id: { $eq: project.id } },
+            object: { reservationNumber: { $in: ['792955671389309', '439371836213743'] } },
+            typeOf: chevre.factory.assetTransactionType.CancelReservation
+        },
+        ['transactionNumber'],
+        []
+    );
+    console.log('assetTransactions found', assetTransactions);
+    console.log(assetTransactions.length, 'assetTransactions found');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/searchOrders.ts

@@ -24,6 +24,11 @@ async function main() {
             limit: 10,
             project: { id: { $eq: project.id } },
             acceptedOffers: {
+                // itemOffered: {
+                //     reservedTicket: {
+                //         identifier: { $eq: 'bls2qevbb:Default:B-9' }
+                //     }
+                // }
                 // $size: 1
                 //     itemOffered: {
                 //         issuedThrough: { typeOf: { $eq: chevre.factory.product.ProductType.MembershipService } }
@@ -47,7 +52,7 @@ async function main() {
             customer: 1
         }
     );
-    // console.log('orders found', orders);
+    console.log('orders found', orders);
     console.log(orders.length, 'orders found');
 }
 

package/lib/chevre/repo/acceptedOffer.d.ts

@@ -106,13 +106,18 @@ export declare class MongoRepository {
     /**
      * 互換性維持対応専用
      */
-    fixSerialNumber(params: {
+    fixReservedTicketIdentifier(params: {
         project: {
             id: string;
         };
         orderNumber: string;
         acceptedOffers: {
-            serialNumber: string;
+            itemOffered: {
+                id: string;
+                reservedTicket: {
+                    identifier: string;
+                };
+            };
         };
     }): Promise<void>;
 }

package/lib/chevre/repo/acceptedOffer.js

@@ -230,19 +230,23 @@ class MongoRepository {
     /**
      * 互換性維持対応専用
      */
-    fixSerialNumber(params) {
+    fixReservedTicketIdentifier(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const doc = yield this.orderModel.findOneAndUpdate({
                 orderNumber: { $eq: params.orderNumber },
                 'project.id': { $eq: params.project.id },
                 typeOf: { $eq: factory.order.OrderType.Order },
-                'acceptedOffers.itemOffered.reservationNumber': { $exists: true, $eq: params.acceptedOffers.serialNumber }
+                'acceptedOffers.itemOffered.id': { $exists: true, $eq: params.acceptedOffers.itemOffered.id }
             }, {
                 $set: {
-                    'acceptedOffers.$[offer].serialNumber': params.acceptedOffers.serialNumber
+                    'acceptedOffers.$[offer].itemOffered.reservedTicket.identifier': params.acceptedOffers.itemOffered.reservedTicket.identifier
                 }
             }, {
-                arrayFilters: [{ 'offer.itemOffered.reservationNumber': { $eq: params.acceptedOffers.serialNumber } }],
+                timestamps: false,
+                arrayFilters: [{
+                        'offer.itemOffered.typeOf': { $eq: factory.reservationType.EventReservation },
+                        'offer.itemOffered.id': { $eq: params.acceptedOffers.itemOffered.id }
+                    }],
                 new: true,
                 projection: {
                     _id: 1

package/lib/chevre/repo/account.js

@@ -427,7 +427,7 @@ class MongoRepository {
     }
     unsetUnnecessaryFields(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.accountModel.updateMany(params.filter, { $unset: params.$unset })
+            return this.accountModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
                 .exec();
         });
     }

package/lib/chevre/repo/aggregateOffer.js

@@ -590,7 +590,7 @@ class MongoRepository {
     }
     unsetUnnecessaryFields(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.aggregateOfferModel.updateMany(params.filter, { $unset: params.$unset })
+            return this.aggregateOfferModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
                 .exec();
         });
     }

package/lib/chevre/repo/assetTransaction.d.ts

@@ -182,6 +182,12 @@ export declare class MongoRepository {
             id: string;
         };
     }): Promise<void>;
+    /**
+     * 終了日時を一定期間過ぎたアクションを削除する
+     */
+    deleteEndDatePassedCertainPeriod(params: {
+        $lt: Date;
+    }): Promise<void>;
     /**
      * 特定の取引を更新する(汎用)
      */
@@ -189,14 +195,29 @@ export declare class MongoRepository {
         id: string;
         update: any;
     }): Promise<factory.assetTransaction.ITransaction<T>>;
-    migratePaymentMethodIdentifier(params: {
+    /**
+     * 互換性維持対応
+     */
+    migrateObjectReservationNumber(params: {
+        id: string;
+        object: {
+            reservationNumber: string;
+        };
+    }): Promise<any>;
+    /**
+     * 互換性維持対応専用
+     */
+    fixReservedTicketIdentifier(params: {
+        project: {
+            id: string;
+        };
         transactionNumber: string;
         object: {
             paymentMethod: {
-                identifier: string;
+                movieTickets: factory.action.trade.pay.IMovieTicket[];
             };
         };
-    }): Promise<any>;
+    }): Promise<void>;
     findByIdAndDelete(params: {
         id: string;
     }): Promise<void>;