test: fix F1.2 source contract paths

feat: F1.2 materialized act administration
chore: bootstrap F1.2 source materialization
2026-09-05 15:10:43 -03:00 · 2026-09-05 18:09:17 +00:00 · 2026-09-05 15:09:01 -03:00
26 changed files with 288 additions and 2064 deletions
@@ -1,6 +1,6 @@
 {
  "name": "dhv2-api",
-  "version": "0.21.0-1",
+  "version": "0.20.0-2",
  "private": true,
  "license": "UNLICENSED",
  "scripts": {
@@ -1,22 +1,12 @@
 import { Module } from '@nestjs/common';
 import { AuditModule } from '../audit/audit.module';
-import {
+import { ActAdministrationController, ActAdministrationQueueController, ActCompanyResponseContentController } from './act-administration.controller';
  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: [
+  controllers: [ActAdministrationQueueController, ActAdministrationController, ActCompanyResponseContentController],
-    ActAdministrationQueueController,
+  providers: [ActAdministrationService],
    ActAdministrationController,
    ActCompanyResponseContentController,
    FieldBriefingController,
  ],
  providers: [ActAdministrationService, FieldBriefingService],
 })
 export class ActAdministrationModule {}
@@ -1,14 +0,0 @@
 import { Controller, Get, Param, ParseUUIDPipe } from '@nestjs/common';
 import { RequirePermissions } from '../authorization/decorators/require-permissions.decorator';
 import { FieldBriefingService } from './field-briefing.service';
@Controller('inspection-visits/:visitId/field-briefing')
 export class FieldBriefingController {
  constructor(private readonly briefing: FieldBriefingService) {}
  @Get()
  @RequirePermissions('inspections.read')
  get(@Param('visitId', new ParseUUIDPipe({ version: '4' })) visitId: string) {
    return this.briefing.forVisit(visitId);
  }
 }
@@ -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,
    };
  }
 }
@@ -49,12 +49,6 @@ import { FieldDiscoveryInspectionLinkService } from '../inspection-operations/fi
    AssetRegistryService,
    FieldDiscoveryInspectionLinkService,
  ],
-  exports: [
+  exports: [AssetHistoryService],
    AssetHistoryService,
    AssetsService,
    AssetGeometriesService,
    AssetMediaService,
    FieldDiscoveryInspectionLinkService,
  ],
 })
 export class AssetMasterModule {}
@@ -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`);
  }
 }
@@ -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 (
+        INSERT INTO inspection_visit_assets (visit_id, asset_id, included, added_by)
-          visit_id, asset_id, included, planning_source, added_by,
+        VALUES ($1, $2, true, $3)
          exclusion_reason, excluded_by, excluded_at
        )
        VALUES ($1, $2, true, 'FIELD', $3, NULL, NULL, NULL)
        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(
        `
@@ -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;
 }
@@ -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;
 }
@@ -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;
 }
@@ -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);
  }
 }
@@ -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')}`;
  }
 }
@@ -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],
+  imports: [AuditModule],
-  controllers: [InspectionVisitsController, FieldInventoryController],
+  controllers: [InspectionVisitsController],
-  providers: [InspectionVisitsService, FieldInventoryService],
+  providers: [InspectionVisitsService],
 })
 export class InspectionVisitsModule {}
@@ -1,2 +1,2 @@
-export const API_VERSION = '0.21.0-1';
+export const API_VERSION = '0.20.0-2';
-export const API_PHASE = 'F2.1';
+export const API_PHASE = 'F1.2';
@@ -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/);
 });
@@ -1,30 +0,0 @@
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 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');
 test('F1.3 agrupa pendientes de campo por Acta y Hallazgo', () => {
  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: \[\]/);
 });
 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 no usa el plazo del Hallazgo como plazo administrativo', () => {
  assert.doesNotMatch(service, /correction_due_on/);
  assert.match(service, /deadline\.response_due_on/);
 });
@@ -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.
@@ -3,112 +3,301 @@ set -Eeuo pipefail
 APP="/var/www/dhv2.korexlabs.com"
 KEY="/root/.ssh/dhv2_github"
 BACKUP_ROOT="/root/DH_V2_BACKUPS"
 DEPLOY_REF="${DHV2_DEPLOY_REF:-deploy}"
-LOG="$(mktemp /tmp/dhv2-android-discovery.XXXXXX.log)"
+STAMP="$(date +%Y%m%d_%H%M%S)"
-STATUS="$(mktemp /tmp/dhv2-android-discovery-status.XXXXXX)"
+BACKUP="$BACKUP_ROOT/GITHUB_DEPLOY_${STAMP}"
 STAGE="/root/dhv2-github-stage-${STAMP}"
 LOG="/tmp/dhv2-github-deploy-${STAMP}.log"
 API_TEST_IMAGE="dhv2-api:github-${STAMP}"
 WEB_TEST_IMAGE="dhv2-web:github-${STAMP}"
 PHASE="bootstrap"
 PREV_SHA=""
 TARGET_SHA=""
 EXPECTED_API_VERSION=""
 EXPECTED_WEB_VERSION=""
 APP_TOUCHED=0
 cd "$APP"
 export GIT_SSH_COMMAND="ssh -i $KEY -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new"
 exec > >(tee -a "$LOG") 2>&1
 cleanup() {
  set +e
  git worktree remove --force "$STAGE" >/dev/null 2>&1 || true
  rm -rf "$STAGE"
  docker image rm "$API_TEST_IMAGE" "$WEB_TEST_IMAGE" >/dev/null 2>&1 || true
 }
 publish_status() {
  local rc="${1:-1}"
  set +e
  local outcome="failure"
  [ "$rc" -eq 0 ] && outcome="success"
-  local current target status_blob log_blob tree commit
+  local current="unknown"
  current="$(git rev-parse HEAD 2>/dev/null || echo unknown)"
-  target="$(git rev-parse origin/$DEPLOY_REF 2>/dev/null || echo unknown)"
+  local status_file log_file status_blob log_blob tree commit
  status_file="$(mktemp /tmp/dhv2-status.XXXXXX)"
  log_file="$(mktemp /tmp/dhv2-log.XXXXXX)"
  {
    echo "status=$outcome"
    echo "exit_code=$rc"
-    echo "phase=android-source-discovery"
+    echo "phase=$PHASE"
    echo "timestamp=$(date --iso-8601=seconds)"
    echo "deploy_ref=$DEPLOY_REF"
-    echo "target_sha=$target"
+    echo "previous_sha=${PREV_SHA:-unknown}"
    echo "target_sha=${TARGET_SHA:-unknown}"
    echo "current_sha=$current"
-    echo "app_touched=0"
+    echo "api_version=${EXPECTED_API_VERSION:-unknown}"
-    echo "backup=not-required-read-only"
+    echo "web_version=${EXPECTED_WEB_VERSION:-unknown}"
-  } > "$STATUS"
+    echo "app_touched=$APP_TOUCHED"
-  status_blob="$(git hash-object -w "$STATUS" 2>/dev/null || true)"
+    echo "backup=${BACKUP:-unknown}"
-  log_blob="$(git hash-object -w "$LOG" 2>/dev/null || true)"
+  } > "$status_file"
  tail -n 500 "$LOG" > "$log_file" 2>/dev/null || true
  status_blob="$(git hash-object -w "$status_file" 2>/dev/null || true)"
  log_blob="$(git hash-object -w "$log_file" 2>/dev/null || true)"
  if [ -n "$status_blob" ] && [ -n "$log_blob" ]; then
    tree="$(printf '100644 blob %s\tdeploy.log\n100644 blob %s\tstatus.txt\n' "$log_blob" "$status_blob" | git mktree 2>/dev/null || true)"
    if [ -n "$tree" ]; then
-      commit="$(printf 'deploy-status: %s · android-source-discovery\n' "$outcome" | git -c user.name='DH V2 Deploy Bot' -c user.email='deploy@dhv2.local' commit-tree "$tree" 2>/dev/null || true)"
+      commit="$(printf 'deploy-status: %s · phase %s\n' "$outcome" "$PHASE" | git -c user.name='DH V2 Deploy Bot' -c user.email='deploy@dhv2.local' commit-tree "$tree" 2>/dev/null || true)"
      [ -z "$commit" ] || git push --force origin "$commit:refs/heads/deploy-status" >/dev/null 2>&1 || true
    fi
  fi
-  rm -f "$STATUS" "$LOG"
+
  rm -f "$status_file" "$log_file"
 }
 trap 'rc=$?; trap - EXIT; publish_status "$rc"; exit "$rc"' EXIT
 on_exit() {
  local rc=$?
  trap - EXIT ERR
  cleanup
  publish_status "$rc"
  exit "$rc"
 }
 trap on_exit EXIT
 rollback() {
  local rc=$?
  trap - ERR
  PHASE="rollback"
  echo
  echo "============================================================"
  echo " DH V2 · DEPLOY FALLÓ · ROLLBACK"
  echo "============================================================"
  cd "$APP"
  if [ "$APP_TOUCHED" -eq 1 ] && [ -n "${PREV_SHA:-}" ]; then
    echo "Restaurando aplicación al commit previo: $PREV_SHA"
    git reset --hard "$PREV_SHA" || true
    docker compose build api web </dev/null || true
    docker compose up -d --no-deps --force-recreate api web </dev/null || true
  else
    echo "El candidato falló antes de modificar producción; no se reconstruye ni reinicia la aplicación activa."
  fi
  echo
  echo "Estado actual:"
  docker compose ps -a </dev/null || true
  if [ "$APP_TOUCHED" -eq 1 ]; then
    echo
    echo "Últimos logs:"
    docker compose logs --tail=160 api web </dev/null || true
  fi
  echo
  if [ -d "$BACKUP" ]; then
    echo "Backup PRE disponible en: $BACKUP"
    echo "Las migraciones son forward-only; database-before.dump queda disponible para restauración manual si hiciera falta."
  else
    echo "No fue necesario crear backup PRE: el fallo ocurrió durante el preflight del candidato, antes de tocar producción."
  fi
  exit "$rc"
 }
 trap rollback ERR
 echo
 echo "============================================================"
-echo " DH V2 · ANDROID SOURCE DISCOVERY · SOLO LECTURA"
+echo " DH V2 · DEPLOY DESDE GITHUB · $DEPLOY_REF"
 echo "============================================================"
 for cmd in git docker curl tar node; do
  command -v "$cmd" >/dev/null || { echo "ERROR: falta $cmd"; false; }
 done
 [ -f "$KEY" ] || { echo "ERROR: falta deploy key $KEY"; false; }
 [ -d .git ] || { echo "ERROR: $APP no es repositorio Git"; false; }
 [ -f .env ] || { echo "ERROR: falta $APP/.env"; false; }
 git config --global --get-all safe.directory 2>/dev/null | grep -Fxq "$APP" || git config --global --add safe.directory "$APP"
 if [ -n "$(git status --porcelain --untracked-files=no)" ]; then
  echo "ERROR: hay cambios locales versionados en producción."
  git status --short
  false
 fi
 PREV_SHA="$(git rev-parse HEAD)"
 PHASE="fetch"
 git fetch origin "$DEPLOY_REF"
-TARGET="$(git rev-parse "origin/$DEPLOY_REF")"
+TARGET_SHA="$(git rev-parse "origin/$DEPLOY_REF")"
-CURRENT="$(git rev-parse HEAD)"
+
-echo "Current: $CURRENT"
+echo "Actual:   $PREV_SHA"
-echo "Target:  $TARGET"
+echo "Objetivo: $TARGET_SHA"
-git merge-base --is-ancestor "$CURRENT" "$TARGET"
+
 if [ "$TARGET_SHA" = "$PREV_SHA" ]; then
  echo "Producción ya está en el commit autorizado."
  PHASE="complete"
  exit 0
 fi
 if ! git merge-base --is-ancestor "$PREV_SHA" "$TARGET_SHA"; then
  echo "ERROR: origin/$DEPLOY_REF no es fast-forward desde producción."
  false
 fi
 PHASE="candidate-preflight"
 rm -rf "$STAGE"
 git worktree add --detach "$STAGE" "$TARGET_SHA" >/dev/null
 EXPECTED_API_VERSION="$(node -p "require('$STAGE/api-v3/package.json').version")"
 EXPECTED_WEB_VERSION="$(node -p "require('$STAGE/web-v2/package.json').version")"
 echo "API candidata: $EXPECTED_API_VERSION"
 echo "WEB candidata: $EXPECTED_WEB_VERSION"
 docker compose --env-file "$APP/.env" -f "$STAGE/docker-compose.yml" config >/dev/null
 while IFS= read -r -d '' script; do
  bash -n "$script"
 done < <(find "$STAGE/scripts" -type f -name '*.sh' -print0)
 echo
-echo "========== PROYECTOS GRADLE / ANDROID =========="
+echo "========== TEST API CANDIDATA =========="
-for root in /root /var/www /home /tmp; do
+docker build --target builder -t "$API_TEST_IMAGE" "$STAGE/api-v3" </dev/null
-  [ -d "$root" ] || continue
+docker run --rm \
-  find "$root" -maxdepth 9 -type f \
+  -v "$STAGE/api-v3/test:/app/test:ro" \
-    \( -name gradlew -o -name settings.gradle -o -name settings.gradle.kts -o -name build.gradle -o -name build.gradle.kts \) \
+  -v "$STAGE/api-v3/tsconfig.test.json:/app/tsconfig.test.json:ro" \
-    -printf '%TY-%Tm-%Td %TH:%TM  %10s  %p\n' 2>/dev/null || true
+  "$API_TEST_IMAGE" npm test </dev/null
 done | sort -r | head -300
 echo
-echo "========== ZIP / APK / AAB RELACIONADOS =========="
+echo "========== BUILD WEB CANDIDATA =========="
-for root in /root /var/www /home /tmp; do
+docker build -t "$WEB_TEST_IMAGE" "$STAGE/web-v2" </dev/null
  [ -d "$root" ] || continue
  find "$root" -maxdepth 10 -type f \
    \( -iname '*android*.zip' -o -iname '*inspeccion*.zip' -o -iname '*dh*.apk' -o -iname '*inspeccion*.apk' -o -iname '*.aab' -o -iname '*E1.1*' -o -iname '*E1_1*' -o -iname '*E1.2*' -o -iname '*E1_2*' -o -iname '*F2.2*' -o -iname '*F2_2*' \) \
    -printf '%TY-%Tm-%Td %TH:%TM  %10s  %p\n' 2>/dev/null || true
 done | sort -r | head -300
 PHASE="backup"
 echo
-echo "========== VERSIONES ANDROID =========="
+echo "========== BACKUP PRE =========="
-for root in /root /var/www /home /tmp; do
+install -d -m 700 "$BACKUP"
-  [ -d "$root" ] || continue
+docker compose exec -T db sh -lc 'pg_dump -U "$POSTGRES_USER" -d "$POSTGRES_DB" -Fc' </dev/null > "$BACKUP/database-before.dump"
-  find "$root" -maxdepth 10 -type f \( -name build.gradle -o -name build.gradle.kts \) -print0 2>/dev/null || true
+tar \
-done | while IFS= read -r -d '' f; do
+  --exclude='./.git' \
-  if grep -Eq 'applicationId|versionCode|versionName|namespace' "$f" 2>/dev/null; then
+  --exclude='./.env' \
-    echo "----- $f -----"
+  --exclude='*/node_modules' \
-    grep -nE 'applicationId|namespace|versionCode|versionName' "$f" 2>/dev/null | head -30 || true
+  --exclude='*/dist' \
-  fi
+  --exclude='*.zip' \
-done
+  --exclude='*.tar.gz' \
  --exclude='*.tgz' \
  -czf "$BACKUP/source-before.tar.gz" .
 install -m 600 .env "$BACKUP/.env"
 git rev-parse HEAD > "$BACKUP/previous.sha"
 printf '%s\n' "$TARGET_SHA" > "$BACKUP/target.sha"
 docker compose ps -a > "$BACKUP/docker-before.txt"
 (
  cd "$BACKUP"
  sha256sum database-before.dump source-before.tar.gz .env previous.sha target.sha docker-before.txt > SHA256SUMS.txt
  sha256sum -c SHA256SUMS.txt
 )
 chmod 600 "$BACKUP"/* "$BACKUP/.env" 2>/dev/null || true
 PHASE="fast-forward"
 echo
-echo "========== GIT REPOS CON GRADLE =========="
+echo "========== FAST-FORWARD =========="
-for root in /root /var/www /home /tmp; do
+git log --oneline --no-decorate "$PREV_SHA..$TARGET_SHA"
-  [ -d "$root" ] || continue
+APP_TOUCHED=1
  find "$root" -maxdepth 9 -type d -name .git -print 2>/dev/null || true
 done | while read -r gitdir; do
  dir="${gitdir%/.git}"
  if find "$dir" -maxdepth 3 \( -name gradlew -o -name settings.gradle -o -name settings.gradle.kts \) -print -quit 2>/dev/null | grep -q .; then
    echo "----- $dir -----"
    git -C "$dir" status --short --branch 2>/dev/null || true
    git -C "$dir" log -8 --oneline 2>/dev/null || true
  fi
 done
 echo
 echo "========== HUELLA KOTLIN / COMPOSE =========="
 for root in /root /var/www /home /tmp; do
  [ -d "$root" ] || continue
  find "$root" -maxdepth 10 -type f -name '*.kt' -printf '%h\n' 2>/dev/null || true
 done | grep -Ei 'dh|inspe|android|mobile|app' | sort -u | head -300
 echo
 echo "DISCOVERY_OK"
 echo
 echo "========== REGISTRAR COMMIT DIAGNÓSTICO =========="
 git merge --ff-only "origin/$DEPLOY_REF"
-echo "Diagnostic commit registrado localmente: $(git rev-parse HEAD)"
+
 PHASE="build"
 echo
 echo "========== BUILD PRODUCCIÓN =========="
 docker compose build api migrate web </dev/null
 PHASE="migrations"
 echo
 echo "========== MIGRACIONES =========="
 docker compose --profile tools run --rm migrate </dev/null
 docker compose --profile tools run --rm migrate npm run migration:show </dev/null | tee "$BACKUP/migrations.txt"
 grep -Fq 'Pending migrations: no' "$BACKUP/migrations.txt"
 PHASE="recreate"
 echo
 echo "========== RECREATE API + WEB =========="
 docker compose up -d --no-deps --force-recreate api web </dev/null
 PHASE="health"
 echo
 echo "========== HEALTH =========="
 HEALTH_OK=0
 for _ in $(seq 1 60); do
  if curl -fsS --max-time 5 http://127.0.0.1:3101/api/v3/health > "$BACKUP/health.json" 2>/dev/null; then
    if grep -F '"status":"ok"' "$BACKUP/health.json" >/dev/null; then
      HEALTH_OK=1
      break
    fi
  fi
  sleep 2
 done
 if [ "$HEALTH_OK" -ne 1 ]; then
  echo "ERROR: API no pasó healthcheck."
  docker compose logs --tail=180 api
  false
 fi
 cat "$BACKUP/health.json"
 echo
 grep -Fq "\"version\":\"$EXPECTED_API_VERSION\"" "$BACKUP/health.json"
 grep -Fq '"database":"ok"' "$BACKUP/health.json"
 WEB_CODE="$(curl -sS -o /dev/null -w '%{http_code}' --max-time 10 http://127.0.0.1:8182/)"
 [ "$WEB_CODE" = "200" ] || { echo "ERROR: WEB HTTP $WEB_CODE"; false; }
 PHASE="verify"
 echo
 echo "========== VERIFICACIÓN FINAL =========="
 docker compose ps -a | tee "$BACKUP/docker-after.txt"
 if docker compose ps --status running --services | grep -Fxq api && docker compose ps --status running --services | grep -Fxq web && docker compose ps --status running --services | grep -Fxq db; then
  echo "Servicios críticos: OK"
 else
  echo "ERROR: falta un servicio crítico en ejecución."
  false
 fi
 PHASE="post-backup"
 docker compose exec -T db sh -lc 'pg_dump -U "$POSTGRES_USER" -d "$POSTGRES_DB" -Fc' </dev/null > "$BACKUP/database-after.dump"
 git rev-parse HEAD > "$BACKUP/deployed.sha"
 printf 'API=%s\nWEB=%s\n' "$EXPECTED_API_VERSION" "$EXPECTED_WEB_VERSION" > "$BACKUP/deployed-versions.txt"
 (
  cd "$BACKUP"
  sha256sum database-after.dump deployed.sha deployed-versions.txt health.json migrations.txt docker-after.txt >> SHA256SUMS.txt
  sha256sum -c SHA256SUMS.txt
 )
 chmod 600 "$BACKUP"/* "$BACKUP/.env" 2>/dev/null || true
 PHASE="complete"
 trap - ERR
 echo
 echo "============================================================"
 echo " DH V2 · DEPLOY OK"
 echo "============================================================"
 echo "Commit: $TARGET_SHA"
 echo "API:    $EXPECTED_API_VERSION"
 echo "WEB:    $EXPECTED_WEB_VERSION"
 echo "Backup: $BACKUP"
 echo "============================================================"
@@ -1,6 +1,6 @@
 {
  "name": "dhv2-web",
-  "version": "0.20.0-4",
+  "version": "0.20.0-2",
  "private": true,
  "type": "module",
  "engines": {
@@ -34,7 +34,6 @@ import { ReportDetailPage } from '../pages/ReportDetailPage';
 import { VerificationPlanningPage } from '../pages/VerificationPlanningPage';
 import { ActAdministrationPage } from '../pages/ActAdministrationPage';
 import { ActAdministrationDetailPage } from '../pages/ActAdministrationDetailPage';
 import { FieldBriefingsPage } from '../pages/FieldBriefingsPage';
 const MapPage = lazy(() => import('../pages/MapPage').then((module) => ({ default: module.MapPage })));
@@ -66,7 +65,6 @@ export function App() {
        <Route element={<PermissionRoute permission="inspections.read" />}>
          <Route path="/inspecciones" element={<InspectionVisitsPage />} />
          <Route path="/inspecciones/:id" element={<InspectionVisitEditorPage />} />
          <Route path="/preparacion-campo" element={<FieldBriefingsPage />} />
        </Route>
        <Route element={<PermissionRoute permission="inspections.manage" />}><Route path="/inspecciones/nueva" element={<InspectionVisitEditorPage />} /></Route>
        <Route element={<PermissionRoute permission="inspection_acts.read" />}>
@@ -1,2 +1,2 @@
-export const APP_VERSION = '0.20.0-4';
+export const APP_VERSION = '0.20.0-2';
-export const APP_PHASE = 'Fase F1.4 · Briefing contextual antes de salir';
+export const APP_PHASE = 'Fase F1.2 · Seguimiento administrativo por Acta';
@@ -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>;
 }
@@ -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 <>
+  if (!canRead) return null;
-    <FieldBriefingPanel visit={visit} />
+
-    {canRead && <section className="inspection-acts-panel">
+  return <section className="inspection-acts-panel">
-      <div className="panel-heading">
+    <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>
+      <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>
+      <span className="status-badge pending">Sólo lectura</span>
-      </div>
+    </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>
+    <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>}
+    {error && <Alert>{error}</Alert>}
-      {loading ? <LoadingBlock label="Cargando actas…" /> : acts.length === 0
+    {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.'} />
+      ? <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>}
+      : <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>}
+  </section>;
  </>;
 }
@@ -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`);
 }
@@ -16,7 +16,6 @@ interface NavItem {
 const operational: NavItem[] = [
  { to: '/', label: 'Inicio', icon: 'home', permission: 'dashboard.read' },
  { to: '/inspecciones', label: 'Inspecciones', icon: 'clipboard', permission: 'inspections.read' },
  { to: '/preparacion-campo', label: 'Preparación de campo', icon: 'clipboard', permission: 'inspections.read' },
 ];
 const followUp: NavItem[] = [
@@ -1,265 +0,0 @@
 import { useEffect, useMemo, useState } from 'react';
 import { Link } from 'react-router';
 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';
 interface VisitOption {
  id: string;
  code: string;
  status: string;
  plannedStartAt: string | null;
  operationalArea: { name: string } | null;
  operatorCompany: { name: string } | null;
 }
 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;
  };
 }
 interface BriefingAct {
  actId: string;
  actCode: string;
  occurredAt: string;
  adminState: AdminState;
  responseDueOn: string | null;
  responseReceivedOn: string | null;
  committedCorrectionOn: string | null;
  latestResponseId: string | null;
  findings: BriefingFinding[];
 }
 interface FieldBriefing {
  inspection: {
    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;
  };
  plannedOn: string;
  summary: {
    acts: number;
    findings: number;
    inventoryItems: number;
    responseOverdue: number;
    commitmentOverdue: number;
    verificationPending: number;
  };
  acts: BriefingAct[];
 }
 async function getJson<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.';
    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 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' };
 }
 export function FieldBriefingsPage() {
  const [visits, setVisits] = useState<VisitOption[]>([]);
  const [visitId, setVisitId] = useState('');
  const [briefing, setBriefing] = useState<FieldBriefing | null>(null);
  const [loadingVisits, setLoadingVisits] = useState(true);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState('');
  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'),
    ]).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));
  }, []);
  useEffect(() => {
    if (!visitId) {
      setBriefing(null);
      return;
    }
    setLoading(true);
    setError('');
    getJson<FieldBriefing>(`/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],
  );
  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>
      </div>
      {briefing && <button className="button secondary no-print" type="button" onClick={() => window.print()}>
        Imprimir preparación
      </button>}
    </div>
    <div className="form-card no-print">
      <label>Inspección planificada</label>
      {loadingVisits ? <LoadingBlock label="Cargando inspecciones…" /> : <SearchableSelect
        value={visitId}
        onChange={(event) => setVisitId(event.target.value)}
        searchPlaceholder="Buscar por código, Área u Operadora…"
      >
        <option value="">Seleccionar inspección…</option>
        {visits.map((visit) => <option key={visit.id} value={visit.id}>
          {visit.code} · {visit.operationalArea?.name ?? 'Sin Área'} · {visit.operatorCompany?.name ?? 'Sin Operadora'}
        </option>)}
      </SearchableSelect>}
      {selected?.plannedStartAt && <small className="block-muted">Salida prevista: {formatDate(selected.plannedStartAt)}</small>}
    </div>
    {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 && <>
      <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>
        </div>
        <Link className="button secondary no-print" to={`/inspecciones/${briefing.inspection.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>
      </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}>
        <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>
      </article>)}
    </>}
  </section>;
 }
Author	SHA1	Message	Date
admin	9b86dbbc17	test: fix F1.2 source contract paths	2026-09-05 15:10:43 -03:00
github-actions[bot]	0279c22e20	feat: F1.2 materialized act administration	2026-09-05 18:09:17 +00:00
admin	2571bda8c4	chore: bootstrap F1.2 source materialization	2026-09-05 15:09:01 -03:00
`@@ -1,2 +1,2 @@`
	`export const API_VERSION = '0.21.0-1';`	`export const API_VERSION = '0.20.0-2';`
	`export const API_PHASE = 'F2.1';`	`export const API_PHASE = 'F1.2';`
`@@ -1,2 +1,2 @@`
	`export const APP_VERSION = '0.20.0-4';`	`export const APP_VERSION = '0.20.0-2';`
	`export const APP_PHASE = 'Fase F1.4 · Briefing contextual antes de salir';`	`export const APP_PHASE = 'Fase F1.2 · Seguimiento administrativo por Acta';`