public ControlBusquedaSocio(Principal principal, Operaciones operacion)
{
InitializeComponent();
ConfiguracionComponentes();
this.principal = principal;
this.operacion = operacion;
}
public Permiso(Lbl.Personas.Usuario usuario, Objeto tipo, Operaciones ops, ListaIds item)
: this(usuario.Connection)
{
this.Usuario = usuario;
this.Objeto = tipo;
this.Operaciones = ops;
this.Item = item;
}
public void Setup()
{
Operacion = new Operaciones();
}
private void btn_finalizarVenta_Click(object sender, EventArgs e)
{
try
{
string msjError;
string msjer;
Operaciones operacionNueva = new Operaciones();
operacionNueva._id_usuario = usuario._id_usuario;
operacionNueva._id_tipo_operacion = 1;
operacionNueva._descripcion = string.Concat("Venta Nro " + lbl_numVenta.Text);
NegOperacion newOp = new NegOperacion();
newOp.NuevaOperacion(operacionNueva, out msjer);
if (String.IsNullOrEmpty(msjer))
{
MessageBox.Show("Operacion realizada correctamente", "Ingreso Exitoso", MessageBoxButtons.OK, MessageBoxIcon.Information);
Ventas ventaNueva = new Ventas();
numOp = oper.UltOper(out msjError);
ventaNueva._usuario = usuario._id_usuario;
ventaNueva._cantidad_productos = dgv_ventas.Rows.Count;
ventaNueva._total_venta = int.Parse(txt_totalVenta.Text);
ventaNueva._NroOperacion = numOp;
NegVentas neguVenta = new NegVentas();
neguVenta.VentaNuevo(ventaNueva, out msjError);
if (String.IsNullOrEmpty(msjError))
{
MessageBox.Show("Venta Registrada", "Registro Exitoso", MessageBoxButtons.OK, MessageBoxIcon.Information);
NegDetalleVenta det = new NegDetalleVenta();
DetalleVenta detalle = new DetalleVenta();
string er = "";
foreach (DataGridViewRow dato in dgv_ventas.Rows)
{
detalle._id_usuario = usuario._id_usuario;
detalle._id_venta = int.Parse(lbl_numVenta.Text);
detalle._serie_producto = Convert.ToString(dato.Cells["Column6"].Value);
detalle._nombre_producto = Convert.ToString(dato.Cells["Column7"].Value);
detalle._cantidad = Convert.ToInt32(dato.Cells["Column9"].Value);
detalle._valor_unitario = Convert.ToInt32(dato.Cells["Column10"].Value);
det.NuevoDetalle(detalle, out er);
}
if (String.IsNullOrEmpty(er))
{
MessageBox.Show("Detalle Venta Registrada", "Registro Exitoso", MessageBoxButtons.OK, MessageBoxIcon.Information);
VentanaVentas recarga = new VentanaVentas(usuario);
recarga.Show();
this.Hide();
}
else
{
MessageBox.Show(msjError, "Ingreso Erroneo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show(msjError, "Ingreso Erroneo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show(msjer, "Ingreso Erroneo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Ingreso Erroneo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
static void Main(string[] args)
{
//1.-Instanciamos nuestra libreria DLL
Operaciones operacion = new Operaciones();
double a, b;
int op = 0;
do
{
try
{
Console.WriteLine("1.-Suma\n2.-Resta\n3.-Multiplicacion\n4.-Division\n5.-Cuadrado de un numero\n6.-Raiz cuadrada\n7.-Salir\n¿Que desea realizar?");
op = int.Parse(Console.ReadLine());
switch (op)
{
case 1: //Suma
{
Console.WriteLine("Introduce el primer número:");
a = double.Parse(Console.ReadLine());
Console.WriteLine("Introduce el segundo número:");
b = double.Parse(Console.ReadLine());
Console.WriteLine("El resultado de la suma es " + operacion.suma(a, b));
break;
}
case 2: { //Resta
Console.WriteLine("Introduce el primer número:");
a = double.Parse(Console.ReadLine());
Console.WriteLine("Introduce el segundo número:");
b = double.Parse(Console.ReadLine());
Console.WriteLine("El resultado de la resta es " + operacion.resta(a, b));
break;
}
case 3: { //Multiplicacion
Console.WriteLine("Introduce el primer número:");
a = double.Parse(Console.ReadLine());
Console.WriteLine("Introduce el segundo número:");
b = double.Parse(Console.ReadLine());
Console.WriteLine("El resultado de la multiplicacion es " + operacion.multiplicacion(a, b));
break;
}
case 4: { //Division
Console.WriteLine("Introduce el primer número:");
a = double.Parse(Console.ReadLine());
Console.WriteLine("Introduce el segundo número:");
b = double.Parse(Console.ReadLine());
Console.WriteLine("El resultado de la division de " + a + "/" + b + "=" + operacion.division(a, b));
break;
}
case 5: {
Console.WriteLine("Introduce el numero que deseas elevar al cuadrado:");
a = double.Parse(Console.ReadLine());
Console.WriteLine("El numero " + a + " elevado al cuadrado =" + operacion.cuadradoNumero(a));
break;
}
case 6: {
Console.WriteLine("Introduce el numero que deseas saber la raiz cuadrada:");
a = double.Parse(Console.ReadLine());
Console.WriteLine("La raiz cuadrada del numero " + a + " es =" + operacion.raizCuadrada(a));
break;
}
case 7: {
Console.WriteLine("Cerrando programa");
break;
}
default: {
Console.WriteLine("Introduce valores validos");
break;
}
}
}
catch (Exception e) {
Console.WriteLine("Error" + e.Message);
}
} while (op != 7);
}
/// <summary>
/// Busca un socio en club.
/// </summary>
/// <param name="cedula">Cédula del socio.</param>
/// <param name="operacion">Indica la operación que se ha llevar a cabo -Autorización, Consumo o Facturación-</param>
/// <exception cref="SocioExisteException">Ocurre cuando el socio ya existe en el club.</exception>
public void BuscarSocio(string cedula, Operaciones operacion)
{
int cedulaEntero;
if (cedula.Equals(""))
{
MessageBox.Show(this, Properties.Resources.DebeIngresarCedula, Properties.Resources.Advertencia, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (Int32.TryParse(cedula, out cedulaEntero))
{
switch (operacion)
{
case Operaciones.Autorizados:
try
{
ArrayList autorizados = club.ObtenerAutorizadosSocio(cedula);
// Actualiza la interfaz:
ctlAutorizados.CambiarAutorizados(autorizados, cedula);
}
catch (SocioExisteException see)
{
MessageBox.Show(this, see.Message, Properties.Resources.Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
break;
case Operaciones.Consumos:
try
{
ArrayList autorizados = club.ObtenerAutorizadosSocio(cedula);
// Actualización interfaz:
ctlConsumos.CambiarClientes(autorizados, cedula);
}
catch (SocioExisteException see)
{
MessageBox.Show(this, see.Message, Properties.Resources.Advertencia, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
break;
case Operaciones.Facturas:
// Actualización interfaz:
ctlFacturas.CambiarFacturas(club.ObtenerFacturasSocio(cedula), cedula);
break;
}
}
else
{
MessageBox.Show(this, Properties.Resources.DebeCedulaSerNumerico, Properties.Resources.Advertencia, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public void OrdenDeMayorAMenorDeArreglo()
{
int[] arregloOrdenado = new int[] { -56, 1, 20, 45, 45, 90, 867 };
int[] arregloDesordenado = new int[] { 1, 45, 867, 45, -56, 20, 99 };
Assert.AreEqual(Operaciones.Ordenar(arregloDesordenado), arregloDesordenado);
}
public void TestResta()
{
uint result = Operaciones.RestaNumeros(7, 9, 8);
Assert.AreEqual(true, result == 1);
}
private void button2_Click(object sender, EventArgs e)
{
int filas, columnas;
filas = Int32.Parse(textBox1.Text);
columnas = Int32.Parse(textBox2.Text);
Operaciones operacion = new Operaciones(filas, columnas);
int[,] a = new int[filas, columnas];
int[,] b = new int[filas, columnas];
/*
* Suma 2 Matrices
* Resta 2 Matrices
* Multiplicacion
* Suma Diagonal Matriz A
* Suma contra diagobal Matriaz A
* Suma columnas Matriz A
* Suma filas Matriz A
*/
for (int i = 0; i < filas; i++)
{
for (int j = 0; j < filas; j++)
{
a[i, j] = Convert.ToInt32(dataGridView1.Rows[i].Cells[j].Value.ToString());
b[i, j] = Convert.ToInt32(dataGridView2.Rows[i].Cells[j].Value.ToString());
//dataGridView3.Rows[i].Cells[j].Value = float.Parse(dataGridView2.Rows[i].Cells[j].Value.ToString());
}
}
//Thread tSuma = new Thread(generaMatriz(dataGridView3, filas, columnas, operacion.suma(a, b)));
Thread tSuma = new Thread(alerta());
tSuma.Start();
if (comboBox1.SelectedItem == "Resta 2 Matrices")
{
generaMatriz(dataGridView3, filas, columnas, operacion.resta(a, b));
}
if (comboBox1.SelectedItem == "Multiplicacion")
{
generaMatriz(dataGridView3, filas, columnas, operacion.multiplicacion(a, b));
}
if (comboBox1.SelectedItem == "Suma Diagonal Matriz A")
{
MessageBox.Show(operacion.sumaDiagonal(a, b).ToString());
}
if (comboBox1.SelectedItem == "Suma contra diagobal Matriaz A")
{
MessageBox.Show(operacion.sumaDiagonalI(a, b).ToString());
}
if (comboBox1.SelectedItem == "Suma columnas Matriz A")
{
}
if (comboBox1.SelectedItem == "Suma filas Matriz A")
{
}
}
private void button1_Click(object sender, EventArgs e)
{
double suma = Operaciones.suma(5, 2);
MessageBox.Show(suma.ToString());
}
public Aritmetica(IExpresion opIzq, Operaciones operacion)
{
this.opIzq = opIzq;
this.operacion = operacion;
}
public App()
{
// The root page of your application
MainPage = new Operaciones();
}
public Aritmetica(IExpresion opIzq, Operaciones operacion, IExpresion opDer)
{
this.opIzq = opIzq;
this.operacion = operacion;
this.opDer = opDer;
}
private void button4_Click(object sender, EventArgs e)
{
double division = Operaciones.division(5, 2);
MessageBox.Show(division.ToString());
}
private void button3_Click(object sender, EventArgs e)
{
double multiplicacion = Operaciones.multiplicacion(5, 2);
MessageBox.Show(multiplicacion.ToString());
}
private void button2_Click(object sender, EventArgs e)
{
double resta = Operaciones.resta(5, 2);
MessageBox.Show(resta.ToString());
}
private void btn_agregar_Click(object sender, EventArgs e)
{
Proveedor provNuevo = new Proveedor();
string msjError;
int j;
try
{
if (Int32.TryParse(string.Concat(txt_telefono.Text), out j))
{
provNuevo._telefonoContacto = j;
provNuevo._nombreProveedor = this.txt_nombre.Text;
provNuevo._correoContacto = this.txt_correo.Text;
if (chkbActivo.Checked)
{
provNuevo._estado = true;
}
else
{
provNuevo._estado = false;
}
NegProveedor negprov = new NegProveedor();
negprov.ProvNuevo(provNuevo, out msjError);
if (String.IsNullOrEmpty(msjError))
{
MessageBox.Show("Proveedor Agregado correctamente", "Registro Exitoso", MessageBoxButtons.OK, MessageBoxIcon.Information);
Operaciones opNueva = new Operaciones();
NegOperacion op = new NegOperacion();
string error1;
opNueva._id_usuario = usuario._id_usuario;
opNueva._id_tipo_operacion = 10;
opNueva._descripcion = "Ingreso de Proveedor nombre: " + provNuevo._nombreProveedor;
op.NuevaOperacion(opNueva, out error1);
if (String.IsNullOrEmpty(error1))
{
MessageBox.Show("Operacion realizada correctamente", "Ingreso Exitoso", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show(msjError, "Operacion Erronea", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
VentanaProveedor frmprv = new VentanaProveedor(usuario);
frmprv.Show();
this.Hide();
}
else
{
MessageBox.Show(msjError, "Ingreso Erroneo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
msjError = "Ingrese Valores Numericos en el campo Telefono Contacto" + "\n";
MessageBox.Show(msjError, "Ingreso Erroneo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
catch (Exception)
{
throw;
}
}
static void Main(string[] args)
{
Console.WriteLine("*************************************************************************");
Console.WriteLine("Calculadora V 1.0");
Console.WriteLine("Esta calculadora pedira dos numeros al usuario");
Console.WriteLine("y en pantalla se mostrarara las diferentes operaciones en pantalla");
Console.WriteLine("*************************************************************************");
var numero1 = string.Empty;
var numero2 = string.Empty;
Console.WriteLine("Digite un numero1");
numero1 = Console.ReadLine();
Console.WriteLine("Digite un numero1");
numero2 = Console.ReadLine();
//SUMA
Operaciones oper = new Operaciones();
var resultadosuma = oper.Suma(numero1, numero2);
//FUNCION SUMA ,sin parametros.
Operaciones oper2 = new Operaciones();
oper2.Mynumero1 = numero1;
oper2.Mynumero2 = numero2;
var resultadosumaSinparametros = oper2.Suma();
//uso de la funcion SUMA "Estatica"
var resultadoestatico = OperacionesEstaticas.Suma(numero1, numero2);
Console.WriteLine("El resultado de la suma de " + numero1 + "+" + numero2 + "" + " =" + resultadosuma.ToString());
Console.WriteLine("llamando funcion SUMA sin parametros" + "=" + resultadosumaSinparametros.ToString());
Console.WriteLine("Funcion SUMA estatica= " + resultadoestatico);
//RESTA
var resultadoresta = oper.Resta(numero1, numero2);
//FUNCION RESTA ,sin parametros.
var resultadorestaSinparametros = oper2.Resta();
//uso de la funcion RESTA "Estatica"
var resultadoestaticoResta = OperacionesEstaticas.Resta(numero1, numero2);
Console.WriteLine("El resultado de la RESTA de " + numero1 + "-" + numero2 + "" + " =" + resultadoresta.ToString());
Console.WriteLine("llamando funcion RESTA sin parametros" + "=" + resultadorestaSinparametros.ToString());
Console.WriteLine("Funcion RESTA estatica= " + resultadoestaticoResta);
//Multiplicacion
var resultadoMultiplicacion = oper.Multiplicacion(numero1, numero2);
//FUNCION Multiplicacion ,sin parametros.
var resultadoMultiplicacionSinparametros = oper2.Multiplicacion();
//uso de la funcion Multiplicacion "Estatica"
var resultadoestaticoresultadoMultiplicacion = OperacionesEstaticas.Multiplicacion(numero1, numero2);
Console.WriteLine("El resultado de la Multiplicacion de " + numero1 + "*" + numero2 + "" + " =" + resultadoMultiplicacion.ToString());
Console.WriteLine("llamando funcion Multiplicacion sin parametros" + "=" + resultadoMultiplicacionSinparametros.ToString());
Console.WriteLine("Funcion Multiplicacion estatica= " + resultadoestaticoresultadoMultiplicacion);
//Division
var resultadoDivision = oper.Division(numero1, numero2);
//FUNCION Division ,sin parametros.
var resultadoDivisionSinparametros = oper2.Division();
//uso de la funcion Division "Estatica"
var resultadoestaticoresultadoDivision = OperacionesEstaticas.Division(numero1, numero2);
Console.WriteLine("El resultado de la Division de " + numero1 + "/" + numero2 + " =" + resultadoDivision.ToString());
Console.WriteLine("llamando funcion Division sin parametros" + "=" + resultadoDivisionSinparametros.ToString());
Console.WriteLine("Funcion RESTA estatica= " + resultadoestaticoresultadoDivision);
Console.WriteLine("*******************************************************************");
Console.WriteLine("FIN Calculadora V 1.0");
Console.ReadLine();
}
private void CargaOperaciones()
{
DataTable dt = SigametSeguridadDataLayer.OperacionesUsuarioModulo(this.modulo, txtUsuario.Text.Trim());
this.operaciones = new Operaciones(dt);
}
private void deleteOperation()
{
Operaciones.Remove(OperationRouteSelected);
}
public static void ExecuteServerObject()
{
// Establish the local endpoint
// for the socket. Dns.GetHostName
// returns the name of the host
// running the application.
IPHostEntry ipHost = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddr = ipHost.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddr, 11111);
// Creation TCP/IP Socket using
// Socket Class Costructor
Socket listener = new Socket(ipAddr.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
Menu menuRecibido = new Menu();
try
{
// Using Bind() method we associate a
// network address to the Server Socket
// All client that will connect to this
// Server Socket must know this network
// Address
listener.Bind(localEndPoint);
// Using Listen() method we create
// the Client list that will want
// to connect to Server
listener.Listen(10);
while (true)
{
Console.WriteLine("Waiting connection ... ");
// Suspend while waiting for
// incoming connection Using
// Accept() method the server
// will accept connection of client
Socket clientSocket = listener.Accept();
// Data buffer
byte[] bytes = new Byte[1024 * 8];
int numByte = clientSocket.Receive(bytes);
menuRecibido = menuRecibido.DeSerialize(bytes);
Operaciones op = new Operaciones();
Boolean men;
men = op.InsertaMenu(menuRecibido);
Console.WriteLine("Text received -> {0} ", menuRecibido.Nombre);
//dire.Pais = "987654321";
byte[] message = Encoding.ASCII.GetBytes("Test Server");
// Send a message to Client
// using Send() method
clientSocket.Send((men == false ? (new Menu()).Serialize() : new Menu().Serialize()));
// Close client Socket using the
// Close() method. After closing,
// we can use the closed Socket
// for a new Client Connection
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private object Recorrer(ParseTreeNode actual)
{
//Tiene varios hijos
if (SoyElNodo("INSTRUCCIONES", actual))
{
LinkedList <INodoAST> instrucciones = new LinkedList <INodoAST>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
instrucciones.AddLast((INodoAST)Recorrer(hijo));
}
return(new AST(instrucciones));
}
//Solo tiene un hijo
if (SoyElNodo("PRINT", actual))
{
return(new Print((IExpresion)Recorrer(actual.ChildNodes[0])));
}
//Solo tiene un hijo
if (SoyElNodo("LITERAL", actual))
{
if (SoyElNodo("entero", actual.ChildNodes[0]))
{
int n = int.Parse(GetLexema(actual, 0));
return(new Literal(n));
}
if (SoyElNodo("decimal", actual.ChildNodes[0]))
{
double d = double.Parse(GetLexema(actual, 0), CultureInfo.InvariantCulture);
return(new Literal(d));
}
if (SoyElNodo("cadena", actual.ChildNodes[0]))
{
string aux = GetLexema(actual, 0);
aux = aux.Replace("\\n", "\n");
aux = aux.Replace("\\t", "\t");
aux = aux.Replace("\\r", "\r");
aux = aux.Substring(1, aux.Length - 2);
return(new Literal(aux));
}
if (GetLexema(actual, 0).Equals("true", System.StringComparison.InvariantCultureIgnoreCase))
{
return(new Literal(true));
}
if (GetLexema(actual, 0).Equals("false", System.StringComparison.InvariantCultureIgnoreCase))
{
return(new Literal(false));
}
if (SoyElNodo("id", actual.ChildNodes[0]))
{
string aux = GetLexema(actual, 0);
return(new Identificador(aux));
}
if (SoyElNodo("date", actual.ChildNodes[0]))
{
string aux = GetLexema(actual, 0);
aux = aux.Replace("\'", "");
DateTime fecha = Convert.ToDateTime(aux);
return(new Literal(fecha));
}
if (SoyElNodo("time", actual.ChildNodes[0]))
{
string aux = GetLexema(actual, 0);
aux = aux.Replace("\'", "");
DateTime hora = Convert.ToDateTime(aux);
return(new Literal(hora));
}
return(null);
}
if (SoyElNodo("DECLARACION", actual))
{
int numero_hijos = actual.ChildNodes.Count;
if (numero_hijos == 2)
{
LinkedList <string> identificadores = GetIds(actual.ChildNodes[1]);
//Estudiante LISTA_IDS_ARR
if (actual.FirstChild.Term.Name.Equals("id"))
{
string id = GetLexema(actual, 0);
return(new DeclaracionStruct(id, identificadores));
}
//int LISTA_IDS_ARR
Tipos tipo = GetTipo(actual.ChildNodes[0]);
return(new Declaracion(tipo, identificadores));
}
if (numero_hijos == 3)
{
LinkedList <string> identificadores = GetIds(actual.ChildNodes[1]);
//Estudiante LISTA_IDS_ARR Estudiante //Est @e = new Est
if (SoyElNodo("id", actual.FirstChild) && SoyElNodo("id", actual.LastChild))
{
string idStructGenerador = GetLexema(actual.FirstChild);
return(new DeclaracionStruct(idStructGenerador, identificadores));
}
//Estudiante LISTA_IDS_ARR LISTA_EXPRESIONES
if (actual.LastChild.Term.Name.Equals("LISTA_EXPRESIONES", System.StringComparison.InvariantCultureIgnoreCase))
{
string idStructGenerador = GetLexema(actual, 0);
LinkedList <IExpresion> asignaciones = (LinkedList <IExpresion>)Recorrer(actual.ChildNodes[2]);
return(new DeclaracionStruct(idStructGenerador, identificadores, asignaciones));
}
//Estudiante LISTA_IDS_ARR CUALQUIER_EXPRESION
if (SoyElNodo("id", actual.FirstChild) && SoyElNodo("LISTA_IDS_ARR", actual.ChildNodes[1]))
{
string idStructGenerador = GetLexema(actual, 0);
LinkedList <IExpresion> asignaciones = new LinkedList <IExpresion>();
IExpresion asig = (IExpresion)Recorrer(actual.LastChild);
asignaciones.AddLast(asig);
return(new DeclaracionStruct(idStructGenerador, identificadores, asignaciones));
}
//int LISTA_IDS_ARR EXP
Tipos tipo = GetTipo(actual.ChildNodes[0]);
IExpresion asignacion = (IExpresion)Recorrer(actual.ChildNodes[2]);
return(new Declaracion(tipo, identificadores, asignacion));
}
}
if (SoyElNodo("ASIGNACION", actual))
{
int numero_hijos = actual.ChildNodes.Count;
if (numero_hijos == 2)
{
string id = GetLexema(actual, 0);
//id LISTA_EXPRESIONES
if (SoyElNodo("LISTA_EXPRESIONES", actual.LastChild))
{
LinkedList <IExpresion> asignaciones = (LinkedList <IExpresion>)Recorrer(actual.LastChild);
return(new AsignacionStruct(id, asignaciones));
}
//id ID
if (SoyElNodo("id", actual.LastChild))
{
string idStructGenerador = GetLexema(actual, 1);
return(new AsignacionStruct(id, idStructGenerador));
}
//id exp
IExpresion valor = (IExpresion)Recorrer(actual.ChildNodes[1]);
return(new Asignacion(id, valor));
}
//id ACCESOS_OBJETO EXP
if (numero_hijos == 3)
{
string id = GetLexema(actual, 0);
LinkedList <string> atributos = (LinkedList <string>)Recorrer(actual.ChildNodes[1]);
IExpresion valor = (IExpresion)Recorrer(actual.ChildNodes[2]);
return(new AsignacionAtributo(id, atributos, valor));
}
}
if (SoyElNodo("ACCESOS_OBJETO", actual))
{
LinkedList <string> atributos = new LinkedList <string>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
string atributo = Recorrer(hijo).ToString();
atributos.AddLast(atributo);
}
return(atributos);
}
if (SoyElNodo("ACCESO", actual))
{
return(GetLexema(actual.FirstChild));
}
if (SoyElNodo("EXPRESION_ARITMETICA", actual))
{
int numero_hijos = actual.ChildNodes.Count;
//exp op exp
if (numero_hijos == 3)
{
IExpresion opIzq = (IExpresion)Recorrer(actual.FirstChild);
Operaciones operacion = GetOperacion(actual.ChildNodes[1]);
IExpresion opDer = (IExpresion)Recorrer(actual.LastChild);
return(new Aritmetica(opIzq, operacion, opDer));
}
}
if (SoyElNodo("ACCESO_OBJETO", actual))
{
//id ACCESOS_OBJETO
string id = GetLexema(actual, 0);
LinkedList <string> atributos = (LinkedList <string>)Recorrer(actual.LastChild);
return(new AccesoObjeto(id, atributos));
}
if (SoyElNodo("CREACION_TIPO", actual))
{
int numero_hijos = actual.ChildNodes.Count;
//id LISTA_ATRIBUTOS
if (numero_hijos == 2)
{
string id = GetLexema(actual, 0);
LinkedList <IInstruccion> declaraciones = (LinkedList <IInstruccion>)Recorrer(actual.LastChild);
return(new DefinicionStruct(id, declaraciones));
}
}
if (SoyElNodo("LISTA_ATRIBUTOS", actual))
{
LinkedList <IInstruccion> declaraciones = new LinkedList <IInstruccion>();
foreach (ParseTreeNode atributo in actual.ChildNodes)
{
declaraciones.AddLast((IInstruccion)Recorrer(atributo));
}
return(declaraciones);
}
if (SoyElNodo("ATRIBUTO", actual))
{
LinkedList <string> ids = new LinkedList <string>();
string id = GetLexema(actual, 0);
ids.AddLast(id);
//id ID
if (actual.LastChild.Term.Name.Equals("id", System.StringComparison.InvariantCultureIgnoreCase))
{
string idStructGenerador = GetLexema(actual, 1);
return(new DeclaracionStructComoAtributo(id, idStructGenerador));
}
//id int
Tipos tipo = GetTipo(actual.LastChild);
return(new Declaracion(tipo, ids));
}
if (SoyElNodo("LISTA_EXPRESIONES", actual))
{
LinkedList <IExpresion> expresiones = new LinkedList <IExpresion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
//Validaciones para diferenciar el uso se {items}
object val = Recorrer(hijo);
if (val is LinkedList <IExpresion> items)
{
Items i = new Items(items, true);
expresiones.AddLast(i);
}
else
{
IExpresion exp = (IExpresion)val;
expresiones.AddLast(exp);
}
}
return(expresiones);
}
if (SoyElNodo("ALTER_TYPE", actual))
{
//id LISTA_ATRIBUTOS
string idStruct = GetLexema(actual, 0);
if (SoyElNodo("LISTA_ATRIBUTOS", actual.LastChild))
{
LinkedList <IInstruccion> declaraciones = (LinkedList <IInstruccion>)Recorrer(actual.LastChild);
return(new AlterType(idStruct, declaraciones));
}
//id LISTA_IDS
if (SoyElNodo("LISTA_IDS", actual.LastChild))
{
LinkedList <string> atributos = (LinkedList <string>)Recorrer(actual.LastChild);
return(new AlterType(idStruct, atributos));
}
}
if (SoyElNodo("LISTA_IDS", actual))
{
LinkedList <string> ids = new LinkedList <string>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
string id = GetLexema(hijo);
ids.AddLast(id);
}
return(ids);
}
if (SoyElNodo("DELETE_TYPE", actual))
{
string idStruct = GetLexema(actual, 0);
return(new DeleteType(idStruct));
}
if (SoyElNodo("CREATE_TABLE", actual))
{
int numero_hijos = actual.ChildNodes.Count;
// nombreTabla COLUMNAS_TABLA
if (numero_hijos == 2)
{
string nombre = GetLexema(actual, 0);
LinkedList <Columna> columnas = (LinkedList <Columna>)Recorrer(actual.LastChild);
return(new CreateTable(nombre, columnas));
}
// exists nombreTabla COLUMNAS_TABLA
if (numero_hijos == 3)
{
string nombre = GetLexema(actual, 1);
LinkedList <Columna> columnas = (LinkedList <Columna>)Recorrer(actual.LastChild);
return(new CreateTable(true, nombre, columnas));
}
}
if (SoyElNodo("COLUMNAS_TABLA", actual))
{
LinkedList <Columna> columnas = new LinkedList <Columna>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
Columna columna = (Columna)Recorrer(hijo);
columnas.AddLast(columna);
}
return(columnas);
}
if (SoyElNodo("COLUMNA_TABLA", actual))
{
int numero_hijos = actual.ChildNodes.Count;
//id TIPO_DATO primary
if (numero_hijos == 3)
{
string nombre = GetLexema(actual, 0);
Tipos tipo = GetTipo(actual.ChildNodes[1]);
return(new Columna(nombre, tipo, true));
}
if (numero_hijos == 2)
{
//persona Atributo
if (SoyElNodo("id", actual.LastChild))
{
string nombre = GetLexema(actual, 0);
return(new Columna(nombre, Tipos.OBJETO));
}
//primary LISTA_IDS
if (SoyElNodo("LISTA_IDS", actual.LastChild))
{
LinkedList <string> ids_columnas_pk = GetIds(actual.LastChild);
return(new Columna(ids_columnas_pk));
}
//id TIPO_DATO
else
{
string nombre = GetLexema(actual, 0);
Tipos tipo = GetTipo(actual.ChildNodes[1]);
return(new Columna(nombre, tipo));
}
}
//id < tipo tipo >
if (numero_hijos == 5)
{
string nombre = GetLexema(actual, 0);
return(new Columna(nombre, Tipos.MAP));
}
//COLUMNA_LIST || COLUMNA_SET
if (numero_hijos == 1)
{
return(Recorrer(actual.FirstChild));
}
}
if (SoyElNodo("COLUMNA_LIST", actual))
{
//id < tipo >
string nombre = GetLexema(actual, 0);
return(new Columna(nombre, Tipos.LIST));
}
if (SoyElNodo("COLUMNA_SET", actual))
{
//id < tipo >
string nombre = GetLexema(actual, 0);
return(new Columna(nombre, Tipos.SET));
}
if (SoyElNodo("INSERT", actual))
{
int numero_hijos = actual.ChildNodes.Count;
string nombreTabla = GetLexema(actual, 0);
LinkedList <IExpresion> expresiones = (LinkedList <IExpresion>)Recorrer(actual.LastChild);
//nombreTabla LISTA_EXPRESIONES
if (numero_hijos == 2)
{
return(new Insert(nombreTabla, expresiones));
}
//nombreTabla LISTA_IDS LISTA_EXPRESIONES
if (numero_hijos == 3)
{
LinkedList <string> ids = (LinkedList <string>)Recorrer(actual.ChildNodes[1]);
return(new Insert(nombreTabla, ids, expresiones));
}
}
if (SoyElNodo("SELECT", actual))
{
int numero_hijos = actual.ChildNodes.Count;
if (numero_hijos == 2)
{
string nombreTabla = GetLexema(actual, 1);
//COLUMNAS_SELECT NombreTabla
if (SoyElNodo("COLUMNAS_SELECT", actual.FirstChild))
{
LinkedList <AccesoColumna> columnas = (LinkedList <AccesoColumna>)Recorrer(actual.FirstChild);
return(new Select(nombreTabla, columnas));
}
// * NombreTabla
return(new Select(nombreTabla));
}
}
if (SoyElNodo("OBJECT_PAIRS", actual))
{
LinkedList <ClaveValor> atributos = new LinkedList <ClaveValor>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
ClaveValor claveValor = (ClaveValor)Recorrer(hijo);
atributos.AddLast(claveValor);
}
return(new InstanciaObjecto(atributos));
}
if (SoyElNodo("OBJECT_PAIR", actual))
{
//clave valor
IExpresion clave = (IExpresion)Recorrer(actual.FirstChild);
IExpresion valor = (IExpresion)Recorrer(actual.LastChild);
return(new ClaveValor(clave, valor));
}
if (SoyElNodo("COLUMNAS_SELECT", actual))
{
LinkedList <AccesoColumna> accesosColumnas = new LinkedList <AccesoColumna>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
AccesoColumna accesoColumna = (AccesoColumna)Recorrer(hijo);
accesosColumnas.AddLast(accesoColumna);
}
return(accesosColumnas);
}
if (SoyElNodo("COLUMNA_SELECT", actual))
{
int numero_hijos = actual.ChildNodes.Count;
//id
if (numero_hijos == 1)
{
string nombre = GetLexema(actual, 0);
return(new AccesoColumna(nombre));
}
//id ACCESOS_OBJETO
if (numero_hijos == 2)
{
string nombre = GetLexema(actual, 0);
LinkedList <string> atributos = (LinkedList <string>)Recorrer(actual.LastChild);
return(new AccesoColumna(nombre, atributos));
}
}
if (SoyElNodo("MAP", actual))
{
int numero_hijos = actual.ChildNodes.Count;
//LISTA_IDS_ARR < tipo tipo >
if (numero_hijos == 5)
{
LinkedList <string> identificadores = (LinkedList <string>)Recorrer(actual.FirstChild);
Tipos tipoClave = GetTipo(actual.ChildNodes[2]);
Tipos tipoValor = GetTipo(actual.ChildNodes[3]);
return(new Map(identificadores, tipoClave, tipoValor));
}
//LISTA_IDS_ARR OBJECT_PAIRS
if (numero_hijos == 2)
{
LinkedList <string> identificadores = (LinkedList <string>)Recorrer(actual.FirstChild);
LinkedList <ClaveValor> valores = ((InstanciaObjecto)Recorrer(actual.LastChild)).atributos;
return(new Map(identificadores, valores));
}
}
if (SoyElNodo("LISTA_IDS_ARR", actual))
{
LinkedList <string> ids = new LinkedList <string>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
ids.AddLast(hijo.Token.Text);
}
return(ids);
}
if (SoyElNodo("COLLECTION_INSERT", actual))
{
//id LISTA_EXPRESIONES
string id = GetLexema(actual, 0);
LinkedList <IExpresion> valores = (LinkedList <IExpresion>)Recorrer(actual.LastChild);
return(new CollectionInsert(id, valores));
}
if (SoyElNodo("COLLECTION_GET", actual))
{
//id LISTA_EXPRESIONES
string id = GetLexema(actual, 0);
LinkedList <IExpresion> valor = (LinkedList <IExpresion>)Recorrer(actual.LastChild);
return(new CollectionGet(id, valor));
}
if (SoyElNodo("COLLECTION_SET", actual))
{
//id LISTA_EXPRESIONES
string id = GetLexema(actual, 0);
LinkedList <IExpresion> valores = (LinkedList <IExpresion>)Recorrer(actual.LastChild);
return(new CollectionSet(id, valores
));
}
if (SoyElNodo("COLLECTION_REMOVE", actual))
{
//id LISTA_EXPRESIONES
string id = GetLexema(actual, 0);
LinkedList <IExpresion> valores = (LinkedList <IExpresion>)Recorrer(actual.LastChild);
return(new CollectionRemove(id, valores));
}
if (SoyElNodo("COLLECTION_SIZE", actual))
{
//id
string id = GetLexema(actual, 0);
return(new CollectionSize(id));
}
if (SoyElNodo("COLLECTION_CLEAR", actual))
{
//id
string id = GetLexema(actual, 0);
return(new CollectionClear(id));
}
if (SoyElNodo("COLLECTION_CONTAINS", actual))
{
//id LISTA_EXPRESIONES
string id = GetLexema(actual, 0);
LinkedList <IExpresion> valores = (LinkedList <IExpresion>)Recorrer(actual.LastChild);
return(new CollectionContains(id, valores));
}
if (SoyElNodo("LIST", actual))
{
int numero_hijos = actual.ChildNodes.Count;
if (numero_hijos == 4)
{
LinkedList <string> ids = GetIds(actual.FirstChild);
//LISTA_IDS_ARR < TIPO_DATO >
if (SoyElNodo("TIPO_DATO", actual.ChildNodes[2]))
{
Tipos tipo = GetTipo(actual.ChildNodes[2]);
return(new List(ids, tipo));
}
//LISTA_IDS_ARR < ID >
if (SoyElNodo("id", actual.ChildNodes[2]))
{
Tipos tipo = Tipos.OBJETO;
return(new List(ids, tipo));
}
}
//LISTA_IDS_ARR LISTA_EXPRESIONES
if (numero_hijos == 2)
{
LinkedList <string> ids = GetIds(actual.FirstChild);
LinkedList <IExpresion> valores = (LinkedList <IExpresion>)Recorrer(actual.LastChild);
return(new List(ids, valores));
}
}
if (SoyElNodo("SET", actual))
{
int numero_hijos = actual.ChildNodes.Count;
//LISTA_IDS_ARR < tipo >
if (numero_hijos == 4)
{
LinkedList <string> ids = GetIds(actual.FirstChild);
Tipos tipo = GetTipo(actual.ChildNodes[2]);
return(new Set(ids, tipo));
}
//LISTA_IDS_ARR LISTA_EXPRESIONES
if (numero_hijos == 2)
{
LinkedList <string> ids = GetIds(actual.FirstChild);
LinkedList <IExpresion> valores = (LinkedList <IExpresion>)Recorrer(actual.LastChild);
return(new Set(ids, valores));
}
}
if (SoyElNodo("ITEMS", actual))
{
//LISTA_EXPRESIONES
LinkedList <IExpresion> valores = (LinkedList <IExpresion>)Recorrer(actual.FirstChild);
return(new Items(valores));
}
return(null);
}
public async Task InsertOperacion(Operaciones operaciones)
{
_context.Operaciones.Add(operaciones);
await _context.SaveChangesAsync();
}
public void TestSuma()
{
uint result = Operaciones.SumaNumeros(7, 9, 8);
Assert.AreEqual(true, result == 3);
}
public void menu()
{
Operaciones operaciones = new Operaciones();
byte opcion;
opcion = 0;
do
{
try
{
Console.WriteLine(" ====UNIVERSIDAD LAICA ELOY ALFARO DE MANABI==== ");
Console.WriteLine(" =======FACULTAD DE CIENCIAS INFORMATICAS========");
Console.WriteLine(" ");
Console.WriteLine(" BIENVENIDOS A EL SISTEMA DE NOTAS DE ESTUDIANTES");
Console.WriteLine("-------------------------------------------------");
Console.WriteLine("=============== Menú de Opciones ================");
Console.WriteLine("1. Insertar ");
Console.WriteLine("2. Modificar ");
Console.WriteLine("3. Eliminar");
Console.WriteLine("4.Consultar por ID");
Console.WriteLine("5.Consulta General ");
Console.WriteLine("6. Salir");
Console.WriteLine(" Que deseas hacer ?..");
opcion = Convert.ToByte(Console.ReadLine());
switch (opcion)
{
case 1:
operaciones.Crearachivo();
operaciones.Insertar();
break;
case 2:
operaciones.Modificaciones();
break;
case 3:
operaciones.Eliminar();
break;
case 4:
operaciones.Consultaid();
break;
case 5:
operaciones.ConsultaGeneral();
break;
case 6:
Console.WriteLine("******************************************");
Console.WriteLine("**********Aplicación Culminada************");
Console.WriteLine("******************************************");
break;
default:
Console.WriteLine("******************************************");
Console.WriteLine("Opcion incorrecta vuelva a teclar del 1 a el 6");
Console.WriteLine("******************************************");
break;
}
}
catch (FormatException fe)
{
Console.WriteLine("******************************************");
Console.WriteLine(" Error !" + fe.Message);
Console.WriteLine("******************************************");
}
catch (Exception e)
{
Console.WriteLine("******************************************");
Console.WriteLine(" Error !" + e.Message);
Console.WriteLine("******************************************");
}
} while (opcion != 6);
}
public void TestConcatenaMensaje()
{
Assert.AreEqual(Operaciones.concatenaMensaje(mensaje), texto + numero1 + numero2);
}
public Normal()
{
base.Load += new EventHandler(this.Normal_Load);
this.operaciones = new Operaciones();
this.InitializeComponent();
}
