@hed-hog/contact 0.0.279 → 0.0.286

package/dist/person/person.service.js

@@ -18,6 +18,7 @@ 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 create_interaction_dto_1 = require("./dto/create-interaction.dto");
 const CONTACT_ALLOW_COMPANY_REGISTRATION_SETTING = 'contact-allow-company-registration';
 const CONTACT_OWNER_ROLE_SLUG = 'owner-contact';
 const CONTACT_OWNER_ALLOWED_ROLE_SLUGS = [
@@ -27,6 +28,16 @@ const CONTACT_OWNER_ALLOWED_ROLE_SLUGS = [
 ];
 const EMPLOYER_COMPANY_METADATA_KEY = 'employer_company_id';
 const NOTES_METADATA_KEY = 'notes';
+const MERGED_INTO_PERSON_METADATA_KEY = 'merged_into_person_id';
+const OWNER_USER_METADATA_KEY = 'owner_user_id';
+const SOURCE_METADATA_KEY = 'source';
+const LIFECYCLE_STAGE_METADATA_KEY = 'lifecycle_stage';
+const NEXT_ACTION_AT_METADATA_KEY = 'next_action_at';
+const SCORE_METADATA_KEY = 'score';
+const DEAL_VALUE_METADATA_KEY = 'deal_value';
+const TAGS_METADATA_KEY = 'tags';
+const LAST_INTERACTION_AT_METADATA_KEY = 'last_interaction_at';
+const INTERACTIONS_METADATA_KEY = 'interactions';
 let PersonService = class PersonService {
     constructor(prismaService, paginationService, fileService, settingService) {
         this.prismaService = prismaService;
@@ -114,6 +125,151 @@ let PersonService = class PersonService {
         }
         return Array.from(byId.values());
     }
+    async checkDuplicates(query) {
+        const excludedPersonId = this.coerceNumber(query.person_id);
+        const normalizedEmail = this.normalizeEmail(query.email);
+        const normalizedPhone = this.normalizeDigits(query.phone || '');
+        const normalizedDocument = this.normalizeDigits(query.document_value || '');
+        const documentTypeId = this.coerceNumber(query.document_type_id);
+        if (!normalizedEmail && !normalizedPhone && !normalizedDocument) {
+            return { hasDuplicates: false, matches: [] };
+        }
+        const reasonsByPersonId = new Map();
+        if (normalizedEmail) {
+            const emailRows = await this.prismaService.contact.findMany({
+                where: Object.assign(Object.assign({}, (excludedPersonId > 0
+                    ? {
+                        person_id: {
+                            not: excludedPersonId,
+                        },
+                    }
+                    : {})), { contact_type: {
+                        code: {
+                            equals: 'EMAIL',
+                            mode: 'insensitive',
+                        },
+                    }, value: {
+                        equals: normalizedEmail,
+                        mode: 'insensitive',
+                    } }),
+                select: {
+                    person_id: true,
+                },
+            });
+            for (const row of emailRows) {
+                this.addDuplicateReason(reasonsByPersonId, row.person_id, 'email');
+            }
+        }
+        if (normalizedPhone) {
+            const excludedPersonFilter = excludedPersonId > 0
+                ? api_prisma_1.Prisma.sql ` AND c.person_id <> ${excludedPersonId}`
+                : api_prisma_1.Prisma.empty;
+            const phoneRows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+          SELECT DISTINCT c.person_id
+          FROM contact c
+          JOIN contact_type ct ON ct.id = c.contact_type_id
+          WHERE UPPER(ct.code) IN ('PHONE', 'MOBILE', 'WHATSAPP')
+            AND regexp_replace(COALESCE(c.value, ''), '[^0-9]+', '', 'g') = ${normalizedPhone}
+            ${excludedPersonFilter}
+        `);
+            for (const row of phoneRows) {
+                this.addDuplicateReason(reasonsByPersonId, row.person_id, 'phone');
+            }
+        }
+        if (normalizedDocument) {
+            const excludedPersonFilter = excludedPersonId > 0
+                ? api_prisma_1.Prisma.sql ` AND d.person_id <> ${excludedPersonId}`
+                : api_prisma_1.Prisma.empty;
+            const documentTypeFilter = documentTypeId > 0
+                ? api_prisma_1.Prisma.sql ` AND d.document_type_id = ${documentTypeId}`
+                : api_prisma_1.Prisma.empty;
+            const documentRows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+          SELECT DISTINCT d.person_id
+          FROM document d
+          WHERE regexp_replace(COALESCE(d.value, ''), '[^0-9]+', '', 'g') = ${normalizedDocument}
+            ${excludedPersonFilter}
+            ${documentTypeFilter}
+        `);
+            for (const row of documentRows) {
+                this.addDuplicateReason(reasonsByPersonId, row.person_id, 'document');
+            }
+        }
+        const duplicateIds = Array.from(reasonsByPersonId.keys());
+        if (duplicateIds.length === 0) {
+            return { hasDuplicates: false, matches: [] };
+        }
+        const people = await this.prismaService.person.findMany({
+            where: {
+                id: {
+                    in: duplicateIds,
+                },
+            },
+            select: {
+                id: true,
+                name: true,
+            },
+            orderBy: {
+                name: 'asc',
+            },
+        });
+        const matches = people.map((person) => ({
+            id: person.id,
+            name: person.name,
+            reasons: Array.from(reasonsByPersonId.get(person.id) || []),
+        }));
+        return {
+            hasDuplicates: matches.length > 0,
+            matches,
+        };
+    }
+    async merge(data, locale) {
+        const sourcePersonId = this.coerceNumber(data.source_person_id);
+        const targetPersonId = this.coerceNumber(data.target_person_id);
+        if (sourcePersonId <= 0 || targetPersonId <= 0) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.idMustBeInteger', locale, 'Source and target person IDs must be valid integers.'));
+        }
+        if (sourcePersonId === targetPersonId) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personMergeSameRecord', locale, 'Source and target person must be different records.'));
+        }
+        const [sourcePerson, targetPerson] = await Promise.all([
+            this.prismaService.person.findUnique({
+                where: { id: sourcePersonId },
+                select: { id: true, name: true, type: true },
+            }),
+            this.prismaService.person.findUnique({
+                where: { id: targetPersonId },
+                select: { id: true, name: true, type: true },
+            }),
+        ]);
+        if (!sourcePerson) {
+            throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${sourcePersonId} not found`));
+        }
+        if (!targetPerson) {
+            throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${targetPersonId} not found`));
+        }
+        if (sourcePerson.type !== targetPerson.type) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personMergeTypeMismatch', locale, 'Only records with the same type can be merged.'));
+        }
+        await this.prismaService.$transaction(async (tx) => {
+            await this.mergeContacts(tx, sourcePersonId, targetPersonId);
+            await this.mergeDocuments(tx, sourcePersonId, targetPersonId);
+            await this.mergeAddresses(tx, sourcePersonId, targetPersonId);
+            await this.mergeMetadata(tx, sourcePersonId, targetPersonId);
+            await tx.person.update({
+                where: { id: sourcePersonId },
+                data: {
+                    status: 'inactive',
+                },
+            });
+            await this.upsertMetadataValue(tx, sourcePersonId, MERGED_INTO_PERSON_METADATA_KEY, targetPersonId);
+        });
+        return {
+            success: true,
+            source_person_id: sourcePersonId,
+            target_person_id: targetPersonId,
+            strategy: 'contact_only',
+        };
+    }
     async list(paginationParams, currentUserId) {
         var _a;
         const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
@@ -136,6 +292,42 @@ let PersonService = class PersonService {
         if (paginationParams.status && paginationParams.status !== 'all') {
             where.status = paginationParams.status;
         }
+        const ownerUserId = this.resolveRequestedOwnerUserId(paginationParams.owner_user_id, paginationParams.mine, currentUserId);
+        const metadataFilters = [];
+        if (ownerUserId > 0) {
+            metadataFilters.push({
+                person_metadata: {
+                    some: {
+                        key: OWNER_USER_METADATA_KEY,
+                        value: ownerUserId,
+                    },
+                },
+            });
+        }
+        if (paginationParams.source && paginationParams.source !== 'all') {
+            metadataFilters.push({
+                person_metadata: {
+                    some: {
+                        key: SOURCE_METADATA_KEY,
+                        value: paginationParams.source,
+                    },
+                },
+            });
+        }
+        if (paginationParams.lifecycle_stage &&
+            paginationParams.lifecycle_stage !== 'all') {
+            metadataFilters.push({
+                person_metadata: {
+                    some: {
+                        key: LIFECYCLE_STAGE_METADATA_KEY,
+                        value: paginationParams.lifecycle_stage,
+                    },
+                },
+            });
+        }
+        if (metadataFilters.length > 0) {
+            where.AND = [...(Array.isArray(where.AND) ? where.AND : []), ...metadataFilters];
+        }
         if (search) {
             where.OR = await this.buildSearchFilters(search);
         }
@@ -179,6 +371,71 @@ let PersonService = class PersonService {
         const [normalized] = await this.enrichPeople([person], allowCompanyRegistration);
         return normalized;
     }
+    async listInteractions(id, locale) {
+        const person = await this.ensurePersonAccessible(id, locale);
+        const metadata = await this.prismaService.person_metadata.findFirst({
+            where: {
+                person_id: person.id,
+                key: INTERACTIONS_METADATA_KEY,
+            },
+            select: {
+                value: true,
+            },
+        });
+        return this.metadataToInteractions(metadata === null || metadata === void 0 ? void 0 : metadata.value);
+    }
+    async createInteraction(id, data, locale, user) {
+        const person = await this.ensurePersonAccessible(id, locale);
+        const interaction = this.buildInteractionRecord(data, user);
+        await this.prismaService.$transaction(async (tx) => {
+            const currentInteractions = await this.loadInteractionsFromTx(tx, person.id);
+            const nextInteractions = this.sortInteractions([
+                interaction,
+                ...currentInteractions,
+            ]);
+            await this.upsertMetadataValue(tx, person.id, INTERACTIONS_METADATA_KEY, nextInteractions);
+            await this.upsertMetadataValue(tx, person.id, LAST_INTERACTION_AT_METADATA_KEY, interaction.created_at);
+        });
+        return interaction;
+    }
+    async scheduleFollowup(id, data, locale, user) {
+        const person = await this.ensurePersonAccessible(id, locale);
+        const normalizedNextActionAt = this.normalizeDateTimeOrNull(data.next_action_at);
+        if (!normalizedNextActionAt) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.dateMustBeString', locale, 'next_action_at must be a valid datetime.'));
+        }
+        await this.prismaService.$transaction(async (tx) => {
+            await this.upsertMetadataValue(tx, person.id, NEXT_ACTION_AT_METADATA_KEY, normalizedNextActionAt);
+            const notes = this.normalizeTextOrNull(data.notes);
+            if (notes) {
+                const interaction = this.buildInteractionRecord({
+                    type: create_interaction_dto_1.PersonInteractionTypeDTO.NOTE,
+                    notes,
+                }, user);
+                const currentInteractions = await this.loadInteractionsFromTx(tx, person.id);
+                const nextInteractions = this.sortInteractions([
+                    interaction,
+                    ...currentInteractions,
+                ]);
+                await this.upsertMetadataValue(tx, person.id, INTERACTIONS_METADATA_KEY, nextInteractions);
+                await this.upsertMetadataValue(tx, person.id, LAST_INTERACTION_AT_METADATA_KEY, interaction.created_at);
+            }
+        });
+        return {
+            success: true,
+            next_action_at: normalizedNextActionAt,
+        };
+    }
+    async updateLifecycleStage(id, data, locale) {
+        const person = await this.ensurePersonAccessible(id, locale);
+        await this.prismaService.$transaction(async (tx) => {
+            await this.upsertMetadataValue(tx, person.id, LIFECYCLE_STAGE_METADATA_KEY, data.lifecycle_stage);
+        });
+        return {
+            success: true,
+            lifecycle_stage: data.lifecycle_stage,
+        };
+    }
     async create(data, locale) {
         const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
         await this.ensureCompanyRegistrationAllowed({
@@ -201,6 +458,13 @@ let PersonService = class PersonService {
                 employer_company_id: allowCompanyRegistration
                     ? (_b = data.employer_company_id) !== null && _b !== void 0 ? _b : null
                     : null,
+                owner_user_id: data.owner_user_id,
+                source: data.source,
+                lifecycle_stage: data.lifecycle_stage,
+                next_action_at: data.next_action_at,
+                score: data.score,
+                deal_value: data.deal_value,
+                tags: data.tags,
             });
             return person;
         });
@@ -246,6 +510,13 @@ let PersonService = class PersonService {
                         ? undefined
                         : data.employer_company_id
                     : null,
+                owner_user_id: data.owner_user_id,
+                source: data.source,
+                lifecycle_stage: data.lifecycle_stage,
+                next_action_at: data.next_action_at,
+                score: data.score,
+                deal_value: data.deal_value,
+                tags: data.tags,
             });
             await this.syncContacts(tx, id, incomingContacts);
             await this.syncAddresses(tx, id, incomingAddresses, locale);
@@ -385,6 +656,66 @@ let PersonService = class PersonService {
                 employerCompanyIdByPersonId.set(meta.person_id, employerId);
             }
         }
+        const ownerUserIdByPersonId = new Map();
+        const sourceByPersonId = new Map();
+        const lifecycleStageByPersonId = new Map();
+        const nextActionAtByPersonId = new Map();
+        const scoreByPersonId = new Map();
+        const dealValueByPersonId = new Map();
+        const tagsByPersonId = new Map();
+        const lastInteractionAtByPersonId = new Map();
+        const interactionCountByPersonId = new Map();
+        for (const person of people) {
+            const metadata = this.metadataArrayToMap(person.person_metadata);
+            const ownerUserId = this.metadataToNumber(metadata.get(OWNER_USER_METADATA_KEY));
+            if (ownerUserId > 0) {
+                ownerUserIdByPersonId.set(person.id, ownerUserId);
+            }
+            const source = this.metadataToString(metadata.get(SOURCE_METADATA_KEY));
+            if (source) {
+                sourceByPersonId.set(person.id, source);
+            }
+            const lifecycleStage = this.metadataToString(metadata.get(LIFECYCLE_STAGE_METADATA_KEY));
+            if (lifecycleStage) {
+                lifecycleStageByPersonId.set(person.id, lifecycleStage);
+            }
+            const nextActionAt = this.metadataToIsoString(metadata.get(NEXT_ACTION_AT_METADATA_KEY));
+            if (nextActionAt) {
+                nextActionAtByPersonId.set(person.id, nextActionAt);
+            }
+            const score = this.metadataToNumber(metadata.get(SCORE_METADATA_KEY));
+            if (score != null) {
+                scoreByPersonId.set(person.id, score);
+            }
+            const dealValue = this.metadataToNumber(metadata.get(DEAL_VALUE_METADATA_KEY));
+            if (dealValue != null) {
+                dealValueByPersonId.set(person.id, dealValue);
+            }
+            const tags = this.metadataToStringArray(metadata.get(TAGS_METADATA_KEY));
+            if (tags.length > 0) {
+                tagsByPersonId.set(person.id, tags);
+            }
+            const lastInteractionAt = this.metadataToIsoString(metadata.get(LAST_INTERACTION_AT_METADATA_KEY));
+            if (lastInteractionAt) {
+                lastInteractionAtByPersonId.set(person.id, lastInteractionAt);
+            }
+            interactionCountByPersonId.set(person.id, this.metadataToInteractions(metadata.get(INTERACTIONS_METADATA_KEY)).length);
+        }
+        const ownerUserIds = Array.from(new Set(ownerUserIdByPersonId.values()));
+        const ownerUsers = ownerUserIds.length > 0
+            ? await this.prismaService.user.findMany({
+                where: {
+                    id: {
+                        in: ownerUserIds,
+                    },
+                },
+                select: {
+                    id: true,
+                    name: true,
+                },
+            })
+            : [];
+        const ownerUserById = new Map(ownerUsers.map((item) => [item.id, { id: item.id, name: item.name || `#${item.id}` }]));
         const employerCompanyIds = Array.from(new Set(Array.from(employerCompanyIdByPersonId.values())));
         const employerCompanies = employerCompanyIds.length > 0
             ? await this.prismaService.person.findMany({
@@ -410,7 +741,7 @@ let PersonService = class PersonService {
             ];
         }));
         return people.map((person) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
             const metadata = this.metadataArrayToMap(person.person_metadata);
             const companyData = companyById.get(person.id);
             const individualData = individualById.get(person.id);
@@ -420,23 +751,34 @@ let PersonService = class PersonService {
             const employerCompany = allowCompanyRegistration && employerCompanyId != null
                 ? this.normalizeRelationPersonSummary(employerCompanyById.get(employerCompanyId))
                 : null;
+            const ownerUserId = (_b = ownerUserIdByPersonId.get(person.id)) !== null && _b !== void 0 ? _b : 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,
+                avatar_id: (_c = person.avatar_id) !== null && _c !== void 0 ? _c : 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,
+                birth_date: (_d = individualData === null || individualData === void 0 ? void 0 : individualData.birth_date) !== null && _d !== void 0 ? _d : null,
+                gender: (_e = individualData === null || individualData === void 0 ? void 0 : individualData.gender) !== null && _e !== void 0 ? _e : null,
+                job_title: (_f = individualData === null || individualData === void 0 ? void 0 : individualData.job_title) !== null && _f !== void 0 ? _f : null,
+                trade_name: (_g = companyData === null || companyData === void 0 ? void 0 : companyData.trade_name) !== null && _g !== void 0 ? _g : null,
+                foundation_date: (_h = companyData === null || companyData === void 0 ? void 0 : companyData.foundation_date) !== null && _h !== void 0 ? _h : null,
+                legal_nature: (_j = companyData === null || companyData === void 0 ? void 0 : companyData.legal_nature) !== null && _j !== void 0 ? _j : null,
+                headquarter_id: (_k = companyData === null || companyData === void 0 ? void 0 : companyData.headquarter_id) !== null && _k !== void 0 ? _k : null,
                 branch_ids: branchesByHeadquarterId.get(person.id) || [],
                 notes: this.metadataToString(metadata.get(NOTES_METADATA_KEY)),
+                owner_user_id: ownerUserId,
+                owner_user: ownerUserId ? (_l = ownerUserById.get(ownerUserId)) !== null && _l !== void 0 ? _l : null : null,
+                source: (_m = sourceByPersonId.get(person.id)) !== null && _m !== void 0 ? _m : null,
+                lifecycle_stage: (_o = lifecycleStageByPersonId.get(person.id)) !== null && _o !== void 0 ? _o : 'new',
+                next_action_at: (_p = nextActionAtByPersonId.get(person.id)) !== null && _p !== void 0 ? _p : null,
+                score: (_q = scoreByPersonId.get(person.id)) !== null && _q !== void 0 ? _q : 0,
+                deal_value: (_r = dealValueByPersonId.get(person.id)) !== null && _r !== void 0 ? _r : 0,
+                tags: (_s = tagsByPersonId.get(person.id)) !== null && _s !== void 0 ? _s : [],
+                last_interaction_at: (_w = (_t = lastInteractionAtByPersonId.get(person.id)) !== null && _t !== void 0 ? _t : (_v = (_u = person.created_at) === null || _u === void 0 ? void 0 : _u.toISOString) === null || _v === void 0 ? void 0 : _v.call(_u)) !== null && _w !== void 0 ? _w : null,
+                interaction_count: (_x = interactionCountByPersonId.get(person.id)) !== null && _x !== void 0 ? _x : 0,
                 employer_company_id: allowCompanyRegistration ? employerCompanyId : null,
                 employer_company: allowCompanyRegistration ? employerCompany : null,
                 contact: person.contact || [],
@@ -466,6 +808,61 @@ let PersonService = class PersonService {
         }
         return null;
     }
+    metadataToNumber(value) {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const parsed = Number(value);
+            return Number.isFinite(parsed) ? parsed : null;
+        }
+        return null;
+    }
+    metadataToIsoString(value) {
+        if (!value)
+            return null;
+        const parsed = new Date(String(value));
+        return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+    }
+    metadataToStringArray(value) {
+        if (Array.isArray(value)) {
+            return value
+                .map((item) => this.normalizeTextOrNull(item))
+                .filter((item) => Boolean(item));
+        }
+        if (typeof value === 'string') {
+            return value
+                .split(',')
+                .map((item) => item.trim())
+                .filter(Boolean);
+        }
+        return [];
+    }
+    metadataToInteractions(value) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        return this.sortInteractions(value
+            .map((item) => {
+            if (!item || typeof item !== 'object')
+                return null;
+            const interaction = item;
+            const createdAt = this.metadataToIsoString(interaction.created_at);
+            const type = this.normalizeTextOrNull(interaction.type);
+            if (!createdAt || !type) {
+                return null;
+            }
+            return {
+                id: this.coerceNumber(interaction.id) || Date.now(),
+                type: type,
+                notes: this.normalizeTextOrNull(interaction.notes),
+                created_at: createdAt,
+                user_id: this.coerceNumber(interaction.user_id) || null,
+                user_name: this.normalizeTextOrNull(interaction.user_name),
+            };
+        })
+            .filter((item) => item != null));
+    }
     async syncPersonSubtypeData(tx, personId, currentType, data, locale) {
         var _a, _b, _c;
         const targetType = (_a = data.type) !== null && _a !== void 0 ? _a : currentType;
@@ -586,6 +983,38 @@ let PersonService = class PersonService {
         if (data.employer_company_id !== undefined) {
             await this.upsertMetadataValue(tx, personId, EMPLOYER_COMPANY_METADATA_KEY, data.employer_company_id);
         }
+        if (data.owner_user_id !== undefined) {
+            await this.upsertMetadataValue(tx, personId, OWNER_USER_METADATA_KEY, data.owner_user_id);
+        }
+        if (data.source !== undefined) {
+            await this.upsertMetadataValue(tx, personId, SOURCE_METADATA_KEY, data.source);
+        }
+        if (data.lifecycle_stage !== undefined) {
+            await this.upsertMetadataValue(tx, personId, LIFECYCLE_STAGE_METADATA_KEY, data.lifecycle_stage);
+        }
+        if (data.next_action_at !== undefined) {
+            await this.upsertMetadataValue(tx, personId, NEXT_ACTION_AT_METADATA_KEY, this.normalizeDateTimeOrNull(data.next_action_at));
+        }
+        if (data.score !== undefined) {
+            await this.upsertMetadataValue(tx, personId, SCORE_METADATA_KEY, data.score);
+        }
+        if (data.deal_value !== undefined) {
+            await this.upsertMetadataValue(tx, personId, DEAL_VALUE_METADATA_KEY, data.deal_value);
+        }
+        if (data.tags !== undefined) {
+            const normalizedTags = Array.isArray(data.tags)
+                ? data.tags
+                    .map((item) => this.normalizeTextOrNull(item))
+                    .filter((item) => Boolean(item))
+                : null;
+            await this.upsertMetadataValue(tx, personId, TAGS_METADATA_KEY, normalizedTags);
+        }
+        if (data.last_interaction_at !== undefined) {
+            await this.upsertMetadataValue(tx, personId, LAST_INTERACTION_AT_METADATA_KEY, this.normalizeDateTimeOrNull(data.last_interaction_at));
+        }
+        if (data.interactions !== undefined) {
+            await this.upsertMetadataValue(tx, personId, INTERACTIONS_METADATA_KEY, data.interactions);
+        }
     }
     async upsertMetadataValue(tx, personId, key, value) {
         const existing = await tx.person_metadata.findFirst({
@@ -630,6 +1059,14 @@ let PersonService = class PersonService {
         if (typeof value === 'boolean') {
             return value;
         }
+        if (Array.isArray(value) || typeof value === 'object') {
+            try {
+                return JSON.parse(JSON.stringify(value));
+            }
+            catch (_a) {
+                return null;
+            }
+        }
         return null;
     }
     async syncContacts(tx, personId, incomingContacts) {
@@ -709,6 +1146,234 @@ let PersonService = class PersonService {
             }
         }
     }
+    addDuplicateReason(reasonsByPersonId, personId, reason) {
+        var _a;
+        if (!reasonsByPersonId.has(personId)) {
+            reasonsByPersonId.set(personId, new Set());
+        }
+        (_a = reasonsByPersonId.get(personId)) === null || _a === void 0 ? void 0 : _a.add(reason);
+    }
+    async mergeContacts(tx, sourcePersonId, targetPersonId) {
+        const [sourceContacts, targetContacts] = await Promise.all([
+            tx.contact.findMany({ where: { person_id: sourcePersonId } }),
+            tx.contact.findMany({ where: { person_id: targetPersonId } }),
+        ]);
+        const existingByKey = new Set(targetContacts.map((contact) => this.buildContactDedupKey(contact.contact_type_id, contact.value)));
+        const hasPrimaryType = new Set(targetContacts
+            .filter((contact) => contact.is_primary)
+            .map((contact) => Number(contact.contact_type_id)));
+        for (const sourceContact of sourceContacts) {
+            const dedupKey = this.buildContactDedupKey(sourceContact.contact_type_id, sourceContact.value);
+            if (existingByKey.has(dedupKey)) {
+                continue;
+            }
+            const keepPrimary = sourceContact.is_primary &&
+                !hasPrimaryType.has(Number(sourceContact.contact_type_id));
+            await tx.contact.create({
+                data: {
+                    person_id: targetPersonId,
+                    contact_type_id: sourceContact.contact_type_id,
+                    value: sourceContact.value,
+                    is_primary: keepPrimary,
+                },
+            });
+            existingByKey.add(dedupKey);
+            if (keepPrimary) {
+                hasPrimaryType.add(Number(sourceContact.contact_type_id));
+            }
+        }
+        await tx.contact.deleteMany({
+            where: {
+                person_id: sourcePersonId,
+            },
+        });
+    }
+    async mergeDocuments(tx, sourcePersonId, targetPersonId) {
+        const [sourceDocuments, targetDocuments] = await Promise.all([
+            tx.document.findMany({ where: { person_id: sourcePersonId } }),
+            tx.document.findMany({ where: { person_id: targetPersonId } }),
+        ]);
+        const existingByKey = new Set(targetDocuments.map((document) => this.buildDocumentDedupKey(document.document_type_id, document.value)));
+        for (const sourceDocument of sourceDocuments) {
+            const dedupKey = this.buildDocumentDedupKey(sourceDocument.document_type_id, sourceDocument.value);
+            if (existingByKey.has(dedupKey)) {
+                continue;
+            }
+            await tx.document.create({
+                data: {
+                    person_id: targetPersonId,
+                    document_type_id: sourceDocument.document_type_id,
+                    value: sourceDocument.value,
+                },
+            });
+            existingByKey.add(dedupKey);
+        }
+        await tx.document.deleteMany({
+            where: {
+                person_id: sourcePersonId,
+            },
+        });
+    }
+    async mergeAddresses(tx, sourcePersonId, targetPersonId) {
+        const [sourceLinks, targetLinks] = await Promise.all([
+            tx.person_address.findMany({
+                where: { person_id: sourcePersonId },
+                include: { address: true },
+            }),
+            tx.person_address.findMany({
+                where: { person_id: targetPersonId },
+                include: { address: true },
+            }),
+        ]);
+        const targetByKey = new Map();
+        const hasPrimaryType = new Set();
+        for (const link of targetLinks) {
+            if (!link.address)
+                continue;
+            targetByKey.set(this.buildAddressDedupKey(link.address), link.address);
+            if (link.address.is_primary && link.address.address_type) {
+                hasPrimaryType.add(String(link.address.address_type));
+            }
+        }
+        for (const sourceLink of sourceLinks) {
+            if (!sourceLink.address) {
+                await tx.person_address.delete({ where: { id: sourceLink.id } });
+                continue;
+            }
+            const sourceAddress = sourceLink.address;
+            const dedupKey = this.buildAddressDedupKey(sourceAddress);
+            const existingTargetAddress = targetByKey.get(dedupKey);
+            if (existingTargetAddress) {
+                if (sourceAddress.is_primary &&
+                    sourceAddress.address_type &&
+                    !hasPrimaryType.has(String(sourceAddress.address_type))) {
+                    await tx.address.update({
+                        where: { id: existingTargetAddress.id },
+                        data: {
+                            is_primary: true,
+                        },
+                    });
+                    hasPrimaryType.add(String(sourceAddress.address_type));
+                }
+                await tx.person_address.delete({ where: { id: sourceLink.id } });
+                await tx.address.delete({ where: { id: sourceAddress.id } });
+                continue;
+            }
+            const keepPrimary = sourceAddress.is_primary &&
+                sourceAddress.address_type &&
+                !hasPrimaryType.has(String(sourceAddress.address_type));
+            await tx.person_address.update({
+                where: { id: sourceLink.id },
+                data: {
+                    person_id: targetPersonId,
+                },
+            });
+            if (Boolean(sourceAddress.is_primary) !== Boolean(keepPrimary)) {
+                await tx.address.update({
+                    where: { id: sourceAddress.id },
+                    data: {
+                        is_primary: Boolean(keepPrimary),
+                    },
+                });
+            }
+            targetByKey.set(dedupKey, sourceAddress);
+            if (keepPrimary && sourceAddress.address_type) {
+                hasPrimaryType.add(String(sourceAddress.address_type));
+            }
+        }
+    }
+    async mergeMetadata(tx, sourcePersonId, targetPersonId) {
+        const [sourceMetadata, targetMetadata] = await Promise.all([
+            tx.person_metadata.findMany({ where: { person_id: sourcePersonId } }),
+            tx.person_metadata.findMany({ where: { person_id: targetPersonId } }),
+        ]);
+        const targetByKey = new Map();
+        for (const metadata of targetMetadata) {
+            if (!targetByKey.has(metadata.key)) {
+                targetByKey.set(metadata.key, metadata);
+            }
+        }
+        for (const sourceItem of sourceMetadata) {
+            if (sourceItem.key === MERGED_INTO_PERSON_METADATA_KEY) {
+                await tx.person_metadata.delete({ where: { id: sourceItem.id } });
+                continue;
+            }
+            const targetItem = targetByKey.get(sourceItem.key);
+            if (!targetItem) {
+                await tx.person_metadata.update({
+                    where: { id: sourceItem.id },
+                    data: {
+                        person_id: targetPersonId,
+                    },
+                });
+                targetByKey.set(sourceItem.key, sourceItem);
+                continue;
+            }
+            if (sourceItem.key === NOTES_METADATA_KEY) {
+                const targetNotes = this.metadataToString(targetItem.value);
+                const sourceNotes = this.metadataToString(sourceItem.value);
+                if (sourceNotes && sourceNotes !== targetNotes) {
+                    const nextNotes = [targetNotes, sourceNotes].filter(Boolean).join('\n\n');
+                    await tx.person_metadata.update({
+                        where: { id: targetItem.id },
+                        data: {
+                            value: nextNotes,
+                        },
+                    });
+                }
+            }
+            else if (sourceItem.key === TAGS_METADATA_KEY) {
+                const mergedTags = Array.from(new Set([
+                    ...this.metadataToStringArray(targetItem.value),
+                    ...this.metadataToStringArray(sourceItem.value),
+                ]));
+                await tx.person_metadata.update({
+                    where: { id: targetItem.id },
+                    data: {
+                        value: mergedTags,
+                    },
+                });
+            }
+            else if (sourceItem.key === INTERACTIONS_METADATA_KEY) {
+                const mergedInteractions = this.sortInteractions([
+                    ...this.metadataToInteractions(targetItem.value),
+                    ...this.metadataToInteractions(sourceItem.value),
+                ]);
+                await tx.person_metadata.update({
+                    where: { id: targetItem.id },
+                    data: {
+                        value: mergedInteractions,
+                    },
+                });
+            }
+            await tx.person_metadata.delete({ where: { id: sourceItem.id } });
+        }
+    }
+    buildContactDedupKey(contactTypeId, value) {
+        return `${contactTypeId}::${this.normalizeText(value).toLowerCase()}`;
+    }
+    buildDocumentDedupKey(documentTypeId, value) {
+        const normalizedDigits = this.normalizeDigits(value || '');
+        const normalizedValue = normalizedDigits || this.normalizeText(value).toLowerCase();
+        return `${documentTypeId}::${normalizedValue}`;
+    }
+    buildAddressDedupKey(address) {
+        const parts = [
+            this.normalizeText(address.line1 || ''),
+            this.normalizeText(address.line2 || ''),
+            this.normalizeText(address.city || ''),
+            this.normalizeText(address.state || ''),
+            this.normalizeText(address.country_code || ''),
+            this.normalizeDigits(address.postal_code || ''),
+        ];
+        return parts.join('::').toLowerCase();
+    }
+    normalizeEmail(value) {
+        return this.normalizeText(value || '').toLowerCase();
+    }
+    normalizeText(value) {
+        return String(value || '').trim();
+    }
     validateSinglePrimaryPerType(items, groupKey, locale, localeKey, fallbackMessage) {
         const map = new Map();
         for (const item of items) {
@@ -736,10 +1401,66 @@ let PersonService = class PersonService {
         const trimmed = value.trim();
         return trimmed.length > 0 ? trimmed : null;
     }
+    normalizeDateTimeOrNull(value) {
+        if (!value)
+            return null;
+        const date = value instanceof Date ? value : new Date(String(value));
+        return Number.isNaN(date.getTime()) ? null : date.toISOString();
+    }
     coerceNumber(value) {
         const parsed = Number(value);
         return Number.isFinite(parsed) ? parsed : 0;
     }
+    resolveRequestedOwnerUserId(ownerUserId, mine, currentUserId) {
+        if (mine === true ||
+            mine === 'true' ||
+            mine === '1') {
+            return Number(currentUserId) > 0 ? Number(currentUserId) : 0;
+        }
+        return this.coerceNumber(ownerUserId);
+    }
+    async ensurePersonAccessible(id, locale) {
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const person = await this.prismaService.person.findUnique({
+            where: { id },
+            select: {
+                id: true,
+                type: true,
+            },
+        });
+        if (!person) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${id} not found`));
+        }
+        if (!allowCompanyRegistration && person.type === 'company') {
+            throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${id} not found`));
+        }
+        return person;
+    }
+    async loadInteractionsFromTx(tx, personId) {
+        const metadata = await tx.person_metadata.findFirst({
+            where: {
+                person_id: personId,
+                key: INTERACTIONS_METADATA_KEY,
+            },
+            select: {
+                value: true,
+            },
+        });
+        return this.metadataToInteractions(metadata === null || metadata === void 0 ? void 0 : metadata.value);
+    }
+    buildInteractionRecord(data, user) {
+        return {
+            id: Date.now() + Math.floor(Math.random() * 1000),
+            type: data.type,
+            notes: this.normalizeTextOrNull(data.notes),
+            created_at: new Date().toISOString(),
+            user_id: Number(user === null || user === void 0 ? void 0 : user.id) > 0 ? Number(user.id) : null,
+            user_name: this.normalizeTextOrNull(user === null || user === void 0 ? void 0 : user.name) || null,
+        };
+    }
+    sortInteractions(interactions) {
+        return [...interactions].sort((left, right) => new Date(right.created_at).getTime() - new Date(left.created_at).getTime());
+    }
     async buildSearchFilters(search) {
         const normalizedDigits = this.normalizeDigits(search);
         const filters = [];