@chevre/domain 21.4.0-alpha.3 → 21.4.0-alpha.30

package/example/src/chevre/cleanActions.ts

@@ -0,0 +1,23 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+
+    const result = await actionRepo.deleteStartDatePassedCertainPeriod({
+        $lt: moment()
+            // tslint:disable-next-line:no-magic-numbers
+            .add(-548, 'days')
+            .toDate()
+    });
+    console.log(result);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/cleanEventsByMovieTheater.ts

@@ -0,0 +1,32 @@
+// 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 LOCATION_BRANCH_CODE = String(process.env.LOCATION_BRANCH_CODE);
+// 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 eventRepo = new chevre.repository.Event(mongoose.connection);
+
+    let result = await eventRepo.deleteScreeningEventSeriesByMovieTheaterBranchCode({
+        project: { id: project.id },
+        location: { branchCode: LOCATION_BRANCH_CODE }
+    });
+    console.log('deleteScreeningEventSeriesByMovieTheaterBranchCode processed.', result);
+
+    result = await eventRepo.deleteScreeningEventsByMovieTheaterBranchCode({
+        project: { id: project.id },
+        location: { branchCode: LOCATION_BRANCH_CODE }
+    });
+    console.log('deleteScreeningEventsByMovieTheaterBranchCode processed.', result);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/createDeleteTransactionTasksOfDeletedPeople.ts

@@ -0,0 +1,126 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const USERPOOL_ID_NEW = String(process.env.USERPOOL_ID_NEW);
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const now = new Date();
+
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+    const orderRepo = new chevre.repository.Order(mongoose.connection);
+    const personRepo = new chevre.repository.Person({ userPoolId: USERPOOL_ID_NEW });
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+
+    const cursor = orderRepo.getCursor(
+        {
+            'project.id': { $eq: project.id },
+            'customer.typeOf': { $eq: chevre.factory.personType.Person },
+            'acceptedOffers.itemOffered.typeOf': { $exists: true.valueOf, $eq: chevre.factory.reservationType.EventReservation }
+        },
+        {
+            _id: 1,
+            project: 1,
+            orderNumber: 1,
+            orderDate: 1,
+            customer: 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, 'id' | 'orderDate' | 'orderNumber' | 'customer' | 'project'>>doc.toObject();
+
+        // person検索
+        console.log('seaching person....', order.project.id, order.orderNumber, order.orderDate, order.customer.id, i);
+        const people = await personRepo.search({ id: String(order.customer.id) });
+        const person = people.shift();
+        const activePerson = (<any>person).Enabled === true;
+        if (activePerson) {
+            // activeであれば何もしない
+            console.log(
+                'person found', order.project.id, order.orderNumber, order.orderDate,
+                person?.memberOf?.membershipNumber,
+                (<any>person).Enabled, i);
+        } else {
+            // migrateアクション検索
+            const deletePersonActions = <chevre.factory.action.update.deleteAction.member.IAction[]>await actionRepo.search(
+                {
+                    limit: 1,
+                    page: 1,
+                    project: { id: { $eq: order.project.id } },
+                    actionStatus: { $in: [chevre.factory.actionStatusType.CompletedActionStatus] },
+                    typeOf: { $eq: chevre.factory.actionType.DeleteAction },
+                    object: {
+                        id: { $eq: order.customer.id },
+                        typeOf: { $eq: chevre.factory.personType.Person }
+                    }
+                },
+                [],
+                []
+            );
+            const deletePersonAction = deletePersonActions.shift();
+            if (deletePersonAction !== undefined) {
+                // migrateアクションがあれば何もしない
+                const migratedUser: boolean = deletePersonAction.object.migrate === true;
+                console.log('migratedUser:', migratedUser);
+                if (migratedUser) {
+                    console.log(
+                        'person migrated', order.project.id, order.orderNumber, order.orderDate,
+                        person?.memberOf?.membershipNumber, i);
+
+                    return;
+                }
+            }
+
+            console.log(
+                'creating task...', order.project.id, order.orderNumber, order.orderDate,
+                person?.memberOf?.membershipNumber, i);
+            // task作成
+            const deleteTransactionTasks: chevre.factory.task.deleteTransaction.IAttributes[] = [
+                chevre.factory.transactionType.MoneyTransfer,
+                chevre.factory.transactionType.PlaceOrder,
+                chevre.factory.transactionType.ReturnOrder
+            ].map((transactionType) => {
+                return {
+                    project: { id: order.project.id, typeOf: chevre.factory.organizationType.Project },
+                    name: chevre.factory.taskName.DeleteTransaction,
+                    status: chevre.factory.taskStatus.Ready,
+                    runsAt: now,
+                    remainingNumberOfTries: 3,
+                    numberOfTried: 0,
+                    executionResults: [],
+                    data: {
+                        object: {
+                            specifyingMethod: chevre.factory.task.deleteTransaction.SpecifyingMethod.AgentId,
+                            agent: { id: order.customer.id },
+                            project: { id: order.project.id },
+                            typeOf: transactionType
+                        }
+                    }
+                };
+            });
+            // console.log(deleteTransactionTasks);
+            await taskRepo.saveMany(deleteTransactionTasks, { emitImmediately: false });
+            updateCount += 1;
+            console.log(
+                'task created.', order.project.id, order.orderNumber, order.orderDate,
+                person?.memberOf?.membershipNumber, i);
+        }
+    });
+
+    console.log(i, 'orders checked');
+    console.log(updateCount, 'tasks created');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/createManyEventsIfNotExist.ts

@@ -5,6 +5,10 @@ import * as mongoose from 'mongoose';
 import { chevre } from '../../../lib/index';
 
 const PROJECT_ID = String(process.env.PROJECT_ID);
+const ORGANIZER_ID = process.env.ORGANIZER_ID;
+if (typeof ORGANIZER_ID !== 'string' || ORGANIZER_ID.length === 0) {
+    throw new Error('ORGANIZER_ID undefined');
+}
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
@@ -15,6 +19,7 @@ async function main() {
     const result = await eventRepo.createManyIfNotExist<chevre.factory.eventType.ScreeningEvent>([
         {
             attributes: {
+                organizer: { id: String(ORGANIZER_ID) },
                 typeOf: chevre.factory.eventType.ScreeningEvent,
                 project: { id: PROJECT_ID, typeOf: chevre.factory.organizationType.Project },
                 name: {
@@ -184,6 +189,7 @@ async function main() {
         },
         {
             attributes: {
+                organizer: { id: String(ORGANIZER_ID) },
                 typeOf: chevre.factory.eventType.ScreeningEvent,
                 project: { id: PROJECT_ID, typeOf: chevre.factory.organizationType.Project },
                 name: {

package/example/src/chevre/iam/searchMemberOfIdsByMemberId.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);
+const memberId = String(process.env.MEMBER_ID);
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const memberRepo = new chevre.repository.Member(mongoose.connection);
+
+    const ids = await memberRepo.searchMemberOfIdsByMemberId({
+        member: {
+            id: memberId,
+            memberOf: {
+                // typeOf: chevre.factory.organizationType.Corporation,
+                typeOf: chevre.factory.organizationType.Project
+            }
+        },
+        project: {
+            id: PROJECT_ID
+        }
+    });
+    console.log(ids);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/iam/searchProjectIdsByMemberId.ts

@@ -0,0 +1,32 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const PROJECT_ID = String(process.env.PROJECT_ID);
+const memberId = String(process.env.MEMBER_ID);
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const memberRepo = new chevre.repository.Member(mongoose.connection);
+
+    const ids = await memberRepo.searchProjectIdsByMemberId({
+        member: {
+            id: memberId
+        },
+        project: {
+            id: {
+                // $regex: 'c'
+            }
+        },
+        limit: 3,
+        page: 1
+
+    });
+    console.log(ids);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/migrateEventOrganizer.ts

@@ -0,0 +1,125 @@
+// 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: true });
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+    const placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            // 'project.id': { $ne: EXCLUDED_PROJECT_ID },
+            typeOf: {
+                $in: [
+                    chevre.factory.eventType.ScreeningEvent,
+                    chevre.factory.eventType.ScreeningEventSeries
+                ]
+            },
+            organizer: { $exists: false }
+            // startDate: {
+            //     $gte: moment()
+            //         // tslint:disable-next-line:no-magic-numbers
+            //         .add(-6, 'months')
+            //         .toDate()
+            // }
+        },
+        {
+            _id: 1,
+            project: 1,
+            location: 1,
+            superEvent: 1,
+            startDate: 1,
+            typeOf: 1,
+            organizer: 1
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: Pick<
+            chevre.factory.event.IEvent<chevre.factory.eventType.ScreeningEvent>,
+            'id' | 'project' | 'location' | 'startDate' | 'typeOf' | 'organizer' | 'superEvent'
+        > | Pick<
+            chevre.factory.event.IEvent<chevre.factory.eventType.ScreeningEventSeries>,
+            'id' | 'project' | 'location' | 'startDate' | 'typeOf' | 'organizer'
+        > = doc.toObject();
+
+        const organizerId = event.organizer?.id;
+        const alreadyMigrated = typeof organizerId === 'string';
+
+        if (alreadyMigrated) {
+            console.log('already exist...', event.project.id, event.id, event.startDate, organizerId, i);
+        } else {
+            let movieTheaterId: string;
+            let movieTheaterBranchCode: string;
+            if (event.typeOf === chevre.factory.eventType.ScreeningEventSeries) {
+                movieTheaterId = event.location.id;
+                movieTheaterBranchCode = event.location.branchCode;
+            } else {
+                movieTheaterId = event.superEvent.location.id;
+                movieTheaterBranchCode = event.superEvent.location.branchCode;
+            }
+            const movieTheaters = <Pick<
+                chevre.factory.place.movieTheater.IPlaceWithoutScreeningRoom,
+                'parentOrganization' | 'branchCode'
+            >[]>
+                await placeRepo.searchMovieTheaters(
+                    {
+                        limit: 1,
+                        page: 1,
+                        project: { id: { $eq: event.project.id } },
+                        id: { $eq: movieTheaterId }
+                    },
+                    ['parentOrganization', 'branchCode'],
+                    []
+                );
+            const movieTheater = movieTheaters.shift();
+            const sellerId = movieTheater?.parentOrganization?.id;
+            console.log(
+                'movieTheater found',
+                event.project.id, event.id, event.startDate, 'sellerId:', sellerId,
+                'movieTheaterId:', movieTheaterId,
+                'movieTheaterBranchCode:', movieTheaterBranchCode,
+                i
+            );
+            // if (typeof sellerId !== 'string') {
+            //     throw new Error('movieTheater not found');
+            // }
+            if (typeof sellerId === 'string') {
+                const newOrganizer: chevre.factory.event.screeningEventSeries.IOrganizer = {
+                    id: sellerId
+                };
+                console.log('updating event...', event.project.id, event.id, event.startDate, i);
+                await eventRepo.updatePartiallyById({
+                    project: { id: event.project.id },
+                    id: event.id,
+                    attributes: <any>{
+                        typeOf: event.typeOf,
+                        organizer: newOrganizer
+                    }
+                });
+                updateCount += 1;
+                console.log('updated.', event.project.id, event.id, event.startDate, i);
+            }
+        }
+    });
+
+    console.log(i, 'events checked');
+    console.log(updateCount, 'events updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateIAMMemberMemberOf.ts

@@ -0,0 +1,59 @@
+// 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: true });
+
+    const memberRepo = new chevre.repository.Member(mongoose.connection);
+
+    const cursor = memberRepo.getCursor(
+        {},
+        {
+            // _id: 1,
+        }
+    );
+    console.log('members found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const iamMember: chevre.factory.iam.IMember = doc.toObject();
+
+        const memberOfId = iamMember.member.memberOf?.id;
+        const alreadyMigrated = typeof memberOfId === 'string';
+
+        if (alreadyMigrated) {
+            console.log('already exist...', iamMember.project.id, iamMember.member.id, iamMember.member.typeOf, memberOfId, i);
+        } else {
+            console.log(
+                'updating reservation...', iamMember.project.id, iamMember.member.id, iamMember.member.typeOf, memberOfId, i);
+            await memberRepo.updateByMemberMemberOf({
+                project: { id: iamMember.project.id },
+                member: {
+                    id: iamMember.member.id,
+                    memberOf: {
+                        id: iamMember.project.id,
+                        typeOf: chevre.factory.organizationType.Project
+                    }
+                }
+            });
+            updateCount += 1;
+            console.log('updated.', iamMember.project.id, iamMember.member.id, iamMember.member.typeOf, memberOfId, i);
+        }
+    });
+
+    console.log(i, 'members checked');
+    console.log(updateCount, 'members updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateReservationProvider.ts

@@ -0,0 +1,119 @@
+// 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 reservationRepo = new chevre.repository.Reservation(mongoose.connection);
+    const placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const cursor = reservationRepo.getCursor(
+        {
+            typeOf: {
+                $in: [
+                    chevre.factory.reservationType.EventReservation
+                ]
+            },
+            // bookingTime: {
+            //     $gte: moment('2022-07-01T00:00:00Z')
+            //         .toDate(),
+            //     $lte: moment('2022-03-01T00:00:00Z')
+            //         .toDate()
+            // },
+            'provider.id': { $exists: false }
+        },
+        {
+            _id: 1,
+            project: 1,
+            provider: 1,
+            bookingTime: 1,
+            reservationFor: 1
+        }
+    );
+    console.log('reservations found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const reservation: Pick<
+            chevre.factory.reservation.IReservation<chevre.factory.reservationType.EventReservation>,
+            'id' | 'project' | 'provider' | 'bookingTime' | 'reservationFor'
+        > = doc.toObject();
+
+        const providerId = reservation.provider?.id;
+        const alreadyMigrated = typeof providerId === 'string';
+
+        if (alreadyMigrated) {
+            console.log('already exist...', reservation.project.id, reservation.id, reservation.bookingTime, providerId, i);
+        } else {
+            const movieTheaterId: string = reservation.reservationFor.superEvent.location.id;
+            const movieTheaterBranchCode: string = reservation.reservationFor.superEvent.location.branchCode;
+            const movieTheaters = <Pick<
+                chevre.factory.place.movieTheater.IPlaceWithoutScreeningRoom,
+                'parentOrganization' | 'branchCode'
+            >[]>
+                await placeRepo.searchMovieTheaters(
+                    {
+                        limit: 1,
+                        page: 1,
+                        project: { id: { $eq: reservation.project.id } },
+                        id: { $eq: movieTheaterId }
+                    },
+                    ['parentOrganization', 'branchCode'],
+                    []
+                );
+            const movieTheater = movieTheaters.shift();
+            const sellerId = movieTheater?.parentOrganization?.id;
+            console.log(
+                'movieTheater found',
+                reservation.project.id, reservation.id, reservation.bookingTime, providerId, 'sellerId:', sellerId,
+                'movieTheaterId:', movieTheaterId,
+                'movieTheaterBranchCode:', movieTheaterBranchCode,
+                i
+            );
+            if (typeof sellerId !== 'string') {
+                console.error(
+                    'movieTheater not found',
+                    reservation.project.id, reservation.id, reservation.bookingTime, providerId, 'sellerId:', sellerId,
+                    'movieTheaterId:', movieTheaterId,
+                    'movieTheaterBranchCode:', movieTheaterBranchCode,
+                    i
+                );
+                throw new Error('movieTheater not found');
+
+                // return;
+            }
+            if (typeof sellerId === 'string') {
+                const newProvider: chevre.factory.reservation.IProvider = {
+                    id: sellerId,
+                    typeOf: chevre.factory.organizationType.Corporation
+                };
+                console.log(
+                    'updating reservation...', reservation.project.id, reservation.id, reservation.bookingTime, providerId, i, updateCount);
+                await reservationRepo.updatePartiallyById({
+                    id: reservation.id,
+                    update: <any>{
+                        provider: newProvider
+                    }
+                });
+                updateCount += 1;
+                console.log('updated.', reservation.project.id, reservation.id, reservation.bookingTime, providerId, i, updateCount);
+            }
+        }
+    });
+
+    console.log(i, 'reservations checked');
+    console.log(updateCount, 'reservations updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateScreeningRoomOrganizer.ts

@@ -0,0 +1,91 @@
+// 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: true });
+
+    const placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const cursor = placeRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            // 'project.id': { $ne: EXCLUDED_PROJECT_ID },
+            typeOf: {
+                $in: [
+                    chevre.factory.placeType.ScreeningRoom
+                ]
+            }
+            // organizer: { $exists: false }
+        },
+        {
+            containsPlace: 0
+        }
+    );
+    console.log('places found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const screeningRoom: chevre.factory.place.screeningRoom.IPlace = doc.toObject();
+        console.log(screeningRoom);
+
+        const organizerId = screeningRoom.parentOrganization?.id;
+        const alreadyMigrated = typeof organizerId === 'string';
+
+        if (alreadyMigrated) {
+            console.log('already exist...', screeningRoom.project.id, screeningRoom.branchCode, organizerId, i);
+        } else {
+            const movieTheaterId = screeningRoom.containedInPlace?.id;
+            if (typeof movieTheaterId !== 'string') {
+                throw new Error('containedInPlace?.id undefined');
+            }
+            const movieTheaters = <Pick<chevre.factory.place.movieTheater.IPlaceWithoutScreeningRoom, 'parentOrganization'>[]>
+                await placeRepo.searchMovieTheaters(
+                    {
+                        limit: 1,
+                        page: 1,
+                        project: { id: { $eq: screeningRoom.project.id } },
+                        id: { $eq: movieTheaterId }
+                    },
+                    ['parentOrganization'],
+                    []
+                );
+            const movieTheater = movieTheaters.shift();
+            const sellerId = movieTheater?.parentOrganization?.id;
+            console.log('movieTheater found', screeningRoom.project.id, screeningRoom.branchCode, 'sellerId:', sellerId, i);
+            // if (typeof sellerId !== 'string') {
+            //     throw new Error('movieTheater not found');
+            // }
+            if (typeof sellerId === 'string') {
+                const newParentOrganization: chevre.factory.place.screeningRoom.IParentOrganization = {
+                    id: sellerId,
+                    typeOf: chevre.factory.organizationType.Corporation
+                };
+                console.log('updating room...', screeningRoom.project.id, screeningRoom.branchCode, i);
+                await placeRepo.addParentOrganization2ScreeningRoom({
+                    project: screeningRoom.project,
+                    branchCode: screeningRoom.branchCode,
+                    containedInPlace: { branchCode: String(screeningRoom.containedInPlace?.branchCode) },
+                    parentOrganization: newParentOrganization
+                });
+                updateCount += 1;
+                console.log('updated.', screeningRoom.project.id, screeningRoom.branchCode, i);
+            }
+        }
+    });
+
+    console.log(i, 'rooms checked');
+    console.log(updateCount, 'rooms updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/processReserve.ts

@@ -69,7 +69,6 @@ async function main() {
         validateEvent: false,
         validateEventOfferPeriod: false,
         validateAppliesToMovieTicket: true,
-        disablePendingReservations: true,
         stockHoldUntilDaysAfterEventEnd: 31,
         useHoldStockByTransactionNumber: true
     })({