616 lines
26 KiB
TypeScript
616 lines
26 KiB
TypeScript
import { createHash } from 'node:crypto';
|
|
import { MigrationInterface, QueryRunner } from 'typeorm';
|
|
import { loadF221ExcelSource } from '../../reference-data/f2-2-1-excel-source';
|
|
|
|
function slug(value: string, max = 70): string {
|
|
const normalized = value
|
|
.normalize('NFD')
|
|
.replace(/[\u0300-\u036f]/g, '')
|
|
.toLowerCase()
|
|
.replace(/[^a-z0-9]+/g, '_')
|
|
.replace(/^_+|_+$/g, '');
|
|
return (normalized || 'item').slice(0, max);
|
|
}
|
|
|
|
function stableCode(prefix: string, ...parts: string[]): string {
|
|
const hash = createHash('sha1').update(parts.join('|')).digest('hex').slice(0, 8).toUpperCase();
|
|
const readable = slug(parts[0] ?? 'item', 72).toUpperCase();
|
|
return `${prefix}-${readable}-${hash}`.slice(0, 120);
|
|
}
|
|
|
|
function legalRightType(value: string): string {
|
|
const normalized = slug(value);
|
|
if (normalized.includes('explot')) return 'EXPLOITATION_CONCESSION';
|
|
if (normalized.includes('explor')) return 'EXPLORATION_PERMIT';
|
|
if (normalized.includes('transport')) return 'TRANSPORT_CONCESSION';
|
|
return 'OTHER';
|
|
}
|
|
|
|
const groupTargets: Record<string, string[]> = {
|
|
tanques: ['tanque'],
|
|
separadores: ['separador'],
|
|
bomba_zona_de_bombas: ['bomba'],
|
|
calderas: ['caldera'],
|
|
drenaje: ['drenaje'],
|
|
antorcha: ['antorcha'],
|
|
colectores: ['colector'],
|
|
sist_electrico_iluminacion: ['sistema_electrico_iluminacion'],
|
|
defensa_contra_incendios: ['defensa_contra_incendios'],
|
|
cargadero_y_descargadero_de_camiones: ['cargadero_descargadero'],
|
|
filtros: ['filtro'],
|
|
eq_flotacion: ['equipo_flotacion'],
|
|
baterias_y_plantas: ['bateria', 'planta'],
|
|
fwko_tratadores_calentadores: ['fwo', 'fwko', 'calentador', 'tratador_termico'],
|
|
bombeo_mecanico: ['bombeo_mecanico'],
|
|
bombeo_electreosumergible: ['bombeo_electreosumergible'],
|
|
bombeo_cavidad_progresiva_pcp: ['bombeo_cavidad_progresiva_pcp'],
|
|
pozos_surgentes_prod_gas: ['pozos_surgentes_prod_gas'],
|
|
pozos_inyectores_agua: ['pozos_inyectores_agua'],
|
|
};
|
|
|
|
const referenceAliases: Record<string, string> = {
|
|
tanque: 'tanque',
|
|
tanques: 'tanque',
|
|
separador: 'separador',
|
|
separadores: 'separador',
|
|
bombas: 'bomba',
|
|
bomba: 'bomba',
|
|
fwo: 'fwo',
|
|
fwko: 'fwko',
|
|
calentador: 'calentador',
|
|
piletas: 'drenaje',
|
|
pileta: 'drenaje',
|
|
cargadero_descargadero: 'cargadero_descargadero',
|
|
generador: 'generador',
|
|
};
|
|
|
|
type IdRow = { id: string };
|
|
type CountRow = { total: string };
|
|
|
|
async function assetIdByCode(queryRunner: QueryRunner, code: string): Promise<string | null> {
|
|
const rows = (await queryRunner.query(
|
|
`SELECT id FROM assets WHERE lower(code)=lower($1::text) LIMIT 1`,
|
|
[code],
|
|
)) as IdRow[];
|
|
return rows[0]?.id ?? null;
|
|
}
|
|
|
|
async function assetTypeIdByCode(queryRunner: QueryRunner, code: string): Promise<string | null> {
|
|
const rows = (await queryRunner.query(
|
|
`SELECT id FROM asset_types WHERE lower(code)=lower($1::text) LIMIT 1`,
|
|
[code],
|
|
)) as IdRow[];
|
|
return rows[0]?.id ?? null;
|
|
}
|
|
|
|
export class PhaseF221ReferenceExcelData1789754400000 implements MigrationInterface {
|
|
name = 'PhaseF221ReferenceExcelData1789754400000';
|
|
|
|
public async up(queryRunner: QueryRunner): Promise<void> {
|
|
const source = loadF221ExcelSource();
|
|
|
|
await queryRunner.query(`
|
|
INSERT INTO source_documents (document_type,document_number,title,issuer,notes)
|
|
SELECT 'SPREADSHEET','DH-F221-TERRITORIO','Tablas de yacimiento(1).xlsx','Dirección de Hidrocarburos',
|
|
'Fuente F2.2.1: maestro territorial y operativo. Hoja normalizada cr26e_tabla1.'
|
|
WHERE NOT EXISTS (
|
|
SELECT 1 FROM source_documents
|
|
WHERE document_number='DH-F221-TERRITORIO' AND issuer='Dirección de Hidrocarburos'
|
|
)
|
|
`);
|
|
await queryRunner.query(`
|
|
INSERT INTO source_documents (document_type,document_number,title,issuer,notes)
|
|
SELECT 'SPREADSHEET','DH-F221-APP','APLICACION APP(1).xlsx','Dirección de Hidrocarburos',
|
|
'Fuente F2.2.1: matriz de jerarquía, información y catálogo contextual de hallazgos. Hojas Hoja1 y Hoja2.'
|
|
WHERE NOT EXISTS (
|
|
SELECT 1 FROM source_documents
|
|
WHERE document_number='DH-F221-APP' AND issuer='Dirección de Hidrocarburos'
|
|
)
|
|
`);
|
|
|
|
const territoryDocuments = (await queryRunner.query(
|
|
`SELECT id FROM source_documents
|
|
WHERE document_number='DH-F221-TERRITORIO' AND issuer='Dirección de Hidrocarburos' LIMIT 1`,
|
|
)) as IdRow[];
|
|
const appDocuments = (await queryRunner.query(
|
|
`SELECT id FROM source_documents
|
|
WHERE document_number='DH-F221-APP' AND issuer='Dirección de Hidrocarburos' LIMIT 1`,
|
|
)) as IdRow[];
|
|
const territoryDocumentId = territoryDocuments[0]?.id;
|
|
const appDocumentId = appDocuments[0]?.id;
|
|
if (!territoryDocumentId || !appDocumentId) {
|
|
throw new Error('F2.2.1 source documents could not be resolved');
|
|
}
|
|
|
|
await queryRunner.query(
|
|
`UPDATE asset_types SET can_be_root=true WHERE operational_role IN ('AREA','COMPANY')`,
|
|
);
|
|
await queryRunner.query(`
|
|
INSERT INTO asset_types (code,name,description,can_be_root,is_active,operational_role)
|
|
SELECT 'yacimiento','Yacimiento',
|
|
'Yacimiento físico/operativo perteneciente a un Área. Su operadora se determina por contexto histórico.',
|
|
false,true,'GENERIC'
|
|
WHERE NOT EXISTS (SELECT 1 FROM asset_types WHERE lower(code)='yacimiento')
|
|
`);
|
|
await queryRunner.query(`
|
|
INSERT INTO asset_type_parent_rules (child_type_id,parent_type_id)
|
|
SELECT child.id,parent.id
|
|
FROM asset_types child CROSS JOIN asset_types parent
|
|
WHERE lower(child.code)='yacimiento' AND parent.operational_role='AREA'
|
|
ON CONFLICT DO NOTHING
|
|
`);
|
|
await queryRunner.query(`
|
|
INSERT INTO asset_attribute_definitions
|
|
(asset_type_id,code,name,data_type,is_required,is_active,sort_order)
|
|
SELECT type.id,definition.code,definition.name,'TEXT',false,true,definition.sort_order
|
|
FROM asset_types type
|
|
CROSS JOIN (VALUES
|
|
('departamento_fuente','Departamento informado por la fuente',10),
|
|
('tipo_concesion_fuente','Tipo de concesión informado por la fuente',20)
|
|
) definition(code,name,sort_order)
|
|
WHERE lower(type.code)='yacimiento'
|
|
ON CONFLICT DO NOTHING
|
|
`);
|
|
await queryRunner.query(`
|
|
INSERT INTO asset_attribute_definitions
|
|
(asset_type_id,code,name,data_type,is_required,is_active,sort_order)
|
|
SELECT type.id,'tipo_concesion_fuente','Tipo de concesión informado por la fuente',
|
|
'TEXT',false,true,40
|
|
FROM asset_types type
|
|
WHERE type.operational_role='AREA'
|
|
ON CONFLICT DO NOTHING
|
|
`);
|
|
|
|
const areaCache = new Map<string, string>();
|
|
const companyCache = new Map<string, string>();
|
|
const seenRights = new Set<string>();
|
|
|
|
for (const row of source.territory) {
|
|
const areaKey = row.area.trim().toLocaleLowerCase('es');
|
|
let areaId = areaCache.get(areaKey) ?? null;
|
|
if (!areaId) {
|
|
const areaCode = stableCode('AREA', row.area);
|
|
areaId = await assetIdByCode(queryRunner, areaCode);
|
|
if (!areaId) {
|
|
const inserted = (await queryRunner.query(
|
|
`INSERT INTO assets (
|
|
asset_type_id,parent_id,code,name,description,information_status,operational_status,
|
|
data_origin,source_name,source_reference,source_notes,current_version
|
|
)
|
|
SELECT type.id,NULL,$1::varchar,$2::varchar,$3::text,
|
|
'VALIDATED','IN_SERVICE','IMPORT',$4::varchar,$5::varchar,$6::text,0
|
|
FROM asset_types type
|
|
WHERE type.operational_role='AREA'
|
|
LIMIT 1
|
|
RETURNING id`,
|
|
[
|
|
areaCode,
|
|
row.area,
|
|
`Área importada desde Tablas de yacimiento. Departamento: ${row.department}.`,
|
|
'Tablas de yacimiento(1).xlsx',
|
|
`cr26e_tabla1|AREA|${row.area}`,
|
|
`Departamento=${row.department}; TipoConcesion=${row.concessionType}`,
|
|
],
|
|
)) as IdRow[];
|
|
areaId = inserted[0]?.id ?? null;
|
|
}
|
|
if (!areaId) throw new Error(`Could not resolve area ${row.area}`);
|
|
areaCache.set(areaKey, areaId);
|
|
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_source_documents (asset_id,document_id,relation_type,notes)
|
|
VALUES ($1::uuid,$2::uuid,'SOURCE','Importación F2.2.1 · cr26e_tabla1')
|
|
ON CONFLICT DO NOTHING`,
|
|
[areaId, territoryDocumentId],
|
|
);
|
|
}
|
|
|
|
for (const [definitionCode, value] of [
|
|
['departamento', row.department],
|
|
['tipo_concesion_fuente', row.concessionType],
|
|
] as const) {
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_attribute_values (asset_id,definition_id,value)
|
|
SELECT $1::uuid,definition.id,to_jsonb($3::text)
|
|
FROM asset_attribute_definitions definition
|
|
JOIN asset_types type ON type.id=definition.asset_type_id
|
|
WHERE type.operational_role='AREA'
|
|
AND lower(definition.code)=lower($2::text)
|
|
ON CONFLICT (asset_id,definition_id)
|
|
DO UPDATE SET value=EXCLUDED.value,updated_at=CURRENT_TIMESTAMP`,
|
|
[areaId, definitionCode, value],
|
|
);
|
|
}
|
|
|
|
const noOperator = slug(row.operator) === 'sin_empresa_operadora';
|
|
let companyId: string | null = null;
|
|
if (!noOperator) {
|
|
const companyKey = row.operator.trim().toLocaleLowerCase('es');
|
|
companyId = companyCache.get(companyKey) ?? null;
|
|
if (!companyId) {
|
|
const companyCode = stableCode('ORG', row.operator);
|
|
companyId = await assetIdByCode(queryRunner, companyCode);
|
|
if (!companyId) {
|
|
const inserted = (await queryRunner.query(
|
|
`INSERT INTO assets (
|
|
asset_type_id,parent_id,code,name,description,information_status,operational_status,
|
|
data_origin,source_name,source_reference,source_notes,current_version
|
|
)
|
|
SELECT type.id,NULL,$1::varchar,$2::varchar,
|
|
'Organización operadora importada desde Tablas de yacimiento.',
|
|
'VALIDATED','IN_SERVICE','IMPORT',$3::varchar,$4::varchar,
|
|
'Empresa/Operadora informada por la fuente',0
|
|
FROM asset_types type
|
|
WHERE type.operational_role='COMPANY'
|
|
LIMIT 1
|
|
RETURNING id`,
|
|
[
|
|
companyCode,
|
|
row.operator,
|
|
'Tablas de yacimiento(1).xlsx',
|
|
`cr26e_tabla1|OPERADORA|${row.operator}`,
|
|
],
|
|
)) as IdRow[];
|
|
companyId = inserted[0]?.id ?? null;
|
|
}
|
|
if (!companyId) throw new Error(`Could not resolve operator ${row.operator}`);
|
|
companyCache.set(companyKey, companyId);
|
|
|
|
await queryRunner.query(
|
|
`INSERT INTO organization_profiles (asset_id,organization_kind,legal_name)
|
|
SELECT $1::uuid,
|
|
CASE WHEN lower($2::text) LIKE 'ute %' OR lower($2::text) LIKE 'ute(%'
|
|
THEN 'UTE'::organization_kind ELSE 'COMPANY'::organization_kind END,
|
|
$2::varchar
|
|
WHERE NOT EXISTS (SELECT 1 FROM organization_profiles WHERE asset_id=$1::uuid)`,
|
|
[companyId, row.operator],
|
|
);
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_source_documents (asset_id,document_id,relation_type,notes)
|
|
VALUES ($1::uuid,$2::uuid,'SOURCE','Importación F2.2.1 · cr26e_tabla1')
|
|
ON CONFLICT DO NOTHING`,
|
|
[companyId, territoryDocumentId],
|
|
);
|
|
}
|
|
|
|
await queryRunner.query(
|
|
`INSERT INTO area_company_relations
|
|
(area_id,company_id,relation_role,valid_from,start_reason,source_document_id)
|
|
SELECT $1::uuid,$2::uuid,'OPERATOR',CURRENT_TIMESTAMP,
|
|
'Importado desde Tablas de yacimiento(1).xlsx',$3::uuid
|
|
WHERE NOT EXISTS (
|
|
SELECT 1 FROM area_company_relations
|
|
WHERE area_id=$1::uuid AND company_id=$2::uuid
|
|
AND relation_role='OPERATOR' AND valid_until IS NULL
|
|
)`,
|
|
[areaId, companyId, territoryDocumentId],
|
|
);
|
|
}
|
|
|
|
const fieldCode = stableCode('YAC', row.field, row.area);
|
|
let fieldId = await assetIdByCode(queryRunner, fieldCode);
|
|
if (!fieldId) {
|
|
// The operational context is intentionally all-or-nothing. A source row
|
|
// that explicitly says "Sin Empresa Operadora" stays physically under
|
|
// its Área but receives no fabricated operator and no half context.
|
|
const operationalAreaId = companyId ? areaId : null;
|
|
const inserted = (await queryRunner.query(
|
|
`INSERT INTO assets (
|
|
asset_type_id,parent_id,operational_area_id,operator_company_id,code,name,description,
|
|
information_status,operational_status,data_origin,source_name,source_reference,
|
|
source_notes,current_version
|
|
)
|
|
SELECT type.id,$1::uuid,$2::uuid,$3::uuid,$4::varchar,$5::varchar,$6::text,
|
|
'VALIDATED','IN_SERVICE','IMPORT',$7::varchar,$8::varchar,$9::text,0
|
|
FROM asset_types type
|
|
WHERE lower(type.code)='yacimiento'
|
|
LIMIT 1
|
|
RETURNING id`,
|
|
[
|
|
areaId,
|
|
operationalAreaId,
|
|
companyId,
|
|
fieldCode,
|
|
row.field,
|
|
`Yacimiento del Área ${row.area}.`,
|
|
'Tablas de yacimiento(1).xlsx',
|
|
`cr26e_tabla1|YACIMIENTO|${row.field}|AREA|${row.area}`,
|
|
`Departamento=${row.department}; TipoConcesion=${row.concessionType}; OperadoraFuente=${row.operator}`,
|
|
],
|
|
)) as IdRow[];
|
|
fieldId = inserted[0]?.id ?? null;
|
|
}
|
|
if (!fieldId) throw new Error(`Could not resolve field ${row.field} / ${row.area}`);
|
|
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_source_documents (asset_id,document_id,relation_type,notes)
|
|
VALUES ($1::uuid,$2::uuid,'SOURCE','Importación F2.2.1 · cr26e_tabla1')
|
|
ON CONFLICT DO NOTHING`,
|
|
[fieldId, territoryDocumentId],
|
|
);
|
|
for (const [definitionCode, value] of [
|
|
['departamento_fuente', row.department],
|
|
['tipo_concesion_fuente', row.concessionType],
|
|
] as const) {
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_attribute_values (asset_id,definition_id,value)
|
|
SELECT $1::uuid,definition.id,to_jsonb($3::text)
|
|
FROM asset_attribute_definitions definition
|
|
JOIN asset_types type ON type.id=definition.asset_type_id
|
|
WHERE lower(type.code)='yacimiento'
|
|
AND lower(definition.code)=lower($2::text)
|
|
ON CONFLICT (asset_id,definition_id)
|
|
DO UPDATE SET value=EXCLUDED.value,updated_at=CURRENT_TIMESTAMP`,
|
|
[fieldId, definitionCode, value],
|
|
);
|
|
}
|
|
|
|
const rightName = `Tipo informado: ${row.concessionType}`;
|
|
const rightKey = `${areaId}|${slug(row.concessionType)}`;
|
|
if (!seenRights.has(rightKey)) {
|
|
seenRights.add(rightKey);
|
|
const existing = (await queryRunner.query(
|
|
`SELECT id FROM area_legal_rights
|
|
WHERE area_id=$1::uuid AND lower(name)=lower($2::text)
|
|
AND source_document_id=$3::uuid LIMIT 1`,
|
|
[areaId, rightName, territoryDocumentId],
|
|
)) as IdRow[];
|
|
if (!existing[0]?.id) {
|
|
await queryRunner.query(
|
|
`INSERT INTO area_legal_rights
|
|
(area_id,right_type,name,status,source_document_id,notes)
|
|
VALUES ($1::uuid,$2::area_legal_right_type,$3::varchar,'ACTIVE',$4::uuid,$5::text)`,
|
|
[
|
|
areaId,
|
|
legalRightType(row.concessionType),
|
|
rightName,
|
|
territoryDocumentId,
|
|
`Importado desde cr26e_tabla1. Departamento: ${row.department}.`,
|
|
],
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
const topLevelTypes = new Set(source.types.map((entry) => entry.code));
|
|
for (const pair of source.parentPairs) topLevelTypes.delete(pair.child);
|
|
|
|
const allTypeDefinitions = new Map(source.types.map((entry) => [entry.code, entry.name]));
|
|
for (const targets of Object.values(groupTargets)) {
|
|
for (const target of targets) {
|
|
if (!allTypeDefinitions.has(target)) {
|
|
allTypeDefinitions.set(target, target.replaceAll('_', ' '));
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const [typeCode, typeName] of allTypeDefinitions) {
|
|
if (!(await assetTypeIdByCode(queryRunner, typeCode))) {
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_types (code,name,description,can_be_root,is_active,operational_role)
|
|
VALUES ($1::varchar,$2::varchar,
|
|
'Tipo incorporado desde APLICACION APP(1).xlsx · F2.2.1',false,true,'GENERIC')`,
|
|
[typeCode, typeName],
|
|
);
|
|
}
|
|
await queryRunner.query(
|
|
`INSERT INTO finding_catalog_asset_type_profiles (asset_type_id,reason)
|
|
SELECT id,'Aplicabilidad inicial importada desde APLICACION APP(1).xlsx'
|
|
FROM asset_types WHERE lower(code)=lower($1::text)
|
|
ON CONFLICT (asset_type_id) DO NOTHING`,
|
|
[typeCode],
|
|
);
|
|
}
|
|
|
|
for (const typeCode of topLevelTypes) {
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_type_parent_rules (child_type_id,parent_type_id)
|
|
SELECT child.id,parent.id FROM asset_types child CROSS JOIN asset_types parent
|
|
WHERE lower(child.code)=lower($1::text) AND lower(parent.code)='yacimiento'
|
|
ON CONFLICT DO NOTHING`,
|
|
[typeCode],
|
|
);
|
|
}
|
|
for (const pair of source.parentPairs) {
|
|
if (pair.child === pair.parent) continue;
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_type_parent_rules (child_type_id,parent_type_id)
|
|
SELECT child.id,parent.id FROM asset_types child CROSS JOIN asset_types parent
|
|
WHERE lower(child.code)=lower($1::text) AND lower(parent.code)=lower($2::text)
|
|
ON CONFLICT DO NOTHING`,
|
|
[pair.child, pair.parent],
|
|
);
|
|
}
|
|
for (const targets of Object.values(groupTargets)) {
|
|
for (const typeCode of targets) {
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_type_parent_rules (child_type_id,parent_type_id)
|
|
SELECT child.id,parent.id FROM asset_types child CROSS JOIN asset_types parent
|
|
WHERE lower(child.code)=lower($1::text) AND lower(parent.code)='yacimiento'
|
|
ON CONFLICT DO NOTHING`,
|
|
[typeCode],
|
|
);
|
|
}
|
|
}
|
|
|
|
for (const entry of source.attributes) {
|
|
let sortOrder = 100;
|
|
for (const label of entry.labels) {
|
|
const attributeCode = slug(label, 72);
|
|
const typeId = await assetTypeIdByCode(queryRunner, entry.type);
|
|
if (!typeId) continue;
|
|
const existing = (await queryRunner.query(
|
|
`SELECT id FROM asset_attribute_definitions
|
|
WHERE asset_type_id=$1::uuid AND lower(code)=lower($2::text) LIMIT 1`,
|
|
[typeId, attributeCode],
|
|
)) as IdRow[];
|
|
if (!existing[0]?.id) {
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_attribute_definitions
|
|
(asset_type_id,code,name,data_type,is_required,is_active,sort_order)
|
|
VALUES ($1::uuid,$2::varchar,$3::varchar,'TEXT',false,true,$4::integer)`,
|
|
[typeId, attributeCode, label, sortOrder],
|
|
);
|
|
}
|
|
sortOrder += 10;
|
|
}
|
|
}
|
|
|
|
await queryRunner.query(`
|
|
INSERT INTO finding_categories (code,name,sort_order,is_active)
|
|
SELECT 'APP26','Aplicación APP 2026',260,true
|
|
WHERE NOT EXISTS (SELECT 1 FROM finding_categories WHERE lower(code)='app26')
|
|
`);
|
|
const categoryRows = (await queryRunner.query(
|
|
`SELECT id FROM finding_categories WHERE lower(code)='app26' LIMIT 1`,
|
|
)) as IdRow[];
|
|
const categoryId = categoryRows[0]?.id;
|
|
if (!categoryId) throw new Error('Could not resolve APP26 finding category');
|
|
|
|
const titlesByType = new Map<string, Set<string>>();
|
|
const addTitle = (typeCode: string, title: string): void => {
|
|
const cleanTitle = title.trim();
|
|
if (!cleanTitle || /^idem\b/i.test(cleanTitle)) return;
|
|
const set = titlesByType.get(typeCode) ?? new Set<string>();
|
|
set.add(cleanTitle);
|
|
titlesByType.set(typeCode, set);
|
|
};
|
|
|
|
for (const entry of source.directFindings) {
|
|
for (const title of entry.titles) addTitle(entry.type, title);
|
|
}
|
|
for (const group of source.groups) {
|
|
const targets = groupTargets[slug(group.name)] ?? [slug(group.name)];
|
|
for (const target of targets) {
|
|
for (const item of group.items) addTitle(target, item.title);
|
|
}
|
|
}
|
|
for (let pass = 0; pass < 3; pass += 1) {
|
|
for (const entry of source.idemRefs) {
|
|
for (const rawReference of entry.refs) {
|
|
const reference = referenceAliases[slug(rawReference)] ?? slug(rawReference);
|
|
for (const title of titlesByType.get(reference) ?? []) addTitle(entry.type, title);
|
|
}
|
|
}
|
|
}
|
|
|
|
const allTitles = [
|
|
...new Set([...titlesByType.values()].flatMap((titles) => [...titles])),
|
|
].sort((a, b) => a.localeCompare(b, 'es'));
|
|
|
|
const itemIdByTitle = new Map<string, string>();
|
|
let sourceNumber = 1;
|
|
for (const title of allTitles) {
|
|
const itemCode = `APP26-${createHash('sha1').update(title).digest('hex').slice(0, 12).toUpperCase()}`;
|
|
let itemRows = (await queryRunner.query(
|
|
`SELECT id FROM finding_catalog_items WHERE lower(code)=lower($1::text) LIMIT 1`,
|
|
[itemCode],
|
|
)) as IdRow[];
|
|
if (!itemRows[0]?.id) {
|
|
itemRows = (await queryRunner.query(
|
|
`INSERT INTO finding_catalog_items
|
|
(category_id,code,source_number,title,import_note,revision,is_active)
|
|
VALUES ($1::uuid,$2::varchar,$3::integer,$4::varchar,
|
|
'Importado desde APLICACION APP(1).xlsx · F2.2.1',1,true)
|
|
RETURNING id`,
|
|
[categoryId, itemCode, sourceNumber, title],
|
|
)) as IdRow[];
|
|
}
|
|
const itemId = itemRows[0]?.id;
|
|
if (itemId) {
|
|
itemIdByTitle.set(title, itemId);
|
|
await queryRunner.query(
|
|
`INSERT INTO finding_catalog_item_versions
|
|
(item_id,revision,snapshot,actor_username)
|
|
SELECT item.id,item.revision,
|
|
jsonb_build_object(
|
|
'id',item.id,'categoryId',category.id,'categoryCode',category.code,
|
|
'categoryName',category.name,'code',item.code,'sourceNumber',item.source_number,
|
|
'title',item.title,'legalBasis',item.legal_basis,'glossary',item.glossary,
|
|
'importNote',item.import_note,'revision',item.revision,'isActive',item.is_active
|
|
),
|
|
'migration:F2.2.1'
|
|
FROM finding_catalog_items item
|
|
JOIN finding_categories category ON category.id=item.category_id
|
|
WHERE item.id=$1::uuid
|
|
AND NOT EXISTS (
|
|
SELECT 1 FROM finding_catalog_item_versions version
|
|
WHERE version.item_id=item.id AND version.revision=item.revision
|
|
)`,
|
|
[itemId],
|
|
);
|
|
}
|
|
sourceNumber += 1;
|
|
}
|
|
|
|
for (const [typeCode, titles] of titlesByType) {
|
|
const assetTypeId = await assetTypeIdByCode(queryRunner, typeCode);
|
|
if (!assetTypeId) continue;
|
|
for (const title of titles) {
|
|
const catalogItemId = itemIdByTitle.get(title);
|
|
if (!catalogItemId) continue;
|
|
await queryRunner.query(
|
|
`INSERT INTO finding_catalog_item_asset_types (catalog_item_id,asset_type_id)
|
|
VALUES ($1::uuid,$2::uuid) ON CONFLICT DO NOTHING`,
|
|
[catalogItemId, assetTypeId],
|
|
);
|
|
}
|
|
}
|
|
|
|
await queryRunner.query(
|
|
`INSERT INTO asset_source_documents (asset_id,document_id,relation_type,notes)
|
|
SELECT asset.id,$1::uuid,'MENTIONS',
|
|
'El tipo/hallazgo del elemento se definió con la matriz APLICACION APP(1).xlsx'
|
|
FROM assets asset
|
|
JOIN asset_types type ON type.id=asset.asset_type_id
|
|
WHERE lower(type.code)='yacimiento'
|
|
ON CONFLICT DO NOTHING`,
|
|
[appDocumentId],
|
|
);
|
|
|
|
const importedYacimientos = (await queryRunner.query(
|
|
`SELECT count(*)::text AS total
|
|
FROM assets asset JOIN asset_types type ON type.id=asset.asset_type_id
|
|
WHERE asset.data_origin='IMPORT'
|
|
AND asset.source_name='Tablas de yacimiento(1).xlsx'
|
|
AND lower(type.code)='yacimiento'`,
|
|
)) as CountRow[];
|
|
if (Number(importedYacimientos[0]?.total ?? 0) !== source.territory.length) {
|
|
throw new Error(
|
|
`F2.2.1 verification failed: expected ${source.territory.length} imported yacimientos, found ${importedYacimientos[0]?.total ?? '0'}`,
|
|
);
|
|
}
|
|
|
|
const importedCatalog = (await queryRunner.query(
|
|
`SELECT count(*)::text AS total
|
|
FROM finding_catalog_items item
|
|
JOIN finding_categories category ON category.id=item.category_id
|
|
WHERE lower(category.code)='app26'`,
|
|
)) as CountRow[];
|
|
if (Number(importedCatalog[0]?.total ?? 0) !== allTitles.length) {
|
|
throw new Error(
|
|
`F2.2.1 verification failed: expected ${allTitles.length} APP26 findings, found ${importedCatalog[0]?.total ?? '0'}`,
|
|
);
|
|
}
|
|
|
|
const halfContexts = (await queryRunner.query(
|
|
`SELECT count(*)::text AS total FROM assets
|
|
WHERE (operational_area_id IS NULL) <> (operator_company_id IS NULL)`,
|
|
)) as CountRow[];
|
|
if (Number(halfContexts[0]?.total ?? 0) !== 0) {
|
|
throw new Error('F2.2.1 verification failed: an imported asset has an incomplete operational context');
|
|
}
|
|
|
|
// eslint-disable-next-line no-console
|
|
console.log(
|
|
`[F2.2.1] imported territory=${source.territory.length}; yacimientos=${importedYacimientos[0]?.total}; catalog=${importedCatalog[0]?.total}; halfContexts=0`,
|
|
);
|
|
}
|
|
|
|
public async down(): Promise<void> {
|
|
throw new Error(
|
|
'F2.2.1 contiene maestros territoriales y catálogo de referencia; no se revierte destructivamente. Restaurar backup PRE si fuera necesario.',
|
|
);
|
|
}
|
|
}
|