@hed-hog/contact 0.0.304 → 0.0.305

package/src/person/person.service.ts

@@ -39,6 +39,7 @@ import {
     FollowupListQueryDTO,
     FollowupStatsQueryDTO,
 } from './dto/followup-query.dto';
+import { CRM_IMPORT_FIELDS } from './dto/import.dto';
 import { MergePersonDTO } from './dto/merge.dto';
 import { ReportsQueryDTO, type CrmReportGroupBy } from './dto/reports-query.dto';
 import { UpdateLifecycleStageDTO } from './dto/update-lifecycle-stage.dto';
@@ -1058,6 +1059,7 @@ export class PersonService {
       type?: string;
       status?: string;
       owner_user_id?: string | number;
+      employer_company_id?: string | number;
       source?: string;
       lifecycle_stage?: string;
       follow_up_status?: string;
@@ -1105,7 +1107,26 @@ export class PersonService {
         person_metadata: {
           some: {
             key: OWNER_USER_METADATA_KEY,
-            value: ownerUserId as any,
+            value: {
+              equals: ownerUserId,
+            },
+          },
+        },
+      });
+    }
+
+    const employerCompanyId = this.coerceNumber(
+      paginationParams.employer_company_id,
+    );
+
+    if (employerCompanyId > 0) {
+      metadataFilters.push({
+        person_metadata: {
+          some: {
+            key: EMPLOYER_COMPANY_METADATA_KEY,
+            value: {
+              equals: employerCompanyId,
+            },
           },
         },
       });
@@ -1116,7 +1137,9 @@ export class PersonService {
         person_metadata: {
           some: {
             key: SOURCE_METADATA_KEY,
-            value: paginationParams.source as any,
+            value: {
+              equals: paginationParams.source,
+            },
           },
         },
       });
@@ -1130,7 +1153,9 @@ export class PersonService {
         person_metadata: {
           some: {
             key: LIFECYCLE_STAGE_METADATA_KEY,
-            value: paginationParams.lifecycle_stage as any,
+            value: {
+              equals: paginationParams.lifecycle_stage,
+            },
           },
         },
       });
@@ -1340,8 +1365,7 @@ export class PersonService {
       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);
+      await this.syncAccountArrays(tx, person.id, data, locale);
 
       return {
         success: true,
@@ -1384,8 +1408,7 @@ export class PersonService {
       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);
+      await this.syncAccountArrays(tx, id, data, locale);
 
       return {
         success: true,
@@ -3116,15 +3139,32 @@ export class PersonService {
       return;
     }
 
-    await client.crm_stage_history.create({
-      data: {
-        person_id: personId,
-        from_stage: fromStage ?? null,
-        to_stage: toStage,
-        changed_by_user_id: changedByUserId,
-        changed_at: new Date(),
-      },
-    });
+    const fromStageSql = fromStage
+      ? Prisma.sql`CAST(${fromStage} AS crm_stage_history_from_stage_f4181e9874_enum)`
+      : Prisma.sql`NULL`;
+
+    await client.$executeRaw(
+      Prisma.sql`
+        INSERT INTO crm_stage_history (
+          person_id,
+          from_stage,
+          to_stage,
+          changed_by_user_id,
+          changed_at,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          ${personId},
+          ${fromStageSql},
+          CAST(${toStage} AS crm_stage_history_to_stage_ca5bd55f9f_enum),
+          ${changedByUserId},
+          NOW(),
+          NOW(),
+          NOW()
+        )
+      `,
+    );
   }
 
   private async syncPersonSubtypeData(
@@ -3498,6 +3538,113 @@ export class PersonService {
     return null;
   }
 
+  private async syncAccountArrays(
+    tx: any,
+    personId: number,
+    data: Pick<
+      CreateAccountDTO,
+      | 'contacts'
+      | 'addresses'
+      | 'documents'
+      | 'email'
+      | 'phone'
+      | 'collaborator_person_ids'
+    >,
+    locale: string,
+  ) {
+    if (Object.prototype.hasOwnProperty.call(data, 'contacts')) {
+      const incomingContacts = Array.isArray(data.contacts) ? data.contacts : [];
+      this.validateSinglePrimaryPerType(
+        incomingContacts,
+        'contact_type_id',
+        locale,
+        'moreThanOnePrimaryContact',
+        'More than one contact of the same type cannot be marked as primary.',
+      );
+      await this.syncContacts(tx, personId, incomingContacts);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(data, 'addresses')) {
+      const incomingAddresses = Array.isArray(data.addresses) ? data.addresses : [];
+      this.validateSinglePrimaryPerType(
+        incomingAddresses,
+        'address_type',
+        locale,
+        'moreThanOnePrimaryAddress',
+        'More than one address of the same type cannot be marked as primary.',
+      );
+      await this.syncAddresses(tx, personId, incomingAddresses, locale);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(data, 'documents')) {
+      const incomingDocuments = Array.isArray(data.documents) ? data.documents : [];
+      this.validateSinglePrimaryPerType(
+        incomingDocuments,
+        'document_type_id',
+        locale,
+        'moreThanOnePrimaryDocument',
+        'More than one document of the same type cannot be marked as primary.',
+      );
+      await this.syncDocuments(tx, personId, incomingDocuments);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(data, 'email')) {
+      await this.upsertPrimaryAccountContact(tx, personId, 'EMAIL', data.email);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(data, 'phone')) {
+      await this.upsertPrimaryAccountContact(tx, personId, 'PHONE', data.phone);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(data, 'collaborator_person_ids')) {
+      await this.attachCollaboratorsToCompany(
+        tx,
+        personId,
+        data.collaborator_person_ids,
+      );
+    }
+  }
+
+  private async attachCollaboratorsToCompany(
+    tx: any,
+    companyId: number,
+    collaboratorPersonIds: number[] | undefined,
+  ) {
+    const normalizedCollaboratorIds = Array.from(
+      new Set(
+        (Array.isArray(collaboratorPersonIds) ? collaboratorPersonIds : [])
+          .map((value) => Number(value))
+          .filter(
+            (value) =>
+              Number.isInteger(value) && value > 0 && value !== companyId,
+          ),
+      ),
+    );
+
+    if (normalizedCollaboratorIds.length === 0) {
+      return;
+    }
+
+    const collaborators = await tx.person.findMany({
+      where: {
+        id: { in: normalizedCollaboratorIds },
+        type: 'individual',
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    for (const collaborator of collaborators) {
+      await this.upsertMetadataValue(
+        tx,
+        collaborator.id,
+        EMPLOYER_COMPANY_METADATA_KEY,
+        companyId,
+      );
+    }
+  }
+
   private async syncContacts(tx: any, personId: number, incomingContacts: any[]) {
     const existingContacts = await tx.contact.findMany({ where: { person_id: personId } });
 
@@ -4078,41 +4225,53 @@ export class PersonService {
     const type: CrmActivityType = 'task';
 
     if (existing) {
-      await tx.crm_activity.update({
-        where: {
-          id: existing.id,
-        },
-        data: {
-          owner_user_id: ownerUserId,
-          type,
-          subject,
-          notes: normalizedNotes,
-          due_at: dueAtDate,
-          priority,
-          updated_at: new Date(),
-        },
-      });
+      await tx.$executeRaw(
+        Prisma.sql`
+          UPDATE crm_activity
+          SET
+            owner_user_id = ${ownerUserId},
+            type = CAST(${'task'} AS crm_activity_type_77c8508dad_enum),
+            subject = ${this.getFollowupActivitySubject()},
+            notes = ${normalizedNotes},
+            due_at = CAST(${dueAt} AS TIMESTAMPTZ),
+            priority = CAST(${'medium'} AS crm_activity_priority_b4e2dbbb4d_enum),
+            updated_at = NOW()
+          WHERE id = ${existing.id}
+        `,
+      );
       return;
     }
 
-    const sourceKind: CrmActivitySourceKind = 'followup';
-    const now = new Date();
-
-    await tx.crm_activity.create({
-      data: {
-        person_id: personId,
-        owner_user_id: ownerUserId,
-        created_by_user_id: actorUserId,
-        type,
-        subject,
-        notes: normalizedNotes,
-        due_at: dueAtDate,
-        priority,
-        source_kind: sourceKind,
-        created_at: now,
-        updated_at: now,
-      },
-    });
+    await tx.$executeRaw(
+      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_77c8508dad_enum),
+          ${this.getFollowupActivitySubject()},
+          ${normalizedNotes},
+          CAST(${dueAt} AS TIMESTAMPTZ),
+          CAST(${'medium'} AS crm_activity_priority_b4e2dbbb4d_enum),
+          CAST(${'followup'} AS crm_activity_source_kind_a09c5de478_enum),
+          NOW(),
+          NOW()
+        )
+      `,
+    );
   }
 
   private async createCompletedInteractionActivity(
@@ -4134,23 +4293,40 @@ export class PersonService {
     const priority: CrmActivityPriority = 'medium';
     const sourceKind: CrmActivitySourceKind = 'interaction';
 
-    await tx.crm_activity.create({
-      data: {
-        person_id: personId,
-        owner_user_id: ownerUserId,
-        created_by_user_id: actorUserId,
-        completed_by_user_id: actorUserId,
-        type,
-        subject: this.getInteractionActivitySubject(interaction.type),
-        notes: this.normalizeTextOrNull(interaction.notes),
-        due_at: completedAt,
-        completed_at: completedAt,
-        priority,
-        source_kind: sourceKind,
-        created_at: completedAt,
-        updated_at: new Date(),
-      },
-    });
+    await tx.$executeRaw(
+      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_77c8508dad_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_b4e2dbbb4d_enum),
+          CAST(${'interaction'} AS crm_activity_source_kind_a09c5de478_enum),
+          CAST(${interaction.created_at} AS TIMESTAMPTZ),
+          NOW()
+        )
+      `,
+    );
   }
 
   private getFollowupActivitySubject() {
@@ -4483,7 +4659,7 @@ export class PersonService {
 
     if (lifecycleStage && lifecycleStage !== 'all') {
       filters.push(
-        Prisma.sql`AND pc.account_lifecycle_stage = ${lifecycleStage}`,
+        Prisma.sql`AND pc.account_lifecycle_stage = CAST(${lifecycleStage} AS person_company_account_lifecycle_stage_680de09d00_enum)`,
       );
     }
 
@@ -4591,12 +4767,14 @@ export class PersonService {
     }
 
     if (type && type !== 'all') {
-      filters.push(Prisma.sql`AND a.type = ${type}`);
+      filters.push(
+        Prisma.sql`AND a.type = CAST(${type} AS crm_activity_type_77c8508dad_enum)`,
+      );
     }
 
     if (priority && priority !== 'all') {
       filters.push(
-        Prisma.sql`AND a.priority = ${priority}`,
+        Prisma.sql`AND a.priority = CAST(${priority} AS crm_activity_priority_b4e2dbbb4d_enum)`,
       );
     }
 
@@ -4811,4 +4989,373 @@ export class PersonService {
       trade_name: tradeName,
     };
   }
+
+  // ─── CSV Import ──────────────────────────────────────────────────────────────
+
+  private getUploadedFileText(file: MulterFile): string {
+    let buffer = file.buffer;
+
+    if (!buffer || buffer.length === 0) {
+      throw new BadRequestException('Uploaded file is empty');
+    }
+
+    const utf8 = buffer.toString('utf8');
+    // Replace UTF-8 BOM if present
+    const withoutBom = utf8.replace(/^\uFEFF/, '');
+    if (withoutBom.includes('\uFFFD')) {
+      return buffer.toString('latin1').replace(/^\uFEFF/, '');
+    }
+
+    return withoutBom;
+  }
+
+  private parseCsvRaw(content: string): { columns: string[]; rows: Record<string, string>[] } {
+    const text = content.trimEnd();
+    if (!text) return { columns: [], rows: [] };
+
+    // Detect delimiter from the first line before parsing the whole content
+    const firstNewlineIdx = text.indexOf('\n');
+    const firstLine = firstNewlineIdx === -1 ? text : text.slice(0, firstNewlineIdx);
+    const delimiter = firstLine.includes(';') ? ';' : ',';
+
+    // RFC 4180-compliant parser: character-by-character so quoted fields
+    // can span multiple lines without being split into separate records.
+    const records: string[][] = [];
+    let row: string[] = [];
+    let field = '';
+    let inQuotes = false;
+    let i = 0;
+
+    const pushField = () => {
+      // For unquoted fields trim surrounding whitespace;
+      // for quoted fields the value is already the inner content.
+      row.push(inQuotes ? field : field.trim());
+      field = '';
+    };
+
+    const pushRow = () => {
+      pushField();
+      // Skip rows where every cell is empty (blank lines between records)
+      if (row.some((c) => c !== '')) {
+        records.push(row);
+      }
+      row = [];
+      inQuotes = false;
+    };
+
+    while (i < text.length) {
+      const ch = text[i];
+
+      if (inQuotes) {
+        if (ch === '"') {
+          if (i + 1 < text.length && text[i + 1] === '"') {
+            // Escaped double-quote ("") → literal "
+            field += '"';
+            i += 2;
+          } else {
+            // Closing quote — exit quoted mode; consume any trailing
+            // whitespace before the next delimiter so malformed exports
+            // like `"value" ;` don't include a trailing space.
+            inQuotes = false;
+            i++;
+          }
+        } else {
+          // Newlines inside quoted fields are literal content, not record separators
+          field += ch;
+          i++;
+        }
+      } else {
+        if (ch === '"' && field.trim() === '') {
+          // Opening quote — only valid at the start of a field
+          inQuotes = true;
+          field = '';
+          i++;
+        } else if (ch === delimiter) {
+          pushField();
+          field = '';
+          i++;
+        } else if (ch === '\r' && i + 1 < text.length && text[i + 1] === '\n') {
+          pushRow();
+          i += 2;
+        } else if (ch === '\n') {
+          pushRow();
+          i++;
+        } else {
+          field += ch;
+          i++;
+        }
+      }
+    }
+
+    // Flush the last record (file may not end with a newline)
+    if (field || row.length > 0) {
+      row.push(inQuotes ? field : field.trim());
+      if (row.some((c) => c !== '')) {
+        records.push(row);
+      }
+    }
+
+    if (records.length === 0) return { columns: [], rows: [] };
+
+    const columns = records[0].map((c) => c.trim());
+    const rows = records
+      .slice(1)
+      .filter((r) => r.some((c) => c !== ''))
+      .map((cells) => {
+        const row: Record<string, string> = {};
+        columns.forEach((col, idx) => {
+          row[col] = (cells[idx] ?? '').trim();
+        });
+        return row;
+      });
+
+    return { columns, rows };
+  }
+
+  async previewCsvImport(file: MulterFile) {
+    const MAX_ROWS = 5000;
+    const PREVIEW_ROWS = 20;
+
+    const content = this.getUploadedFileText(file);
+    const { columns, rows } = this.parseCsvRaw(content);
+
+    if (rows.length > MAX_ROWS) {
+      throw new BadRequestException(
+        `File exceeds the maximum of ${MAX_ROWS} rows. Split the file and try again.`,
+      );
+    }
+
+    return {
+      fileName: file.originalname,
+      totalEstimated: rows.length,
+      columns,
+      preview: rows.slice(0, PREVIEW_ROWS),
+    };
+  }
+
+  async importFromCsv(
+    file: MulterFile,
+    mapping: Record<string, string>,
+    companyId: number | undefined,
+    locale: string,
+    userId: number,
+  ) {
+    // 1. Validate the linked company, if provided
+    if (companyId) {
+      const company = await this.prismaService.person.findFirst({
+        where: { id: companyId, type: 'company' },
+        select: { id: true },
+      });
+      if (!company) {
+        throw new BadRequestException(
+          getLocaleText('personNotFound', locale, `Company with ID ${companyId} not found.`),
+        );
+      }
+    }
+
+    // 1b. Validate mapping field names against allowed CRM fields
+    const validCrmFields = new Set<string>(CRM_IMPORT_FIELDS);
+    for (const val of Object.values(mapping)) {
+      if (!validCrmFields.has(val)) {
+        throw new BadRequestException(
+          getLocaleText('validation.nameMustBeString', locale, `Invalid mapping field: "${val}"`),
+        );
+      }
+    }
+
+    // 2. Pre-fetch contact type IDs once (avoid per-row roundtrips)
+    const contactTypes = await this.prismaService.contact_type.findMany({
+      where: { code: { in: ['EMAIL', 'PHONE', 'MOBILE'] } },
+      select: { id: true, code: true },
+    });
+    const contactTypeMap = new Map(contactTypes.map((t) => [t.code.toUpperCase(), t.id]));
+
+    // 3. Pre-fetch document type IDs once
+    const documentTypes = await this.prismaService.document_type.findMany({
+      where: { code: { in: ['CPF', 'CNPJ'] } },
+      select: { id: true, code: true },
+    });
+    const documentTypeMap = new Map(documentTypes.map((t) => [t.code.toUpperCase(), t.id]));
+
+    // 4. Parse CSV content
+    const content = this.getUploadedFileText(file);
+    const { rows } = this.parseCsvRaw(content);
+
+    let imported = 0;
+    let skipped = 0;
+    const errors: Array<{ row: number; message: string }> = [];
+
+    const BATCH_SIZE = 50;
+    for (let batchStart = 0; batchStart < rows.length; batchStart += BATCH_SIZE) {
+      const batch = rows.slice(batchStart, batchStart + BATCH_SIZE);
+
+      for (let i = 0; i < batch.length; i++) {
+        const rowIndex = batchStart + i + 2; // +2: 1-indexed and skip header row
+        const row = batch[i];
+
+        try {
+          // Build a flat object: CRM field → CSV cell value
+          const mapped: Record<string, string> = {};
+          for (const [csvCol, crmField] of Object.entries(mapping)) {
+            if (crmField !== '_ignore' && row[csvCol] !== undefined && row[csvCol] !== '') {
+              mapped[crmField] = row[csvCol];
+            }
+          }
+
+          // 'name' is mandatory — skip silently when absent
+          const name = this.normalizeTextOrNull(mapped['name']);
+          if (!name) {
+            skipped++;
+            continue;
+          }
+
+          // Coerce type (default: individual)
+          const rawType = (mapped['type'] ?? '').toLowerCase();
+          const personType: 'individual' | 'company' =
+            rawType === 'company' ||
+            rawType === 'empresa' ||
+            rawType === 'jurídica' ||
+            rawType === 'juridica'
+              ? 'company'
+              : 'individual';
+
+          // Coerce status (default: active)
+          const rawStatus = (mapped['status'] ?? '').toLowerCase();
+          const personStatus: 'active' | 'inactive' =
+            rawStatus === 'inactive' || rawStatus === 'inativo' ? 'inactive' : 'active';
+
+          // Run each row inside its own transaction so a bad row never rolls
+          // back successfully imported rows
+          await this.prismaService.$transaction(async (tx) => {
+            // (a) Base person record
+            const person = await tx.person.create({
+              data: { name, type: personType, status: personStatus },
+            });
+
+            // (b) Subtype-specific table (person_individual / person_company)
+            await this.syncPersonSubtypeData(
+              tx,
+              person.id,
+              null,
+              {
+                type: personType,
+                job_title:
+                  personType === 'individual' ? (mapped['job_title'] ?? null) : null,
+                trade_name:
+                  personType === 'company' ? (mapped['trade_name'] ?? null) : null,
+                website:
+                  personType === 'company' ? (mapped['website'] ?? null) : null,
+              },
+              locale,
+            );
+
+            // (c) Metadata (notes, source, employer company, owner)
+            await this.syncPersonMetadata(tx, person.id, {
+              notes: mapped['notes'] ?? undefined,
+              source: mapped['source'] ?? undefined,
+              employer_company_id:
+                personType === 'individual' && companyId ? companyId : undefined,
+              owner_user_id: userId > 0 ? userId : undefined,
+            });
+
+            // (d) Contacts — email takes priority as primary
+            let needsPrimary = true;
+
+            const emailTypeId = contactTypeMap.get('EMAIL');
+            if (mapped['email'] && emailTypeId) {
+              await tx.contact.create({
+                data: {
+                  person_id: person.id,
+                  contact_type_id: emailTypeId,
+                  value: mapped['email'],
+                  is_primary: true,
+                },
+              });
+              needsPrimary = false;
+            }
+
+            const phoneTypeId = contactTypeMap.get('PHONE');
+            if (mapped['phone'] && phoneTypeId) {
+              await tx.contact.create({
+                data: {
+                  person_id: person.id,
+                  contact_type_id: phoneTypeId,
+                  value: mapped['phone'],
+                  is_primary: needsPrimary,
+                },
+              });
+              needsPrimary = false;
+            }
+
+            const mobileTypeId = contactTypeMap.get('MOBILE');
+            if (mapped['mobile'] && mobileTypeId) {
+              await tx.contact.create({
+                data: {
+                  person_id: person.id,
+                  contact_type_id: mobileTypeId,
+                  value: mapped['mobile'],
+                  is_primary: needsPrimary,
+                },
+              });
+            }
+
+            // (e) Address — only created when at least one address field is present
+            const hasAddress =
+              mapped['address_street'] ||
+              mapped['address_city'] ||
+              mapped['address_state'] ||
+              mapped['address_zip'] ||
+              mapped['address_country'];
+
+            if (hasAddress) {
+              const address = await tx.address.create({
+                data: {
+                  line1: mapped['address_street'] ?? '',
+                  line2: '',
+                  city: mapped['address_city'] ?? '',
+                  state: mapped['address_state'] ?? '',
+                  country_code: mapped['address_country'] || 'BRA',
+                  postal_code: mapped['address_zip'] ?? '',
+                  is_primary: true,
+                  address_type: 'residential',
+                },
+              });
+              await tx.person_address.create({
+                data: { person_id: person.id, address_id: address.id },
+              });
+            }
+
+            // (f) Documents — the document table has no is_primary column
+            const cpfTypeId = documentTypeMap.get('CPF');
+            if (mapped['cpf'] && cpfTypeId) {
+              await tx.document.create({
+                data: {
+                  person_id: person.id,
+                  document_type_id: cpfTypeId,
+                  value: mapped['cpf'],
+                },
+              });
+            }
+
+            const cnpjTypeId = documentTypeMap.get('CNPJ');
+            if (mapped['cnpj'] && cnpjTypeId) {
+              await tx.document.create({
+                data: {
+                  person_id: person.id,
+                  document_type_id: cnpjTypeId,
+                  value: mapped['cnpj'],
+                },
+              });
+            }
+          });
+
+          imported++;
+        } catch (err: any) {
+          errors.push({ row: rowIndex, message: err?.message ?? 'Unknown error' });
+        }
+      }
+    }
+
+    return { imported, skipped, errors };
+  }
 }