@hed-hog/contact 0.0.266 → 0.0.274

package/dist/person/person.service.js

@@ -16,13 +16,44 @@ exports.PersonService = void 0;
 const api_locale_1 = require("@hed-hog/api-locale");
 const api_pagination_1 = require("@hed-hog/api-pagination");
 const api_prisma_1 = require("@hed-hog/api-prisma");
+const core_1 = require("@hed-hog/core");
 const common_1 = require("@nestjs/common");
+const CONTACT_ALLOW_COMPANY_REGISTRATION_SETTING = 'contact-allow-company-registration';
+const CONTACT_OWNER_ROLE_SLUG = 'owner-contact';
+const CONTACT_OWNER_ALLOWED_ROLE_SLUGS = [
+    'admin',
+    'admin-contact',
+    CONTACT_OWNER_ROLE_SLUG,
+];
+const EMPLOYER_COMPANY_METADATA_KEY = 'employer_company_id';
+const NOTES_METADATA_KEY = 'notes';
 let PersonService = class PersonService {
-    constructor(prismaService, paginationService) {
+    constructor(prismaService, paginationService, fileService, settingService) {
         this.prismaService = prismaService;
         this.paginationService = paginationService;
+        this.fileService = fileService;
+        this.settingService = settingService;
     }
     async getStats() {
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        if (!allowCompanyRegistration) {
+            const [individual, active, inactive] = await Promise.all([
+                this.prismaService.person.count({ where: { type: 'individual' } }),
+                this.prismaService.person.count({
+                    where: { type: 'individual', status: 'active' },
+                }),
+                this.prismaService.person.count({
+                    where: { type: 'individual', status: 'inactive' },
+                }),
+            ]);
+            return {
+                total: individual,
+                individual,
+                company: 0,
+                active,
+                inactive,
+            };
+        }
         const [total, individual, company, active, inactive] = await Promise.all([
             this.prismaService.person.count(),
             this.prismaService.person.count({ where: { type: 'individual' } }),
@@ -38,143 +69,192 @@ let PersonService = class PersonService {
             inactive,
         };
     }
-    async list(paginationParams) {
+    async getOwnerOptions(currentUserId) {
+        const where = {
+            OR: [
+                {
+                    role_user: {
+                        some: {
+                            role: {
+                                slug: {
+                                    in: CONTACT_OWNER_ALLOWED_ROLE_SLUGS,
+                                },
+                            },
+                        },
+                    },
+                },
+                ...(Number(currentUserId) > 0
+                    ? [
+                        {
+                            id: Number(currentUserId),
+                        },
+                    ]
+                    : []),
+            ],
+        };
+        const users = await this.prismaService.user.findMany({
+            where,
+            select: {
+                id: true,
+                name: true,
+            },
+            orderBy: {
+                name: 'asc',
+            },
+            take: 500,
+        });
+        const byId = new Map();
+        for (const user of users) {
+            if (!(user === null || user === void 0 ? void 0 : user.id))
+                continue;
+            byId.set(user.id, {
+                id: user.id,
+                name: user.name || `#${user.id}`,
+            });
+        }
+        return Array.from(byId.values());
+    }
+    async list(paginationParams, currentUserId) {
         var _a;
-        const OR = [];
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const where = {};
         const search = (_a = paginationParams.search) === null || _a === void 0 ? void 0 : _a.trim();
-        if (search) {
-            if (!isNaN(+search)) {
-                OR.push({ id: { equals: +search } });
-            }
-            OR.push({ name: { contains: search, mode: 'insensitive' } });
+        const requestedType = paginationParams.type;
+        if (!allowCompanyRegistration && requestedType === 'company') {
+            return this.paginationService.paginate(this.prismaService.person, paginationParams, {
+                where: {
+                    id: -1,
+                },
+            });
         }
-        const where = {};
-        if (OR.length > 0) {
-            where.OR = OR;
+        if (!allowCompanyRegistration) {
+            where.type = 'individual';
         }
-        if (paginationParams.type && paginationParams.type !== 'all') {
-            where.type = paginationParams.type;
+        else if (requestedType && requestedType !== 'all') {
+            where.type = requestedType;
         }
         if (paginationParams.status && paginationParams.status !== 'all') {
             where.status = paginationParams.status;
         }
-        return this.paginationService.paginate(this.prismaService.person, paginationParams, {
+        if (search) {
+            where.OR = await this.buildSearchFilters(search);
+        }
+        const result = await this.paginationService.paginate(this.prismaService.person, paginationParams, {
             where,
             include: {
-                address: true,
+                person_address: {
+                    include: {
+                        address: true,
+                    },
+                },
                 contact: true,
                 document: true,
+                person_metadata: true,
             },
         });
+        const enriched = await this.enrichPeople(result.data, allowCompanyRegistration);
+        return Object.assign(Object.assign({}, result), { data: enriched });
     }
     async get(locale, id) {
-        const person = await this.prismaService.person.findUnique({ where: { id } });
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const person = await this.prismaService.person.findUnique({
+            where: { id },
+            include: {
+                person_address: {
+                    include: {
+                        address: true,
+                    },
+                },
+                contact: true,
+                document: true,
+                person_metadata: true,
+            },
+        });
         if (!person) {
             throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${id} not found`));
         }
-        return person;
+        if (!allowCompanyRegistration && person.type === 'company') {
+            throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${id} not found`));
+        }
+        const [normalized] = await this.enrichPeople([person], allowCompanyRegistration);
+        return normalized;
     }
-    async create(data) {
-        return this.prismaService.person.create({
-            data,
+    async create(data, locale) {
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        await this.ensureCompanyRegistrationAllowed({
+            nextType: data.type,
+            locale,
+        });
+        return this.prismaService.$transaction(async (tx) => {
+            var _a, _b;
+            const person = await tx.person.create({
+                data: {
+                    name: data.name,
+                    type: data.type,
+                    status: data.status,
+                    avatar_id: (_a = data.avatar_id) !== null && _a !== void 0 ? _a : null,
+                },
+            });
+            await this.syncPersonSubtypeData(tx, person.id, null, data, locale);
+            await this.syncPersonMetadata(tx, person.id, {
+                notes: data.notes,
+                employer_company_id: allowCompanyRegistration
+                    ? (_b = data.employer_company_id) !== null && _b !== void 0 ? _b : null
+                    : null,
+            });
+            return person;
         });
     }
     async update(id, data, locale) {
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
         const person = await this.prismaService.person.findUnique({ where: { id } });
         if (!person) {
             throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${id} not found`));
         }
-        const incomingContacts = data.contacts || [];
-        const incomingAddresses = data.addresses || [];
-        const incomingDocuments = data.documents || [];
-        const contactPrimaryMap = new Map();
-        for (const c of incomingContacts) {
-            if (c.is_primary) {
-                const key = String(c.contact_type_id);
-                contactPrimaryMap.set(key, (contactPrimaryMap.get(key) || 0) + 1);
-            }
-        }
-        for (const [_, count] of contactPrimaryMap.entries()) {
-            if (count > 1) {
-                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('moreThanOnePrimaryContact', locale, 'More than one contact of the same type cannot be marked as primary.'));
-            }
-        }
-        const addressPrimaryMap = new Map();
-        for (const a of incomingAddresses) {
-            if (a.is_primary) {
-                const key = String(a.address_type_id);
-                addressPrimaryMap.set(key, (addressPrimaryMap.get(key) || 0) + 1);
-            }
-        }
-        for (const [_, count] of addressPrimaryMap.entries()) {
-            if (count > 1) {
-                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('moreThanOnePrimaryAddress', locale, 'More than one address of the same type cannot be marked as primary.'));
-            }
+        if (!allowCompanyRegistration && person.type === 'company') {
+            throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${id} not found`));
         }
-        const documentPrimaryMap = new Map();
-        for (const d of incomingDocuments) {
-            if (d.is_primary) {
-                const key = String(d.document_type_id);
-                documentPrimaryMap.set(key, (documentPrimaryMap.get(key) || 0) + 1);
-            }
-        }
-        for (const [_, count] of documentPrimaryMap.entries()) {
-            if (count > 1) {
-                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('moreThanOnePrimaryDocument', locale, 'More than one document of the same type cannot be marked as primary.'));
-            }
-        }
-        return this.prismaService.$transaction(async (tx) => {
+        await this.ensureCompanyRegistrationAllowed({
+            currentType: person.type,
+            nextType: data.type,
+            locale,
+        });
+        const incomingContacts = Array.isArray(data.contacts) ? data.contacts : [];
+        const incomingAddresses = Array.isArray(data.addresses) ? data.addresses : [];
+        const incomingDocuments = Array.isArray(data.documents) ? data.documents : [];
+        this.validateSinglePrimaryPerType(incomingContacts, 'contact_type_id', locale, 'moreThanOnePrimaryContact', 'More than one contact of the same type cannot be marked as primary.');
+        this.validateSinglePrimaryPerType(incomingAddresses, 'address_type', locale, 'moreThanOnePrimaryAddress', 'More than one address of the same type cannot be marked as primary.');
+        this.validateSinglePrimaryPerType(incomingDocuments, 'document_type_id', locale, 'moreThanOnePrimaryDocument', 'More than one document of the same type cannot be marked as primary.');
+        return this.prismaService
+            .$transaction(async (tx) => {
+            var _a, _b, _c;
+            const nextType = (_a = data.type) !== null && _a !== void 0 ? _a : person.type;
             await tx.person.update({
                 where: { id },
                 data: {
-                    name: data.name,
-                    type: data.type,
-                    status: data.status,
+                    name: (_b = data.name) !== null && _b !== void 0 ? _b : person.name,
+                    type: nextType,
+                    status: (_c = data.status) !== null && _c !== void 0 ? _c : person.status,
+                    avatar_id: data.avatar_id === undefined ? person.avatar_id : data.avatar_id,
                 },
             });
-            const existingContacts = await tx.contact.findMany({ where: { person_id: id } });
-            for (const c of incomingContacts) {
-                if (c.id) {
-                    await tx.contact.update({ where: { id: c.id }, data: c });
-                }
-                else {
-                    await tx.contact.create({ data: Object.assign(Object.assign({}, c), { person_id: id }) });
-                }
-            }
-            for (const old of existingContacts) {
-                if (!incomingContacts.find((c) => c.id === old.id)) {
-                    await tx.contact.delete({ where: { id: old.id } });
-                }
-            }
-            const existingAddresses = await tx.address.findMany({ where: { person_id: id } });
-            for (const a of incomingAddresses) {
-                if (a.id) {
-                    await tx.address.update({ where: { id: a.id }, data: a });
-                }
-                else {
-                    await tx.address.create({ data: Object.assign(Object.assign({}, a), { person_id: id }) });
-                }
-            }
-            for (const old of existingAddresses) {
-                if (!incomingAddresses.find((a) => a.id === old.id)) {
-                    await tx.address.delete({ where: { id: old.id } });
-                }
-            }
-            const existingDocuments = await tx.document.findMany({ where: { person_id: id } });
-            for (const d of incomingDocuments) {
-                if (d.id) {
-                    await tx.document.update({ where: { id: d.id }, data: d });
-                }
-                else {
-                    await tx.document.create({ data: Object.assign(Object.assign({}, d), { person_id: id }) });
-                }
-            }
-            for (const old of existingDocuments) {
-                if (!incomingDocuments.find((d) => d.id === old.id)) {
-                    await tx.document.delete({ where: { id: old.id } });
-                }
-            }
+            await this.syncPersonSubtypeData(tx, id, person.type, data, locale);
+            await this.syncPersonMetadata(tx, id, {
+                notes: data.notes,
+                employer_company_id: allowCompanyRegistration
+                    ? data.employer_company_id === undefined
+                        ? undefined
+                        : data.employer_company_id
+                    : null,
+            });
+            await this.syncContacts(tx, id, incomingContacts);
+            await this.syncAddresses(tx, id, incomingAddresses, locale);
+            await this.syncDocuments(tx, id, incomingDocuments);
             return { success: true };
+        })
+            .then(async (result) => {
+            await this.cleanupReplacedAvatar(locale, person.avatar_id, data.avatar_id);
+            return result;
         });
     }
     async delete({ ids }, locale) {
@@ -185,15 +265,53 @@ let PersonService = class PersonService {
             where: { id: { in: ids } },
             select: { id: true },
         });
-        const existingIds = existing.map(p => p.id);
-        const missingIds = ids.filter(id => !existingIds.includes(id));
+        const existingIds = existing.map((p) => p.id);
+        const missingIds = ids.filter((itemId) => !existingIds.includes(itemId));
         if (missingIds.length > 0) {
             throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person(s) with ID(s) ${missingIds.join(', ')} not found.`));
         }
+        const personAddresses = await this.prismaService.person_address.findMany({
+            where: {
+                person_id: { in: ids },
+            },
+            select: {
+                id: true,
+                address_id: true,
+            },
+        });
+        const addressIds = personAddresses.map((item) => item.address_id);
         return this.prismaService.$transaction([
             this.prismaService.contact.deleteMany({ where: { person_id: { in: ids } } }),
-            this.prismaService.address.deleteMany({ where: { person_id: { in: ids } } }),
             this.prismaService.document.deleteMany({ where: { person_id: { in: ids } } }),
+            this.prismaService.person_individual_relation.deleteMany({
+                where: {
+                    OR: [
+                        { person_individual_id: { in: ids } },
+                        { related_person_individual_id: { in: ids } },
+                    ],
+                },
+            }),
+            this.prismaService.person_company.deleteMany({
+                where: {
+                    OR: [{ id: { in: ids } }, { headquarter_id: { in: ids } }],
+                },
+            }),
+            this.prismaService.person_individual.deleteMany({
+                where: { id: { in: ids } },
+            }),
+            this.prismaService.person_metadata.deleteMany({
+                where: { person_id: { in: ids } },
+            }),
+            this.prismaService.person_address.deleteMany({
+                where: { person_id: { in: ids } },
+            }),
+            this.prismaService.address.deleteMany({
+                where: {
+                    id: {
+                        in: addressIds,
+                    },
+                },
+            }),
             this.prismaService.person.deleteMany({
                 where: {
                     id: {
@@ -203,13 +321,549 @@ let PersonService = class PersonService {
             }),
         ]);
     }
+    async openPublicAvatar(locale, fileId, res) {
+        const personWithAvatar = await this.prismaService.person.findFirst({
+            where: {
+                avatar_id: fileId,
+            },
+            select: {
+                id: true,
+            },
+        });
+        if (!personWithAvatar) {
+            throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('personNotFound', locale, 'Person not found'));
+        }
+        const { file, buffer } = await this.fileService.getBuffer(fileId);
+        res.set({
+            'Content-Type': file.file_mimetype.name,
+            'Content-Length': buffer.length,
+            'Cache-Control': 'public, max-age=3600',
+        });
+        res.send(buffer);
+    }
+    async enrichPeople(people, allowCompanyRegistration = true) {
+        if (people.length === 0) {
+            return [];
+        }
+        const personIds = people.map((person) => person.id);
+        const [companies, individuals, companyBranches, employerMetadata] = await Promise.all([
+            this.prismaService.person_company.findMany({
+                where: { id: { in: personIds } },
+            }),
+            this.prismaService.person_individual.findMany({
+                where: { id: { in: personIds } },
+            }),
+            this.prismaService.person_company.findMany({
+                where: { headquarter_id: { in: personIds } },
+                select: { id: true, headquarter_id: true },
+            }),
+            this.prismaService.person_metadata.findMany({
+                where: {
+                    person_id: { in: personIds },
+                    key: EMPLOYER_COMPANY_METADATA_KEY,
+                },
+                select: {
+                    person_id: true,
+                    value: true,
+                },
+            }).then((metadata) => (allowCompanyRegistration ? metadata : [])),
+        ]);
+        const companyById = new Map(companies.map((item) => [item.id, item]));
+        const individualById = new Map(individuals.map((item) => [item.id, item]));
+        const branchesByHeadquarterId = new Map();
+        for (const branch of companyBranches) {
+            if (!branch.headquarter_id)
+                continue;
+            const current = branchesByHeadquarterId.get(branch.headquarter_id) || [];
+            current.push(branch.id);
+            branchesByHeadquarterId.set(branch.headquarter_id, current);
+        }
+        const employerCompanyIdByPersonId = new Map();
+        for (const meta of employerMetadata) {
+            const employerId = this.coerceNumber(meta.value);
+            if (employerId > 0) {
+                employerCompanyIdByPersonId.set(meta.person_id, employerId);
+            }
+        }
+        const employerCompanyIds = Array.from(new Set(Array.from(employerCompanyIdByPersonId.values())));
+        const employerCompanies = employerCompanyIds.length > 0
+            ? await this.prismaService.person.findMany({
+                where: {
+                    id: { in: employerCompanyIds },
+                    type: 'company',
+                },
+            })
+            : [];
+        const employerCompanyRows = employerCompanyIds.length > 0
+            ? await this.prismaService.person_company.findMany({
+                where: {
+                    id: { in: employerCompanyIds },
+                },
+            })
+            : [];
+        const employerCompanyRowById = new Map(employerCompanyRows.map((item) => [item.id, item]));
+        const employerCompanyById = new Map(employerCompanies.map((item) => {
+            var _a;
+            return [
+                item.id,
+                Object.assign(Object.assign({}, item), { person_company: (_a = employerCompanyRowById.get(item.id)) !== null && _a !== void 0 ? _a : null }),
+            ];
+        }));
+        return people.map((person) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const metadata = this.metadataArrayToMap(person.person_metadata);
+            const companyData = companyById.get(person.id);
+            const individualData = individualById.get(person.id);
+            const employerCompanyId = allowCompanyRegistration
+                ? (_a = employerCompanyIdByPersonId.get(person.id)) !== null && _a !== void 0 ? _a : null
+                : null;
+            const employerCompany = allowCompanyRegistration && employerCompanyId != null
+                ? this.normalizeRelationPersonSummary(employerCompanyById.get(employerCompanyId))
+                : null;
+            return {
+                id: person.id,
+                name: person.name,
+                type: person.type,
+                status: person.status,
+                avatar_id: (_b = person.avatar_id) !== null && _b !== void 0 ? _b : null,
+                created_at: person.created_at,
+                updated_at: person.updated_at,
+                birth_date: (_c = individualData === null || individualData === void 0 ? void 0 : individualData.birth_date) !== null && _c !== void 0 ? _c : null,
+                gender: (_d = individualData === null || individualData === void 0 ? void 0 : individualData.gender) !== null && _d !== void 0 ? _d : null,
+                job_title: (_e = individualData === null || individualData === void 0 ? void 0 : individualData.job_title) !== null && _e !== void 0 ? _e : null,
+                trade_name: (_f = companyData === null || companyData === void 0 ? void 0 : companyData.trade_name) !== null && _f !== void 0 ? _f : null,
+                foundation_date: (_g = companyData === null || companyData === void 0 ? void 0 : companyData.foundation_date) !== null && _g !== void 0 ? _g : null,
+                legal_nature: (_h = companyData === null || companyData === void 0 ? void 0 : companyData.legal_nature) !== null && _h !== void 0 ? _h : null,
+                headquarter_id: (_j = companyData === null || companyData === void 0 ? void 0 : companyData.headquarter_id) !== null && _j !== void 0 ? _j : null,
+                branch_ids: branchesByHeadquarterId.get(person.id) || [],
+                notes: this.metadataToString(metadata.get(NOTES_METADATA_KEY)),
+                employer_company_id: allowCompanyRegistration ? employerCompanyId : null,
+                employer_company: allowCompanyRegistration ? employerCompany : null,
+                contact: person.contact || [],
+                document: person.document || [],
+                address: Array.isArray(person.person_address)
+                    ? person.person_address
+                        .map((item) => item.address)
+                        .filter((address) => address != null)
+                    : [],
+            };
+        });
+    }
+    metadataArrayToMap(metadata) {
+        const map = new Map();
+        for (const item of Array.isArray(metadata) ? metadata : []) {
+            map.set(item.key, item.value);
+        }
+        return map;
+    }
+    metadataToString(value) {
+        if (value == null)
+            return null;
+        if (typeof value === 'string')
+            return value;
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        return null;
+    }
+    async syncPersonSubtypeData(tx, personId, currentType, data, locale) {
+        var _a, _b, _c;
+        const targetType = (_a = data.type) !== null && _a !== void 0 ? _a : currentType;
+        if (!targetType)
+            return;
+        if (targetType === 'individual') {
+            await tx.person_company.deleteMany({ where: { id: personId } });
+            await tx.person_individual.upsert({
+                where: { id: personId },
+                create: {
+                    id: personId,
+                    birth_date: this.parseDateOrNull(data.birth_date),
+                    gender: (_b = data.gender) !== null && _b !== void 0 ? _b : null,
+                    job_title: this.normalizeTextOrNull(data.job_title),
+                },
+                update: {
+                    birth_date: data.birth_date === undefined
+                        ? undefined
+                        : this.parseDateOrNull(data.birth_date),
+                    gender: data.gender === undefined ? undefined : (_c = data.gender) !== null && _c !== void 0 ? _c : null,
+                    job_title: data.job_title === undefined
+                        ? undefined
+                        : this.normalizeTextOrNull(data.job_title),
+                },
+            });
+            return;
+        }
+        await tx.person_individual_relation.deleteMany({
+            where: {
+                OR: [
+                    { person_individual_id: personId },
+                    { related_person_individual_id: personId },
+                ],
+            },
+        });
+        await tx.person_individual.deleteMany({ where: { id: personId } });
+        const normalizedHeadquarterId = this.coerceNumber(data.headquarter_id);
+        if (normalizedHeadquarterId > 0) {
+            if (normalizedHeadquarterId === personId) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('companyRelationSelfReference', locale, 'A company cannot be its own headquarter.'));
+            }
+            const headquarter = await tx.person.findFirst({
+                where: { id: normalizedHeadquarterId, type: 'company' },
+                select: { id: true },
+            });
+            if (!headquarter) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('companyRelationInvalidTarget', locale, 'Only company records can be linked as headquarters or branches.'));
+            }
+        }
+        await tx.person_company.upsert({
+            where: { id: personId },
+            create: {
+                id: personId,
+                trade_name: this.normalizeTextOrNull(data.trade_name),
+                foundation_date: this.parseDateOrNull(data.foundation_date),
+                legal_nature: this.normalizeTextOrNull(data.legal_nature),
+                headquarter_id: normalizedHeadquarterId > 0 ? normalizedHeadquarterId : null,
+            },
+            update: {
+                trade_name: data.trade_name === undefined
+                    ? undefined
+                    : this.normalizeTextOrNull(data.trade_name),
+                foundation_date: data.foundation_date === undefined
+                    ? undefined
+                    : this.parseDateOrNull(data.foundation_date),
+                legal_nature: data.legal_nature === undefined
+                    ? undefined
+                    : this.normalizeTextOrNull(data.legal_nature),
+                headquarter_id: data.headquarter_id === undefined
+                    ? undefined
+                    : normalizedHeadquarterId > 0
+                        ? normalizedHeadquarterId
+                        : null,
+            },
+        });
+        if (Object.prototype.hasOwnProperty.call(data, 'branch_ids')) {
+            await this.syncCompanyBranches(tx, personId, data.branch_ids, locale);
+        }
+    }
+    async syncCompanyBranches(tx, personId, branchIds, locale) {
+        const normalizedBranchIds = Array.from(new Set((Array.isArray(branchIds) ? branchIds : [])
+            .map((value) => Number(value))
+            .filter((value) => Number.isInteger(value) && value > 0 && value !== personId)));
+        if (normalizedBranchIds.length > 0) {
+            const companies = await tx.person.findMany({
+                where: {
+                    id: { in: normalizedBranchIds },
+                    type: 'company',
+                },
+                select: { id: true },
+            });
+            if (companies.length !== normalizedBranchIds.length) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('companyRelationInvalidTarget', locale, 'Only company records can be linked as headquarters or branches.'));
+            }
+            await tx.person_company.updateMany({
+                where: {
+                    id: { in: normalizedBranchIds },
+                },
+                data: {
+                    headquarter_id: personId,
+                },
+            });
+        }
+        await tx.person_company.updateMany({
+            where: {
+                headquarter_id: personId,
+                id: { notIn: normalizedBranchIds.length > 0 ? normalizedBranchIds : [-1] },
+            },
+            data: {
+                headquarter_id: null,
+            },
+        });
+    }
+    async syncPersonMetadata(tx, personId, data) {
+        if (data.notes !== undefined) {
+            await this.upsertMetadataValue(tx, personId, NOTES_METADATA_KEY, data.notes);
+        }
+        if (data.employer_company_id !== undefined) {
+            await this.upsertMetadataValue(tx, personId, EMPLOYER_COMPANY_METADATA_KEY, data.employer_company_id);
+        }
+    }
+    async upsertMetadataValue(tx, personId, key, value) {
+        const existing = await tx.person_metadata.findFirst({
+            where: {
+                person_id: personId,
+                key,
+            },
+            select: { id: true },
+        });
+        const normalizedValue = this.normalizeMetadataValue(value);
+        if (normalizedValue == null) {
+            if (existing) {
+                await tx.person_metadata.delete({ where: { id: existing.id } });
+            }
+            return;
+        }
+        if (existing) {
+            await tx.person_metadata.update({
+                where: { id: existing.id },
+                data: { value: normalizedValue },
+            });
+            return;
+        }
+        await tx.person_metadata.create({
+            data: {
+                person_id: personId,
+                key,
+                value: normalizedValue,
+            },
+        });
+    }
+    normalizeMetadataValue(value) {
+        if (value == null)
+            return null;
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            return trimmed.length > 0 ? trimmed : null;
+        }
+        if (typeof value === 'number') {
+            return Number.isFinite(value) ? value : null;
+        }
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        return null;
+    }
+    async syncContacts(tx, personId, incomingContacts) {
+        const existingContacts = await tx.contact.findMany({ where: { person_id: personId } });
+        for (const contact of incomingContacts) {
+            if (contact.id) {
+                await tx.contact.update({ where: { id: contact.id }, data: contact });
+            }
+            else {
+                await tx.contact.create({ data: Object.assign(Object.assign({}, contact), { person_id: personId }) });
+            }
+        }
+        for (const old of existingContacts) {
+            if (!incomingContacts.find((item) => item.id === old.id)) {
+                await tx.contact.delete({ where: { id: old.id } });
+            }
+        }
+    }
+    async syncAddresses(tx, personId, incomingAddresses, locale) {
+        const existingAddresses = await tx.person_address.findMany({
+            where: { person_id: personId },
+            include: { address: true },
+        });
+        for (const address of incomingAddresses) {
+            const addressData = {
+                line1: address.line1,
+                line2: address.line2 || '',
+                city: address.city,
+                state: address.state,
+                country_code: address.country_code || 'BRA',
+                postal_code: address.postal_code || '',
+                is_primary: address.is_primary,
+                address_type: address.address_type,
+            };
+            if (address.id) {
+                const existingLink = existingAddresses.find((item) => item.address_id === address.id);
+                if (!existingLink) {
+                    throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Address with ID ${address.id} not found for person ${personId}.`));
+                }
+                await tx.address.update({
+                    where: { id: address.id },
+                    data: addressData,
+                });
+            }
+            else {
+                const createdAddress = await tx.address.create({
+                    data: addressData,
+                });
+                await tx.person_address.create({
+                    data: {
+                        person_id: personId,
+                        address_id: createdAddress.id,
+                    },
+                });
+            }
+        }
+        for (const old of existingAddresses) {
+            if (!incomingAddresses.find((item) => item.id === old.address_id)) {
+                await tx.person_address.delete({ where: { id: old.id } });
+                await tx.address.delete({ where: { id: old.address_id } });
+            }
+        }
+    }
+    async syncDocuments(tx, personId, incomingDocuments) {
+        const existingDocuments = await tx.document.findMany({ where: { person_id: personId } });
+        for (const document of incomingDocuments) {
+            if (document.id) {
+                await tx.document.update({ where: { id: document.id }, data: document });
+            }
+            else {
+                await tx.document.create({ data: Object.assign(Object.assign({}, document), { person_id: personId }) });
+            }
+        }
+        for (const old of existingDocuments) {
+            if (!incomingDocuments.find((item) => item.id === old.id)) {
+                await tx.document.delete({ where: { id: old.id } });
+            }
+        }
+    }
+    validateSinglePrimaryPerType(items, groupKey, locale, localeKey, fallbackMessage) {
+        const map = new Map();
+        for (const item of items) {
+            if (!item.is_primary)
+                continue;
+            const key = String(item[groupKey]);
+            map.set(key, (map.get(key) || 0) + 1);
+        }
+        for (const count of map.values()) {
+            if (count > 1) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)(localeKey, locale, fallbackMessage));
+            }
+        }
+    }
+    parseDateOrNull(value) {
+        if (!value)
+            return null;
+        const date = value instanceof Date ? value : new Date(String(value));
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    normalizeTextOrNull(value) {
+        if (typeof value !== 'string') {
+            return value == null ? null : String(value);
+        }
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    coerceNumber(value) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    async buildSearchFilters(search) {
+        const normalizedDigits = this.normalizeDigits(search);
+        const filters = [];
+        if (!Number.isNaN(+search)) {
+            filters.push({ id: { equals: +search } });
+        }
+        filters.push({ name: { contains: search, mode: 'insensitive' } }, {
+            person_metadata: {
+                some: {
+                    value: { path: [], equals: search },
+                },
+            },
+        }, {
+            contact: {
+                some: {
+                    value: { contains: search, mode: 'insensitive' },
+                },
+            },
+        }, {
+            document: {
+                some: {
+                    value: { contains: search, mode: 'insensitive' },
+                },
+            },
+        }, {
+            person_address: {
+                some: {
+                    address: {
+                        OR: [
+                            { line1: { contains: search, mode: 'insensitive' } },
+                            { line2: { contains: search, mode: 'insensitive' } },
+                            { city: { contains: search, mode: 'insensitive' } },
+                            { state: { contains: search, mode: 'insensitive' } },
+                            { postal_code: { contains: search, mode: 'insensitive' } },
+                            { country_code: { contains: search, mode: 'insensitive' } },
+                        ],
+                    },
+                },
+            },
+        });
+        if (normalizedDigits.length > 0) {
+            const normalizedMatches = await this.findPersonIdsByNormalizedDigits(normalizedDigits);
+            if (normalizedMatches.length > 0) {
+                filters.push({
+                    id: {
+                        in: normalizedMatches,
+                    },
+                });
+            }
+        }
+        return filters;
+    }
+    normalizeDigits(value) {
+        return value.replace(/\D/g, '');
+    }
+    async findPersonIdsByNormalizedDigits(normalizedDigits) {
+        const likeValue = `%${normalizedDigits}%`;
+        const rows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT DISTINCT p.id
+        FROM person p
+        LEFT JOIN contact c ON c.person_id = p.id
+        LEFT JOIN document d ON d.person_id = p.id
+        LEFT JOIN person_address pa ON pa.person_id = p.id
+        LEFT JOIN address a ON a.id = pa.address_id
+        WHERE regexp_replace(COALESCE(c.value, ''), '[^0-9]+', '', 'g') ILIKE ${likeValue}
+          OR regexp_replace(COALESCE(d.value, ''), '[^0-9]+', '', 'g') ILIKE ${likeValue}
+          OR regexp_replace(COALESCE(a.postal_code, ''), '[^0-9]+', '', 'g') ILIKE ${likeValue}
+      `);
+        return rows.map((row) => row.id);
+    }
+    async ensureCompanyRegistrationAllowed({ currentType, nextType, locale, }) {
+        const targetType = nextType !== null && nextType !== void 0 ? nextType : currentType;
+        const isNewCompanyRegistration = targetType === 'company' && currentType !== 'company';
+        if (!isNewCompanyRegistration) {
+            return;
+        }
+        const settings = await this.settingService.getSettingValues(CONTACT_ALLOW_COMPANY_REGISTRATION_SETTING);
+        if (settings[CONTACT_ALLOW_COMPANY_REGISTRATION_SETTING] !== false) {
+            return;
+        }
+        throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('companyRegistrationDisabled', locale, 'Company registration is disabled. Only individual records can be created.'));
+    }
+    async isCompanyRegistrationAllowed() {
+        const settings = await this.settingService.getSettingValues(CONTACT_ALLOW_COMPANY_REGISTRATION_SETTING);
+        return settings[CONTACT_ALLOW_COMPANY_REGISTRATION_SETTING] !== false;
+    }
+    async cleanupReplacedAvatar(locale, previousAvatarId, nextAvatarId) {
+        if (!previousAvatarId || previousAvatarId === nextAvatarId) {
+            return;
+        }
+        try {
+            await this.fileService.delete(locale, { ids: [previousAvatarId] });
+        }
+        catch (_a) {
+            // Keep the person update successful even if avatar cleanup fails.
+        }
+    }
+    normalizeRelationPersonSummary(person) {
+        var _a, _b;
+        if (!person)
+            return null;
+        const tradeName = ((_a = person.person_company) === null || _a === void 0 ? void 0 : _a.trade_name) != null
+            ? String(person.person_company.trade_name)
+            : null;
+        return {
+            id: person.id,
+            name: person.name,
+            type: person.type,
+            status: person.status,
+            avatar_id: (_b = person.avatar_id) !== null && _b !== void 0 ? _b : null,
+            trade_name: tradeName,
+        };
+    }
 };
 exports.PersonService = PersonService;
 exports.PersonService = PersonService = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)((0, common_1.forwardRef)(() => api_prisma_1.PrismaService))),
     __param(1, (0, common_1.Inject)((0, common_1.forwardRef)(() => api_pagination_1.PaginationService))),
+    __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.FileService))),
+    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.SettingService))),
     __metadata("design:paramtypes", [api_prisma_1.PrismaService,
-        api_pagination_1.PaginationService])
+        api_pagination_1.PaginationService,
+        core_1.FileService,
+        core_1.SettingService])
 ], PersonService);
 //# sourceMappingURL=person.service.js.map