@chevre/domain 28.0.0-alpha.4 → 28.0.0-alpha.40

package/lib/chevre/repo/adminAccountTitleCategory.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminAccountTitleCategoryRepo = void 0;
+const factory_1 = require("../factory");
+const settings_1 = require("../settings");
+const accountTitle_1 = require("./mongoose/schemas/accountTitle");
+function createFilterQueries(params) {
+    const conditions = [];
+    const projectIdEq = params.project?.id?.$eq;
+    if (typeof projectIdEq === 'string') {
+        conditions.push({ 'project.id': { $eq: projectIdEq } });
+    }
+    if (typeof params.codeValue === 'string') {
+        conditions.push({ codeValue: { $exists: true, $regex: new RegExp(params.codeValue) } });
+    }
+    else {
+        const codeValueEq = params.codeValue?.$eq;
+        if (typeof codeValueEq === 'string') {
+            conditions.push({ codeValue: { $exists: true, $eq: codeValueEq } });
+        }
+    }
+    const nameRegex = params.name;
+    if (typeof nameRegex === 'string') {
+        conditions.push({ name: { $exists: true, $regex: new RegExp(nameRegex) } });
+    }
+    return conditions;
+}
+/**
+ * 科目分類管理リポジトリ
+ */
+class AdminAccountTitleCategoryRepo {
+    accountTitleModel;
+    constructor(connection) {
+        this.accountTitleModel = connection.model(accountTitle_1.modelName, (0, accountTitle_1.createSchema)());
+    }
+    async findAccountTitleCategorAsNotification(params) {
+        const { id, projectId } = params;
+        const doc = await this.accountTitleModel.findOne({
+            _id: { $eq: id },
+            'project.id': { $eq: projectId }
+        }, {
+            _id: 0,
+            id: { $toString: '$_id' },
+            codeValue: 1,
+            hasCategoryCode: 1,
+            name: 1,
+            project: 1,
+            typeOf: 1
+        })
+            .lean()
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound('AccountTitleCategory');
+        }
+        return doc;
+    }
+    async deleteAccountTitleCategoriesByProject(params) {
+        await this.accountTitleModel.deleteMany({
+            'project.id': { $exists: true, $eq: params.project.id }
+        })
+            .exec();
+    }
+    async addAccountTitleCategory(params) {
+        const { codeValue, name, project } = params;
+        const creatingAccountTitle = {
+            codeValue,
+            hasCategoryCode: [],
+            name,
+            project,
+            typeOf: 'AccountTitle'
+        };
+        const doc = await this.accountTitleModel.create(creatingAccountTitle);
+        return { id: doc.id };
+    }
+    async updateAccountTitleCategory(params) {
+        const { codeValue, name, project } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: codeValue }
+        }, {
+            $set: { name }
+        }, {
+            new: true,
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+    async findAccountTitleCategories(params) {
+        const query = this.accountTitleModel.find({ $and: createFilterQueries(params) }, {
+            _id: 0,
+            codeValue: 1,
+            name: 1,
+        });
+        if (typeof params.limit === 'number' && typeof params.page === 'number') {
+            query.limit(params.limit)
+                .skip(params.limit * (params.page - 1));
+        }
+        if (typeof params.sort?.codeValue === 'number') {
+            query.sort({ codeValue: params.sort.codeValue });
+        }
+        return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean()
+            .exec();
+    }
+    async deleteAccountTitleCategoryByCodeValue(params) {
+        const { projectId, codeValue } = params;
+        await this.accountTitleModel.findOneAndDelete({
+            'project.id': { $eq: projectId },
+            codeValue: { $eq: codeValue }
+        })
+            .exec()
+            .then((doc) => {
+            if (doc === null) {
+                throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+            }
+        });
+    }
+    async unsetUnnecessaryFields(params) {
+        return this.accountTitleModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
+            .exec();
+    }
+}
+exports.AdminAccountTitleCategoryRepo = AdminAccountTitleCategoryRepo;

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

@@ -0,0 +1,42 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+type IFindParams = Pick<factory.accountTitle.ISearchConditions, 'codeValue' | 'limit' | 'name' | 'page' | 'project'> & {
+    inCodeSet?: {
+        codeValue?: string | {
+            $eq?: string;
+        };
+    };
+};
+type IAccountTitleSetAsFindResult = Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name'> & {
+    inCodeSet: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name'>;
+};
+/**
+ * 科目管理リポジトリ
+ */
+export declare class AdminAccountTitleSetRepo {
+    private readonly accountTitleModel;
+    constructor(connection: Connection);
+    addAccountTitleSet(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project'> & {
+        inCodeSet: {
+            codeValue: string;
+        };
+    }): Promise<{
+        id: string;
+    }>;
+    updateAccountTitleSet(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project'> & {
+        inCodeSet: {
+            codeValue: string;
+        };
+    }): Promise<{
+        id: string;
+    }>;
+    findAccountTitleSets(params: IFindParams): Promise<IAccountTitleSetAsFindResult[]>;
+    deleteAccountTitleSetByCodeValue(params: {
+        projectId: string;
+        accountTitleCategoryCode: string;
+        codeValue: string;
+    }): Promise<{
+        id: string;
+    }>;
+}
+export {};

package/lib/chevre/repo/adminAccountTitleSet.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminAccountTitleSetRepo = void 0;
+const factory_1 = require("../factory");
+const accountTitle_1 = require("./mongoose/schemas/accountTitle");
+function createMatchStages(params) {
+    const matchStages = [];
+    if (typeof params.project?.id?.$eq === 'string') {
+        matchStages.push({ $match: { 'project.id': { $eq: params.project.id.$eq } } });
+    }
+    if (typeof params.codeValue === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.codeValue': { $exists: true, $regex: new RegExp(params.codeValue) } }
+        });
+    }
+    else if (params.codeValue !== undefined && params.codeValue !== null) {
+        if (typeof params.codeValue.$eq === 'string') {
+            matchStages.push({
+                $match: { 'hasCategoryCode.codeValue': { $exists: true, $eq: params.codeValue.$eq } }
+            });
+        }
+    }
+    if (params.inCodeSet !== undefined) {
+        if (typeof params.inCodeSet.codeValue === 'string') {
+            matchStages.push({
+                $match: { codeValue: { $exists: true, $regex: new RegExp(params.inCodeSet.codeValue) } }
+            });
+        }
+        else if (params.inCodeSet.codeValue !== undefined && params.inCodeSet.codeValue !== null) {
+            if (typeof params.inCodeSet.codeValue.$eq === 'string') {
+                matchStages.push({
+                    $match: { codeValue: { $exists: true, $eq: params.inCodeSet.codeValue.$eq } }
+                });
+            }
+        }
+    }
+    const nameRegex = params.name;
+    if (typeof nameRegex === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.name': { $exists: true, $regex: new RegExp(nameRegex) } }
+        });
+    }
+    return matchStages;
+}
+/**
+ * 科目管理リポジトリ
+ */
+class AdminAccountTitleSetRepo {
+    accountTitleModel;
+    constructor(connection) {
+        this.accountTitleModel = connection.model(accountTitle_1.modelName, (0, accountTitle_1.createSchema)());
+    }
+    async addAccountTitleSet(params) {
+        const { codeValue, name, project, inCodeSet } = params;
+        // 科目分類の存在確認
+        const categoryDoc = await this.accountTitleModel.findOne({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.codeValue }
+        }, { _id: 1 })
+            .exec();
+        if (categoryDoc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        const newAccountTitleSet = {
+            typeOf: 'AccountTitle',
+            codeValue,
+            hasCategoryCode: [],
+            ...(name !== undefined) && { name }
+        };
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $ne: codeValue }
+        }, {
+            $push: { hasCategoryCode: newAccountTitleSet }
+        }, {
+            new: true,
+            projection: { _id: 1 }
+        })
+            .exec();
+        // 存在しなければ科目コード重複
+        if (doc === null) {
+            throw new factory_1.factory.errors.AlreadyInUse(accountTitle_1.modelName, ['hasCategoryCode.codeValue']);
+        }
+        return { id: doc.id };
+    }
+    async updateAccountTitleSet(params) {
+        const { codeValue, name, project, inCodeSet } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $eq: codeValue }
+        }, {
+            'hasCategoryCode.$[accountTitleSet].name': name,
+        }, {
+            new: true,
+            arrayFilters: [
+                { 'accountTitleSet.codeValue': codeValue }
+            ],
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+    async findAccountTitleSets(params) {
+        const aggregate = this.accountTitleModel.aggregate([
+            { $unwind: '$hasCategoryCode' },
+            ...createMatchStages(params),
+            {
+                $project: {
+                    _id: 0,
+                    codeValue: '$hasCategoryCode.codeValue',
+                    name: '$hasCategoryCode.name',
+                    inCodeSet: {
+                        codeValue: '$codeValue',
+                        name: '$name'
+                    },
+                }
+            }
+        ]);
+        if (typeof params.limit === 'number' && typeof params.page === 'number') {
+            aggregate.skip(params.limit * (params.page - 1))
+                .limit(params.limit);
+        }
+        return aggregate.exec();
+    }
+    async deleteAccountTitleSetByCodeValue(params) {
+        const { projectId, accountTitleCategoryCode, codeValue } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: projectId },
+            codeValue: { $eq: accountTitleCategoryCode },
+            'hasCategoryCode.codeValue': { $exists: true, $eq: codeValue }
+        }, {
+            $pull: { hasCategoryCode: { codeValue } }
+        }, {
+            new: true,
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+}
+exports.AdminAccountTitleSetRepo = AdminAccountTitleSetRepo;

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

@@ -100,7 +100,7 @@ export declare class AdminEventRepo {
         project: {
             id: string;
         };
-        superEventFromDB: Pick<factory.eventSeries.IEvent, 'additionalProperty' | 'alternativeHeadline' | 'description' | 'dubLanguage' | 'endDate' | 'headline' | 'id' | 'kanaName' | 'location' | 'name' | 'soundFormat' | 'startDate' | 'subtitleLanguage' | 'typeOf' | 'workPerformed'>;
+        superEventFromDB: Pick<factory.eventSeries.IEvent, 'additionalProperty' | 'alternativeHeadline' | 'description' | 'dubLanguage' | 'endDate' | 'headline' | 'id' | 'kanaName' | 'location' | 'name' | 'startDate' | 'subtitleLanguage' | 'typeOf' | 'workPerformed'>;
         startDate: {
             $gte: Date;
         };
@@ -170,9 +170,6 @@ export declare class AdminEventRepo {
         };
     }): Promise<mongo.DeleteResult>;
     deleteManyEventsEndedByProject(params: {
-        typeOf: {
-            $in: factory.eventType.ScreeningEvent[];
-        };
         project: {
             id: string;
         };
@@ -181,9 +178,6 @@ export declare class AdminEventRepo {
         };
     }): Promise<mongo.DeleteResult>;
     deleteManyEventsEnded(params: {
-        typeOf: {
-            $eq: factory.eventType.ScreeningEvent;
-        };
         endDate: {
             $lte: Date;
         };

package/lib/chevre/repo/adminEvent.js

@@ -155,8 +155,7 @@ class AdminEventRepo {
         }
         const doc = await this.eventModel.findOneAndUpdate({
             _id: { $eq: params.id },
-            'project.id': { $eq: params.project.id },
-            typeOf: { $eq: typeOf }
+            'project.id': { $eq: params.project.id }
         }, {
             $set: updateFields
         }, { upsert: false, new: false, projection: { _id: 1 } })
@@ -187,8 +186,7 @@ class AdminEventRepo {
         }
         try {
             doc = await this.eventModel.findOneAndUpdate({
-                _id: { $eq: params.id },
-                typeOf: { $eq: typeOf }
+                _id: { $eq: params.id }
             }, {
                 // 編集のためのみのメソッドになったので、setOnInsertは廃止(2025-10-27~)
                 // 上書き禁止属性を除外(2022-08-24~)
@@ -231,8 +229,7 @@ class AdminEventRepo {
                     bulkWriteOps.push({
                         updateOne: {
                             filter: {
-                                _id: p.id,
-                                typeOf: p.attributes.typeOf
+                                _id: p.id
                             },
                             update: {
                                 $setOnInsert: {
@@ -279,7 +276,6 @@ class AdminEventRepo {
     async syncScreeningEventSeries2screeningEvents(params) {
         const superEvent = EventFactory.minimizeSuperEvent({ superEventFromDB: params.superEventFromDB });
         await this.eventModel.updateMany({
-            typeOf: { $eq: factory_1.factory.eventType.ScreeningEvent },
             'project.id': { $eq: params.project.id },
             'superEvent.id': { $exists: true, $eq: params.superEventFromDB.id },
             startDate: { $gte: params.startDate.$gte }
@@ -338,7 +334,6 @@ class AdminEventRepo {
     }
     async deleteManyEventsEndedByProject(params) {
         return this.eventModel.deleteMany({
-            typeOf: { $in: params.typeOf.$in },
             'project.id': { $eq: params.project.id },
             endDate: { $lte: params.endDate.$lte }
         })
@@ -346,7 +341,6 @@ class AdminEventRepo {
     }
     async deleteManyEventsEnded(params) {
         return this.eventModel.deleteMany({
-            typeOf: { $eq: params.typeOf.$eq },
             endDate: { $lte: params.endDate.$lte }
         })
             .exec();

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

@@ -0,0 +1,67 @@
+import type { Connection, FilterQuery, mongo } from 'mongoose';
+import { factory } from '../factory';
+type IUnset = {
+    [key in keyof factory.eventSeries.IEvent]?: 1;
+};
+/**
+ * 施設コンテンツ管理リポジトリ
+ */
+export declare class AdminEventSeriesRepo {
+    private readonly eventSeriesModel;
+    constructor(connection: Connection);
+    /**
+     * 施設+コンテンツ+バージョンをキーにして冪等置換
+     */
+    upsertByVersion(params: {
+        $set: factory.eventSeries.IAttributes;
+        $unset?: IUnset;
+    }[], options: {
+        /**
+         * falseの場合setOnInsertのみ
+         * trueの場合setOnInsert+setのみ
+         */
+        upsert: boolean;
+    }): Promise<{
+        bulkWriteResult?: mongo.BulkWriteResult;
+        modifiedEvents: {
+            id: string;
+        }[];
+    }>;
+    /**
+     * sskts施設コンテンツ保管
+     */
+    upsertManyEventSeriesById4sskts(params: {
+        id: string;
+        attributes: factory.eventSeries.IAttributes;
+    }[]): Promise<void>;
+    deleteEventSeriesById(params: {
+        project: {
+            id: string;
+        };
+        id: string;
+    }): Promise<void>;
+    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, factory.eventSeries.IAttributes & {
+        _id: string;
+    }, import("./mongoose/virtuals").IVirtuals, {}> & factory.eventSeries.IAttributes & {
+        _id: string;
+    } & Required<{
+        _id: string;
+    }> & {
+        __v: number;
+    }, import("mongoose").QueryOptions<factory.eventSeries.IAttributes & {
+        _id: string;
+    }>, (import("mongoose").Document<unknown, Record<string, never>, factory.eventSeries.IAttributes & {
+        _id: string;
+    }, import("./mongoose/virtuals").IVirtuals, {}> & factory.eventSeries.IAttributes & {
+        _id: string;
+    } & Required<{
+        _id: string;
+    }> & {
+        __v: number;
+    }) | null>;
+    unsetUnnecessaryFields(params: {
+        filter: FilterQuery<factory.eventSeries.IEvent>;
+        $unset: IUnset;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+}
+export {};

package/lib/chevre/repo/adminEventSeries.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminEventSeriesRepo = void 0;
+const factory_1 = require("../factory");
+const eventSeries_1 = require("./mongoose/schemas/eventSeries");
+/**
+ * 施設コンテンツ管理リポジトリ
+ */
+class AdminEventSeriesRepo {
+    eventSeriesModel;
+    constructor(connection) {
+        this.eventSeriesModel = connection.model(eventSeries_1.modelName, (0, eventSeries_1.createSchema)());
+    }
+    /**
+     * 施設+コンテンツ+バージョンをキーにして冪等置換
+     */
+    async upsertByVersion(params, options) {
+        const { upsert } = options;
+        const { default: uniqid } = await import('uniqid');
+        const bulkWriteOps = [];
+        const queryFilters = [];
+        if (Array.isArray(params)) {
+            params.forEach(({ $set, $unset }) => {
+                const version = $set.workPerformed.version;
+                if (typeof version !== 'string' || version.length === 0) {
+                    throw new factory_1.factory.errors.ArgumentNull('workPerformed.version');
+                }
+                // リソースのユニークネスを保証するfilter
+                const filter = {
+                    'project.id': { $eq: $set.project.id },
+                    'location.branchCode': { $exists: true, $eq: $set.location.branchCode },
+                    'workPerformed.identifier': { $exists: true, $eq: $set.workPerformed.identifier },
+                    'workPerformed.version': { $exists: true, $eq: version }
+                };
+                queryFilters.push({
+                    'project.id': { $eq: $set.project.id },
+                    'location.branchCode': { $exists: true, $eq: $set.location.branchCode },
+                    'workPerformed.identifier': { $exists: true, $eq: $set.workPerformed.identifier },
+                    'workPerformed.version': { $exists: true, $eq: version }
+                });
+                const { identifier, project, typeOf, ...setFields } = $set; // eslint-disable-line @typescript-eslint/no-unused-vars
+                const setOnInsert = {
+                    project,
+                    typeOf,
+                    _id: uniqid()
+                };
+                let updateOne;
+                if (upsert === true) {
+                    updateOne = {
+                        filter,
+                        update: {
+                            $setOnInsert: setOnInsert,
+                            $set: setFields,
+                            ...($unset !== undefined) ? { $unset } : undefined
+                        },
+                        upsert: true
+                    };
+                }
+                else {
+                    updateOne = {
+                        filter,
+                        update: {
+                            $setOnInsert: {
+                                ...setOnInsert,
+                                ...setFields
+                            }
+                        },
+                        upsert: true
+                    };
+                }
+                bulkWriteOps.push({ updateOne });
+            });
+        }
+        if (bulkWriteOps.length > 0) {
+            const bulkWriteResult = await this.eventSeriesModel.bulkWrite(bulkWriteOps, { ordered: false });
+            // upsert:falseの場合、upsertedIdsのみmodifiedEventsとして返せばよい(2026-01-27~)
+            if (!upsert) {
+                // BulkWriteResult -> upsertedIds: { '0': '7iri6p4m54k0r3g' }
+                return {
+                    bulkWriteResult,
+                    modifiedEvents: Object.values(bulkWriteResult.upsertedIds)
+                        .map((id) => ({ id: String(id) }))
+                };
+            }
+            else {
+                // modifiedの場合upsertedIdsに含まれないので、idを検索する
+                const modifiedEvents = await this.eventSeriesModel.find({ $or: queryFilters }, { _id: 1 })
+                    .exec();
+                return { bulkWriteResult, modifiedEvents };
+            }
+        }
+        return { modifiedEvents: [] };
+    }
+    /**
+     * sskts施設コンテンツ保管
+     */
+    async upsertManyEventSeriesById4sskts(params) {
+        const bulkWriteOps = [];
+        if (Array.isArray(params)) {
+            params.forEach((p) => {
+                // 上書き禁止属性を除外(2022-08-24~)
+                const { identifier, project, typeOf, ...updateFields } = p.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
+                bulkWriteOps.push({
+                    updateOne: {
+                        filter: { _id: { $eq: p.id } },
+                        update: {
+                            $setOnInsert: {
+                                typeOf: factory_1.factory.eventType.ScreeningEventSeries,
+                                project: p.attributes.project,
+                                ...(typeof p.attributes.identifier === 'string')
+                                    ? { identifier: p.attributes.identifier } : undefined
+                            },
+                            $set: updateFields
+                            // $unsetに対応(2022-08-31~)
+                            // ...(p.$unset !== undefined) ? { $unset: p.$unset } : undefined
+                        },
+                        upsert: true
+                    }
+                });
+            });
+        }
+        if (bulkWriteOps.length > 0) {
+            await this.eventSeriesModel.bulkWrite(bulkWriteOps, { ordered: false });
+        }
+    }
+    async deleteEventSeriesById(params) {
+        await this.eventSeriesModel.findOneAndDelete({
+            _id: { $eq: params.id },
+            'project.id': { $eq: params.project.id }
+        }, { projection: { _id: 1 } })
+            .exec();
+    }
+    // /**
+    //  * 既存施設コンテンツの最大バージョンを集計する
+    //  */
+    // public async aggregateMaxVersion(params: {
+    //     project: { id: { $eq: string } };
+    //     workPerformed: { identifier: { $eq: string } };
+    //     location: { branchCode: { $in: string[] } };
+    // }): Promise<{ maxVersion: string }> {
+    //     const aggregations = await this.eventSeriesModel.aggregate<{ maxVersion: number }>([
+    //         {
+    //             $match: {
+    //                 'project.id': { $eq: params.project.id.$eq },
+    //                 'workPerformed.identifier': { $exists: true, $eq: params.workPerformed.identifier.$eq },
+    //                 'workPerformed.version': { $exists: true },
+    //                 'location.branchCode': { $exists: true, $in: params.location.branchCode.$in }
+    //             }
+    //         },
+    //         {
+    //             $project: {
+    //                 // workPerformed: '$workPerformed',
+    //                 version: { $toLong: '$workPerformed.version' } // support YYYYMMDDHHmmss
+    //             }
+    //         },
+    //         {
+    //             $group: {
+    //                 _id: null,
+    //                 maxVersion: { $max: '$version' }
+    //             }
+    //         }
+    //     ])
+    //         .exec();
+    //     const firstMaxVersion = aggregations.at(0)?.maxVersion;
+    //     const maxVersion: string = (typeof firstMaxVersion === 'number') ? String(firstMaxVersion) : '0';
+    //     return { maxVersion };
+    // }
+    getCursor(conditions, projection) {
+        return this.eventSeriesModel.find(conditions, projection)
+            .sort({ startDate: factory_1.factory.sortType.Descending })
+            .cursor();
+    }
+    async unsetUnnecessaryFields(params) {
+        return this.eventSeriesModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
+            .exec();
+    }
+}
+exports.AdminEventSeriesRepo = AdminEventSeriesRepo;