/// <summary>
/// Mapea el tipo actual del nodo, al atributo TipoNodo del objeto Nodo
/// </summary>
/// <param name="propiedadesDeserializadas"></param>
/// <param name="nodoListo"></param>
/// <returns></returns>
private async static Task AñadirTipoPersonalizado(dynamic propiedadesDeserializadas, Nodo nodoListo)
{
string prefijoModeloNodo = nodoListo.NodeType.Split(':')[0];
string nombreTipoNodo = nodoListo.NodeType.Split(':')[1];
//Si no existe el modelo, entonces no se añade el tipo personalizado
Model modelo = await ModelosPersonalizadosStatic.ObtenerModeloPersonalizadoxPrefijo(prefijoModeloNodo);
if (!(modelo is null))
{
Modelos.CMM.Type tipoNodo = await TiposPersonalizadosStatic.ObtenerTipoPersonalizado(modelo.Name, nombreTipoNodo);
string nodoPropertiesJson = JsonConvert.SerializeObject(propiedadesDeserializadas);
Dictionary <string, dynamic> nodoProperties = JsonConvert.DeserializeObject <Dictionary <string, dynamic> >(nodoPropertiesJson);
if (!(nodoProperties is null))
{
foreach (var propiedad in nodoProperties)
{
Property propiedadTemp = tipoNodo.Properties.Find(x => x.PrefixedName == propiedad.Key);
if (!(propiedadTemp is null))
{
propiedadTemp.Value = propiedad.Value;
continue;
}
}
}
tipoNodo.ModeloPerteneciente = modelo;
nodoListo.TipoNodo = tipoNodo;
}
}
private async Task CargarCmbxModelos()
{
List <Model> modelosDisponibles = await ModelosPersonalizadosStatic.ObtenerModelosPersonalizados();
foreach (var item in modelosDisponibles)
{
cmbxModelo.Items.Add(item);
}
}
/// <summary>
/// Pobla el datagridView con los modelos de usuario
/// </summary>
/// <returns></returns>
private async Task PoblarDtgvModelos(string filtro)
{
List <Model> modelos = new List <Model>();
if (filtro == "Autor")
{
modelos = await ModelosPersonalizadosStatic.ObtenerModelosPersonalizadosxAuthor();
lblFiltradoPor.Text = "Filtrado por: Mis modelos";
}
else if (filtro == "Sin filtro")
{
modelos = await ModelosPersonalizadosStatic.ObtenerModelosPersonalizados();
lblFiltradoPor.Text = "Filtrado por: Sin filtro";
}
else if (filtro == "Activos")
{
modelos = await ModelosPersonalizadosStatic.ObtenerModelosPersonalizados();
List <Model> modelosActivos = new List <Model>();
foreach (var item in modelos)
{
if (item.Status == "ACTIVE")
{
modelosActivos.Add(item);
}
}
modelos = modelosActivos;
lblFiltradoPor.Text = "Filtrado por: Activos";
}
else if (filtro == "Desactivados")
{
modelos = await ModelosPersonalizadosStatic.ObtenerModelosPersonalizados();
List <Model> modelosActivos = new List <Model>();
foreach (var item in modelos)
{
if (item.Status != "ACTIVE")
{
modelosActivos.Add(item);
}
}
modelos = modelosActivos;
lblFiltradoPor.Text = "Filtrado por: Desactivados";
}
dtgviewDatos.AutoGenerateColumns = false;
dtgviewDatos.DataSource = modelos;
dtgviewDatos.Columns["clmNombreModelo"].DataPropertyName = "Name";
dtgviewDatos.Columns["clmEspacioNombres"].DataPropertyName = "NamespaceUri";
dtgviewDatos.Columns["clmAuthor"].DataPropertyName = "Author";
dtgviewDatos.Columns["clmEstadoModelo"].DataPropertyName = "Status";
}
/// <summary>
/// Mapea Aspectos y sus propiedades de un Nodo JSON a los Aspectos y sus propiedades de un Objeto Nodo
/// </summary>
/// <param name="propiedadesDeserializadas">Nodo JSON con metadatos de descarga</param>
/// <param name="nodoListo">Objeto Nodo, deserializado pero aun sin Aspectos. Se le añadirá sus Aspectos</param>
private static async Task AñadirAspectos(dynamic propiedadesDeserializadas, Nodo nodoListo)
{
List <string> nodoAspectnames = (List <string>)nodoListo.AspectNames;
List <Aspect> aspectosNodo = new List <Aspect>();
List <Aspect> aspectosDisponibles = Aspect.Aspects();
foreach (var aspecto in nodoAspectnames)
{
foreach (var aspectoDisponible in aspectosDisponibles)
{
if (aspectoDisponible.Name.Equals(aspecto))
{
aspectosNodo.Add(aspectoDisponible);
break;
}
}
}
//Mapeo de aspectos personalizados
List <Aspect> aspectosFaltantes = new List <Aspect>();
foreach (var aspectoNoMap in nodoAspectnames)
{
if (aspectosNodo.Find(x => x.Name == aspectoNoMap) is null)
{
string prefijoModelodesdeAspecto = aspectoNoMap.Split(':')[0];
string nombreAspecto = aspectoNoMap.Split(':')[1];
if ((await ModelosPersonalizadosStatic.ObtenerModeloPersonalizadoxPrefijo(prefijoModelodesdeAspecto) is null))
{
continue;
}
Model modelo = await ModelosPersonalizadosStatic.ObtenerModeloPersonalizadoxPrefijo(prefijoModelodesdeAspecto);
Aspect aspectoPersonalizado = await AspectosPersonalizadosStatic.ObtenerAspectoPersonalizado(modelo.Name, nombreAspecto);
aspectoPersonalizado.Showable = true;
aspectosFaltantes.Add(aspectoPersonalizado);
}
}
if (aspectosFaltantes.Count != 0)
{
aspectosNodo.AddRange(aspectosFaltantes);
}
//Properties de Aspectos:
AñadirPropsAspectos(propiedadesDeserializadas, aspectosNodo, nodoListo);
}
public async static Task <List <Aspect> > ObtenerAspectosActivos()
{
List <Model> modelos = await ModelosPersonalizadosStatic.ObtenerModelosPersonalizados();
List <Aspect> aspectosPersonalizados = new List <Aspect>();
foreach (var modelo in modelos)
{
if (modelo.Status == "ACTIVE")
{
aspectosPersonalizados.AddRange(await ObtenerAspectosPersonalizados(modelo.Name));
}
}
return(aspectosPersonalizados);
}
public static async Task <List <Type> > ObtenerTiposActivos()
{
List <Model> modelos = await ModelosPersonalizadosStatic.ObtenerModelosPersonalizados();
List <Type> tiposPersonalizados = new List <Type>();
foreach (var modelo in modelos)
{
if (modelo.Status == "ACTIVE")
{
tiposPersonalizados.AddRange(await ObtenerTiposPersonalizados(modelo.Name));
}
}
return(tiposPersonalizados);
}
private async void btnAceptarModelo_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtNombreModelo.Text) || string.IsNullOrEmpty(txtEspacioModelo.Text) || string.IsNullOrEmpty(txtPrefijoModelo.Text))
{
MessageBox.Show("Es obligatorio llenar los campos: Nombre, Espacio de Nombres y Prefijo ", "Advertencia", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
if (btnAceptarModelo.Text == "Crear")
{
FLoading fPrincipalLoading = new FLoading();
try
{
Model modelo = new Model();
modelo.Name = txtNombreModelo.Text;
modelo.NamespaceUri = txtEspacioModelo.Text;
modelo.NamespacePrefix = txtPrefijoModelo.Text;
modelo.Description = txtDescripcionModelo.Text;
var mdiParent = MdiParent as FDashboard;
string autorModelo = PersonasStatic.PersonaAutenticada.FirstName + PersonasStatic.PersonaAutenticada.LastName;
modelo.Author = autorModelo;
modelo.Status = "DRAFT";
fPrincipalLoading.Show();
await ModelosPersonalizadosStatic.CrearModeloPersonalizado(modelo);
fPrincipalLoading.Close();
MessageBox.Show("El nuevo modelo ha sido creado con éxito");
await PoblarDtgvModelos("Sin filtro");
dtgviewDatos.Refresh();
panelModelo.Visible = false;
}
catch (ModelException exception)
{
if (exception.Codigo == 409)
{
fPrincipalLoading.Close();
MessageBox.Show("Uno de los nombres especificados ya se está utlizando", "Nombres duplicados", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else if (btnAceptarModelo.Text == "Editar")
{
FLoading fPrincipalLoading = new FLoading();
try
{
Model modelo = new Model();
modelo.Name = txtNombreModelo.Text;
modelo.NamespaceUri = txtEspacioModelo.Text;
modelo.NamespacePrefix = txtPrefijoModelo.Text;
modelo.Description = txtDescripcionModelo.Text;
var mdiParent = MdiParent as FDashboard;
fPrincipalLoading.Show();
await ModelosPersonalizadosStatic.ActualizarModeloPersonalizado(modelo);
fPrincipalLoading.Close();
MessageBox.Show("El modelo " + modelo.Name + " ha sido actualizado con éxito", "", MessageBoxButtons.OK, MessageBoxIcon.Information);
await PoblarDtgvModelos("Sin filtro");
dtgviewDatos.Refresh();
panelModelo.Visible = false;
PlantillaNuevoModelo();
}
catch (ModelException exception)
{
if (exception.Codigo == 409)
{
fPrincipalLoading.Close();
MessageBox.Show("Uno de los nombres especificados ya se está utlizando", "Nombres duplicados", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
}
private async Task pruebaUnitaria()
{
//prueba unitaria
Model modelo = await ModelosPersonalizadosStatic.ObtenerModeloPersonalizado("testModelNueva");
Console.WriteLine("N " + modelo.Name);
Console.WriteLine("M " + modelo.Author);
Console.WriteLine("S " + modelo.Status);
//Console.WriteLine("Types: "+modelo.Types.Count);
List <Modelos.CMM.Type> tipos = await TiposPersonalizadosStatic.ObtenerTiposPersonalizados("testModelNueva");
foreach (var item in tipos)
{
Console.WriteLine("********TIPOS*******");
Console.WriteLine("Nombre: " + item.Name);
Console.WriteLine("Descripción: " + item.Description);
Console.WriteLine("Título" + item.Title);
foreach (var prop in item.Properties)
{
Console.WriteLine("----*Propiedades*");
Console.WriteLine("----Nombre:" + prop.Name);
Console.WriteLine("----Título: " + prop.Title);
if (prop.Constraints is null)
{
}
else
{
foreach (var constr in prop.Constraints)
{
Console.WriteLine("-----------*Constraint*: " + constr.Name);
Console.WriteLine("-----------Const PrefixedName: " + constr.PrefixedName);
Console.WriteLine("-------------------*Params*");
foreach (var param in constr.Parameters)
{
Console.WriteLine("----------------- key: " + param.Name + " valor: " + param.SimpleValue);
}
}
}
}
}
List <Aspect> aspectos = await AspectosPersonalizadosStatic.ObtenerAspectosPersonalizados("testModelNueva");
foreach (var aspecto in aspectos)
{
Console.WriteLine();
Console.WriteLine("********ASPECTOS*******");
Console.WriteLine("Nombre: " + aspecto.Name);
foreach (var prop in aspecto.Properties)
{
Console.WriteLine("----*Propiedades*");
Console.WriteLine("-----Nombre: " + prop.Name);
Console.WriteLine("-----Descripción: " + prop.Description);
Console.WriteLine("-----Título: " + prop.Title);
Console.WriteLine("-----Tipo de dato: " + prop.Datatype);
Console.WriteLine("-----Valor por defecto: " + prop.DefaultValue);
Console.WriteLine("-----Prefixed Name:" + prop.PrefixedName);
Console.WriteLine("-----Indexación" + prop.IndexTokenisationMode);
Console.WriteLine("-----Multivalorado:" + prop.MultiValued);
foreach (var constraint in prop.Constraints)
{
Console.WriteLine("-----------*Constraint*: " + constraint.Name);
Console.WriteLine("------------Prefijo: " + constraint.PrefixedName);
Console.WriteLine("------------Tipo " + constraint.Type);
Console.WriteLine("-------------------*Params*");
foreach (var param in constraint.Parameters)
{
Console.WriteLine("------------------Nombre:" + param.Name);
Console.WriteLine("------------------Valor simple:" + param.SimpleValue);
}
}
}
}
}