fix(F1.3): asegurar visita única en build estricto

Agrega paquete de campo por inspección con Actas anteriores del mismo contexto, hallazgos abiertos priorizados para verificación y vista web imprimible.

api-v3/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhv2-api",
-  "version": "0.21.0-2",
+  "version": "0.20.0-3",
   "private": true,
   "license": "UNLICENSED",
   "scripts": {

api-v3/src/act-administration/act-administration.module.ts

@@ -1,22 +1,12 @@
+
 import { Module } from '@nestjs/common';
 import { AuditModule } from '../audit/audit.module';
-import {
-  ActAdministrationController,
-  ActAdministrationQueueController,
-  ActCompanyResponseContentController,
-} from './act-administration.controller';
+import { ActAdministrationController, ActAdministrationQueueController, ActCompanyResponseContentController } from './act-administration.controller';
 import { ActAdministrationService } from './act-administration.service';
-import { FieldBriefingController } from './field-briefing.controller';
-import { FieldBriefingService } from './field-briefing.service';
 
 @Module({
   imports: [AuditModule],
-  controllers: [
-    ActAdministrationQueueController,
-    ActAdministrationController,
-    ActCompanyResponseContentController,
-    FieldBriefingController,
-  ],
-  providers: [ActAdministrationService, FieldBriefingService],
+  controllers: [ActAdministrationQueueController, ActAdministrationController, ActCompanyResponseContentController],
+  providers: [ActAdministrationService],
 })
 export class ActAdministrationModule {}

api-v3/src/act-administration/field-briefing.service.ts

@@ -1,242 +0,0 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
-import { DataSource } from 'typeorm';
-
-export type FieldBriefingActState =
-  | 'ACT_RESPONSE_OVERDUE'
-  | 'ACT_RESPONSE_DUE_SOON'
-  | 'WAITING_RESPONSE'
-  | 'COMPANY_COMMITMENT_OVERDUE'
-  | 'VERIFICATION_PENDING'
-  | 'RESPONSE_RECEIVED';
-
-export interface FieldBriefingFinding {
-  id: string;
-  code: string;
-  title: string;
-  status: string;
-  severity: number | null;
-  nextControlOn: string | null;
-  asset: {
-    id: string;
-    code: string;
-    name: string;
-    typeName: string;
-  };
-}
-
-export interface FieldBriefingAct {
-  actId: string;
-  actCode: string;
-  occurredAt: Date;
-  adminState: FieldBriefingActState;
-  responseDueOn: string | null;
-  responseReceivedOn: string | null;
-  committedCorrectionOn: string | null;
-  latestResponseId: string | null;
-  findings: FieldBriefingFinding[];
-}
-
-@Injectable()
-export class FieldBriefingService {
-  constructor(private readonly dataSource: DataSource) {}
-
-  async forVisit(visitId: string) {
-    const [visit] = (await this.dataSource.query(`
-      SELECT
-        visit.id,
-        visit.code,
-        visit.status,
-        visit.planned_start_at AS "plannedStartAt",
-        visit.operational_area_id AS "areaId",
-        visit.operator_company_id AS "companyId",
-        area.code AS "areaCode",
-        area.name AS "areaName",
-        company.code AS "companyCode",
-        COALESCE(profile.legal_name, company.name) AS "companyName"
-      FROM inspection_visits visit
-      LEFT JOIN assets area ON area.id = visit.operational_area_id
-      LEFT JOIN assets company ON company.id = visit.operator_company_id
-      LEFT JOIN organization_profiles profile ON profile.asset_id = company.id
-      WHERE visit.id = $1
-    `, [visitId])) as Array<Record<string, unknown>>;
-
-    if (!visit) {
-      throw new NotFoundException({
-        code: 'INSPECTION_VISIT_NOT_FOUND',
-        message: 'Inspección no encontrada',
-      });
-    }
-
-    const plannedOn = String(visit.plannedStartAt ?? new Date().toISOString()).slice(0, 10);
-
-    const rows = (await this.dataSource.query(`
-      WITH prior_acts AS (
-        SELECT
-          act.id AS act_id,
-          act.code AS act_code,
-          act.occurred_at,
-          deadline.response_due_on,
-          response.id AS latest_response_id,
-          response.received_on AS response_received_on,
-          response.committed_correction_on,
-          finding.id AS finding_id,
-          finding.code AS finding_code,
-          finding.title AS finding_title,
-          finding.status AS finding_status,
-          finding.severity,
-          finding.next_control_on,
-          asset.id AS asset_id,
-          asset.code AS asset_code,
-          asset.name AS asset_name,
-          asset_type.name AS asset_type_name,
-          CASE
-            WHEN response.id IS NULL
-              AND deadline.response_due_on IS NOT NULL
-              AND deadline.response_due_on < $4::date
-              THEN 'ACT_RESPONSE_OVERDUE'
-            WHEN response.id IS NULL
-              AND deadline.response_due_on IS NOT NULL
-              AND deadline.response_due_on BETWEEN $4::date AND ($4::date + 3)
-              THEN 'ACT_RESPONSE_DUE_SOON'
-            WHEN response.id IS NOT NULL
-              AND response.committed_correction_on IS NOT NULL
-              AND response.committed_correction_on < $4::date
-              THEN 'COMPANY_COMMITMENT_OVERDUE'
-            WHEN response.id IS NOT NULL
-              AND finding.next_control_on IS NULL
-              THEN 'VERIFICATION_PENDING'
-            WHEN response.id IS NOT NULL
-              THEN 'RESPONSE_RECEIVED'
-            ELSE 'WAITING_RESPONSE'
-          END AS admin_state
-        FROM inspection_acts act
-        INNER JOIN inspection_visits source_visit ON source_visit.id = act.visit_id
-        INNER JOIN inspection_findings finding ON finding.act_id = act.id
-          AND finding.status = 'OPEN'
-        INNER JOIN assets asset ON asset.id = finding.asset_id
-        INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id
-        LEFT JOIN LATERAL (
-          SELECT event.response_due_on
-          FROM inspection_act_deadline_events event
-          WHERE event.act_id = act.id
-          ORDER BY event.created_at DESC, event.id DESC
-          LIMIT 1
-        ) deadline ON true
-        LEFT JOIN LATERAL (
-          SELECT company_response.id, company_response.received_on, company_response.committed_correction_on
-          FROM inspection_act_company_responses company_response
-          WHERE company_response.act_id = act.id
-          ORDER BY company_response.received_on DESC, company_response.created_at DESC, company_response.id DESC
-          LIMIT 1
-        ) response ON true
-        WHERE act.status IN ('CLOSED', 'RECTIFIED')
-          AND source_visit.id <> $1
-          AND source_visit.operational_area_id = $2::uuid
-          AND source_visit.operator_company_id = $3::uuid
-      )
-      SELECT *
-      FROM prior_acts
-      WHERE admin_state IN (
-        'ACT_RESPONSE_OVERDUE',
-        'ACT_RESPONSE_DUE_SOON',
-        'COMPANY_COMMITMENT_OVERDUE',
-        'VERIFICATION_PENDING',
-        'RESPONSE_RECEIVED'
-      )
-         OR next_control_on IS NOT NULL
-      ORDER BY
-        CASE admin_state
-          WHEN 'ACT_RESPONSE_OVERDUE' THEN 1
-          WHEN 'COMPANY_COMMITMENT_OVERDUE' THEN 2
-          WHEN 'VERIFICATION_PENDING' THEN 3
-          WHEN 'ACT_RESPONSE_DUE_SOON' THEN 4
-          ELSE 5
-        END,
-        response_due_on NULLS LAST,
-        occurred_at,
-        act_code,
-        finding_code
-    `, [visitId, visit.areaId, visit.companyId, plannedOn])) as Array<{
-      act_id: string;
-      act_code: string;
-      occurred_at: Date;
-      response_due_on: string | null;
-      latest_response_id: string | null;
-      response_received_on: string | null;
-      committed_correction_on: string | null;
-      finding_id: string;
-      finding_code: string;
-      finding_title: string;
-      finding_status: string;
-      severity: number | null;
-      next_control_on: string | null;
-      asset_id: string;
-      asset_code: string;
-      asset_name: string;
-      asset_type_name: string;
-      admin_state: FieldBriefingActState;
-    }>;
-
-    const byAct = new Map<string, FieldBriefingAct>();
-    for (const row of rows) {
-      let act = byAct.get(row.act_id);
-      if (!act) {
-        act = {
-          actId: row.act_id,
-          actCode: row.act_code,
-          occurredAt: row.occurred_at,
-          adminState: row.admin_state,
-          responseDueOn: row.response_due_on,
-          responseReceivedOn: row.response_received_on,
-          committedCorrectionOn: row.committed_correction_on,
-          latestResponseId: row.latest_response_id,
-          findings: [],
-        };
-        byAct.set(row.act_id, act);
-      }
-      act.findings.push({
-        id: row.finding_id,
-        code: row.finding_code,
-        title: row.finding_title,
-        status: row.finding_status,
-        severity: row.severity,
-        nextControlOn: row.next_control_on,
-        asset: {
-          id: row.asset_id,
-          code: row.asset_code,
-          name: row.asset_name,
-          typeName: row.asset_type_name,
-        },
-      });
-    }
-
-    const acts = [...byAct.values()];
-    const assetIds = new Set<string>();
-    let findingCount = 0;
-    for (const act of acts) {
-      findingCount += act.findings.length;
-      for (const finding of act.findings) assetIds.add(finding.asset.id);
-    }
-
-    return {
-      inspection: {
-        id: visit.id,
-        code: visit.code,
-        status: visit.status,
-        plannedStartAt: visit.plannedStartAt,
-        area: visit.areaId ? { id: visit.areaId, code: visit.areaCode, name: visit.areaName } : null,
-        operatorCompany: visit.companyId ? { id: visit.companyId, code: visit.companyCode, name: visit.companyName } : null,
-      },
-      plannedOn,
-      summary: {
-        acts: acts.length,
-        findings: findingCount,
-        inventoryItems: assetIds.size,
-        responseOverdue: acts.filter((item) => item.adminState === 'ACT_RESPONSE_OVERDUE').length,
-        commitmentOverdue: acts.filter((item) => item.adminState === 'COMPANY_COMMITMENT_OVERDUE').length,
-        verificationPending: acts.filter((item) => item.adminState === 'VERIFICATION_PENDING').length,
-      },
-      acts,
-    };
-  }
-}

api-v3/src/app.module.ts

@@ -25,6 +25,7 @@ import { AssetImportsModule } from './asset-imports/asset-imports.module';
 import { InspectionReportsModule } from './inspection-reports/inspection-reports.module';
 import { InspectionVerificationsModule } from './inspection-verifications/inspection-verifications.module';
 import { ActAdministrationModule } from './act-administration/act-administration.module';
+import { FieldBriefingModule } from './field-briefing/field-briefing.module';
 
 function required(config: ConfigService, key: string): string {
   const value = config.get<string>(key);
@@ -78,6 +79,7 @@ function required(config: ConfigService, key: string): string {
     InspectionReportsModule,
     InspectionVerificationsModule,
     ActAdministrationModule,
+    FieldBriefingModule,
     AssetImportsModule,
   ],
   controllers: [HealthController],

api-v3/src/asset-master/asset-master.module.ts

@@ -49,12 +49,6 @@ import { FieldDiscoveryInspectionLinkService } from '../inspection-operations/fi
     AssetRegistryService,
     FieldDiscoveryInspectionLinkService,
   ],
-  exports: [
-    AssetHistoryService,
-    AssetsService,
-    AssetGeometriesService,
-    AssetMediaService,
-    FieldDiscoveryInspectionLinkService,
-  ],
+  exports: [AssetHistoryService],
 })
 export class AssetMasterModule {}

api-v3/src/database/migrations/1788652800000-reset-production-operational-data.ts

@@ -1,173 +0,0 @@
-import { MigrationInterface, QueryRunner } from 'typeorm';
-
-/**
- * One-time production reset requested before the first clean Android rollout.
- *
- * Keeps only structural product configuration plus the single `admin` account.
- * Operational/business data is removed. Recovery is intentionally performed
- * from the deploy PRE backup, not through a synthetic down migration.
- */
-export class ResetProductionOperationalData1788652800000 implements MigrationInterface {
-  name = 'ResetProductionOperationalData1788652800000';
-
-  public async up(queryRunner: QueryRunner): Promise<void> {
-    const adminRows: Array<{ id: string; username: string }> = await queryRunner.query(`
-      SELECT id, username
-      FROM users
-      WHERE lower(trim(username)) = 'admin'
-      ORDER BY id
-    `);
-
-    if (adminRows.length !== 1) {
-      throw new Error(
-        `Production reset aborted: expected exactly one username admin, found ${adminRows.length}`,
-      );
-    }
-
-    const adminId = adminRows[0].id;
-
-    const structuralTables = [
-      'roles',
-      'permissions',
-      'role_permissions',
-      'asset_types',
-      'asset_attribute_definitions',
-      'asset_type_parent_rules',
-      'finding_categories',
-      'finding_catalog_items',
-      'finding_catalog_item_asset_types',
-      'finding_catalog_asset_type_profiles',
-    ];
-
-    // Snapshot structural row counts so TRUNCATE ... CASCADE can never silently
-    // remove product configuration while still leaving operational tables empty.
-    const structuralCounts = new Map<string, string>();
-    for (const table of structuralTables) {
-      const safeTable = `"${table.replace(/"/g, '""')}"`;
-      const rows: Array<{ total: string }> = await queryRunner.query(
-        `SELECT count(*)::text AS total FROM ${safeTable}`,
-      );
-      structuralCounts.set(table, rows[0]?.total ?? '0');
-    }
-
-    const adminRolesBefore: Array<{ total: string }> = await queryRunner.query(
-      `SELECT count(*)::text AS total FROM user_roles WHERE user_id = $1`,
-      [adminId],
-    );
-    const adminRoleCount = adminRolesBefore[0]?.total ?? '0';
-    if (adminRoleCount === '0') {
-      throw new Error('Production reset aborted: admin has no assigned role');
-    }
-
-    // Product configuration that must survive a clean operational start.
-    const preservedTables = new Set([
-      'typeorm_migrations',
-      'users',
-      'user_roles',
-      ...structuralTables,
-    ]);
-
-    const tableRows: Array<{ table_name: string }> = await queryRunner.query(`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = 'public'
-        AND table_type = 'BASE TABLE'
-      ORDER BY table_name
-    `);
-
-    const operationalTables = tableRows
-      .map((row) => row.table_name)
-      .filter((table) => !preservedTables.has(table));
-
-    if (operationalTables.length > 0) {
-      const quoted = operationalTables
-        .map((table) => `"${table.replace(/"/g, '""')}"`)
-        .join(', ');
-      await queryRunner.query(`TRUNCATE TABLE ${quoted} RESTART IDENTITY CASCADE`);
-    }
-
-    // Remove every user except the explicitly validated administrator.
-    // user_roles for removed users follow their FK cascade.
-    await queryRunner.query(`DELETE FROM users WHERE id <> $1`, [adminId]);
-
-    // A reset must invalidate every prior login token, including admin's.
-    // auth_sessions is operational and was truncated above; admin simply logs in again.
-    await queryRunner.query(
-      `
-      UPDATE users
-      SET failed_login_attempts = 0,
-          locked_until = NULL,
-          last_login_at = NULL,
-          updated_at = CURRENT_TIMESTAMP
-      WHERE id = $1
-    `,
-      [adminId],
-    );
-
-    const finalUsers: Array<{ total: string; admins: string }> = await queryRunner.query(`
-      SELECT
-        count(*)::text AS total,
-        count(*) FILTER (WHERE lower(trim(username)) = 'admin')::text AS admins
-      FROM users
-    `);
-
-    if (finalUsers[0]?.total !== '1' || finalUsers[0]?.admins !== '1') {
-      throw new Error('Production reset verification failed: users table is not admin-only');
-    }
-
-    const finalAdminRoles: Array<{ total: string; foreign_users: string }> = await queryRunner.query(
-      `
-      SELECT
-        count(*) FILTER (WHERE user_id = $1)::text AS total,
-        count(*) FILTER (WHERE user_id <> $1)::text AS foreign_users
-      FROM user_roles
-    `,
-      [adminId],
-    );
-
-    if (
-      finalAdminRoles[0]?.total !== adminRoleCount ||
-      finalAdminRoles[0]?.foreign_users !== '0'
-    ) {
-      throw new Error('Production reset verification failed: admin role assignments changed');
-    }
-
-    // Assert every structural table kept exactly the same number of rows.
-    for (const table of structuralTables) {
-      const safeTable = `"${table.replace(/"/g, '""')}"`;
-      const rows: Array<{ total: string }> = await queryRunner.query(
-        `SELECT count(*)::text AS total FROM ${safeTable}`,
-      );
-      const before = structuralCounts.get(table) ?? '0';
-      if (rows[0]?.total !== before) {
-        throw new Error(
-          `Production reset verification failed: structural table ${table} changed (${before} -> ${rows[0]?.total ?? 'unknown'})`,
-        );
-      }
-    }
-
-    // Assert that every operational table is empty. This makes the migration
-    // fail atomically if a table was repopulated during the reset transaction.
-    for (const table of operationalTables) {
-      const safeTable = `"${table.replace(/"/g, '""')}"`;
-      const rows: Array<{ total: string }> = await queryRunner.query(
-        `SELECT count(*)::text AS total FROM ${safeTable}`,
-      );
-      if (rows[0]?.total !== '0') {
-        throw new Error(`Production reset verification failed: ${table} is not empty`);
-      }
-    }
-
-    // Keep a concise server-side record in the migration log for deploy diagnostics.
-    // eslint-disable-next-line no-console
-    console.log(
-      `[production-reset] kept admin=${adminRows[0].username} (${adminId}); preserved ${structuralTables.length} structural tables; cleared ${operationalTables.length} operational tables`,
-    );
-  }
-
-  public async down(): Promise<void> {
-    throw new Error(
-      'ResetProductionOperationalData is irreversible by migration; restore the deploy PRE database backup instead.',
-    );
-  }
-}

api-v3/src/database/migrations/1789668000000-phase-f2-1-field-inventory.ts

@@ -1,197 +0,0 @@
-import { MigrationInterface, QueryRunner } from 'typeorm';
-
-function quoteIdentifier(identifier: string): string {
-  return `"${identifier.replaceAll('"', '""')}"`;
-}
-
-export class PhaseF21FieldInventory1789668000000 implements MigrationInterface {
-  name = 'PhaseF21FieldInventory1789668000000';
-
-  public async up(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(`
-      CREATE TABLE field_inventory_code_sequences (
-        year integer PRIMARY KEY,
-        last_value integer NOT NULL DEFAULT 0,
-        CONSTRAINT chk_field_inventory_code_sequences_year CHECK (year BETWEEN 2000 AND 9999),
-        CONSTRAINT chk_field_inventory_code_sequences_value CHECK (last_value >= 0)
-      )
-    `);
-
-    await queryRunner.query(`
-      CREATE TABLE asset_field_capture_events (
-        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
-        visit_id uuid NOT NULL,
-        asset_id uuid NOT NULL,
-        media_id uuid,
-        event_type varchar(24) NOT NULL,
-        device_latitude numeric(9, 6) NOT NULL,
-        device_longitude numeric(9, 6) NOT NULL,
-        device_accuracy_m numeric(12, 3),
-        device_captured_at timestamptz NOT NULL,
-        device_label varchar(255),
-        exif_latitude numeric(9, 6),
-        exif_longitude numeric(9, 6),
-        exif_captured_at timestamptz,
-        created_by uuid NOT NULL,
-        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        CONSTRAINT fk_asset_field_capture_visit FOREIGN KEY (visit_id)
-          REFERENCES inspection_visits(id) ON DELETE RESTRICT,
-        CONSTRAINT fk_asset_field_capture_asset FOREIGN KEY (asset_id)
-          REFERENCES assets(id) ON DELETE RESTRICT,
-        CONSTRAINT fk_asset_field_capture_media FOREIGN KEY (media_id)
-          REFERENCES asset_media(id) ON DELETE RESTRICT,
-        CONSTRAINT fk_asset_field_capture_created_by FOREIGN KEY (created_by)
-          REFERENCES users(id) ON DELETE RESTRICT,
-        CONSTRAINT chk_asset_field_capture_event_type CHECK (event_type IN ('CREATED','PHOTO')),
-        CONSTRAINT chk_asset_field_capture_device_coordinates CHECK (
-          device_latitude BETWEEN -90 AND 90
-          AND device_longitude BETWEEN -180 AND 180
-        ),
-        CONSTRAINT chk_asset_field_capture_accuracy CHECK (
-          device_accuracy_m IS NULL OR device_accuracy_m BETWEEN 0 AND 100000
-        ),
-        CONSTRAINT chk_asset_field_capture_exif_coordinates CHECK (
-          (exif_latitude IS NULL AND exif_longitude IS NULL)
-          OR (
-            exif_latitude IS NOT NULL
-            AND exif_longitude IS NOT NULL
-            AND exif_latitude BETWEEN -90 AND 90
-            AND exif_longitude BETWEEN -180 AND 180
-          )
-        ),
-        CONSTRAINT chk_asset_field_capture_media_event CHECK (
-          (event_type = 'CREATED' AND media_id IS NULL)
-          OR (event_type = 'PHOTO' AND media_id IS NOT NULL)
-        )
-      )
-    `);
-    await queryRunner.query(`CREATE INDEX idx_asset_field_capture_visit ON asset_field_capture_events (visit_id, created_at, id)`);
-    await queryRunner.query(`CREATE INDEX idx_asset_field_capture_asset ON asset_field_capture_events (asset_id, created_at, id)`);
-    await queryRunner.query(`CREATE UNIQUE INDEX uq_asset_field_capture_media ON asset_field_capture_events (media_id) WHERE media_id IS NOT NULL`);
-
-    await queryRunner.query(`
-      ALTER TABLE inspection_visit_assets
-      DROP CONSTRAINT chk_inspection_visit_assets_planning_source
-    `);
-    await queryRunner.query(`
-      ALTER TABLE inspection_visit_assets
-      ADD CONSTRAINT chk_inspection_visit_assets_planning_source CHECK (
-        planning_source IN ('LEGACY','AUTOMATIC','PREVENTIVE','VERIFICATION','FIELD')
-      )
-    `);
-
-    await queryRunner.query(`
-      ALTER TABLE inspection_visit_asset_events
-      DROP CONSTRAINT chk_inspection_visit_asset_events_type
-    `);
-    await queryRunner.query(`
-      ALTER TABLE inspection_visit_asset_events
-      ADD CONSTRAINT chk_inspection_visit_asset_events_type CHECK (
-        event_type IN ('LEGACY_INCLUDED','AUTO_INCLUDED','PREVENTIVE_INCLUDED','VERIFICATION_INCLUDED','FIELD_INCLUDED','EXCLUDED','REINCLUDED')
-      )
-    `);
-
-    await queryRunner.query(`
-      CREATE OR REPLACE FUNCTION enforce_field_inventory_capture_before_finding()
-      RETURNS trigger
-      LANGUAGE plpgsql
-      AS $$
-      DECLARE
-        finding_visit_id uuid;
-      BEGIN
-        SELECT act.visit_id INTO finding_visit_id
-        FROM inspection_acts act
-        WHERE act.id = NEW.act_id;
-
-        IF finding_visit_id IS NULL THEN
-          RETURN NEW;
-        END IF;
-
-        IF EXISTS (
-          SELECT 1
-          FROM asset_field_discoveries discovery
-          WHERE discovery.visit_id = finding_visit_id
-            AND discovery.asset_id = NEW.asset_id
-        ) THEN
-          IF NOT EXISTS (
-            SELECT 1
-            FROM asset_field_capture_events capture
-            WHERE capture.visit_id = finding_visit_id
-              AND capture.asset_id = NEW.asset_id
-              AND capture.event_type = 'CREATED'
-          ) THEN
-            RAISE EXCEPTION USING
-              ERRCODE = '23514',
-              MESSAGE = 'FIELD_INVENTORY_GPS_REQUIRED';
-          END IF;
-
-          IF NOT EXISTS (
-            SELECT 1
-            FROM asset_field_capture_events capture
-            WHERE capture.visit_id = finding_visit_id
-              AND capture.asset_id = NEW.asset_id
-              AND capture.event_type = 'PHOTO'
-          ) THEN
-            RAISE EXCEPTION USING
-              ERRCODE = '23514',
-              MESSAGE = 'FIELD_INVENTORY_PHOTO_REQUIRED';
-          END IF;
-        END IF;
-
-        RETURN NEW;
-      END
-      $$
-    `);
-    await queryRunner.query(`
-      CREATE TRIGGER trg_inspection_findings_field_capture
-      BEFORE INSERT OR UPDATE OF act_id, asset_id ON inspection_findings
-      FOR EACH ROW
-      EXECUTE FUNCTION enforce_field_inventory_capture_before_finding()
-    `);
-
-    const appRole = process.env.DB_APP_USER;
-    if (!appRole) throw new Error('Missing required environment variable: DB_APP_USER');
-    const applicationRole = quoteIdentifier(appRole);
-    await queryRunner.query(`GRANT SELECT, INSERT, UPDATE ON TABLE field_inventory_code_sequences TO ${applicationRole}`);
-    await queryRunner.query(`GRANT SELECT, INSERT ON TABLE asset_field_capture_events TO ${applicationRole}`);
-    await queryRunner.query(`REVOKE UPDATE, DELETE ON TABLE asset_field_capture_events FROM ${applicationRole}`);
-  }
-
-  public async down(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(`
-      DO $$
-      BEGIN
-        IF EXISTS (SELECT 1 FROM asset_field_capture_events LIMIT 1) THEN
-          RAISE EXCEPTION 'F2.1 no puede revertirse: existen capturas GPS/EXIF de campo';
-        END IF;
-        IF EXISTS (SELECT 1 FROM inspection_visit_assets WHERE planning_source = 'FIELD' LIMIT 1) THEN
-          RAISE EXCEPTION 'F2.1 no puede revertirse: existen registros seleccionados o creados en campo';
-        END IF;
-        IF EXISTS (SELECT 1 FROM inspection_visit_asset_events WHERE event_type = 'FIELD_INCLUDED' LIMIT 1) THEN
-          RAISE EXCEPTION 'F2.1 no puede revertirse: existen eventos de Inventario de campo';
-        END IF;
-      END
-      $$
-    `);
-
-    await queryRunner.query(`DROP TRIGGER IF EXISTS trg_inspection_findings_field_capture ON inspection_findings`);
-    await queryRunner.query(`DROP FUNCTION IF EXISTS enforce_field_inventory_capture_before_finding()`);
-
-    await queryRunner.query(`ALTER TABLE inspection_visit_asset_events DROP CONSTRAINT chk_inspection_visit_asset_events_type`);
-    await queryRunner.query(`
-      ALTER TABLE inspection_visit_asset_events
-      ADD CONSTRAINT chk_inspection_visit_asset_events_type CHECK (
-        event_type IN ('LEGACY_INCLUDED','AUTO_INCLUDED','PREVENTIVE_INCLUDED','VERIFICATION_INCLUDED','EXCLUDED','REINCLUDED')
-      )
-    `);
-    await queryRunner.query(`ALTER TABLE inspection_visit_assets DROP CONSTRAINT chk_inspection_visit_assets_planning_source`);
-    await queryRunner.query(`
-      ALTER TABLE inspection_visit_assets
-      ADD CONSTRAINT chk_inspection_visit_assets_planning_source CHECK (
-        planning_source IN ('LEGACY','AUTOMATIC','PREVENTIVE','VERIFICATION')
-      )
-    `);
-    await queryRunner.query(`DROP TABLE asset_field_capture_events`);
-    await queryRunner.query(`DROP TABLE field_inventory_code_sequences`);
-  }
-}

api-v3/src/field-briefing/field-briefing.controller.ts

@@ -9,6 +9,6 @@ export class FieldBriefingController {
   @Get()
   @RequirePermissions('inspections.read')
   get(@Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string) {
-    return this.briefing.forVisit(visitId);
+    return this.briefing.getForVisit(visitId);
   }
 }

api-v3/src/field-briefing/field-briefing.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { FieldBriefingController } from './field-briefing.controller';
+import { FieldBriefingService } from './field-briefing.service';
+
+@Module({
+  controllers: [FieldBriefingController],
+  providers: [FieldBriefingService],
+})
+export class FieldBriefingModule {}

api-v3/src/field-briefing/field-briefing.service.ts

@@ -0,0 +1,310 @@
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+export type FieldBriefingAdminState =
+  | 'NEW'
+  | 'WAITING_RESPONSE'
+  | 'DUE_SOON'
+  | 'OVERDUE'
+  | 'RESPONSE_RECEIVED'
+  | 'VERIFICATION_PENDING'
+  | 'COMMITMENT_OVERDUE';
+
+export type FieldBriefingReviewState = 'REQUIRED' | 'UPCOMING' | 'CONTEXT';
+
+interface BriefingVisitRow {
+  id: string;
+  code: string;
+  status: string;
+  plannedStartAt: Date | null;
+  areaId: string | null;
+  areaCode: string | null;
+  areaName: string | null;
+  companyId: string | null;
+  companyCode: string | null;
+  companyName: string | null;
+}
+
+interface BriefingFindingRow {
+  sourceActId: string;
+  sourceActCode: string;
+  sourceActOccurredAt: Date;
+  sourceVisitId: string;
+  sourceVisitCode: string;
+  responseDueOn: string | null;
+  responseReceivedOn: string | null;
+  committedCorrectionOn: string | null;
+  latestResponseId: string | null;
+  responseHasPdf: boolean;
+  adminState: FieldBriefingAdminState;
+  reviewState: FieldBriefingReviewState;
+  reviewReason: string;
+  priority: number;
+  findingId: string;
+  findingCode: string;
+  findingTitle: string;
+  severity: number | null;
+  nextControlOn: string | null;
+  latestVerificationOutcome: string | null;
+  assetId: string;
+  assetCode: string;
+  assetName: string;
+  assetTypeName: string;
+}
+
+@Injectable()
+export class FieldBriefingService {
+  constructor(private readonly dataSource: DataSource) {}
+
+  async getForVisit(visitId: string) {
+    const [visit] = (await this.dataSource.query(`
+      SELECT
+        visit.id,
+        visit.code,
+        visit.status,
+        visit.planned_start_at AS "plannedStartAt",
+        visit.operational_area_id AS "areaId",
+        area.code AS "areaCode",
+        area.name AS "areaName",
+        visit.operator_company_id AS "companyId",
+        company.code AS "companyCode",
+        COALESCE(profile.legal_name, company.name) AS "companyName"
+      FROM inspection_visits visit
+      LEFT JOIN assets area ON area.id = visit.operational_area_id
+      LEFT JOIN assets company ON company.id = visit.operator_company_id
+      LEFT JOIN organization_profiles profile ON profile.asset_id = company.id
+      WHERE visit.id = $1
+    `, [visitId])) as BriefingVisitRow[];
+
+    if (!visit) {
+      throw new NotFoundException({
+        code: 'INSPECTION_VISIT_NOT_FOUND',
+        message: 'Inspección no encontrada',
+      });
+    }
+    if (!visit.areaId || !visit.companyId) {
+      throw new BadRequestException({
+        code: 'FIELD_BRIEFING_CONTEXT_REQUIRED',
+        message: 'La inspección debe tener Área y Operadora antes de preparar el paquete de campo',
+      });
+    }
+
+    const referenceAt = visit.plannedStartAt ?? new Date();
+    const referenceDate = referenceAt.toISOString().slice(0, 10);
+
+    const rows = (await this.dataSource.query(`
+      SELECT
+        act.id AS "sourceActId",
+        act.code AS "sourceActCode",
+        act.occurred_at AS "sourceActOccurredAt",
+        source_visit.id AS "sourceVisitId",
+        source_visit.code AS "sourceVisitCode",
+        deadline.response_due_on AS "responseDueOn",
+        response.received_on AS "responseReceivedOn",
+        response.committed_correction_on AS "committedCorrectionOn",
+        response.id AS "latestResponseId",
+        (response.stored_name IS NOT NULL) AS "responseHasPdf",
+        CASE
+          WHEN response.id IS NOT NULL
+            AND response.committed_correction_on IS NOT NULL
+            AND response.committed_correction_on < $5::date
+            THEN 'COMMITMENT_OVERDUE'
+          WHEN response.id IS NOT NULL AND finding.next_control_on IS NULL
+            THEN 'VERIFICATION_PENDING'
+          WHEN response.id IS NOT NULL THEN 'RESPONSE_RECEIVED'
+          WHEN deadline.id IS NULL THEN 'NEW'
+          WHEN deadline.response_due_on < $5::date THEN 'OVERDUE'
+          WHEN deadline.response_due_on <= ($5::date + 3) THEN 'DUE_SOON'
+          ELSE 'WAITING_RESPONSE'
+        END AS "adminState",
+        CASE
+          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
+            AND finding.next_control_on IS NOT NULL
+            AND finding.next_control_on <= $5::date
+            THEN 'REQUIRED'
+          WHEN response.id IS NOT NULL
+            AND response.committed_correction_on IS NOT NULL
+            AND response.committed_correction_on <= $5::date
+            THEN 'REQUIRED'
+          WHEN response.id IS NOT NULL AND finding.next_control_on IS NULL
+            THEN 'REQUIRED'
+          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
+            AND finding.next_control_on IS NOT NULL
+            AND finding.next_control_on <= ($5::date + 30)
+            THEN 'UPCOMING'
+          ELSE 'CONTEXT'
+        END AS "reviewState",
+        CASE
+          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
+            AND finding.next_control_on IS NOT NULL
+            AND finding.next_control_on <= $5::date
+            THEN 'CONTROL_OVERDUE'
+          WHEN response.id IS NOT NULL
+            AND response.committed_correction_on IS NOT NULL
+            AND response.committed_correction_on <= $5::date
+            THEN 'COMMITMENT_REACHED'
+          WHEN response.id IS NOT NULL AND finding.next_control_on IS NULL
+            THEN 'RESPONSE_WITHOUT_CONTROL'
+          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
+            AND finding.next_control_on IS NOT NULL
+            AND finding.next_control_on <= ($5::date + 30)
+            THEN 'CONTROL_UPCOMING'
+          WHEN response.id IS NULL
+            AND deadline.response_due_on IS NOT NULL
+            AND deadline.response_due_on < $5::date
+            THEN 'ADMIN_RESPONSE_OVERDUE'
+          ELSE 'CONTEXT_ONLY'
+        END AS "reviewReason",
+        CASE
+          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
+            AND finding.next_control_on IS NOT NULL
+            AND finding.next_control_on <= $5::date THEN 1
+          WHEN response.id IS NOT NULL
+            AND response.committed_correction_on IS NOT NULL
+            AND response.committed_correction_on <= $5::date THEN 2
+          WHEN response.id IS NOT NULL AND finding.next_control_on IS NULL THEN 3
+          WHEN COALESCE(verification.outcome, '') <> 'RESOLVED'
+            AND finding.next_control_on IS NOT NULL
+            AND finding.next_control_on <= ($5::date + 30) THEN 4
+          WHEN response.id IS NULL
+            AND deadline.response_due_on IS NOT NULL
+            AND deadline.response_due_on < $5::date THEN 5
+          ELSE 6
+        END AS priority,
+        finding.id AS "findingId",
+        finding.code AS "findingCode",
+        finding.title AS "findingTitle",
+        finding.severity,
+        finding.next_control_on AS "nextControlOn",
+        verification.outcome AS "latestVerificationOutcome",
+        asset.id AS "assetId",
+        asset.code AS "assetCode",
+        asset.name AS "assetName",
+        asset_type.name AS "assetTypeName"
+      FROM inspection_acts act
+      INNER JOIN inspection_visits source_visit ON source_visit.id = act.visit_id
+      INNER JOIN inspection_findings finding ON finding.act_id = act.id
+      INNER JOIN assets asset ON asset.id = finding.asset_id
+      INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id
+      LEFT JOIN LATERAL (
+        SELECT event.id, event.response_due_on
+        FROM inspection_act_deadline_events event
+        WHERE event.act_id = act.id
+        ORDER BY event.created_at DESC, event.id DESC
+        LIMIT 1
+      ) deadline ON true
+      LEFT JOIN LATERAL (
+        SELECT company_response.id, company_response.received_on,
+               company_response.committed_correction_on, company_response.stored_name
+        FROM inspection_act_company_responses company_response
+        WHERE company_response.act_id = act.id
+        ORDER BY company_response.received_on DESC,
+                 company_response.created_at DESC,
+                 company_response.id DESC
+        LIMIT 1
+      ) response ON true
+      LEFT JOIN LATERAL (
+        SELECT verification_visit.outcome
+        FROM inspection_finding_verification_visits verification_visit
+        WHERE verification_visit.finding_id = finding.id
+          AND verification_visit.outcome IS NOT NULL
+        ORDER BY verification_visit.result_recorded_at DESC NULLS LAST,
+                 verification_visit.created_at DESC,
+                 verification_visit.id DESC
+        LIMIT 1
+      ) verification ON true
+      WHERE source_visit.operational_area_id = $2
+        AND source_visit.operator_company_id = $3
+        AND source_visit.id <> $1
+        AND act.status IN ('CLOSED', 'RECTIFIED')
+        AND finding.status = 'OPEN'
+        AND COALESCE(act.closed_at, act.occurred_at) <= $4::timestamptz
+      ORDER BY priority, act.occurred_at, act.act_number, finding.finding_number
+    `, [visit.id, visit.areaId, visit.companyId, referenceAt.toISOString(), referenceDate])) as BriefingFindingRow[];
+
+    const actMap = new Map<string, {
+      actId: string;
+      actCode: string;
+      occurredAt: Date;
+      sourceVisit: { id: string; code: string };
+      adminState: FieldBriefingAdminState;
+      responseDueOn: string | null;
+      latestResponse: null | {
+        id: string;
+        receivedOn: string;
+        committedCorrectionOn: string | null;
+        hasPdf: boolean;
+      };
+      findings: Array<Record<string, unknown>>;
+    }>();
+
+    for (const row of rows) {
+      let act = actMap.get(row.sourceActId);
+      if (!act) {
+        act = {
+          actId: row.sourceActId,
+          actCode: row.sourceActCode,
+          occurredAt: row.sourceActOccurredAt,
+          sourceVisit: { id: row.sourceVisitId, code: row.sourceVisitCode },
+          adminState: row.adminState,
+          responseDueOn: row.responseDueOn,
+          latestResponse: row.latestResponseId && row.responseReceivedOn ? {
+            id: row.latestResponseId,
+            receivedOn: row.responseReceivedOn,
+            committedCorrectionOn: row.committedCorrectionOn,
+            hasPdf: Boolean(row.responseHasPdf),
+          } : null,
+          findings: [],
+        };
+        actMap.set(row.sourceActId, act);
+      }
+      act.findings.push({
+        id: row.findingId,
+        code: row.findingCode,
+        title: row.findingTitle,
+        severity: row.severity,
+        nextControlOn: row.nextControlOn,
+        latestVerificationOutcome: row.latestVerificationOutcome,
+        reviewState: row.reviewState,
+        reviewReason: row.reviewReason,
+        priority: Number(row.priority),
+        asset: {
+          id: row.assetId,
+          code: row.assetCode,
+          name: row.assetName,
+          typeName: row.assetTypeName,
+        },
+      });
+    }
+
+    const acts = Array.from(actMap.values());
+    const uniqueAssets = new Set(rows.map((row) => row.assetId));
+    const required = rows.filter((row) => row.reviewState === 'REQUIRED').length;
+    const upcoming = rows.filter((row) => row.reviewState === 'UPCOMING').length;
+    const adminAttention = rows.filter((row) =>
+      ['OVERDUE', 'DUE_SOON', 'COMMITMENT_OVERDUE'].includes(row.adminState),
+    ).length;
+
+    return {
+      visit: {
+        id: visit.id,
+        code: visit.code,
+        status: visit.status,
+        plannedStartAt: visit.plannedStartAt,
+        operationalArea: { id: visit.areaId, code: visit.areaCode, name: visit.areaName },
+        operatorCompany: { id: visit.companyId, code: visit.companyCode, name: visit.companyName },
+      },
+      referenceDate,
+      generatedAt: new Date().toISOString(),
+      summary: {
+        actCount: acts.length,
+        openFindingCount: rows.length,
+        fieldReviewRequired: required,
+        fieldReviewUpcoming: upcoming,
+        administrativeAttention: adminAttention,
+        assetCount: uniqueAssets.size,
+      },
+      acts,
+    };
+  }
+}

api-v3/src/inspection-operations/field-discovery-inspection-link.service.ts

@@ -26,60 +26,19 @@ export class FieldDiscoveryInspectionLinkService {
       [visitId],
     )) as Array<{ id: string; status: string }>;
 
-    const [existing] = (await manager.query(
-      `
-        SELECT included, planning_source AS "planningSource"
-        FROM inspection_visit_assets
-        WHERE visit_id = $1 AND asset_id = $2
-        FOR UPDATE
-      `,
-      [visitId, assetId],
-    )) as Array<{ included: boolean; planningSource: string }>;
 
     await manager.query(
       `
-        INSERT INTO inspection_visit_assets (
-          visit_id, asset_id, included, planning_source, added_by,
-          exclusion_reason, excluded_by, excluded_at
-        )
-        VALUES ($1, $2, true, 'FIELD', $3, NULL, NULL, NULL)
+        INSERT INTO inspection_visit_assets (visit_id, asset_id, included, added_by)
+        VALUES ($1, $2, true, $3)
         ON CONFLICT (visit_id, asset_id) DO UPDATE SET
           included = true,
-          planning_source = CASE
-            WHEN inspection_visit_assets.planning_source IN ('AUTOMATIC','VERIFICATION')
-              THEN inspection_visit_assets.planning_source
-            ELSE 'FIELD'
-          END,
           added_by = EXCLUDED.added_by,
-          exclusion_reason = NULL,
-          excluded_by = NULL,
-          excluded_at = NULL,
           updated_at = CURRENT_TIMESTAMP
       `,
       [visitId, assetId, userId],
     );
 
-    const eventType = existing && existing.included ? null : 'FIELD_INCLUDED';
-    if (eventType) {
-      await manager.query(
-        `
-          INSERT INTO inspection_visit_asset_events (
-            visit_id, asset_id, event_type, actor_user_id, metadata
-          )
-          VALUES ($1, $2, 'FIELD_INCLUDED', $3, $4::jsonb)
-        `,
-        [
-          visitId,
-          assetId,
-          userId,
-          JSON.stringify({
-            fieldSelection: true,
-            previousPlanningSource: existing?.planningSource ?? null,
-          }),
-        ],
-      );
-    }
-
     if (act) {
       await manager.query(
         `

api-v3/src/inspection-visits/dto/create-field-inventory.dto.ts

@@ -1,85 +0,0 @@
-import { Transform, Type } from 'class-transformer';
-import {
-  IsISO8601,
-  IsNumber,
-  IsObject,
-  IsOptional,
-  IsString,
-  IsUUID,
-  Matches,
-  Max,
-  MaxLength,
-  Min,
-  MinLength,
-} from 'class-validator';
-
-export class CreateFieldInventoryDto {
-  @IsUUID('4')
-  typeId!: string;
-
-  @IsOptional()
-  @IsUUID('4')
-  parentId?: string;
-
-  @IsOptional()
-  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim().toUpperCase() : undefined)
-  @IsString()
-  @MaxLength(120)
-  @Matches(/^[A-Z0-9][A-Z0-9._/-]*$/)
-  code?: string;
-
-  @Transform(({ value }) => typeof value === 'string' ? value.trim() : value)
-  @IsString()
-  @MinLength(1)
-  @MaxLength(200)
-  name!: string;
-
-  @IsOptional()
-  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
-  @IsString()
-  @MaxLength(200)
-  commonName?: string | null;
-
-  @IsOptional()
-  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
-  @IsString()
-  @MaxLength(4000)
-  description?: string | null;
-
-  @IsOptional()
-  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
-  @IsString()
-  @MaxLength(4000)
-  discoveryNotes?: string | null;
-
-  @IsObject()
-  attributes!: Record<string, unknown>;
-
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 6 })
-  @Min(-90)
-  @Max(90)
-  deviceLatitude!: number;
-
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 6 })
-  @Min(-180)
-  @Max(180)
-  deviceLongitude!: number;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 3 })
-  @Min(0)
-  @Max(100000)
-  deviceAccuracyM?: number;
-
-  @IsISO8601({ strict: true })
-  deviceCapturedAt!: string;
-
-  @IsOptional()
-  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
-  @IsString()
-  @MaxLength(255)
-  deviceLabel?: string | null;
-}

api-v3/src/inspection-visits/dto/list-field-inventory-query.dto.ts

@@ -1,25 +0,0 @@
-import { Transform, Type } from 'class-transformer';
-import { IsInt, IsOptional, IsString, IsUUID, Max, MaxLength, Min } from 'class-validator';
-
-export class ListFieldInventoryQueryDto {
-  @IsOptional()
-  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : undefined)
-  @IsString()
-  @MaxLength(200)
-  search?: string;
-
-  @IsOptional()
-  @IsUUID('4')
-  parentId?: string;
-
-  @IsOptional()
-  @IsUUID('4')
-  typeId?: string;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(1)
-  @Max(100)
-  limit = 50;
-}

api-v3/src/inspection-visits/dto/upload-field-inventory-photo.dto.ts

@@ -1,70 +0,0 @@
-import { Transform, Type } from 'class-transformer';
-import {
-  IsISO8601,
-  IsNumber,
-  IsOptional,
-  IsString,
-  Max,
-  MaxLength,
-  Min,
-} from 'class-validator';
-
-export class UploadFieldInventoryPhotoDto {
-  @IsOptional()
-  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
-  @IsString()
-  @MaxLength(200)
-  title?: string | null;
-
-  @IsOptional()
-  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
-  @IsString()
-  @MaxLength(4000)
-  description?: string | null;
-
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 6 })
-  @Min(-90)
-  @Max(90)
-  deviceLatitude!: number;
-
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 6 })
-  @Min(-180)
-  @Max(180)
-  deviceLongitude!: number;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 3 })
-  @Min(0)
-  @Max(100000)
-  deviceAccuracyM?: number;
-
-  @IsISO8601({ strict: true })
-  deviceCapturedAt!: string;
-
-  @IsOptional()
-  @Transform(({ value }) => typeof value === 'string' && value.trim() ? value.trim() : null)
-  @IsString()
-  @MaxLength(255)
-  deviceLabel?: string | null;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 6 })
-  @Min(-90)
-  @Max(90)
-  exifLatitude?: number;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsNumber({ maxDecimalPlaces: 6 })
-  @Min(-180)
-  @Max(180)
-  exifLongitude?: number;
-
-  @IsOptional()
-  @IsISO8601({ strict: true })
-  exifCapturedAt?: string;
-}

api-v3/src/inspection-visits/field-inventory.controller.ts

@@ -1,93 +0,0 @@
-import {
-  Body,
-  Controller,
-  Get,
-  Param,
-  ParseUUIDPipe,
-  Post,
-  Query,
-  Req,
-  UploadedFile,
-  UseInterceptors,
-} from '@nestjs/common';
-import { FileInterceptor } from '@nestjs/platform-express';
-import { CurrentAuth } from '../auth/decorators/current-auth.decorator';
-import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
-import { MAX_ASSET_MEDIA_BYTES, type UploadedAssetFile } from '../asset-master/asset-media-file';
-import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import { CreateFieldInventoryDto } from './dto/create-field-inventory.dto';
-import { ListFieldInventoryQueryDto } from './dto/list-field-inventory-query.dto';
-import { UploadFieldInventoryPhotoDto } from './dto/upload-field-inventory-photo.dto';
-import { FieldInventoryService } from './field-inventory.service';
-
-@Controller('inspection-visits/:visitId/field-inventory')
-export class FieldInventoryController {
-  constructor(private readonly fieldInventory: FieldInventoryService) {}
-
-  @Get()
-  @RequirePermissions('assets.read', 'inspections.execute')
-  list(
-    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
-    @Query() query: ListFieldInventoryQueryDto,
-    @CurrentAuth() principal: AuthPrincipal,
-  ) {
-    return this.fieldInventory.list(visitId, query, principal);
-  }
-
-  @Get('types')
-  @RequirePermissions('assets.read', 'inspections.execute')
-  types(
-    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
-    @Query() query: ListFieldInventoryQueryDto,
-    @CurrentAuth() principal: AuthPrincipal,
-  ) {
-    return this.fieldInventory.types(visitId, query.parentId, principal);
-  }
-
-  @Get(':assetId')
-  @RequirePermissions('assets.read', 'inspections.execute')
-  detail(
-    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
-    @Param('assetId', new ParseUUIDPipe({ version: '4' })) assetId: string,
-    @CurrentAuth() principal: AuthPrincipal,
-  ) {
-    return this.fieldInventory.detail(visitId, assetId, principal);
-  }
-
-  @Post(':assetId/select')
-  @RequirePermissions('assets.read', 'inspections.execute')
-  selectExisting(
-    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
-    @Param('assetId', new ParseUUIDPipe({ version: '4' })) assetId: string,
-    @CurrentAuth() principal: AuthPrincipal,
-  ) {
-    return this.fieldInventory.selectExisting(visitId, assetId, principal);
-  }
-
-  @Post()
-  @RequirePermissions('assets.create', 'inspections.execute')
-  create(
-    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
-    @Body() dto: CreateFieldInventoryDto,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.fieldInventory.create(visitId, dto, principal, request);
-  }
-
-  @Post(':assetId/photos')
-  @RequirePermissions('assets.create', 'inspections.execute')
-  @UseInterceptors(FileInterceptor('file', {
-    limits: { fileSize: MAX_ASSET_MEDIA_BYTES, files: 1 },
-  }))
-  uploadPhoto(
-    @Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string,
-    @Param('assetId', new ParseUUIDPipe({ version: '4' })) assetId: string,
-    @Body() dto: UploadFieldInventoryPhotoDto,
-    @UploadedFile() file: UploadedAssetFile | undefined,
-    @CurrentAuth() principal: AuthPrincipal,
-    @Req() request: RequestWithContext,
-  ) {
-    return this.fieldInventory.uploadPhoto(visitId, assetId, dto, file, principal, request);
-  }
-}

api-v3/src/inspection-visits/field-inventory.service.ts

@@ -1,648 +0,0 @@
-import {
-  BadRequestException,
-  ConflictException,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
-import { DataSource } from 'typeorm';
-import { AssetGeometriesService } from '../asset-master/asset-geometries.service';
-import { AssetMediaService, type AssetMediaView } from '../asset-master/asset-media.service';
-import { AssetsService } from '../asset-master/assets.service';
-import type { UploadedAssetFile } from '../asset-master/asset-media-file';
-import type { CreateFieldDiscoveryDto } from '../asset-master/dto/create-field-discovery.dto';
-import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
-import { AssetGeometryType, AssetMediaKind } from '../database/entities';
-import { FieldDiscoveryInspectionLinkService } from '../inspection-operations/field-discovery-inspection-link.service';
-import { assertMobileInspector } from '../inspection-operations/mobile-inspector-policy';
-import type { CreateFieldInventoryDto } from './dto/create-field-inventory.dto';
-import type { ListFieldInventoryQueryDto } from './dto/list-field-inventory-query.dto';
-import type { UploadFieldInventoryPhotoDto } from './dto/upload-field-inventory-photo.dto';
-
-interface MobileVisitContext {
-  id: string;
-  code: string;
-  status: string;
-  areaId: string;
-  areaCode: string;
-  areaName: string;
-  companyId: string;
-  companyCode: string;
-  companyName: string;
-  assigned: boolean;
-}
-
-interface FieldDiscoveryCreated {
-  id: string;
-  asset: {
-    id: string;
-    code: string;
-    name: string;
-    informationStatus: string;
-  };
-}
-
-export interface FieldInventoryCaptureStatus {
-  captureRequired: boolean;
-  hasGeometry: boolean;
-  creationGpsCaptured: boolean;
-  fieldPhotoCount: number;
-  readyForFinding: boolean;
-  latestDeviceCapture: {
-    latitude: number;
-    longitude: number;
-    accuracyM: number | null;
-    capturedAt: Date;
-    deviceLabel: string | null;
-  } | null;
-  latestPhotoExif: {
-    latitude: number | null;
-    longitude: number | null;
-    capturedAt: Date | null;
-  } | null;
-}
-
-@Injectable()
-export class FieldInventoryService {
-  constructor(
-    private readonly dataSource: DataSource,
-    private readonly assets: AssetsService,
-    private readonly geometries: AssetGeometriesService,
-    private readonly media: AssetMediaService,
-    private readonly links: FieldDiscoveryInspectionLinkService,
-  ) {}
-
-  async list(
-    visitId: string,
-    query: ListFieldInventoryQueryDto,
-    principal: AuthPrincipal,
-  ) {
-    const context = await this.requireVisitContext(visitId, principal, false);
-    if (query.parentId) await this.requireParentInContext(query.parentId, context);
-
-    const args: unknown[] = [context.areaId, context.companyId, visitId];
-    const conditions = [
-      'asset.operational_area_id = $1::uuid',
-      'asset.operator_company_id = $2::uuid',
-      "asset.information_status <> 'INACTIVE'",
-    ];
-
-    if (query.search?.trim()) {
-      args.push(`%${query.search.trim()}%`);
-      const p = `$${args.length}`;
-      conditions.push(`(
-        asset.code ILIKE ${p}
-        OR asset.name ILIKE ${p}
-        OR asset.common_name ILIKE ${p}
-        OR EXISTS (
-          SELECT 1
-          FROM asset_attribute_values value
-          JOIN asset_attribute_definitions definition ON definition.id = value.definition_id
-          WHERE value.asset_id = asset.id
-            AND definition.is_active = true
-            AND (value.value #>> '{}') ILIKE ${p}
-        )
-      )`);
-    }
-
-    if (query.parentId) {
-      args.push(query.parentId);
-      conditions.push(`asset.parent_id = $${args.length}::uuid`);
-    }
-    if (query.typeId) {
-      args.push(query.typeId);
-      conditions.push(`asset.asset_type_id = $${args.length}::uuid`);
-    }
-
-    args.push(query.limit);
-    const limit = `$${args.length}`;
-    const data = await this.dataSource.query(`
-      SELECT
-        asset.id,
-        asset.code,
-        asset.name,
-        asset.common_name AS "commonName",
-        asset.information_status AS "informationStatus",
-        asset.data_origin AS "dataOrigin",
-        JSONB_BUILD_OBJECT('id', type.id, 'code', type.code, 'name', type.name) AS type,
-        CASE WHEN parent.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
-          'id', parent.id, 'code', parent.code, 'name', parent.name
-        ) END AS parent,
-        EXISTS (
-          SELECT 1 FROM inspection_visit_assets link
-          WHERE link.visit_id = $3::uuid
-            AND link.asset_id = asset.id
-            AND link.included = true
-        ) AS "selectedInInspection",
-        EXISTS (
-          SELECT 1 FROM asset_field_discoveries discovery
-          WHERE discovery.visit_id = $3::uuid AND discovery.asset_id = asset.id
-        ) AS "captureRequired",
-        EXISTS (
-          SELECT 1 FROM asset_geometries geometry WHERE geometry.asset_id = asset.id
-        ) AS "hasGeometry",
-        (
-          SELECT COUNT(*)::integer
-          FROM asset_field_capture_events capture
-          WHERE capture.visit_id = $3::uuid
-            AND capture.asset_id = asset.id
-            AND capture.event_type = 'PHOTO'
-        ) AS "fieldPhotoCount",
-        (
-          NOT EXISTS (
-            SELECT 1 FROM asset_field_discoveries discovery
-            WHERE discovery.visit_id = $3::uuid AND discovery.asset_id = asset.id
-          )
-          OR (
-            EXISTS (SELECT 1 FROM asset_geometries geometry WHERE geometry.asset_id = asset.id)
-            AND EXISTS (
-              SELECT 1 FROM asset_field_capture_events capture
-              WHERE capture.visit_id = $3::uuid
-                AND capture.asset_id = asset.id
-                AND capture.event_type = 'CREATED'
-            )
-            AND EXISTS (
-              SELECT 1 FROM asset_field_capture_events capture
-              WHERE capture.visit_id = $3::uuid
-                AND capture.asset_id = asset.id
-                AND capture.event_type = 'PHOTO'
-            )
-          )
-        ) AS "readyForFinding"
-      FROM assets asset
-      JOIN asset_types type ON type.id = asset.asset_type_id
-      LEFT JOIN assets parent ON parent.id = asset.parent_id
-      WHERE ${conditions.join(' AND ')}
-      ORDER BY asset.name, asset.code
-      LIMIT ${limit}
-    `, args);
-
-    return { context: this.publicContext(context), data };
-  }
-
-  async types(
-    visitId: string,
-    parentId: string | undefined,
-    principal: AuthPrincipal,
-  ) {
-    const context = await this.requireVisitContext(visitId, principal, false);
-    const effectiveParentId = parentId ?? context.areaId;
-    const parent = await this.requireParentInContext(effectiveParentId, context);
-
-    const data = await this.dataSource.query(`
-      SELECT
-        type.id,
-        type.code,
-        type.name,
-        type.description,
-        COALESCE(
-          JSONB_AGG(
-            JSONB_BUILD_OBJECT(
-              'id', definition.id,
-              'code', definition.code,
-              'name', definition.name,
-              'dataType', definition.data_type,
-              'isRequired', definition.is_required,
-              'unit', definition.unit,
-              'options', definition.options,
-              'sortOrder', definition.sort_order
-            ) ORDER BY definition.sort_order, definition.name
-          ) FILTER (WHERE definition.id IS NOT NULL),
-          '[]'::jsonb
-        ) AS attributes
-      FROM asset_type_parent_rules rule
-      JOIN asset_types type ON type.id = rule.child_type_id
-      LEFT JOIN asset_attribute_definitions definition
-        ON definition.asset_type_id = type.id
-       AND definition.is_active = true
-      WHERE rule.parent_type_id = $1::uuid
-        AND type.is_active = true
-        AND type.operational_role = 'GENERIC'
-      GROUP BY type.id, type.code, type.name, type.description
-      ORDER BY type.name, type.code
-    `, [parent.typeId]);
-
-    return {
-      context: this.publicContext(context),
-      parent: { id: parent.id, code: parent.code, name: parent.name },
-      data,
-    };
-  }
-
-  async detail(visitId: string, assetId: string, principal: AuthPrincipal) {
-    const context = await this.requireVisitContext(visitId, principal, false);
-    await this.requireAssetInContext(assetId, context);
-    return {
-      context: this.publicContext(context),
-      asset: await this.assets.getById(assetId),
-      selectedInInspection: await this.isSelected(visitId, assetId),
-      capture: await this.captureStatus(visitId, assetId),
-    };
-  }
-
-  async selectExisting(
-    visitId: string,
-    assetId: string,
-    principal: AuthPrincipal,
-  ) {
-    const context = await this.requireVisitContext(visitId, principal, true);
-    await this.requireAssetInContext(assetId, context);
-    await this.dataSource.transaction((manager) =>
-      this.links.attach(manager, visitId, assetId, principal.userId),
-    );
-    return this.detail(visitId, assetId, principal);
-  }
-
-  async create(
-    visitId: string,
-    dto: CreateFieldInventoryDto,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ) {
-    const context = await this.requireVisitContext(visitId, principal, true);
-    const parentId = dto.parentId ?? context.areaId;
-    await this.requireParentInContext(parentId, context);
-
-    const capturedAt = new Date(dto.deviceCapturedAt);
-    if (!Number.isFinite(capturedAt.getTime())) {
-      throw new BadRequestException({
-        code: 'FIELD_INVENTORY_INVALID_CAPTURE_DATE',
-        message: 'La fecha de captura del dispositivo no es válida',
-      });
-    }
-
-    const code = dto.code?.trim().toUpperCase() || await this.nextFieldCode(capturedAt);
-    const discoveryDto: CreateFieldDiscoveryDto = {
-      visitId,
-      code,
-      name: dto.name,
-      commonName: dto.commonName ?? null,
-      typeId: dto.typeId,
-      parentId,
-      operationalAreaId: context.areaId,
-      operatorCompanyId: context.companyId,
-      description: dto.description ?? null,
-      discoveryNotes: dto.discoveryNotes ?? null,
-      attributes: dto.attributes,
-    };
-
-    const discovery = await this.assets.createFieldDiscovery(
-      discoveryDto,
-      principal,
-      request,
-    ) as FieldDiscoveryCreated;
-    const assetId = discovery.asset?.id;
-    if (!assetId) {
-      throw new Error('El alta de campo no devolvió el identificador del Inventario creado');
-    }
-
-    await this.geometries.upsert(assetId, {
-      geometry: {
-        type: AssetGeometryType.POINT,
-        coordinates: [dto.deviceLongitude, dto.deviceLatitude],
-      },
-      accuracyM: dto.deviceAccuracyM ?? null,
-      capturedAt: dto.deviceCapturedAt,
-      deviceLabel: dto.deviceLabel ?? null,
-    }, principal, request);
-
-    await this.dataSource.query(`
-      INSERT INTO asset_field_capture_events (
-        visit_id, asset_id, event_type,
-        device_latitude, device_longitude, device_accuracy_m,
-        device_captured_at, device_label, created_by
-      ) VALUES ($1,$2,'CREATED',$3,$4,$5,$6,$7,$8)
-    `, [
-      visitId,
-      assetId,
-      dto.deviceLatitude,
-      dto.deviceLongitude,
-      dto.deviceAccuracyM ?? null,
-      capturedAt,
-      dto.deviceLabel ?? null,
-      principal.userId,
-    ]);
-
-    return this.detail(visitId, assetId, principal);
-  }
-
-  async uploadPhoto(
-    visitId: string,
-    assetId: string,
-    dto: UploadFieldInventoryPhotoDto,
-    file: UploadedAssetFile | undefined,
-    principal: AuthPrincipal,
-    request: RequestWithContext,
-  ): Promise<{ media: AssetMediaView; capture: FieldInventoryCaptureStatus }> {
-    const context = await this.requireVisitContext(visitId, principal, true);
-    await this.requireAssetInContext(assetId, context);
-    if (!await this.isSelected(visitId, assetId)) {
-      throw new ConflictException({
-        code: 'FIELD_INVENTORY_NOT_SELECTED',
-        message: 'Seleccioná el registro dentro de la inspección antes de agregar fotografías',
-      });
-    }
-
-    const exifHasLatitude = dto.exifLatitude !== undefined;
-    const exifHasLongitude = dto.exifLongitude !== undefined;
-    if (exifHasLatitude !== exifHasLongitude) {
-      throw new BadRequestException({
-        code: 'FIELD_PHOTO_EXIF_COORDINATES_INCOMPLETE',
-        message: 'Las coordenadas EXIF deben incluir latitud y longitud juntas',
-      });
-    }
-
-    const uploaded = await this.media.upload(assetId, {
-      kind: AssetMediaKind.PHOTO,
-      title: dto.title ?? undefined,
-      description: dto.description ?? undefined,
-      capturedAt: dto.deviceCapturedAt,
-      latitude: dto.deviceLatitude,
-      longitude: dto.deviceLongitude,
-      accuracyM: dto.deviceAccuracyM,
-    }, file, principal, request);
-
-    await this.dataSource.query(`
-      INSERT INTO asset_field_capture_events (
-        visit_id, asset_id, media_id, event_type,
-        device_latitude, device_longitude, device_accuracy_m,
-        device_captured_at, device_label,
-        exif_latitude, exif_longitude, exif_captured_at,
-        created_by
-      ) VALUES ($1,$2,$3,'PHOTO',$4,$5,$6,$7,$8,$9,$10,$11,$12)
-    `, [
-      visitId,
-      assetId,
-      uploaded.id,
-      dto.deviceLatitude,
-      dto.deviceLongitude,
-      dto.deviceAccuracyM ?? null,
-      new Date(dto.deviceCapturedAt),
-      dto.deviceLabel ?? null,
-      dto.exifLatitude ?? null,
-      dto.exifLongitude ?? null,
-      dto.exifCapturedAt ? new Date(dto.exifCapturedAt) : null,
-      principal.userId,
-    ]);
-
-    return { media: uploaded, capture: await this.captureStatus(visitId, assetId) };
-  }
-
-  private async requireVisitContext(
-    visitId: string,
-    principal: AuthPrincipal,
-    requireInProgress: boolean,
-  ): Promise<MobileVisitContext> {
-    assertMobileInspector(principal);
-    const [context] = (await this.dataSource.query(`
-      SELECT
-        visit.id,
-        visit.code,
-        visit.status,
-        visit.operational_area_id AS "areaId",
-        area.code AS "areaCode",
-        area.name AS "areaName",
-        visit.operator_company_id AS "companyId",
-        company.code AS "companyCode",
-        company.name AS "companyName",
-        (
-          visit.lead_inspector_user_id = $2::uuid
-          OR EXISTS (
-            SELECT 1
-            FROM inspection_visit_members member
-            WHERE member.visit_id = visit.id
-              AND member.user_id = $2::uuid
-              AND member.included = true
-          )
-        ) AS assigned
-      FROM inspection_visits visit
-      LEFT JOIN assets area ON area.id = visit.operational_area_id
-      LEFT JOIN assets company ON company.id = visit.operator_company_id
-      WHERE visit.id = $1::uuid
-    `, [visitId, principal.userId])) as MobileVisitContext[];
-
-    if (!context) {
-      throw new NotFoundException({ code: 'INSPECTION_VISIT_NOT_FOUND', message: 'Inspección no encontrada' });
-    }
-    if (!context.areaId || !context.companyId) {
-      throw new ConflictException({
-        code: 'FIELD_INVENTORY_CONTEXT_REQUIRED',
-        message: 'La inspección no tiene Área y Operadora definidas',
-      });
-    }
-    if (!context.assigned) {
-      throw new ConflictException({
-        code: 'FIELD_INVENTORY_INSPECTOR_NOT_ASSIGNED',
-        message: 'El inspector no está asignado a esta inspección',
-      });
-    }
-    if (requireInProgress && context.status !== 'IN_PROGRESS') {
-      throw new ConflictException({
-        code: 'FIELD_INVENTORY_VISIT_NOT_IN_PROGRESS',
-        message: 'El Inventario sólo puede modificarse cuando la inspección está en curso',
-      });
-    }
-    if (!requireInProgress && !['PLANNED', 'IN_PROGRESS'].includes(context.status)) {
-      throw new ConflictException({
-        code: 'FIELD_INVENTORY_VISIT_NOT_AVAILABLE',
-        message: 'El Inventario de campo está disponible para inspecciones planificadas o en curso',
-      });
-    }
-    return context;
-  }
-
-  private publicContext(context: MobileVisitContext) {
-    return {
-      inspection: { id: context.id, code: context.code, status: context.status },
-      area: { id: context.areaId, code: context.areaCode, name: context.areaName },
-      operatorCompany: {
-        id: context.companyId,
-        code: context.companyCode,
-        name: context.companyName,
-      },
-    };
-  }
-
-  private async requireParentInContext(parentId: string, context: MobileVisitContext) {
-    const [parent] = (await this.dataSource.query(`
-      SELECT
-        asset.id,
-        asset.code,
-        asset.name,
-        asset.asset_type_id AS "typeId",
-        asset.operational_area_id AS "areaId",
-        asset.operator_company_id AS "companyId"
-      FROM assets asset
-      WHERE asset.id = $1::uuid
-        AND asset.information_status <> 'INACTIVE'
-    `, [parentId])) as Array<{
-      id: string;
-      code: string;
-      name: string;
-      typeId: string;
-      areaId: string | null;
-      companyId: string | null;
-    }>;
-
-    if (!parent) {
-      throw new NotFoundException({
-        code: 'FIELD_INVENTORY_PARENT_NOT_FOUND',
-        message: 'La ubicación padre no existe',
-      });
-    }
-    if (
-      parent.id !== context.areaId
-      && (parent.areaId !== context.areaId || parent.companyId !== context.companyId)
-    ) {
-      throw new BadRequestException({
-        code: 'FIELD_INVENTORY_PARENT_OUTSIDE_CONTEXT',
-        message: 'La ubicación padre no pertenece al Área y Operadora de la inspección',
-      });
-    }
-    return parent;
-  }
-
-  private async requireAssetInContext(assetId: string, context: MobileVisitContext) {
-    const [asset] = (await this.dataSource.query(`
-      SELECT id,
-             operational_area_id AS "areaId",
-             operator_company_id AS "companyId"
-      FROM assets
-      WHERE id = $1::uuid
-        AND information_status <> 'INACTIVE'
-    `, [assetId])) as Array<{
-      id: string;
-      areaId: string | null;
-      companyId: string | null;
-    }>;
-
-    if (!asset) {
-      throw new NotFoundException({
-        code: 'FIELD_INVENTORY_NOT_FOUND',
-        message: 'Registro de Inventario no encontrado',
-      });
-    }
-    if (asset.areaId !== context.areaId || asset.companyId !== context.companyId) {
-      throw new BadRequestException({
-        code: 'FIELD_INVENTORY_OUTSIDE_CONTEXT',
-        message: 'El registro no pertenece al Área y Operadora de esta inspección',
-      });
-    }
-    return asset;
-  }
-
-  private async isSelected(visitId: string, assetId: string): Promise<boolean> {
-    const rows = await this.dataSource.query(`
-      SELECT 1
-      FROM inspection_visit_assets
-      WHERE visit_id = $1::uuid
-        AND asset_id = $2::uuid
-        AND included = true
-    `, [visitId, assetId]) as unknown[];
-    return rows.length > 0;
-  }
-
-  private async captureStatus(
-    visitId: string,
-    assetId: string,
-  ): Promise<FieldInventoryCaptureStatus> {
-    const [row] = (await this.dataSource.query(`
-      SELECT
-        EXISTS (
-          SELECT 1
-          FROM asset_field_discoveries discovery
-          WHERE discovery.visit_id = $1::uuid
-            AND discovery.asset_id = $2::uuid
-        ) AS "captureRequired",
-        EXISTS (
-          SELECT 1 FROM asset_geometries geometry WHERE geometry.asset_id = $2::uuid
-        ) AS "hasGeometry",
-        EXISTS (
-          SELECT 1
-          FROM asset_field_capture_events event
-          WHERE event.visit_id = $1::uuid
-            AND event.asset_id = $2::uuid
-            AND event.event_type = 'CREATED'
-        ) AS "creationGpsCaptured",
-        (
-          SELECT COUNT(*)::integer
-          FROM asset_field_capture_events event
-          WHERE event.visit_id = $1::uuid
-            AND event.asset_id = $2::uuid
-            AND event.event_type = 'PHOTO'
-        ) AS "fieldPhotoCount",
-        (
-          SELECT JSONB_BUILD_OBJECT(
-            'latitude', event.device_latitude,
-            'longitude', event.device_longitude,
-            'accuracyM', event.device_accuracy_m,
-            'capturedAt', event.device_captured_at,
-            'deviceLabel', event.device_label
-          )
-          FROM asset_field_capture_events event
-          WHERE event.visit_id = $1::uuid
-            AND event.asset_id = $2::uuid
-          ORDER BY event.device_captured_at DESC, event.created_at DESC, event.id DESC
-          LIMIT 1
-        ) AS "latestDeviceCapture",
-        (
-          SELECT JSONB_BUILD_OBJECT(
-            'latitude', event.exif_latitude,
-            'longitude', event.exif_longitude,
-            'capturedAt', event.exif_captured_at
-          )
-          FROM asset_field_capture_events event
-          WHERE event.visit_id = $1::uuid
-            AND event.asset_id = $2::uuid
-            AND event.event_type = 'PHOTO'
-          ORDER BY event.device_captured_at DESC, event.created_at DESC, event.id DESC
-          LIMIT 1
-        ) AS "latestPhotoExif"
-    `, [visitId, assetId])) as Array<{
-      captureRequired: boolean;
-      hasGeometry: boolean;
-      creationGpsCaptured: boolean;
-      fieldPhotoCount: number;
-      latestDeviceCapture: FieldInventoryCaptureStatus['latestDeviceCapture'];
-      latestPhotoExif: FieldInventoryCaptureStatus['latestPhotoExif'];
-    }>;
-
-    const captureRequired = Boolean(row?.captureRequired);
-    const hasGeometry = Boolean(row?.hasGeometry);
-    const creationGpsCaptured = Boolean(row?.creationGpsCaptured);
-    const fieldPhotoCount = Number(row?.fieldPhotoCount ?? 0);
-
-    return {
-      captureRequired,
-      hasGeometry,
-      creationGpsCaptured,
-      fieldPhotoCount,
-      readyForFinding: !captureRequired || (
-        hasGeometry && creationGpsCaptured && fieldPhotoCount > 0
-      ),
-      latestDeviceCapture: row?.latestDeviceCapture ?? null,
-      latestPhotoExif: row?.latestPhotoExif ?? null,
-    };
-  }
-
-  private async nextFieldCode(observedAt: Date): Promise<string> {
-    const year = observedAt.getUTCFullYear();
-    if (!Number.isInteger(year) || year < 2000 || year > 9999) {
-      throw new BadRequestException({
-        code: 'FIELD_INVENTORY_INVALID_CAPTURE_DATE',
-        message: 'La fecha de captura no es válida para generar el código',
-      });
-    }
-
-    const [row] = (await this.dataSource.query(`
-      INSERT INTO field_inventory_code_sequences (year, last_value)
-      VALUES ($1, 1)
-      ON CONFLICT (year)
-      DO UPDATE SET last_value = field_inventory_code_sequences.last_value + 1
-      RETURNING last_value AS value
-    `, [year])) as Array<{ value: number }>;
-
-    const value = Number(row?.value ?? 0);
-    if (!value) throw new Error('No se pudo generar el código de Inventario de campo');
-    return `CAM-${year}-${String(value).padStart(6, '0')}`;
-  }
-}

api-v3/src/inspection-visits/inspection-visits.module.ts

@@ -1,14 +1,11 @@
 import { Module } from '@nestjs/common';
-import { AssetMasterModule } from '../asset-master/asset-master.module';
 import { AuditModule } from '../audit/audit.module';
-import { FieldInventoryController } from './field-inventory.controller';
-import { FieldInventoryService } from './field-inventory.service';
 import { InspectionVisitsController } from './inspection-visits.controller';
 import { InspectionVisitsService } from './inspection-visits.service';
 
 @Module({
-  imports: [AuditModule, AssetMasterModule],
-  controllers: [InspectionVisitsController, FieldInventoryController],
-  providers: [InspectionVisitsService, FieldInventoryService],
+  imports: [AuditModule],
+  controllers: [InspectionVisitsController],
+  providers: [InspectionVisitsService],
 })
 export class InspectionVisitsModule {}

api-v3/src/version.ts

@@ -1,2 +1,2 @@
-export const API_VERSION = '0.21.0-2';
-export const API_PHASE = 'F2.1';
+export const API_VERSION = '0.20.0-3';
+export const API_PHASE = 'F1.3';

api-v3/test/unit/field-inventory-f2-1.test.ts

@@ -1,67 +0,0 @@
-import 'reflect-metadata';
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { readFileSync } from 'node:fs';
-import { validate } from 'class-validator';
-import { plainToInstance } from 'class-transformer';
-import { FieldInventoryController } from '../../src/inspection-visits/field-inventory.controller';
-import { CreateFieldInventoryDto } from '../../src/inspection-visits/dto/create-field-inventory.dto';
-import { UploadFieldInventoryPhotoDto } from '../../src/inspection-visits/dto/upload-field-inventory-photo.dto';
-import { REQUIRED_PERMISSIONS_KEY } from '../../src/authorization/decorators/require-permissions.decorator';
-
-function permissions(method: string): string[] {
-  const controller = FieldInventoryController.prototype;
-  const handler = controller[method as keyof typeof controller];
-  return Reflect.getMetadata(REQUIRED_PERMISSIONS_KEY, handler) as string[];
-}
-
-test('F2.1 mantiene Inventario de campo bajo política móvil y permisos explícitos', () => {
-  assert.deepEqual(permissions('list'), ['assets.read', 'inspections.execute']);
-  assert.deepEqual(permissions('types'), ['assets.read', 'inspections.execute']);
-  assert.deepEqual(permissions('selectExisting'), ['assets.read', 'inspections.execute']);
-  assert.deepEqual(permissions('create'), ['assets.create', 'inspections.execute']);
-  assert.deepEqual(permissions('uploadPhoto'), ['assets.create', 'inspections.execute']);
-});
-
-test('F2.1 exige GPS del dispositivo al crear Inventario en campo', async () => {
-  const dto = plainToInstance(CreateFieldInventoryDto, {
-    typeId: '11111111-1111-4111-8111-111111111111',
-    name: 'Batería 28',
-    attributes: {},
-    deviceCapturedAt: '2026-09-05T17:30:00-03:00',
-  });
-  const errors = await validate(dto);
-  const properties = new Set(errors.map((error) => error.property));
-  assert.equal(properties.has('deviceLatitude'), true);
-  assert.equal(properties.has('deviceLongitude'), true);
-});
-
-test('F2.1 exige GPS del dispositivo en cada fotografía de campo', async () => {
-  const dto = plainToInstance(UploadFieldInventoryPhotoDto, {
-    deviceCapturedAt: '2026-09-05T17:30:00-03:00',
-  });
-  const errors = await validate(dto);
-  const properties = new Set(errors.map((error) => error.property));
-  assert.equal(properties.has('deviceLatitude'), true);
-  assert.equal(properties.has('deviceLongitude'), true);
-});
-
-test('F2.1 deriva Área y Operadora desde la Inspección y usa el asset anidado del alta provisional', () => {
-  const source = readFileSync('src/inspection-visits/field-inventory.service.ts', 'utf8');
-  assert.match(source, /visit\.operational_area_id AS \"areaId\"/);
-  assert.match(source, /visit\.operator_company_id AS \"companyId\"/);
-  assert.match(source, /operationalAreaId: context\.areaId/);
-  assert.match(source, /operatorCompanyId: context\.companyId/);
-  assert.match(source, /const assetId = discovery\.asset\?\.id/);
-});
-
-test('F2.1 bloquea hallazgos sobre altas de campo hasta tener GPS y foto', () => {
-  const migration = readFileSync(
-    'src/database/migrations/1789668000000-phase-f2-1-field-inventory.ts',
-    'utf8',
-  );
-  assert.match(migration, /enforce_field_inventory_capture_before_finding/);
-  assert.match(migration, /FIELD_INVENTORY_GPS_REQUIRED/);
-  assert.match(migration, /FIELD_INVENTORY_PHOTO_REQUIRED/);
-  assert.match(migration, /REVOKE UPDATE, DELETE ON TABLE asset_field_capture_events/);
-});

api-v3/test/unit/phase-f1-3-field-briefing.test.ts

@@ -1,30 +1,37 @@
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
-import { test } from 'node:test';
+import { resolve } from 'node:path';
+import test from 'node:test';
 
-const service = readFileSync('src/act-administration/field-briefing.service.ts', 'utf8');
-const controller = readFileSync('src/act-administration/field-briefing.controller.ts', 'utf8');
-const moduleSource = readFileSync('src/act-administration/act-administration.module.ts', 'utf8');
+const source = (path: string) => readFileSync(resolve(process.cwd(), path), 'utf8');
+const service = source('src/field-briefing/field-briefing.service.ts');
+const controller = source('src/field-briefing/field-briefing.controller.ts');
 
-test('F1.3 agrupa pendientes de campo por Acta y Hallazgo', () => {
+test('F1.3 prepares field briefing from prior Acts in the same operational context', () => {
+  assert.match(service, /source_visit\.operational_area_id = \$2/);
+  assert.match(service, /source_visit\.operator_company_id = \$3/);
+  assert.match(service, /source_visit\.id <> \$1/);
+});
+
+test('F1.3 uses Act-level deadline and company response ledgers', () => {
   assert.match(service, /inspection_act_deadline_events/);
   assert.match(service, /inspection_act_company_responses/);
-  assert.match(service, /source_visit\.operational_area_id = \$2::uuid/);
-  assert.match(service, /source_visit\.operator_company_id = \$3::uuid/);
-  assert.match(service, /ACT_RESPONSE_OVERDUE/);
-  assert.match(service, /COMPANY_COMMITMENT_OVERDUE/);
-  assert.match(service, /VERIFICATION_PENDING/);
-  assert.match(service, /findings: \[\]/);
+  assert.doesNotMatch(service, /company_response_received_on/);
 });
 
-test('F1.3 expone el briefing para una inspección planificada', () => {
-  assert.match(controller, /inspection-visits\/:visitId\/field-briefing/);
-  assert.match(controller, /RequirePermissions\('inspections\.read'\)/);
-  assert.match(moduleSource, /FieldBriefingController/);
-  assert.match(moduleSource, /FieldBriefingService/);
+test('F1.3 only turns open findings from closed Acts into pending field context', () => {
+  assert.match(service, /act\.status IN \('CLOSED', 'RECTIFIED'\)/);
+  assert.match(service, /finding\.status = 'OPEN'/);
 });
 
-test('F1.3 no usa el plazo del Hallazgo como plazo administrativo', () => {
-  assert.doesNotMatch(service, /correction_due_on/);
-  assert.match(service, /deadline\.response_due_on/);
+test('F1.3 separates required field review, upcoming review and administrative context', () => {
+  assert.match(service, /'REQUIRED'/);
+  assert.match(service, /'UPCOMING'/);
+  assert.match(service, /'CONTEXT'/);
+  assert.match(service, /ADMIN_RESPONSE_OVERDUE/);
+});
+
+test('F1.3 exposes the briefing through the inspection read contract', () => {
+  assert.match(controller, /field-briefing/);
+  assert.match(controller, /inspections\.read/);
 });

docs/f1-3-planning-scope.md

@@ -1,11 +0,0 @@
-# F1.3 · Planificación inteligente de pendientes
-
-Objetivo: al planificar una inspección para un Área/Yacimiento + Operadora, generar un paquete de campo con pendientes administrativos y operativos provenientes de Actas anteriores del mismo contexto.
-
-Reglas:
-- La unidad administrativa es el Acta.
-- Los hallazgos se muestran dentro de su Acta de origen.
-- El checklist de planificación incluye Actas con respuesta vencida o por vencer, respuestas de empresa con fecha comprometida de regularización, y hallazgos con control/verificación pendiente.
-- El inspector puede ver antecedentes antes de salir y en la APK.
-- La planificación no modifica ni cierra Actas/hallazgos previos.
-- La verificación en campo se registra append-only.

web-v2/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhv2-web",
-  "version": "0.20.0-4",
+  "version": "0.20.0-3",
   "private": true,
   "type": "module",
   "engines": {

web-v2/src/app/App.tsx

@@ -37,8 +37,8 @@ import { ActAdministrationDetailPage } from '../pages/ActAdministrationDetailPag
 import { FieldBriefingsPage } from '../pages/FieldBriefingsPage';
 
 const MapPage = lazy(() => import('../pages/MapPage').then((module) => ({ default: module.MapPage })));
-
 const DocumentDeliveryPage = lazy(() => import('../pages/DocumentDeliveryPage').then((module) => ({ default: module.DocumentDeliveryPage })));
+
 export function App() {
   return <Suspense fallback={<div className="loading-block"><span className="spinner" />Cargando módulo…</div>}><Routes>
     <Route path="/login" element={<LoginPage />} />

web-v2/src/config/version.ts

@@ -1,2 +1,2 @@
-export const APP_VERSION = '0.20.0-4';
-export const APP_PHASE = 'Fase F1.4 · Briefing contextual antes de salir';
+export const APP_VERSION = '0.20.0-3';
+export const APP_PHASE = 'Fase F1.3 · Preparación inteligente de campo';

web-v2/src/features/inspections/FieldBriefingPanel.tsx

@@ -1,97 +0,0 @@
-import { useEffect, useState } from 'react';
-import { Link } from 'react-router';
-import { Alert, EmptyState, LoadingBlock, errorMessage } from '../../components/Feedback';
-import { Icon } from '../../components/Icon';
-import type { InspectionVisit } from '../../lib/api';
-import { formatDate, formatDateOnly } from '../../lib/format';
-import {
-  getInspectionFieldBriefing,
-  type FieldBriefing,
-  type FieldBriefingActState,
-} from './fieldBriefingApi';
-
-function stateLabel(state: FieldBriefingActState): string {
-  if (state === 'ACT_RESPONSE_OVERDUE') return 'Respuesta del Acta vencida';
-  if (state === 'ACT_RESPONSE_DUE_SOON') return 'Respuesta próxima a vencer';
-  if (state === 'COMPANY_COMMITMENT_OVERDUE') return 'Compromiso de empresa vencido';
-  if (state === 'VERIFICATION_PENDING') return 'Verificación pendiente';
-  if (state === 'RESPONSE_RECEIVED') return 'Respuesta recibida';
-  return 'Esperando respuesta';
-}
-
-function stateClass(state: FieldBriefingActState): string {
-  if (state === 'ACT_RESPONSE_OVERDUE' || state === 'COMPANY_COMMITMENT_OVERDUE') return 'danger';
-  if (state === 'ACT_RESPONSE_DUE_SOON' || state === 'VERIFICATION_PENDING') return 'warning';
-  return 'pending';
-}
-
-export function FieldBriefingPanel({ visit }: { visit: InspectionVisit }) {
-  const [briefing, setBriefing] = useState<FieldBriefing | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState('');
-
-  useEffect(() => {
-    let active = true;
-    setLoading(true);
-    setError('');
-    getInspectionFieldBriefing(visit.id)
-      .then((value) => { if (active) setBriefing(value); })
-      .catch((requestError) => { if (active) setError(errorMessage(requestError)); })
-      .finally(() => { if (active) setLoading(false); });
-    return () => { active = false; };
-  }, [visit.id, visit.updatedAt]);
-
-  return <section className="panel inspection-checklist-panel">
-    <div className="panel-heading">
-      <div>
-        <span className="eyebrow">ANTES DE CONFIRMAR LA SALIDA</span>
-        <h2>Pendientes para revisar en campo</h2>
-        <p className="section-copy">Actas anteriores del mismo Área y Operadora que requieren atención durante esta inspección. El plazo administrativo pertenece al Acta y los hallazgos se mantienen dentro de su expediente de origen.</p>
-      </div>
-      <div className="form-actions">
-        <Link className="button secondary" to="/preparacion-campo"><Icon name="clipboard" />Vista imprimible</Link>
-      </div>
-    </div>
-
-    {error && <Alert>{error}</Alert>}
-    {loading ? <LoadingBlock label="Preparando pendientes de campo…" /> : briefing && <>
-      <div className="inspection-checklist-metrics">
-        <div><strong>{briefing.summary.acts}</strong><span>actas con pendientes</span></div>
-        <div><strong>{briefing.summary.findings}</strong><span>hallazgos a revisar</span></div>
-        <div><strong>{briefing.summary.inventoryItems}</strong><span>registros involucrados</span></div>
-        <div><strong>{briefing.summary.responseOverdue}</strong><span>respuestas vencidas</span></div>
-        <div><strong>{briefing.summary.commitmentOverdue}</strong><span>compromisos vencidos</span></div>
-        <div><strong>{briefing.summary.verificationPending}</strong><span>verificaciones pendientes</span></div>
-      </div>
-
-      <div className="temporal-notice">
-        <Icon name="clipboard" />
-        <p><strong>Contexto de salida:</strong> {briefing.inspection.area?.name ?? 'Área sin definir'} · {briefing.inspection.operatorCompany?.name ?? 'Operadora sin definir'} · {formatDateOnly(briefing.plannedOn)}.</p>
-      </div>
-
-      {briefing.acts.length === 0
-        ? <EmptyState title="Sin pendientes anteriores" text="No hay Actas anteriores con acciones de campo pendientes para este Área y Operadora." />
-        : <div>{briefing.acts.map((act) => <div className="table-panel" key={act.actId}>
-            <div className="table-summary">
-              <div><strong>{act.actCode}</strong><span>{formatDate(act.occurredAt)} · {act.findings.length} hallazgo{act.findings.length === 1 ? '' : 's'}</span></div>
-              <span className={`status-badge ${stateClass(act.adminState)}`}>{stateLabel(act.adminState)}</span>
-            </div>
-            <div className="table-scroll"><table>
-              <thead><tr><th>Hallazgo</th><th>Inventario</th><th>Gravedad</th><th>Control</th><th /></tr></thead>
-              <tbody>{act.findings.map((finding) => <tr key={finding.id}>
-                <td><Link className="history-asset-link" to={`/hallazgos/${finding.id}`}><strong>{finding.title}</strong><small>{finding.code} · {finding.status}</small></Link></td>
-                <td><Link className="history-asset-link" to={`/inventarios/${finding.asset.id}`}><strong>{finding.asset.name}</strong><small>{finding.asset.code} · {finding.asset.typeName}</small></Link></td>
-                <td>{finding.severity ?? '—'}</td>
-                <td>{finding.nextControlOn ? formatDateOnly(finding.nextControlOn) : 'A definir'}</td>
-                <td className="action-cell"><Link className="button secondary compact" to={`/seguimiento-actas/${act.actId}`}>Ver Acta</Link></td>
-              </tr>)}</tbody>
-            </table></div>
-            <div className="table-summary">
-              <span>Plazo empresa: <strong>{act.responseDueOn ? formatDateOnly(act.responseDueOn) : 'sin definir'}</strong></span>
-              <span>Respuesta: <strong>{act.responseReceivedOn ? formatDateOnly(act.responseReceivedOn) : 'pendiente'}</strong></span>
-              <span>Compromiso: <strong>{act.committedCorrectionOn ? formatDateOnly(act.committedCorrectionOn) : '—'}</strong></span>
-            </div>
-          </div>)}</div>}
-    </>}
-  </section>;
-}

web-v2/src/features/inspections/InspectionActsPanel.tsx

@@ -6,7 +6,6 @@ import { Icon } from '../../components/Icon';
 import { listInspectionActs } from '../../lib/api';
 import type { InspectionActListItem, InspectionVisit } from '../../lib/api';
 import { formatDate } from '../../lib/format';
-import { FieldBriefingPanel } from './FieldBriefingPanel';
 import { inspectionActStatusClass, inspectionActStatusLabel } from './inspectionActPresentation';
 
 export function InspectionActsPanel({ visit }: { visit: InspectionVisit }) {
@@ -26,18 +25,17 @@ export function InspectionActsPanel({ visit }: { visit: InspectionVisit }) {
       .finally(() => setLoading(false));
   }, [canRead, visit.id]);
 
-  return <>
-    <FieldBriefingPanel visit={visit} />
-    {canRead && <section className="inspection-acts-panel">
-      <div className="panel-heading">
-        <div><span className="eyebrow">ACTAS DE LA INSPECCIÓN</span><h2>Actas generadas</h2><p className="section-copy">Una inspección puede generar múltiples actas. Cada acta agrupa sus propios hallazgos y tendrá un único informe.</p></div>
-        <span className="status-badge pending">Sólo lectura</span>
-      </div>
-      <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Las actas se crean en la APK.</strong> El dashboard permite consultar cada acta, sus hallazgos, firmas e informe después de la sincronización.</p></div>
-      {error && <Alert>{error}</Alert>}
-      {loading ? <LoadingBlock label="Cargando actas…" /> : acts.length === 0
-        ? <EmptyState title="Sin actas sincronizadas" text={visit.status === 'IN_PROGRESS' ? 'El inspector puede crear la primera acta desde la APK.' : 'Aparecerán aquí a medida que el inspector genere actas desde la APK.'} />
-        : <div className="table-panel inspection-acts-table"><div className="table-summary"><strong>Actas de la inspección</strong><span>Numeración oficial global por año</span></div><div className="table-scroll"><table><thead><tr><th>Acta</th><th>Estado</th><th>Fecha</th><th>Registros</th><th>Hallazgos</th><th>Versión</th><th /></tr></thead><tbody>{acts.map((act) => <tr key={act.id}><td><div className="asset-cell"><span className="asset-symbol"><Icon name="clipboard" size={17} /></span><div><strong>{act.title}</strong><small>{act.code}</small></div></div></td><td><span className={`status-badge ${inspectionActStatusClass(act.status)}`}>{inspectionActStatusLabel(act.status)}</span></td><td>{formatDate(act.occurredAt)}</td><td>{act.assetCount}</td><td>{act.findingCount}</td><td>v{act.currentVersion}</td><td className="action-cell"><Link className="icon-button" to={`/inspecciones/actas/${act.id}`} aria-label={`Abrir ${act.code}`}><Icon name="chevron" /></Link></td></tr>)}</tbody></table></div></div>}
-    </section>}
-  </>;
+  if (!canRead) return null;
+
+  return <section className="inspection-acts-panel">
+    <div className="panel-heading">
+      <div><span className="eyebrow">ACTAS DE LA INSPECCIÓN</span><h2>Actas generadas</h2><p className="section-copy">Una inspección puede generar múltiples actas. Cada acta agrupa sus propios hallazgos y tendrá un único informe.</p></div>
+      <span className="status-badge pending">Sólo lectura</span>
+    </div>
+    <div className="temporal-notice"><Icon name="clipboard" /><p><strong>Las actas se crean en la APK.</strong> El dashboard permite consultar cada acta, sus hallazgos, firmas e informe después de la sincronización.</p></div>
+    {error && <Alert>{error}</Alert>}
+    {loading ? <LoadingBlock label="Cargando actas…" /> : acts.length === 0
+      ? <EmptyState title="Sin actas sincronizadas" text={visit.status === 'IN_PROGRESS' ? 'El inspector puede crear la primera acta desde la APK.' : 'Aparecerán aquí a medida que el inspector genere actas desde la APK.'} />
+      : <div className="table-panel inspection-acts-table"><div className="table-summary"><strong>Actas de la inspección</strong><span>Numeración oficial global por año</span></div><div className="table-scroll"><table><thead><tr><th>Acta</th><th>Estado</th><th>Fecha</th><th>Registros</th><th>Hallazgos</th><th>Versión</th><th /></tr></thead><tbody>{acts.map((act) => <tr key={act.id}><td><div className="asset-cell"><span className="asset-symbol"><Icon name="clipboard" size={17} /></span><div><strong>{act.title}</strong><small>{act.code}</small></div></div></td><td><span className={`status-badge ${inspectionActStatusClass(act.status)}`}>{inspectionActStatusLabel(act.status)}</span></td><td>{formatDate(act.occurredAt)}</td><td>{act.assetCount}</td><td>{act.findingCount}</td><td>v{act.currentVersion}</td><td className="action-cell"><Link className="icon-button" to={`/inspecciones/actas/${act.id}`} aria-label={`Abrir ${act.code}`}><Icon name="chevron" /></Link></td></tr>)}</tbody></table></div></div>}
+  </section>;
 }

web-v2/src/features/inspections/fieldBriefingApi.ts

@@ -1,56 +0,0 @@
-import { apiRequest } from '../../lib/api';
-
-export type FieldBriefingActState =
-  | 'ACT_RESPONSE_OVERDUE'
-  | 'ACT_RESPONSE_DUE_SOON'
-  | 'WAITING_RESPONSE'
-  | 'COMPANY_COMMITMENT_OVERDUE'
-  | 'VERIFICATION_PENDING'
-  | 'RESPONSE_RECEIVED';
-
-export interface FieldBriefingFinding {
-  id: string;
-  code: string;
-  title: string;
-  status: string;
-  severity: number | null;
-  nextControlOn: string | null;
-  asset: { id: string; code: string; name: string; typeName: string };
-}
-
-export interface FieldBriefingAct {
-  actId: string;
-  actCode: string;
-  occurredAt: string;
-  adminState: FieldBriefingActState;
-  responseDueOn: string | null;
-  responseReceivedOn: string | null;
-  committedCorrectionOn: string | null;
-  latestResponseId: string | null;
-  findings: FieldBriefingFinding[];
-}
-
-export interface FieldBriefing {
-  inspection: {
-    id: string;
-    code: string;
-    status: string;
-    plannedStartAt: string | null;
-    area: { id: string; code: string; name: string } | null;
-    operatorCompany: { id: string; code: string; name: string } | null;
-  };
-  plannedOn: string;
-  summary: {
-    acts: number;
-    findings: number;
-    inventoryItems: number;
-    responseOverdue: number;
-    commitmentOverdue: number;
-    verificationPending: number;
-  };
-  acts: FieldBriefingAct[];
-}
-
-export function getInspectionFieldBriefing(visitId: string) {
-  return apiRequest<FieldBriefing>(`/inspection-visits/${visitId}/field-briefing`);
-}

web-v2/src/pages/FieldBriefingsPage.tsx

@@ -4,13 +4,7 @@ import { SearchableSelect } from '../components/SearchableSelect';
 import { Alert, EmptyState, LoadingBlock } from '../components/Feedback';
 import { formatDate, formatDateOnly } from '../lib/format';
 
-type AdminState =
-  | 'ACT_RESPONSE_OVERDUE'
-  | 'ACT_RESPONSE_DUE_SOON'
-  | 'WAITING_RESPONSE'
-  | 'COMPANY_COMMITMENT_OVERDUE'
-  | 'VERIFICATION_PENDING'
-  | 'RESPONSE_RECEIVED';
+type ReviewState = 'REQUIRED' | 'UPCOMING' | 'CONTEXT';
 
 interface VisitOption {
   id: string;
@@ -25,100 +19,79 @@ interface BriefingFinding {
   id: string;
   code: string;
   title: string;
-  status: string;
   severity: number | null;
   nextControlOn: string | null;
-  asset: {
-    id: string;
-    code: string;
-    name: string;
-    typeName: string;
-  };
+  reviewState: ReviewState;
+  reviewReason: string;
+  asset: { id: string; code: string; name: string; typeName: string };
 }
 
 interface BriefingAct {
   actId: string;
   actCode: string;
   occurredAt: string;
-  adminState: AdminState;
+  adminState: string;
   responseDueOn: string | null;
-  responseReceivedOn: string | null;
-  committedCorrectionOn: string | null;
-  latestResponseId: string | null;
+  latestResponse: null | { id: string; receivedOn: string; committedCorrectionOn: string | null; hasPdf: boolean };
   findings: BriefingFinding[];
 }
 
-interface FieldBriefing {
-  inspection: {
+interface Briefing {
+  visit: {
     id: string;
     code: string;
     status: string;
     plannedStartAt: string | null;
-    area: { id: string; code: string | null; name: string | null } | null;
-    operatorCompany: { id: string; code: string | null; name: string | null } | null;
+    operationalArea: { id: string; code: string | null; name: string | null };
+    operatorCompany: { id: string; code: string | null; name: string | null };
   };
-  plannedOn: string;
+  referenceDate: string;
+  generatedAt: string;
   summary: {
-    acts: number;
-    findings: number;
-    inventoryItems: number;
-    responseOverdue: number;
-    commitmentOverdue: number;
-    verificationPending: number;
+    actCount: number;
+    openFindingCount: number;
+    fieldReviewRequired: number;
+    fieldReviewUpcoming: number;
+    administrativeAttention: number;
+    assetCount: number;
   };
   acts: BriefingAct[];
 }
 
-async function getJson<T>(url: string): Promise<T> {
-  const response = await fetch(url, {
-    credentials: 'same-origin',
-    headers: { Accept: 'application/json' },
-  });
+async function json<T>(url: string): Promise<T> {
+  const response = await fetch(url, { credentials: 'same-origin', headers: { Accept: 'application/json' } });
   const payload = await response.json().catch(() => ({}));
   if (!response.ok) {
     const message = typeof payload?.message === 'string'
       ? payload.message
-      : 'No se pudo preparar el paquete de campo.';
+      : 'No se pudo cargar la preparación de campo.';
     throw new Error(message);
   }
   return payload as T;
 }
 
-function adminStateLabel(state: AdminState): string {
-  const labels: Record<AdminState, string> = {
-    ACT_RESPONSE_OVERDUE: 'Respuesta del Acta vencida',
-    ACT_RESPONSE_DUE_SOON: 'Respuesta próxima a vencer',
-    WAITING_RESPONSE: 'Esperando respuesta',
-    COMPANY_COMMITMENT_OVERDUE: 'Compromiso de empresa vencido',
-    VERIFICATION_PENDING: 'Verificación pendiente',
-    RESPONSE_RECEIVED: 'Respuesta recibida',
-  };
-  return labels[state];
+function reviewLabel(state: ReviewState) {
+  if (state === 'REQUIRED') return 'Revisar en campo';
+  if (state === 'UPCOMING') return 'Próximo control';
+  return 'Antecedente';
 }
 
-function findingAction(finding: BriefingFinding, act: BriefingAct, plannedOn: string) {
-  if (finding.nextControlOn) {
-    if (finding.nextControlOn <= plannedOn) {
-      return { label: 'Revisar en campo', detail: 'Control programado o vencido', tone: 'danger' };
-    }
-    return { label: 'Próximo control', detail: `Previsto ${formatDateOnly(finding.nextControlOn)}`, tone: 'pending' };
-  }
-  if (act.adminState === 'VERIFICATION_PENDING') {
-    return { label: 'Revisar en campo', detail: 'Respuesta recibida sin control programado', tone: 'danger' };
-  }
-  if (act.adminState === 'COMPANY_COMMITMENT_OVERDUE') {
-    return { label: 'Revisar en campo', detail: 'Regularización comprometida vencida', tone: 'danger' };
-  }
-  if (act.adminState === 'RESPONSE_RECEIVED') {
-    return { label: 'Antecedente', detail: 'Respuesta de empresa recibida', tone: 'pending' };
-  }
-  return { label: 'Antecedente', detail: adminStateLabel(act.adminState), tone: 'pending' };
+function reasonLabel(reason: string) {
+  const labels: Record<string, string> = {
+    CONTROL_OVERDUE: 'Control vencido',
+    COMMITMENT_REACHED: 'Compromiso de empresa alcanzado',
+    RESPONSE_WITHOUT_CONTROL: 'Respuesta recibida sin control programado',
+    CONTROL_UPCOMING: 'Control próximo',
+    ADMIN_RESPONSE_OVERDUE: 'Respuesta administrativa vencida',
+    CONTEXT_ONLY: 'Antecedente abierto',
+  };
+  return labels[reason] ?? reason;
 }
 
 export function FieldBriefingsPage() {
   const [visits, setVisits] = useState<VisitOption[]>([]);
   const [visitId, setVisitId] = useState('');
-  const [briefing, setBriefing] = useState<FieldBriefing | null>(null);
+  const [briefing, setBriefing] = useState<Briefing | null>(null);
   const [loadingVisits, setLoadingVisits] = useState(true);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState('');
@@ -126,17 +99,16 @@ export function FieldBriefingsPage() {
   useEffect(() => {
     setLoadingVisits(true);
     Promise.all([
-      getJson<{ data: VisitOption[] }>('/api/v3/inspection-visits?status=PLANNED&page=1&pageSize=100'),
-      getJson<{ data: VisitOption[] }>('/api/v3/inspection-visits?status=DRAFT&page=1&pageSize=100'),
+      json<{ data: VisitOption[] }>('/api/v3/inspection-visits?status=PLANNED&page=1&pageSize=100'),
+      json<{ data: VisitOption[] }>('/api/v3/inspection-visits?status=DRAFT&page=1&pageSize=100'),
     ]).then(([planned, drafts]) => {
       const all = [...planned.data, ...drafts.data]
         .sort((a, b) => String(a.plannedStartAt ?? '').localeCompare(String(b.plannedStartAt ?? '')));
       setVisits(all);
       const onlyVisit = all[0];
       if (all.length === 1 && onlyVisit) setVisitId(onlyVisit.id);
-    }).catch((cause) => {
-      setError(cause instanceof Error ? cause.message : String(cause));
-    }).finally(() => setLoadingVisits(false));
+    }).catch((cause) => setError(cause instanceof Error ? cause.message : String(cause)))
+      .finally(() => setLoadingVisits(false));
   }, []);
 
   useEffect(() => {
@@ -146,27 +118,22 @@ export function FieldBriefingsPage() {
     }
     setLoading(true);
     setError('');
-    getJson<FieldBriefing>(`/api/v3/inspection-visits/${visitId}/field-briefing`)
+    json<Briefing>(`/api/v3/inspection-visits/${visitId}/field-briefing`)
       .then(setBriefing)
       .catch((cause) => setError(cause instanceof Error ? cause.message : String(cause)))
       .finally(() => setLoading(false));
   }, [visitId]);
 
-  const selected = useMemo(
-    () => visits.find((visit) => visit.id === visitId) ?? null,
-    [visits, visitId],
-  );
+  const selected = useMemo(() => visits.find((visit) => visit.id === visitId) ?? null, [visits, visitId]);
 
   return <section className="field-briefing-page">
     <div className="page-heading">
       <div>
         <span className="eyebrow">ANTES DE SALIR A CAMPO</span>
         <h1>Preparación de campo</h1>
-        <p>Seleccioná la inspección y revisá los pendientes de Actas anteriores del mismo Área/Yacimiento y Operadora.</p>
+        <p>Actas anteriores y hallazgos abiertos del mismo Área/Yacimiento y Operadora, ordenados por lo que el inspector debe revisar.</p>
       </div>
-      {briefing && <button className="button secondary no-print" type="button" onClick={() => window.print()}>
-        Imprimir preparación
-      </button>}
+      {briefing && <button className="button secondary" type="button" onClick={() => window.print()}>Imprimir preparación</button>}
     </div>
 
     <div className="form-card no-print">
@@ -186,79 +153,39 @@ export function FieldBriefingsPage() {
 
     {error && <Alert>{error}</Alert>}
     {loading && <LoadingBlock label="Armando paquete de campo…" />}
-
-    {!loading && !briefing && !error && <EmptyState
-      title="Seleccioná una inspección"
-      text="El sistema reunirá automáticamente los pendientes de inspecciones anteriores del mismo contexto."
-    />}
-
+    {!loading && !briefing && !error && <EmptyState title="Seleccioná una inspección" text="El sistema reunirá automáticamente los pendientes de inspecciones anteriores." />}
     {!loading && briefing && <>
       <div className="page-heading compact">
         <div>
-          <span className="eyebrow">{briefing.inspection.code}</span>
-          <h2>{briefing.inspection.area?.name ?? 'Área sin definir'} · {briefing.inspection.operatorCompany?.name ?? 'Operadora sin definir'}</h2>
-          <p>Fecha de referencia: {formatDateOnly(briefing.plannedOn)}</p>
+          <span className="eyebrow">{briefing.visit.code}</span>
+          <h2>{briefing.visit.operationalArea.name ?? 'Área'} · {briefing.visit.operatorCompany.name ?? 'Operadora'}</h2>
+          <p>Referencia: {formatDateOnly(briefing.referenceDate)} · generado {formatDate(briefing.generatedAt)}</p>
         </div>
-        <Link className="button secondary no-print" to={`/inspecciones/${briefing.inspection.id}`}>
-          Abrir planificación
-        </Link>
+        <Link className="button secondary no-print" to={`/inspecciones/${briefing.visit.id}`}>Abrir planificación</Link>
       </div>
 
       <div className="status-tabs briefing-summary">
-        <span>Actas <strong>{briefing.summary.acts}</strong></span>
-        <span>Hallazgos <strong>{briefing.summary.findings}</strong></span>
-        <span>Inventario <strong>{briefing.summary.inventoryItems}</strong></span>
-        <span>Respuestas vencidas <strong>{briefing.summary.responseOverdue}</strong></span>
-        <span>Compromisos vencidos <strong>{briefing.summary.commitmentOverdue}</strong></span>
-        <span>Verificaciones pendientes <strong>{briefing.summary.verificationPending}</strong></span>
+        <span>Actas <strong>{briefing.summary.actCount}</strong></span>
+        <span>Hallazgos abiertos <strong>{briefing.summary.openFindingCount}</strong></span>
+        <span>Revisar en campo <strong>{briefing.summary.fieldReviewRequired}</strong></span>
+        <span>Próximos <strong>{briefing.summary.fieldReviewUpcoming}</strong></span>
+        <span>Inventario involucrado <strong>{briefing.summary.assetCount}</strong></span>
       </div>
 
-      {briefing.acts.length === 0 ? <EmptyState
-        title="Sin pendientes anteriores"
-        text="No hay Actas anteriores con hallazgos abiertos que requieran atención para esta inspección."
-      /> : briefing.acts.map((act) => <article className="table-panel" key={act.actId}>
+      {briefing.acts.length === 0 ? <EmptyState title="Sin pendientes anteriores" text="No hay hallazgos abiertos de Actas anteriores para este contexto." /> : briefing.acts.map((act) => <article className="table-panel" key={act.actId}>
         <div className="table-summary">
-          <div>
-            <strong>{act.actCode}</strong>
-            <small className="block-muted">{formatDate(act.occurredAt)} · {adminStateLabel(act.adminState)}</small>
-          </div>
-          <div>
-            <small>Plazo del Acta</small>
-            <strong>{act.responseDueOn ? formatDateOnly(act.responseDueOn) : 'Sin definir'}</strong>
-          </div>
-          <div>
-            <small>Respuesta empresa</small>
-            <strong>{act.responseReceivedOn ? formatDateOnly(act.responseReceivedOn) : 'Pendiente'}</strong>
-          </div>
-          <div>
-            <small>Compromiso empresa</small>
-            <strong>{act.committedCorrectionOn ? formatDateOnly(act.committedCorrectionOn) : 'Sin fecha'}</strong>
-          </div>
-        </div>
-
-        <div className="table-scroll">
-          <table>
-            <thead><tr><th>Qué hacer</th><th>Hallazgo</th><th>Inventario</th><th>Control</th></tr></thead>
-            <tbody>{act.findings.map((finding) => {
-              const action = findingAction(finding, act, briefing.plannedOn);
-              return <tr key={finding.id}>
-                <td>
-                  <span className={`status-badge ${action.tone}`}>{action.label}</span>
-                  <small className="block-muted">{action.detail}</small>
-                </td>
-                <td>
-                  <strong>{finding.code}</strong>
-                  <small className="block-muted">{finding.title}</small>
-                </td>
-                <td>
-                  <strong>{finding.asset.code}</strong>
-                  <small className="block-muted">{finding.asset.name} · {finding.asset.typeName}</small>
-                </td>
-                <td>{finding.nextControlOn ? formatDateOnly(finding.nextControlOn) : 'Sin fecha'}</td>
-              </tr>;
-            })}</tbody>
-          </table>
+          <div><strong>{act.actCode}</strong><small className="block-muted">{formatDate(act.occurredAt)} · {act.adminState}</small></div>
+          <div><small>Plazo empresa</small><strong>{act.responseDueOn ? formatDateOnly(act.responseDueOn) : 'Sin definir'}</strong></div>
+          <div><small>Respuesta</small><strong>{act.latestResponse ? formatDateOnly(act.latestResponse.receivedOn) : 'Pendiente'}</strong></div>
         </div>
+        <div className="table-scroll"><table><thead><tr><th>Prioridad</th><th>Hallazgo</th><th>Inventario</th><th>Próximo control</th></tr></thead><tbody>
+          {act.findings.map((finding) => <tr key={finding.id}>
+            <td><span className={`status-badge ${finding.reviewState === 'REQUIRED' ? 'danger' : 'pending'}`}>{reviewLabel(finding.reviewState)}</span><small className="block-muted">{reasonLabel(finding.reviewReason)}</small></td>
+            <td><strong>{finding.code}</strong><small className="block-muted">{finding.title}</small></td>
+            <td><strong>{finding.asset.code}</strong><small className="block-muted">{finding.asset.name} · {finding.asset.typeName}</small></td>
+            <td>{finding.nextControlOn ? formatDateOnly(finding.nextControlOn) : 'Sin fecha'}</td>
+          </tr>)}
+        </tbody></table></div>
       </article>)}
     </>}
   </section>;