@chevre/domain 21.20.0-alpha.7 → 21.20.0-alpha.70

package/example/src/chevre/findTransactionById.ts

@@ -0,0 +1,21 @@
+// 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 transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
+
+    const transaction = await transactionRepo.findById({
+        typeOf: chevre.factory.transactionType.PlaceOrder,
+        id: '65ab04d5206595479469f50c',
+        inclusion: ['endDate', 'id', 'object', 'project', 'seller', 'startDate', 'status', 'typeOf']
+    });
+    console.log('transaction:', transaction);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/importCategoryCodesFromCOA.ts

@@ -9,7 +9,8 @@ const project = { id: String(process.env.PROJECT_ID) };
 
 const coaAuthClient = new COA.auth.RefreshToken({
     endpoint: chevre.credentials.coa.endpoint,
-    refreshToken: chevre.credentials.coa.refreshToken
+    refreshToken: chevre.credentials.coa.refreshToken,
+    useFetch: chevre.credentials.coa.useFetch
 });
 
 async function main() {

package/example/src/chevre/importOffersFromCOA.ts

@@ -9,7 +9,8 @@ const project = { id: String(process.env.PROJECT_ID) };
 
 const coaAuthClient = new COA.auth.RefreshToken({
     endpoint: chevre.credentials.coa.endpoint,
-    refreshToken: chevre.credentials.coa.refreshToken
+    refreshToken: chevre.credentials.coa.refreshToken,
+    useFetch: chevre.credentials.coa.useFetch
 });
 
 async function main() {

package/example/src/chevre/migrateActionInstrumentTransactionNumber.ts

@@ -0,0 +1,93 @@
+// 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) };
+const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const actionRepo = await chevre.repository.Action.createInstance(mongoose.connection);
+
+    const cursor = actionRepo.getCursor(
+        {
+            // 'instrument.transactionNumber': { $exists: false },
+            'object.typeOf': { $eq: chevre.factory.action.authorize.offer.eventService.ObjectType.SeatReservation },
+            // 'project.id': { $eq: project.id },
+            startDate: {
+                $gte: moment()
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-12, 'months')
+                    .toDate()
+                // $lte: moment('2023-08-01T21:20:43.133Z')
+                //     .toDate()
+            },
+            // actionStatus: { $eq: chevre.factory.actionStatusType.CompletedActionStatus }
+            'project.id': {
+                $ne: EXCLUDED_PROJECT_ID
+            }
+            // _id: { $eq: '6500d53f8f5a524f061b4771' }
+        },
+        {
+            startDate: 1,
+            object: 1,
+            project: 1,
+            instrument: 1,
+            purpose: 1
+            // result: 1
+        }
+    );
+    console.log('actions found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const action: Pick<
+            chevre.factory.action.authorize.offer.eventService.IAction<chevre.factory.service.webAPI.Identifier>,
+            'startDate' | 'object' | 'project' | 'instrument' | 'id' | 'purpose'
+        > = doc.toObject();
+
+        const noPendingTransaction = false;
+        const transactionNumber = action.object.pendingTransaction?.transactionNumber;
+        // const transactionNumberFromResult = (<any>action).result?.responseBody?.tmpReserveNum;
+        if (typeof transactionNumber !== 'string' || transactionNumber.length === 0) {
+            // noPendingTransaction = true;
+            // console.error('transactionNumber not found.', action.project.id, action.id, transactionNumber, action.startDate, i);
+            // if (typeof transactionNumberFromResult !== 'string' || transactionNumberFromResult.length === 0) {
+            //     throw new Error('transactionNumber & transactionNumberFromResult not found.');
+            // } else {
+            //     transactionNumber = transactionNumberFromResult;
+            // }
+            throw new Error('transactionNumber & transactionNumberFromResult not found.');
+        }
+        const alreadyMigrated = typeof action.instrument.transactionNumber === 'string'
+            && action.instrument.transactionNumber === transactionNumber;
+
+        if (alreadyMigrated) {
+            console.log('already exist.', action.project.id, action.id, action.purpose.id, transactionNumber, action.startDate, i);
+        } else {
+            console.log('updating...', action.project.id, action.id, action.purpose.id, transactionNumber, action.startDate, i);
+            await actionRepo.fixInstrumentTransactionNumber({
+                id: action.id,
+                instrument: { transactionNumber },
+                ...(noPendingTransaction)
+                    ? { object: { pendingTransaction: { transactionNumber } } }
+                    : undefined
+            });
+            updateCount += 1;
+            console.log('updated.', action.project.id, action.id, transactionNumber, action.startDate, i);
+        }
+    });
+
+    console.log(i, 'actions checked');
+    console.log(updateCount, 'actions updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateEventMakesOfferAvailableAtOrFrom.ts

@@ -0,0 +1,87 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const OLD_CLIENT = String(process.env.OLD_CLIENT);
+const NEW_CLIENT = String(process.env.NEW_CLIENT);
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            'project.id': { $eq: project.id },
+            // _id: { $eq: 'als04raei' },
+            'offers.seller.makesOffer.availableAtOrFrom.id': { $eq: OLD_CLIENT },
+            typeOf: { $eq: chevre.factory.eventType.ScreeningEvent }
+        },
+        {
+            _id: 1,
+            offers: 1,
+            project: 1,
+            startDate: 1
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: Pick<
+            chevre.factory.event.screeningEvent.IEvent,
+            'id' | 'offers' | 'project' | 'startDate'
+        > = doc.toObject();
+
+        const eventOffers = <chevre.factory.event.screeningEvent.IOffer>event.offers;
+        const alreadyMigrated = eventOffers.seller.makesOffer.some(
+            ({ availableAtOrFrom }) => availableAtOrFrom?.some((({ id }) => id === NEW_CLIENT))
+        );
+        const offerOnOldClient = eventOffers.seller.makesOffer.find(
+            ({ availableAtOrFrom }) => availableAtOrFrom?.some((({ id }) => id === OLD_CLIENT))
+        );
+        if (offerOnOldClient === undefined) {
+            throw new Error('!oldClientExists');
+        }
+
+        if (alreadyMigrated) {
+            await eventRepo.deleteAvailableAtOrFrom({
+                id: String(event.id),
+                offers: {
+                    seller: {
+                        makesOffer: { availableAtOrFrom: { id: OLD_CLIENT } }
+                    }
+                }
+            });
+            console.log('already exist.', event.project.id, event.id, event.startDate, i);
+        } else {
+            const offerNewOldClient: chevre.factory.event.screeningEvent.ISellerMakesOffer = {
+                ...offerOnOldClient,
+                availableAtOrFrom: [{ id: NEW_CLIENT }]
+            };
+            console.log('updating...', event.project.id, event.id, event.startDate, i);
+            await eventRepo.addAvailableAtOrFrom({
+                id: String(event.id),
+                offers: {
+                    seller: {
+                        makesOffer: offerNewOldClient
+                    }
+                }
+            });
+            updateCount += 1;
+            console.log('updated.', event.project.id, event.id, event.startDate, i);
+        }
+    });
+
+    console.log(i, 'offers checked');
+    console.log(updateCount, 'offers updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateOfferAvailableAtOrFrom.ts

@@ -0,0 +1,63 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const OLD_CLIENT = String(process.env.OLD_CLIENT);
+const NEW_CLIENT = String(process.env.NEW_CLIENT);
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const offerRepo = await chevre.repository.Offer.createInstance(mongoose.connection);
+
+    const cursor = offerRepo.getCursor(
+        {
+            'project.id': { $eq: project.id },
+            // _id: { $eq: 'blqm9a6ui' },
+            'offers.availableAtOrFrom.id': { $eq: OLD_CLIENT }
+        },
+        {
+            _id: 1,
+            offers: 1,
+            project: 1
+        }
+    );
+    console.log('offers found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const aggregateOffer: chevre.factory.aggregateOffer.IAggregateOffer = doc.toObject();
+
+        const alreadyMigrated = aggregateOffer.offers[0].availableAtOrFrom?.some(({ id }) => id === NEW_CLIENT);
+        console.log(aggregateOffer.offers[0].availableAtOrFrom, i);
+
+        if (alreadyMigrated) {
+            await offerRepo.deleteAvailableAtOrFrom({
+                id: String(aggregateOffer.id),
+                offers: { availableAtOrFrom: { id: OLD_CLIENT } }
+            });
+            console.log('already exist.', aggregateOffer.project.id, aggregateOffer.id, i);
+        } else {
+            console.log('updating...', aggregateOffer.project.id, aggregateOffer.id, i);
+            await offerRepo.addAvailableAtOrFrom({
+                id: String(aggregateOffer.id),
+                identifier: aggregateOffer.offers[0].identifier,
+                offers: { availableAtOrFrom: { id: NEW_CLIENT } }
+            });
+            updateCount += 1;
+            console.log('updated.', aggregateOffer.project.id, aggregateOffer.id, i);
+        }
+    });
+
+    console.log(i, 'offers checked');
+    console.log(updateCount, 'offers updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

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

@@ -10,14 +10,15 @@ import { chevre } from '../../../lib/index';
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
+    const acceptedOfferRepo = await chevre.repository.AcceptedOffer.createInstance(mongoose.connection);
     const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
 
     const cursor = orderRepo.getCursor(
         {
-            'paymentMethods.paymentMethodId': { $exists: true },
-            'paymentMethods.paymentMethod.identifier': { $exists: false },
+            // 'acceptedOffers.serialNumber': { $exists: false },
+            'acceptedOffers.itemOffered.reservationNumber': { $exists: true },
             // 'project.id': { $eq: project.id },
-            // orderNumber: { $eq: 'KNR1-3961294-9087043' },
+            // orderNumber: { $eq: 'KOB1-3749861-4732433' },
             orderDate: {
                 $gte: moment()
                     // tslint:disable-next-line:no-magic-numbers
@@ -33,7 +34,7 @@ async function main() {
             orderDate: 1,
             orderNumber: 1,
             project: 1,
-            paymentMethods: 1
+            acceptedOffers: 1
         }
     );
     console.log('orders found');
@@ -45,28 +46,26 @@ async function main() {
         const order: Pick<
             chevre.factory.order.IOrder,
             'orderDate' | 'orderNumber' | 'project' | 'paymentMethods'
-        > = doc.toObject();
+        > & {
+            acceptedOffers: chevre.factory.order.IAcceptedOffer<chevre.factory.order.IReservation>[];
+        } = doc.toObject();
 
-        const noPayment = order.paymentMethods.length === 0;
-        const alreadyMigrated = order.paymentMethods.every((invoice) => {
-            return typeof invoice.paymentMethod?.identifier === 'string'
-                && invoice.paymentMethod?.identifier.length > 0;
-            // && invoice.paymentMethod.identifier === (<any>invoice).typeOf;
+        const alreadyMigrated = order.acceptedOffers.every((offer) => {
+            return typeof offer.serialNumber === 'string'
+                && offer.serialNumber.length > 0
+                && offer.itemOffered.reservationNumber === offer.serialNumber;
         });
 
-        if (noPayment) {
-            console.log('noPayment.', order.project.id, order.orderNumber, order.orderDate, i);
-        } else if (alreadyMigrated) {
+        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({
+            for (const offer of order.acceptedOffers) {
+                console.log('updating...', order.project.id, order.orderNumber, order.orderDate, offer.itemOffered.reservationNumber, i);
+                await acceptedOfferRepo.fixSerialNumber({
                     project: { id: order.project.id },
                     orderNumber: order.orderNumber,
-                    invoice: {
-                        paymentMethodId: invoice.paymentMethodId,
-                        paymentMethod: { identifier: (<any>invoice).typeOf }
+                    acceptedOffers: {
+                        serialNumber: offer.itemOffered.reservationNumber
                     }
                 });
             }

package/example/src/chevre/onAssetTransactionStatusChanged.ts

@@ -0,0 +1,36 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    (await chevre.service.order.createService())
+        .onAssetTransactionStatusChanged({
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            object: {
+                typeOf: chevre.factory.assetTransactionType.Reserve,
+                transactionNumber: '863918387495116',
+                status: chevre.factory.transactionStatusType.Confirmed
+            },
+            purpose: {
+                confirmationNumber: '',
+                orderNumber: 'CIN1-3748070-2008463',
+                typeOf: chevre.factory.order.OrderType.Order
+            },
+            useOnOrderStatusChanged: true
+        })({
+            assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
+            acceptedOffer: await chevre.repository.AcceptedOffer.createInstance(mongoose.connection),
+            order: await chevre.repository.Order.createInstance(mongoose.connection),
+            task: await chevre.repository.Task.createInstance(mongoose.connection),
+            transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
+        });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/retryTasks.ts

@@ -0,0 +1,39 @@
+// tslint:disable:no-implicit-dependencies no-console
+import { chevre } from '../../../lib/index';
+
+import * as  moment from 'moment';
+import * as  mongoose from 'mongoose';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+    const result = await taskRepo.taskModel.updateMany(
+        {
+            status: { $eq: chevre.factory.taskStatus.Aborted },
+            lastTriedAt: {
+                $gt: moment()
+                    .add(-1, 'day')
+                    .toDate()
+            },
+            name: { $eq: chevre.factory.taskName.TriggerWebhook },
+            'project.id': { $eq: project.id }
+        },
+        {
+            $set: {
+                status: chevre.factory.taskStatus.Ready,
+                remainingNumberOfTries: 20
+            }
+        }
+    )
+        .exec();
+    console.log('result:', result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/searchActions.ts

@@ -5,20 +5,26 @@ import * as  mongoose from 'mongoose';
 
 // 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 actionRepo = await chevre.repository.Action.createInstance(mongoose.connection);
     const actions = await actionRepo.search(
         {
-            typeOf: { $eq: chevre.factory.actionType.CheckAction },
+            limit: 1,
+            // typeOf: { $eq: chevre.factory.actionType.CheckAction },
             // project: { id: { $eq: project.id } },
-            object: {
-                movieTickets: {
-                    identifier: { $eq: '0947524082' },
-                    serviceOutput: { reservationFor: { id: { $eq: 'clhvvbpyn' } } }
-                }
-            }
+            // object: {
+            //     movieTickets: {
+            //         identifier: { $eq: '0947524082' },
+            //         serviceOutput: { reservationFor: { id: { $eq: 'clhvvbpyn' } } }
+            //     }
+            // }
+            instrument: { transactionNumber: { $eq: 'x' } }
         },
         ['_id'],
         []

package/example/src/chevre/searchOrderAcceptedOffers.ts

@@ -5,6 +5,10 @@ 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);
 
@@ -16,10 +20,16 @@ async function main() {
             limit: 10,
             page: 1,
             project: { id: { $eq: project.id } },
-            orderNumber: { $eq: 'CIN3-0760465-8981560' },
-            acceptedOffers: { itemOffered: { typeOf: { $in: [chevre.factory.reservationType.EventReservation] } } }
+            orderNumber: { $eq: 'CIN7-9247770-0699829' },
+            acceptedOffers: {
+                itemOffered: {
+                    typeOf: { $in: [chevre.factory.reservationType.EventReservation] },
+                    reservationFor: { id: { $in: ['blpw1ew8f'] } },
+                    reservedTicket: { ticketedSeat: { seatNumber: { $in: ['A-26', 'xxx'] } } }
+                }
+            }
         },
-        ['itemOffered', 'id']
+        ['itemOffered', 'priceSpecification']
     );
     // tslint:disable-next-line:no-null-keyword
     console.dir(acceptedOffers, { depth: 1 });

package/example/src/chevre/searchOrders.ts

@@ -5,21 +5,19 @@ 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 orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+    const indexes = await mongoose.connection.db.collection('orders')
+        .indexes();
+    // console.log(indexes);
+    console.log(indexes.length, 'indexes found');
 
-    const order = await orderRepo.findByOrderNumber({
-        orderNumber: 'CIN4-3943271-4221863',
-        project: { id: project.id },
-        inclusion: [
-            // 'project', 'typeOf', 'orderNumber', 'dateReturned', 'id',
-            // 'customer', 'returner', 'seller', 'price', 'priceCurrency', 'orderDate'
-        ],
-        exclusion: ['acceptedOffers']
-    });
-    console.log(order);
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
 
     const orders = await orderRepo.search(
         {
@@ -30,10 +28,10 @@ async function main() {
                 //     itemOffered: {
                 //         issuedThrough: { typeOf: { $eq: chevre.factory.product.ProductType.MembershipService } }
                 //     }
-            },
-            orderedItem: {
-                $size: 3
             }
+            // orderedItem: {
+            //     $size: 3
+            // }
             // paymentMethods: {
             //     paymentMethod: { identifier: { $in: ['Cash'] } }
             //     additionalProperty: {
@@ -49,7 +47,7 @@ async function main() {
             customer: 1
         }
     );
-    console.log('orders found', orders);
+    // console.log('orders found', orders);
     console.log(orders.length, 'orders found');
 }
 

package/example/src/chevre/searchSlicedAcceptedOffersByOrderNumber.ts

@@ -0,0 +1,28 @@
+// 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);
+
+    const acceptedOfferRepo = await chevre.repository.AcceptedOffer.createInstance(mongoose.connection);
+
+    const result = await acceptedOfferRepo.searchSlicedAcceptedOffersByOrderNumber(
+        {
+            orderNumber: { $eq: 'CIN1-3748070-2008463' },
+            project: { id: { $eq: String(process.env.PROJECT_ID) } },
+            // tslint:disable-next-line:no-magic-numbers
+            $slice: [0, 2]
+        }
+    );
+    console.log(result);
+    console.log(result.acceptedOffers.map((offer) => {
+        return `${(<any>offer.itemOffered).id}`;
+    }));
+    console.log(result.acceptedOffers.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/sendOrder.ts

@@ -0,0 +1,37 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    (await chevre.service.order.createService())
+        .sendOrder({
+            agent: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            project: { id: project.id },
+            object: {
+                confirmationNumber: '57761',
+                orderNumber: 'CIN1-3748070-2008463',
+                previousOrderStatus: chevre.factory.orderStatus.OrderInTransit,
+                acceptedOffers: {
+                    limit: 1,
+                    page: 1
+                }
+            },
+            useOnOrderStatusChanged: false
+        })({
+            acceptedOffer: await chevre.repository.AcceptedOffer.createInstance(mongoose.connection),
+            action: await chevre.repository.Action.createInstance(mongoose.connection),
+            order: await chevre.repository.Order.createInstance(mongoose.connection),
+            ownershipInfo: await chevre.repository.OwnershipInfo.createInstance(mongoose.connection),
+            task: await chevre.repository.Task.createInstance(mongoose.connection),
+            transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
+        });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);