@hed-hog/contact 0.0.294 → 0.0.295

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 account_dto_1 = require("./dto/account.dto");
 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';
@@ -38,6 +39,23 @@ 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';
+const CRM_DASHBOARD_STAGE_ORDER = [
+    'new',
+    'contacted',
+    'qualified',
+    'proposal',
+    'negotiation',
+    'customer',
+    'lost',
+];
+const CRM_DASHBOARD_SOURCE_ORDER = [
+    'website',
+    'referral',
+    'social',
+    'inbound',
+    'outbound',
+    'other',
+];
 let PersonService = class PersonService {
     constructor(prismaService, paginationService, fileService, settingService) {
         this.prismaService = prismaService;
@@ -80,6 +98,105 @@ let PersonService = class PersonService {
             inactive,
         };
     }
+    async getDashboard(query, locale) {
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const ownerUserId = this.coerceNumber(query.owner_user_id);
+        const ranges = this.resolveDashboardRanges(query, locale);
+        const where = {};
+        if (!allowCompanyRegistration) {
+            where.type = 'individual';
+        }
+        if (ownerUserId > 0) {
+            where.AND = [
+                {
+                    person_metadata: {
+                        some: {
+                            key: OWNER_USER_METADATA_KEY,
+                            value: ownerUserId,
+                        },
+                    },
+                },
+            ];
+        }
+        const people = await this.prismaService.person.findMany({
+            where,
+            select: {
+                id: true,
+                name: true,
+                type: true,
+                status: true,
+                avatar_id: true,
+                created_at: true,
+                updated_at: true,
+                person_metadata: true,
+            },
+            orderBy: {
+                created_at: 'desc',
+            },
+        });
+        const enriched = await this.enrichPeople(people, allowCompanyRegistration);
+        const createdScoped = enriched.filter((person) => this.isDateWithinRange(person.created_at, ranges.created));
+        const nextActionScoped = enriched.filter((person) => !!person.next_action_at &&
+            this.isDateWithinRange(person.next_action_at, ranges.operational));
+        const kpis = {
+            total_leads: createdScoped.length,
+            qualified: createdScoped.filter((person) => {
+                var _a;
+                return ['qualified', 'proposal', 'negotiation', 'customer'].includes((_a = person.lifecycle_stage) !== null && _a !== void 0 ? _a : 'new');
+            }).length,
+            proposal: createdScoped.filter((person) => person.lifecycle_stage === 'proposal').length,
+            customers: createdScoped.filter((person) => person.lifecycle_stage === 'customer').length,
+            lost: createdScoped.filter((person) => person.lifecycle_stage === 'lost')
+                .length,
+            unassigned: createdScoped.filter((person) => !person.owner_user_id).length,
+            overdue: nextActionScoped.filter((person) => {
+                const nextActionAt = this.parseDateOrNull(person.next_action_at);
+                return !!nextActionAt && nextActionAt.getTime() < Date.now();
+            }).length,
+            next_actions: nextActionScoped.length,
+        };
+        const charts = {
+            stage: CRM_DASHBOARD_STAGE_ORDER.map((key) => ({
+                key,
+                total: createdScoped.filter((person) => { var _a; return ((_a = person.lifecycle_stage) !== null && _a !== void 0 ? _a : 'new') === key; }).length,
+            })),
+            source: CRM_DASHBOARD_SOURCE_ORDER.map((key) => ({
+                key,
+                total: createdScoped.filter((person) => { var _a; return ((_a = person.source) !== null && _a !== void 0 ? _a : 'other') === key; }).length,
+            })),
+            owner_performance: this.buildDashboardOwnerPerformance(createdScoped),
+        };
+        const lists = {
+            next_actions: [...nextActionScoped]
+                .sort((left, right) => {
+                var _a, _b;
+                return new Date((_a = left.next_action_at) !== null && _a !== void 0 ? _a : 0).getTime() -
+                    new Date((_b = right.next_action_at) !== null && _b !== void 0 ? _b : 0).getTime();
+            })
+                .slice(0, 5)
+                .map((person) => this.mapDashboardListItem(person, {
+                includeCreatedAt: false,
+                includeNextActionAt: true,
+            })),
+            unattended: [...createdScoped]
+                .filter((person) => { var _a; return !person.owner_user_id || ((_a = person.lifecycle_stage) !== null && _a !== void 0 ? _a : 'new') === 'new'; })
+                .sort((left, right) => {
+                var _a, _b;
+                return new Date((_a = right.created_at) !== null && _a !== void 0 ? _a : 0).getTime() -
+                    new Date((_b = left.created_at) !== null && _b !== void 0 ? _b : 0).getTime();
+            })
+                .slice(0, 5)
+                .map((person) => this.mapDashboardListItem(person, {
+                includeCreatedAt: true,
+                includeNextActionAt: false,
+            })),
+        };
+        return {
+            kpis,
+            charts,
+            lists,
+        };
+    }
     async getOwnerOptions(currentUserId) {
         const where = {
             OR: [
@@ -347,6 +464,517 @@ let PersonService = class PersonService {
         const enriched = await this.enrichPeople(result.data, allowCompanyRegistration);
         return Object.assign(Object.assign({}, result), { data: enriched });
     }
+    async listAccounts(paginationParams) {
+        var _a;
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const page = Math.max(Number(paginationParams.page || 1), 1);
+        const pageSize = Math.max(Number(paginationParams.pageSize || 12), 1);
+        const skip = (page - 1) * pageSize;
+        if (!allowCompanyRegistration) {
+            return this.createEmptyAccountPagination(page, pageSize);
+        }
+        const search = this.normalizeTextOrNull(paginationParams.search);
+        const filters = this.buildAccountSqlFilters({
+            search,
+            status: paginationParams.status,
+            lifecycleStage: paginationParams.lifecycle_stage,
+        });
+        const orderBy = this.getAccountOrderBySql(paginationParams.sortField, paginationParams.sortOrder);
+        const totalRows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT COUNT(*) AS total
+        FROM person p
+        INNER JOIN person_company pc ON pc.id = p.id
+        WHERE p.type = 'company'
+        ${filters}
+      `);
+        const total = this.coerceCount((_a = totalRows[0]) === null || _a === void 0 ? void 0 : _a.total);
+        if (total === 0) {
+            return this.createEmptyAccountPagination(page, pageSize);
+        }
+        const rows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT p.id AS person_id
+        FROM person p
+        INNER JOIN person_company pc ON pc.id = p.id
+        WHERE p.type = 'company'
+        ${filters}
+        ORDER BY ${orderBy}, p.id ASC
+        LIMIT ${pageSize}
+        OFFSET ${skip}
+      `);
+        const personIds = rows.map((row) => row.person_id).filter((id) => id > 0);
+        if (personIds.length === 0) {
+            return this.createEmptyAccountPagination(page, pageSize);
+        }
+        const people = await this.loadAccountPeopleByIds(personIds);
+        const companies = await this.prismaService.person_company.findMany({
+            where: {
+                id: {
+                    in: personIds,
+                },
+            },
+        });
+        const personById = new Map(people.map((item) => [item.id, item]));
+        const companyById = new Map(companies.map((item) => [item.id, item]));
+        const data = rows
+            .map((row) => {
+            const person = personById.get(row.person_id);
+            const company = companyById.get(row.person_id);
+            if (!person || !company) {
+                return null;
+            }
+            return this.mapAccountFromPerson(person, company);
+        })
+            .filter((item) => item != null);
+        const lastPage = Math.max(1, Math.ceil(total / pageSize));
+        return {
+            total,
+            lastPage,
+            page,
+            pageSize,
+            prev: page > 1 ? page - 1 : null,
+            next: page < lastPage ? page + 1 : null,
+            data,
+        };
+    }
+    async getAccountStats() {
+        var _a, _b, _c, _d;
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        if (!allowCompanyRegistration) {
+            return {
+                total: 0,
+                active: 0,
+                customers: 0,
+                prospects: 0,
+            };
+        }
+        const rows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT
+          COUNT(*) AS total,
+          COUNT(*) FILTER (WHERE p.status = 'active') AS active,
+          COUNT(*) FILTER (WHERE pc.account_lifecycle_stage = 'customer') AS customers,
+          COUNT(*) FILTER (WHERE pc.account_lifecycle_stage = 'prospect') AS prospects
+        FROM person p
+        INNER JOIN person_company pc ON pc.id = p.id
+        WHERE p.type = 'company'
+      `);
+        return {
+            total: this.coerceCount((_a = rows[0]) === null || _a === void 0 ? void 0 : _a.total),
+            active: this.coerceCount((_b = rows[0]) === null || _b === void 0 ? void 0 : _b.active),
+            customers: this.coerceCount((_c = rows[0]) === null || _c === void 0 ? void 0 : _c.customers),
+            prospects: this.coerceCount((_d = rows[0]) === null || _d === void 0 ? void 0 : _d.prospects),
+        };
+    }
+    async createAccount(data, locale) {
+        await this.ensureCompanyRegistrationAllowed({
+            nextType: 'company',
+            locale,
+        });
+        const normalizedName = this.normalizeTextOrNull(data.name);
+        if (!normalizedName) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.nameMustBeString', locale, 'Name is required.'));
+        }
+        return this.prismaService.$transaction(async (tx) => {
+            const person = await tx.person.create({
+                data: {
+                    name: normalizedName,
+                    type: 'company',
+                    status: data.status,
+                },
+            });
+            await this.syncPersonSubtypeData(tx, person.id, null, Object.assign(Object.assign({}, data), { type: 'company', name: normalizedName }), locale);
+            await this.syncPersonMetadata(tx, person.id, {
+                owner_user_id: data.owner_user_id,
+            });
+            await this.upsertPrimaryAccountContact(tx, person.id, 'EMAIL', data.email);
+            await this.upsertPrimaryAccountContact(tx, person.id, 'PHONE', data.phone);
+            return {
+                success: true,
+                id: person.id,
+            };
+        });
+    }
+    async updateAccount(id, data, locale) {
+        var _a;
+        await this.ensureCompanyRegistrationAllowed({
+            currentType: 'company',
+            nextType: 'company',
+            locale,
+        });
+        const person = await this.ensureCompanyAccountAccessible(id, locale);
+        const nextName = (_a = this.normalizeTextOrNull(data.name)) !== null && _a !== void 0 ? _a : person.name;
+        return this.prismaService.$transaction(async (tx) => {
+            var _a;
+            await tx.person.update({
+                where: { id },
+                data: {
+                    name: nextName,
+                    type: 'company',
+                    status: (_a = data.status) !== null && _a !== void 0 ? _a : person.status,
+                },
+            });
+            await this.syncPersonSubtypeData(tx, id, 'company', Object.assign(Object.assign({}, data), { type: 'company', name: nextName }), locale);
+            await this.syncPersonMetadata(tx, id, {
+                owner_user_id: data.owner_user_id,
+            });
+            await this.upsertPrimaryAccountContact(tx, id, 'EMAIL', data.email);
+            await this.upsertPrimaryAccountContact(tx, id, 'PHONE', data.phone);
+            return {
+                success: true,
+                id,
+            };
+        });
+    }
+    async deleteAccounts({ ids }, locale) {
+        if (ids == undefined || ids == null) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('deleteItemsRequired', locale, 'You must select at least one item to delete.'));
+        }
+        const companies = await this.prismaService.person.findMany({
+            where: {
+                id: {
+                    in: ids,
+                },
+            },
+            select: {
+                id: true,
+                type: true,
+            },
+        });
+        const existingIds = companies.map((item) => item.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 invalidIds = companies
+            .filter((item) => item.type !== 'company')
+            .map((item) => item.id);
+        if (invalidIds.length > 0) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('companyRelationInvalidTarget', locale, 'Only company records can be managed as accounts.'));
+        }
+        return this.delete({ ids }, locale);
+    }
+    async listActivities(paginationParams) {
+        var _a;
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const page = Math.max(Number(paginationParams.page || 1), 1);
+        const pageSize = Math.max(Number(paginationParams.pageSize || 12), 1);
+        const skip = (page - 1) * pageSize;
+        const filters = this.buildCrmActivitySqlFilters({
+            allowCompanyRegistration,
+            search: this.normalizeTextOrNull(paginationParams.search),
+            status: paginationParams.status,
+            type: paginationParams.type,
+            priority: paginationParams.priority,
+        });
+        const totalRows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT COUNT(*) AS total
+        FROM crm_activity a
+        INNER JOIN person p ON p.id = a.person_id
+        LEFT JOIN "user" owner_user ON owner_user.id = a.owner_user_id
+        WHERE 1 = 1
+        ${filters}
+      `);
+        const total = this.coerceCount((_a = totalRows[0]) === null || _a === void 0 ? void 0 : _a.total);
+        if (total === 0) {
+            return this.createEmptyCrmActivityPagination(page, pageSize);
+        }
+        const rows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT
+          a.id,
+          a.person_id,
+          a.owner_user_id,
+          a.type,
+          a.subject,
+          a.notes,
+          a.due_at,
+          a.completed_at,
+          a.created_at,
+          a.priority,
+          p.name AS person_name,
+          p.type AS person_type,
+          p.status AS person_status,
+          pc.trade_name AS person_trade_name,
+          owner_user.name AS owner_user_name
+        FROM crm_activity a
+        INNER JOIN person p ON p.id = a.person_id
+        LEFT JOIN person_company pc ON pc.id = p.id
+        LEFT JOIN "user" owner_user ON owner_user.id = a.owner_user_id
+        WHERE 1 = 1
+        ${filters}
+        ORDER BY a.due_at ASC, a.id ASC
+        LIMIT ${pageSize}
+        OFFSET ${skip}
+      `);
+        const data = rows.map((row) => this.mapCrmActivityListRow(row));
+        const lastPage = Math.max(1, Math.ceil(total / pageSize));
+        return {
+            total,
+            lastPage,
+            page,
+            pageSize,
+            prev: page > 1 ? page - 1 : null,
+            next: page < lastPage ? page + 1 : null,
+            data,
+        };
+    }
+    async getActivityStats() {
+        var _a, _b, _c, _d;
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const visibilityFilter = allowCompanyRegistration
+            ? api_prisma_1.Prisma.empty
+            : api_prisma_1.Prisma.sql `AND p.type = 'individual'`;
+        const rows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT
+          COUNT(*) AS total,
+          COUNT(*) FILTER (
+            WHERE a.completed_at IS NULL
+              AND a.due_at >= NOW()
+          ) AS pending,
+          COUNT(*) FILTER (
+            WHERE a.completed_at IS NULL
+              AND a.due_at < NOW()
+          ) AS overdue,
+          COUNT(*) FILTER (
+            WHERE a.completed_at IS NOT NULL
+          ) AS completed
+        FROM crm_activity a
+        INNER JOIN person p ON p.id = a.person_id
+        WHERE 1 = 1
+        ${visibilityFilter}
+      `);
+        return {
+            total: this.coerceCount((_a = rows[0]) === null || _a === void 0 ? void 0 : _a.total),
+            pending: this.coerceCount((_b = rows[0]) === null || _b === void 0 ? void 0 : _b.pending),
+            overdue: this.coerceCount((_c = rows[0]) === null || _c === void 0 ? void 0 : _c.overdue),
+            completed: this.coerceCount((_d = rows[0]) === null || _d === void 0 ? void 0 : _d.completed),
+        };
+    }
+    async getActivity(id, locale) {
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const visibilityFilter = allowCompanyRegistration
+            ? api_prisma_1.Prisma.empty
+            : api_prisma_1.Prisma.sql `AND p.type = 'individual'`;
+        const rows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT
+          a.id,
+          a.person_id,
+          a.owner_user_id,
+          a.created_by_user_id,
+          a.completed_by_user_id,
+          a.type,
+          a.subject,
+          a.notes,
+          a.due_at,
+          a.completed_at,
+          a.created_at,
+          a.priority,
+          a.source_kind,
+          p.name AS person_name,
+          p.type AS person_type,
+          p.status AS person_status,
+          pc.trade_name AS person_trade_name,
+          owner_user.name AS owner_user_name,
+          created_by_user.name AS created_by_user_name,
+          completed_by_user.name AS completed_by_user_name
+        FROM crm_activity a
+        INNER JOIN person p ON p.id = a.person_id
+        LEFT JOIN person_company pc ON pc.id = p.id
+        LEFT JOIN "user" owner_user ON owner_user.id = a.owner_user_id
+        LEFT JOIN "user" created_by_user ON created_by_user.id = a.created_by_user_id
+        LEFT JOIN "user" completed_by_user ON completed_by_user.id = a.completed_by_user_id
+        WHERE a.id = ${id}
+        ${visibilityFilter}
+        LIMIT 1
+      `);
+        const row = rows[0];
+        if (!row) {
+            throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Activity with ID ${id} not found`));
+        }
+        return this.mapCrmActivityDetailRow(row);
+    }
+    async completeActivity(id, locale, user) {
+        const actorUserId = Number((user === null || user === void 0 ? void 0 : user.id) || 0) || null;
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const visibilityFilter = allowCompanyRegistration
+            ? api_prisma_1.Prisma.empty
+            : api_prisma_1.Prisma.sql `AND p.type = 'individual'`;
+        return this.prismaService.$transaction(async (tx) => {
+            const rows = (await tx.$queryRaw(api_prisma_1.Prisma.sql `
+          SELECT
+            a.id,
+            a.person_id,
+            a.completed_at,
+            a.source_kind
+          FROM crm_activity a
+          INNER JOIN person p ON p.id = a.person_id
+          WHERE a.id = ${id}
+          ${visibilityFilter}
+          LIMIT 1
+        `));
+            const activity = rows[0];
+            if (!activity) {
+                throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Activity with ID ${id} not found`));
+            }
+            if (activity.completed_at) {
+                return {
+                    success: true,
+                    completed_at: activity.completed_at.toISOString(),
+                };
+            }
+            const completedAt = new Date();
+            await tx.$executeRaw(api_prisma_1.Prisma.sql `
+          UPDATE crm_activity
+          SET
+            completed_at = CAST(${completedAt.toISOString()} AS TIMESTAMPTZ),
+            completed_by_user_id = ${actorUserId},
+            updated_at = NOW()
+          WHERE id = ${id}
+        `);
+            if (activity.source_kind === 'followup') {
+                await this.upsertMetadataValue(tx, activity.person_id, NEXT_ACTION_AT_METADATA_KEY, null);
+            }
+            return {
+                success: true,
+                completed_at: completedAt.toISOString(),
+            };
+        });
+    }
+    async listFollowups(paginationParams, _currentUserId) {
+        var _a;
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const page = Math.max(Number(paginationParams.page || 1), 1);
+        const pageSize = Math.max(Number(paginationParams.pageSize || 12), 1);
+        const skip = (page - 1) * pageSize;
+        const searchPersonIds = await this.findFollowupSearchPersonIds(paginationParams.search, allowCompanyRegistration);
+        if (searchPersonIds && searchPersonIds.length === 0) {
+            return this.createEmptyFollowupPagination(page, pageSize);
+        }
+        const filters = this.buildFollowupSqlFilters({
+            allowCompanyRegistration,
+            searchPersonIds,
+            status: paginationParams.status,
+            dateFrom: paginationParams.date_from,
+            dateTo: paginationParams.date_to,
+        });
+        const followupTimestampSql = this.getFollowupTimestampSql();
+        const totalRows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT COUNT(*) AS total
+        FROM person p
+        INNER JOIN person_metadata pm_next
+          ON pm_next.person_id = p.id
+         AND pm_next.key = ${NEXT_ACTION_AT_METADATA_KEY}
+        WHERE 1 = 1
+        ${filters}
+      `);
+        const total = this.coerceCount((_a = totalRows[0]) === null || _a === void 0 ? void 0 : _a.total);
+        if (total === 0) {
+            return this.createEmptyFollowupPagination(page, pageSize);
+        }
+        const rows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT p.id AS person_id
+        FROM person p
+        INNER JOIN person_metadata pm_next
+          ON pm_next.person_id = p.id
+         AND pm_next.key = ${NEXT_ACTION_AT_METADATA_KEY}
+        WHERE 1 = 1
+        ${filters}
+        ORDER BY ${followupTimestampSql} ASC, p.id ASC
+        LIMIT ${pageSize}
+        OFFSET ${skip}
+      `);
+        const personIds = rows.map((row) => row.person_id).filter((id) => id > 0);
+        const people = personIds.length > 0
+            ? await this.prismaService.person.findMany({
+                where: {
+                    id: {
+                        in: personIds,
+                    },
+                },
+                include: {
+                    person_address: {
+                        include: {
+                            address: true,
+                        },
+                    },
+                    contact: true,
+                    document: true,
+                    person_metadata: true,
+                },
+            })
+            : [];
+        const enrichedPeople = await this.enrichPeople(people, allowCompanyRegistration);
+        const personById = new Map(enrichedPeople.map((person) => [person.id, person]));
+        const data = rows
+            .map((row) => {
+            var _a;
+            const person = personById.get(row.person_id);
+            const nextActionAt = this.normalizeDateTimeOrNull(person === null || person === void 0 ? void 0 : person.next_action_at);
+            if (!person || !nextActionAt) {
+                return null;
+            }
+            return {
+                person,
+                next_action_at: nextActionAt,
+                last_interaction_at: (_a = this.normalizeDateTimeOrNull(person.last_interaction_at)) !== null && _a !== void 0 ? _a : null,
+                status: this.getFollowupStatus(nextActionAt),
+            };
+        })
+            .filter((item) => item != null);
+        const lastPage = Math.max(1, Math.ceil(total / pageSize));
+        return {
+            total,
+            lastPage,
+            page,
+            pageSize,
+            prev: page > 1 ? page - 1 : null,
+            next: page < lastPage ? page + 1 : null,
+            data,
+        };
+    }
+    async getFollowupStats(query, _currentUserId) {
+        var _a, _b, _c, _d;
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        const searchPersonIds = await this.findFollowupSearchPersonIds(query.search, allowCompanyRegistration);
+        if (searchPersonIds && searchPersonIds.length === 0) {
+            return {
+                total: 0,
+                today: 0,
+                overdue: 0,
+                upcoming: 0,
+            };
+        }
+        const filters = this.buildFollowupSqlFilters({
+            allowCompanyRegistration,
+            searchPersonIds,
+        });
+        const followupTimestampSql = this.getFollowupTimestampSql();
+        const { todayStartIso, tomorrowStartIso } = this.getFollowupDayBoundaryIsoStrings();
+        const rows = await this.prismaService.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT
+          COUNT(*) AS total,
+          COUNT(*) FILTER (
+            WHERE ${followupTimestampSql} >= CAST(${todayStartIso} AS TIMESTAMPTZ)
+              AND ${followupTimestampSql} < CAST(${tomorrowStartIso} AS TIMESTAMPTZ)
+          ) AS today,
+          COUNT(*) FILTER (
+            WHERE ${followupTimestampSql} < CAST(${todayStartIso} AS TIMESTAMPTZ)
+          ) AS overdue,
+          COUNT(*) FILTER (
+            WHERE ${followupTimestampSql} >= CAST(${tomorrowStartIso} AS TIMESTAMPTZ)
+          ) AS upcoming
+        FROM person p
+        INNER JOIN person_metadata pm_next
+          ON pm_next.person_id = p.id
+         AND pm_next.key = ${NEXT_ACTION_AT_METADATA_KEY}
+        WHERE 1 = 1
+        ${filters}
+      `);
+        return {
+            total: this.coerceCount((_a = rows[0]) === null || _a === void 0 ? void 0 : _a.total),
+            today: this.coerceCount((_b = rows[0]) === null || _b === void 0 ? void 0 : _b.today),
+            overdue: this.coerceCount((_c = rows[0]) === null || _c === void 0 ? void 0 : _c.overdue),
+            upcoming: this.coerceCount((_d = rows[0]) === null || _d === void 0 ? void 0 : _d.upcoming),
+        };
+    }
     async get(locale, id) {
         const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
         const person = await this.prismaService.person.findUnique({
@@ -387,6 +1015,7 @@ let PersonService = class PersonService {
     async createInteraction(id, data, locale, user) {
         const person = await this.ensurePersonAccessible(id, locale);
         const interaction = this.buildInteractionRecord(data, user);
+        const ownerUserId = await this.getPersonOwnerUserId(person.id);
         await this.prismaService.$transaction(async (tx) => {
             const currentInteractions = await this.loadInteractionsFromTx(tx, person.id);
             const nextInteractions = this.sortInteractions([
@@ -395,12 +1024,19 @@ let PersonService = class PersonService {
             ]);
             await this.upsertMetadataValue(tx, person.id, INTERACTIONS_METADATA_KEY, nextInteractions);
             await this.upsertMetadataValue(tx, person.id, LAST_INTERACTION_AT_METADATA_KEY, interaction.created_at);
+            await this.createCompletedInteractionActivity(tx, {
+                personId: person.id,
+                ownerUserId,
+                interaction,
+                actorUserId: Number((user === null || user === void 0 ? void 0 : user.id) || 0) || null,
+            });
         });
         return interaction;
     }
     async scheduleFollowup(id, data, locale, user) {
         const person = await this.ensurePersonAccessible(id, locale);
         const normalizedNextActionAt = this.normalizeDateTimeOrNull(data.next_action_at);
+        const ownerUserId = await this.getPersonOwnerUserId(person.id);
         if (!normalizedNextActionAt) {
             throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.dateMustBeString', locale, 'next_action_at must be a valid datetime.'));
         }
@@ -420,6 +1056,13 @@ let PersonService = class PersonService {
                 await this.upsertMetadataValue(tx, person.id, INTERACTIONS_METADATA_KEY, nextInteractions);
                 await this.upsertMetadataValue(tx, person.id, LAST_INTERACTION_AT_METADATA_KEY, interaction.created_at);
             }
+            await this.upsertFollowupActivity(tx, {
+                personId: person.id,
+                ownerUserId,
+                dueAt: normalizedNextActionAt,
+                notes: data.notes,
+                actorUserId: Number((user === null || user === void 0 ? void 0 : user.id) || 0) || null,
+            });
         });
         return {
             success: true,
@@ -592,6 +1235,118 @@ let PersonService = class PersonService {
             }),
         ]);
     }
+    async findFollowupSearchPersonIds(search, allowCompanyRegistration) {
+        const normalizedSearch = this.normalizeTextOrNull(search);
+        if (!normalizedSearch) {
+            return null;
+        }
+        const where = {
+            OR: await this.buildSearchFilters(normalizedSearch),
+        };
+        if (!allowCompanyRegistration) {
+            where.type = 'individual';
+        }
+        const people = await this.prismaService.person.findMany({
+            where,
+            select: {
+                id: true,
+            },
+        });
+        return people.map((person) => person.id).filter((id) => id > 0);
+    }
+    buildFollowupSqlFilters({ allowCompanyRegistration, searchPersonIds, status, dateFrom, dateTo, }) {
+        const filters = [];
+        const followupTimestampSql = this.getFollowupTimestampSql();
+        if (!allowCompanyRegistration) {
+            filters.push(api_prisma_1.Prisma.sql `AND p.type = 'individual'`);
+        }
+        if (searchPersonIds && searchPersonIds.length > 0) {
+            filters.push(api_prisma_1.Prisma.sql `AND p.id IN (${api_prisma_1.Prisma.join(searchPersonIds)})`);
+        }
+        const { todayStartIso, tomorrowStartIso } = this.getFollowupDayBoundaryIsoStrings();
+        if (status === 'overdue') {
+            filters.push(api_prisma_1.Prisma.sql `AND ${followupTimestampSql} < CAST(${todayStartIso} AS TIMESTAMPTZ)`);
+        }
+        else if (status === 'today') {
+            filters.push(api_prisma_1.Prisma.sql `AND ${followupTimestampSql} >= CAST(${todayStartIso} AS TIMESTAMPTZ)`);
+            filters.push(api_prisma_1.Prisma.sql `AND ${followupTimestampSql} < CAST(${tomorrowStartIso} AS TIMESTAMPTZ)`);
+        }
+        else if (status === 'upcoming') {
+            filters.push(api_prisma_1.Prisma.sql `AND ${followupTimestampSql} >= CAST(${tomorrowStartIso} AS TIMESTAMPTZ)`);
+        }
+        const dateFromIso = this.normalizeDateOnlyBoundary(dateFrom, 'start');
+        if (dateFromIso) {
+            filters.push(api_prisma_1.Prisma.sql `AND ${followupTimestampSql} >= CAST(${dateFromIso} AS TIMESTAMPTZ)`);
+        }
+        const dateToIso = this.normalizeDateOnlyBoundary(dateTo, 'endExclusive');
+        if (dateToIso) {
+            filters.push(api_prisma_1.Prisma.sql `AND ${followupTimestampSql} < CAST(${dateToIso} AS TIMESTAMPTZ)`);
+        }
+        return filters.length > 0
+            ? api_prisma_1.Prisma.join(filters, '\n')
+            : api_prisma_1.Prisma.empty;
+    }
+    createEmptyFollowupPagination(page, pageSize) {
+        return {
+            total: 0,
+            lastPage: 1,
+            page,
+            pageSize,
+            prev: page > 1 ? page - 1 : null,
+            next: null,
+            data: [],
+        };
+    }
+    getFollowupTimestampSql() {
+        return api_prisma_1.Prisma.sql `CAST(TRIM(BOTH '"' FROM pm_next.value::text) AS TIMESTAMPTZ)`;
+    }
+    getFollowupDayBoundaryDates(reference = new Date()) {
+        const todayStart = new Date(reference.getFullYear(), reference.getMonth(), reference.getDate());
+        const tomorrowStart = new Date(todayStart);
+        tomorrowStart.setDate(tomorrowStart.getDate() + 1);
+        return {
+            todayStart,
+            tomorrowStart,
+        };
+    }
+    getFollowupDayBoundaryIsoStrings(reference = new Date()) {
+        const { todayStart, tomorrowStart } = this.getFollowupDayBoundaryDates(reference);
+        return {
+            todayStartIso: todayStart.toISOString(),
+            tomorrowStartIso: tomorrowStart.toISOString(),
+        };
+    }
+    normalizeDateOnlyBoundary(value, mode) {
+        if (!value) {
+            return null;
+        }
+        const parsed = new Date(`${value}T00:00:00`);
+        if (Number.isNaN(parsed.getTime())) {
+            return null;
+        }
+        if (mode === 'endExclusive') {
+            parsed.setDate(parsed.getDate() + 1);
+        }
+        return parsed.toISOString();
+    }
+    getFollowupStatus(nextActionAt) {
+        const parsed = new Date(nextActionAt);
+        const { todayStart, tomorrowStart } = this.getFollowupDayBoundaryDates();
+        if (parsed < todayStart) {
+            return 'overdue';
+        }
+        if (parsed < tomorrowStart) {
+            return 'today';
+        }
+        return 'upcoming';
+    }
+    coerceCount(value) {
+        if (typeof value === 'bigint') {
+            return Number(value);
+        }
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
     async openPublicAvatar(locale, fileId, res) {
         const personWithAvatar = await this.prismaService.person.findFirst({
             where: {
@@ -612,6 +1367,110 @@ let PersonService = class PersonService {
         });
         res.send(buffer);
     }
+    resolveDashboardRanges(query, locale) {
+        var _a;
+        const period = (_a = query.period) !== null && _a !== void 0 ? _a : '30d';
+        const now = new Date();
+        if (period === 'custom') {
+            if (!query.date_from || !query.date_to) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.dateMustBeString', locale, 'date_from and date_to are required when period is custom.'));
+            }
+            const start = this.startOfDay(this.parseDateOrThrow(query.date_from, locale));
+            const end = this.endOfDay(this.parseDateOrThrow(query.date_to, locale));
+            if (start.getTime() > end.getTime()) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.dateMustBeString', locale, 'date_from must be less than or equal to date_to.'));
+            }
+            return {
+                created: { start, end },
+                operational: { start, end },
+            };
+        }
+        const dayCount = Number(period.replace('d', ''));
+        const createdStart = this.startOfDay(this.addDays(now, -(dayCount - 1)));
+        const createdEnd = this.endOfDay(now);
+        const operationalStart = this.startOfDay(this.addDays(now, -(dayCount - 1)));
+        const operationalEnd = this.endOfDay(this.addDays(now, dayCount - 1));
+        return {
+            created: {
+                start: createdStart,
+                end: createdEnd,
+            },
+            operational: {
+                start: operationalStart,
+                end: operationalEnd,
+            },
+        };
+    }
+    buildDashboardOwnerPerformance(people) {
+        var _a, _b;
+        const byOwnerId = new Map();
+        for (const person of people) {
+            const ownerUserId = this.coerceNumber(person.owner_user_id);
+            if (ownerUserId <= 0) {
+                continue;
+            }
+            const current = (_a = byOwnerId.get(ownerUserId)) !== null && _a !== void 0 ? _a : {
+                owner_user_id: ownerUserId,
+                owner_name: ((_b = person.owner_user) === null || _b === void 0 ? void 0 : _b.name) || `#${ownerUserId}`,
+                leads: 0,
+                customers: 0,
+                pipeline_value: 0,
+            };
+            current.leads += 1;
+            if (person.lifecycle_stage === 'customer') {
+                current.customers += 1;
+            }
+            if (person.lifecycle_stage !== 'lost') {
+                current.pipeline_value += this.coerceNumber(person.deal_value);
+            }
+            byOwnerId.set(ownerUserId, current);
+        }
+        return Array.from(byOwnerId.values()).sort((left, right) => left.owner_name.localeCompare(right.owner_name));
+    }
+    mapDashboardListItem(person, { includeCreatedAt, includeNextActionAt, }) {
+        var _a, _b, _c, _d, _e;
+        const source = ((_a = person.source) !== null && _a !== void 0 ? _a : 'other');
+        const lifecycleStage = ((_b = person.lifecycle_stage) !== null && _b !== void 0 ? _b : 'new');
+        return Object.assign(Object.assign({ id: person.id, name: person.name, trade_name: (_c = person.trade_name) !== null && _c !== void 0 ? _c : null, owner_user: (_d = person.owner_user) !== null && _d !== void 0 ? _d : null, source, lifecycle_stage: lifecycleStage }, (includeNextActionAt && person.next_action_at
+            ? { next_action_at: person.next_action_at }
+            : {})), (includeCreatedAt && person.created_at
+            ? {
+                created_at: (_e = this.normalizeDateTimeOrNull(person.created_at)) !== null && _e !== void 0 ? _e : person.created_at,
+            }
+            : {}));
+    }
+    isDateWithinRange(value, range) {
+        const parsed = this.parseDateOrNull(value);
+        if (!parsed) {
+            return false;
+        }
+        return (parsed.getTime() >= range.start.getTime() &&
+            parsed.getTime() <= range.end.getTime());
+    }
+    parseDateOrThrow(value, locale) {
+        const parsed = /^\d{4}-\d{2}-\d{2}$/.test(value)
+            ? this.parseDateOrNull(`${value}T00:00:00`)
+            : this.parseDateOrNull(value);
+        if (!parsed) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.dateMustBeString', locale, `Invalid date value: ${value}`));
+        }
+        return parsed;
+    }
+    addDays(date, amount) {
+        const next = new Date(date);
+        next.setDate(next.getDate() + amount);
+        return next;
+    }
+    startOfDay(date) {
+        const next = new Date(date);
+        next.setHours(0, 0, 0, 0);
+        return next;
+    }
+    endOfDay(date) {
+        const next = new Date(date);
+        next.setHours(23, 59, 59, 999);
+        return next;
+    }
     async enrichPeople(people, allowCompanyRegistration = true) {
         if (people.length === 0) {
             return [];
@@ -917,6 +1776,13 @@ let PersonService = class PersonService {
             create: {
                 id: personId,
                 trade_name: this.normalizeTextOrNull(data.trade_name),
+                industry: this.normalizeTextOrNull(data.industry),
+                website: this.normalizeTextOrNull(data.website),
+                annual_revenue: this.normalizeDecimalOrNull(data.annual_revenue),
+                employee_count: this.normalizeIntegerOrNull(data.employee_count),
+                account_lifecycle_stage: this.normalizeAccountLifecycleStage(data.lifecycle_stage),
+                city: this.normalizeTextOrNull(data.city),
+                state: this.normalizeStateOrNull(data.state),
                 foundation_date: this.parseDateOrNull(data.foundation_date),
                 legal_nature: this.normalizeTextOrNull(data.legal_nature),
                 headquarter_id: normalizedHeadquarterId > 0 ? normalizedHeadquarterId : null,
@@ -925,6 +1791,27 @@ let PersonService = class PersonService {
                 trade_name: data.trade_name === undefined
                     ? undefined
                     : this.normalizeTextOrNull(data.trade_name),
+                industry: data.industry === undefined
+                    ? undefined
+                    : this.normalizeTextOrNull(data.industry),
+                website: data.website === undefined
+                    ? undefined
+                    : this.normalizeTextOrNull(data.website),
+                annual_revenue: data.annual_revenue === undefined
+                    ? undefined
+                    : this.normalizeDecimalOrNull(data.annual_revenue),
+                employee_count: data.employee_count === undefined
+                    ? undefined
+                    : this.normalizeIntegerOrNull(data.employee_count),
+                account_lifecycle_stage: data.lifecycle_stage === undefined
+                    ? undefined
+                    : this.normalizeAccountLifecycleStage(data.lifecycle_stage),
+                city: data.city === undefined
+                    ? undefined
+                    : this.normalizeTextOrNull(data.city),
+                state: data.state === undefined
+                    ? undefined
+                    : this.normalizeStateOrNull(data.state),
                 foundation_date: data.foundation_date === undefined
                     ? undefined
                     : this.parseDateOrNull(data.foundation_date),
@@ -1394,6 +2281,20 @@ let PersonService = class PersonService {
         const date = value instanceof Date ? value : new Date(String(value));
         return Number.isNaN(date.getTime()) ? null : date;
     }
+    normalizeDecimalOrNull(value) {
+        if (value == null || value === '') {
+            return null;
+        }
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? new api_prisma_1.Prisma.Decimal(parsed) : null;
+    }
+    normalizeIntegerOrNull(value) {
+        if (value == null || value === '') {
+            return null;
+        }
+        const parsed = Number(value);
+        return Number.isInteger(parsed) ? parsed : null;
+    }
     normalizeTextOrNull(value) {
         if (typeof value !== 'string') {
             return value == null ? null : String(value);
@@ -1411,6 +2312,20 @@ let PersonService = class PersonService {
         const parsed = Number(value);
         return Number.isFinite(parsed) ? parsed : 0;
     }
+    normalizeStateOrNull(value) {
+        var _a, _b;
+        const normalized = (_b = (_a = this.normalizeTextOrNull(value)) === null || _a === void 0 ? void 0 : _a.toUpperCase()) !== null && _b !== void 0 ? _b : null;
+        return normalized ? normalized.slice(0, 2) : null;
+    }
+    normalizeAccountLifecycleStage(value) {
+        const normalized = this.normalizeTextOrNull(value);
+        if (!normalized) {
+            return null;
+        }
+        return account_dto_1.ACCOUNT_LIFECYCLE_STAGES.includes(normalized)
+            ? normalized
+            : null;
+    }
     resolveRequestedOwnerUserId(ownerUserId, mine, currentUserId) {
         if (mine === true ||
             mine === 'true' ||
@@ -1436,6 +2351,288 @@ let PersonService = class PersonService {
         }
         return person;
     }
+    async getPersonOwnerUserId(personId) {
+        const metadata = await this.prismaService.person_metadata.findFirst({
+            where: {
+                person_id: personId,
+                key: OWNER_USER_METADATA_KEY,
+            },
+            select: {
+                value: true,
+            },
+        });
+        const ownerUserId = this.metadataToNumber(metadata === null || metadata === void 0 ? void 0 : metadata.value);
+        return ownerUserId && ownerUserId > 0 ? ownerUserId : null;
+    }
+    async upsertFollowupActivity(tx, { personId, ownerUserId, dueAt, notes, actorUserId, }) {
+        const existingRows = (await tx.$queryRaw(api_prisma_1.Prisma.sql `
+        SELECT id
+        FROM crm_activity
+        WHERE person_id = ${personId}
+          AND source_kind = 'followup'
+          AND completed_at IS NULL
+        ORDER BY id DESC
+        LIMIT 1
+      `));
+        const existing = existingRows[0];
+        const normalizedNotes = this.normalizeTextOrNull(notes);
+        if (existing) {
+            await tx.$executeRaw(api_prisma_1.Prisma.sql `
+          UPDATE crm_activity
+          SET
+            owner_user_id = ${ownerUserId},
+            type = CAST(${'task'} AS crm_activity_type_enum),
+            subject = ${this.getFollowupActivitySubject()},
+            notes = ${normalizedNotes},
+            due_at = CAST(${dueAt} AS TIMESTAMPTZ),
+            priority = CAST(${'medium'} AS crm_activity_priority_enum),
+            updated_at = NOW()
+          WHERE id = ${existing.id}
+        `);
+            return;
+        }
+        await tx.$executeRaw(api_prisma_1.Prisma.sql `
+        INSERT INTO crm_activity (
+          person_id,
+          owner_user_id,
+          created_by_user_id,
+          type,
+          subject,
+          notes,
+          due_at,
+          priority,
+          source_kind,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          ${personId},
+          ${ownerUserId},
+          ${actorUserId},
+          CAST(${'task'} AS crm_activity_type_enum),
+          ${this.getFollowupActivitySubject()},
+          ${normalizedNotes},
+          CAST(${dueAt} AS TIMESTAMPTZ),
+          CAST(${'medium'} AS crm_activity_priority_enum),
+          CAST(${'followup'} AS crm_activity_source_kind_enum),
+          NOW(),
+          NOW()
+        )
+      `);
+    }
+    async createCompletedInteractionActivity(tx, { personId, ownerUserId, interaction, actorUserId, }) {
+        const completedAt = new Date(interaction.created_at);
+        await tx.$executeRaw(api_prisma_1.Prisma.sql `
+        INSERT INTO crm_activity (
+          person_id,
+          owner_user_id,
+          created_by_user_id,
+          completed_by_user_id,
+          type,
+          subject,
+          notes,
+          due_at,
+          completed_at,
+          priority,
+          source_kind,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          ${personId},
+          ${ownerUserId},
+          ${actorUserId},
+          ${actorUserId},
+          CAST(${interaction.type} AS crm_activity_type_enum),
+          ${this.getInteractionActivitySubject(interaction.type)},
+          ${this.normalizeTextOrNull(interaction.notes)},
+          CAST(${interaction.created_at} AS TIMESTAMPTZ),
+          CAST(${interaction.created_at} AS TIMESTAMPTZ),
+          CAST(${'medium'} AS crm_activity_priority_enum),
+          CAST(${'interaction'} AS crm_activity_source_kind_enum),
+          CAST(${interaction.created_at} AS TIMESTAMPTZ),
+          NOW()
+        )
+      `);
+    }
+    getFollowupActivitySubject() {
+        return 'Follow-up';
+    }
+    getInteractionActivitySubject(type) {
+        switch (type) {
+            case create_interaction_dto_1.PersonInteractionTypeDTO.CALL:
+                return 'Call';
+            case create_interaction_dto_1.PersonInteractionTypeDTO.EMAIL:
+                return 'Email';
+            case create_interaction_dto_1.PersonInteractionTypeDTO.WHATSAPP:
+                return 'WhatsApp';
+            case create_interaction_dto_1.PersonInteractionTypeDTO.MEETING:
+                return 'Meeting';
+            case create_interaction_dto_1.PersonInteractionTypeDTO.NOTE:
+            default:
+                return 'Note';
+        }
+    }
+    async ensureCompanyAccountAccessible(id, locale) {
+        const allowCompanyRegistration = await this.isCompanyRegistrationAllowed();
+        if (!allowCompanyRegistration) {
+            throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${id} not found`));
+        }
+        const person = await this.prismaService.person.findUnique({
+            where: { id },
+            select: {
+                id: true,
+                name: true,
+                status: true,
+                type: true,
+            },
+        });
+        if (!person || person.type !== 'company') {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, `Person with ID ${id} not found`));
+        }
+        return person;
+    }
+    async loadAccountPeopleByIds(personIds) {
+        if (personIds.length === 0) {
+            return [];
+        }
+        const people = await this.prismaService.person.findMany({
+            where: {
+                id: {
+                    in: personIds,
+                },
+            },
+            include: {
+                contact: {
+                    include: {
+                        contact_type: true,
+                    },
+                },
+                person_metadata: true,
+            },
+        });
+        return this.enrichPeople(people, true);
+    }
+    mapAccountFromPerson(person, company) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        return {
+            id: person.id,
+            name: person.name,
+            trade_name: (_a = company.trade_name) !== null && _a !== void 0 ? _a : null,
+            status: person.status,
+            industry: (_b = company.industry) !== null && _b !== void 0 ? _b : null,
+            website: (_c = company.website) !== null && _c !== void 0 ? _c : null,
+            email: this.getPrimaryAccountContactValue(person.contact, ['EMAIL']),
+            phone: this.getPrimaryAccountContactValue(person.contact, [
+                'PHONE',
+                'MOBILE',
+                'WHATSAPP',
+            ]),
+            owner_user_id: (_d = person.owner_user_id) !== null && _d !== void 0 ? _d : null,
+            owner_user: (_e = person.owner_user) !== null && _e !== void 0 ? _e : null,
+            annual_revenue: company.annual_revenue == null ? null : Number(company.annual_revenue),
+            employee_count: (_f = company.employee_count) !== null && _f !== void 0 ? _f : null,
+            lifecycle_stage: (_g = company.account_lifecycle_stage) !== null && _g !== void 0 ? _g : null,
+            city: (_h = company.city) !== null && _h !== void 0 ? _h : null,
+            state: (_j = company.state) !== null && _j !== void 0 ? _j : null,
+            created_at: (_m = (_l = (_k = person.created_at) === null || _k === void 0 ? void 0 : _k.toISOString) === null || _l === void 0 ? void 0 : _l.call(_k)) !== null && _m !== void 0 ? _m : String(person.created_at),
+            last_interaction_at: (_o = this.normalizeDateTimeOrNull(person.last_interaction_at)) !== null && _o !== void 0 ? _o : null,
+        };
+    }
+    getPrimaryAccountContactValue(contacts, codes) {
+        var _a;
+        const normalizedCodes = new Set(codes.map((code) => code.toUpperCase()));
+        const items = Array.isArray(contacts)
+            ? contacts.filter((contact) => {
+                var _a;
+                return normalizedCodes.has(String(((_a = contact === null || contact === void 0 ? void 0 : contact.contact_type) === null || _a === void 0 ? void 0 : _a.code) || '').toUpperCase());
+            })
+            : [];
+        const primary = items.find((contact) => contact === null || contact === void 0 ? void 0 : contact.is_primary);
+        const fallback = items[0];
+        return this.normalizeTextOrNull((_a = primary === null || primary === void 0 ? void 0 : primary.value) !== null && _a !== void 0 ? _a : fallback === null || fallback === void 0 ? void 0 : fallback.value);
+    }
+    async upsertPrimaryAccountContact(tx, personId, code, value) {
+        const normalizedValue = this.normalizeTextOrNull(value);
+        const allowedCodes = code === 'PHONE' ? ['PHONE', 'MOBILE', 'WHATSAPP'] : ['EMAIL'];
+        const type = await tx.contact_type.findFirst({
+            where: {
+                code: {
+                    equals: code,
+                    mode: 'insensitive',
+                },
+            },
+            select: {
+                id: true,
+            },
+        });
+        if (!type) {
+            return;
+        }
+        const existingContacts = await tx.contact.findMany({
+            where: {
+                person_id: personId,
+                contact_type: {
+                    code: {
+                        in: allowedCodes,
+                    },
+                },
+            },
+            orderBy: [{ is_primary: 'desc' }, { id: 'asc' }],
+            select: {
+                id: true,
+                is_primary: true,
+            },
+        });
+        if (!normalizedValue) {
+            const contactToDelete = existingContacts[0];
+            if (contactToDelete) {
+                await tx.contact.delete({
+                    where: {
+                        id: contactToDelete.id,
+                    },
+                });
+            }
+            return;
+        }
+        const primaryContact = existingContacts[0];
+        if (primaryContact) {
+            await tx.contact.update({
+                where: {
+                    id: primaryContact.id,
+                },
+                data: {
+                    value: normalizedValue,
+                    is_primary: true,
+                    contact_type_id: type.id,
+                },
+            });
+            const secondaryContacts = existingContacts
+                .slice(1)
+                .filter((contact) => contact.is_primary);
+            if (secondaryContacts.length > 0) {
+                await tx.contact.updateMany({
+                    where: {
+                        id: {
+                            in: secondaryContacts.map((contact) => contact.id),
+                        },
+                    },
+                    data: {
+                        is_primary: false,
+                    },
+                });
+            }
+            return;
+        }
+        await tx.contact.create({
+            data: {
+                person_id: personId,
+                contact_type_id: type.id,
+                value: normalizedValue,
+                is_primary: true,
+            },
+        });
+    }
     async loadInteractionsFromTx(tx, personId) {
         const metadata = await tx.person_metadata.findFirst({
             where: {
@@ -1513,6 +2710,176 @@ let PersonService = class PersonService {
         }
         return filters;
     }
+    buildAccountSqlFilters({ search, status, lifecycleStage, }) {
+        const filters = [];
+        if (status && status !== 'all') {
+            filters.push(api_prisma_1.Prisma.sql `AND p.status = ${status}`);
+        }
+        if (lifecycleStage && lifecycleStage !== 'all') {
+            filters.push(api_prisma_1.Prisma.sql `AND pc.account_lifecycle_stage = CAST(${lifecycleStage} AS person_company_account_lifecycle_stage_enum)`);
+        }
+        if (search) {
+            const searchLike = `%${search}%`;
+            const normalizedDigits = this.normalizeDigits(search);
+            const digitsLike = `%${normalizedDigits}%`;
+            filters.push(api_prisma_1.Prisma.sql `
+          AND (
+            p.name ILIKE ${searchLike}
+            OR COALESCE(pc.trade_name, '') ILIKE ${searchLike}
+            OR COALESCE(pc.city, '') ILIKE ${searchLike}
+            OR COALESCE(pc.state, '') ILIKE ${searchLike}
+            OR EXISTS (
+              SELECT 1
+              FROM contact c
+              INNER JOIN contact_type ct ON ct.id = c.contact_type_id
+              WHERE c.person_id = p.id
+                AND UPPER(ct.code) = 'EMAIL'
+                AND c.value ILIKE ${searchLike}
+            )
+            ${normalizedDigits.length > 0
+                ? api_prisma_1.Prisma.sql `
+                    OR EXISTS (
+                      SELECT 1
+                      FROM contact c
+                      INNER JOIN contact_type ct ON ct.id = c.contact_type_id
+                      WHERE c.person_id = p.id
+                        AND UPPER(ct.code) IN ('PHONE', 'MOBILE', 'WHATSAPP')
+                        AND regexp_replace(COALESCE(c.value, ''), '[^0-9]+', '', 'g') ILIKE ${digitsLike}
+                    )
+                  `
+                : api_prisma_1.Prisma.empty}
+          )
+        `);
+        }
+        return filters.length > 0 ? api_prisma_1.Prisma.join(filters, '\n') : api_prisma_1.Prisma.empty;
+    }
+    getAccountOrderBySql(sortField, sortOrder) {
+        const normalizedSortField = sortField === 'created_at' ? 'created_at' : 'name';
+        const normalizedSortOrder = sortOrder === 'desc' ? 'DESC' : 'ASC';
+        if (normalizedSortField === 'created_at') {
+            return normalizedSortOrder === 'DESC'
+                ? api_prisma_1.Prisma.sql `p.created_at DESC`
+                : api_prisma_1.Prisma.sql `p.created_at ASC`;
+        }
+        return normalizedSortOrder === 'DESC'
+            ? api_prisma_1.Prisma.sql `LOWER(p.name) DESC`
+            : api_prisma_1.Prisma.sql `LOWER(p.name) ASC`;
+    }
+    createEmptyAccountPagination(page, pageSize) {
+        return {
+            total: 0,
+            lastPage: 1,
+            page,
+            pageSize,
+            prev: page > 1 ? page - 1 : null,
+            next: null,
+            data: [],
+        };
+    }
+    buildCrmActivitySqlFilters({ allowCompanyRegistration, search, status, type, priority, }) {
+        const filters = [];
+        if (!allowCompanyRegistration) {
+            filters.push(api_prisma_1.Prisma.sql `AND p.type = 'individual'`);
+        }
+        if (status === 'pending') {
+            filters.push(api_prisma_1.Prisma.sql `AND a.completed_at IS NULL AND a.due_at >= NOW()`);
+        }
+        else if (status === 'overdue') {
+            filters.push(api_prisma_1.Prisma.sql `AND a.completed_at IS NULL AND a.due_at < NOW()`);
+        }
+        else if (status === 'completed') {
+            filters.push(api_prisma_1.Prisma.sql `AND a.completed_at IS NOT NULL`);
+        }
+        if (type && type !== 'all') {
+            filters.push(api_prisma_1.Prisma.sql `AND a.type = CAST(${type} AS crm_activity_type_enum)`);
+        }
+        if (priority && priority !== 'all') {
+            filters.push(api_prisma_1.Prisma.sql `AND a.priority = CAST(${priority} AS crm_activity_priority_enum)`);
+        }
+        if (search) {
+            const searchLike = `%${search}%`;
+            filters.push(api_prisma_1.Prisma.sql `
+          AND (
+            a.subject ILIKE ${searchLike}
+            OR COALESCE(a.notes, '') ILIKE ${searchLike}
+            OR p.name ILIKE ${searchLike}
+            OR COALESCE(owner_user.name, '') ILIKE ${searchLike}
+          )
+        `);
+        }
+        return filters.length > 0 ? api_prisma_1.Prisma.join(filters, '\n') : api_prisma_1.Prisma.empty;
+    }
+    createEmptyCrmActivityPagination(page, pageSize) {
+        return {
+            total: 0,
+            lastPage: 1,
+            page,
+            pageSize,
+            prev: page > 1 ? page - 1 : null,
+            next: null,
+            data: [],
+        };
+    }
+    mapCrmActivityListRow(row) {
+        var _a, _b;
+        const completedAt = this.normalizeDateTimeOrNull(row.completed_at);
+        const dueAt = (_a = this.normalizeDateTimeOrNull(row.due_at)) !== null && _a !== void 0 ? _a : new Date().toISOString();
+        const ownerUserId = this.coerceNumber(row.owner_user_id) || null;
+        return {
+            id: this.coerceNumber(row.id),
+            person_id: this.coerceNumber(row.person_id),
+            person: {
+                id: this.coerceNumber(row.person_id),
+                name: this.normalizeTextOrNull(row.person_name) || `#${row.person_id}`,
+                type: this.normalizeTextOrNull(row.person_type) === 'company'
+                    ? 'company'
+                    : 'individual',
+                status: this.normalizeTextOrNull(row.person_status) === 'inactive'
+                    ? 'inactive'
+                    : 'active',
+                trade_name: this.normalizeTextOrNull(row.person_trade_name),
+            },
+            owner_user_id: ownerUserId,
+            owner_user: ownerUserId
+                ? {
+                    id: ownerUserId,
+                    name: this.normalizeTextOrNull(row.owner_user_name) || `#${ownerUserId}`,
+                }
+                : null,
+            type: (this.normalizeTextOrNull(row.type) || 'task'),
+            subject: this.normalizeTextOrNull(row.subject) || 'Activity',
+            notes: this.normalizeTextOrNull(row.notes),
+            due_at: dueAt,
+            completed_at: completedAt,
+            created_at: (_b = this.normalizeDateTimeOrNull(row.created_at)) !== null && _b !== void 0 ? _b : new Date().toISOString(),
+            priority: (this.normalizeTextOrNull(row.priority) || 'medium'),
+            status: this.getCrmActivityStatus(dueAt, completedAt),
+        };
+    }
+    mapCrmActivityDetailRow(row) {
+        const base = this.mapCrmActivityListRow(row);
+        const createdByUserId = this.coerceNumber(row.created_by_user_id) || null;
+        const completedByUserId = this.coerceNumber(row.completed_by_user_id) || null;
+        return Object.assign(Object.assign({}, base), { source_kind: (this.normalizeTextOrNull(row.source_kind) || 'manual'), created_by_user_id: createdByUserId, created_by_user: createdByUserId
+                ? {
+                    id: createdByUserId,
+                    name: this.normalizeTextOrNull(row.created_by_user_name) ||
+                        `#${createdByUserId}`,
+                }
+                : null, completed_by_user_id: completedByUserId, completed_by_user: completedByUserId
+                ? {
+                    id: completedByUserId,
+                    name: this.normalizeTextOrNull(row.completed_by_user_name) ||
+                        `#${completedByUserId}`,
+                }
+                : null });
+    }
+    getCrmActivityStatus(dueAt, completedAt) {
+        if (completedAt) {
+            return 'completed';
+        }
+        return new Date(dueAt) < new Date() ? 'overdue' : 'pending';
+    }
     normalizeDigits(value) {
         return value.replace(/\D/g, '');
     }