@hed-hog/lms 0.0.361 → 0.0.364

package/src/lesson-xp-map/lesson-xp-segment.service.ts

@@ -0,0 +1,229 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  SegmentAreaDto,
+  SegmentLearningTypeDto,
+  SegmentSkillDto,
+  CreateLessonXpSegmentDto,
+} from './dto/create-lesson-xp-segment.dto';
+import { UpdateLessonXpSegmentDto } from './dto/update-lesson-xp-segment.dto';
+
+@Injectable()
+export class LessonXpSegmentService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async listByMap(mapId: number, params: { page?: number; pageSize?: number }) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 50, 1);
+    const offset = (page - 1) * pageSize;
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total FROM lesson_xp_segment WHERE lesson_xp_map_id = $1`,
+      [mapId],
+    );
+
+    const rows = await this.queryRows<any>(
+      `SELECT
+          s.id,
+          s.lesson_xp_map_id AS "lessonXpMapId",
+          s.start_seconds::float AS "startSeconds",
+          s.end_seconds::float AS "endSeconds",
+          s.xp_value AS "xpValue",
+          s.difficulty::text AS difficulty,
+          s.should_grant_xp AS "shouldGrantXp",
+          s.ai_summary AS "aiSummary",
+          s.ai_confidence::float AS "aiConfidence",
+          s.sort_order AS "sortOrder",
+          s.created_at::text AS "createdAt",
+          s.updated_at::text AS "updatedAt",
+          COALESCE(
+            (SELECT json_agg(json_build_object('xpAreaId', sa.xp_area_id, 'weightPercent', sa.weight_percent::float))
+               FROM lesson_xp_segment_area sa WHERE sa.lesson_xp_segment_id = s.id),
+            '[]'
+          ) AS areas,
+          COALESCE(
+            (SELECT json_agg(json_build_object('xpSkillId', ss.xp_skill_id, 'weightPercent', ss.weight_percent::float))
+               FROM lesson_xp_segment_skill ss WHERE ss.lesson_xp_segment_id = s.id),
+            '[]'
+          ) AS skills,
+          COALESCE(
+            (SELECT json_agg(json_build_object('xpLearningTypeId', sl.xp_learning_type_id, 'weightPercent', sl.weight_percent::float))
+               FROM lesson_xp_segment_learning_type sl WHERE sl.lesson_xp_segment_id = s.id),
+            '[]'
+          ) AS "learningTypes"
+        FROM lesson_xp_segment s
+       WHERE s.lesson_xp_map_id = $1
+       ORDER BY s.sort_order ASC, s.start_seconds ASC
+       LIMIT $2 OFFSET $3`,
+      [mapId, pageSize, offset],
+    );
+
+    const total = Number(totalRow?.total ?? 0);
+    return { data: rows, total, page, pageSize, lastPage: Math.ceil(total / pageSize) };
+  }
+
+  async getById(id: number) {
+    const row = await this.querySingle<any>(
+      `SELECT
+          s.id,
+          s.lesson_xp_map_id AS "lessonXpMapId",
+          s.start_seconds::float AS "startSeconds",
+          s.end_seconds::float AS "endSeconds",
+          s.xp_value AS "xpValue",
+          s.difficulty::text AS difficulty,
+          s.should_grant_xp AS "shouldGrantXp",
+          s.ai_summary AS "aiSummary",
+          s.ai_confidence::float AS "aiConfidence",
+          s.sort_order AS "sortOrder",
+          s.created_at::text AS "createdAt",
+          s.updated_at::text AS "updatedAt"
+        FROM lesson_xp_segment s WHERE s.id = $1`,
+      [id],
+    );
+    if (!row) throw new NotFoundException('Lesson XP segment not found');
+
+    const [areas, skills, learningTypes] = await Promise.all([
+      this.queryRows<any>(`SELECT xp_area_id AS "xpAreaId", weight_percent::float AS "weightPercent" FROM lesson_xp_segment_area WHERE lesson_xp_segment_id = $1`, [id]),
+      this.queryRows<any>(`SELECT xp_skill_id AS "xpSkillId", weight_percent::float AS "weightPercent" FROM lesson_xp_segment_skill WHERE lesson_xp_segment_id = $1`, [id]),
+      this.queryRows<any>(`SELECT xp_learning_type_id AS "xpLearningTypeId", weight_percent::float AS "weightPercent" FROM lesson_xp_segment_learning_type WHERE lesson_xp_segment_id = $1`, [id]),
+    ]);
+
+    return { ...row, areas, skills, learningTypes };
+  }
+
+  async create(mapId: number, dto: CreateLessonXpSegmentDto) {
+    const map = await this.querySingle<{ id: number }>(`SELECT id FROM lesson_xp_map WHERE id = $1`, [mapId]);
+    if (!map) throw new NotFoundException('Lesson XP map not found');
+
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO lesson_xp_segment
+         (lesson_xp_map_id, start_seconds, end_seconds, xp_value, difficulty, should_grant_xp,
+          ai_summary, ai_confidence, sort_order, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5::lesson_xp_segment_difficulty_e5f6a7b8c9_enum, $6, $7, $8, $9, NOW(), NOW())
+       RETURNING id`,
+      [
+        mapId, dto.startSeconds, dto.endSeconds, dto.xpValue,
+        dto.difficulty, dto.shouldGrantXp, dto.aiSummary ?? null,
+        dto.aiConfidence ?? null, dto.sortOrder ?? 0,
+      ],
+    );
+
+    await this.syncRelations(created!.id, dto.areas, dto.skills, dto.learningTypes);
+    await this.recalculateTotalXp(mapId);
+    return this.getById(created!.id);
+  }
+
+  async update(id: number, dto: UpdateLessonXpSegmentDto) {
+    const segment = await this.querySingle<{ id: number; lesson_xp_map_id: number }>(
+      `SELECT id, lesson_xp_map_id FROM lesson_xp_segment WHERE id = $1`,
+      [id],
+    );
+    if (!segment) throw new NotFoundException('Lesson XP segment not found');
+
+    const updates: string[] = [];
+    const values: unknown[] = [];
+
+    if (dto.startSeconds !== undefined) updates.push(`start_seconds = ${this.param(values, dto.startSeconds)}`);
+    if (dto.endSeconds !== undefined) updates.push(`end_seconds = ${this.param(values, dto.endSeconds)}`);
+    if (dto.xpValue !== undefined) updates.push(`xp_value = ${this.param(values, dto.xpValue)}`);
+    if (dto.difficulty !== undefined) updates.push(`difficulty = ${this.param(values, dto.difficulty)}::lesson_xp_segment_difficulty_e5f6a7b8c9_enum`);
+    if (dto.shouldGrantXp !== undefined) updates.push(`should_grant_xp = ${this.param(values, dto.shouldGrantXp)}`);
+    if (dto.aiSummary !== undefined) updates.push(`ai_summary = ${this.param(values, dto.aiSummary)}`);
+    if (dto.aiConfidence !== undefined) updates.push(`ai_confidence = ${this.param(values, dto.aiConfidence)}`);
+    if (dto.sortOrder !== undefined) updates.push(`sort_order = ${this.param(values, dto.sortOrder)}`);
+
+    if (updates.length > 0) {
+      values.push(id);
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE lesson_xp_segment SET ${updates.join(', ')}, updated_at = NOW() WHERE id = $${values.length}`,
+        ...values,
+      );
+    }
+
+    if (dto.areas !== undefined || dto.skills !== undefined || dto.learningTypes !== undefined) {
+      await this.syncRelations(id, dto.areas, dto.skills, dto.learningTypes);
+    }
+
+    await this.recalculateTotalXp(segment.lesson_xp_map_id);
+    return this.getById(id);
+  }
+
+  async delete(id: number) {
+    const segment = await this.querySingle<{ id: number; lesson_xp_map_id: number }>(
+      `SELECT id, lesson_xp_map_id FROM lesson_xp_segment WHERE id = $1`,
+      [id],
+    );
+    if (!segment) throw new NotFoundException('Lesson XP segment not found');
+
+    await this.prisma.$executeRawUnsafe(`DELETE FROM lesson_xp_segment WHERE id = $1`, id);
+    await this.recalculateTotalXp(segment.lesson_xp_map_id);
+  }
+
+  private async syncRelations(
+    segmentId: number,
+    areas?: SegmentAreaDto[],
+    skills?: SegmentSkillDto[],
+    learningTypes?: SegmentLearningTypeDto[],
+  ) {
+    if (areas !== undefined) {
+      await this.prisma.$executeRawUnsafe(`DELETE FROM lesson_xp_segment_area WHERE lesson_xp_segment_id = $1`, segmentId);
+      for (const area of areas) {
+        await this.prisma.$executeRawUnsafe(
+          `INSERT INTO lesson_xp_segment_area (lesson_xp_segment_id, xp_area_id, weight_percent, created_at, updated_at)
+           VALUES ($1, $2, $3, NOW(), NOW())`,
+          segmentId, area.xpAreaId, area.weightPercent,
+        );
+      }
+    }
+
+    if (skills !== undefined) {
+      await this.prisma.$executeRawUnsafe(`DELETE FROM lesson_xp_segment_skill WHERE lesson_xp_segment_id = $1`, segmentId);
+      for (const skill of skills) {
+        await this.prisma.$executeRawUnsafe(
+          `INSERT INTO lesson_xp_segment_skill (lesson_xp_segment_id, xp_skill_id, weight_percent, created_at, updated_at)
+           VALUES ($1, $2, $3, NOW(), NOW())`,
+          segmentId, skill.xpSkillId, skill.weightPercent,
+        );
+      }
+    }
+
+    if (learningTypes !== undefined) {
+      await this.prisma.$executeRawUnsafe(`DELETE FROM lesson_xp_segment_learning_type WHERE lesson_xp_segment_id = $1`, segmentId);
+      for (const lt of learningTypes) {
+        await this.prisma.$executeRawUnsafe(
+          `INSERT INTO lesson_xp_segment_learning_type (lesson_xp_segment_id, xp_learning_type_id, weight_percent, created_at, updated_at)
+           VALUES ($1, $2, $3, NOW(), NOW())`,
+          segmentId, lt.xpLearningTypeId, lt.weightPercent,
+        );
+      }
+    }
+  }
+
+  private async recalculateTotalXp(mapId: number) {
+    await this.prisma.$executeRawUnsafe(
+      `UPDATE lesson_xp_map
+          SET total_xp = COALESCE(
+            (SELECT SUM(xp_value) FROM lesson_xp_segment
+              WHERE lesson_xp_map_id = $1 AND should_grant_xp = true),
+            0
+          ),
+          updated_at = NOW()
+        WHERE id = $1`,
+      mapId,
+    );
+  }
+
+  private param(values: unknown[], value: unknown) {
+    values.push(value);
+    return `$${values.length}`;
+  }
+
+  private async queryRows<T>(query: string, values: unknown[] = []) {
+    return this.prisma.$queryRawUnsafe<T[]>(query, ...values);
+  }
+
+  private async querySingle<T>(query: string, values: unknown[] = []) {
+    const rows = await this.prisma.$queryRawUnsafe<T[]>(query, ...values);
+    return rows[0] ?? null;
+  }
+}

package/src/lms.module.ts

@@ -12,6 +12,7 @@ import { ClassGroupModule } from './class-group/class-group.module';
 import { CourseLessonDiscussionModule } from './course-lesson-discussion/course-lesson-discussion.module';
 import { CourseLessonNoteModule } from './course-lesson-note/course-lesson-note.module';
 import { CourseAudioTranscriptionService } from './course/course-audio-transcription.service';
+import { LmsBulkUploadAutomationService } from './course/lms-bulk-upload-automation.service';
 import { CourseModule } from './course/course.module';
 import { LmsDashboardModule } from './dashboard/dashboard.module';
 import { EnterpriseModule } from './enterprise/enterprise.module';
@@ -19,9 +20,13 @@ import { EnterpriseTrainingModule } from './enterprise/training/enterprise-train
 import { EvaluationModule } from './evaluation/evaluation.module';
 import { ExamModule } from './exam/exam.module';
 import { InstructorModule } from './instructor/instructor.module';
+import { LessonXpMapModule } from './lesson-xp-map/lesson-xp-map.module';
+import { PlataformaController } from './platforma/platforma.controller';
+import { StudentXpModule } from './student-xp/student-xp.module';
+import { XpCatalogModule } from './xp-catalog/xp-catalog.module';
+import { PlatformaService } from './platforma/platforma.service';
 import { LmsRealtimeModule } from './realtime/lms-realtime.module';
 import { LmsReportsModule } from './reports/reports.module';
-import { PlataformaController } from './platforma/platforma.controller';
 import { TrainingModule } from './training/training.module';
 import { VideoResolutionProfileModule } from './video-resolution-profile/video-resolution-profile.module';
 
@@ -50,9 +55,16 @@ import { VideoResolutionProfileModule } from './video-resolution-profile/video-r
     forwardRef(() => LmsReportsModule),
     forwardRef(() => TrainingModule),
     forwardRef(() => VideoResolutionProfileModule),
+    forwardRef(() => XpCatalogModule),
+    forwardRef(() => LessonXpMapModule),
+    forwardRef(() => StudentXpModule),
   ],
   controllers: [PlataformaController],
-  providers: [CourseAudioTranscriptionService],
+  providers: [
+    CourseAudioTranscriptionService,
+    LmsBulkUploadAutomationService,
+    PlatformaService,
+  ],
   exports: [
     forwardRef(() => AchievementModule),
     forwardRef(() => BitcodeWalletModule),
@@ -71,6 +83,9 @@ import { VideoResolutionProfileModule } from './video-resolution-profile/video-r
     forwardRef(() => LmsReportsModule),
     forwardRef(() => TrainingModule),
     forwardRef(() => VideoResolutionProfileModule),
+    forwardRef(() => XpCatalogModule),
+    forwardRef(() => LessonXpMapModule),
+    forwardRef(() => StudentXpModule),
   ],
 })
 export class LmsModule {}

package/src/platforma/dto/update-profile.dto.ts

@@ -0,0 +1,59 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class UpdatePlatformaProfileDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  cpf?: string;
+
+  @IsOptional()
+  @IsString()
+  dob?: string;
+
+  @IsOptional()
+  @IsString()
+  gender?: string;
+
+  @IsOptional()
+  @IsString()
+  country?: string;
+
+  @IsOptional()
+  @IsString()
+  city?: string;
+
+  @IsOptional()
+  @IsString()
+  state?: string;
+
+  @IsOptional()
+  @IsString()
+  neighborhood?: string;
+
+  @IsOptional()
+  @IsString()
+  street?: string;
+
+  @IsOptional()
+  @IsString()
+  number?: string;
+
+  @IsOptional()
+  @IsString()
+  complement?: string;
+
+  @IsOptional()
+  @IsString()
+  zip?: string;
+
+  @IsOptional()
+  @IsString()
+  phone?: string;
+
+  @IsOptional()
+  @IsString()
+  profession?: string;
+}

package/src/platforma/platforma.controller.ts

@@ -1,7 +1,12 @@
 import { NoRole, User } from '@hed-hog/api';
 import { NotificationService } from '@hed-hog/core';
-import { Body, Controller, Get, Param, ParseIntPipe, Patch, Post, Query } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, ParseIntPipe, Patch, Post, Put, Query, Req, Res } from '@nestjs/common';
+import type { Request, Response } from 'express';
+import { BitcodeWalletService } from '../bitcode-wallet/bitcode-wallet.service';
+import { CreateCurrentBitcodeWalletTransactionDto } from '../bitcode-wallet/dto/create-current-bitcode-wallet-transaction.dto';
 import { TrainingStudentService } from '../enterprise/training/training-student.service';
+import { UpdatePlatformaProfileDto } from './dto/update-profile.dto';
+import { PlatformaService } from './platforma.service';
 
 @NoRole()
 @Controller('lms/platforma')
@@ -9,6 +14,8 @@ export class PlataformaController {
   constructor(
     private readonly trainingStudentService: TrainingStudentService,
     private readonly notificationService: NotificationService,
+    private readonly platforma: PlatformaService,
+    private readonly bitcodeWalletService: BitcodeWalletService,
   ) {}
 
   @Get()
@@ -74,6 +81,28 @@ export class PlataformaController {
     return this.notificationService.markRead(userId, id);
   }
 
+  @Get('notifications/stream')
+  streamNotifications(
+    @User('id') userId: number,
+    @Req() req: Request,
+    @Res() res: Response,
+  ) {
+    return this.notificationService.stream(userId, req, res);
+  }
+
+  @Delete('notifications/:id')
+  deleteNotification(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) id: number,
+  ) {
+    return this.notificationService.delete(userId, id);
+  }
+
+  @Delete('notifications')
+  deleteAllNotifications(@User('id') userId: number) {
+    return this.notificationService.deleteAll(userId);
+  }
+
   @Get('streak')
   getStreak(
     @User('id') userId: number,
@@ -89,4 +118,30 @@ export class PlataformaController {
   ) {
     return this.trainingStudentService.registerStreakActivity(userId, body);
   }
-}
+
+  @Get('bitcodes/wallet')
+  getBitcodeWallet(@User('id') userId: number) {
+    return this.bitcodeWalletService.getCurrentUserWallet(userId);
+  }
+
+  @Post('bitcodes/transactions')
+  createBitcodeTransaction(
+    @User('id') userId: number,
+    @Body() dto: CreateCurrentBitcodeWalletTransactionDto,
+  ) {
+    return this.bitcodeWalletService.createCurrentUserTransaction(userId, dto);
+  }
+
+  @Get('profile')
+  getProfile(@User('id') userId: number) {
+    return this.platforma.getProfile(userId);
+  }
+
+  @Put('profile')
+  updateProfile(
+    @User('id') userId: number,
+    @Body() dto: UpdatePlatformaProfileDto,
+  ) {
+    return this.platforma.updateProfile(userId, dto);
+  }
+}

package/src/platforma/platforma.service.ts

@@ -0,0 +1,268 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable } from '@nestjs/common';
+import { UpdatePlatformaProfileDto } from './dto/update-profile.dto';
+
+function mapGenderToDb(
+  gender?: string | null,
+): 'male' | 'female' | 'other' | null {
+  if (!gender) return null;
+  if (gender === 'Masculino') return 'male';
+  if (gender === 'Feminino') return 'female';
+  return 'other';
+}
+
+function mapGenderToDisplay(gender?: string | null): string | null {
+  if (!gender) return null;
+  if (gender === 'male') return 'Masculino';
+  if (gender === 'female') return 'Feminino';
+  return 'Prefiro nao dizer';
+}
+
+function buildLine1(street?: string | null, number?: string | null): string {
+  if (!street && !number) return '';
+  if (!number) return street ?? '';
+  if (!street) return number;
+  return `${street}, ${number}`;
+}
+
+function buildLine2(
+  neighborhood?: string | null,
+  complement?: string | null,
+): string {
+  const parts = [neighborhood, complement].filter(Boolean);
+  return parts.join('; ');
+}
+
+function parseAddressLine1(line1?: string | null): [string, string] {
+  if (!line1) return ['', ''];
+  const idx = line1.lastIndexOf(', ');
+  if (idx === -1) return [line1, ''];
+  return [line1.slice(0, idx), line1.slice(idx + 2)];
+}
+
+function parseAddressLine2(line2?: string | null): [string, string] {
+  if (!line2) return ['', ''];
+  const idx = line2.indexOf('; ');
+  if (idx === -1) return [line2, ''];
+  return [line2.slice(0, idx), line2.slice(idx + 2)];
+}
+
+@Injectable()
+export class PlatformaService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async getProfile(userId: number) {
+    const [user, personUser] = await Promise.all([
+      this.prisma.user.findUnique({ where: { id: userId } }),
+      this.prisma.person_user.findFirst({
+        where: { user_id: userId },
+        select: { person_id: true },
+      }),
+    ]);
+
+    const personId = personUser?.person_id;
+
+    const [individual, contacts, documents, personAddresses] =
+      await Promise.all([
+        personId
+          ? this.prisma.person_individual.findUnique({
+              where: { id: personId },
+            })
+          : Promise.resolve(null),
+        personId
+          ? this.prisma.contact.findMany({
+              where: { person_id: personId },
+              include: { contact_type: true },
+            })
+          : Promise.resolve([]),
+        personId
+          ? this.prisma.document.findMany({
+              where: { person_id: personId },
+              include: { document_type: true },
+            })
+          : Promise.resolve([]),
+        personId
+          ? this.prisma.person_address.findMany({
+              where: { person_id: personId },
+              include: { address: true },
+              orderBy: { address: { is_primary: 'desc' } },
+            })
+          : Promise.resolve([]),
+      ]);
+
+    const phoneContact = contacts.find((c) => c.contact_type.code === 'PHONE');
+    const cpfDoc = documents.find((d) => d.document_type.code === 'CPF');
+    const primaryAddress =
+      personAddresses.find((pa) => pa.address.is_primary)?.address ??
+      personAddresses[0]?.address;
+
+    const [street, number] = parseAddressLine1(primaryAddress?.line1);
+    const [neighborhood, complement] = parseAddressLine2(primaryAddress?.line2);
+
+    return {
+      id: user?.id,
+      name: user?.name ?? null,
+      cpf: cpfDoc?.value ?? null,
+      dob: individual?.birth_date
+        ? individual.birth_date.toISOString().slice(0, 10)
+        : null,
+      gender: mapGenderToDisplay(individual?.gender as string | null),
+      country: primaryAddress?.country_code ?? null,
+      city: primaryAddress?.city ?? null,
+      state: primaryAddress?.state ?? null,
+      neighborhood,
+      street,
+      number,
+      complement,
+      zip: primaryAddress?.postal_code ?? null,
+      phone: phoneContact?.value ?? null,
+      profession: individual?.job_title ?? null,
+    };
+  }
+
+  async updateProfile(userId: number, dto: UpdatePlatformaProfileDto) {
+    await this.prisma.$transaction(async (tx) => {
+      if (dto.name) {
+        await tx.user.update({
+          where: { id: userId },
+          data: { name: dto.name },
+        });
+      }
+
+      let personUser = await tx.person_user.findFirst({
+        where: { user_id: userId },
+      });
+      let personId: number;
+
+      if (!personUser) {
+        const user = await tx.user.findUnique({ where: { id: userId } });
+        const newPerson = await tx.person.create({
+          data: {
+            name: dto.name ?? user?.name ?? '',
+            type: 'individual',
+            status: 'active',
+          } as any,
+        });
+        await tx.person_user.create({
+          data: { person_id: newPerson.id, user_id: userId },
+        });
+        personId = newPerson.id;
+      } else {
+        personId = personUser.person_id;
+        if (dto.name) {
+          await tx.person.update({
+            where: { id: personId },
+            data: { name: dto.name },
+          });
+        }
+      }
+
+      const individualData: Record<string, unknown> = {};
+      if (dto.dob !== undefined) {
+        individualData.birth_date = dto.dob ? new Date(dto.dob) : null;
+      }
+      if (dto.gender !== undefined) {
+        individualData.gender = mapGenderToDb(dto.gender);
+      }
+      if (dto.profession !== undefined) {
+        individualData.job_title = dto.profession || null;
+      }
+
+      await (tx as any).person_individual.upsert({
+        where: { id: personId },
+        create: { id: personId, ...individualData },
+        update: individualData,
+      });
+
+      const phoneType = await tx.contact_type.findFirst({
+        where: { code: 'PHONE' },
+      });
+      if (phoneType && dto.phone !== undefined) {
+        const existingPhone = await tx.contact.findFirst({
+          where: { person_id: personId, contact_type_id: phoneType.id },
+        });
+        if (dto.phone) {
+          if (existingPhone) {
+            await tx.contact.update({
+              where: { id: existingPhone.id },
+              data: { value: dto.phone },
+            });
+          } else {
+            await tx.contact.create({
+              data: {
+                person_id: personId,
+                contact_type_id: phoneType.id,
+                value: dto.phone,
+                is_primary: true,
+              },
+            });
+          }
+        } else if (existingPhone) {
+          await tx.contact.delete({ where: { id: existingPhone.id } });
+        }
+      }
+
+      const cpfType = await tx.document_type.findFirst({
+        where: { code: 'CPF' },
+      });
+      if (cpfType && dto.cpf !== undefined) {
+        const existingCpf = await tx.document.findFirst({
+          where: { person_id: personId, document_type_id: cpfType.id },
+        });
+        if (dto.cpf) {
+          if (existingCpf) {
+            await tx.document.update({
+              where: { id: existingCpf.id },
+              data: { value: dto.cpf },
+            });
+          } else {
+            await tx.document.create({
+              data: {
+                person_id: personId,
+                document_type_id: cpfType.id,
+                value: dto.cpf,
+              },
+            });
+          }
+        } else if (existingCpf) {
+          await tx.document.delete({ where: { id: existingCpf.id } });
+        }
+      }
+
+      const hasAddressData =
+        dto.street || dto.city || dto.state || dto.zip || dto.country;
+      if (hasAddressData) {
+        const existingPersonAddress = await tx.person_address.findFirst({
+          where: { person_id: personId },
+          include: { address: true },
+          orderBy: { address: { is_primary: 'desc' } },
+        });
+
+        const addressData = {
+          country_code: dto.country ?? '',
+          state: dto.state ?? '',
+          city: dto.city ?? '',
+          postal_code: (dto.zip ?? '').replace(/\D/g, ''),
+          line1: buildLine1(dto.street, dto.number),
+          line2: buildLine2(dto.neighborhood, dto.complement),
+          is_primary: true,
+          address_type: 'residential' as const,
+        };
+
+        if (existingPersonAddress) {
+          await tx.address.update({
+            where: { id: existingPersonAddress.address_id },
+            data: addressData,
+          });
+        } else {
+          const newAddress = await tx.address.create({ data: addressData });
+          await tx.person_address.create({
+            data: { person_id: personId, address_id: newAddress.id },
+          });
+        }
+      }
+    });
+
+    return { success: true };
+  }
+}