@chevre/domain 21.2.0-alpha.98 → 21.2.0

package/example/src/chevre/migrateCategoryCodeAdditionalProperties.ts

@@ -0,0 +1,116 @@
+// 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 additionalPropertyRepo = new chevre.repository.AdditionalProperty(mongoose.connection);
+    const categoryCodeRepo = new chevre.repository.CategoryCode(mongoose.connection);
+
+    const cursor = categoryCodeRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            // 'project.id': { $ne: EXCLUDED_PROJECT_ID },
+        },
+        {
+            // paymentMethods: 1,
+            // project: 1,
+            // orderDate: 1
+        }
+    );
+    console.log('categoryCodes found');
+
+    const additionalPropertyNames: string[] = [];
+    const projectIds: string[] = [];
+    const unexpextedprojectIds: string[] = [];
+    let checked: number = 0;
+    let created: number = 0;
+
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const categoryCode: chevre.factory.categoryCode.ICategoryCode = doc.toObject();
+
+        const additionalPropertyNamesOnResource = (Array.isArray(categoryCode.additionalProperty))
+            ? categoryCode.additionalProperty?.map((p) => p.name)
+            : [];
+        if (Array.isArray(additionalPropertyNamesOnResource) && additionalPropertyNamesOnResource.length > 0) {
+            console.log(
+                additionalPropertyNamesOnResource.join(','),
+                additionalPropertyNamesOnResource.length,
+                'additionalPropertyNamesOnResource found',
+                categoryCode.project.id,
+                categoryCode.codeValue
+            );
+            additionalPropertyNames.push(...additionalPropertyNamesOnResource);
+            projectIds.push(categoryCode.project.id);
+            additionalPropertyNamesOnResource.forEach((name) => {
+                if (!name.match(/^[a-zA-Z]*$/)) {
+                    // throw new Error(`not matched ${creativeWork.project.id} ${creativeWork.id}`);
+                    unexpextedprojectIds.push(categoryCode.project.id);
+                }
+                // tslint:disable-next-line:no-magic-numbers
+                if (name.length < 5) {
+                    // throw new Error(`length matched ${creativeWork.project.id} ${creativeWork.id} ${name}`);
+                    unexpextedprojectIds.push(categoryCode.project.id);
+                }
+            });
+
+            for (const additionalPropertyNameOnResource of additionalPropertyNamesOnResource) {
+                checked += 1;
+                const existingAdditionalProperties = await additionalPropertyRepo.search({
+                    limit: 1,
+                    project: { id: { $eq: categoryCode.project.id } },
+                    codeValue: { $eq: additionalPropertyNameOnResource },
+                    inCodeSet: { identifier: { $eq: categoryCode.typeOf } }
+                });
+                if (existingAdditionalProperties.length === 0) {
+                    const additionalProperty: chevre.factory.additionalProperty.IAdditionalProperty = {
+                        project: categoryCode.project,
+                        // id?: string;
+                        typeOf: 'CategoryCode',
+                        codeValue: additionalPropertyNameOnResource,
+                        inCodeSet: {
+                            typeOf: 'CategoryCodeSet',
+                            identifier: categoryCode.typeOf
+                        },
+                        name: { ja: additionalPropertyNameOnResource }
+                    };
+                    await additionalPropertyRepo.save({ attributes: additionalProperty });
+                    created += 1;
+                    console.log(
+                        'additionalProerty created',
+                        additionalPropertyNameOnResource,
+                        categoryCode.project.id,
+                        categoryCode.codeValue
+                    );
+                } else {
+                    console.log(
+                        'additionalProerty existed',
+                        additionalPropertyNameOnResource,
+                        categoryCode.project.id,
+                        categoryCode.codeValue
+                    );
+                }
+
+            }
+        }
+    });
+    console.log(i, 'categoryCodes checked');
+    console.log('additionalPropertyNames:', [...new Set(additionalPropertyNames)]);
+    console.log('projectIds:', [...new Set(projectIds)]);
+    console.log('unexpextedprojectIds:', [...new Set(unexpextedprojectIds)]);
+    console.log('checked:', checked);
+    console.log('created:', created);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateScreeningEventSeriesVersion.ts

@@ -0,0 +1,79 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { typeOf: chevre.factory.organizationType.Project, id: String(process.env.PROJECT_ID) };
+
+const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            'project.id': {
+                // $eq: project.id,
+                $ne: EXCLUDED_PROJECT_ID
+            },
+            typeOf: { $eq: chevre.factory.eventType.ScreeningEventSeries },
+            'workPerformed.version': { $exists: false }
+            // _id: { $eq: 'bl7ed6sq9' }
+        },
+        {
+            _id: 1,
+            workPerformed: 1,
+            project: 1,
+            location: 1,
+            startDate: 1,
+            typeOf: 1
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: chevre.factory.event.screeningEventSeries.IEvent = doc.toObject();
+        const version = event.workPerformed.version;
+
+        const alreadyMigrated = typeof version === 'string' && version.length > 0;
+
+        if (alreadyMigrated) {
+            console.log('alreadyMigrated.', event.project.id, event.id, event.startDate, version, i);
+        } else {
+            // 既存施設コンテンツバージョンを検索
+            const { maxVersion } = await eventRepo.aggregateScreeningEventMaxVersion({
+                project: { id: { $eq: event.project.id } },
+                workPerformed: { identifier: { $eq: event.workPerformed.identifier } },
+                location: { branchCode: { $in: [event.location.branchCode] } }
+            });
+            console.log('maxVersion:', maxVersion);
+
+            const newVersion: string = `${Number(maxVersion) + 1}`;
+            console.log('updating event...', event.project.id, event.id, event.startDate, newVersion, i);
+            await eventRepo.updatePartiallyById({
+                id: event.id,
+                attributes: <any>{
+                    typeOf: event.typeOf,
+                    'workPerformed.version': newVersion
+                }
+            });
+            updateCount += 1;
+            console.log('updated.', event.project.id, event.id, event.startDate, newVersion, i);
+        }
+    });
+
+    console.log(i, 'events checked');
+    console.log(updateCount, 'events updated');
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/processPay.ts

@@ -63,8 +63,11 @@ async function main() {
                 name: 'xx'
             }
         },
-        true,
-        false
+        {
+            useCheckMovieTicketBeforePay: true,
+            useCheckByIdentifierIfNotYet: true,
+            searchTrade4accountId: false
+        }
     )({
         accountingReport: accountingReportRepo,
         action: actionRepo,

package/example/src/chevre/processRegisterMembership.ts

@@ -21,10 +21,14 @@ async function main() {
     const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
 
     // プロダクト検索
-    const products = await productRepo.search({
-        project: { id: { $eq: project.id } },
-        typeOf: { $eq: chevre.factory.product.ProductType.MembershipService }
-    });
+    const products = await productRepo.search(
+        {
+            project: { id: { $eq: project.id } },
+            typeOf: { $eq: chevre.factory.product.ProductType.MembershipService }
+        },
+        [],
+        []
+    );
     console.log(products);
 
     const product = products[0];

package/example/src/chevre/processRegisterPaymentCard.ts

@@ -21,10 +21,14 @@ async function main() {
     const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
 
     // プロダクト検索
-    const products = await productRepo.search({
-        project: { id: { $eq: project.id } },
-        typeOf: { $eq: chevre.factory.product.ProductType.PaymentCard }
-    });
+    const products = await productRepo.search(
+        {
+            project: { id: { $eq: project.id } },
+            typeOf: { $eq: chevre.factory.product.ProductType.PaymentCard }
+        },
+        [],
+        []
+    );
     console.log(products);
 
     const product = products[0];

package/example/src/chevre/processReserve.ts

@@ -30,7 +30,7 @@ async function main() {
     const priceSpecRepo = new chevre.repository.PriceSpecification(mongoose.connection);
     const reservationRepo = new chevre.repository.Reservation(mongoose.connection);
     const eventRepo = new chevre.repository.Event(mongoose.connection);
-    const itemAvailabilityRepo = new chevre.repository.StockHolder(client);
+    const itemAvailabilityRepo = new chevre.repository.StockHolder(client, mongoose.connection);
     const offerRateLimitRepo = new chevre.repository.rateLimit.Offer(client);
 
     const identifier = `CIN${(new Date()).valueOf()}`;

package/example/src/chevre/searchAbortedTasks.ts

@@ -9,24 +9,22 @@ async function main() {
 
     const taskRepo = new chevre.repository.Task(mongoose.connection);
 
-    const tasks = <chevre.factory.task.ITask<chevre.factory.taskName.ConfirmPayTransaction>[]>await taskRepo.search({
+    const tasks = <chevre.factory.task.ITask<chevre.factory.taskName.ConfirmReserveTransaction>[]>await taskRepo.search({
         // limit: 100,
         // page: 1,
         name: {
-            $in: [chevre.factory.taskName.ConfirmPayTransaction]
+            $in: [chevre.factory.taskName.ConfirmReserveTransaction]
             // $nin: [
             //     chevre.factory.taskName.ImportEventsFromCOA,
             //     chevre.factory.taskName.ImportEventCapacitiesFromCOA
             // ]
         },
         statuses: [chevre.factory.taskStatus.Aborted],
-        runsFrom: moment('2023-05-02T22:00:00Z')
+        runsFrom: moment('2023-06-02T22:00:00Z')
             .toDate(),
         sort: { runsAt: chevre.factory.sortType.Ascending }
     });
-    console.log(tasks.map((task) => `${task.project.id},${task.id},${task.name},${moment(task.runsAt)
-        .tz('Asia/Tokyo')
-        .format('YYYY-MM-DDTHH:mm:ssZ')},"${task.data.object[0]?.transactionNumber}"`)
+    console.log(tasks.map((task) => `${task.data.object?.transactionNumber}`)
         .join('\n'));
     console.log(tasks.length);
 }

package/example/src/chevre/searchActions.ts

@@ -0,0 +1,33 @@
+// tslint:disable:no-implicit-dependencies no-console
+import { chevre } from '../../../lib/index';
+
+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: true });
+
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+    const actions = await actionRepo.search(
+        {
+            typeOf: { $eq: chevre.factory.actionType.CheckAction },
+            // project: { id: { $eq: project.id } },
+            object: {
+                movieTickets: {
+                    identifier: { $eq: '0947524082' },
+                    serviceOutput: { reservationFor: { id: { $eq: 'clhvvbpyn' } } }
+                }
+            }
+        },
+        ['_id'],
+        []
+    );
+    console.log('actions:', actions);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/searchEventSeats.ts

@@ -1,9 +1,10 @@
 // tslint:disable:no-console
+import * as  mongoose from 'mongoose';
 import * as redis from 'redis';
 
 import { chevre } from '../../../lib/index';
 
-// const project = { id: String(process.env.PROJECT_ID) };
+const project = { id: String(process.env.PROJECT_ID) };
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
@@ -16,11 +17,13 @@ async function main() {
     });
     await client.connect();
 
-    const itemAvailabilityRepo = new chevre.repository.StockHolder(client);
+    const itemAvailabilityRepo = new chevre.repository.StockHolder(client, mongoose.connection);
 
     const result = await itemAvailabilityRepo.searchHolders({
+        project,
         eventId: 'alckc9mlx',
         startDate: new Date(),
+        hasTicketedSeat: true,
         offers: [
             {
                 seatSection: 'Default',

package/example/src/chevre/searchHoldReservations.ts

@@ -0,0 +1,38 @@
+// tslint:disable:no-console
+// import * as redis from 'redis';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: true });
+    const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+        socket: {
+            host: process.env.REDIS_HOST,
+            port: Number(process.env.REDIS_PORT)
+        },
+        password: process.env.REDIS_KEY
+    });
+    await client.connect();
+
+    const stockHolderRepo = new chevre.repository.StockHolder(client, mongoose.connection);
+
+    const holdReservations = await stockHolderRepo.search({
+        limit: 2,
+        page: 2,
+        sort: { 'reservationFor.startDate': chevre.factory.sortType.Ascending }
+    });
+    console.log(holdReservations);
+    console.log(holdReservations.length);
+
+    // const aggregations = await stockHolderRepo.aggregateByReservationFor({
+    //     limit: 100,
+    //     page: 1
+    // });
+    // console.log(aggregations);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchPermissions.ts

@@ -0,0 +1,54 @@
+// 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 memberId = 'xxx';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const memberRepo = new chevre.repository.Member(mongoose.connection);
+    const roleRepo = new chevre.repository.Role(mongoose.connection);
+
+    let now: Date;
+
+    // let now = new Date();
+    // const aggregateRoleNamesResult = await memberRepo.aggregateRoleNames({
+    //     project: { id: { $eq: PROJECT_ID } },
+    //     member: { id: { $eq: memberId } }
+    // });
+
+    // const aggregatePermissionsResult = await roleRepo.aggregatePermissions({
+    //     roleName: {
+    //         $in: aggregateRoleNamesResult.map((r) => r.roleName)
+    //     }
+    // });
+    // console.log('time cost:', moment()
+    //     .diff(now));
+
+    now = new Date();
+    const searchPermissionsResult = await chevre.service.iam.searchPermissions({
+        project: { id: PROJECT_ID },
+        member: { id: memberId }
+    })({
+        member: memberRepo,
+        role: roleRepo
+    });
+    console.log('time cost:', moment()
+        .diff(now));
+
+    console.log(searchPermissionsResult);
+    console.log(searchPermissionsResult.permissions.length);
+
+    // console.log(aggregateRoleNamesResult);
+    // console.log(aggregateRoleNamesResult.length);
+    // console.log(aggregatePermissionsResult);
+    // console.log(aggregatePermissionsResult.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchScreeningRooms.ts

@@ -0,0 +1,35 @@
+// 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 placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const rooms = await placeRepo.searchScreeningRooms(
+        {
+            limit: 10,
+            page: 1,
+            $projection: { sectionCount: 1 }
+        },
+        true
+    );
+    console.log('place found', rooms);
+    const filteredRooms = rooms.filter((room) => typeof room.sectionCount === 'number' && room.sectionCount > 1);
+    console.log(filteredRooms.length, 'filteredRooms found');
+
+    const screeningRoom = await placeRepo.findScreeningRoomsByBranchCode({
+        branchCode: { $eq: rooms[0].branchCode },
+        containedInPlace: { id: { $eq: String(rooms[0].containedInPlace?.id) } },
+        useScreeningRoomType: true
+    });
+    console.log('screeningRoom found', screeningRoom);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/sendEmailMessage.ts

@@ -61,8 +61,7 @@ async function main() {
             },
             customer: {
                 typeOf: chevre.factory.creativeWorkType.WebApplication,
-                id: 'xxxx',
-                name: '****'
+                id: 'xxxx'
             },
             orderNumber: 'CIN1-3970498-5700993',
             price: 0,

package/example/src/chevre/syncScreeningRooms.ts

@@ -0,0 +1,22 @@
+// 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 placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    await placeRepo.syncScreeningRooms({
+        id: '60409176f60a46000a7a3787',
+        useScreeningRoomType: true
+    });
+    console.log('synced');
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/syncScreeningRoomsAll.ts

@@ -0,0 +1,44 @@
+// 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 placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const cursor = placeRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.placeType.MovieTheater }
+        },
+        {
+            _id: 1,
+            name: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('places found');
+
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const { id, name, project, typeOf } = <Pick<chevre.factory.place.movieTheater.IPlace, 'id' | 'name' | 'project' | 'typeOf'>>
+            doc.toObject();
+
+        console.log('syncing...', project.id, typeOf, id, name.ja, i);
+        await placeRepo.syncScreeningRooms({
+            id,
+            useScreeningRoomType: true
+        });
+        console.log('synced.', project.id, typeOf, id, name.ja, i);
+    });
+
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/unsetContainsInPlaceFromMovieTheater.ts

@@ -0,0 +1,41 @@
+// 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 placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const cursor = placeRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.placeType.MovieTheater }
+        },
+        {
+            _id: 1,
+            name: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('places found');
+
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const { id, name, project, typeOf } = <Pick<chevre.factory.place.movieTheater.IPlace, 'id' | 'name' | 'project' | 'typeOf'>>
+            doc.toObject();
+
+        console.log('unset processing...', project.id, typeOf, id, name.ja, i);
+        const result = await placeRepo.unsetContainsPlaceFromMovieTheater({ id });
+        console.log('unset processed.', project.id, typeOf, id, name.ja, result?.id, i);
+    });
+
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/lib/chevre/factory/order.d.ts

@@ -1,6 +1,9 @@
 import * as factory from '../factory';
 export declare const AWARD_ACCOUNTS_IDENTIFIER_NAME = "awardAccounts";
+export type IMaskedCustomer = factory.order.ICustomer | Pick<factory.order.ICustomer, 'id' | 'typeOf'>;
 /**
  * 個人情報のマスクされたカスタマーを作成する
  */
-export declare function createMaskedCustomer(order: Pick<factory.order.IOrder, 'customer'>): factory.order.ICustomer;
+export declare function createMaskedCustomer(order: Pick<factory.order.IOrder, 'customer'>, options: {
+    noProfile: boolean;
+}): IMaskedCustomer;

package/lib/chevre/factory/order.js

@@ -6,11 +6,24 @@ const MASKED_PROFILE = '****';
 /**
  * 個人情報のマスクされたカスタマーを作成する
  */
-function createMaskedCustomer(order) {
-    return Object.assign(Object.assign({}, order.customer), { 
-        // ↓identifierも隠蔽
-        identifier: [], 
-        // ↓additionalPropertyも隠蔽
-        additionalProperty: [], email: MASKED_PROFILE, telephone: MASKED_PROFILE, name: MASKED_PROFILE, familyName: MASKED_PROFILE, givenName: MASKED_PROFILE });
+function createMaskedCustomer(order, options) {
+    // noProfileに対応する(2023-07-03~)
+    if ((options === null || options === void 0 ? void 0 : options.noProfile) === true) {
+        return {
+            id: order.customer.id,
+            typeOf: order.customer.typeOf
+            // ↓identifierも隠蔽
+            // identifier: [],
+            // ↓additionalPropertyも隠蔽
+            // additionalProperty: [],
+        };
+    }
+    else {
+        return Object.assign(Object.assign({}, order.customer), { 
+            // ↓identifierも隠蔽
+            identifier: [], 
+            // ↓additionalPropertyも隠蔽
+            additionalProperty: [], email: MASKED_PROFILE, telephone: MASKED_PROFILE, name: MASKED_PROFILE, familyName: MASKED_PROFILE, givenName: MASKED_PROFILE });
+    }
 }
 exports.createMaskedCustomer = createMaskedCustomer;

package/lib/chevre/repo/account.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoRepository = void 0;
 const account_1 = require("./mongoose/schemas/account");
 const factory = require("../factory");
+const settings_1 = require("../settings");
 /**
  * 口座リポジトリ
  */
@@ -390,7 +391,7 @@ class MongoRepository {
         return __awaiter(this, void 0, void 0, function* () {
             const conditions = MongoRepository.CREATE_MONGO_CONDITIONS(params);
             return this.accountModel.countDocuments((conditions.length > 0) ? { $and: conditions } : {})
-                .setOptions({ maxTimeMS: 10000 })
+                .setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
                 .exec();
         });
     }
@@ -419,7 +420,7 @@ class MongoRepository {
             if (((_a = params.sort) === null || _a === void 0 ? void 0 : _a.openDate) !== undefined) {
                 query.sort({ openDate: params.sort.openDate });
             }
-            return query.setOptions({ maxTimeMS: 10000 })
+            return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
                 .exec()
                 .then((docs) => docs.map((doc) => doc.toObject()));
         });