/// <summary>
/// Metodo que almacena un objeto de tipo OntologyConcept
/// </summary>
/// <param name="myOntologyConcept">Objeto de tipo OntologyConcept que se va almacenar</param>
/// <returns>retorna 1 si la transaccion se realizo con exito de lo contrario retorna 0</returns>
public static int Save(OntologyConcept myOntologyConcept)
{
int result = 0;
using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString))
{
SqlCommand myCommand = new SqlCommand("spOntologyConceptUpsert", myConnection);
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.AddWithValue("@Ont_Id", myOntologyConcept.OntId);
myCommand.Parameters.AddWithValue("@Ont_NameConcept", myOntologyConcept.OntNameConcept);
DbParameter returnValue;
returnValue = myCommand.CreateParameter();
returnValue.Direction = ParameterDirection.ReturnValue;
myCommand.Parameters.Add(returnValue);
myConnection.Open();
myCommand.ExecuteNonQuery();
result = Convert.ToInt32(returnValue.Value);
myConnection.Close();
}
return(result);
}
/// <summary>
/// Metodo que inicializa un Objeto myOntologyConcept a partir de un registro de la Base de datos
/// </summary>
/// <param name="myDataRecord">Registro de la tabla TBL_ONTOLOGY_CONCEPTS</param>
/// <returns>retorna Objeto OntologyConcept inicializado</returns>
public static OntologyConcept FillDataRecord(IDataRecord myDataRecord)
{
OntologyConcept myOntologyConcept = new OntologyConcept();
myOntologyConcept.OntId = myDataRecord.GetInt32(myDataRecord.GetOrdinal("ONT_ID"));
myOntologyConcept.OntNameConcept = myDataRecord.GetString(myDataRecord.GetOrdinal("ONTCOPY_NAMECONCEPT"));
return(myOntologyConcept);
}
internal int getWeigthByConcept(OntologyConcept ontologyConcept)
{
int Weigth = 0;
if (ClassParent == null)
{
//Obtiene solo las clases.
OWLClass _class = getClass(ontology.getClassesInSignature(), ontologyConcept.ConceptKey);
if (_class != null)
{
Weigth = getDepthClass(_class);
}
//else
//{
// //Al ser individuo no se puede buscar en subclase, por tanto el peso es 1
// Weigth = 1;
//}
}
return(Weigth);
}
/// <summary>
/// Metodo que obtiene un OntologyConcept
/// </summary>
/// <param name="id">Identificador del OntologyConcept que se va obtener</param>
/// <returns>retorna Objeto OntologyConcept si el mismo se encuentra,de lo contrario retorna null</returns>
public static OntologyConcept GetItem(int id)
{
OntologyConcept myOntologyConcept = null;
using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString))
{
SqlCommand myCommand = new SqlCommand("spGetOntologyConcept", myConnection);
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.AddWithValue("@Ont_Id", id);
myConnection.Open();
using (SqlDataReader myReader = myCommand.ExecuteReader())
{
if (myReader.Read())
{
myOntologyConcept = FillDataRecord(myReader);
}
myReader.Close();
}
myConnection.Close();
}
return(myOntologyConcept);
}
/// <summary>
/// proceso para cargar las clases, subclases y axiomas de la ontologia
/// </summary>
private void LoadOWLAPI()
{
//Inicializamos variables
OntologyConcept ontologyConcept = null;
int weigth = 1;
string claseKey = string.Empty;
string claseValor = string.Empty;
//OWLClass _class;
//Se carga la ontologia
string path = url;
java.io.File file = new java.io.File(path);
//Aseguramos una ontologia en el managet
ontology = ontologyManager.loadOntologyFromOntologyDocument(file);
//Creamos el datafactory para obtener los labels de las clases
OWLDataFactory df = ontologyManager.getOWLDataFactory();
OWLAnnotationProperty label = df.getOWLAnnotationProperty(OWLRDFVocabulary.RDFS_LABEL.getIRI());
//Obtenemos las clases de la ontologia y las recorremos para obtener las anotaciones
java.util.Set clases = ontology.getClassesInSignature();
for (java.util.Iterator iteratorClases = clases.iterator(); iteratorClases.hasNext();)
{
OWLClass clase = (OWLClass)iteratorClases.next();
List <Anotacion> Anotaciones = new List <Anotacion>();
java.util.Set lit = clase.getAnnotations(ontology, label);
//Se recorren las anotaciones tipo Label
for (java.util.Iterator iteratorAnno = lit.iterator(); iteratorAnno.hasNext();)
{
OWLAnnotation anno = (OWLAnnotation)iteratorAnno.next();
OWLLiteral val = (OWLLiteral)anno.getValue();
string valorAnotacion = string.Empty;
if (val.hasLang("es"))
{
//Se debe hacer un tratamiento a la cadena por los acentos
valorAnotacion = ToAscii(val.getLiteral()).Trim();
}
else
{
valorAnotacion = val.getLiteral().Trim();
}
//Agregar la anotacion a la lista
Anotacion annotemp = new Anotacion(anno.getSignature().ToString(), valorAnotacion, val.getLang());
Anotaciones.Add(annotemp);
//Añadimos la anotacion a la lista de valores a consultar verificando que no este repetido
if (!valores.Contains(valorAnotacion) && !string.IsNullOrEmpty(valorAnotacion))
{
valores.Add(valorAnotacion);
}
//Reportar la anotacion encontrada
Trace.WriteLine(clase.getSignature().ToString() + " -> " + valorAnotacion);
//Almacenamos todas anotaciones en un string para el valor de la clase
claseValor = claseValor + " " + valorAnotacion;
//En caso de tener individuos se almacena en la lista de valores para su búsqueda
Trace.WriteLine("Obteniendo conceptos de los individuos");
string individuoKey = string.Empty;
java.util.Set individuos = clase.getIndividuals(ontology);
for (java.util.Iterator iteratorIndividuos = individuos.iterator(); iteratorIndividuos.hasNext();)
{
OWLIndividual individuo = (OWLIndividual)iteratorIndividuos.next();
java.util.Set litind = individuo.asOWLNamedIndividual().getAnnotations(ontology, df.getRDFSLabel());
//Se recorre las anotaciones tipo Label individuo
for (java.util.Iterator iteratorAnnoind = litind.iterator(); iteratorAnnoind.hasNext();)
{
OWLAnnotation annoind = (OWLAnnotation)iteratorAnnoind.next();
OWLLiteral valind = (OWLLiteral)annoind.getValue();
string valorAnotacionind = string.Empty;
if (valind.hasLang("es"))
{
//Se debe hacer un tratamiento a la cadena por los acentos
valorAnotacionind = ToAscii(valind.getLiteral()).Trim();
}
else
{
valorAnotacionind = valind.getLiteral().Trim();
}
//Agregar la anotacion a la lista
Anotacion annotempind = new Anotacion(annoind.getSignature().ToString(), valorAnotacionind, valind.getLang());
Anotaciones.Add(annotempind);
//Añadimos la anotacion a la lista de valores a consultar verificando que no este repetido
if (!valores.Contains(valorAnotacionind) && !string.IsNullOrEmpty(valorAnotacionind))
{
valores.Add(valorAnotacionind);
}
//Reportar la anotacion encontrada
Trace.WriteLine(clase.getSignature().ToString() + ":" + individuo.getSignature().ToString() + " -> " + valorAnotacionind);
//Almacenamos todas anotaciones en un string para el valor de la clase
claseValor = claseValor + " " + valorAnotacionind;
}
}
//Agregar el concepto a la lista
claseKey = clase.getSignature().ToString();
ontologyConcept = new OntologyConcept(claseKey, claseValor, weigth, clase, clase.getSuperClasses(ontology), clase.getSubClasses(ontology));
ontologyConcept.Anotaciones = Anotaciones;
//Reinicializamos el valor para la nueva clase
claseValor = "";
//Verificar que se obtengan conceptos diferentes. Las claseKey se repiten siempre que aporten anotaciones diferentes
if (!this.concepts.ContainsKey(claseKey) && !this.concepts.ContainsValue(ontologyConcept) && !valores.Contains(ontologyConcept.ConceptValue) && !string.IsNullOrEmpty(ontologyConcept.ConceptValue))
{
this.concepts.Add(claseKey, ontologyConcept);
}
}
}
}
/// <summary>
/// Metodo que delega a OntologyConceptDB almacenar un OntolgyConcept
/// </summary>
/// <param name="myOntologyConcept">Objeto de tipo OntologyConcept que se va a almacenar</param>
/// <returns>retorna 1 si la transaccion se realizo con exito de lo contrario retorna 0</returns>
public static int Save(OntologyConcept myOntologyConcept)
{
return(OntologyConceptDB.Save(myOntologyConcept));
}
