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();
}
}
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>>();
}
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;
}
}
public void CriarAtributo(Atributo inputs)
{
_repo.CriarAtributo(inputs);
}
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);
}
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);
}
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);
}
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();
}
}
public NotificationResult Atualizar(Atributo entidade)
{
return(_atributoServico.Atualizar(entidade));
}
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);
}
}
/*
* 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);
}
public void CrearAtributoVacio()
{
var nuevoAtributo = new Atributo(null, 0);
}
public indAtrib(int i, Atributo a)
{
this.i = i;
this.a = a ?? throw new ArgumentNullException(nameof(a));
}
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);
}
/// <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();
}
}*/
}
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();
}
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);
}
private void descerAtributo(Atributo atributo)
{
if(validarAtributo(atributo, Acao.descer)) {
diminuirAtributo(atributo);
}
else {
jogador.SendMessage( "Você não pode diminuir este atributo.");
}
}
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);
}
private void diminuirAtributo(Atributo atributo)
{
if(atributo == Atributo.forca) {
forca -= 5;
}
else if(atributo == Atributo.destreza) {
destreza -= 5;
}
else {
inteligencia -= 5;
}
}
/// <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;
}
}
private void somarAtributo(Atributo atributo)
{
if(atributo == Atributo.forca) {
forca += 5;
}
else if(atributo == Atributo.destreza) {
destreza += 5;
}
else {
inteligencia += 5;
}
}
public NotificationResult Salvar(Atributo entidade)
{
throw new NotImplementedException();
}
private void subirAtributo(Atributo atributo)
{
if(validarAtributo(atributo, Acao.subir)) {
somarAtributo(atributo);
}
else {
jogador.SendMessage( "Você não pode aumentar este atributo.");
}
}
public NotificationResult Salvar(Atributo entidade)
{
return(_atributoServico.Salvar(entidade));
}
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;
}
}
}
/// <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));
}
public string Excluir(Atributo entidade)
{
return(atributo_Servico.Excluir(entidade));
}
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);
}
/*
* 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);
}
public void EditarAtributo(Atributo inputs)
{
_repo.EditarAtributo(inputs);
}
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());
}
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);
}
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);
}
public Indice(string Nombre, int i, Atributo a) : base(Nombre + ".idx")
{
index = i;
atrib = a;
}
/*
* 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("");
}
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);
}
}
}
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;
}
public string Excluir(Atributo entidade)
{
return("");
}
/// <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;
}
/// <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);
}
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);
}
/// <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
}
}
public void insertaAtributo(Atributo atr)
{
atributos.Insert(0, atr);
}
public NotificationResult Excluir(Atributo entidade)
{
return(_atributoServico.Excluir(entidade));
}
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);
}
}