@chevre/domain 23.0.0-alpha.2 → 23.0.0-alpha.20

package/example/src/chevre/assetTransaction/processReserve.ts

@@ -6,8 +6,16 @@ import * as redis from 'redis';
 import { chevre } from '../../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
+const { EVENT_ID, OFFER_ID, APPLICATION_ID, OFFER_TOKEN } = process.env;
 
+// tslint:disable-next-line:max-func-body-length
 async function main() {
+    if (typeof EVENT_ID !== 'string'
+        || typeof OFFER_ID !== 'string'
+        || typeof APPLICATION_ID !== 'string') {
+        throw new Error('environment variables required');
+    }
+
     const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
         socket: {
             port: Number(<string>process.env.REDIS_PORT),
@@ -21,59 +29,113 @@ async function main() {
     const transactionNumberRepo = await chevre.repository.TransactionNumber.createInstance({
         connection: mongoose.connection
     });
-    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
-
     const { transactionNumber } = await transactionNumberRepo.publishByTimestamp({ startDate: new Date() });
     const provider: chevre.factory.reservation.IProvider = {
         id: '59d20831e53ebc2b4e774466',
         typeOf: chevre.factory.organizationType.Corporation
     };
-    const reserveTransaction = await assetTransactionRepo.start<chevre.factory.assetTransactionType.Reserve>({
-        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
-        typeOf: chevre.factory.assetTransactionType.Reserve,
-        transactionNumber,
-        agent: { ...provider, name: 'sample agent name' },
-        object: {
-            provider,
-            reservationNumber: transactionNumber,
-            reservationStatus: chevre.factory.reservationStatusType.ReservationPending,
-            disablePendingReservations: true,
-            useHoldStockByTransactionNumber: true,
-            typeOf: chevre.factory.reservationType.ReservationPackage
-        },
-        expires: moment()
-            .add(1, 'minute')
-            .toDate()
-    });
-    let cancelResult = await assetTransactionRepo.cancel<chevre.factory.assetTransactionType.Reserve>({
-        typeOf: reserveTransaction.typeOf,
-        id: reserveTransaction.id
-    });
-    console.log('cancelResult:', cancelResult);
-    cancelResult = await assetTransactionRepo.cancel<chevre.factory.assetTransactionType.Reserve>({
-        typeOf: reserveTransaction.typeOf,
-        id: reserveTransaction.id
-    });
-    console.log('cancelResult:', cancelResult);
 
-    let transaction = await assetTransactionRepo.findById<chevre.factory.assetTransactionType.Reserve>(
+    const { transaction } = await (await chevre.service.assetTransaction.createService()).reserve.start(
         {
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
             typeOf: chevre.factory.assetTransactionType.Reserve,
-            id: reserveTransaction.id
+            transactionNumber,
+            agent: { ...provider, name: 'sample agent name' },
+            object: {
+                acceptedOffer: [{
+                    /**
+                     * オファーID
+                     */
+                    id: OFFER_ID,
+                    /**
+                     * アイテム情報
+                     * 予約の詳細指定など
+                     */
+                    itemOffered: {
+                        serviceOutput: {
+                            typeOf: chevre.factory.reservationType.EventReservation,
+                            reservedTicket: {
+                                /**
+                                 * チケット識別子
+                                 * 指定された場合、決済カードの対象チケット識別子と関連付けされます
+                                 * /^[0-9a-zA-Z]{8,16}$/
+                                 */
+                                // identifier?: string;
+                                // issuedBy?: ReservationFactory.IUnderName;
+                                typeOf: 'Ticket',
+                                ticketedSeat: {
+                                    typeOf: chevre.factory.placeType.Seat,
+                                    seatNumber: 'A-01',
+                                    seatRow: '',
+                                    seatSection: 'Default'
+                                }
+                            }
+                        }
+                    }
+                }],
+                reservationFor: {
+                    id: EVENT_ID,
+                    offers: {
+                        token: OFFER_TOKEN,
+                        identifier: 'LegacyReservation'
+                    }
+                }
+            },
+            expires: moment()
+                // tslint:disable-next-line:no-magic-numbers
+                .add(5, 'seconds')
+                .toDate(),
+            validateEvent: false,
+            validateEventOfferPeriod: true,
+            validateAppliesToMovieTicket: true,
+            instrument: [],
+            availableAtOrFrom: { id: APPLICATION_ID }
+            // stockHoldUntilDaysAfterEventEnd: STOCK_HOLD_UNTIL_DAYS_AFTER_EVENT_END
         },
-        ['status', 'transactionNumber', 'project', 'typeOf']
-    );
-    console.log('transaction:', transaction);
-
-    transaction = await assetTransactionRepo.findByTransactionNumber<chevre.factory.assetTransactionType.Reserve>(
+        { maxReservationGracePeriodInDays: 93 }
+    )(
         {
-            typeOf: chevre.factory.assetTransactionType.Reserve,
-            transactionNumber
+            advanceBookingRequirement: await chevre.repository.AdvanceBookingRequirement.createInstance(mongoose.connection),
+            project: await chevre.repository.Project.createInstance(mongoose.connection),
+            stockHolder: await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection }),
+            event: await chevre.repository.Event.createInstance(mongoose.connection),
+            eventSeries: await chevre.repository.EventSeries.createInstance(mongoose.connection),
+            issuer: await chevre.repository.Issuer.createInstance(mongoose.connection),
+            memberProgram: await chevre.repository.MemberProgram.createInstance(mongoose.connection),
+            offer: await chevre.repository.Offer.createInstance(mongoose.connection),
+            offerCatalog: await chevre.repository.OfferCatalog.createInstance(mongoose.connection),
+            offerCatalogItem: await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection),
+            offerRateLimit: await chevre.repository.rateLimit.Offer.createInstance(redisClient),
+            paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
+            priceSpecification: await chevre.repository.PriceSpecification.createInstance(mongoose.connection),
+            product: await chevre.repository.Product.createInstance(mongoose.connection),
+            productOffer: await chevre.repository.ProductOffer.createInstance(mongoose.connection),
+            seat: await chevre.repository.place.Seat.createInstance(mongoose.connection),
+            setting: await chevre.repository.Setting.createInstance(mongoose.connection),
+            task: await chevre.repository.Task.createInstance(mongoose.connection),
+            assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection)
         },
-        ['status']
+        new chevre.settings.Settings({
+            abortedTasksWithoutReport: [],
+            numTryConfirmReserveTransaction: 10,
+            deliverOrderLimit: 1,
+            coa: { timeout: 20000 },
+            gmo: {
+                timeout: 5000,
+                timeoutBackground: 5000,
+                useFetch: true
+            },
+            movieticketReserve: {
+                timeout: 5000,
+                timeoutCheck: 5000,
+                minIntervalBetweenPayAndRefund: 1,
+                credentialsExpireInSeconds: 300
+            },
+            // useAssetTransactionSyncProcessing: process.env.USE_ASSET_TRANSACTION_SYNC_PROCESSING === '1',
+            useExperimentalFeature: false
+        })
     );
     console.log('transaction:', transaction);
-
 }
 
 main()

package/example/src/chevre/event/updateSellerMakesOffersByIdentifier.ts

@@ -0,0 +1,106 @@
+// 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 { EVENT_IDENTTIFIER } = process.env;
+
+async function main() {
+    if (typeof EVENT_IDENTTIFIER !== 'string') {
+        throw new Error('environment variables required');
+    }
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventSellerMakesOfferRepo = await chevre.repository.EventSellerMakesOffer.createInstance(mongoose.connection);
+    const availabilityEnds = moment('2025-10-26T05:20:00.000Z')
+        .toDate();
+    const availabilityStarts = moment('2025-10-23T15:00:00.000Z')
+        .toDate();
+    const validFrom = moment('2025-10-12T15:00:00.000Z')
+        .toDate();
+    const validThrough = moment('2025-10-26T05:20:00.000Z')
+        .toDate();
+    const result = await eventSellerMakesOfferRepo.updateSellerMakesOffersByEventIdentifier([
+        {
+            $set: {
+                project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+                identifier: EVENT_IDENTTIFIER,
+                offers: {
+                    seller: {
+                        makesOffer: [
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '3eo6okferrsdpfd9j2ce1iv9k7'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '51qbjcfr72h62m06vtv5kkhgje'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '5h3gs22mu9j3ok7o63uog9o9i3'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '66e7p2g713675v96nrhdm975kg'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '7divuoimobsfgq95tp1csorjqq'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: 'ckevmf3fueqcunnideu6artt'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    ]);
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/note/findNotes.ts

@@ -0,0 +1,34 @@
+// tslint:disable:no-console no-magic-numbers
+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 noteRepo = await chevre.repository.Note.createInstance(mongoose.connection);
+    const notes = await noteRepo.findNotes(
+        {
+            limit: 10,
+            page: 1,
+            project: { id: { $eq: project.id } },
+            hasDigitalDocumentPermission: {
+                grantee: {
+                    audienceType: {
+                        $eq: chevre.factory.creativeWork.noteDigitalDocument.PermissionGranteeAudienceType.Public
+                    }
+                }
+            }
+        },
+        ['about', 'identifier']
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(notes, { depth: null });
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/note/upsertNotesByIdentifier.ts

@@ -15,7 +15,10 @@ async function main() {
         chevre.factory.creativeWork.noteDigitalDocument.INoteAboutProduct,
         'about' | 'creator' | 'identifier' | 'project' | 'provider' | 'text' | 'version' | 'hasDigitalDocumentPermission'
     > = {
-        about: { id: '656038908b1cd5ce629f5992', typeOf: chevre.factory.product.ProductType.EventService },
+        about: {
+            id: '656038908b1cd5ce629f5992',
+            typeOf: chevre.factory.product.ProductType.EventService
+        },
         creator: { id: 'xxx', typeOf: chevre.factory.personType.Person },
         identifier: 'abcdefgh',
         project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
@@ -27,14 +30,13 @@ async function main() {
     };
     const createResult = await noteRepo.upsertNotesByIdentifier(
         [
-            {
-                $set: creatingNote
-                // $unset: {}
-            },
             {
                 $set: creatingNote
                 // $unset: {}
             }
+            // {
+            //     $set: creatingNote
+            // }
         ],
         { update: false }
     );
@@ -46,6 +48,9 @@ async function main() {
             {
                 $set: creatingNote
             }
+            // {
+            //     $set: creatingNote
+            // }
         ],
         { update: true }
     );

package/example/src/chevre/offerCatalog/updateManyOfferCatalogsByIds.ts

@@ -0,0 +1,49 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const PROJECT_ID = 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 offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+
+    try {
+        await offerCatalogRepo.updateManyOfferCatalogsByIds({
+            id: {
+                $in: ['xxx']
+            },
+            itemOffered: {
+                typeOf: {
+                    $eq: chevre.factory.product.ProductType.EventService
+                }
+            },
+            $push: {
+                itemListElement: {
+                    $each: [{ id: 'xxx', typeOf: chevre.factory.offerType.Offer }],
+                    $slice: 300
+                }
+            },
+            $pull: {
+                itemListElement: {
+                    $elemMatch: {
+                        id: {
+                            $in: ['xxx']
+                        }
+                    }
+                }
+            }
+        });
+    } catch (error) {
+        throw await chevre.errorHandler.handleMongoError(error);
+    }
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/paymentServices/findPaymentServices.ts

@@ -0,0 +1,37 @@
+// tslint:disable:no-implicit-dependencies no-console
+import * as  mongoose from 'mongoose';
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    try {
+        await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+        const paymentServiceRepo = await chevre.repository.PaymentService.createInstance(mongoose.connection);
+
+        const limit = 10;
+        const page = 1;
+        const docs = await paymentServiceRepo.projectFields(
+            {
+                limit,
+                page,
+                project: { id: { $eq: project.id } },
+                availableChannel: { id: { $eq: 'xxx' } },
+                id: { $eq: 'xxx' }
+            },
+            ['availableChannel', 'productID']
+        );
+        // tslint:disable-next-line:no-null-keyword
+        console.dir(docs, { depth: null });
+        console.log(docs.length, 'docs found');
+    } catch (error) {
+        throw await chevre.errorHandler.handleMongoError(error);
+    }
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/product/findHasOfferCatalog.ts

@@ -0,0 +1,31 @@
+// 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, { autoIndex: false });
+
+    const productHasOfferCatalogRepo = await chevre.repository.ProductHasOfferCatalog.createInstance(mongoose.connection);
+
+    try {
+        const offerCatalogs = (await productHasOfferCatalogRepo.findOfferCatalogs(
+            {
+                limit: 10,
+                page: 1,
+                project: { id: { $eq: project.id } },
+                product: { id: { $in: ['656038908b1cd5ce629f5992', '60c1c0031fb182000bed5eff'] } }
+            }
+        ));
+        // tslint:disable-next-line:no-null-keyword
+        console.dir(offerCatalogs, { depth: null });
+    } catch (error) {
+        throw await chevre.errorHandler.handleMongoError(error);
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/reIndex.ts

@@ -11,9 +11,7 @@ mongoose.Model.on('index', (...args) => {
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    await chevre.repository.place.ScreeningRoom.createInstance(mongoose.connection);
-    await chevre.repository.Seller.createInstance(mongoose.connection);
-    await chevre.repository.ProductOffer.createInstance(mongoose.connection);
+    await chevre.repository.Note.createInstance(mongoose.connection);
     console.log('success!');
 }
 

package/example/src/chevre/roles/addAdminNotePermissionIfNotExists.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 roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    const roleNames = [
+        chevre.factory.role.organizationRole.RoleName.InventoryManager
+        // chevre.factory.role.organizationRole.RoleName.SellersOwner,
+        // chevre.factory.role.organizationRole.RoleName.SellersInventoryManager
+    ];
+    const permissions = [
+        'admin.notes.*'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+
+    // roleNames = [
+    //     chevre.factory.role.organizationRole.RoleName.TicketClerk
+    // ];
+    // permissions = [
+    //     'admin.sellers.productOffers.read'
+    // ];
+    // for (const roleName of roleNames) {
+    //     for (const permission of permissions) {
+    //         const result = await roleRepo.addPermissionIfNotExists({
+    //             roleName: { $eq: roleName },
+    //             permission
+    //         });
+    //         console.log('permission added.', result, roleName);
+    //     }
+    // }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/roles/{addAdminProductOfferPermissionIfNotExists.ts → addAdminPaymentServiceReadPermissionIfNotExists.ts}

@@ -8,29 +8,14 @@ async function main() {
 
     const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
 
-    let roleNames = [
+    const roleNames = [
         chevre.factory.role.organizationRole.RoleName.InventoryManager,
         chevre.factory.role.organizationRole.RoleName.SellersOwner,
-        chevre.factory.role.organizationRole.RoleName.SellersInventoryManager
-    ];
-    let permissions = [
-        'admin.sellers.productOffers.*'
-    ];
-    for (const roleName of roleNames) {
-        for (const permission of permissions) {
-            const result = await roleRepo.addPermissionIfNotExists({
-                roleName: { $eq: roleName },
-                permission
-            });
-            console.log('permission added.', result, roleName);
-        }
-    }
-
-    roleNames = [
+        chevre.factory.role.organizationRole.RoleName.SellersInventoryManager,
         chevre.factory.role.organizationRole.RoleName.TicketClerk
     ];
-    permissions = [
-        'admin.sellers.productOffers.read'
+    const permissions = [
+        'admin.paymentServices.read'
     ];
     for (const roleName of roleNames) {
         for (const permission of permissions) {
@@ -41,6 +26,22 @@ async function main() {
             console.log('permission added.', result, roleName);
         }
     }
+
+    // roleNames = [
+    //     chevre.factory.role.organizationRole.RoleName.TicketClerk
+    // ];
+    // permissions = [
+    //     'admin.sellers.productOffers.read'
+    // ];
+    // for (const roleName of roleNames) {
+    //     for (const permission of permissions) {
+    //         const result = await roleRepo.addPermissionIfNotExists({
+    //             roleName: { $eq: roleName },
+    //             permission
+    //         });
+    //         console.log('permission added.', result, roleName);
+    //     }
+    // }
 }
 
 main()

package/example/src/chevre/roles/addAdminProductHasOfferCatalogReadPermissionIfNotExists.ts

@@ -0,0 +1,33 @@
+// 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 roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    const roleNames = [
+        chevre.factory.role.organizationRole.RoleName.InventoryManager
+        // chevre.factory.role.organizationRole.RoleName.SellersOwner,
+        // chevre.factory.role.organizationRole.RoleName.SellersInventoryManager,
+        // chevre.factory.role.organizationRole.RoleName.TicketClerk
+    ];
+    const permissions = [
+        'admin.productHasOfferCatalog.read'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/roles/removeConsolePermissionIfExists.ts

@@ -9,7 +9,7 @@ async function main() {
     const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
 
     const permissions = [
-        'eventOffers.*'
+        'products.read'
     ];
     for (const permission of permissions) {
         const roles = await roleRepo.projectFields(

package/example/src/chevre/roles/removePermissionIfExists.ts

@@ -9,12 +9,7 @@ async function main() {
     const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
 
     const permissions = [
-        'tokens',
-        'authorizations.create',
-        'permits.read',
-        'tasks.read',
-        'transactionNumbers.write',
-        'chevre.admin'
+        'admin.sellers.productOffers.*'
     ];
     for (const permission of permissions) {
         const roles = await roleRepo.projectFields(

package/example/src/chevre/unsetUnnecessaryFields.ts

@@ -9,18 +9,16 @@ import { chevre } from '../../../lib/index';
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const noteRepo = await chevre.repository.NoteAboutOrder.createInstance(mongoose.connection);
 
     let updateResult: any;
 
-    updateResult = await eventRepo.unsetUnnecessaryFields({
+    updateResult = await noteRepo.unsetUnnecessaryFields({
         filter: {
-            // 'project.id': { $eq: '*' }
-            // 'location.maximumAttendeeCapacity': { $exists: true },
-            maximumPhysicalAttendeeCapacity: { $exists: true }
+            'about.identifier': { $exists: true }
         },
-        $unset: <any>{
-            'location.maximumAttendeeCapacity': 1
+        $unset: {
+            'about.identifier': 1
         }
     });
     console.log(updateResult);