コード例 #1
0
        /// <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);
        }
コード例 #2
0
        private async Task PresentarNodo()
        {
            try
            {
                nodoSeleccionado = await NodosStatic.ObtenerNodoPersonalizado(nodoSeleccionado.Id);

                //Presentación de Tipo y Aspectos del Nodo
                cmbxAspectos.Items.Clear();
                cmbxTipos.Items.Clear();
                cmbxAspectos.Visible         = false;
                cmbxTipos.Visible            = false;
                chkboxCambiarAspecto.Checked = false;
                chkboxCambiarTipo.Checked    = false;
                lblTipo.Text = nodoSeleccionado.NodeType;
                CargarListBoxAspectosPropios();


                flwypanelPropiedades.Controls.Clear();
                //Mapeo de atributos del Nodo para su visualización en el formulario
                lnklblNombre.Text  = nodoSeleccionado.Name;
                lblModificado.Text = "Modificado el " +
                                     nodoSeleccionado.ModifiedAt.ToShortDateString() + " por: " +
                                     nodoSeleccionado.ModifiedByUser.DisplayName;

                List <Aspect> aspectosDisponibles = Aspect.Aspects();

                //Nota: [1] y [0] Depende del orden de creacion de los aspectos-propiedades por defecto
                if (!(nodoSeleccionado.Aspectos is null) || nodoSeleccionado.Aspectos.Find(x => x.Name == aspectosDisponibles[1].Name) is null)
                {
                    lblVersion.Text = "1.0";
                }
                else
                {
                    lblVersion.Text = nodoSeleccionado.Aspectos.Find(x => x.Name == aspectosDisponibles[1].Name).Properties[0].Value;
                }

                //Propiedades(Metadatos):

                //Del nodo (principales):
                DibujarPropiedad("Nombre", nodoSeleccionado.Name, "ATRIBUTO");

                if (!(nodoSeleccionado.Content is null))
                {
                    DibujarPropiedad("Tipo", nodoSeleccionado.Content.MimeTypeName, "ATRIBUTO");
                }

                //De los aspectos del nodo:
                if (!(nodoSeleccionado.Aspectos is null))
                {
                    foreach (var aspecto in nodoSeleccionado.Aspectos)
                    {
                        if (aspecto.Showable && aspecto.PrefixedName != "sync:Sincronizable")
                        {
                            foreach (var propiedad in aspecto.Properties)
                            {
                                DibujarPropiedad(propiedad, "ASPECTO");
                            }
                        }
                    }

                    //Del tipo de nodo(NodeType)
                    if (!(nodoSeleccionado.TipoNodo is null))
                    {
                        if (!(nodoSeleccionado.TipoNodo.Properties is null))
                        {
                            foreach (var propiedad in nodoSeleccionado.TipoNodo.Properties)
                            {
                                DibujarPropiedad(propiedad, "TIPO");
                            }
                        }
                    }
                }
            }