public JobController(DiscoverItemBDService iIDiscoverItemService, ProcessDiscoverStateJobBDService iProcessDiscoverStateJobBDService, CallCronApiService serviceApi, ICallEtlService callEDtlPublishService, ConfigUnidataPrefix unidataPrefix)
{
_serviceApi = serviceApi;
_discoverItemService = iIDiscoverItemService;
_processDiscoverStateJobBDService = iProcessDiscoverStateJobBDService;
_callEDtlPublishService = callEDtlPublishService;
_unidataPrefix = unidataPrefix;
}
/// <summary>
/// Procesa un item de descubrimiento
/// </summary>
/// <param name="itemIDstring">Identificador del item</param>
/// <returns></returns>
public bool ProcessItem(string itemIDstring)
{
Guid itemID = JsonConvert.DeserializeObject <Guid>(itemIDstring);
try
{
DiscoverItemBDService discoverItemBDService = _serviceScopeFactory.CreateScope().ServiceProvider.GetRequiredService <DiscoverItemBDService>();
ProcessDiscoverStateJobBDService processDiscoverStateJobBDService = _serviceScopeFactory.CreateScope().ServiceProvider.GetRequiredService <ProcessDiscoverStateJobBDService>();
CallCronApiService callCronApiService = _serviceScopeFactory.CreateScope().ServiceProvider.GetRequiredService <CallCronApiService>();
CallEtlApiService callEtlApiService = _serviceScopeFactory.CreateScope().ServiceProvider.GetRequiredService <CallEtlApiService>();
CallUrisFactoryApiService callUrisFactoryApiService = _serviceScopeFactory.CreateScope().ServiceProvider.GetRequiredService <CallUrisFactoryApiService>();
DiscoverItem discoverItem = discoverItemBDService.GetDiscoverItemById(itemID);
if (discoverItem != null)
{
//Aplicamos el proceso de descubrimiento
DiscoverResult resultado = Init(discoverItem, callEtlApiService, callUrisFactoryApiService);
Process(discoverItem, resultado,
discoverItemBDService,
callCronApiService,
callUrisFactoryApiService,
processDiscoverStateJobBDService
);
}
}
catch (Exception ex)
{
Logging.Error(ex);
//Se ha producido un error al aplicar el descubrimiento
//Modificamos los datos del DiscoverItem que ha fallado
DiscoverItemBDService discoverItemBDService = _serviceScopeFactory.CreateScope().ServiceProvider.GetRequiredService <DiscoverItemBDService>();
DiscoverItem discoverItemBBDD = discoverItemBDService.GetDiscoverItemById(itemID);
discoverItemBBDD.UpdateError($"{ex.Message}\n{ex.StackTrace}\n");
discoverItemBDService.ModifyDiscoverItem(discoverItemBBDD);
if (!string.IsNullOrEmpty(discoverItemBBDD.JobID))
{
//Si viene de una tarea actualizamos su estado de descubrimiento
ProcessDiscoverStateJobBDService processDiscoverStateJobBDService = _serviceScopeFactory.CreateScope().ServiceProvider.GetRequiredService <ProcessDiscoverStateJobBDService>();
ProcessDiscoverStateJob processDiscoverStateJob = processDiscoverStateJobBDService.GetProcessDiscoverStateJobByIdJob(discoverItemBBDD.JobID);
if (processDiscoverStateJob != null)
{
processDiscoverStateJob.State = "Error";
processDiscoverStateJobBDService.ModifyProcessDiscoverStateJob(processDiscoverStateJob);
}
else
{
processDiscoverStateJob = new ProcessDiscoverStateJob()
{
State = "Error", JobId = discoverItemBBDD.JobID
};
processDiscoverStateJobBDService.AddProcessDiscoverStateJob(processDiscoverStateJob);
}
}
}
return(true);
}
public JobController(CallCronApiService serviceApi)
{
_serviceApi = serviceApi;
}
/// <summary>
/// Procesa los resultados del descubrimiento
/// </summary>
/// <param name="pDiscoverItem">Objeto con los datos de com procesar el proeso de descubrimiento</param>
/// <param name="pDiscoverResult">Resultado de la aplicación del descubrimiento</param>
/// <param name="pDiscoverItemBDService">Clase para gestionar las operaciones de las tareas de descubrimiento</param>
/// <param name="pCallCronApiService">Servicio para hacer llamadas a los métodos del apiCron</param>
/// <param name="pCallUrisFactoryApiService">Servicio para hacer llamadas a los métodos del Uris Factory</param>
/// <param name="pProcessDiscoverStateJobBDService">Clase para gestionar los estados de descubrimiento de las tareas</param>
/// <returns></returns>
public void Process(DiscoverItem pDiscoverItem, DiscoverResult pDiscoverResult, DiscoverItemBDService pDiscoverItemBDService, CallCronApiService pCallCronApiService, CallUrisFactoryApiService pCallUrisFactoryApiService, ProcessDiscoverStateJobBDService pProcessDiscoverStateJobBDService)
{
#region Cargamos configuraciones
ConfigSparql ConfigSparql = new ConfigSparql();
string SGI_SPARQLEndpoint = ConfigSparql.GetEndpoint();
string SGI_SPARQLGraph = ConfigSparql.GetGraph();
string SGI_SPARQLQueryParam = ConfigSparql.GetQueryParam();
string SGI_SPARQLUsername = ConfigSparql.GetUsername();
string SGI_SPARQLPassword = ConfigSparql.GetPassword();
string Unidata_SPARQLEndpoint = ConfigSparql.GetUnidataEndpoint();
string Unidata_SPARQLGraph = ConfigSparql.GetUnidataGraph();
string Unidata_SPARQLQueryParam = ConfigSparql.GetUnidataQueryParam();
string Unidata_SPARQLUsername = ConfigSparql.GetUnidataUsername();
string Unidata_SPARQLPassword = ConfigSparql.GetUnidataPassword();
ConfigService ConfigService = new ConfigService();
string UnidataDomain = ConfigService.GetUnidataDomain();
string UnidataUriTransform = ConfigService.GetUnidataUriTransform();
#endregion
/*
* En función del resultado obtenido se realiza una de las siguientes acciones:
* Si para alguna entidad hay más de un candidato que supere el umbral máximo o hay alguna entidad que supere el umbral mínimo pero no alcance el máximo se agregará el RDF a una BBDD junto con todos los datos necesarios para que el administrador decida como proceder.
* Si no estamos en el punto anterior
* Se obtienen las entidades principales del RDF y se eliminan todos los triples que haya en la BBDD en los que aparezcan como sujeto u objeto.
* Se eliminan todos los triples cuyo sujeto y predicado estén en el RDF a cargar y estén marcados como monovaluados.
* Se vuelcan los triples a la BBDD.
*
*
*/
if (pDiscoverItem.Publish)
{
if (pDiscoverResult.discoveredEntitiesProbability.Count > 0)
{
//Hay dudas en la desambiguación, por lo que lo actualizamos en la BBDD con su estado correspondiente
pDiscoverItem.UpdateDissambiguationProblems(
pDiscoverResult.discoveredEntitiesProbability,
pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD.Values.Select(x => x.uri).Union(pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds.Values).Union(pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject).Union(pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration.Values.Select(x => x.uri)).ToList(),
pDiscoverResult.GetDataGraphRDF());
pDiscoverItemBDService.ModifyDiscoverItem(pDiscoverItem);
}
else
{
string urlDiscoverAgent = pCallUrisFactoryApiService.GetUri("Agent", "discover");
//Creamos los SameAs hacia unidata para las entidades que NO lo tengan hacia Unidata
//TODO descomentar cuando esté habilitaado Unidata
//pDiscoverResult.dataGraph = AsioPublication.CreateUnidataSameAs(pDiscoverResult.dataGraph, UnidataDomain, UnidataUriTransform);
//Publicamos en el SGI
AsioPublication asioPublication = new AsioPublication(SGI_SPARQLEndpoint, SGI_SPARQLQueryParam, SGI_SPARQLGraph, SGI_SPARQLUsername, SGI_SPARQLPassword);
asioPublication.PublishRDF(pDiscoverResult.dataGraph, pDiscoverResult.ontologyGraph, new KeyValuePair <string, string>(urlDiscoverAgent, "Algoritmos de descubrimiento"), pDiscoverResult.start, pDiscoverResult.end, pDiscoverResult.discoverLinkData, pCallUrisFactoryApiService);
//TODO Lógica nombres de personas
SparqlResultSet sparqlResultSet = (SparqlResultSet)pDiscoverResult.dataGraph.ExecuteQuery("select ?s ?name where {?s a <http://purl.org/roh/mirror/foaf#Person>. ?s <http://purl.org/roh/mirror/foaf#name> ?name}");
foreach (SparqlResult sparqlResult in sparqlResultSet.Results)
{
string s = sparqlResult["s"].ToString();
string nombre = sparqlResult["name"].ToString();
if (sparqlResult["name"] is ILiteralNode)
{
nombre = ((ILiteralNode)sparqlResult["name"]).Value;
}
_discoverCacheGlobal.PersonsNormalizedNames[s] = DiscoverUtility.NormalizeName(nombre);
}
//TODO Lógica titles
SparqlResultSet sparqlResultSetTitles = (SparqlResultSet)pDiscoverResult.dataGraph.ExecuteQuery("select * where {?s a ?rdftype. ?s <http://purl.org/roh#title> ?title}");
foreach (SparqlResult sparqlResult in sparqlResultSetTitles.Results)
{
string s = sparqlResult["s"].ToString();
string rdftype = sparqlResult["rdftype"].ToString();
string title = sparqlResult["title"].ToString();
if (sparqlResult["title"] is ILiteralNode)
{
title = ((ILiteralNode)sparqlResult["title"]).Value;
}
title = DiscoverUtility.NormalizeTitle(title);
if (!_discoverCacheGlobal.EntitiesNormalizedTitles.ContainsKey(rdftype))
{
_discoverCacheGlobal.EntitiesNormalizedTitles.Add(rdftype, new Dictionary <string, HashSet <string> >());
}
if (!_discoverCacheGlobal.EntitiesNormalizedTitles[rdftype].ContainsKey(title))
{
_discoverCacheGlobal.EntitiesNormalizedTitles[rdftype].Add(title, new HashSet <string>());
}
_discoverCacheGlobal.EntitiesNormalizedTitles[rdftype][title].Add(s);
}
//TODO descomentar cuando esté habilitaado Unidata
if (false)
{
//Publicamos en UNIDATA
AsioPublication asioPublicationUnidata = new AsioPublication(Unidata_SPARQLEndpoint, Unidata_SPARQLQueryParam, Unidata_SPARQLGraph, Unidata_SPARQLUsername, Unidata_SPARQLPassword);
// Prepara el grafo para su carga en Unidata, para ello coge las URIs de Unidata del SameAs y la aplica a los sujetos y los antiguos sujetos se agregan al SameAs
RohGraph unidataGraph = AsioPublication.TransformUrisToUnidata(pDiscoverResult.dataGraph, UnidataDomain, UnidataUriTransform);
//Eliminamos los triples de crisIdentifier ya que no hay que volcarlos en unidata
{
TripleStore store = new TripleStore();
store.Add(unidataGraph);
SparqlUpdateParser parser = new SparqlUpdateParser();
//Actualizamos los sujetos
SparqlUpdateCommandSet updateSubject = parser.ParseFromString(
@" DELETE { ?s ?p ?o. }
WHERE
{
?s ?p ?o. FILTER(?p =<" + mPropertySGIRohCrisIdentifier + @">)
}");
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(updateSubject);
}
asioPublicationUnidata.PublishRDF(unidataGraph, pDiscoverResult.ontologyGraph, new KeyValuePair <string, string>(urlDiscoverAgent, "Algoritmos de descubrimiento"), pDiscoverResult.start, pDiscoverResult.end, pDiscoverResult.discoverLinkData, pCallUrisFactoryApiService);
}
//Lo marcamos como procesado en la BBDD y eliminamos sus metadatos
pDiscoverItem.UpdateProcessed();
pDiscoverItemBDService.ModifyDiscoverItem(pDiscoverItem);
}
//Actualizamos el estado de descubrimiento de la tarea si el estado encolado esta en estado Succeeded o Failed (ha finalizado)
//TODO cambiar por query a BBDD
string statusQueueJob = pCallCronApiService.GetJob(pDiscoverItem.JobID).State;
if ((statusQueueJob == "Failed" || statusQueueJob == "Succeeded"))
{
ProcessDiscoverStateJob processDiscoverStateJob = pProcessDiscoverStateJobBDService.GetProcessDiscoverStateJobByIdJob(pDiscoverItem.JobID);
string state;
//Actualizamos a error si existen items en estado error o con problemas de desambiguación
if (pDiscoverItemBDService.ExistsDiscoverItemsErrorOrDissambiguatinProblems(pDiscoverItem.JobID))
{
state = "Error";
}
else if (pDiscoverItemBDService.ExistsDiscoverItemsPending(pDiscoverItem.JobID))
{
//Actualizamos a 'Pending' si aún existen items pendientes
state = "Pending";
}
else
{
//Actualizamos a Success si no existen items en estado error ni con problemas de desambiguación y no hay ninguno pendiente
state = "Success";
}
if (processDiscoverStateJob != null)
{
processDiscoverStateJob.State = state;
pProcessDiscoverStateJobBDService.ModifyProcessDiscoverStateJob(processDiscoverStateJob);
}
else
{
processDiscoverStateJob = new ProcessDiscoverStateJob()
{
State = state, JobId = pDiscoverItem.JobID
};
pProcessDiscoverStateJobBDService.AddProcessDiscoverStateJob(processDiscoverStateJob);
}
}
}
else
{
//Actualizamos en BBDD
DiscoverItem discoverItemBD = pDiscoverItemBDService.GetDiscoverItemById(pDiscoverItem.ID);
//Reporte de descubrimiento
string discoverReport = "Time processed (seconds): " + pDiscoverResult.secondsProcessed + "\n";
if (pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject != null && pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject.Count > 0)
{
discoverReport += "Entities discover with the same uri: " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject.Count + "\n";
foreach (string uri in pDiscoverResult.reconciliationData.reconciliatedEntitiesWithSubject)
{
discoverReport += "\t" + uri + "\n";
}
}
if (pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds != null && pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds.Count > 0)
{
discoverReport += "Entities discover with some common identifier: " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds.Count + "\n";
foreach (string uri in pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds.Keys)
{
discoverReport += "\t" + uri + " --> " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithIds[uri] + "\n";
}
}
if (pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD != null && pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD.Count > 0)
{
discoverReport += "Entities discover with reconciliation config: " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD.Count + "\n";
foreach (string uri in pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD.Keys)
{
discoverReport += "\t" + uri + " --> " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithBBDD[uri] + "\n";
}
}
if (pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration != null && pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration.Count > 0)
{
discoverReport += "Entities discover with external integrations config: " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration.Count + "\n";
foreach (string uri in pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration.Keys)
{
discoverReport += "\t" + uri + " --> " + pDiscoverResult.reconciliationData.reconciliatedEntitiesWithExternalIntegration[uri] + "\n";
}
}
if (pDiscoverResult.discoverLinkData != null && pDiscoverResult.discoverLinkData.entitiesProperties != null && pDiscoverResult.discoverLinkData.entitiesProperties.Count > 0)
{
discoverReport += "Entities with identifiers obtained with External integration: " + pDiscoverResult.discoverLinkData.entitiesProperties.Count + "\n";
foreach (string uri in pDiscoverResult.discoverLinkData.entitiesProperties.Keys)
{
foreach (DiscoverLinkData.PropertyData property in pDiscoverResult.discoverLinkData.entitiesProperties[uri])
{
foreach (string value in property.valueProvenance.Keys)
{
foreach (string provenance in property.valueProvenance[value])
{
discoverReport += "\t" + uri + " - " + property.property + " - " + value + " --> " + provenance + "\n";
}
}
}
}
}
discoverItemBD.UpdateReport(pDiscoverResult.discoveredEntitiesProbability, pDiscoverResult.GetDataGraphRDF(), discoverReport);
pDiscoverItemBDService.ModifyDiscoverItem(discoverItemBD);
}
}
