267 lines
14 KiB
TypeScript
267 lines
14 KiB
TypeScript
import { Injectable, NotFoundException } from '@nestjs/common';
|
|
import { DataSource, EntityManager } from 'typeorm';
|
|
import type {
|
|
AuthPrincipal,
|
|
RequestWithContext,
|
|
} from '../common/http/request-context';
|
|
import {
|
|
AssetVersionChangeType,
|
|
AuditSource,
|
|
} from '../database/entities';
|
|
import { changedSnapshotFields } from './asset-version-diff';
|
|
import type {
|
|
AssetVersionPageQueryDto,
|
|
ListAssetVersionsQueryDto,
|
|
} from './dto/list-asset-versions-query.dto';
|
|
|
|
export interface AssetVersionSummary {
|
|
id: string;
|
|
assetId: string;
|
|
assetCode: string;
|
|
assetName: string;
|
|
typeId: string;
|
|
typeName: string;
|
|
informationStatus: string;
|
|
operationalStatus: string;
|
|
versionNumber: number;
|
|
changeType: AssetVersionChangeType;
|
|
changedFields: string[];
|
|
occurredAt: Date;
|
|
actorUserId: string | null;
|
|
actorUsername: string | null;
|
|
source: AuditSource;
|
|
requestId: string | null;
|
|
isCurrent: boolean;
|
|
}
|
|
|
|
export interface AssetVersionDetail extends AssetVersionSummary {
|
|
snapshot: Record<string, unknown>;
|
|
}
|
|
|
|
function assetNotFound(): NotFoundException {
|
|
return new NotFoundException({
|
|
code: 'ASSET_NOT_FOUND',
|
|
message: 'Inventario no encontrado',
|
|
});
|
|
}
|
|
|
|
function versionNotFound(): NotFoundException {
|
|
return new NotFoundException({
|
|
code: 'ASSET_VERSION_NOT_FOUND',
|
|
message: 'Versión de Inventario no encontrada',
|
|
});
|
|
}
|
|
|
|
@Injectable()
|
|
export class AssetHistoryService {
|
|
constructor(private readonly dataSource: DataSource) {}
|
|
|
|
async capture(
|
|
manager: EntityManager,
|
|
assetId: string,
|
|
changeType: AssetVersionChangeType,
|
|
principal: AuthPrincipal,
|
|
request: RequestWithContext,
|
|
): Promise<number> {
|
|
await manager.query(
|
|
`UPDATE assets
|
|
SET current_version = COALESCE(current_version, 0) + 1
|
|
WHERE id = $1`,
|
|
[assetId],
|
|
);
|
|
const [versionRow] = (await manager.query(
|
|
`SELECT current_version
|
|
FROM assets
|
|
WHERE id = $1`,
|
|
[assetId],
|
|
)) as Array<{ current_version: number | string | null }>;
|
|
if (!versionRow) throw assetNotFound();
|
|
|
|
const versionNumber = Number(versionRow.current_version);
|
|
if (!Number.isInteger(versionNumber) || versionNumber < 1) {
|
|
throw new Error(`Versión de Inventario inválida después de incrementar: ${versionRow.current_version}`);
|
|
}
|
|
|
|
const snapshot = await this.loadCurrentSnapshot(manager, assetId);
|
|
const [previousRow] = (await manager.query(
|
|
`SELECT snapshot
|
|
FROM asset_versions
|
|
WHERE asset_id = $1 AND version_number < $2
|
|
ORDER BY version_number DESC
|
|
LIMIT 1`,
|
|
[assetId, versionNumber],
|
|
)) as Array<{ snapshot: Record<string, unknown> }>;
|
|
const changedFields = changedSnapshotFields(previousRow?.snapshot ?? null, snapshot);
|
|
const source = principal.transport === 'bearer'
|
|
? AuditSource.ANDROID
|
|
: AuditSource.WEB;
|
|
|
|
await manager.query(
|
|
`INSERT INTO asset_versions (
|
|
asset_id, version_number, change_type, changed_fields, snapshot,
|
|
actor_user_id, actor_username, source, request_id
|
|
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
|
|
[assetId, versionNumber, changeType, changedFields, snapshot,
|
|
principal.userId, principal.username, source, request.requestId],
|
|
);
|
|
return versionNumber;
|
|
}
|
|
|
|
async list(query: ListAssetVersionsQueryDto) {
|
|
const conditions: string[] = [];
|
|
const parameters: unknown[] = [];
|
|
const add = (value: unknown): string => {
|
|
parameters.push(value);
|
|
return `$${parameters.length}`;
|
|
};
|
|
if (query.search?.trim()) {
|
|
const search = add(`%${query.search.trim()}%`);
|
|
conditions.push(`(version.snapshot->>'code' ILIKE ${search} OR version.snapshot->>'name' ILIKE ${search} OR version.actor_username ILIKE ${search})`);
|
|
}
|
|
if (query.typeId) conditions.push(`version.snapshot #>> '{type,id}' = ${add(query.typeId)}`);
|
|
if (query.status) conditions.push(`version.snapshot->>'informationStatus' = ${add(query.status)}`);
|
|
if (query.changeType) conditions.push(`version.change_type = ${add(query.changeType)}`);
|
|
if (query.from) conditions.push(`version.occurred_at >= ${add(new Date(query.from))}`);
|
|
if (query.to) conditions.push(`version.occurred_at <= ${add(new Date(query.to))}`);
|
|
return this.listWithConditions(query.page, query.pageSize, conditions, parameters);
|
|
}
|
|
|
|
async listForAsset(assetId: string, query: AssetVersionPageQueryDto) {
|
|
await this.requireAsset(assetId);
|
|
return this.listWithConditions(query.page, query.pageSize, ['version.asset_id = $1'], [assetId]);
|
|
}
|
|
|
|
async getVersion(assetId: string, versionNumber: number): Promise<AssetVersionDetail> {
|
|
await this.requireAsset(assetId);
|
|
const [row] = (await this.dataSource.query(
|
|
`${this.selectSummary()}, version.snapshot
|
|
FROM asset_versions version
|
|
INNER JOIN assets current_asset ON current_asset.id = version.asset_id
|
|
WHERE version.asset_id = $1 AND version.version_number = $2`,
|
|
[assetId, versionNumber],
|
|
)) as AssetVersionDetail[];
|
|
if (!row) throw versionNotFound();
|
|
return row;
|
|
}
|
|
|
|
private async listWithConditions(page: number, pageSize: number, conditions: string[], parameters: unknown[]) {
|
|
const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
|
|
const [countRow] = (await this.dataSource.query(`SELECT COUNT(*)::integer AS total FROM asset_versions version ${where}`, parameters)) as Array<{ total: number }>;
|
|
const total = Number(countRow?.total ?? 0);
|
|
const paginated = [...parameters, pageSize, (page - 1) * pageSize];
|
|
const limit = `$${parameters.length + 1}`;
|
|
const offset = `$${parameters.length + 2}`;
|
|
const data = (await this.dataSource.query(
|
|
`${this.selectSummary()}
|
|
FROM asset_versions version
|
|
INNER JOIN assets current_asset ON current_asset.id = version.asset_id
|
|
${where}
|
|
ORDER BY version.occurred_at DESC, version.version_number DESC
|
|
LIMIT ${limit} OFFSET ${offset}`,
|
|
paginated,
|
|
)) as AssetVersionSummary[];
|
|
return { data, meta: { page, pageSize, total, totalPages: total === 0 ? 0 : Math.ceil(total / pageSize) } };
|
|
}
|
|
|
|
private selectSummary(): string {
|
|
return `SELECT
|
|
version.id, version.asset_id AS "assetId",
|
|
version.snapshot->>'code' AS "assetCode", version.snapshot->>'name' AS "assetName",
|
|
version.snapshot #>> '{type,id}' AS "typeId", version.snapshot #>> '{type,name}' AS "typeName",
|
|
version.snapshot->>'informationStatus' AS "informationStatus",
|
|
version.snapshot->>'operationalStatus' AS "operationalStatus",
|
|
version.version_number AS "versionNumber", version.change_type AS "changeType",
|
|
version.changed_fields AS "changedFields", version.occurred_at AS "occurredAt",
|
|
version.actor_user_id AS "actorUserId", version.actor_username AS "actorUsername",
|
|
version.source, version.request_id AS "requestId",
|
|
(version.version_number = current_asset.current_version) AS "isCurrent"`;
|
|
}
|
|
|
|
private async requireAsset(assetId: string): Promise<void> {
|
|
const [row] = (await this.dataSource.query('SELECT 1 FROM assets WHERE id = $1', [assetId])) as unknown[];
|
|
if (!row) throw assetNotFound();
|
|
}
|
|
|
|
private async loadCurrentSnapshot(manager: EntityManager, assetId: string): Promise<Record<string, unknown>> {
|
|
const [row] = (await manager.query(
|
|
`SELECT JSONB_BUILD_OBJECT(
|
|
'id', asset.id,
|
|
'code', asset.code,
|
|
'name', asset.name,
|
|
'commonName', asset.common_name,
|
|
'description', asset.description,
|
|
'type', JSONB_BUILD_OBJECT('id', asset_type.id,'code', asset_type.code,'name', asset_type.name,'operationalRole', asset_type.operational_role),
|
|
'parent', CASE WHEN parent.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT('id', parent.id,'code', parent.code,'name', parent.name) END,
|
|
'operationalArea', CASE WHEN operational_area.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT('id', operational_area.id,'code', operational_area.code,'name', operational_area.name) END,
|
|
'operatorCompany', CASE WHEN operator_company.id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT('id', operator_company.id,'code', operator_company.code,'name', operator_company.name) END,
|
|
'informationStatus', asset.information_status,
|
|
'operationalStatus', asset.operational_status,
|
|
'currentFunction', (
|
|
SELECT JSONB_BUILD_OBJECT(
|
|
'assignmentId', assignment.id,
|
|
'id', fn.id,
|
|
'code', fn.code,
|
|
'name', fn.name,
|
|
'validFrom', assignment.valid_from,
|
|
'reason', assignment.change_reason
|
|
)
|
|
FROM inventory_function_assignments assignment
|
|
JOIN inventory_functions fn ON fn.id=assignment.function_id
|
|
WHERE assignment.asset_id=asset.id AND assignment.valid_until IS NULL
|
|
ORDER BY assignment.valid_from DESC LIMIT 1
|
|
),
|
|
'attributes', COALESCE((
|
|
SELECT JSONB_AGG(JSONB_BUILD_OBJECT(
|
|
'definitionId', 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,'value', value.value
|
|
) ORDER BY definition.sort_order, definition.name)
|
|
FROM asset_attribute_definitions definition
|
|
LEFT JOIN asset_attribute_values value ON value.definition_id = definition.id AND value.asset_id = asset.id
|
|
WHERE definition.asset_type_id = asset.asset_type_id AND definition.is_active = true
|
|
), '[]'::jsonb),
|
|
'geometry', CASE WHEN geometry.asset_id IS NULL THEN NULL ELSE JSONB_BUILD_OBJECT(
|
|
'assetId', geometry.asset_id,'geometry', ST_AsGeoJSON(geometry.geometry)::jsonb,'geometryType', geometry.geometry_type,
|
|
'source', geometry.source,'accuracyM', geometry.accuracy_m::double precision,'capturedAt', geometry.captured_at,
|
|
'deviceLabel', geometry.device_label,'createdAt', geometry.created_at,'updatedAt', geometry.updated_at,'updatedBy', geometry.updated_by
|
|
) END,
|
|
'media', COALESCE((
|
|
SELECT JSONB_AGG(JSONB_BUILD_OBJECT(
|
|
'id', media.id,'kind', media.kind,'originalName', media.original_name,'mimeType', media.mime_type,
|
|
'sizeBytes', media.size_bytes,'sha256', media.sha256,'title', media.title,'description', media.description,
|
|
'capturedAt', media.captured_at,'latitude', media.latitude,'longitude', media.longitude,'accuracyM', media.accuracy_m,
|
|
'source', media.source,'uploadedBy', media.uploaded_by,'createdAt', media.created_at,'updatedAt', media.updated_at
|
|
) ORDER BY media.created_at, media.id)
|
|
FROM asset_media media WHERE media.asset_id = asset.id AND media.deleted_at IS NULL
|
|
), '[]'::jsonb),
|
|
'organizationProfile', (SELECT TO_JSONB(profile) - 'created_at' - 'updated_at' FROM organization_profiles profile WHERE profile.asset_id=asset.id),
|
|
'organizationMemberships', COALESCE((
|
|
SELECT JSONB_AGG(JSONB_BUILD_OBJECT('id',m.id,'parentOrganizationId',m.parent_organization_id,'memberOrganizationId',m.member_organization_id,'role',m.role,'participationPercent',m.participation_percent::double precision,'validFrom',m.valid_from,'validUntil',m.valid_until,'sourceDocumentId',m.source_document_id,'notes',m.notes,'endReason',m.end_reason) ORDER BY m.valid_until NULLS FIRST,m.valid_from DESC)
|
|
FROM organization_memberships m WHERE m.parent_organization_id=asset.id OR m.member_organization_id=asset.id
|
|
),'[]'::jsonb),
|
|
'externalIdentifiers', COALESCE((
|
|
SELECT JSONB_AGG(JSONB_BUILD_OBJECT('id',i.id,'namespace',i.namespace,'value',i.value,'validFrom',i.valid_from,'validUntil',i.valid_until,'sourceDocumentId',i.source_document_id,'notes',i.notes,'endReason',i.end_reason) ORDER BY i.valid_until NULLS FIRST,i.namespace,i.valid_from DESC) FROM asset_external_identifiers i WHERE i.asset_id=asset.id
|
|
),'[]'::jsonb),
|
|
'sourceDocuments', COALESCE((
|
|
SELECT JSONB_AGG(JSONB_BUILD_OBJECT('linkId',l.id,'relationType',l.relation_type,'documentId',d.id,'documentType',d.document_type,'documentNumber',d.document_number,'title',d.title,'issuer',d.issuer,'documentDate',d.document_date,'externalReference',d.external_reference) ORDER BY d.document_date DESC NULLS LAST,d.created_at DESC) FROM asset_source_documents l JOIN source_documents d ON d.id=l.document_id WHERE l.asset_id=asset.id
|
|
),'[]'::jsonb),
|
|
'legalRights', COALESCE((
|
|
SELECT JSONB_AGG(JSONB_BUILD_OBJECT('id',r.id,'rightType',r.right_type,'name',r.name,'instrumentNumber',r.instrument_number,'validFrom',r.valid_from,'validUntil',r.valid_until,'status',r.status,'sourceDocumentId',r.source_document_id,'notes',r.notes,'organizations',COALESCE((SELECT JSONB_AGG(JSONB_BUILD_OBJECT('id',o.id,'organizationId',o.organization_id,'role',o.role,'participationPercent',o.participation_percent::double precision,'validFrom',o.valid_from,'validUntil',o.valid_until,'notes',o.notes,'endReason',o.end_reason) ORDER BY o.valid_until NULLS FIRST,o.valid_from DESC) FROM area_legal_right_organizations o WHERE o.right_id=r.id),'[]'::jsonb)) ORDER BY r.valid_until DESC NULLS FIRST,r.valid_from DESC NULLS LAST) FROM area_legal_rights r WHERE r.area_id=asset.id
|
|
),'[]'::jsonb),
|
|
'provenance', JSONB_BUILD_OBJECT('origin', asset.data_origin,'sourceName', asset.source_name,'sourceReference', asset.source_reference,'observedAt', asset.source_observed_at,'notes', asset.source_notes,'verifiedAt', asset.provenance_verified_at,'verifiedBy', asset.provenance_verified_by,'updatedAt', asset.provenance_updated_at,'updatedBy', asset.provenance_updated_by),
|
|
'createdAt', asset.created_at,'updatedAt', asset.updated_at,'createdBy', asset.created_by,'updatedBy', asset.updated_by,'currentVersion', asset.current_version
|
|
) AS snapshot
|
|
FROM assets asset
|
|
INNER JOIN asset_types asset_type ON asset_type.id = asset.asset_type_id
|
|
LEFT JOIN assets parent ON parent.id = asset.parent_id
|
|
LEFT JOIN assets operational_area ON operational_area.id = asset.operational_area_id
|
|
LEFT JOIN assets operator_company ON operator_company.id = asset.operator_company_id
|
|
LEFT JOIN asset_geometries geometry ON geometry.asset_id = asset.id
|
|
WHERE asset.id = $1`,
|
|
[assetId],
|
|
)) as Array<{ snapshot: Record<string, unknown> }>;
|
|
if (!row) throw assetNotFound();
|
|
return row.snapshot;
|
|
}
|
|
}
|