@rytass/bpm-core-nestjs-module 0.3.0 → 0.5.0

package/src/lib/organization/organization.service.js

@@ -1,751 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrganizationService = void 0;
-const tslib_1 = require("tslib");
-const node_crypto_1 = require("node:crypto");
-const common_1 = require("@nestjs/common");
-const typeorm_1 = require("@nestjs/typeorm");
-const typeorm_2 = require("typeorm");
-const manager_resolution_entity_1 = require("./manager-resolution.entity");
-const membership_entity_1 = require("./membership.entity");
-const org_unit_entity_1 = require("./org-unit.entity");
-const organization_enums_1 = require("./organization.enums");
-const position_entity_1 = require("./position.entity");
-const json_metadata_1 = require("./json-metadata");
-const ROOT_PATH_PREFIX = 'org';
-const BUSINESS_TIME_ZONE = 'Asia/Taipei';
-let OrganizationService = class OrganizationService {
-    constructor(dataSource, orgUnitRepository, positionRepository, membershipRepository, managerResolutionRepository) {
-        this.dataSource = dataSource;
-        this.orgUnitRepository = orgUnitRepository;
-        this.positionRepository = positionRepository;
-        this.membershipRepository = membershipRepository;
-        this.managerResolutionRepository = managerResolutionRepository;
-    }
-    async createOrgUnit(input) {
-        await this.assertOrgUnitCodeAvailable(input.code);
-        const id = (0, node_crypto_1.randomUUID)();
-        const parent = input.parentId
-            ? await this.getOrgUnitOrThrow(input.parentId)
-            : null;
-        const pathSegment = this.buildPathSegment(id);
-        const path = parent
-            ? `${parent.path}.${pathSegment}`
-            : `${ROOT_PATH_PREFIX}.${pathSegment}`;
-        const entity = this.orgUnitRepository.create({
-            code: input.code,
-            id,
-            metadata: (0, json_metadata_1.parseMetadataJson)(input.metadataJson),
-            name: input.name,
-            parentId: input.parentId,
-            path,
-            type: input.type,
-        });
-        return this.orgUnitRepository.save(entity);
-    }
-    async updateOrgUnit(input) {
-        const existing = await this.getOrgUnitOrThrow(input.id);
-        const nextParentId = input.parentId === undefined ? existing.parentId : input.parentId;
-        const parent = nextParentId
-            ? await this.getOrgUnitOrThrow(nextParentId)
-            : null;
-        const nextCode = input.code ?? existing.code;
-        if (nextParentId === existing.id) {
-            throw new common_1.BadRequestException('Org unit cannot be its own parent');
-        }
-        if (parent && parent.path.startsWith(`${existing.path}.`)) {
-            throw new common_1.BadRequestException('Org unit cannot be moved under its descendant');
-        }
-        await this.assertOrgUnitCodeAvailable(nextCode, existing.id);
-        const pathSegment = this.buildPathSegment(existing.id);
-        const path = parent
-            ? `${parent.path}.${pathSegment}`
-            : `${ROOT_PATH_PREFIX}.${pathSegment}`;
-        const previousPath = existing.path;
-        const next = this.orgUnitRepository.merge(existing, {
-            code: nextCode,
-            metadata: input.metadataJson
-                ? (0, json_metadata_1.parseMetadataJson)(input.metadataJson)
-                : existing.metadata,
-            name: input.name ?? existing.name,
-            parentId: nextParentId,
-            path,
-            type: input.type ?? existing.type,
-        });
-        return this.dataSource.transaction(async (manager) => {
-            const saved = await manager.getRepository(org_unit_entity_1.OrgUnitEntity).save(next);
-            if (saved.path !== previousPath) {
-                const descendants = await manager
-                    .getRepository(org_unit_entity_1.OrgUnitEntity)
-                    .createQueryBuilder('orgUnit')
-                    .where('orgUnit.deleted_at IS NULL')
-                    .andWhere('orgUnit.path <@ :previousPath', { previousPath })
-                    .andWhere('orgUnit.id != :id', { id: saved.id })
-                    .getMany();
-                await Promise.all(descendants.map((descendant) => {
-                    const updatedDescendant = manager
-                        .getRepository(org_unit_entity_1.OrgUnitEntity)
-                        .merge(descendant, {
-                        path: descendant.path.replace(previousPath, saved.path),
-                    });
-                    return manager
-                        .getRepository(org_unit_entity_1.OrgUnitEntity)
-                        .save(updatedDescendant);
-                }));
-            }
-            return saved;
-        });
-    }
-    async commitOrgUnitTreeDraft(input) {
-        if (!input.moves.length) {
-            return { orgUnits: [] };
-        }
-        this.assertUniqueOrgUnitTreeMoves(input.moves);
-        return this.dataSource.transaction(async (manager) => {
-            const repository = manager.getRepository(org_unit_entity_1.OrgUnitEntity);
-            const orgUnitIds = collectOrgUnitTreeDraftIds(input.moves);
-            const orgUnits = await repository.find({
-                where: { deletedAt: (0, typeorm_2.IsNull)(), id: (0, typeorm_2.In)(orgUnitIds) },
-            });
-            const orgUnitById = new Map(orgUnits.map((orgUnit) => [
-                orgUnit.id,
-                orgUnit,
-            ]));
-            this.assertOrgUnitTreeDraftReferences(input.moves, orgUnitById);
-            this.assertOrgUnitTreeDraftVersions(input.moves, orgUnitById);
-            this.assertOrgUnitTreeDraftHierarchy(input.moves, orgUnitById);
-            const affectedOrgUnits = new Map();
-            const sortedMoves = sortOrgUnitTreeDraftMoves(input.moves);
-            for (const move of sortedMoves) {
-                const existing = orgUnitById.get(move.id);
-                if (!existing) {
-                    throw new common_1.NotFoundException(`Org unit ${move.id} was not found`);
-                }
-                const parent = move.parentId
-                    ? orgUnitById.get(move.parentId) ?? null
-                    : null;
-                const previousPath = existing.path;
-                const nextPath = parent
-                    ? `${parent.path}.${this.buildPathSegment(existing.id)}`
-                    : `${ROOT_PATH_PREFIX}.${this.buildPathSegment(existing.id)}`;
-                if (existing.parentId === move.parentId &&
-                    existing.path === nextPath) {
-                    affectedOrgUnits.set(existing.id, existing);
-                    continue;
-                }
-                const saved = await repository.save(repository.merge(existing, {
-                    parentId: move.parentId,
-                    path: nextPath,
-                }));
-                orgUnitById.set(saved.id, saved);
-                affectedOrgUnits.set(saved.id, saved);
-                const descendants = await repository
-                    .createQueryBuilder('orgUnit')
-                    .where('orgUnit.deleted_at IS NULL')
-                    .andWhere('orgUnit.path <@ :previousPath', { previousPath })
-                    .andWhere('orgUnit.id != :id', { id: saved.id })
-                    .getMany();
-                for (const descendant of descendants) {
-                    const updatedDescendant = await repository.save(repository.merge(descendant, {
-                        path: descendant.path.replace(previousPath, saved.path),
-                    }));
-                    orgUnitById.set(updatedDescendant.id, updatedDescendant);
-                    affectedOrgUnits.set(updatedDescendant.id, updatedDescendant);
-                }
-            }
-            return {
-                orgUnits: [...affectedOrgUnits.values()].sort(compareOrgUnitPath),
-            };
-        });
-    }
-    async deleteOrgUnit(id) {
-        await this.getOrgUnitOrThrow(id);
-        const childCount = await this.orgUnitRepository.count({
-            where: { deletedAt: (0, typeorm_2.IsNull)(), parentId: id },
-        });
-        if (childCount > 0) {
-            throw new common_1.BadRequestException('Org unit with child units cannot be deleted');
-        }
-        const membershipCount = await this.membershipRepository.count({
-            where: { orgUnitId: id },
-        });
-        if (membershipCount > 0) {
-            throw new common_1.BadRequestException('Org unit with memberships cannot be deleted');
-        }
-        await this.orgUnitRepository.softDelete(id);
-        return true;
-    }
-    async getOrgUnit(id) {
-        return this.getOrgUnitOrThrow(id);
-    }
-    async listOrgUnits({ page, pageSize, parentId, searchText, type, } = {}) {
-        return this.orgUnitRepository.find({
-            ...createPaginationFindOptions({ page, pageSize }),
-            order: { path: 'ASC' },
-            where: createOrgUnitWhere({ parentId, searchText, type }),
-        });
-    }
-    async countOrgUnits({ parentId, searchText, type, } = {}) {
-        return this.orgUnitRepository.count({
-            where: createOrgUnitWhere({ parentId, searchText, type }),
-        });
-    }
-    async createPosition(input) {
-        await this.assertPositionCodeAvailable(input.code);
-        return this.positionRepository.save(this.positionRepository.create({
-            code: input.code,
-            level: input.level,
-            metadata: (0, json_metadata_1.parseMetadataJson)(input.metadataJson),
-            name: input.name,
-        }));
-    }
-    async updatePosition(input) {
-        const existing = await this.getPositionOrThrow(input.id);
-        const nextCode = input.code ?? existing.code;
-        await this.assertPositionCodeAvailable(nextCode, existing.id);
-        const next = this.positionRepository.merge(existing, {
-            code: nextCode,
-            level: input.level ?? existing.level,
-            metadata: input.metadataJson
-                ? (0, json_metadata_1.parseMetadataJson)(input.metadataJson)
-                : existing.metadata,
-            name: input.name ?? existing.name,
-        });
-        return this.positionRepository.save(next);
-    }
-    async listPositions({ page, pageSize, searchText, } = {}) {
-        return this.positionRepository.find({
-            ...createPaginationFindOptions({ page, pageSize }),
-            order: { level: 'DESC', code: 'ASC' },
-            where: createPositionWhere({ searchText }),
-        });
-    }
-    async countPositions({ searchText, } = {}) {
-        return this.positionRepository.count({
-            where: createPositionWhere({ searchText }),
-        });
-    }
-    async createMembership(input) {
-        await this.assertMembershipReferences(input);
-        await this.assertMembershipDateRange(input.effectiveFrom, input.effectiveTo);
-        if (input.isPrimary) {
-            await this.clearPrimaryMemberships(input.memberId);
-        }
-        return this.membershipRepository.save(this.membershipRepository.create(input));
-    }
-    async updateMembership(input) {
-        const existing = await this.getMembershipOrThrow(input.id);
-        const nextMemberId = existing.memberId;
-        const nextOrgUnitId = input.orgUnitId ?? existing.orgUnitId;
-        const nextPositionId = input.positionId === undefined ? existing.positionId : input.positionId;
-        const nextEffectiveFrom = input.effectiveFrom ?? existing.effectiveFrom;
-        const nextEffectiveTo = input.effectiveTo === undefined
-            ? existing.effectiveTo
-            : input.effectiveTo;
-        const nextIsPrimary = input.isPrimary ?? existing.isPrimary;
-        await this.assertMembershipReferences({
-            effectiveFrom: nextEffectiveFrom,
-            effectiveTo: nextEffectiveTo,
-            isPrimary: nextIsPrimary,
-            memberId: nextMemberId,
-            orgUnitId: nextOrgUnitId,
-            positionId: nextPositionId,
-        });
-        await this.assertMembershipDateRange(nextEffectiveFrom, nextEffectiveTo);
-        if (nextIsPrimary) {
-            await this.clearPrimaryMemberships(nextMemberId, existing.id);
-        }
-        const next = this.membershipRepository.merge(existing, {
-            effectiveFrom: nextEffectiveFrom,
-            effectiveTo: nextEffectiveTo,
-            isPrimary: nextIsPrimary,
-            orgUnitId: nextOrgUnitId,
-            positionId: nextPositionId,
-        });
-        return this.membershipRepository.save(next);
-    }
-    async deleteMembership(id) {
-        await this.getMembershipOrThrow(id);
-        await this.membershipRepository.delete(id);
-        return true;
-    }
-    async listMemberships({ activeOnly = false, memberId, orgUnitId, page, pageSize, positionId, } = {}) {
-        const date = this.toDateOnly(new Date());
-        return this.membershipRepository.find({
-            ...createPaginationFindOptions({ page, pageSize }),
-            order: { memberId: 'ASC', isPrimary: 'DESC', effectiveFrom: 'DESC' },
-            where: createMembershipWhere({
-                activeOnly,
-                date,
-                memberId,
-                orgUnitId,
-                positionId,
-            }),
-        });
-    }
-    async countMemberships({ activeOnly = false, memberId, orgUnitId, positionId, } = {}) {
-        const date = this.toDateOnly(new Date());
-        return this.membershipRepository.count({
-            where: createMembershipWhere({
-                activeOnly,
-                date,
-                memberId,
-                orgUnitId,
-                positionId,
-            }),
-        });
-    }
-    async createManagerResolution(input) {
-        await this.assertManagerResolutionReferences(input);
-        await this.assertMembershipDateRange(input.effectiveFrom, input.effectiveTo);
-        return this.managerResolutionRepository.save(this.managerResolutionRepository.create(input));
-    }
-    async updateManagerResolution(input) {
-        const existing = await this.getManagerResolutionOrThrow(input.id);
-        const nextScopeType = input.scopeType ?? existing.scopeType;
-        const nextScopeId = input.scopeId ?? existing.scopeId;
-        const nextManagerMemberId = input.managerMemberId ?? existing.managerMemberId;
-        const nextEffectiveFrom = input.effectiveFrom ?? existing.effectiveFrom;
-        const nextEffectiveTo = input.effectiveTo === undefined
-            ? existing.effectiveTo
-            : input.effectiveTo;
-        await this.assertManagerResolutionReferences({
-            effectiveFrom: nextEffectiveFrom,
-            effectiveTo: nextEffectiveTo,
-            managerMemberId: nextManagerMemberId,
-            priority: input.priority ?? existing.priority,
-            scopeId: nextScopeId,
-            scopeType: nextScopeType,
-        });
-        await this.assertMembershipDateRange(nextEffectiveFrom, nextEffectiveTo);
-        const next = this.managerResolutionRepository.merge(existing, {
-            effectiveFrom: nextEffectiveFrom,
-            effectiveTo: nextEffectiveTo,
-            managerMemberId: nextManagerMemberId,
-            priority: input.priority ?? existing.priority,
-            scopeId: nextScopeId,
-            scopeType: nextScopeType,
-        });
-        return this.managerResolutionRepository.save(next);
-    }
-    async deleteManagerResolution(id) {
-        await this.getManagerResolutionOrThrow(id);
-        await this.managerResolutionRepository.delete(id);
-        return true;
-    }
-    async listManagerResolutions({ activeOnly = false, page, pageSize, scopeId, scopeType, } = {}) {
-        const date = this.toDateOnly(new Date());
-        return this.managerResolutionRepository.find({
-            ...createPaginationFindOptions({ page, pageSize }),
-            order: { priority: 'DESC', createdAt: 'DESC' },
-            where: createManagerResolutionWhere({
-                activeOnly,
-                date,
-                scopeId,
-                scopeType,
-            }),
-        });
-    }
-    async countManagerResolutions({ activeOnly = false, scopeId, scopeType, } = {}) {
-        const date = this.toDateOnly(new Date());
-        return this.managerResolutionRepository.count({
-            where: createManagerResolutionWhere({
-                activeOnly,
-                date,
-                scopeId,
-                scopeType,
-            }),
-        });
-    }
-    async readOrganizationSummary() {
-        const [orgUnitCount, positionCount, membershipCount, managerResolutionCount,] = await Promise.all([
-            this.orgUnitRepository.count({ where: { deletedAt: (0, typeorm_2.IsNull)() } }),
-            this.positionRepository.count(),
-            this.membershipRepository.count(),
-            this.managerResolutionRepository.count(),
-        ]);
-        return {
-            managerResolutionCount,
-            membershipCount,
-            orgUnitCount,
-            positionCount,
-        };
-    }
-    async resolveManagerMemberId(memberId, effectiveAt = new Date()) {
-        const date = this.toDateOnly(effectiveAt);
-        const memberships = await this.findActiveMemberships(memberId, date);
-        const orgUnits = await this.findMembershipOrgUnits(memberships);
-        const positionIds = memberships
-            .map((membership) => membership.positionId)
-            .filter((positionId) => Boolean(positionId));
-        const candidatePairs = [
-            { scopeId: memberId, scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER },
-            ...orgUnits.map((orgUnit) => ({
-                scopeId: orgUnit.id,
-                scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT,
-            })),
-            ...positionIds.map((positionId) => ({
-                scopeId: positionId,
-                scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION,
-            })),
-        ];
-        const scopeIds = candidatePairs.map((pair) => pair.scopeId);
-        const resolutions = scopeIds.length
-            ? await this.managerResolutionRepository.find({
-                where: {
-                    scopeId: (0, typeorm_2.In)(scopeIds),
-                    scopeType: (0, typeorm_2.In)([
-                        organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER,
-                        organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT,
-                        organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION,
-                    ]),
-                },
-            })
-            : [];
-        const active = resolutions
-            .filter((resolution) => candidatePairs.some((pair) => pair.scopeId === resolution.scopeId &&
-            pair.scopeType === resolution.scopeType))
-            .filter((resolution) => this.isDateActive(resolution, date))
-            .sort((left, right) => this.compareManagerResolution(left, right));
-        return active[0]?.managerMemberId ?? null;
-    }
-    assertUniqueOrgUnitTreeMoves(moves) {
-        const moveIds = moves.map((move) => move.id);
-        const uniqueMoveIds = new Set(moveIds);
-        if (uniqueMoveIds.size !== moveIds.length) {
-            throw new common_1.BadRequestException('Org unit tree draft includes duplicate moves');
-        }
-    }
-    assertOrgUnitTreeDraftReferences(moves, orgUnitById) {
-        const missingId = collectOrgUnitTreeDraftIds(moves).find((id) => !orgUnitById.has(id));
-        if (missingId) {
-            throw new common_1.NotFoundException(`Org unit ${missingId} was not found`);
-        }
-    }
-    assertOrgUnitTreeDraftVersions(moves, orgUnitById) {
-        const staleMove = moves.find((move) => {
-            const orgUnit = orgUnitById.get(move.id);
-            return orgUnit
-                ? orgUnit.updatedAt.getTime() !== parseBaseUpdatedAt(move).getTime()
-                : false;
-        });
-        if (staleMove) {
-            throw new common_1.ConflictException(`Org unit ${staleMove.id} has changed since this draft was based`);
-        }
-    }
-    assertOrgUnitTreeDraftHierarchy(moves, orgUnitById) {
-        for (const move of moves) {
-            if (move.id === move.parentId) {
-                throw new common_1.BadRequestException('Org unit cannot be its own parent');
-            }
-            const existing = orgUnitById.get(move.id);
-            const parent = move.parentId ? orgUnitById.get(move.parentId) : null;
-            if (existing && parent?.path.startsWith(`${existing.path}.`)) {
-                throw new common_1.BadRequestException('Org unit cannot be moved under its descendant');
-            }
-        }
-        assertOrgUnitTreeDraftHasNoCycles(moves);
-    }
-    async getOrgUnitOrThrow(id) {
-        const entity = await this.orgUnitRepository.findOne({
-            where: { deletedAt: (0, typeorm_2.IsNull)(), id },
-        });
-        if (!entity) {
-            throw new common_1.NotFoundException(`Org unit ${id} was not found`);
-        }
-        return entity;
-    }
-    async getPositionOrThrow(id) {
-        const entity = await this.positionRepository.findOne({ where: { id } });
-        if (!entity) {
-            throw new common_1.NotFoundException(`Position ${id} was not found`);
-        }
-        return entity;
-    }
-    async assertOrgUnitCodeAvailable(code, exceptId) {
-        const existing = await this.orgUnitRepository.findOne({
-            where: {
-                code,
-                deletedAt: (0, typeorm_2.IsNull)(),
-                ...(exceptId ? { id: (0, typeorm_2.Not)(exceptId) } : {}),
-            },
-        });
-        if (existing) {
-            throw new common_1.BadRequestException(`Org unit code ${code} is already used`);
-        }
-    }
-    async assertPositionCodeAvailable(code, exceptId) {
-        const existing = await this.positionRepository.findOne({
-            where: {
-                code,
-                ...(exceptId ? { id: (0, typeorm_2.Not)(exceptId) } : {}),
-            },
-        });
-        if (existing) {
-            throw new common_1.BadRequestException(`Position code ${code} is already used`);
-        }
-    }
-    async assertMembershipReferences(input) {
-        await this.getOrgUnitOrThrow(input.orgUnitId);
-        if (input.positionId) {
-            await this.getPositionOrThrow(input.positionId);
-        }
-    }
-    async assertManagerResolutionReferences(input) {
-        if (input.scopeType === organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER &&
-            input.scopeId === input.managerMemberId) {
-            throw new common_1.BadRequestException('Manager cannot be the scoped member');
-        }
-        if (input.scopeType === organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT) {
-            await this.getOrgUnitOrThrow(input.scopeId);
-        }
-        if (input.scopeType === organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION) {
-            await this.getPositionOrThrow(input.scopeId);
-        }
-    }
-    async assertMembershipDateRange(effectiveFrom, effectiveTo) {
-        if (effectiveTo && effectiveFrom > effectiveTo) {
-            throw new common_1.BadRequestException('Effective from cannot be after effective to');
-        }
-    }
-    async clearPrimaryMemberships(memberId, exceptId) {
-        await this.membershipRepository.update({
-            isPrimary: true,
-            memberId,
-            ...(exceptId ? { id: (0, typeorm_2.Not)(exceptId) } : {}),
-        }, { isPrimary: false });
-    }
-    async getMembershipOrThrow(id) {
-        const entity = await this.membershipRepository.findOne({ where: { id } });
-        if (!entity) {
-            throw new common_1.NotFoundException(`Membership ${id} was not found`);
-        }
-        return entity;
-    }
-    async getManagerResolutionOrThrow(id) {
-        const entity = await this.managerResolutionRepository.findOne({
-            where: { id },
-        });
-        if (!entity) {
-            throw new common_1.NotFoundException(`Manager resolution ${id} was not found`);
-        }
-        return entity;
-    }
-    async findActiveMemberships(memberId, date) {
-        const memberships = await this.membershipRepository.find({
-            where: { memberId },
-        });
-        return memberships.filter((membership) => this.isDateActive(membership, date));
-    }
-    async findMembershipOrgUnits(memberships) {
-        const orgUnitIds = memberships.map((membership) => membership.orgUnitId);
-        if (!orgUnitIds.length) {
-            return [];
-        }
-        const directOrgUnits = await this.orgUnitRepository.find({
-            where: { deletedAt: (0, typeorm_2.IsNull)(), id: (0, typeorm_2.In)(orgUnitIds) },
-        });
-        const ancestorGroups = await Promise.all(directOrgUnits.map((orgUnit) => this.orgUnitRepository
-            .createQueryBuilder('orgUnit')
-            .where('orgUnit.deleted_at IS NULL')
-            .andWhere('orgUnit.path @> :path', { path: orgUnit.path })
-            .getMany()));
-        const flattened = ancestorGroups.flat();
-        const byId = new Map(flattened.map((orgUnit) => [
-            orgUnit.id,
-            orgUnit,
-        ]));
-        return [...byId.values()];
-    }
-    buildPathSegment(id) {
-        return `n${id.replace(/-/g, '_')}`;
-    }
-    toDateOnly(date) {
-        const parts = new Intl.DateTimeFormat('en-US', {
-            day: '2-digit',
-            month: '2-digit',
-            timeZone: BUSINESS_TIME_ZONE,
-            year: 'numeric',
-        }).formatToParts(date);
-        const byType = new Map(parts.map((part) => [part.type, part.value]));
-        return `${byType.get('year') ?? '1970'}-${byType.get('month') ?? '01'}-${byType.get('day') ?? '01'}`;
-    }
-    isDateActive(value, date) {
-        return (value.effectiveFrom <= date &&
-            (!value.effectiveTo || value.effectiveTo >= date));
-    }
-    compareManagerResolution(left, right) {
-        const priorityDiff = right.priority - left.priority;
-        if (priorityDiff !== 0) {
-            return priorityDiff;
-        }
-        return (this.scopeRank(right.scopeType) - this.scopeRank(left.scopeType) ||
-            right.effectiveFrom.localeCompare(left.effectiveFrom));
-    }
-    scopeRank(scopeType) {
-        const ranks = {
-            [organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER]: 3,
-            [organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT]: 2,
-            [organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION]: 1,
-        };
-        return ranks[scopeType];
-    }
-};
-exports.OrganizationService = OrganizationService;
-exports.OrganizationService = OrganizationService = tslib_1.__decorate([
-    (0, common_1.Injectable)(),
-    tslib_1.__param(1, (0, typeorm_1.InjectRepository)(org_unit_entity_1.OrgUnitEntity)),
-    tslib_1.__param(2, (0, typeorm_1.InjectRepository)(position_entity_1.PositionEntity)),
-    tslib_1.__param(3, (0, typeorm_1.InjectRepository)(membership_entity_1.MembershipEntity)),
-    tslib_1.__param(4, (0, typeorm_1.InjectRepository)(manager_resolution_entity_1.ManagerResolutionEntity)),
-    tslib_1.__metadata("design:paramtypes", [typeorm_2.DataSource,
-        typeorm_2.Repository,
-        typeorm_2.Repository,
-        typeorm_2.Repository,
-        typeorm_2.Repository])
-], OrganizationService);
-function createOrgUnitWhere({ parentId, searchText, type, }) {
-    const parentWhere = parentId === undefined
-        ? {}
-        : { parentId: parentId === null ? (0, typeorm_2.IsNull)() : parentId };
-    const baseWhere = {
-        deletedAt: (0, typeorm_2.IsNull)(),
-        ...parentWhere,
-        ...(type ? { type } : {}),
-    };
-    const trimmedSearchText = searchText?.trim();
-    if (!trimmedSearchText) {
-        return baseWhere;
-    }
-    const searchPattern = `%${trimmedSearchText}%`;
-    return [
-        { ...baseWhere, code: (0, typeorm_2.ILike)(searchPattern) },
-        { ...baseWhere, name: (0, typeorm_2.ILike)(searchPattern) },
-    ];
-}
-function createPositionWhere({ searchText, }) {
-    const trimmedSearchText = searchText?.trim();
-    if (!trimmedSearchText) {
-        return {};
-    }
-    const searchPattern = `%${trimmedSearchText}%`;
-    return [{ code: (0, typeorm_2.ILike)(searchPattern) }, { name: (0, typeorm_2.ILike)(searchPattern) }];
-}
-function createMembershipWhere({ activeOnly, date, memberId, orgUnitId, positionId, }) {
-    const baseWhere = {
-        ...(memberId ? { memberId } : {}),
-        ...(orgUnitId ? { orgUnitId } : {}),
-        ...(positionId ? { positionId } : {}),
-    };
-    if (!activeOnly) {
-        return baseWhere;
-    }
-    return [
-        {
-            ...baseWhere,
-            effectiveFrom: (0, typeorm_2.LessThanOrEqual)(date),
-            effectiveTo: (0, typeorm_2.IsNull)(),
-        },
-        {
-            ...baseWhere,
-            effectiveFrom: (0, typeorm_2.LessThanOrEqual)(date),
-            effectiveTo: (0, typeorm_2.MoreThanOrEqual)(date),
-        },
-    ];
-}
-function createManagerResolutionWhere({ activeOnly, date, scopeId, scopeType, }) {
-    const baseWhere = {
-        ...(scopeId ? { scopeId } : {}),
-        ...(scopeType ? { scopeType } : {}),
-    };
-    if (!activeOnly) {
-        return baseWhere;
-    }
-    return [
-        {
-            ...baseWhere,
-            effectiveFrom: (0, typeorm_2.LessThanOrEqual)(date),
-            effectiveTo: (0, typeorm_2.IsNull)(),
-        },
-        {
-            ...baseWhere,
-            effectiveFrom: (0, typeorm_2.LessThanOrEqual)(date),
-            effectiveTo: (0, typeorm_2.MoreThanOrEqual)(date),
-        },
-    ];
-}
-function createPaginationFindOptions({ page, pageSize, }) {
-    const normalizedPageSize = normalizePageSize(pageSize);
-    if (!normalizedPageSize) {
-        return {};
-    }
-    return {
-        skip: (normalizePage(page) - 1) * normalizedPageSize,
-        take: normalizedPageSize,
-    };
-}
-function normalizePage(page) {
-    if (typeof page !== 'number' || !Number.isFinite(page)) {
-        return 1;
-    }
-    return Math.max(1, Math.floor(page));
-}
-function normalizePageSize(pageSize) {
-    if (typeof pageSize !== 'number' || !Number.isFinite(pageSize)) {
-        return null;
-    }
-    return Math.min(100, Math.max(1, Math.floor(pageSize)));
-}
-function collectOrgUnitTreeDraftIds(moves) {
-    return [
-        ...new Set(moves.flatMap((move) => move.parentId ? [move.id, move.parentId] : [move.id])),
-    ];
-}
-function parseBaseUpdatedAt(move) {
-    const baseUpdatedAt = new Date(move.baseUpdatedAt);
-    if (Number.isNaN(baseUpdatedAt.getTime())) {
-        throw new common_1.BadRequestException(`Org unit ${move.id} baseUpdatedAt is invalid`);
-    }
-    return baseUpdatedAt;
-}
-function assertOrgUnitTreeDraftHasNoCycles(moves) {
-    const parentById = new Map(moves.map((move) => [
-        move.id,
-        move.parentId,
-    ]));
-    for (const move of moves) {
-        const visited = new Set();
-        let parentId = move.parentId;
-        while (parentId && parentById.has(parentId)) {
-            if (parentId === move.id || visited.has(parentId)) {
-                throw new common_1.BadRequestException('Org unit tree draft cannot create a cycle');
-            }
-            visited.add(parentId);
-            parentId = parentById.get(parentId) ?? null;
-        }
-    }
-}
-function sortOrgUnitTreeDraftMoves(moves) {
-    const moveById = new Map(moves.map((move) => [
-        move.id,
-        move,
-    ]));
-    return [...moves].sort((left, right) => {
-        const leftDepth = calculateOrgUnitTreeDraftMoveDepth(left, moveById);
-        const rightDepth = calculateOrgUnitTreeDraftMoveDepth(right, moveById);
-        return leftDepth - rightDepth || left.id.localeCompare(right.id);
-    });
-}
-function calculateOrgUnitTreeDraftMoveDepth(move, moveById) {
-    let depth = 0;
-    let parentId = move.parentId;
-    while (parentId && moveById.has(parentId)) {
-        depth += 1;
-        parentId = moveById.get(parentId)?.parentId ?? null;
-    }
-    return depth;
-}
-function compareOrgUnitPath(left, right) {
-    return left.path.localeCompare(right.path);
-}
-//# sourceMappingURL=organization.service.js.map