コード例 #1
0
    protected void grDatos_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        DataRow row = dt.Rows[int.Parse(e.CommandArgument.ToString())];
        int id = int.Parse(row["idatributos"].ToString());

        if (e.CommandName.Equals("btnEditar"))
        {
            Atributo attr = new Atributo(id);
            if (DAOAtributo.sqlLeer(attr))
            {
                btnCancelar.Visible = true;
                hdnId.Value = id.ToString();
                hdnAccion.Value = "u";
                btnAgregar.Text = "Editar";
                btnAgregar.CssClass = "btn btn-success";

                txtNombre.Text = attr.Attr;

                // Si pongo solamente el checked = true no funciona :s.
                // tengo que poner en false los otros.
                if (attr.Textarea != 0)
                {
                    rbTextareaNo.Checked = false;
                    rbTextareaSi.Checked = true;
                }
                else
                {
                    rbTextareaSi.Checked = false;
                    rbTextareaNo.Checked = true;
                }
            }

        }

        if (e.CommandName.Equals("btnEliminar"))
        {
            if (DAOAtributo.sqlDelete(new Atributo(id)))
            {
                hdnAccion.Value = "d";
                panelMensajesCorrectos.Visible = true;
                lblMensajes.Text = "Atributo <b>" + txtNombre.Text + "</b> eliminado con éxito.";
                hdnAccion.Value = "i";
                btnAgregar.Text = "Agregar";
                btnAgregar.CssClass = "btn btn-primary";
            }
            else
            {
                panelMensajesErrores.Visible = true;
                lblErrores.Text = "No se ha podido eliminar el atributo. Intente de nuevo.";
            }

            cargarGrilla();
        }
    }
コード例 #2
0
ファイル: Entidad.cs プロジェクト: miguee90/DataBase
 public Entidad(string nom)
 {
     nombre = nom;
     atributos = new List<Atributo>();
     bloques = new List<Bloque>();
     Atributo fechaA = new Atributo("fecha_A", "string", 8, 3, 0, 0, 0, "");
     Atributo fechaB = new Atributo("fecha_B", "string", 8, 3, 0, 0, 0, "");
     Atributo fechaM = new Atributo("fecha_M", "string", 8, 3, 0, 0, 0, "");
     Atributo usuarioA = new Atributo("usuario_A", "string", 8, 3, 0, 0, 0, "");
     Atributo usuarioB = new Atributo("usuario_B", "string", 8, 3, 0, 0, 0, "");
     Atributo usuarioM = new Atributo("usuario_M", "string", 8, 3, 0, 0, 0, "");
     atributos.Add(fechaA);
     atributos.Add(fechaB);
     atributos.Add(fechaM);
     atributos.Add(usuarioA);
     atributos.Add(usuarioB);
     atributos.Add(usuarioM);
     listaRegistros = new List<List<string>>();
 }
コード例 #3
0
ファイル: Multilistas.cs プロジェクト: miguee90/DataBase
        private void eliminaOrdenado(Entidad ent, Atributo a, string dirBloq, int indice)
        {
            string datoLeido;
            long dirNextBloq = a.ApuntaEntidad; ;
            long dirActual = 0;
            long dirAnt = 0;

                while (dirNextBloq != -1)
                {
                    archivo.setStreamPosition(dirNextBloq);
                    //Recorre los atributos
                    dirNextBloq=recorrePtrs(dirNextBloq, ent,indice);
                    dirActual = archivo.getLong();
                    archivo.getLong();
                    //Obtiene el dato a ordenar
                    datoLeido = getDatoByIndice(indice,Convert.ToInt64( dirBloq), ent);
                    if (dirActual==Convert.ToInt64(dirBloq))
                    {
                        //Si es el primer lugar
                        if (dirAnt == 0)
                        {
                            a.ApuntaEntidad = dirNextBloq;
                            archivo.escribePtrDatAtr(a.Direccion, dirNextBloq);
                            break;
                        }
                        //Si es un elemento intermedio
                        else
                        {
                            //reescribe el apuntador del bloque anterior
                            escribePtrNextBloq(dirAnt, indice, ent, dirNextBloq);
                            break;
                        }
                    }
                    dirAnt = dirActual;
                }
        }
コード例 #4
0
 public void CriarAtributo(Atributo inputs)
 {
     _repo.CriarAtributo(inputs);
 }
コード例 #5
0
        private object Ejecutar(ParseTreeNode nodo)
        {
            string produccion = nodo.Term.Name.ToString();
            int    tipo_real  = 0;

            switch (produccion)
            {
            case "DATABASES2":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Database> bases = (List <Database>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    bases.Add((Database)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(bases);
                }
                else if (nodo.ChildNodes.Count == 1)
                {
                    List <Database> bases = new List <Database>
                    {
                        (Database)Ejecutar(nodo.ChildNodes.ElementAt(0))
                    };
                    return(bases);
                }
                else
                {
                    return(new List <Database>());
                }

            case "DATABASE":
                List <Tipo_Objeto> lst_objetos = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(1));
                Database           new_db      = new Database();

                foreach (Tipo_Objeto item in lst_objetos)
                {
                    if (item.Name.ToLower().Equals("\"name\""))
                    {
                        new_db.Name = item.Valor.ToString();
                    }
                    else if (item.Name.ToLower().Equals("\"data\""))
                    {
                        if (item.Valor != null)
                        {
                            try
                            {
                                foreach (Tipo_Objeto item2 in (List <Tipo_Objeto>)item.Valor)
                                {
                                    if (item2.Name.Equals("table"))
                                    {
                                        new_db.Tablas.Add((Tabla)item2.Valor);
                                    }
                                    else if (item2.Name.Equals("object"))
                                    {
                                        new_db.Objetos.Add((Objeto)item2.Valor);
                                    }
                                    else if (item2.Name.Equals("procedure"))
                                    {
                                        new_db.Procedures.Add((Procedure)item2.Valor);
                                    }
                                }
                            }
                            catch (Exception)
                            {
                                Tipo_Objeto val_aux = (Tipo_Objeto)item.Valor;
                                new_db.Link      = val_aux.Link;
                                new_db.Exportada = val_aux.Export;

                                //aqui exportamos los archivos de bases de datos

                                String text = System.IO.File.ReadAllText("./NOSQL/Generados/" + new_db.Link);

                                LanguageData  lenguaje = new LanguageData(new Gramatica_Import_DATABASE());
                                Parser        parser   = new Parser(lenguaje);
                                ParseTree     arbol    = parser.Parse(text);
                                ParseTreeNode raiz     = arbol.Root;

                                if (raiz != null && arbol.ParserMessages.Count == 0)
                                {
                                    foreach (Tipo_Objeto item2 in (List <Tipo_Objeto>)Ejecutar(raiz.ChildNodes.ElementAt(0)))
                                    {
                                        if (item2.Name.Equals("table"))
                                        {
                                            new_db.Tablas.Add((Tabla)item2.Valor);
                                        }
                                        else if (item2.Name.Equals("object"))
                                        {
                                            new_db.Objetos.Add((Objeto)item2.Valor);
                                        }
                                        else if (item2.Name.Equals("procedure"))
                                        {
                                            new_db.Procedures.Add((Procedure)item2.Valor);
                                        }
                                    }
                                }
                                else
                                {
                                    Program.addError(arbol);
                                }
                            }
                        }
                    }
                }
                return(new_db);

            case "DATABASE2":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Tipo_Objeto> tipo_Objetos = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    tipo_Objetos.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(tipo_Objetos);
                }
                else
                {
                    List <Tipo_Objeto> objetos = new List <Tipo_Objeto>
                    {
                        (Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0))
                    };

                    return(objetos);
                }

            case "DATABASE3":
                return((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));

            case "DATA":
                Tipo_Objeto objeto1 = new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(3)));
                return(objeto1);

            case "DATA5":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Tipo_Objeto> lst_general = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    lst_general.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(lst_general);
                }
                else if (nodo.ChildNodes.Count == 1)
                {
                    if (nodo.ChildNodes.ElementAt(0).Term.Name.Equals("ruta_import"))
                    {
                        Tipo_Objeto aux__ = new Tipo_Objeto("null", "null");
                        aux__.Export = true;
                        string link = nodo.ChildNodes.ElementAt(0).Token.Text.Replace("${ ", "");
                        link       = link.Replace(" }$", "");
                        aux__.Link = link;
                        return(aux__);
                    }

                    List <Tipo_Objeto> lst_general = new List <Tipo_Objeto>();
                    lst_general.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(lst_general);
                }
                else
                {
                    return(null);
                }

            case "DATA2":
                Tabla              tabla_aux = new Tabla();
                Objeto             objeto_aux = new Objeto();
                Procedure          procedure_aux = new Procedure();
                string             name = "", cql_type = "";
                object             columna = null, data = null, attrs = null, parametros = null, instr = null;
                List <Tipo_Objeto> lst = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(1));
                foreach (Tipo_Objeto item in lst)
                {
                    if (item.Name.ToLower().Equals("\"name\""))
                    {
                        name = item.Valor.ToString();
                    }
                    else if (item.Name.ToLower().Equals("\"cql-type\""))
                    {
                        cql_type = item.Valor.ToString();
                    }
                    else if (item.Name.ToLower().Equals("\"columns\""))
                    {
                        columna = item.Valor;
                    }
                    else if (item.Name.ToLower().Equals("\"data\""))
                    {
                        data = item.Valor;
                    }
                    else if (item.Name.ToLower().Equals("\"attrs\""))
                    {
                        attrs = item.Valor;
                    }
                    else if (item.Name.ToLower().Equals("\"parameters\""))
                    {
                        parametros = item.Valor;
                    }
                    else if (item.Name.ToLower().Equals("\"instr\""))
                    {
                        instr = item.Valor;
                    }
                }

                if (cql_type.ToLower().Equals("table"))
                {
                    tabla_aux      = new Tabla();
                    tabla_aux.Name = name;
                    if (columna != null)
                    {
                        tabla_aux.Columnas = (List <Columna>)columna;
                    }
                    else
                    {
                        tabla_aux.Columnas = new List <Columna>();
                    }
                    if (data != null)
                    {
                        try
                        {
                            List <Fila> filas = (List <Fila>)data;
                            tabla_aux.Filas = filas;
                        }
                        catch (Exception)
                        {
                            Tipo_Objeto aux2 = (Tipo_Objeto)data;
                            tabla_aux.Link      = aux2.Link;
                            tabla_aux.Exportada = aux2.Export;

                            String text = System.IO.File.ReadAllText("./NOSQL/Generados/" + tabla_aux.Link);

                            LanguageData  lenguaje = new LanguageData(new Gramatica_Import_DATA());
                            Parser        parser   = new Parser(lenguaje);
                            ParseTree     arbol    = parser.Parse(text);
                            ParseTreeNode raiz     = arbol.Root;

                            if (raiz != null && arbol.ParserMessages.Count == 0)
                            {
                                tabla_aux.Filas = (List <Fila>)Ejecutar(raiz.ChildNodes.ElementAt(0));
                            }
                            else
                            {
                                Program.addError(arbol);
                            }

                            //instanciamos un objeto para la base de datos no-sql
                        }
                    }
                    else
                    {
                        tabla_aux.Filas = new List <Fila>();
                    }

                    return(new Tipo_Objeto("table", tabla_aux));
                }
                else if (cql_type.ToLower().Equals("object"))
                {
                    objeto_aux.Name = name;
                    if (attrs != null)
                    {
                        objeto_aux.Atributos = (List <Atributo>)attrs;
                    }
                    else
                    {
                        objeto_aux.Atributos = new List <Atributo>();
                    }
                    return(new Tipo_Objeto("object", objeto_aux));
                }
                else if (cql_type.ToLower().Equals("procedure"))
                {
                    procedure_aux.Name = name;
                    if (instr != null)
                    {
                        procedure_aux.Instr = instr.ToString();
                    }
                    else
                    {
                        procedure_aux.Instr = "";
                    }
                    if (parametros != null)
                    {
                        procedure_aux.Parametros = (List <Parametro>)parametros;
                    }
                    else
                    {
                        procedure_aux.Parametros = new List <Parametro>();
                    }

                    return(new Tipo_Objeto("procedure", procedure_aux));
                }
                else
                {
                    return(new Tipo_Objeto("table", tabla_aux));
                }

            case "DATA3":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Tipo_Objeto> lst_general = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    lst_general.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(lst_general);
                }
                else
                {
                    List <Tipo_Objeto> lst_general = new List <Tipo_Objeto>();
                    lst_general.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(lst_general);
                }

            case "DATA4":
                return((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));

            case "TABLA":
                return((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));

            case "OBJETO":
                return((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));

            case "PROCEDURE":
                return((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));

            case "COLUMNS":
                if (Ejecutar(nodo.ChildNodes.ElementAt(3)) != null)
                {
                    return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(3))));
                }
                else
                {
                    return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), null));
                }

            case "COLUMNS4":

                if (nodo.ChildNodes.Count == 3)
                {
                    List <Columna> columnas = (List <Columna>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    columnas.Add((Columna)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(columnas);
                }
                else if (nodo.ChildNodes.Count == 1)
                {
                    List <Columna> columnas = new List <Columna>();
                    columnas.Add((Columna)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(columnas);
                }
                else
                {
                    return(null);
                }

            case "COLUMNS2":

                Columna new_column = new Columna();
                foreach (Tipo_Objeto item in (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(1)))
                {
                    if (item.Name.ToLower().Equals("\"name\""))
                    {
                        new_column.Name = item.Valor.ToString();
                    }
                    else if (item.Name.ToLower().Equals("\"type\""))
                    {
                        if (item.Valor.ToString().ToLower().Contains("set"))
                        {
                            new_column.Type  = "SET";
                            new_column.Attr1 = item.Valor.ToString().ToLower().Replace("set<", "").Replace(">", "");
                        }
                        else if (item.Valor.ToString().ToLower().Contains("map"))
                        {
                            new_column.Type = "MAP";
                            string[] attrsa = item.Valor.ToString().ToLower().Replace("map<", "").Replace(">", "").Split(",");

                            new_column.Attr1 = attrsa.ElementAt(0);
                            new_column.Attr2 = attrsa.ElementAt(1);
                        }
                        else if (item.Valor.ToString().ToLower().Contains("list"))
                        {
                            new_column.Type  = "LIST";
                            new_column.Attr1 = item.Valor.ToString().ToLower().Replace("list<", "").Replace(">", "");
                        }
                        else
                        {
                            new_column.Type = item.Valor.ToString();
                        }
                    }
                    else if (item.Name.ToLower().Equals("\"pk\""))
                    {
                        if (item.Valor.ToString().ToLower().Equals("false"))
                        {
                            new_column.Pk = false;
                        }
                        else if (item.Valor.ToString().ToLower().Equals("true"))
                        {
                            new_column.Pk = true;
                        }
                        else
                        {
                            //algun error
                        }
                    }
                }
                return(new_column);

            case "COLUMNS3":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Tipo_Objeto> tipo_Objetos = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    tipo_Objetos.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(tipo_Objetos);
                }
                else
                {
                    List <Tipo_Objeto> objetos = new List <Tipo_Objeto>();
                    objetos.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(objetos);
                }

            case "COLUMN":
                return(Ejecutar(nodo.ChildNodes.ElementAt(0)));

            case "TYPE":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(2)).ToString()));

            case "PK":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(2)).ToString()));

            case "BOOL":
                return(nodo.ChildNodes[0].Term.Name);

            case "AS":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(2)).ToString()));

            case "IN_OUT":
                return(nodo.ChildNodes[0].Token.Text);

            case "DATA_DATA":
                //Aqui armamos las filas;
                if (Ejecutar(nodo.ChildNodes.ElementAt(3)) != null)
                {
                    return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(3))));
                }
                else
                {
                    return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), null));
                }

            case "DATA_DATA2":

                if (nodo.ChildNodes.Count == 1)
                {
                    if (nodo.ChildNodes.ElementAt(0).Term.Name.Equals("ruta_import"))
                    {
                        Tipo_Objeto aux__ = new Tipo_Objeto("null", "null");
                        string      link  = nodo.ChildNodes.ElementAt(0).Token.Text.Replace("${ ", "");
                        link         = link.Replace(" }$", "");
                        aux__.Export = true;
                        aux__.Link   = link;

                        return(aux__);
                    }

                    return(Ejecutar(nodo.ChildNodes.ElementAt(0)));
                }
                else
                {
                    return(null);
                }


            case "DATA_DATA3":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Fila> filas = (List <Fila>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    filas.Add((Fila)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(filas);
                }
                else
                {
                    List <Fila> filas = new List <Fila>();
                    filas.Add((Fila)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(filas);
                }

            case "DATA_DATA4":
                //aqui armamos la fila
                Fila fila = new Fila();
                fila.Valores = (List <Valor>)Ejecutar(nodo.ChildNodes.ElementAt(1));
                return(fila);

            case "DATA_DATA5":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Valor> valors = (List <Valor>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    valors.Add((Valor)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(valors);
                }
                else
                {
                    List <Valor> valors = new List <Valor>();
                    valors.Add((Valor)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(valors);
                }

            case "DATA_DATA6":
                tipo_real = getType(nodo.ChildNodes[2].ChildNodes.ElementAt(0));
                Valor val = new Valor(Ejecutar(nodo.ChildNodes.ElementAt(0)).ToString(), Ejecutar(nodo.ChildNodes.ElementAt(2)), tipo_real);
                return(val);

            case "ATTRIBUTES":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(3))));

            case "ATTRIBUTES2":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Atributo> atributos = (List <Atributo>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    atributos.Add((Atributo)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(atributos);
                }
                else if (nodo.ChildNodes.Count == 1)
                {
                    List <Atributo> atributos = new List <Atributo>();
                    atributos.Add((Atributo)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(atributos);
                }
                else
                {
                    return(new List <Atributo>());
                }

            case "ATTRIBUTES3":
                Atributo atributo_new = new Atributo();

                foreach (Tipo_Objeto item in (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(1)))
                {
                    if (item.Name.ToLower().Equals("\"name\""))
                    {
                        atributo_new.Name = item.Valor.ToString();
                    }
                    else if (item.Name.ToLower().Equals("\"type\""))
                    {
                        if (item.Valor.ToString().ToLower().Contains("set"))
                        {
                            atributo_new.Type  = "SET";
                            atributo_new.Attr1 = item.Valor.ToString().ToLower().Replace("set<", "").Replace(">", "");
                        }
                        else if (item.Valor.ToString().ToLower().Contains("map"))
                        {
                            atributo_new.Type = "MAP";
                            string[] attrsa = item.Valor.ToString().ToLower().Replace("map<", "").Replace(">", "").Split(",");

                            atributo_new.Attr1 = attrsa.ElementAt(0);
                            atributo_new.Attr2 = attrsa.ElementAt(1);
                        }
                        else if (item.Valor.ToString().ToLower().Contains("list"))
                        {
                            atributo_new.Type  = "LIST";
                            atributo_new.Attr1 = item.Valor.ToString().ToLower().Replace("list<", "").Replace(">", "");
                        }
                        else
                        {
                            atributo_new.Type = item.Valor.ToString();
                        }
                    }
                    else
                    {
                        //algun error
                    }
                }
                return(atributo_new);

            case "ATTRIBUTES4":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Tipo_Objeto> tipo_Objetos = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    tipo_Objetos.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(tipo_Objetos);
                }
                else
                {
                    List <Tipo_Objeto> objetos = new List <Tipo_Objeto>();
                    objetos.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(objetos);
                }

            case "ATTRIBUTE":
                return(Ejecutar(nodo.ChildNodes.ElementAt(0)));

            case "INSTR":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), nodo.ChildNodes.ElementAt(2).Token.Text));

            case "PARAMETERS":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(3))));

            case "PARAMETERS2":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Parametro> param = (List <Parametro>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    param.Add((Parametro)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(param);
                }
                else if (nodo.ChildNodes.Count == 1)
                {
                    List <Parametro> param = new List <Parametro>();
                    param.Add((Parametro)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(param);
                }
                else
                {
                    return(new List <Parametro>());
                }

            case "PARAMETERS3":
                Parametro new_param = new Parametro();

                foreach (Tipo_Objeto item in (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(1)))
                {
                    if (item.Name.ToLower().Equals("\"name\""))
                    {
                        new_param.Name = item.Valor.ToString();
                    }
                    else if (item.Name.ToLower().Equals("\"type\""))
                    {
                        if (item.Valor.ToString().ToLower().Contains("set"))
                        {
                            new_param.Type  = "SET";
                            new_param.Attr1 = item.Valor.ToString().ToLower().Replace("set<", "").Replace(">", "");
                        }
                        else if (item.Valor.ToString().ToLower().Contains("map"))
                        {
                            new_param.Type = "MAP";
                            string[] attrsa = item.Valor.ToString().ToLower().Replace("map<", "").Replace(">", "").Split(",");

                            new_param.Attr1 = attrsa.ElementAt(0);
                            new_param.Attr2 = attrsa.ElementAt(1);
                        }
                        else if (item.Valor.ToString().ToLower().Contains("list"))
                        {
                            new_param.Type  = "LIST";
                            new_param.Attr1 = item.Valor.ToString().ToLower().Replace("list<", "").Replace(">", "");
                        }
                        else
                        {
                            new_param.Type = item.Valor.ToString();
                        }
                    }
                    else if (item.Name.ToLower().Equals("\"as\""))
                    {
                        if (item.Valor.ToString().ToLower().Equals("in"))
                        {
                            new_param.Out_ = false; new_param.Out__ = item.Valor.ToString();
                        }
                        else
                        {
                            new_param.Out_ = true; new_param.Out__ = item.Valor.ToString();
                        }
                    }
                    else
                    {
                        //algun error
                    }
                }
                return(new_param);

            case "PARAMETERS4":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Tipo_Objeto> tipo_Objetos = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    tipo_Objetos.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(tipo_Objetos);
                }
                else
                {
                    List <Tipo_Objeto> objetos = new List <Tipo_Objeto>();
                    objetos.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(objetos);
                }

            case "PARAMETER":
                return(Ejecutar(nodo.ChildNodes.ElementAt(0)));

            case "LISTAS":
                return(Ejecutar(nodo.ChildNodes.ElementAt(1)));

            case "MAPA":
                return(Ejecutar(nodo.ChildNodes.ElementAt(1)));

            case "MAPA2":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Tipo_Objeto> valores = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    valores.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(valores);
                }
                else if (nodo.ChildNodes.Count == 1)
                {
                    List <Tipo_Objeto> valores = new List <Tipo_Objeto>();
                    valores.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(valores);
                }
                else
                {
                    return(new List <Tipo_Objeto>());
                }

            case "MAPA3":
                tipo_real = getType(nodo.ChildNodes[2].ChildNodes.ElementAt(0));
                Tipo_Objeto ret = new Tipo_Objeto(Ejecutar(nodo.ChildNodes.ElementAt(0)).ToString(), Ejecutar(nodo.ChildNodes.ElementAt(2)));
                ret.Type = tipo_real;
                return(ret);

            case "LISTAS2":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Item_List> valores = (List <Item_List>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    valores.Add((Item_List)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(valores);
                }
                else if (nodo.ChildNodes.Count == 1)
                {
                    List <Item_List> valores = new List <Item_List>();
                    valores.Add((Item_List)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(valores);
                }
                else
                {
                    return(new List <Item_List>());
                }

            case "LISTAS3":
                tipo_real = getType(nodo.ChildNodes[0].ChildNodes.ElementAt(0));

                return(new Item_List(tipo_real, Ejecutar(nodo.ChildNodes.ElementAt(0))));


            case "USERS2":
                if (nodo.ChildNodes.ElementAt(0).Term.Name.Equals("ruta_import"))
                {
                    string link = nodo.ChildNodes.ElementAt(0).Token.Text.Replace("${ ", "");
                    link               = link.Replace(" }$", "");
                    db_nosql.Link      = link;
                    db_nosql.Importada = true;
                    String text = System.IO.File.ReadAllText("./NOSQL/Generados/" + link);

                    LanguageData  lenguaje = new LanguageData(new Gramatica_Import_User());
                    Parser        parser   = new Parser(lenguaje);
                    ParseTree     arbol    = parser.Parse(text);
                    ParseTreeNode raiz     = arbol.Root;

                    if (raiz != null && arbol.ParserMessages.Count == 0)
                    {
                        return((List <Usuario>)Ejecutar(raiz.ChildNodes.ElementAt(0)));
                    }
                    else
                    {
                        Program.addError(arbol);
                        return(new List <Usuario>());
                    }
                }
                else if (nodo.ChildNodes.Count == 3)
                {
                    List <Usuario> usuarios = (List <Usuario>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    usuarios.Add((Usuario)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(usuarios);
                }
                else if (nodo.ChildNodes.Count == 1)
                {
                    List <Usuario> users = new List <Usuario>();
                    users.Add((Usuario)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(users);
                }
                else
                {
                    return(new List <Usuario>());
                }

            case "USERS3":
                Usuario new_user = new Usuario();

                foreach (Tipo_Objeto item in (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(1)))
                {
                    if (item.Name.ToLower().Equals("\"name\""))
                    {
                        new_user.Name = item.Valor.ToString();
                    }
                    else if (item.Name.ToLower().Equals("\"password\""))
                    {
                        new_user.Password = item.Valor.ToString();
                    }
                    else if (item.Name.ToLower().Equals("\"permissions\""))
                    {
                        new_user.Permisos = (List <Permiso>)item.Valor;
                    }
                }
                return(new_user);

            case "USERS4":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Tipo_Objeto> tipo_Objetos = (List <Tipo_Objeto>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    tipo_Objetos.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(tipo_Objetos);
                }
                else
                {
                    List <Tipo_Objeto> objetos = new List <Tipo_Objeto>();
                    objetos.Add((Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(objetos);
                }

            case "USER":
                return(Ejecutar(nodo.ChildNodes.ElementAt(0)));

            case "CQL_TYPE":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(2)).ToString()));

            case "NAME":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(2)).ToString()));

            case "PASSWORD":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(2)).ToString()));

            case "PERMISSIONS":
                return(new Tipo_Objeto(nodo.ChildNodes[0].Term.Name.ToString(), Ejecutar(nodo.ChildNodes.ElementAt(3))));

            case "VALOR":
                String evaluar = nodo.ChildNodes[0].Term.Name;
                switch (evaluar)
                {
                case "Cadena":
                    return(nodo.ChildNodes[0].ToString().Replace(" (Cadena)", ""));

                case "Identificador":
                    return(nodo.ChildNodes[0].ToString().Replace(" (Identificador)", ""));

                case "Numero":
                    return(nodo.ChildNodes[0].Token.Text);

                case "NULL":
                    return(null);

                case "Time":
                    return(nodo.ChildNodes[0].Token.Text);

                case "FALSE":
                    return(false);

                case "TRUE":
                    return(true);

                case "Date":
                    return(nodo.ChildNodes[0].Token.Text);

                case "LISTAS":
                    return(Ejecutar(nodo.ChildNodes.ElementAt(0)));

                case "MAPA":
                    return(Ejecutar(nodo.ChildNodes.ElementAt(0)));

                default:
                    return("");
                }

            case "PERMISSIONS2":
                if (nodo.ChildNodes.Count == 3)
                {
                    List <Permiso> permisos = (List <Permiso>)Ejecutar(nodo.ChildNodes.ElementAt(0));
                    permisos.Add((Permiso)Ejecutar(nodo.ChildNodes.ElementAt(2)));
                    return(permisos);
                }
                else if (nodo.ChildNodes.Count == 1)
                {
                    List <Permiso> permisos = new List <Permiso>();
                    permisos.Add((Permiso)Ejecutar(nodo.ChildNodes.ElementAt(0)));
                    return(permisos);
                }
                else
                {
                    return(new List <Permiso>());
                }

            case "PERMISSION":
                Tipo_Objeto aux     = (Tipo_Objeto)Ejecutar(nodo.ChildNodes.ElementAt(1));
                Permiso     permiso = new Permiso(aux.Valor.ToString());
                return(permiso);
            }
            return(null);
        }
コード例 #6
0
        public object analizar(ParseTreeNode raiz, LinkedList <string> mensajes)
        {
            if (raiz != null)
            {
                string etiqueta = raiz.Term.Name.ToLower();
                switch (etiqueta)
                {
                case "lista":
                    LinkedList <Data> lista = new LinkedList <Data>();
                    object            res;
                    if (raiz.ChildNodes.Count() == 3)
                    {
                        lista = (LinkedList <Data>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        l     = raiz.ChildNodes.ElementAt(1).Token.Location.Line;
                        c     = raiz.ChildNodes.ElementAt(1).Token.Location.Column;
                        res   = analizar(raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(1), mensajes);
                    }
                    else
                    {
                        //-------------------------------- IMPORTAR ------------------------------------------
                        if (raiz.ChildNodes.ElementAt(0).ChildNodes.Count() == 1)
                        {
                            ParseTreeNode hijo      = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0);
                            string        direccion = hijo.Token.Text.TrimStart('$').TrimStart('{').TrimEnd('}').TrimEnd('}').TrimEnd('$').TrimEnd('}');
                            object        nuevoNodo = analizarImport(direccion, mensajes);
                            if (nuevoNodo != null)
                            {
                                return(analizar((ParseTreeNode)nuevoNodo, mensajes));
                            }
                            else
                            {
                                return(null);
                            }
                        }

                        l   = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0).Token.Location.Line;
                        c   = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0).Token.Location.Column;
                        res = analizar(raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(1), mensajes);
                    }

                    if (res != null)
                    {
                        lista.AddLast(new Data((LinkedList <Atributo>)res));
                    }

                    return(lista);

                    break;



                case "inobjetos":
                    LinkedList <Data> lista2 = new LinkedList <Data>();
                    object            res2;
                    if (raiz.ChildNodes.Count() == 5)
                    {
                        lista2 = (LinkedList <Data>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        l      = raiz.ChildNodes.ElementAt(1).Token.Location.Line;
                        c      = raiz.ChildNodes.ElementAt(1).Token.Location.Column;
                        res2   = analizar(raiz.ChildNodes.ElementAt(3), mensajes);
                    }
                    else
                    {
                        l    = raiz.ChildNodes.ElementAt(0).Token.Location.Line;
                        c    = raiz.ChildNodes.ElementAt(0).Token.Location.Column;
                        res2 = analizar(raiz.ChildNodes.ElementAt(1), mensajes);
                    }

                    if (res2 != null)
                    {
                        lista2.AddLast(new Data((LinkedList <Atributo>)res2));
                    }

                    return(lista2);



                //-------------------------------------- objetos -------------------------------------------------------------------
                case "objetos":
                    LinkedList <Atributo> listaValores = new LinkedList <Atributo>();
                    object resO;
                    if (raiz.ChildNodes.Count() == 3)
                    {
                        listaValores = (LinkedList <Atributo>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        resO         = analizar(raiz.ChildNodes.ElementAt(2), mensajes);
                    }
                    else
                    {
                        resO = analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                    }

                    if (resO != null)
                    {
                        listaValores.AddLast((Atributo)resO);
                    }
                    return(listaValores);

                //------------------------------------ OBJETO -----------------------------------------------------------------------
                case "objeto":

                    string nombre = raiz.ChildNodes.ElementAt(0).Token.Text.ToLower().TrimEnd('\"').TrimStart('\"');

                    object valor = analizar(raiz.ChildNodes.ElementAt(2), mensajes);

                    Atributo a = new Atributo(nombre, valor, "");
                    return(a);

                    break;



                //-------------------------------------------------------------- analizar las tablas ---------------------------------------------------------
                case "tipo":

                    if (raiz.ChildNodes.Count() == 1)
                    {
                        string term          = raiz.ChildNodes.ElementAt(0).Term.Name.ToLower().TrimStart().TrimEnd();
                        string valorRetornar = raiz.ChildNodes.ElementAt(0).Token.Text.TrimEnd('\"').TrimStart('\"');
                        valorRetornar = valorRetornar.TrimStart('\'').TrimEnd('\'');
                        valorRetornar = valorRetornar.TrimEnd().TrimStart();
                        if (term.Equals("cadena"))
                        {
                            return(valorRetornar);
                        }
                        else if (term.Equals("true"))
                        {
                            return(true);
                        }
                        else if (term.Equals("false"))
                        {
                            return(false);
                        }
                        else if (term.Equals("entero"))
                        {
                            return(Int32.Parse(valorRetornar));
                        }
                        else if (term.Equals("decimal"))
                        {
                            return(Double.Parse(valorRetornar));
                        }
                        else if (term.Equals("fecha"))
                        {
                            return(DateTime.Parse(valorRetornar));
                        }
                        else if (term.Equals("hora"))
                        {
                            return(TimeSpan.Parse(valorRetornar));
                        }
                    }
                    else if (raiz.ChildNodes.Count() == 2)
                    {
                        return(new Set("", new LinkedList <object>()));
                    }
                    else if (raiz.ChildNodes.Count() == 3)
                    {
                        string token = raiz.ChildNodes.ElementAt(1).Term.Name.ToLower();
                        if (token.Equals("lista"))
                        {
                            return((Set)analizarLista(raiz.ChildNodes.ElementAt(1), mensajes));
                        }
                        else if (token.Equals("objetos"))
                        {
                            return((LinkedList <Atributo>)analizar(raiz.ChildNodes.ElementAt(1), mensajes));
                        }
                    }

                    break;
                }
            }
            return(null);
        }
コード例 #7
0
        public Resultado ejecutar(ParseTreeNode raiz)
        {
            Resultado resultado = null;

            foreach (ParseTreeNode hijo in raiz.ChildNodes)
            {
                if (resultado != null)
                {
                    return(resultado);
                }
                String tipoAccion = hijo.Term.Name;
                switch (tipoAccion)
                {
                case "CREARDB":
                    Form1.sistemaArchivos.crearBase(hijo);
                    break;

                case "CREARTABLA":
                    Form1.sistemaArchivos.crearTabla(hijo);
                    break;

                case "CONTAR":
                    Form1.sistemaArchivos.contar(hijo);
                    break;

                case "DECLARACION":    //jose
                    Declaracion declaracion = new Declaracion();
                    Boolean     estado      = declaracion.declaracion(hijo);
                    break;

                case "SELECCIONAR":
                    Form1.sistemaArchivos.realizarConsulta(hijo);
                    break;

                case "RESTAURARBD":
                    Form1.sistemaArchivos.restaurar(hijo);
                    break;

                case "BACKUP":
                    Form1.sistemaArchivos.backup(hijo);
                    break;

                case "USAR":
                    Form1.sistemaArchivos.setBaseActual(hijo.ChildNodes[0]);
                    guardarMetodos(raiz, raizCompleta);
                    break;

                case "IMPRIMIR":
                    opL = new Logica();
                    Form1.Mensajes.Add(opL.operar(hijo.ChildNodes[0]).valor + "");
                    break;

                case "USUARIO":
                    Form1.sistemaArchivos.crearUsuario(hijo);
                    break;

                case "ACTUALIZAR":
                    Form1.sistemaArchivos.actualizar(hijo);
                    break;

                case "ALTERARTABLA":
                    Form1.sistemaArchivos.alterarTabla(hijo);
                    break;

                case "ALTERAROBJETO":
                    Form1.sistemaArchivos.alterarObjeto(hijo);
                    break;

                case "ALTERARUSUARIO":
                    Form1.sistemaArchivos.alterarUsuario(hijo);
                    break;

                case "BORRAR":     // Borrar registro en la tupla
                    Form1.sistemaArchivos.borrar(hijo);
                    break;

                case "INSERTAR":
                    Form1.sistemaArchivos.insertar(hijo);
                    break;

                case "PERMISOS":
                    Form1.sistemaArchivos.permisos(hijo);
                    break;

                case "ELIMINAR":
                    Form1.sistemaArchivos.eliminar(hijo);
                    break;

                case "CREAROBJETO":    //jose
                    String        nombreObjeto = hijo.ChildNodes[0].Token.Text;
                    ParseTreeNode atributos    = hijo.ChildNodes[1];
                    Objeto        objeto       = new Objeto(nombreObjeto);
                    foreach (ParseTreeNode nodoAtributo in atributos.ChildNodes)
                    {
                        Atributo atributo = new Atributo(nodoAtributo.ChildNodes[0].ChildNodes[0].Token.Text, nodoAtributo.ChildNodes[1].Token.Text, null);
                        objeto.addAtributo(atributo);
                    }
                    Form1.sistemaArchivos.getBase().agregarObjeto(objeto, hijo.Span.Location.Line, hijo.Span.Location.Column);
                    break;

                case "ASIGNAROBJ":
                    Asignacion asignacion = new Asignacion();
                    asignacion.asignar(hijo);
                    break;

                case "LLAMADA":
                    nivel++;
                    Llamada   llamada = new Llamada(this);
                    Resultado r       = llamada.ejecutar(hijo);
                    nivel--;
                    break;

                case "RETORNO":
                    opL       = new Logica();
                    resultado = opL.operar(hijo.ChildNodes[0]);
                    return(resultado);

                case "SENTSI":
                    Si si = new Si(this);
                    resultado = si.ejecutar(hijo);
                    break;

                case "MIENTRAS":
                    Mientras mientras = new Mientras(this);
                    resultado = mientras.ejecutar(hijo);
                    break;

                case "DETENER":
                    resultado         = new Resultado("Error", null);
                    resultado.detener = true;
                    return(resultado);

                case "PARA":
                    Para para = new Para(this);
                    resultado = para.ejecutar(hijo);
                    break;

                case "SENTSELECCIONA":
                    Selecciona selecciona = new Selecciona(this);
                    resultado = selecciona.ejecutar(hijo);
                    break;
                }
            }
            return(resultado);
        }
コード例 #8
0
        private void GravarFeicoesShape(FonteFeicaoShapeStream fonte, FonteFeicaoOracleSpatial destino, string shapeName, StringCollection relatorio)
        {
            ClasseFeicao classeFonte = fonte.ObterClasseFeicao(shapeName);

            if (classeFonte == null)
            {
                return;
            }

            ClasseFeicao classeDestino = destino.ObterClasseFeicao("TMP_RASC_TRACKMAKER");

            if (classeDestino == null)
            {
                return;
            }

            FeicaoAdapter adpt = new FeicaoAdapter(classeDestino);

            if (!adpt.EhTransformavel(classeDestino, relatorio))
            {
                relatorio.Add("Arquivo " + shapeName + " desconsiderado por causa das observações acima");
                return;
            }

            LeitorFeicao leitorFeicao = fonte.ObterLeitorFeicao(shapeName);
            OperadorFeicaoOracleSpatial escritorFeicao = (OperadorFeicaoOracleSpatial)destino.ObterOperadorFeicao("TMP_RASC_TRACKMAKER");

            if (leitorFeicao == null)
            {
                return;
            }
            if (escritorFeicao == null)
            {
                return;
            }

            adpt.Adaptadores["PROJETO"].Origem = TipoOrigem.Manual;
            adpt.Adaptadores["PROJETO"].Valor  = Project.Id;

            int cont = 0;

            try
            {
                while (true)
                {
                    try
                    {
                        if (!leitorFeicao.Ler())
                        {
                            return;
                        }

                        cont++;

                        if (leitorFeicao.Atual.Atributos.IndiceDe("NOME") >= 0)
                        {
                            Atributo atributo = leitorFeicao.Atual.Atributos["NOME"];
                            leitorFeicao.Atual.Atributos.Clear();
                            leitorFeicao.Atual.Atributos.Adicionar(atributo);
                        }
                        else if (leitorFeicao.Atual.Atributos.IndiceDe("NAME") >= 0)
                        {
                            Atributo atributo = leitorFeicao.Atual.Atributos["NAME"];
                            atributo.Nome = "NOME";
                            leitorFeicao.Atual.Atributos.Clear();
                            leitorFeicao.Atual.Atributos.Adicionar(atributo);
                        }

                        Feicao otherFeicao = adpt.Transformar(leitorFeicao.Atual);

                        escritorFeicao.Inserir(otherFeicao);
                    }
                    catch
                    {
                        relatorio.Add(String.Format("A geometria {0} da feição {1} é inválida ou nula, deve ser redesenhada ou removida.", cont, shapeName));
                    }
                }
            }
            catch (TecnoGeoException exc)
            {
                throw new Exception(string.Format("Erro ao transportar geometria {0}/{1} da feição {2}. Erro subjacente era: {3}", cont, Project.Id, shapeName, exc.Message));
            }
            finally
            {
                escritorFeicao.Fechar();
                leitorFeicao.Fechar();
            }
        }
コード例 #9
0
 public NotificationResult Atualizar(Atributo entidade)
 {
     return(_atributoServico.Atualizar(entidade));
 }
コード例 #10
0
        private void where (int v, string[] c)
        {
            if (c.Contains("WHERE"))// si hay un where
            {
                v += 2;
                do
                {
                    v++;
                    //No encuentra el atributo coorrecto
                    Atributo atri  = atributos.Find(o => o.sNombre.CompareTo(c[v]) != 0);//tablaOut.Atrib.Find(o => o.sNombre.Contains(c[v]));
                    int      index = atributos.IndexOf(atri);
                    v++;
                    string op = c[v];
                    v++;
                    string com = c[v];
                    for (int i = 0; error == "" && i < tablaOut.Registros.Count; i++)
                    {
                        List <string> r = tablaOut.Registros[i];
                        switch (op)
                        {
                        case ">":
                            if (Convert.ToInt32(com) >= Convert.ToInt32(r[index + 1]))
                            {
                                tablaOut.Registros.Remove(r);
                                i--;
                            }
                            break;

                        case "<":
                            if (Convert.ToInt32(com) <= Convert.ToInt32(r[index + 1]))
                            {
                                tablaOut.Registros.Remove(r);
                                i--;
                            }
                            break;

                        case "=":
                            if (com != r[index + 1])
                            {
                                tablaOut.Registros.Remove(r);
                                i--;
                            }
                            break;

                        case "<>":
                            if (com == r[index + 1])
                            {
                                tablaOut.Registros.Remove(r);
                                i--;
                            }
                            break;

                        case "<=":
                            if (Convert.ToInt32(com) < Convert.ToInt32(r[index + 1]))
                            {
                                tablaOut.Registros.Remove(r);
                                i--;
                            }
                            break;

                        case ">=":
                            if (Convert.ToInt32(com) > Convert.ToInt32(r[index + 1]))
                            {
                                tablaOut.Registros.Remove(r);
                                i--;
                            }
                            break;

                        default:
                            error += "Error: Sintaxis";
                            break;
                        }
                    }
                    //v++;
                } while (v + 3 < c.Length);
            }
        }
コード例 #11
0
        /*
         * Metodo de la implementacion
         * @ts tabla de simbolos global
         * @user usuario que ejecuta la accion
         * @baseD base de datos donde estamos ejecutando todo
         * @mensajes linkedlist con la salida deseada
         */
        public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
        {
            Mensaje ms  = new Mensaje();
            object  res = ts.getValor(id);

            if (!res.Equals("none"))
            {
                if (res.GetType() == typeof(TypeCursor))
                {
                    TypeCursor tabla = (TypeCursor)res;
                    if (tabla.tabla != null)
                    {
                        generarIdentificador(tabla.tabla);
                        if (tabla.tabla.columnas.Count() == parametros.Count())
                        {
                            string identificadorParametros = generarIdentificadorDeclaracion();
                            if (identificadorParametros.Equals(identificador))
                            {
                                foreach (Data data in tabla.tabla.datos)
                                {
                                    TablaDeSimbolos newAmbito = new TablaDeSimbolos();
                                    foreach (Simbolo s in ambito.tablaPadre)
                                    {
                                        newAmbito.AddLast(s);
                                    }
                                    //-------------------------------------- ASIGNARLE A LOS PARAMETROS LOS VALORES DE LA CONSULTA ----------------------------
                                    for (int i = 0; i < parametros.Count(); i++)
                                    {
                                        Declaracion d = (Declaracion)parametros.ElementAt(i);
                                        d.parametro = true;
                                        object rd = d.ejecutar(newAmbito, ambito, tsT);
                                        if (rd == null)
                                        {
                                            return(null);
                                        }
                                        Atributo atributo = data.valores.ElementAt(i);
                                        newAmbito.setValor(d.id, atributo.valor);
                                    }
                                    //---------------------------------------- EJECUTAR INSTRUCCIONES DENTRO DEL FOREACH -----------------------------------------
                                    foreach (InstruccionCQL i in cuerpo)
                                    {
                                        object resultado = i.ejecutar(newAmbito, ambito, tsT);
                                        if (resultado == null)
                                        {
                                            return(null);
                                        }
                                        else if (resultado.GetType() == typeof(Retorno))
                                        {
                                            return((Retorno)resultado);
                                        }
                                        else if (i.GetType() == typeof(Continue) || resultado.GetType() == typeof(Continue))
                                        {
                                            break;
                                        }
                                    }
                                }
                                return("");
                            }
                            else
                            {
                                ambito.mensajes.AddLast(ms.error("No coinciden el tipo de parametros con el tipo de columnas", l, c, "Semantico"));
                            }
                        }
                        else
                        {
                            ambito.mensajes.AddLast(ms.error("No coincide la cantidad de parametros con la cantidad de columnas", l, c, "Semantico"));
                        }
                    }
                    else
                    {
                        ambito.mensajes.AddLast(ms.error("El cursor: " + id + " no ha sido abierto", l, c, "Semantico"));
                    }
                }
                else
                {
                    ambito.mensajes.AddLast(ms.error("La variable tiene que ser de tipo Cursor  no se reconoce: " + res, l, c, "Semantico"));
                }
            }
            else
            {
                ambito.mensajes.AddLast(ms.error("La variable : " + id + " no existe en este ambito", l, c, "Semantico"));
            }
            return(null);
        }
コード例 #12
0
 public void CrearAtributoVacio()
 {
     var nuevoAtributo = new Atributo(null, 0);
 }
コード例 #13
0
 public indAtrib(int i, Atributo a)
 {
     this.i = i;
     this.a = a ?? throw new ArgumentNullException(nameof(a));
 }
コード例 #14
0
        public object analizar(ParseTreeNode raiz, LinkedList <string> mensajes)
        {
            if (raiz != null)
            {
                string etiqueta = raiz.Term.Name.ToLower();
                int    l        = 0;
                int    c        = 0;
                switch (etiqueta)
                {
                case "inobjetos":
                    ParseTreeNode hijo;
                    if (raiz.ChildNodes.Count() == 5)
                    {
                        analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        hijo = raiz.ChildNodes.ElementAt(3);
                    }
                    else
                    {
                        hijo = raiz.ChildNodes.ElementAt(1);
                    }
                    object res = analizar(hijo, mensajes);
                    if (res != null)
                    {
                        l = raiz.ChildNodes.ElementAt(2).Token.Location.Line;
                        c = raiz.ChildNodes.ElementAt(2).Token.Location.Column;
                        if (res.GetType() == typeof(LinkedList <Atributo>))
                        {
                            LinkedList <Atributo> temp = (LinkedList <Atributo>)res;
                            Atributo atri     = getValor("name", temp);
                            string   nombreDB = "";
                            Objeto   info;
                            if (atri == null)
                            {
                                mensajes.AddLast("Se necesita un nombre para la base de datos Linea: " + l + " Columna: " + c);
                                return(null);
                            }
                            nombreDB = atri.valor.ToString();
                            atri     = getValor("data", temp);
                            if (atri == null)
                            {
                                mensajes.AddLast("Se necesita data para la base de datos Linea: " + l + " Columna: " + c);
                                return(null);
                            }
                            info = (Objeto)atri.valor;
                            info = fixData(info);
                            TablaBaseDeDatos.global.AddLast(new BaseDeDatos(nombreDB, info));
                            return("");
                        }
                    }
                    break;



                case "objetos":
                    LinkedList <Atributo> listaAtributos = new LinkedList <Atributo>();
                    object resultado;
                    if (raiz.ChildNodes.Count() == 3)
                    {
                        listaAtributos = (LinkedList <Atributo>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        resultado      = analizar(raiz.ChildNodes.ElementAt(2), mensajes);
                    }
                    else
                    {
                        resultado = analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                    }
                    if (resultado != null)
                    {
                        listaAtributos.AddLast((Atributo)resultado);
                    }

                    return(listaAtributos);



                case "objeto":
                    string key = raiz.ChildNodes.ElementAt(0).Token.Text.ToLower().TrimEnd('\"').TrimStart('\"').TrimEnd().TrimStart();
                    l = raiz.ChildNodes.ElementAt(0).Token.Location.Line;
                    c = raiz.ChildNodes.ElementAt(0).Token.Location.Column;
                    if (key.Equals("name"))
                    {
                        string name = raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(0).Token.Text.ToLower();
                        name = name.TrimStart('\"').TrimEnd('\"').TrimEnd().TrimStart();
                        return(new Atributo("name", name, ""));
                    }
                    else if (key.Equals("data"))
                    {
                        AnalizarObject analisis = new AnalizarObject();
                        object         resData  = analisis.analizar(raiz.ChildNodes.ElementAt(2), mensajes);
                        if (resData != null)
                        {
                            return(new Atributo("data", resData, ""));
                        }
                        mensajes.AddLast("LA DATA DE BASES DE DATOS necesita tablas,procedures y USER TYPES Linea : " + l + " Columna:  " + c);
                    }
                    else
                    {
                        mensajes.AddLast("No se reconoce el atributo para una base de datos: " + key + " Linea: " + l + " Columna: " + c);
                    }
                    break;
                }
            }
            return(null);
        }
コード例 #15
0
ファイル: GetDatos.cs プロジェクト: miguee90/DataBase
 /// <summary>
 /// Constructor para ?
 /// </summary>
 /// <param name="atri"></param>
 /// <param name="dicc"></param>
 /// <param name="arch"></param>
 /// <param name="dato"></param>
 /// <param name="mod"></param>
 public GetDatos(Atributo atri, Diccionario dicc, Archivo arch,string dato,bool mod)
 {
     InitializeComponent();
     atributo = atri;
     diccionario = dicc;
     archivo = arch;
     noSecu = true;
     modificando = false;
     cambioPrim = false;
     viejo = dato;
     modificando = mod;
     /*
     textCaptura.Text = dato;
     groupCaptura.Text = atributo.Nombre + "(" + atributo.Tipo + ")";
     if (atributo.TClave == 2)
     {
         textCaptura.Visible = false;
         comboExternas.Visible = true;
         /*Llena el combo con los datos de clave primaria
         if (!llenaComboIndexada(atributo.ApuntaPrim))
         {
             MessageBox.Show("Error aun no existen datos para llenar la clave externa", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
             dato = "error";
             this.Close();
         }
     }*/
 }
コード例 #16
0
ファイル: Form1.cs プロジェクト: miguee90/DataBase
        private void buttonSave_Click(object sender, EventArgs e)
        {
            string primEnt = "";
            bool fueError = false;
            Atributo atr;

            if (modA == true)
                diccionario.eliminaAtributo(groupAtriubuto.Text, textNomA.Text);

            if (textNomA.Text == string.Empty || comboTipo.Text == string.Empty
                || (radioPrimaria.Checked == false &&
                radioExterna.Checked == false && radioNinguna.Checked == false))
            {
                MessageBox.Show("Llena todos los campos necesarios", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {
                buttonModA.Enabled = true;
                buttonDelA.Enabled = true;

                if (getRadioClv() == 2 && comboEntidad.Text==string.Empty)
                {
                    fueError = true;
                    MessageBox.Show("Enlaza a la entidad con clave primaria", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                else if (getRadioClv() == 2)
                {
                    primEnt = comboEntidad.Text;
                }
                //Area de insercion de datos
                if(diccionario.buscaAtributoRepetido(groupAtriubuto.Text,textNomA.Text))
                {
                    MessageBox.Show("Atributo repetido", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                else
                {
                    if (getRadioClv() == 1)
                    {
                        //Buscar que la entidad no tenga mas claves primarias
                        if (diccionario.buscaPrimarias(groupAtriubuto.Text))
                        {
                            MessageBox.Show("Ya existe una clave primaria en esta entidad", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            fueError = true;
                        }
                    }

                    if (fueError == false)
                    {
                        if (comboTipo.Text == "string")
                        {
                            //Se crea el objeto Atributo
                            atr = new Atributo(textNomA.Text, comboTipo.Text, (int)numericUpDown1.Value,
                                getRadioClv(), diccionario.getDirEnt(groupAtriubuto.Text), (long)-1, (long)-1, primEnt);
                        }
                        else if (comboTipo.Text == "char")
                        {
                            //Se crea el objeto Atributo
                            atr = new Atributo(textNomA.Text, comboTipo.Text, (int)1,
                                getRadioClv(), diccionario.getDirEnt(groupAtriubuto.Text), (long)-1, (long)-1, primEnt);
                        }
                        else if(comboTipo.Text=="int")
                        {
                            //Se crea el objeto Atributo
                            atr = new Atributo(textNomA.Text, comboTipo.Text, (int)4,
                                getRadioClv(), diccionario.getDirEnt(groupAtriubuto.Text), (long)-1, (long)-1, primEnt);
                        }
                        else
                        {
                            //Se crea el objeto Atributo
                            atr = new Atributo(textNomA.Text, comboTipo.Text, (int)8,
                                getRadioClv(), diccionario.getDirEnt(groupAtriubuto.Text), (long)-1, (long)-1, primEnt);
                        }
                        //se inserta en el diccionario
                        diccionario.insertaAtributo(atr, groupAtriubuto.Text);
                        //actualiza el datagrd
                        llenaDataA();
                        llenaDataE();
                    }
                }
            }
            //Limpia los campos
            limpiaCamposA();
        }
コード例 #17
0
        private List <Atributo> generarAtributos(ParseTreeNode nodoAtributo)
        {
            List <Atributo> lista = new List <Atributo>();
            Atributo        nuevo;
            int             noHijos = nodoAtributo.ChildNodes.Count;
            string          tipo, nombre, visibilidad;


            if (noHijos == 3 && nodoAtributo.ChildNodes[2].Term.Name.Equals(Constantes.instancia, StringComparison.OrdinalIgnoreCase))
            {
                ////TIPO + identificador + ToTerm("=") + INSTANCIA + ";"
                visibilidad = Constantes.publico;
                tipo        = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                nombre      = nodoAtributo.ChildNodes[1].Token.ValueString;

                nuevo = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
                nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[2]);
                lista.Add(nuevo);
            }

            else if (noHijos == 4 && nodoAtributo.ChildNodes[3].Term.Name.Equals(Constantes.instancia, StringComparison.OrdinalIgnoreCase))
            {//VISIBILIDAD + TIPO + identificador + ToTerm("=") + INSTANCIA
                visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                tipo        = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
                nombre      = nodoAtributo.ChildNodes[2].Token.ValueString;
                nuevo       = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
                nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[3]);
                lista.Add(nuevo);
            }
            else if (noHijos == 5)
            {//arreglo con filas declaradas y visibilidad
                // VISIBILIDAD + TIPO + identificador + LPOSICIONES + ToTerm("=") + "{" + LFILAS + "}" + ";"
                visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                tipo        = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
                nombre      = nodoAtributo.ChildNodes[2].Token.ValueString;
                int             noPosiciones           = nodoAtributo.ChildNodes[3].ChildNodes.Count;
                ParseTreeNode[] expresionesDimensiones = getExpresionesArreglo(nodoAtributo.ChildNodes[3]);
                if (noPosiciones == expresionesDimensiones.Length && noPosiciones == nodoAtributo.ChildNodes[4].ChildNodes.Count)
                {//si se puede crear el arreglo
                    nuevo = new Atributo(visibilidad, nombre, tipo, Constantes.ARREGLO, noPosiciones, expresionesDimensiones);
                    nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[4]);
                    lista.Add(nuevo);
                }
                else
                {//error semantico
                    ErrorA err = new ErrorA(Constantes.errorSemantico, "No coinciden numero de dimensiones", nodoAtributo.Token);
                    Form1.errores.addError(err);
                }
            }
            else if (noHijos == 4)
            {
                if (nodoAtributo.ChildNodes[0].Term.Name.Equals(Constantes.tipo, StringComparison.OrdinalIgnoreCase))
                {
                    // TIPO + identificador + LPOSICIONES + ToTerm("=") + "{" + LFILAS + "}" + ";";

                    visibilidad = Constantes.publico;
                    tipo        = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                    nombre      = nodoAtributo.ChildNodes[1].Token.ValueString;
                    int             noPosiciones           = nodoAtributo.ChildNodes[3].ChildNodes.Count;
                    ParseTreeNode[] expresionesDimensiones = getExpresionesArreglo(nodoAtributo.ChildNodes[2]);
                    int             noFilasExpresion       = nodoAtributo.ChildNodes[3].ChildNodes.Count;
                    if (expresionesDimensiones.Length == noPosiciones && noPosiciones == noFilasExpresion)
                    {
                        nuevo = new Atributo(visibilidad, nombre, tipo, Constantes.ARREGLO, noPosiciones, expresionesDimensiones);
                        nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[3]);
                        lista.Add(nuevo);
                    }
                    else
                    {
                        ErrorA err = new ErrorA(Constantes.errorSemantico, "No coinciden numero de dimensiones", nodoAtributo.Token);
                        Form1.errores.addError(err);
                    }
                }
                else if (nodoAtributo.ChildNodes[3].Term.Name.Equals(Constantes.lposiciones, StringComparison.OrdinalIgnoreCase))
                {
                    // VISIBILIDAD + TIPO + identificador + LPOSICIONES + ToTerm(";")
                    visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                    tipo        = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
                    nombre      = nodoAtributo.ChildNodes[2].Token.ValueString;
                    int             noPosiciones           = nodoAtributo.ChildNodes[3].ChildNodes.Count;
                    ParseTreeNode[] expresionesDimensiones = getExpresionesArreglo(nodoAtributo.ChildNodes[3]);
                    if (noPosiciones == expresionesDimensiones.Length)
                    {//si se puede crear el arreglo
                        nuevo = new Atributo(visibilidad, nombre, tipo, Constantes.ARREGLO, noPosiciones, expresionesDimensiones);
                        lista.Add(nuevo);
                    }
                    else
                    {//error semantico
                        ErrorA err = new ErrorA(Constantes.errorSemantico, "No coinciden numero de dimensiones", nodoAtributo.Token);
                        Form1.errores.addError(err);
                    }
                }
                else
                {
                    /*VISIBILIDAD + TIPO + identificador + ToTerm("=") + EXPRESION + ToTerm(";") //1
                     */
                    visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                    tipo        = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
                    nombre      = nodoAtributo.ChildNodes[2].Token.ValueString;
                    nuevo       = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
                    nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[3]);
                    lista.Add(nuevo);
                }
            }//fin de ==4
            else if (noHijos == 3)
            {
                if (nodoAtributo.ChildNodes[0].Term.Name.Equals(Constantes.visibilidad, StringComparison.OrdinalIgnoreCase))
                {
                    //ATRIBUTO.Rule = VISIBILIDAD + TIPO + L_IDS + ToTerm(";")
                    visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                    tipo        = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
                    foreach (ParseTreeNode item in nodoAtributo.ChildNodes[2].ChildNodes)
                    {
                        nombre = item.Token.Value.ToString();
                        nuevo  = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
                        lista.Add(nuevo);
                    }
                }
                else if (nodoAtributo.ChildNodes[2].Term.Name.Equals(Constantes.lposiciones, StringComparison.OrdinalIgnoreCase))
                {
                    //| TIPO + identificador + LPOSICIONES + ToTerm(";")
                    visibilidad = Constantes.publico;
                    nombre      = nodoAtributo.ChildNodes[1].Token.ValueString;
                    tipo        = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                    int             noPosiciones           = nodoAtributo.ChildNodes[2].ChildNodes.Count;
                    ParseTreeNode[] expresionesDimensiones = getExpresionesArreglo(nodoAtributo.ChildNodes[2]);
                    if (noPosiciones == expresionesDimensiones.Length)
                    {//si se puede crear el arreglo
                        nuevo = new Atributo(visibilidad, nombre, tipo, Constantes.ARREGLO, noPosiciones, expresionesDimensiones);
                        lista.Add(nuevo);
                    }
                    else
                    {//error semantico
                        ErrorA err = new ErrorA(Constantes.errorSemantico, "No coinciden numero de dimensiones", nodoAtributo.Token);
                        Form1.errores.addError(err);
                    }
                }
                else
                {
                    //| TIPO + identificador + ToTerm("=") + EXPRESION + ToTerm(";") //1
                    visibilidad = Constantes.publico;
                    nombre      = nodoAtributo.ChildNodes[1].Token.ValueString;
                    tipo        = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                    nuevo       = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
                    nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[2]);
                    lista.Add(nuevo);
                }
            }
            else if (noHijos == 2)
            {
                //TIPO + L_IDS + ToTerm(";")

                visibilidad = Constantes.publico;
                tipo        = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
                foreach (ParseTreeNode item in nodoAtributo.ChildNodes[1].ChildNodes)
                {
                    nombre = item.Token.Value.ToString();
                    nuevo  = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
                    lista.Add(nuevo);
                }
            }

            return(lista);
        }
コード例 #18
0
 private void descerAtributo(Atributo atributo)
 {
     if(validarAtributo(atributo, Acao.descer)) {
         diminuirAtributo(atributo);
     }
     else {
         jogador.SendMessage( "Você não pode diminuir este atributo.");
     }
 }
コード例 #19
0
        public object analizar(ParseTreeNode raiz, LinkedList <string> mensajes)
        {
            if (raiz != null)
            {
                string etiqueta = raiz.Term.Name.ToLower();
                int    l        = 0;
                int    c        = 0;
                switch (etiqueta)
                {
                case "tipo":
                    if (raiz.ChildNodes.Count() == 2)
                    {
                        return(new LinkedList <Attrs>());
                    }
                    else if (raiz.ChildNodes.Count() == 3)
                    {
                        return(analizar(raiz.ChildNodes.ElementAt(1), mensajes));
                    }
                    mensajes.AddLast("No se reconoce el tipo de objeto para Attrs");
                    break;



                case "lista":
                    LinkedList <Attrs> lista = new LinkedList <Attrs>();
                    ParseTreeNode      hijo;
                    if (raiz.ChildNodes.Count() == 3)
                    {
                        lista = (LinkedList <Attrs>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);

                        hijo = raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(1);
                        l    = raiz.ChildNodes.ElementAt(1).Token.Location.Line;
                        c    = raiz.ChildNodes.ElementAt(1).Token.Location.Column;
                    }
                    else
                    {
                        //-------------------------------- IMPORTAR ------------------------------------------
                        if (raiz.ChildNodes.ElementAt(0).ChildNodes.Count() == 1)
                        {
                            hijo = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0);
                            string direccion = hijo.Token.Text.TrimStart('$').TrimStart('{').TrimEnd('}').TrimEnd('}').TrimEnd('$').TrimEnd('}');
                            object nuevoNodo = analizarImport(direccion, mensajes);
                            if (nuevoNodo != null)
                            {
                                return(analizar((ParseTreeNode)nuevoNodo, mensajes));
                            }
                            else
                            {
                                return(null);
                            }
                        }
                        l    = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0).Token.Location.Line;
                        c    = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0).Token.Location.Column;
                        hijo = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(1);
                    }
                    LinkedList <Atributo> resultado = (LinkedList <Atributo>)analizar(hijo, mensajes);

                    if (resultado != null)
                    {
                        Atributo temp = buscarAtributo(resultado, "name");
                        if (temp == null)
                        {
                            mensajes.AddLast("Los attr necesitan un atributo name, Linea: " + l + " Columna: " + c);
                            return(lista);
                        }
                        string name = temp.valor.ToString().ToLower().TrimEnd().TrimStart();
                        temp = buscarAtributo(resultado, "type");
                        if (temp == null)
                        {
                            mensajes.AddLast("Los attr necesitan un atributo type, Linea: " + l + " Columna: " + c);
                            return(lista);
                        }
                        string type = temp.valor.ToString().ToLower().TrimEnd().TrimStart();
                        lista.AddLast(new Attrs(name, type));
                    }
                    return(lista);


                case "inobjetos":
                    LinkedList <Attrs> lista2 = new LinkedList <Attrs>();
                    ParseTreeNode      hijo2;
                    if (raiz.ChildNodes.Count() == 5)
                    {
                        lista2 = (LinkedList <Attrs>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);

                        hijo2 = raiz.ChildNodes.ElementAt(3);
                        l     = raiz.ChildNodes.ElementAt(1).Token.Location.Line;
                        c     = raiz.ChildNodes.ElementAt(1).Token.Location.Column;
                    }
                    else
                    {
                        l     = raiz.ChildNodes.ElementAt(0).Token.Location.Line;
                        c     = raiz.ChildNodes.ElementAt(0).Token.Location.Column;
                        hijo2 = raiz.ChildNodes.ElementAt(1);
                    }
                    LinkedList <Atributo> resultado2 = (LinkedList <Atributo>)analizar(hijo2, mensajes);

                    if (resultado2 != null)
                    {
                        Atributo temp = buscarAtributo(resultado2, "name");
                        if (temp == null)
                        {
                            mensajes.AddLast("Los attr necesitan un atributo name, Linea: " + l + " Columna: " + c);
                            return(lista2);
                        }
                        string name = temp.valor.ToString().ToLower().TrimEnd().TrimStart();
                        temp = buscarAtributo(resultado2, "type");
                        if (temp == null)
                        {
                            mensajes.AddLast("Los attr necesitan un atributo type, Linea: " + l + " Columna: " + c);
                            return(lista2);
                        }
                        string type = temp.valor.ToString().ToLower().TrimEnd().TrimStart();
                        lista2.AddLast(new Attrs(name, type));
                    }
                    return(lista2);



                case "objetos":
                    LinkedList <Atributo> atributos = new LinkedList <Atributo>();
                    object resultadoA;
                    if (raiz.ChildNodes.Count() == 3)
                    {
                        atributos  = (LinkedList <Atributo>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        resultadoA = analizar(raiz.ChildNodes.ElementAt(2), mensajes);
                    }
                    else
                    {
                        resultadoA = analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                    }
                    if (resultadoA != null)
                    {
                        atributos.AddLast((Atributo)resultadoA);
                    }

                    return(atributos);



                case "objeto":
                    string key = raiz.ChildNodes.ElementAt(0).Token.Text.ToLower().TrimStart('\"').TrimEnd('\"').TrimEnd().TrimStart();
                    l = raiz.ChildNodes.ElementAt(0).Token.Location.Line;
                    c = raiz.ChildNodes.ElementAt(0).Token.Location.Column;
                    if (key.Equals("name"))
                    {
                        string valor = raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(0).Token.Text;
                        valor = valor.ToLower().TrimStart('\"').TrimEnd('\"').TrimEnd().TrimStart();
                        return(new Atributo("name", valor, ""));
                    }
                    else if (key.Equals("type"))
                    {
                        string valor = raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(0).Token.Text;
                        valor = valor.ToLower().TrimStart('\"').TrimEnd('\"').TrimEnd().TrimStart();
                        return(new Atributo("type", valor, ""));
                    }
                    mensajes.AddLast("No se reconoce este atributo: " + key + " Linea :" + l + "Columna: " + c);
                    break;
                }
            }
            return(null);
        }
コード例 #20
0
 private void diminuirAtributo(Atributo atributo)
 {
     if(atributo == Atributo.forca) {
         forca -= 5;
     }
     else if(atributo == Atributo.destreza) {
         destreza -= 5;
     }
     else {
         inteligencia -= 5;
     }
 }
コード例 #21
0
ファイル: Organizacion.cs プロジェクト: miguee90/DataBase
 /// <summary>
 /// Inserta el dato de acuerdo a su tipo en el archivo
 /// </summary>
 /// <param name="atr"></param>
 /// <param name="value"></param>
 private void insertaAtDato(Atributo atr, string value)
 {
     switch (atr.Tipo)
     {
         case "int":
             //escribe entero en archivo
             archivo.escribeInt(Convert.ToInt32(value));
             break;
         case "float":
             archivo.escribeFloat(Convert.ToDouble(value));
             break;
         case "char":
             archivo.escribeChar(Convert.ToChar(value));
             break;
         case "string":
             archivo.escribeString(value,atr.Tam);
             break;
     }
 }
コード例 #22
0
 private void somarAtributo(Atributo atributo)
 {
     if(atributo == Atributo.forca) {
         forca += 5;
     }
     else if(atributo == Atributo.destreza) {
         destreza += 5;
     }
     else {
         inteligencia += 5;
     }
 }
コード例 #23
0
 public NotificationResult Salvar(Atributo entidade)
 {
     throw new NotImplementedException();
 }
コード例 #24
0
 private void subirAtributo(Atributo atributo)
 {
     if(validarAtributo(atributo, Acao.subir)) {
         somarAtributo(atributo);
     }
     else {
         jogador.SendMessage( "Você não pode aumentar este atributo.");
     }
 }
コード例 #25
0
 public NotificationResult Salvar(Atributo entidade)
 {
     return(_atributoServico.Salvar(entidade));
 }
コード例 #26
0
        private bool validarAtributo(Atributo atributo, Acao acao)
        {
            //valida o total de pontos
            if(acao.Equals(Acao.subir)) {
                int totalParaGastar = (totalPontos - (forca + destreza + inteligencia));
                if(totalParaGastar == 0) {
                    return false;
                }
            }

            //força
            if(atributo == Atributo.forca) {

                if(acao == Acao.subir) {
                    if(forca >= maxAtributo) {
                        return false;
                    }
                    return true;
                }
                else {
                    if(forca <= minimoAtributo) {
                        return false;
                    }
                    return true;
                }
            }

            //destreza
            else if(atributo == Atributo.destreza) {

                if(acao == Acao.subir) {
                    if(destreza >= maxAtributo) {
                        return false;
                    }
                    return true;
                }
                else {
                    if(destreza <= minimoAtributo) {
                        return false;
                    }
                    return true;
                }
            }

            //inteligencia
            else {

                if(acao == Acao.subir) {
                    if(inteligencia >= maxAtributo) {
                        return false;
                    }
                    return true;
                }
                else {
                    if(inteligencia <= minimoAtributo) {
                        return false;
                    }
                    return true;
                }
            }
        }
コード例 #27
0
        /// <summary>
        /// Realiza assinatura do XML
        /// </summary>
        /// <param name="XMLString">String do XML</param>
        /// <param name="tagId">Tag que tera o campo ID a ser usado na assinatura</param>
        /// <param name="assinaCorpoXML">Indica se o no root do XML será assinado</param>
        /// <returns>XML assinado</returns>
        public string AssinarXML(string XMLString, string tagId, bool assinaCorpoXML, ParametrosObtemFatura parametros)
        {
            X509Certificate2         X509Cert = new X509Certificate2();
            RSACryptoServiceProvider RSACert  = new RSACryptoServiceProvider();

            if (parametros.TipoCert == TipoCert.A3)
            {
                try {
                    RSACert = ObtemRsaCertificado(parametros.TipoProvider, parametros.NomeProvider);
                } catch (Exception) {
                    throw new Exception("Nenhum certificado encontrado");
                }
            }
            else
            {
                try {
                    // Obtem o certificado digital da máquina do usuário
                    X509Cert = ObtemCertificado();
                } catch (Exception) {
                    throw new Exception("Nenhum certificado encontrado");
                }
            }

            // Cria Documento XML
            XmlDocument Documento = new XmlDocument();

            Documento.PreserveWhitespace = false;

            // XML a ser carregado
            Documento.LoadXml(XMLString);

            // Cria objeto XML a ser assinado
            SignedXml signedXml = new SignedXml(Documento);

            // Adicionar a chave privada ao XML
            signedXml.SigningKey = X509Cert.PrivateKey;

            // Obtem a tag que ira fornecer os dados para a assinatura "InfRps"
            XmlNodeList _Uri = Documento.GetElementsByTagName(tagId);

            foreach (XmlElement Atributo in _Uri)
            {
                // ID que ira ser a referencia para o calculo da assinatura
                string    id        = Atributo.Attributes.GetNamedItem("Id").Value;
                Reference reference = new Reference("#" + id);

                reference.AddTransform(new XmlDsigEnvelopedSignatureTransform());
                reference.AddTransform(new XmlDsigC14NTransform());

                // Adiciona a referencia ao objeto SignedXml
                signedXml.AddReference(reference);

                KeyInfo keyInfo = new KeyInfo();

                // Carrega os dados do Certificado a ser adicionado na assinatura
                keyInfo.AddClause(new KeyInfoX509Data(X509Cert));

                // Adicionar os dados do certificado
                signedXml.KeyInfo = keyInfo;

                signedXml.ComputeSignature();

                XmlElement xmlSignature  = Documento.CreateElement("Signature", "http://www.w3.org/2000/09/xmldsig#");
                XmlElement xmlSignedInfo = signedXml.SignedInfo.GetXml();
                XmlElement xmlKeyInfo    = signedXml.KeyInfo.GetXml();

                XmlElement xmlSignatureValue = Documento.CreateElement("SignatureValue", xmlSignature.NamespaceURI);
                string     signBase64        = Convert.ToBase64String(signedXml.Signature.SignatureValue);
                XmlText    text = Documento.CreateTextNode(signBase64);
                xmlSignatureValue.AppendChild(text);

                xmlSignature.AppendChild(Documento.ImportNode(xmlSignedInfo, true));
                xmlSignature.AppendChild(xmlSignatureValue);
                xmlSignature.AppendChild(Documento.ImportNode(xmlKeyInfo, true));

                Atributo.AppendChild(xmlSignature);
            }

            AssinarXML(ref Documento, parametros);
            return(FormatXML(Documento));
        }
コード例 #28
0
ファイル: AtributoController.cs プロジェクト: Gokinha/RPG
 public string Excluir(Atributo entidade)
 {
     return(atributo_Servico.Excluir(entidade));
 }
コード例 #29
0
        public ActionResult Editar(Guid?id, Guid?AtributoID, Guid?LLaveID)
        {
            //id PiezaID
            //atributoID
            //AtributoPiezaID || TablaID

            Pieza pieza = db.Piezas.Find(id);

            PartialViewResult _vista = null;


            if (id == null || AtributoID == null || LLaveID == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            Atributo att = db.Atributos.Find(AtributoID);

            if (att == null)
            {
                return(HttpNotFound());
            }

            if (att.TipoAtributo.EsGenerico)
            {
                AtributoPieza attPieza = db.AtributoPiezas.Find(LLaveID);

                if (att.TipoAtributo.EsLista)
                {
                    List <ListaValor> lista = new List <ListaValor>();
                    lista.Add(attPieza.ListaValor); //agregar valor por si no viene en los primeros 500
                    lista.AddRange(att.TipoAtributo.ListaValores.Where(a => a.Status && !String.IsNullOrWhiteSpace(a.Valor)).OrderBy(a => a.Valor).Take(100).ToList());


                    ViewBag.ListaValorID = new SelectList(lista, "ListaValorID", "Valor", attPieza.ListaValorID);

                    _vista = PartialView("_EditarGenericoLista", attPieza);
                }
                else
                {
                    _vista = PartialView("_EditarGenericoCampo", attPieza);
                }
            }
            else
            {
                switch (att.TipoAtributo.TablaSQL)
                {
                case "Autor":
                    List <Autor> listaAutores = new List <Autor>();
                    var          piezaAutor   = db.AutorPiezas.Find(id, LLaveID);

                    listaAutores.Add(piezaAutor.Autor);
                    listaAutores.AddRange(db.Autores.Where(a => a.Status).OrderBy(a => a.Nombre).Take(100).ToList());

                    ViewBag.AutorID = new SelectList(listaAutores.Select(a => new { Nombre = a.Nombre + " " + a.Apellido, a.AutorID }), "AutorID", "Nombre", piezaAutor.Autor.AutorID);

                    _vista = PartialView("~/Views/AutorPieza/_Editar.cshtml", piezaAutor);

                    break;

                case "Ubicacion":

                    List <Ubicacion> listaUbicaciones = new List <Ubicacion>();
                    listaUbicaciones.Add(pieza.Ubicacion);
                    listaUbicaciones.AddRange(db.Ubicaciones.Where(a => a.Status).OrderBy(a => a.Nombre).Take(100).ToList());
                    ViewBag.UbicacionID = new SelectList(listaUbicaciones, "UbicacionID", "Nombre", pieza.UbicacionID);

                    _vista = PartialView("~/Views/Pieza/_EditarUbicacion.cshtml", pieza);
                    break;

                case "TipoTecnica":
                    List <Tecnica> listaTecnicas = new List <Tecnica>();
                    var            piezaTecnica  = db.TecnicaPiezas.Find(id, LLaveID);

                    //Select TipoTecnica
                    var listaTipoTecnicas = db.TipoTecnicas.Where(a => a.TipoTecnicaID == piezaTecnica.TipoTecnicaID).OrderBy(a => a.Nombre).Select(a => new { Nombre = a.Nombre, a.TipoTecnicaID }).ToList();
                    ViewBag.TipoTecnicaID = new SelectList(listaTipoTecnicas, "TipoTecnicaID", "Nombre", piezaTecnica.TipoTecnicaID);

                    //Select Tecnica
                    listaTecnicas.Add(piezaTecnica.Tecnica);
                    listaTecnicas.AddRange(db.Tecnicas.Where(a => a.Status && a.TipoTecnicaID == piezaTecnica.TipoTecnicaID).OrderBy(a => a.Descripcion).Take(100).ToList());
                    ViewBag.TecnicaID = new SelectList(listaTecnicas.Select(a => new { Nombre = a.Descripcion, a.TecnicaID }), "TecnicaID", "Nombre", piezaTecnica.TecnicaID);

                    _vista = PartialView("~/Views/TecnicaPieza/_Editar.cshtml", piezaTecnica);
                    break;

                case "TipoMedida":
                    var medidaPieza = db.MedidaPiezas.Find(id, LLaveID);
                    ViewBag.NombreMedida = medidaPieza.TipoMedida.Nombre;
                    _vista = PartialView("~/Views/MedidaPieza/_Editar.cshtml", medidaPieza);
                    break;

                default:
                    //_vista = PartialView("_ErrorCampo");
                    break;
                }
            }


            ViewBag.EsMultipleValor = att.TipoAtributo.EsMultipleValor;
            ViewBag.ParametrosHTML  = att.TipoAtributo.HTMLParametros;
            ViewBag.TipoAtributoID  = att.TipoAtributo.TipoAtributoID;
            ViewBag.NombreAtt       = att.TipoAtributo.Nombre;
            ViewBag.id         = id;
            ViewBag.AtributoID = AtributoID;
            ViewBag.LLaveID    = LLaveID;

            switch (att.TipoAtributo.DatoCS)
            {
            case "double":
            case "Double":
            case "int":
            case "float":
            case "int32":
            case "int64":
            case "decimal": ViewBag.TipoInput = "number"; break;

            case "date": ViewBag.TipoInput = "date"; break;

            case "time": ViewBag.TipoInput = "time"; break;

            case "datetime": ViewBag.TipoInput = "datetime"; break;

            case "datetime-local": ViewBag.TipoInput = "datetime-local"; break;

            case "month": ViewBag.TipoInput = "month"; break;

            case "week": ViewBag.TipoInput = "week"; break;

            case "color": ViewBag.TipoInput = "color"; break;

            case "email": ViewBag.TipoInput = "email"; break;

            case "url": ViewBag.TipoInput = "url"; break;

            case "tel": ViewBag.TipoInput = "tel"; break;

            case "range": ViewBag.TipoInput = "range"; break;

            default: ViewBag.TipoInput = "text"; break;
            }


            return(_vista);
        }
コード例 #30
0
        /*
         * METODO QUE SE ENCARGARA DE VER EL TIPO DE OBJETO DE UNA TABLA
         * @param {atributos} lista de atributos del objeto
         * @param {mensajes} output
         * @return Table|Procedure|USER TYPE
         */
        private object tipoCQLTYPE(LinkedList <Atributo> atributos, LinkedList <string> mensajes)
        {
            int      l    = 0;
            int      c    = 0;
            Atributo resA = buscarAtributo(atributos, "cql-type");

            if (resA == null)
            {
                mensajes.AddLast("Se necesita un CQL-TYPE Linea: " + l + " Columna: " + c);
                return(null);
            }
            string cql_type = resA.valor.ToString();

            //--------------------------------------------- TABLAS ----------------------------------------------------------
            if (cql_type.Equals("table"))
            {
                resA = buscarAtributo(atributos, "name");
                if (resA == null)
                {
                    mensajes.AddLast("Se necesita un Nombre para la tabla Linea: " + l + " Columna: " + c);
                    return(null);
                }
                string name = resA.valor.ToString();

                resA = buscarAtributo(atributos, "columns");
                if (resA == null)
                {
                    mensajes.AddLast("Se necesitan Columnas para la tabla Linea: " + l + " Columna: " + c);
                    return(null);
                }
                LinkedList <Columna> columnas = (LinkedList <Columna>)resA.valor;

                resA = buscarAtributo(atributos, "data");
                if (resA == null)
                {
                    mensajes.AddLast("Se necesitan Data para la tabla Linea: " + l + " Columna: " + c);
                    return(null);
                }
                LinkedList <Data> data = (LinkedList <Data>)resA.valor;
                return(new Tabla(name, columnas, data));
            }

            // ----------------------------------------------- USER TYPES -----------------------------
            else if (cql_type.Equals("object"))
            {
                resA = buscarAtributo(atributos, "name");
                if (resA == null)
                {
                    mensajes.AddLast("Se necesita un Nombre para el User type Linea: " + l + " Columna: " + c);
                    return(null);
                }
                string name = resA.valor.ToString();

                resA = buscarAtributo(atributos, "attrs");
                if (resA == null)
                {
                    mensajes.AddLast("Se necesita un ATTRS para el User type Linea: " + l + " Columna: " + c);
                    return(null);
                }
                LinkedList <Attrs> attrs = (LinkedList <Attrs>)resA.valor;

                return(new User_Types(name, attrs));
            }

            //------------------------------------------------ PROCEDURE -------------------------------------------------
            else if (cql_type.Equals("procedure"))
            {
                resA = buscarAtributo(atributos, "name");
                if (resA == null)
                {
                    mensajes.AddLast("Se necesita un Nombre para el Procedure Linea: " + l + " Columna: " + c);
                    return(null);
                }
                string name = resA.valor.ToString();

                resA = buscarAtributo(atributos, "parameters");
                if (resA == null)
                {
                    mensajes.AddLast("Se necesita un Parameters para el PROCEDURE Linea: " + l + " Columna: " + c);
                    return(null);
                }
                LinkedList <listaParametros> parametros = new LinkedList <listaParametros>();
                LinkedList <listaParametros> retornos   = new LinkedList <listaParametros>();
                setearParemetrosINOUT(parametros, retornos, (LinkedList <Atributo>)resA.valor);

                resA = buscarAtributo(atributos, "instr");
                if (resA == null)
                {
                    mensajes.AddLast("Se necesita un Instr para el PROCEDURE Linea: " + l + " Columna: " + c);
                    return(null);
                }

                string codigo = resA.valor.ToString();

                SintacticoCQL sintactico        = new SintacticoCQL();
                object        respuestaAnalisis = sintactico.analizarProcedure(codigo, mensajes);
                if (respuestaAnalisis != null)
                {
                    return(new Procedures(name, codigo, getIdentificador(name, parametros), parametros, getIdentificador("", retornos), retornos, (LinkedList <InstruccionCQL>)respuestaAnalisis));
                }
                else
                {
                    mensajes.AddLast("Hubo un error en el analisis del INSR para el procedure: " + name);
                }
            }


            return(null);
        }
コード例 #31
0
 public void EditarAtributo(Atributo inputs)
 {
     _repo.EditarAtributo(inputs);
 }
コード例 #32
0
    public static string EditarGenerador(Dictionary <string, object> pClaseGenerador)
    {
        CConexion       ConexionBaseDatos = new CConexion();
        string          respuesta         = ConexionBaseDatos.ConectarBaseDatosSqlServer();
        CClaseGenerador ClaseGenerador    = new CClaseGenerador();

        ClaseGenerador.IdClaseGenerador = Convert.ToInt32(pClaseGenerador["IdClaseGenerador"]);
        ClaseGenerador.Clase            = Convert.ToString(pClaseGenerador["Clase"]);
        ClaseGenerador.Bloqueo          = Convert.ToBoolean(pClaseGenerador["Bloqueo"]);
        ClaseGenerador.ManejaBaja       = Convert.ToBoolean(pClaseGenerador["ManejaBaja"]);
        ClaseGenerador.Abreviatura      = Convert.ToString(pClaseGenerador["Abreviatura"]);
        List <CClaseAtributo> Atributos = new List <CClaseAtributo>();

        foreach (Dictionary <string, object> OAtributo in (Array)pClaseGenerador["Atributos"])
        {
            CClaseAtributo CClaseAtributo = new CClaseAtributo();
            CClaseAtributo.IdClaseAtributo  = Convert.ToInt32(OAtributo["IdClaseAtributo"]);
            CClaseAtributo.Atributo         = Convert.ToString(OAtributo["Atributo"]);
            CClaseAtributo.TipoAtributo     = Convert.ToString(OAtributo["TipoAtributo"]);
            CClaseAtributo.LlavePrimaria    = Convert.ToString(OAtributo["LlavePrimaria"]).ToLower().Trim();
            CClaseAtributo.Identidad        = Convert.ToString(OAtributo["Identidad"]).ToLower().Trim();
            CClaseAtributo.Longitud         = Convert.ToString(OAtributo["Longitud"]);
            CClaseAtributo.Decimales        = Convert.ToString(OAtributo["NumeroDecimales"]);
            CClaseAtributo.IdClaseGenerador = ClaseGenerador.IdClaseGenerador;
            Atributos.Add(CClaseAtributo);
        }

        string  validacion = ValidaClaseGenerador(ClaseGenerador, Atributos, ConexionBaseDatos);
        JObject o          = new JObject();

        o.Add(new JProperty("Error", 0));
        if (validacion == "")
        {
            JObject Modelo = new JObject();
            Modelo.Add(new JProperty("IdClaseGenerador", ClaseGenerador.IdClaseGenerador));
            ClaseGenerador.EditarTabla(ClaseGenerador, Atributos, Convert.ToString(pClaseGenerador["ClaseAnterior"]), ConexionBaseDatos);
            ClaseGenerador.EliminarStoredProcedures(ClaseGenerador, ConexionBaseDatos);

            if (ClaseGenerador.CrearStoredProcedures(ClaseGenerador, Atributos, ConexionBaseDatos) == "")
            {
                o["Error"] = 1;
                o.Add(new JProperty("Descripcion", "<span>*</span> Ocurrio un error al editar los stored procedures."));
            }

            if ((int)o["Error"] == 0)
            {
                ClaseGenerador.CrearClase(ClaseGenerador, Atributos, ConexionBaseDatos);
            }

            ClaseGenerador.Editar(ConexionBaseDatos);
            CClaseAtributo        ObtenerAtributos  = new CClaseAtributo();
            List <CClaseAtributo> AtributosActuales = new List <CClaseAtributo>();

            foreach (CClaseAtributo Atributo in ObtenerAtributos.LlenaObjetos_FiltroIdClaseGenerador(ClaseGenerador.IdClaseGenerador, ConexionBaseDatos))
            {
                AtributosActuales.Add(Atributo);
            }

            foreach (CClaseAtributo AtributoActual in AtributosActuales)
            {
                bool eliminar = true;
                foreach (CClaseAtributo Atributo in Atributos)
                {
                    if (AtributoActual.IdClaseAtributo == Atributo.IdClaseAtributo)
                    {
                        eliminar = false;
                    }

                    if (eliminar == false)
                    {
                        break;
                    }
                }

                if (eliminar == true)
                {
                    AtributoActual.Eliminar(ConexionBaseDatos);
                }
            }

            ClaseGenerador.Editar(ConexionBaseDatos);
            foreach (CClaseAtributo Atributo in Atributos)
            {
                if (Atributo.IdClaseAtributo == 0)
                {
                    Atributo.Agregar(ConexionBaseDatos);
                }
                else
                {
                    Atributo.Editar(ConexionBaseDatos);
                }
            }

            o.Add(new JProperty("Modelo", Modelo));
            ConexionBaseDatos.CerrarBaseDatosSqlServer();
        }
        else
        {
            o.Add(new JProperty("Error", 1));
            o.Add(new JProperty("Descripcion", validacion));
        }
        ConexionBaseDatos.CerrarBaseDatosSqlServer();
        return(o.ToString());
    }
コード例 #33
0
        public object analizar(ParseTreeNode raiz, LinkedList <string> mensajes)
        {
            if (raiz != null)
            {
                string etiqueta = raiz.Term.Name.ToLower();
                switch (etiqueta)
                {
                case "lista":
                    LinkedList <string> lista = new LinkedList <string>();
                    object res;
                    if (raiz.ChildNodes.Count() == 3)
                    {
                        lista = (LinkedList <string>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        l     = raiz.ChildNodes.ElementAt(1).Token.Location.Line;
                        c     = raiz.ChildNodes.ElementAt(1).Token.Location.Column;
                        res   = analizar(raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(1), mensajes);
                    }
                    else
                    {
                        //-------------------------------- IMPORTAR ------------------------------------------
                        if (raiz.ChildNodes.ElementAt(0).ChildNodes.Count() == 1)
                        {
                            ParseTreeNode hijo      = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0);
                            string        direccion = hijo.Token.Text.TrimStart('$').TrimStart('{').TrimEnd('}').TrimEnd('}').TrimEnd('$').TrimEnd('}');
                            object        nuevoNodo = analizarImport(direccion, mensajes);
                            if (nuevoNodo != null)
                            {
                                return(analizar((ParseTreeNode)nuevoNodo, mensajes));
                            }
                            else
                            {
                                return(null);
                            }
                        }
                        l   = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0).Token.Location.Line;
                        c   = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0).Token.Location.Column;
                        res = analizar(raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(1), mensajes);
                    }

                    if (res != null)
                    {
                        Atributo atributo = buscarAtributo((LinkedList <Atributo>)res, "name");
                        if (atributo == null)
                        {
                            mensajes.AddLast("Los permisos necesitan un nombre, Linea: " + l + " Columna: " + c);
                            return(lista);
                        }
                        lista.AddLast(atributo.valor.ToString());
                    }

                    return(lista);



                case "inobjetos":
                    LinkedList <string> lista2 = new LinkedList <string>();
                    object res2;
                    if (raiz.ChildNodes.Count() == 5)
                    {
                        lista2 = (LinkedList <string>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        l      = raiz.ChildNodes.ElementAt(1).Token.Location.Line;
                        c      = raiz.ChildNodes.ElementAt(1).Token.Location.Column;
                        res2   = analizar(raiz.ChildNodes.ElementAt(3), mensajes);
                    }
                    else
                    {
                        l    = raiz.ChildNodes.ElementAt(0).Token.Location.Line;
                        c    = raiz.ChildNodes.ElementAt(0).Token.Location.Column;
                        res2 = analizar(raiz.ChildNodes.ElementAt(1), mensajes);
                    }

                    if (res2 != null)
                    {
                        Atributo atributo = buscarAtributo((LinkedList <Atributo>)res2, "name");
                        if (atributo == null)
                        {
                            mensajes.AddLast("Los permisos necesitan un nombre, Linea: " + l + " Columna: " + c);
                            return(lista2);
                        }
                        lista2.AddLast(atributo.valor.ToString());
                    }

                    return(lista2);


                //-------------------------------------- objetos -------------------------------------------------------------------
                case "objetos":
                    LinkedList <Atributo> listaValores = new LinkedList <Atributo>();
                    object resO;
                    if (raiz.ChildNodes.Count() == 3)
                    {
                        listaValores = (LinkedList <Atributo>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        resO         = analizar(raiz.ChildNodes.ElementAt(2), mensajes);
                    }
                    else
                    {
                        resO = analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                    }

                    if (resO != null)
                    {
                        listaValores.AddLast((Atributo)resO);
                    }
                    return(listaValores);

                //------------------------------------ OBJETO -----------------------------------------------------------------------
                case "objeto":

                    string nombre = raiz.ChildNodes.ElementAt(0).Token.Text.ToLower().TrimEnd('\"').TrimStart('\"');

                    if (nombre.Equals("name"))
                    {
                        string   valor = raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(0).Token.Text.ToLower().TrimEnd('\"').TrimStart('\"');
                        Atributo a     = new Atributo(nombre, valor, "");
                        return(a);
                    }

                    return(null);

                    break;
                }
            }
            return(null);
        }
コード例 #34
0
        public object analizar(ParseTreeNode raiz, LinkedList <string> mensajes)
        {
            if (raiz != null)
            {
                string etiqueta = raiz.Term.Name.ToLower();

                switch (etiqueta)
                {
                case "tipo":
                    l = raiz.ChildNodes.ElementAt(0).Token.Location.Line;
                    c = raiz.ChildNodes.ElementAt(0).Token.Location.Column;
                    if (raiz.ChildNodes.Count == 2)
                    {
                        return(new LinkedList <Columna>());
                    }
                    else if (raiz.ChildNodes.Count() == 3)
                    {
                        object res = analizar(raiz.ChildNodes.ElementAt(1), mensajes);
                        if (res == null)
                        {
                            return(null);
                        }
                        return((LinkedList <Columna>)res);
                    }
                    mensajes.AddLast("La informacion para Columns tiene que ser de tipo objeto Linea: " + l + " Columna: " + c);
                    break;



                case "lista":
                    LinkedList <Columna> lista = new LinkedList <Columna>();
                    ParseTreeNode        hijoI;
                    if (raiz.ChildNodes.Count() == 3)
                    {
                        lista = (LinkedList <Columna>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        hijoI = raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(1);
                        l     = raiz.ChildNodes.ElementAt(1).Token.Location.Line;
                        c     = raiz.ChildNodes.ElementAt(1).Token.Location.Column;
                    }
                    else
                    {
                        //----------------------------------------------- import ------------------------------------------------------
                        if (raiz.ChildNodes.ElementAt(0).ChildNodes.Count() == 1)
                        {
                            hijoI = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0);
                            string direccion = hijoI.Token.Text.TrimStart('$').TrimStart('{').TrimEnd('}').TrimEnd('}').TrimEnd('$').TrimEnd('}');
                            object nuevoNodo = analizarImport(direccion, mensajes);
                            if (nuevoNodo != null)
                            {
                                return(analizar((ParseTreeNode)nuevoNodo, mensajes));
                            }
                            else
                            {
                                return(null);
                            }
                        }
                        l     = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0).Token.Location.Line;
                        c     = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(0).Token.Location.Column;
                        hijoI = raiz.ChildNodes.ElementAt(0).ChildNodes.ElementAt(1);
                    }
                    object resI = analizar(hijoI, mensajes);
                    if (resI != null)
                    {
                        LinkedList <Atributo> temp = (LinkedList <Atributo>)resI;
                        Atributo a = valorAtributo(temp, "name");
                        if (a == null)
                        {
                            mensajes.AddLast("Una columna necesita el atributo: name Linea:" + l + " Columna: " + c);
                            return(lista);
                        }
                        string nombre = a.valor.ToString();

                        a = valorAtributo(temp, "type");
                        if (a == null)
                        {
                            mensajes.AddLast("Una columna necesita el atributo: Type Linea:" + l + " Columna: " + c);
                            return(lista);
                        }
                        string type = a.valor.ToString();

                        a = valorAtributo(temp, "pk");
                        if (a == null)
                        {
                            mensajes.AddLast("Una columna necesita el atributo: PK Linea:" + l + " Columna: " + c);
                            return(lista);
                        }
                        Boolean pk = (Boolean)a.valor;

                        lista.AddLast(new Columna(nombre, type, pk));
                    }
                    return(lista);


                case "inobjetos":
                    LinkedList <Columna> lista2 = new LinkedList <Columna>();
                    ParseTreeNode        hijoI2;
                    if (raiz.ChildNodes.Count() == 5)
                    {
                        lista2 = (LinkedList <Columna>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        hijoI2 = raiz.ChildNodes.ElementAt(3);
                        l      = raiz.ChildNodes.ElementAt(1).Token.Location.Line;
                        c      = raiz.ChildNodes.ElementAt(1).Token.Location.Column;
                    }
                    else
                    {
                        l      = raiz.ChildNodes.ElementAt(0).Token.Location.Line;
                        c      = raiz.ChildNodes.ElementAt(0).Token.Location.Column;
                        hijoI2 = raiz.ChildNodes.ElementAt(1);
                    }
                    object resI2 = analizar(hijoI2, mensajes);
                    if (resI2 != null)
                    {
                        LinkedList <Atributo> temp = (LinkedList <Atributo>)resI2;
                        Atributo a = valorAtributo(temp, "name");
                        if (a == null)
                        {
                            mensajes.AddLast("Una columna necesita el atributo: name Linea:" + l + " Columna: " + c);
                            return(lista2);
                        }
                        string nombre = a.valor.ToString();

                        a = valorAtributo(temp, "type");
                        if (a == null)
                        {
                            mensajes.AddLast("Una columna necesita el atributo: Type Linea:" + l + " Columna: " + c);
                            return(lista2);
                        }
                        string type = a.valor.ToString();

                        a = valorAtributo(temp, "pk");
                        if (a == null)
                        {
                            mensajes.AddLast("Una columna necesita el atributo: PK Linea:" + l + " Columna: " + c);
                            return(lista2);
                        }
                        Boolean pk = (Boolean)a.valor;

                        lista2.AddLast(new Columna(nombre, type, pk));
                    }
                    return(lista2);



                case "objetos":
                    LinkedList <Atributo> listaValores = new LinkedList <Atributo>();
                    object resO;

                    if (raiz.ChildNodes.Count() == 3)
                    {
                        listaValores = (LinkedList <Atributo>)analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                        resO         = analizar(raiz.ChildNodes.ElementAt(2), mensajes);
                    }
                    else
                    {
                        resO = analizar(raiz.ChildNodes.ElementAt(0), mensajes);
                    }

                    if (resO != null)
                    {
                        listaValores.AddLast((Atributo)resO);
                    }

                    return(listaValores);


                    break;


                case "objeto":
                    string key = raiz.ChildNodes.ElementAt(0).Token.Text.ToLower().TrimEnd('\"').TrimStart('\"').TrimStart().TrimEnd();
                    l = raiz.ChildNodes.ElementAt(0).Token.Location.Line;
                    c = raiz.ChildNodes.ElementAt(0).Token.Location.Column;
                    string valor = raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(0).Token.Text.ToLower().TrimEnd('\"').TrimStart('\"').TrimStart().TrimEnd();
                    if (key.Equals("name"))
                    {
                        return(new Atributo("name", valor, ""));
                    }
                    else if (key.Equals("type"))
                    {
                        return(new Atributo("type", valor, ""));
                    }
                    else if (key.Equals("pk"))
                    {
                        return(new Atributo("pk", Boolean.Parse(valor), ""));
                    }
                    else
                    {
                        mensajes.AddLast("No se reconoce el atributo: " + key + " para una columna");
                        return(null);
                    }

                    break;
                }
            }
            return(null);
        }
コード例 #35
0
ファイル: Indice.cs プロジェクト: maggie97/ArchivosDD
 public Indice(string Nombre, int i, Atributo a) : base(Nombre + ".idx")
 {
     index = i;
     atrib = a;
 }
コード例 #36
0
        /*
         * Metodo que se encargara de editar todos los campos
         * @ts tabla de simbolos padre
         * @user usuario que esta ejecutando las acciones
         * @baseD string por referencia de que base de datos estamos trabajando
         * @mensajes el output de la ejecucion
         * @tsT se encargara de guardar todos los datos en una tabla temporal para la tabla
         * @t tabla actual
         */

        private object changeAll(TablaDeSimbolos ts, Ambito ambito, Tabla t)
        {
            Mensaje             mensa    = new Mensaje();
            string              baseD    = ambito.baseD;
            LinkedList <string> mensajes = ambito.mensajes;
            BaseDeDatos         db       = TablaBaseDeDatos.getBase(baseD);

            foreach (Data data in t.datos)
            {
                TablaDeSimbolos tsT = new TablaDeSimbolos();
                guardarTemp(data.valores, tsT);
                if (checkColumns(t.columnas, mensajes, ambito))
                {
                    foreach (SetCQL set in asignacion)
                    {
                        foreach (Atributo atributo in data.valores)
                        {
                            object op1 = (set.valor == null) ? null : set.valor.ejecutar(ts, ambito, tsT);
                            if (set.operacion.Equals("NORMAL"))
                            {
                                if (set.campo.Equals(atributo.nombre))
                                {
                                    Atributo temp = checkinfo(getColumna(t.columnas, set.campo), op1, set.valor, mensajes, db, ambito);
                                    if (temp != null)
                                    {
                                        atributo.valor = temp.valor;
                                    }
                                    else
                                    {
                                        return(null);
                                    }
                                }
                            }
                            else
                            {
                                object op2 = (set.accesoUS == null) ? null : set.accesoUS.ejecutar(ts, ambito, tsT);

                                if (op2 != null)
                                {
                                    if (op2.GetType() == typeof(InstanciaUserType))
                                    {
                                        InstanciaUserType temp = (InstanciaUserType)op2;
                                        foreach (Atributo a in temp.lista)
                                        {
                                            if (a.nombre.Equals(set.campo))
                                            {
                                                Columna  co    = new Columna(a.nombre, a.tipo, false);
                                                Atributo temp2 = checkinfo(co, op1, set.valor, mensajes, db, ambito);
                                                if (temp2 != null)
                                                {
                                                    a.valor = temp2.valor;
                                                }
                                                else
                                                {
                                                    return(null);
                                                }
                                            }
                                        }
                                    }
                                    else if (op2.GetType() == typeof(Map))
                                    {
                                        object campo = (set.key == null) ? null : set.key.ejecutar(ts, ambito, tsT);
                                        Map    temp  = (Map)op2;
                                        string tipo  = temp.id.Split(new[] { ',' }, 2)[1];
                                        foreach (KeyValue ky in temp.datos)
                                        {
                                            if (ky.key.ToString().Equals(campo))
                                            {
                                                Columna  co    = new Columna(ky.key.ToString(), tipo, false);
                                                Atributo temp2 = checkinfo(co, op1, set.valor, mensajes, db, ambito);
                                                if (temp2 != null)
                                                {
                                                    ky.value = temp2.valor;
                                                }
                                                else
                                                {
                                                    return(null);
                                                }
                                            }
                                        }
                                        ambito.listadoExcepciones.AddLast(new Excepcion("indexoutexception", "No se encontro la key"));
                                    }
                                    else if (op2.GetType() == typeof(List))
                                    {
                                        List   temp  = (List)op2;
                                        object campo = (set.key == null) ? null : set.key.ejecutar(ts, ambito, tsT);
                                        if (campo != null)
                                        {
                                            if (campo.GetType() == typeof(int))
                                            {
                                                if ((int)campo > -1)
                                                {
                                                    if ((int)campo < temp.lista.Count())
                                                    {
                                                        if (temp.lista.Count() > 0)
                                                        {
                                                            var node  = temp.lista.First;
                                                            int index = 0;
                                                            while (node != null)
                                                            {
                                                                var nodeNext = node.Next;
                                                                if (index == (int)campo)
                                                                {
                                                                    Columna  co    = new Columna("", temp.id, false);
                                                                    Atributo temp2 = checkinfo(co, op1, set.valor, mensajes, db, ambito);
                                                                    if (temp2 != null)
                                                                    {
                                                                        node.Value = temp2.valor;
                                                                    }
                                                                    else
                                                                    {
                                                                        return(null);
                                                                    }
                                                                    break;
                                                                }
                                                                node = nodeNext;
                                                                index++;
                                                            }
                                                        }
                                                    }
                                                    else
                                                    {
                                                        ambito.listadoExcepciones.AddLast(new Excepcion("indexoutexception", "El index es mayor al tamaño de la lista"));
                                                        mensajes.AddLast(mensa.error("El index supera el tamanio de la lista", l, c, "Semantico"));
                                                        return(null);
                                                    }
                                                }
                                                else
                                                {
                                                    ambito.mensajes.AddLast(mensa.error("Index tiene que ser mayor a 0  ", l, c, "Semantico"));
                                                    mensajes.AddLast(mensa.error("El index debe de ser positivo: " + campo, l, c, "Semantico"));
                                                    return(null);
                                                }
                                            }
                                            else
                                            {
                                                mensajes.AddLast(mensa.error("El index debe de ser de tipo numerico: " + campo, l, c, "Semantico"));
                                                return(null);
                                            }
                                        }
                                        else
                                        {
                                            mensajes.AddLast(mensa.error("El index no puede ser null", l, c, "Semantico"));
                                            return(null);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                else
                {
                    return(null);
                }
            }
            mensajes.AddLast(mensa.message("Datos actualizados con exito"));
            return("");
        }
コード例 #37
0
        private bool validarAtributo(Atributo atributo, Acao acao)
        {
            //valida o total de pontos
            if (acao.Equals(Acao.subir))
            {
                int totalParaGastar = (totalPontos - (forca + destreza + inteligencia));
                if (totalParaGastar == 0)
                {
                    return(false);
                }
            }

            //força
            if (atributo == Atributo.forca)
            {
                if (acao == Acao.subir)
                {
                    if (forca >= maxAtributo)
                    {
                        return(false);
                    }
                    return(true);
                }
                else
                {
                    if (forca <= minimoAtributo)
                    {
                        return(false);
                    }
                    return(true);
                }
            }

            //destreza
            else if (atributo == Atributo.destreza)
            {
                if (acao == Acao.subir)
                {
                    if (destreza >= maxAtributo)
                    {
                        return(false);
                    }
                    return(true);
                }
                else
                {
                    if (destreza <= minimoAtributo)
                    {
                        return(false);
                    }
                    return(true);
                }
            }

            //inteligencia
            else
            {
                if (acao == Acao.subir)
                {
                    if (inteligencia >= maxAtributo)
                    {
                        return(false);
                    }
                    return(true);
                }
                else
                {
                    if (inteligencia <= minimoAtributo)
                    {
                        return(false);
                    }
                    return(true);
                }
            }
        }
コード例 #38
0
ファイル: Archivo.cs プロジェクト: miguee90/DataBase
        public Atributo getBloqueAtributo(long direccion)
        {
            stream.Position=direccion;
            string nombre = reader.ReadString();
            string uno = reader.ReadString();
            int dos = reader.ReadInt32();
            int tres = reader.ReadInt32();
            long cuatro = reader.ReadInt64();
            long cinco = reader.ReadInt64();
            long seis = reader.ReadInt64();

            Atributo atr = new Atributo(nombre, uno, dos,
                tres, cuatro, cinco, seis, "");

            return atr;
        }
コード例 #39
0
 public string Excluir(Atributo entidade)
 {
     return("");
 }
コード例 #40
0
ファイル: Multilistas.cs プロジェクト: miguee90/DataBase
        /// <summary>
        /// inserta ordenado de acuerdo al tipo de dato que es el atributo
        /// </summary>
        /// <param name="ent"></param>
        /// <param name="a"></param>
        /// <param name="dato"></param>
        /// <param name="dirBloq"></param>
        /// <param name="indice"></param>
        /// <param name="tipo"></param>
        /// <returns></returns>
        private bool insertaOrdenado(Entidad ent,Atributo a,string dato,long dirBloq,int indice,string tipo)
        {
            bool esRepe = false;
            string datoLeido;
            long dirNextBloq = a.ApuntaEntidad; ;
            long dirActual = 0;
            long dirDats = a.ApuntaEntidad;
            long dirAnt = 0;
            bool inserto = false;

            //Si no hay ningun dato inserta al inicio
            if (dirDats == ent.Dir)
            {
                a.ApuntaEntidad = dirBloq;
                archivo.escribePtrDatAtr(a.Direccion, dirBloq);
                inserto = true;
            }
            else
            {
                while (dirNextBloq != -1)
                {
                    archivo.setStreamPosition(dirNextBloq);
                    //Recorre los atributos
                    dirNextBloq=recorrePtrs(dirNextBloq, ent,indice);
                    dirActual = archivo.getLong();
                    archivo.getLong();
                    //Obtiene el dato a ordenar
                    datoLeido = getDatoByIndice(indice, dirBloq, ent);
                    if (comparaMayor(datoLeido, dato, tipo))
                    {
                        //Si es el primer lugar
                        if (dirAnt == 0)
                        {
                            a.ApuntaEntidad = dirBloq;
                            archivo.escribePtrDatAtr(a.Direccion, dirBloq);
                            //Nuevo apunta a las anteriores
                            //Escribe en el apuntador de acuerdo al indice
                            escribePtrNextBloq(dirBloq, indice, ent, dirActual);
                            inserto = true;
                            break;
                        }
                        //Si es un elemento intermedio
                        else
                        {
                            //reescribe el apuntador del bloque anterior
                            escribePtrNextBloq(dirAnt, indice, ent, dirBloq);
                            //escribe el apuntador a siguiente mio
                            escribePtrNextBloq(dirBloq, indice, ent, dirActual);
                            inserto = true;
                            break;
                        }
                    }
                    dirAnt = dirActual;
                }
                //Inserta al final 
                if (inserto == false)
                {
                    //reescribe el apuntador del bloque anterior
                    escribePtrNextBloq(dirAnt, indice, ent, dirBloq);
                    //escribe el apuntador a siguiente mio
                    escribePtrNextBloq(dirBloq, indice, ent, (long)-1);
                }
            }

            return esRepe;
        }
コード例 #41
0
ファイル: Archivo.cs プロジェクト: miguee90/DataBase
        /// <summary>
        /// Escribe un bloque de atributo en el archivo
        /// </summary>
        /// <param name="atr"></param>

        public void escrbeAtributo(Atributo atr)
        {
            stream.Position = stream.Length;
            writer.Write(atr.Nombre);
            writer.Write(atr.Tipo);
            writer.Write(atr.Tam);
            writer.Write(atr.TClave);
            writer.Write(atr.ApuntaEntidad);
            writer.Write(atr.ApuntaAtri);
            writer.Write(atr.Direccion);
            writer.Write(atr.ApuntaPrim);
        }
コード例 #42
0
        private List <byte[]> GerarZipProcessado()
        {
            List <string> prjList = new List <string>();

            string[] featureList = null;
            string[] aliasList   = null;

            switch (Project.Type)
            {
            case OPERACAO_DOMINIALIDADE:
                featureList = "TMP_ATP,TMP_APMP,TMP_AFD,TMP_ROCHA,TMP_VERTICE,TMP_ARL,TMP_RPPN,TMP_AFS,TMP_AVN,TMP_AA,TMP_ACONSTRUIDA,TMP_DUTO,TMP_LTRANSMISSAO,TMP_ESTRADA,TMP_FERROVIA,TMP_NASCENTE,TMP_RIO_LINHA,TMP_RIO_AREA,TMP_LAGOA,TMP_REPRESA,TMP_DUNA,TMP_REST_DECLIVIDADE,TMP_ESCARPA,TMP_AREAS_CALCULADAS".Split(',');
                aliasList   = "ATP,APMP,AFD,ROCHA,VERTICE,ARL,RPPN,AFS,AVN,AA,ACONSTRUIDA,DUTO,LTRANSMISSAO,ESTRADA,FERROVIA,NASCENTE,RIO_LINHA,RIO_AREA,LAGOA,REPRESA,DUNA,REST_DECLIVIDADE,ESCARPA,AREAS_CALCULADAS".Split(',');
                break;

            case OPERACAO_ATIVIDADE:
                featureList = "TMP_PATIV,TMP_LATIV,TMP_AATIV,TMP_AIATIV".Split(',');
                aliasList   = "PATIV,LATIV,AATIV,AIATIV".Split(',');
                break;
            }

            FonteFeicaoOracleSpatial origem            = GetDatabaseFontFeicao();
            FonteFeicaoShapeStream   destino           = new FonteFeicaoShapeStream();
            FonteFeicaoShapeStream   destinoTrackmaker = new FonteFeicaoShapeStream();

            origem.Abrir();
            destino.Abrir();
            destinoTrackmaker.Abrir();

            LeitorFeicao leitor       = null;
            ClasseFeicao classeFeicao = null;

            List <OperadorFeicaoShape> lstEscritores           = new List <OperadorFeicaoShape>();
            List <OperadorFeicaoShape> lstEscritoresTrackmaker = new List <OperadorFeicaoShape>();

            int count = featureList.Length;

            for (int i = 0; i < count; i++)
            {
                string feicao = featureList[i];
                string alias  = aliasList[i];

                classeFeicao = origem.ObterClasseFeicao(feicao);
                if (classeFeicao == null)
                {
                    continue;
                }

                OperadorFeicaoShape escritor  = null;
                AtributoCollection  atributos = null;

                OperadorFeicaoShape escritorTrackmaker  = null;
                AtributoCollection  atributosTrackmaker = null;

                Expressao filtro = null;
                Atributo  atributo;
                Feicao    data;

                if (feicao == "TMP_AREAS_CALCULADAS")
                {
                    string[] tipos = "APP_APMP,APP_AA_USO,APP_AA_REC,APP_AVN,APP_ARL".Split(',');

                    foreach (string tipoArea in tipos)
                    {
                        ExpressaoRelacionalOracleSpatial termo1 = new ExpressaoRelacionalOracleSpatial(new Campo("PROJETO"), TipoOperadorRelacional.Igual, new ParametroOracleSpatial(DbType.Int32, Project.Id));
                        ExpressaoRelacionalOracleSpatial termo2 = new ExpressaoRelacionalOracleSpatial(new Campo("TIPO"), TipoOperadorRelacional.Igual, new ParametroOracleSpatial(DbType.String, tipoArea, 50));
                        filtro = new ExpressaoLogicaOracleSpatial(termo1, TipoOperadorLogico.E, termo2);

                        try
                        {
                            leitor = origem.ObterLeitorFeicao(feicao, null, filtro);
                        }
                        catch (Exception exc)
                        {
                            for (int k = 0; k < 5; k++)
                            {
                                try
                                {
                                    ExpressaoRelacionalOracleSpatial termoAux = new ExpressaoRelacionalOracleSpatial(new Campo("1"), TipoOperadorRelacional.Igual, new Campo("1"));
                                    filtro = new ExpressaoLogicaOracleSpatial(filtro, TipoOperadorLogico.E, termoAux);
                                    leitor = origem.ObterLeitorFeicao(feicao, null, filtro);
                                }
                                catch (Exception)
                                {
                                    if (k < 4)
                                    {
                                        continue;
                                    }

                                    throw new Exception(string.Format("Feicao: {0} / Project.Id: {1} / tipo {2} / where: {3}", feicao, Project.Id, tipoArea, filtro.GerarComando()), exc);
                                }

                                break;
                            }
                        }

                        escritor = null;

                        while (leitor.Ler())
                        {
                            if (escritor == null)
                            {
                                atributos = new AtributoCollection();
                                atributos.Adicionar(classeFeicao.Atributos["AREA_M2"]);

                                escritor = (OperadorFeicaoShape)destino.CriarClasseFeicao(tipoArea, leitor.Atual.Geometria.ObterTipo(), 2, false, atributos);
                                prjList.Add(tipoArea);

                                lstEscritores.Add(escritor);


                                //Trackmaker
                                atributo         = new Atributo();
                                atributo.Nome    = "NOME";
                                atributo.Tamanho = 200;
                                atributo.Tipo    = DbType.String;

                                atributosTrackmaker = new AtributoCollection();
                                atributosTrackmaker.Adicionar(atributo);
                                escritorTrackmaker = (OperadorFeicaoShape)destinoTrackmaker.CriarClasseFeicao(tipoArea, leitor.Atual.Geometria.ObterTipo(), 2, false, atributosTrackmaker);

                                lstEscritoresTrackmaker.Add(escritorTrackmaker);
                            }

                            //Normal information
                            data           = new Feicao();
                            data.ID        = leitor.Atual.ID;
                            data.Geometria = leitor.Atual.Geometria;

                            data.Atributos = new AtributoCollection();
                            foreach (Atributo attr in atributos)
                            {
                                atributo       = attr.Clonar();
                                atributo.Valor = leitor.Atual.Atributos[atributo.Nome].Valor;
                                data.Atributos.Adicionar(atributo);
                            }

                            escritor.Inserir(data);


                            //Trackmaker information
                            data           = new Feicao();
                            data.ID        = leitor.Atual.ID;
                            data.Geometria = leitor.Atual.Geometria;

                            data.Atributos = new AtributoCollection();
                            atributo       = atributosTrackmaker[0].Clonar();
                            atributo.Valor = GenerateTrackMakerNameValue("TMP_" + tipoArea, leitor.Atual.Atributos);
                            data.Atributos.Adicionar(atributo);

                            escritorTrackmaker.Inserir(data);
                        }
                    }
                }
                else
                {
                    filtro = new ExpressaoRelacionalOracleSpatial(new Campo("PROJETO"), TipoOperadorRelacional.Igual, new ParametroOracleSpatial(DbType.Int32, Project.Id));

                    try
                    {
                        leitor = origem.ObterLeitorFeicao(feicao, null, filtro);
                    }
                    catch (Exception)
                    {
                        for (int k = 0; k < 5; k++)
                        {
                            try
                            {
                                ExpressaoRelacionalOracleSpatial termoAux = new ExpressaoRelacionalOracleSpatial(new Campo("1"), TipoOperadorRelacional.Igual, new Campo("1"));
                                filtro = new ExpressaoLogicaOracleSpatial(filtro, TipoOperadorLogico.E, termoAux);
                                leitor = origem.ObterLeitorFeicao(feicao, null, filtro);
                            }
                            catch (Exception)
                            {
                                if (k < 4)
                                {
                                    continue;
                                }

                                throw;
                            }

                            break;
                        }
                    }

                    while (leitor.Ler())
                    {
                        if (escritor == null)
                        {
                            atributos = new AtributoCollection();

                            atributos.Adicionar(classeFeicao.Atributos["ID"]);

                            if (classeFeicao.Atributos.IndiceDe("LARGURA") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["LARGURA"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("NOME") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["NOME"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("AMORTECIMENTO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["AMORTECIMENTO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("COD_APMP") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["COD_APMP"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("COMPENSADA") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["COMPENSADA"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("ESTAGIO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["ESTAGIO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("PROJETO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["PROJETO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("SITUACAO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["SITUACAO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("TIPO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["TIPO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("ZONA") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["ZONA"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("AREA_M2") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["AREA_M2"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("CODIGO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["CODIGO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("VEGETACAO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["VEGETACAO"]);
                            }

                            escritor = (OperadorFeicaoShape)destino.CriarClasseFeicao(alias, leitor.Atual.Geometria.ObterTipo(), 2, false, atributos);
                            prjList.Add(alias);

                            lstEscritores.Add(escritor);

                            //Trackmaker
                            atributo         = new Atributo();
                            atributo.Nome    = "NOME";
                            atributo.Tamanho = 200;
                            atributo.Tipo    = DbType.String;

                            atributosTrackmaker = new AtributoCollection();
                            atributosTrackmaker.Adicionar(atributo);
                            escritorTrackmaker = (OperadorFeicaoShape)destinoTrackmaker.CriarClasseFeicao(alias, leitor.Atual.Geometria.ObterTipo(), 2, false, atributosTrackmaker);

                            lstEscritoresTrackmaker.Add(escritorTrackmaker);
                        }

                        //Normal information
                        data           = new Feicao();
                        data.ID        = leitor.Atual.ID;
                        data.Geometria = leitor.Atual.Geometria;

                        data.Atributos = new AtributoCollection();
                        foreach (Atributo attr in atributos)
                        {
                            atributo       = attr.Clonar();
                            atributo.Valor = leitor.Atual.Atributos[atributo.Nome].Valor;
                            data.Atributos.Adicionar(atributo);
                        }

                        escritor.Inserir(data);

                        //Trackmaker information
                        data           = new Feicao();
                        data.ID        = leitor.Atual.ID;
                        data.Geometria = leitor.Atual.Geometria;

                        data.Atributos = new AtributoCollection();
                        atributo       = atributosTrackmaker[0].Clonar();
                        atributo.Valor = GenerateTrackMakerNameValue(feicao, leitor.Atual.Atributos);
                        data.Atributos.Adicionar(atributo);

                        escritorTrackmaker.Inserir(data);
                    }
                }

                leitor.Fechar();
            }

            byte[] byteReturn           = null;
            byte[] byteTrackmakerReturn = null;

            if (lstEscritores.Count > 0)
            {
                using (MemoryStream ms = new MemoryStream())
                {
                    destino.ExportarParaZip(ms);
                    byteReturn = AdicionarArquivosPrj(ms, prjList.ToArray());
                }

                using (MemoryStream ms = new MemoryStream())
                {
                    destinoTrackmaker.ExportarParaZip(ms);
                    byteTrackmakerReturn = AdicionarArquivosPrj(ms, prjList.ToArray());
                }

                foreach (OperadorFeicaoShape escritorShp in lstEscritores)
                {
                    escritorShp.Fechar();
                }

                foreach (OperadorFeicaoShape escritorShp in lstEscritoresTrackmaker)
                {
                    escritorShp.Fechar();
                }
            }

            origem.Fechar();
            destino.Fechar();
            destinoTrackmaker.Fechar();

            List <byte[]> result = new List <byte[]>();

            result.Add(byteReturn);
            result.Add(byteTrackmakerReturn);

            return(result);
        }
コード例 #43
0
ファイル: Diccionario.cs プロジェクト: miguee90/DataBase
 /// <summary>
 /// Obtiene su direccion en archivo y lo escribe en el
 /// </summary>
 /// <param name="atr"></param>
 /// <param name="nombreEnt"></param>
 public void insertaAtributo(Atributo atr, string nombreEnt)
 {
     //Busca la entidad
      for (int i=0; i < entidades.Count; i++)
          if (entidades[i].Nombre == nombreEnt)
          {
              //inserta en memoria
              entidades[i].insertaAtributo(atr);
              //Cambia el apuntador a atributos de la entidad
              //En memoria
              entidades[i].ApuntaAt = entidades[i].Atributos[0].Direccion;
              //En archivo
          }
 }
コード例 #44
0
ファイル: Entidad.cs プロジェクト: miguee90/DataBase
 public void insertaAtributo(Atributo atr)
 {
     atributos.Insert(0, atr);
 }
コード例 #45
0
 public NotificationResult Excluir(Atributo entidade)
 {
     return(_atributoServico.Excluir(entidade));
 }
コード例 #46
0
        internal ClasseFeicao ObterClasseFeicao(string classeFeicao)
        {
            ClasseFeicao classeFeicao1 = new ClasseFeicao(classeFeicao);

            try
            {
                int    length = classeFeicao1.Nome.IndexOf(".");
                string str1;
                string str2;
                if (length < 0)
                {
                    str1 = "IDAFGEO";
                    str2 = classeFeicao1.Nome;
                }
                else
                {
                    str1 = classeFeicao1.Nome.Substring(0, length);
                    str2 = classeFeicao1.Nome.Substring(length + 1);
                }

                string sql = "select count(*) from (select m.owner||'.'|| m.table_name tabela from " +
                             "all_sdo_geom_metadata m) x where x.tabela = upper(:tabela)";
                string result;

                using (Comando comando = this.banco.CriarComando(sql))
                {
                    comando.AdicionarParametroEntrada("tabela", (str1 + "." + str2), DbType.String);

                    result = this.banco.ExecutarScalar(comando).ToString();
                }

                if (result == "")
                {
                    throw new Exception("Tabela " + classeFeicao1.Nome + " não encontrada");
                }

                sql = "select a.column_name, a.data_type, a.char_length, a.data_precision, a.data_scale " +
                      "from all_tab_cols a where a.owner=UPPER(:owner) and a.table_name=UPPER(:tablename) " +
                      "and a.hidden_column='NO' order by a.column_id";

                Hashtable    list          = new Hashtable();
                ClasseFeicao classeFeicao2 = new ClasseFeicao(classeFeicao);
                using (Comando comando = this.banco.CriarComando(sql))
                {
                    comando.AdicionarParametroEntrada("owner", str1, DbType.String);
                    comando.AdicionarParametroEntrada("tablename", str2, DbType.String);

                    using (IDataReader reader = banco.ExecutarReader(comando))
                    {
                        while (reader.Read())
                        {
                            if (reader["data_type"].ToString() == "SDO_GEOMETRY")
                            {
                                classeFeicao2.CampoGeometrico = reader["column_name"].ToString();
                            }
                            else
                            {
                                Atributo campo = new Atributo();
                                campo.Nome = reader["column_name"].ToString();
                                switch (reader["data_type"].ToString())
                                {
                                case "DATE":
                                    campo.Tipo = DbType.DateTime;
                                    break;

                                case "NUMBER":
                                    campo.Tipo = DbType.Decimal;
                                    if (reader["data_precision"] is DBNull || reader["data_precision"] == null)
                                    {
                                        if (reader["data_scale"] is DBNull || reader["data_scale"] == null)
                                        {
                                            campo.Tamanho       = -1;
                                            campo.CasasDecimais = -1;
                                            break;
                                        }
                                        campo.Tamanho       = 38;
                                        campo.CasasDecimais = int.Parse(reader["data_scale"].ToString());
                                        break;
                                    }
                                    campo.Tamanho = int.Parse(reader["data_precision"].ToString());
                                    int num = reader["data_scale"] is DBNull || reader["data_scale"] == null ? 0 : (Convert.ToInt32(reader["data_scale"]) >= 0 ? 1 : 0);
                                    campo.CasasDecimais = num != 0 ? int.Parse(reader["data_scale"].ToString()) : 0;
                                    break;

                                case "REAL":
                                case "FLOAT":
                                    campo.Tipo          = DbType.Decimal;
                                    campo.Tamanho       = -1;
                                    campo.CasasDecimais = -1;
                                    break;

                                case "INT":
                                case "SMALLINT":
                                case "DECIMAL":
                                case "DEC":
                                case "NUMERIC":
                                case "INTEGER":
                                    campo.Tipo          = DbType.Decimal;
                                    campo.Tamanho       = 38;
                                    campo.CasasDecimais = 0;
                                    break;

                                case "CHAR":
                                case "NCHAR":
                                case "NVARCHAR2":
                                case "STRING":
                                case "VARCHAR2":
                                    campo.Tipo    = DbType.String;
                                    campo.Tamanho = int.Parse(reader["char_length"].ToString());
                                    break;

                                case "LONG":
                                    campo.Tipo    = DbType.String;
                                    campo.Tamanho = 32760;
                                    break;

                                case "BLOB":
                                    break;

                                default:
                                    throw new Exception("Tipo de campo não tratado \"" + reader["data_type"].ToString() + "\"");
                                }
                                classeFeicao2.Atributos.Adicionar(campo);
                            }
                        }
                        return(classeFeicao2);
                    }
                }
            }
            catch
            {
                return(null);
            }
        }