admin
d938db7913
Jerarquía física definitiva, compatibilidades N↔N de clasificaciones, Hallazgos y campos técnicos por familia, navegación WEB/Android y APK F6 0.14.0-debug.
418 lines
19 KiB
TypeScript
418 lines
19 KiB
TypeScript
import { randomUUID } from 'node:crypto';
|
|
import {
|
|
BadRequestException,
|
|
ConflictException,
|
|
Injectable,
|
|
NotFoundException,
|
|
} from '@nestjs/common';
|
|
import { DataSource, EntityManager } from 'typeorm';
|
|
import { administrationAuditContext, isUniqueViolation } from '../administration/common/administration-audit';
|
|
import { AuditService } from '../audit/audit.service';
|
|
import type { AuthPrincipal, RequestWithContext } from '../common/http/request-context';
|
|
import {
|
|
AssetDataOrigin,
|
|
AssetInformationStatus,
|
|
AssetOperationalStatus,
|
|
AssetVersionChangeType,
|
|
AuditAction,
|
|
} from '../database/entities';
|
|
import type { CreateInventoryStructureDto, InventoryStructureKind } from './dto/create-inventory-structure.dto';
|
|
import { AssetHistoryService } from './asset-history.service';
|
|
|
|
type StructureTypeRow = { id: string; code: string; name: string };
|
|
type FamilyParent = { id: string; code: string; name: string };
|
|
type FamilyRow = {
|
|
id: string;
|
|
code: string;
|
|
name: string;
|
|
level: 'INSTALLATION' | 'SUBINSTALLATION';
|
|
legacyTypeCode: string | null;
|
|
informationLabels: string[];
|
|
parentFamilyIds: string[];
|
|
parentFamilies: FamilyParent[];
|
|
};
|
|
type ParentRow = {
|
|
id: string;
|
|
code: string;
|
|
name: string;
|
|
typeCode: string;
|
|
inventoryFamilyId: string | null;
|
|
};
|
|
type IdRow = { id: string };
|
|
|
|
const TYPE_CODE_BY_KIND: Record<Exclude<InventoryStructureKind, 'EMPRESA'>, string> = {
|
|
DEPARTAMENTO: 'departamento',
|
|
AREA: 'area',
|
|
YACIMIENTO: 'yacimiento',
|
|
INSTALACION: 'instalacion',
|
|
SUBINSTALACION: 'subinstalacion',
|
|
};
|
|
const PARENT_TYPE_BY_KIND: Record<InventoryStructureKind, string | null> = {
|
|
EMPRESA: null,
|
|
DEPARTAMENTO: null,
|
|
AREA: 'departamento',
|
|
YACIMIENTO: 'area',
|
|
INSTALACION: 'yacimiento',
|
|
SUBINSTALACION: 'instalacion',
|
|
};
|
|
const FAMILY_LEVEL_BY_KIND: Partial<Record<InventoryStructureKind, FamilyRow['level']>> = {
|
|
INSTALACION: 'INSTALLATION',
|
|
SUBINSTALACION: 'SUBINSTALLATION',
|
|
};
|
|
|
|
@Injectable()
|
|
export class InventoryStructureService {
|
|
constructor(
|
|
private readonly dataSource: DataSource,
|
|
private readonly audit: AuditService,
|
|
private readonly history: AssetHistoryService,
|
|
) {}
|
|
|
|
async options() {
|
|
const types = (await this.dataSource.query(`
|
|
SELECT id,code,name
|
|
FROM asset_types
|
|
WHERE (
|
|
lower(code) IN ('departamento','area','yacimiento','instalacion','subinstalacion')
|
|
OR operational_role='COMPANY'
|
|
) AND is_active=true
|
|
ORDER BY CASE
|
|
WHEN operational_role='COMPANY' THEN 0
|
|
WHEN lower(code)='departamento' THEN 1
|
|
WHEN lower(code)='area' THEN 2
|
|
WHEN lower(code)='yacimiento' THEN 3
|
|
WHEN lower(code)='instalacion' THEN 4
|
|
WHEN lower(code)='subinstalacion' THEN 5 ELSE 9 END
|
|
`)) as StructureTypeRow[];
|
|
const company = types.find((item) => ['empresa','organizacion'].includes(item.code.toLowerCase()));
|
|
const departamento = types.find((item) => item.code.toLowerCase()==='departamento');
|
|
const area = types.find((item) => item.code.toLowerCase()==='area');
|
|
const yacimiento = types.find((item) => item.code.toLowerCase()==='yacimiento');
|
|
const instalacion = types.find((item) => item.code.toLowerCase()==='instalacion');
|
|
const subinstalacion = types.find((item) => item.code.toLowerCase()==='subinstalacion');
|
|
if (!company || !departamento || !area || !yacimiento || !instalacion || !subinstalacion) {
|
|
throw new ConflictException({
|
|
code: 'INVENTORY_STRUCTURE_TYPES_INCOMPLETE',
|
|
message: 'La configuración maestra de Empresa e Inventario todavía no está completa',
|
|
});
|
|
}
|
|
|
|
const families = (await this.dataSource.query(`
|
|
SELECT family.id,family.code,family.name,family.level,
|
|
family.legacy_type_code AS "legacyTypeCode",
|
|
family.information_labels AS "informationLabels",
|
|
COALESCE((SELECT JSONB_AGG(rule.parent_family_id ORDER BY parent.name,parent.code)
|
|
FROM inventory_family_parent_rules rule
|
|
JOIN inventory_families parent ON parent.id=rule.parent_family_id
|
|
WHERE rule.child_family_id=family.id),'[]'::jsonb) AS "parentFamilyIds",
|
|
COALESCE((SELECT JSONB_AGG(JSONB_BUILD_OBJECT('id',parent.id,'code',parent.code,'name',parent.name) ORDER BY parent.name,parent.code)
|
|
FROM inventory_family_parent_rules rule
|
|
JOIN inventory_families parent ON parent.id=rule.parent_family_id
|
|
WHERE rule.child_family_id=family.id),'[]'::jsonb) AS "parentFamilies"
|
|
FROM inventory_families family
|
|
WHERE family.is_active=true
|
|
ORDER BY family.level,family.name,family.code
|
|
`)) as FamilyRow[];
|
|
|
|
return {
|
|
independentMasters: [
|
|
{ kind: 'EMPRESA', label: 'Empresa', type: company, parentKind: null, requiresFamily: false },
|
|
],
|
|
levels: [
|
|
{ kind: 'DEPARTAMENTO', label: 'Departamento', type: departamento, parentKind: null, requiresFamily: false },
|
|
{ kind: 'AREA', label: 'Área', type: area, parentKind: 'DEPARTAMENTO', requiresFamily: false },
|
|
{ kind: 'YACIMIENTO', label: 'Yacimiento', type: yacimiento, parentKind: 'AREA', requiresFamily: false },
|
|
{ kind: 'INSTALACION', label: 'Instalación', type: instalacion, parentKind: 'YACIMIENTO', requiresFamily: true },
|
|
{ kind: 'SUBINSTALACION', label: 'Subinstalación', type: subinstalacion, parentKind: 'INSTALACION', requiresFamily: true },
|
|
],
|
|
installationFamilies: families.filter((item) => item.level==='INSTALLATION'),
|
|
subinstallationFamilies: families.filter((item) => item.level==='SUBINSTALLATION'),
|
|
};
|
|
}
|
|
|
|
async parents(kindValue: string, search?: string) {
|
|
const kind = kindValue.toUpperCase() as InventoryStructureKind;
|
|
if (!(kind in PARENT_TYPE_BY_KIND) || kind === 'DEPARTAMENTO' || kind === 'EMPRESA') {
|
|
throw new BadRequestException({
|
|
code: 'INVENTORY_STRUCTURE_PARENT_KIND_INVALID',
|
|
message: 'El nivel indicado no requiere un registro padre',
|
|
});
|
|
}
|
|
const expectedType = PARENT_TYPE_BY_KIND[kind];
|
|
const parameters: unknown[] = [expectedType];
|
|
let searchSql = '';
|
|
if (search?.trim()) {
|
|
parameters.push(`%${search.trim()}%`);
|
|
searchSql = `AND (asset.code ILIKE $2 OR asset.name ILIKE $2 OR COALESCE(asset.common_name,'') ILIKE $2)`;
|
|
}
|
|
const rows = await this.dataSource.query(`
|
|
SELECT
|
|
asset.id,asset.code,asset.name,asset.common_name AS "commonName",
|
|
JSONB_BUILD_OBJECT('id',type.id,'code',type.code,'name',type.name) AS type,
|
|
CASE WHEN family.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
|
|
'id',family.id,'code',family.code,'name',family.name,'level',family.level,
|
|
'informationLabels',family.information_labels
|
|
) END AS "inventoryFamily",
|
|
CASE WHEN parent.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
|
|
'id',parent.id,'code',parent.code,'name',parent.name
|
|
) END AS parent
|
|
FROM assets asset
|
|
JOIN asset_types type ON type.id=asset.asset_type_id
|
|
LEFT JOIN inventory_families family ON family.id=asset.inventory_family_id
|
|
LEFT JOIN assets parent ON parent.id=asset.parent_id
|
|
WHERE lower(type.code)=lower($1::text)
|
|
AND asset.information_status<>'INACTIVE'
|
|
${searchSql}
|
|
ORDER BY asset.name,asset.code
|
|
LIMIT 100
|
|
`, parameters);
|
|
return { data: rows };
|
|
}
|
|
|
|
async create(
|
|
dto: CreateInventoryStructureDto,
|
|
principal: AuthPrincipal,
|
|
request: RequestWithContext,
|
|
) {
|
|
try {
|
|
return await this.dataSource.transaction(async (manager) => {
|
|
const type = await this.requireStructureType(manager, dto.kind);
|
|
const parent = await this.requireParent(manager, dto.kind, dto.parentId ?? null);
|
|
const family = await this.requireFamily(manager, dto.kind, dto.familyId ?? null, parent);
|
|
const generatedCode = dto.code?.trim().toUpperCase() || this.generatedCode(dto.kind, dto.name);
|
|
const operationalAreaId = parent && ['YACIMIENTO','INSTALACION','SUBINSTALACION'].includes(dto.kind)
|
|
? await this.resolveAreaId(manager, parent)
|
|
: null;
|
|
|
|
const inserted = (await manager.query(`
|
|
INSERT INTO assets (
|
|
asset_type_id,parent_id,operational_area_id,operator_company_id,inventory_family_id,
|
|
code,name,common_name,description,information_status,operational_status,
|
|
data_origin,source_name,source_reference,source_notes,created_by,updated_by,provenance_updated_by
|
|
) VALUES (
|
|
$1::uuid,$2::uuid,$3::uuid,NULL,$4::uuid,
|
|
$5::varchar,$6::varchar,$7::varchar,$8::text,$9::asset_information_status,$10::asset_operational_status,
|
|
$11::varchar,$12::varchar,$13::varchar,$14::text,$15::uuid,$15::uuid,$15::uuid
|
|
) RETURNING id
|
|
`, [
|
|
type.id,
|
|
parent?.id ?? null,
|
|
operationalAreaId,
|
|
family?.id ?? null,
|
|
generatedCode,
|
|
dto.name,
|
|
dto.commonName ?? null,
|
|
dto.description ?? null,
|
|
AssetInformationStatus.DRAFT,
|
|
AssetOperationalStatus.UNKNOWN,
|
|
AssetDataOrigin.MANUAL,
|
|
dto.kind === 'EMPRESA' ? 'Maestro manual de Empresas F6' : 'Estructura manual de Inventario F6',
|
|
dto.kind === 'EMPRESA' ? 'inventory-master:empresa' : `inventory-structure:${dto.kind.toLowerCase()}`,
|
|
family ? `Clasificación técnica: ${family.code} · ${family.name}` : null,
|
|
principal.userId,
|
|
])) as Array<{ id: string }>;
|
|
const id = inserted[0]?.id;
|
|
if (!id) throw new Error('No se pudo crear el registro');
|
|
|
|
if (dto.kind === 'EMPRESA') {
|
|
await manager.query(`
|
|
INSERT INTO organization_profiles(asset_id,organization_kind,legal_name,updated_by)
|
|
VALUES ($1::uuid,'COMPANY',$2,$3::uuid)
|
|
ON CONFLICT (asset_id) DO UPDATE SET legal_name=EXCLUDED.legal_name,updated_by=EXCLUDED.updated_by,updated_at=CURRENT_TIMESTAMP
|
|
`,[id,dto.name,principal.userId]);
|
|
}
|
|
|
|
const versionNumber = await this.history.capture(
|
|
manager,id,AssetVersionChangeType.CREATED,principal,request,
|
|
);
|
|
await manager.query(`
|
|
INSERT INTO asset_context_history (
|
|
asset_id,parent_id,operational_area_id,operator_company_id,valid_from,
|
|
change_reason,asset_version_number,source,request_id,created_by
|
|
) VALUES ($1,$2,$3,NULL,CURRENT_TIMESTAMP,$4,$5,'WEB',$6,$7)
|
|
`, [
|
|
id,parent?.id ?? null,operationalAreaId,
|
|
dto.kind === 'EMPRESA' ? 'Alta manual de Empresa independiente F6' : 'Alta manual de estructura de Inventario F6',
|
|
versionNumber,request.requestId,principal.userId,
|
|
]);
|
|
const created = await this.loadView(manager, id);
|
|
await this.audit.record({
|
|
...administrationAuditContext(principal, request),
|
|
action: AuditAction.ASSET_CREATED,
|
|
entityType: 'asset',entityId: id,
|
|
afterData: created as unknown as Record<string, unknown>,
|
|
metadata: {
|
|
versionNumber,inventoryStructureKind: dto.kind,
|
|
inventoryFamilyId: family?.id ?? null,inventoryFamilyCode: family?.code ?? null,
|
|
operatorOwnership: false,
|
|
},
|
|
}, manager);
|
|
return created;
|
|
});
|
|
} catch (error) {
|
|
if (isUniqueViolation(error)) throw new ConflictException({
|
|
code: 'ASSET_CODE_ALREADY_EXISTS',message: 'Ya existe un registro con ese código',
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
private async requireStructureType(manager: EntityManager, kind: InventoryStructureKind): Promise<StructureTypeRow> {
|
|
const sql = kind === 'EMPRESA'
|
|
? `SELECT id,code,name FROM asset_types WHERE operational_role='COMPANY' AND is_active=true ORDER BY (lower(code)='empresa') DESC,created_at LIMIT 1`
|
|
: `SELECT id,code,name FROM asset_types WHERE lower(code)=lower($1::text) AND is_active=true LIMIT 1`;
|
|
const params = kind === 'EMPRESA' ? [] : [TYPE_CODE_BY_KIND[kind as Exclude<InventoryStructureKind,'EMPRESA'>]];
|
|
const rows = (await manager.query(sql,params)) as StructureTypeRow[];
|
|
if (!rows[0]) throw new ConflictException({
|
|
code: 'INVENTORY_STRUCTURE_TYPE_NOT_CONFIGURED',message: `El nivel ${kind} no está configurado`,
|
|
});
|
|
return rows[0];
|
|
}
|
|
|
|
private async requireParent(
|
|
manager: EntityManager,
|
|
kind: InventoryStructureKind,
|
|
parentId: string | null,
|
|
): Promise<ParentRow | null> {
|
|
const expectedType = PARENT_TYPE_BY_KIND[kind];
|
|
if (!expectedType) {
|
|
if (parentId) throw new BadRequestException({
|
|
code: 'INVENTORY_ROOT_MUST_NOT_HAVE_PARENT',
|
|
message: kind === 'EMPRESA'
|
|
? 'Una Empresa es un maestro independiente y no puede tener padre'
|
|
: 'Un Departamento es un registro raíz y no puede tener padre',
|
|
});
|
|
return null;
|
|
}
|
|
if (!parentId) throw new BadRequestException({
|
|
code: 'INVENTORY_STRUCTURE_PARENT_REQUIRED',
|
|
message: `Para crear ${kind.toLowerCase()} primero tenés que elegir su ${expectedType}`,
|
|
});
|
|
const rows = (await manager.query(`
|
|
SELECT asset.id,asset.code,asset.name,type.code AS "typeCode",
|
|
asset.inventory_family_id AS "inventoryFamilyId"
|
|
FROM assets asset
|
|
JOIN asset_types type ON type.id=asset.asset_type_id
|
|
WHERE asset.id=$1::uuid AND asset.information_status<>'INACTIVE'
|
|
FOR KEY SHARE
|
|
`, [parentId])) as ParentRow[];
|
|
const parent = rows[0];
|
|
if (!parent) throw new NotFoundException({ code: 'INVENTORY_STRUCTURE_PARENT_NOT_FOUND', message: 'El registro padre no existe' });
|
|
if (parent.typeCode.toLowerCase() !== expectedType) throw new BadRequestException({
|
|
code: 'INVENTORY_STRUCTURE_PARENT_INVALID',
|
|
message: 'La jerarquía requerida es Departamento → Área → Yacimiento → Instalación → Subinstalación',
|
|
});
|
|
return parent;
|
|
}
|
|
|
|
private async resolveAreaId(manager: EntityManager,parent: ParentRow):Promise<string> {
|
|
if (parent.typeCode.toLowerCase()==='area') return parent.id;
|
|
const rows = (await manager.query(`
|
|
WITH RECURSIVE lineage AS (
|
|
SELECT asset.id,asset.parent_id,asset.asset_type_id FROM assets asset WHERE asset.id=$1::uuid
|
|
UNION ALL
|
|
SELECT parent.id,parent.parent_id,parent.asset_type_id
|
|
FROM assets parent JOIN lineage child ON child.parent_id=parent.id
|
|
)
|
|
SELECT lineage.id
|
|
FROM lineage JOIN asset_types type ON type.id=lineage.asset_type_id
|
|
WHERE type.operational_role='AREA'
|
|
LIMIT 1
|
|
`,[parent.id])) as IdRow[];
|
|
const areaId=rows[0]?.id;
|
|
if (!areaId) throw new ConflictException({
|
|
code:'INVENTORY_STRUCTURE_AREA_ANCESTOR_MISSING',
|
|
message:'La ubicación seleccionada no pertenece a un Área válida',
|
|
});
|
|
return areaId;
|
|
}
|
|
|
|
private async requireFamily(
|
|
manager: EntityManager,
|
|
kind: InventoryStructureKind,
|
|
familyId: string | null,
|
|
parent: ParentRow | null,
|
|
): Promise<FamilyRow | null> {
|
|
const expectedLevel = FAMILY_LEVEL_BY_KIND[kind];
|
|
if (!expectedLevel) {
|
|
if (familyId) throw new BadRequestException({
|
|
code: 'INVENTORY_STRUCTURE_FAMILY_NOT_ALLOWED',
|
|
message: 'Empresa, Departamento, Área y Yacimiento no llevan clasificación técnica',
|
|
});
|
|
return null;
|
|
}
|
|
if (!familyId) throw new BadRequestException({
|
|
code: 'INVENTORY_STRUCTURE_FAMILY_REQUIRED',
|
|
message: `Elegí la clasificación técnica de la ${kind.toLowerCase()}`,
|
|
});
|
|
const rows = (await manager.query(`
|
|
SELECT family.id,family.code,family.name,family.level,
|
|
family.legacy_type_code AS "legacyTypeCode",family.information_labels AS "informationLabels",
|
|
COALESCE((SELECT JSONB_AGG(rule.parent_family_id ORDER BY rule.parent_family_id)
|
|
FROM inventory_family_parent_rules rule WHERE rule.child_family_id=family.id),'[]'::jsonb) AS "parentFamilyIds",
|
|
COALESCE((SELECT JSONB_AGG(JSONB_BUILD_OBJECT('id',parent.id,'code',parent.code,'name',parent.name) ORDER BY parent.name,parent.code)
|
|
FROM inventory_family_parent_rules rule JOIN inventory_families parent ON parent.id=rule.parent_family_id
|
|
WHERE rule.child_family_id=family.id),'[]'::jsonb) AS "parentFamilies"
|
|
FROM inventory_families family
|
|
WHERE family.id=$1::uuid AND family.is_active=true
|
|
LIMIT 1
|
|
`, [familyId])) as FamilyRow[];
|
|
const family = rows[0];
|
|
if (!family) throw new NotFoundException({ code: 'INVENTORY_FAMILY_NOT_FOUND', message: 'La clasificación técnica no existe' });
|
|
if (family.level !== expectedLevel) throw new BadRequestException({
|
|
code: 'INVENTORY_FAMILY_LEVEL_INVALID',
|
|
message: 'La clasificación técnica no corresponde al nivel seleccionado',
|
|
});
|
|
if (kind === 'SUBINSTALACION') {
|
|
if (!parent?.inventoryFamilyId) throw new BadRequestException({
|
|
code:'INVENTORY_PARENT_FAMILY_REQUIRED',
|
|
message:'La Instalación padre debe tener una clasificación técnica válida',
|
|
});
|
|
const [compatible]=(await manager.query(`
|
|
SELECT 1 AS ok FROM inventory_family_parent_rules
|
|
WHERE child_family_id=$1::uuid AND parent_family_id=$2::uuid
|
|
LIMIT 1
|
|
`,[family.id,parent.inventoryFamilyId])) as Array<{ok:number}>;
|
|
if (!compatible) throw new BadRequestException({
|
|
code: 'INVENTORY_SUBINSTALLATION_FAMILY_PARENT_INVALID',
|
|
message: 'Ese tipo de Subinstalación no es compatible con la clasificación de la Instalación seleccionada',
|
|
});
|
|
}
|
|
return family;
|
|
}
|
|
|
|
private generatedCode(kind: InventoryStructureKind, name: string): string {
|
|
const prefix = kind === 'EMPRESA' ? 'EMP'
|
|
: kind === 'DEPARTAMENTO' ? 'DEP'
|
|
: kind === 'AREA' ? 'AREA'
|
|
: kind === 'YACIMIENTO' ? 'YAC'
|
|
: kind === 'INSTALACION' ? 'INST'
|
|
: 'SUB';
|
|
const readable = name.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toUpperCase()
|
|
.replace(/[^A-Z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || 'REGISTRO';
|
|
return `${prefix}-${readable}-${randomUUID().slice(0, 8).toUpperCase()}`.slice(0, 120);
|
|
}
|
|
|
|
private async loadView(manager: EntityManager, id: string) {
|
|
const rows = await manager.query(`
|
|
SELECT asset.id,asset.code,asset.name,asset.common_name AS "commonName",asset.description,
|
|
asset.information_status AS "informationStatus",asset.operational_status AS "operationalStatus",
|
|
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,
|
|
CASE WHEN area.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT('id',area.id,'code',area.code,'name',area.name) END AS "operationalArea",
|
|
CASE WHEN family.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
|
|
'id',family.id,'code',family.code,'name',family.name,'level',family.level,
|
|
'informationLabels',family.information_labels
|
|
) END AS "inventoryFamily",
|
|
asset.created_at AS "createdAt",asset.updated_at AS "updatedAt"
|
|
FROM assets asset
|
|
JOIN asset_types type ON type.id=asset.asset_type_id
|
|
LEFT JOIN assets parent ON parent.id=asset.parent_id
|
|
LEFT JOIN assets area ON area.id=asset.operational_area_id
|
|
LEFT JOIN inventory_families family ON family.id=asset.inventory_family_id
|
|
WHERE asset.id=$1::uuid
|
|
`, [id]);
|
|
return rows[0];
|
|
}
|
|
}
|