public Operacion(long id, Cuenta cuenta, DateTime fecha, Decimal importe)
 {
     this.Id = id;
     this.Cuenta = cuenta;
     this.Fecha = fecha;
     this.Importe = importe;
 }
 private void button2_Click(object sender, EventArgs e)
 {
     if (CLC_SessionManager.getFecha() >= (dataGridView1.SelectedRows[0].DataBoundItem as Cuenta).FechaCreacion)
     {
         CuentaSeleccionada = dataGridView1.SelectedRows[0].DataBoundItem as Cuenta;
         this.Close();
     }
 }
 public FormAltaCuenta(Cliente cli, Cuenta cuenta, bool esCliente)
     : this(cli, esCliente)
 {
     this.Text = "Modificar Cuenta";
     btnGuardar.Text = "Modificar";
     volcarDatosCliente(cuenta);
     id = cuenta.id;
     dtFechaApertura.Enabled = false;
     tbSaldo.Visible = true;
     lblSaldo.Visible = true;
 }
Exemplo n.º 4
0
         public Comision(long id, Cuenta cuenta, Factura factura, Operacion operacion, TipoCuenta tipoCuenta, string descripcion, decimal monto)
        {
             this.Id = id;
             this.Cuenta = cuenta;
             this.Factura = factura;
             this.Operacion = operacion;
             this.TipoCuenta = tipoCuenta;
             this.Descripcion = descripcion;
             this.Monto = monto;

        }
 private void Guardarbutton_Click(object sender, EventArgs e)
 {
     if(AhorroradioButton.Checked)
     {
         cu = new Cuenta(NombreEntidadFinacieratextBox.Text,"Ahorro",NumeroCuentatextBox.Text);
         arreglo.Add(cu.ToString());
     }
     if(CorrienteradioButton.Checked)
     {
         cu = new Cuenta(NombreEntidadFinacieratextBox.Text,"Corriente",NumeroCuentatextBox.Text);
         arreglo.Add(cu.ToString());
     }
     MessageBox.Show("Se guardo la cuenta","Mensaje",MessageBoxButtons.OK,MessageBoxIcon.Information);
     NombreEntidadFinacieratextBox.Clear();
     NumeroCuentatextBox.Clear();
 }
        private void btnGuardar_Click(object sender, EventArgs e)
        {
            if (!sonDatosValidos())
                return;

            Cuenta c = new Cuenta();
            c.id = id;
            c.pais = ((Pais)cbPais.SelectedItem).id;
            c.numCuenta = Convert.ToInt64(tbNroCuenta.Text.Trim());
            c.tipoCuenta = ((TipoCuenta)cbTipoCuenta.SelectedItem).id;
            c.tipoMoneda = ((Moneda)cbMoneda.SelectedItem).id;
            c.fechaCreacion = dtFechaApertura.Value.Date;
            c.estado = ((EstadoCuenta)cbEstado.SelectedItem).id;
            c.codigoCliente = codCli;

            Cuenta result = null;
            if (update)
            {
                try
                {
                    result = new DAOCuenta().update(c);
                    MessageBox.Show(String.Format("Cuenta Numero:{0} Tipo:{1}", result.numCuenta, result.tipoCuenta), "Operacion Exitosa", MessageBoxButtons.OK);
                }
                catch (MyException exc)
                {
                    MessageBox.Show(exc.Message);
                    return;
                }
            }
            else
            {
                try
                {
                    result = new DAOCuenta().create(c);
                    MessageBox.Show(String.Format("Cuenta Numero:{0} Tipo:{1}", result.numCuenta, result.tipoCuenta), "Operacion Exitosa", MessageBoxButtons.OK);
                }
                catch (MyException exc)
                {
                    MessageBox.Show(exc.Message);
                    return;
                }
            }
            this.Close();
        }
Exemplo n.º 7
0
        public async Task get_Iniciar_Accion(ClienteTcp cliente, string paquete)
        {
            string[]  separador = paquete.Substring(2).Split(';');
            int       id_accion = int.Parse(separador[1]);
            Cuenta    cuenta    = cliente.cuenta;
            Personaje personaje = cuenta.juego.personaje;

            if (id_accion > 0)//Error: GA;0
            {
                int        id_entidad = int.Parse(separador[2]);
                Luchadores luchador   = null;

                switch (id_accion)
                {
                case 1:
                    Mapa  mapa          = cuenta.juego.mapa;
                    Celda celda_destino = mapa.celdas[Hash.get_Celda_Id_Desde_hash(separador[3].Substring(separador[3].Length - 2))];
                    byte  tipo_gkk_movimiento;

                    if (!cuenta.esta_luchando())
                    {
                        if (id_entidad == personaje.id && celda_destino.id > 0 && personaje.celda.id != celda_destino.id)
                        {
                            tipo_gkk_movimiento = byte.Parse(separador[0]);

                            await cuenta.juego.manejador.movimientos.evento_Movimiento_Finalizado(celda_destino, tipo_gkk_movimiento, true);
                        }
                        else if (mapa.personajes.TryGetValue(id_entidad, out Personaje personaje_mapa))
                        {
                            personaje_mapa.celda = celda_destino;

                            if (GlobalConf.mostrar_mensajes_debug)
                            {
                                cuenta.logger.log_informacion("DEBUG", "Detectado movimiento de un personaje a la casilla: " + celda_destino.id);
                            }
                        }
                        else if (mapa.monstruos.TryGetValue(id_entidad, out Monstruo monstruo_mapa))
                        {
                            monstruo_mapa.celda = celda_destino;
                            if (GlobalConf.mostrar_mensajes_debug)
                            {
                                cuenta.logger.log_informacion("DEBUG", "Detectado movimiento de un grupo de monstruo a la casilla: " + celda_destino.id);
                            }
                        }
                        else if (mapa.npcs.TryGetValue(id_entidad, out Npcs npc_mapa))
                        {
                            npc_mapa.celda = celda_destino;

                            if (GlobalConf.mostrar_mensajes_debug)
                            {
                                cuenta.logger.log_informacion("DEBUG", "Detectado movimiento de npc a la casilla: " + celda_destino.id);
                            }
                        }
                        mapa.evento_Entidad_Actualizada();
                    }
                    else
                    {
                        luchador = cuenta.pelea.get_Luchador_Por_Id(id_entidad);
                        if (luchador != null)
                        {
                            luchador.celda_id = celda_destino.id;

                            if (luchador.id == personaje.id)
                            {
                                tipo_gkk_movimiento = byte.Parse(separador[0]);

                                await Task.Delay(300 *personaje.celda.get_Distancia_Entre_Dos_Casillas(celda_destino));

                                cuenta.conexion.enviar_Paquete("GKK" + tipo_gkk_movimiento);
                            }
                        }
                    }
                    break;

                case 2:     //Cargando el mapa
                    await Task.Delay(200);

                    break;

                case 102:
                    if (cuenta.esta_luchando())
                    {
                        luchador = cuenta.pelea.get_Luchador_Por_Id(id_entidad);
                        byte pa_utilizados = byte.Parse(separador[3].Split(',')[1].Substring(1));

                        if (luchador != null)
                        {
                            luchador.pa -= pa_utilizados;
                        }
                    }
                    break;

                case 103:
                    if (cuenta.esta_luchando())
                    {
                        int id_muerto = int.Parse(separador[3]);

                        luchador = cuenta.pelea.get_Luchador_Por_Id(id_muerto);
                        if (luchador != null)
                        {
                            luchador.esta_vivo = false;
                        }
                    }
                    break;

                case 129:     //movimiento en pelea con exito
                    if (cuenta.esta_luchando())
                    {
                        luchador = cuenta.pelea.get_Luchador_Por_Id(id_entidad);
                        byte pm_utilizados = byte.Parse(separador[3].Split(',')[1].Substring(1));

                        if (luchador != null)
                        {
                            luchador.pm -= pm_utilizados;
                        }

                        if (id_entidad == personaje.id)
                        {
                            cuenta.pelea.get_Movimiento_Exito();
                        }
                    }
                    break;

                case 181:     //efecto de invocacion (pelea)
                    short celda       = short.Parse(separador[3].Substring(1));
                    short id_luchador = short.Parse(separador[6]);
                    short vida        = short.Parse(separador[15]);
                    byte  pa          = byte.Parse(separador[16]);
                    byte  pm          = byte.Parse(separador[17]);
                    byte  equipo      = byte.Parse(separador[25]);

                    cuenta.pelea.get_Agregar_Luchador(new Luchadores(id_luchador, true, vida, pa, pm, celda, vida, equipo, id_entidad));
                    break;

                case 302:
                case 300:     //hechizo lanzado con exito
                    if (id_entidad == cuenta.juego.personaje.id)
                    {
                        cuenta.pelea.get_Hechizo_Lanzado();
                    }
                    break;

                case 501:
                    int   tiempo_recoleccion   = int.Parse(separador[3].Split(',')[1]);
                    short celda_id             = short.Parse(separador[3].Split(',')[0]);
                    byte  tipo_gkk_recoleccion = byte.Parse(separador[0]);

                    await cuenta.juego.manejador.recoleccion.evento_Recoleccion_Iniciada(id_entidad, tiempo_recoleccion, celda_id, tipo_gkk_recoleccion);

                    break;

                case 900:
                    cuenta.conexion.enviar_Paquete("GA902" + id_entidad);
                    cuenta.logger.log_informacion("INFORMACIÓN", "Desafio del personaje id: " + id_entidad + " cancelado");
                    break;
                }
            }
            else
            {
                if (!cuenta.esta_luchando())
                {
                    await cuenta.juego.manejador.movimientos.evento_Movimiento_Finalizado(null, 0, false);
                }
            }
        }
Exemplo n.º 8
0
 abstract internal Task <ResultadosAcciones> proceso(Cuenta cuenta);
Exemplo n.º 9
0
 public PersonajeApi(Cuenta _cuenta) => cuenta = _cuenta;
Exemplo n.º 10
0
        private void Grabar()
        {
            try
            {
                NegocioMesa me   = new NegocioMesa();
                Mesa        mesa = me.buscarMesa(int.Parse(lblMesa.Text.ToString()));

                mesa._llegada = horaLlegada.ToString();
                mesa._estadia = tiempoEstadia.ToString();
                mesa._estado  = 2;
                me.modificarMesa(mesa);



                NegocioProducto prod = new NegocioProducto();
                NegocioCuenta   cu   = new NegocioCuenta();
                int             contadorDeCuentas = 0;
                foreach (TabPage item in tcCuentas.TabPages)
                {
                    Cuenta cuen  = new Cuenta();
                    int    fecha = int.Parse(DateTime.Now.Hour.ToString());
                    int    hora  = int.Parse(DateTime.Now.Minute.ToString());
                    int    mill  = int.Parse(DateTime.Now.Second.ToString());
                    int    ver   = fecha * hora * mill;
                    cuen._ID_Cuenta = ver + contadorDeCuentas;
                    cuen._Mesa      = mesa._ID_Mesa;
                    cuen._nombre    = item.Text;
                    cuen._expirada  = 1;
                    cu.insertarCuenta(cuen);

                    TabPage                tab    = item;
                    string                 nombre = tab.Name.ToString();
                    Control[]              ctl    = tab.Controls.Find("dgv" + nombre, false);
                    DataGridView           dgv    = (DataGridView)ctl[0];
                    NegocioCuenta_Producto cue    = new NegocioCuenta_Producto();
                    int contadorDeCuePro          = 0;
                    int numerodefilas             = dgv.Rows.Count;

                    foreach (DataGridViewRow item2 in dgv.Rows)
                    {
                        Cuenta_Producto cp = new Cuenta_Producto();

                        if (contadorDeCuePro < numerodefilas)
                        {
                            cp           = new Cuenta_Producto();
                            cp._ID_Lista = ver + contadorDeCuentas * contadorDeCuePro;
                            cp._Cuenta   = cuen._ID_Cuenta;
                            string   nompro = dgv["Column2" + nombre, item2.Index].Value.ToString();
                            Producto pro    = prod.buscarProductoxnombre(nompro);
                            cp._producto    = pro._ID_Producto;
                            cp._observacion = (string)dgv[5, item2.Index].Value;
                            cp._cantidad    = int.Parse(dgv["Column3" + nombre, item2.Index].Value.ToString());
                            cp._expirada    = 1;
                            cue.insertarCuenta_Producto(cp);
                            contadorDeCuePro++;
                        }
                        contadorDeCuentas++;
                    }
                }

                NegocioPedido pe   = new NegocioPedido();
                Pedido        pedi = new Pedido();
                pedi._ID_Pedido = we * int.Parse(DateTime.Now.Millisecond.ToString());
                pedi._Mesa      = int.Parse(lblMesa.Text);
                string         garxon = lblGarzon.Text;
                NegocioUsuario usu    = new NegocioUsuario();
                Usuario        usua   = usu.buscarUsuarioxnombre(garxon);
                pedi._Garzon    = usua._nombre;
                pedi._expirado  = 1;
                lblComanda.Text = pedi._ID_Pedido + "";
                pe.insertarPedido(pedi);
            }
            catch {
                MessageBox.Show("Hubo un error al intentar guardar la comanda. Porfavor verifique que" +
                                "todos los datos fueron ingresados correctamente.", "Error de comanda", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Exemplo n.º 11
0
        public Cuenta Traer(int idCliente)
        {
            Cuenta result = mapper.Traer(idCliente);

            return(result);
        }
Exemplo n.º 12
0
        public void inicio()
        {
            try
            {
                _iMaster.RolesUsuario = "";
                String rolUsuario = HttpContext.Current.Session[RecursosInterfazMaster.sessionRol].ToString();
                Boolean permitido = false;
                List<String> rolesPermitidos = new List<string>
                    (new string[] { RecursosInterfazMaster.rolSistema, RecursosInterfazMaster.rolDojo });
                foreach (String rol in rolesPermitidos)
                {
                    if (rol == rolUsuario)
                        permitido = true;
                }
                if (permitido)
                {

                    if (HttpContext.Current.Request.QueryString[RecursosInterfazPresentadorM2.parametroIDUsuario] != null)
                    {
                        idUsuarioURL = cripto.DesencriptarCadenaDeCaracteres
                             (HttpContext.Current.Request.QueryString[RecursosInterfazPresentadorM2.parametroIDUsuario], RecursosInterfazPresentadorM2.claveDES);
                        cuentaComando.Id = int.Parse(idUsuarioURL);
                        ComandoCuentaUsuario cuentaConsultada = (ComandoCuentaUsuario)laFabrica.ObtenerCuentaUsuario();
                        cuentaConsultada.LaEntidad = cuentaComando;
                        cuenta =(Cuenta)cuentaConsultada.Ejecutar();
                        rolesDePersona = cuenta.Roles;
                    }
                    List<Rol> rolesDePersonaE = rolesDePersona;
                    rolSinPermiso = validaciones.rolNoEditable(rolesDePersonaE,
                            HttpContext.Current.Session[RecursosInterfazMaster.sessionRol].ToString());
                    rolesDePersona = validaciones.validarPrioridad(rolesDePersona,
                        HttpContext.Current.Session[RecursosInterfazMaster.sessionRol].ToString());
                    ComandoRolesDeSistema rolesSistema = (ComandoRolesDeSistema)laFabrica.ObtenerRolesDeSistema();
                    losRolesDeSistema = rolesSistema.Ejecutar();
                    rolesFiltrados = validaciones.filtrarRoles(rolesDePersona, losRolesDeSistema);
                    rolesFiltrados = validaciones.validarPrioridad(rolesFiltrados,
                        HttpContext.Current.Session[RecursosInterfazMaster.sessionRol].ToString());

                    //asigno la imagen del perfil
                    if (cuenta.Imagen == "")
                        _iMaster.ImagenEtqSRC = RecursosInterfazPresentadorM2.imgDefault;
                    else
                        _iMaster.ImagenEtqSRC= _iMaster.ImagenEtqSRC + cuenta.Imagen;

                }
                else
                {
                    HttpContext.Current.Response.Redirect(RecursosInterfazMaster.direccionMaster_Inicio);
                }

                RolesUsuario(rolSinPermiso,RecursosInterfazPresentadorM2.informacionCat);
                RolesUsuario(rolesDePersona, RecursosInterfazPresentadorM2.eliminarCat);
                RolesUsuario(rolesFiltrados, RecursosInterfazPresentadorM2.agregarCat);

            }
            catch (NullReferenceException ex)
            {
                HttpContext.Current.Response.Redirect(RecursosInterfazPresentadorM1.direccionM1_Index);
            }
        }
 private Transferencia CreateTransferencia(Cuenta destino)
 {
     Transferencia trans = new Transferencia();
     trans.tipo_moneda = Convert.ToInt32(cmbMoneda.SelectedValue);
     trans.fecha = Utils.fechaSistema;
     trans.cuenta_origen = Convert.ToInt64(cmbCuentaOrigen.SelectedValue);
     trans.cuenta_destino = (long)destino.id;
     trans.costo = (destino.codigoCliente == cliente.id) ? 0 :new DAOTipoCuenta().costo_transaccion(Convert.ToInt64(cmbCuentaOrigen.SelectedValue));
     trans.importe = Convert.ToDouble(txtImporte.Text);
     return trans;
 }
Exemplo n.º 14
0
        public async Task <IActionResult> AnalsisVertical(int?Anual)
        {
            var            user = this.User;
            List <Usuario> u    = _context.Users.Include(e => e.Idempresa).Where(e => e.UserName == user.Identity.Name).ToList();

            if (u[0].Idempresa != null)
            {
                //recupero el catalogo de la empresa del usuario
                var proyAnfContext = _context.Valoresdebalance.Where(y => y.Idempresa == u[0].Idempresa.Idempresa);
                if (proyAnfContext.Any())
                {
                    if (Anual == null)
                    {
                        Anual = proyAnfContext.FirstOrDefault().Anio;
                    }
                    List <Valoresdebalance> pasivo1 = new List <Valoresdebalance>();

                    List <Valoresdebalance> activo1 = new List <Valoresdebalance>();

                    string mensajeVirtud     = "";
                    string mensajeNegativo   = "";
                    string mensajeSugerencia = "";
                    double suma1             = 0;
                    double suma2             = 0;
                    Cuenta cuentaAct1Max     = new Cuenta();
                    double valorAct1Max      = 0;
                    Cuenta cuentaPas1Max     = new Cuenta();
                    double valorPas1Max      = 0;
                    Cuenta cuentaAct1Min     = new Cuenta();
                    double valorAct1Min      = 0;
                    Cuenta cuentaPas1Min     = new Cuenta();
                    double valorPas1Min      = 0;


                    List <Catalogodecuenta> cuentas = _context.Catalogodecuenta.Include(r => r.IdcuentaNavigation).Where(y => y.Idempresa == u[0].Idempresa.Idempresa).ToList();
                    int cuen = proyAnfContext.Where(x => x.Id.IdcuentaNavigation.Nomcuenta == "TOTAL ACTIVO" && x.Anio == Anual).FirstOrDefault().Idcuenta;

                    List <int>       Anos      = new List <int>();
                    List <Cuenta>    cuentasU  = _context.Cuenta.ToList();
                    Valoresdebalance chance    = new Valoresdebalance();
                    var duplicado              = cuentas.Where(l => l.Codcuentacatalogo != "0");
                    Valoresdebalance        lv = new Valoresdebalance();
                    List <Valoresdebalance> vb = new List <Valoresdebalance>();
                    foreach (Catalogodecuenta cs in cuentas)
                    {
                        lv = proyAnfContext.Where(l => l.Idcuenta == cs.Idcuenta && l.Anio == Anual).FirstOrDefault();
                        if (lv != null)
                        {
                            vb.Add(lv);
                        }
                    }
                    double cuentala             = proyAnfContext.Where(x => x.Idcuenta == cuen).FirstOrDefault().Valorcuenta;
                    List <Valoresdebalance> AH1 = proyAnfContext.Include(x => x.Id.IdcuentaNavigation).Where(s => s.Anio == Anual).OrderBy(r => r.Id.IdcuentaNavigation.Nomcuenta).ToList();

                    /*
                     * //recupero usuario
                     * var user = this.User;
                     * List<Usuario> u = _context.Users.Include(e => e.Idempresa).Where(e => e.UserName == user.Identity.Name).ToList();
                     * //recupero el catalogo de la empresa del usuario
                     * List<Catalogodecuenta> cuentas = _context.Catalogodecuenta.Include(r => r.IdcuentaNavigation).Where(y => y.Idempresa == u[0].Idempresa.Idempresa).ToList();
                     * //busco el catalogo  que no sean totales por su id  diferente de 0
                     * List<Catalogodecuenta> cuentis = cuentas.Where(z => z.Codcuentacatalogo != "0").ToList();
                     * //para guardar el nombre de las cuentas
                     * List<string> xc = new List<string>();
                     * //contexto de  cuenta
                     * var cuenta = from x in _context.Cuenta select x;
                     * // contexto de balance general de la empresa del usuario loggeado
                     * var proyAnfContext = _context.Valoresdebalance.Where(y => y.Idempresa == u[0].Idempresa.Idempresa);
                     * //recupero el primer año de los balances
                     * int an = proyAnfContext.FirstOrDefault().Anio;
                     * //busco los balances con el primer año
                     * proyAnfContext = proyAnfContext.Where(y => y.Anio == an);
                     * //consigo la cuenta de nombre Total activo de  la empresa
                     *
                     * //Guardo el valor en balance de la cuenta total activo
                     * double activoTotal = proyAnfContext.Where(x => x.Idcuenta == cuentala.Idcuenta).FirstOrDefault().Valorcuenta;
                     * // filtro las nombres de la cuentas que peretenecen al balance de la empresa
                     * foreach (var aw in proyAnfContext)
                     * {
                     *
                     *  xc.Add(cuenta.Where(x => x.Idcuenta == aw.Idcuenta).FirstOrDefault().Nomcuenta);
                     * }
                     * //envìo el total y el nombre a la vista
                     * ViewBag.activo = Math.Round( activoTotal);
                     *
                     */
                    //òpniones
                    foreach (var dato in AH1)
                    {
                        if (dato.Id.Codcuentacatalogo.StartsWith("1"))
                        {
                            activo1.Add(dato);
                        }
                        if (dato.Id.Codcuentacatalogo.StartsWith("2"))
                        {
                            pasivo1.Add(dato);
                        }
                    }
                    chance        = activo1.OrderBy(r => r.Valorcuenta).LastOrDefault();
                    cuentaAct1Max = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                    valorAct1Max  = chance.Valorcuenta;
                    chance        = activo1.OrderBy(r => r.Valorcuenta).FirstOrDefault();
                    cuentaAct1Min = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                    valorAct1Min  = chance.Valorcuenta;
                    //pasivo minimo 1
                    chance        = pasivo1.OrderBy(r => r.Valorcuenta).FirstOrDefault();
                    cuentaPas1Min = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                    valorPas1Min  = chance.Valorcuenta;
                    //
                    chance        = pasivo1.OrderBy(r => r.Valorcuenta).LastOrDefault();
                    cuentaPas1Max = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                    valorPas1Max  = chance.Valorcuenta;

                    mensajeVirtud = "Su activo de mayor provecho es la cuenta: " + cuentaAct1Max.Nomcuenta + " siendo la cuenta que produce mayor ganancia con un valor de $" + valorAct1Max +
                                    " por su contraparte, la empresa se ve afectada por gastos mayormente ocasiones por: " + cuentaPas1Max.Nomcuenta + ", cuenta que tiene un saldo de: " + valorPas1Max
                    ;

                    ViewBag.activo       = cuentala;
                    ViewBag.year         = Anual;
                    ViewBag.cuentas      = vb;
                    ViewBag.mensajebueno = mensajeVirtud;
                    var xs = proyAnfContext.GroupBy(x => x.Anio).Select(x => new { Anio = x.Key, Buildings = x.Count() });



                    ViewData["Anios"] = new SelectList(xs, "Anio", "Anio");
                    ViewBag.existe    = true;
                }
                else
                {
                    ViewBag.existe = false;
                }
                ViewBag.noexiste = false;
                return(View(await proyAnfContext.ToListAsync()));
            }
            else
            {
                ViewBag.noexiste = true;
                var proyAnfContext = _context.Valoresdebalance;
                return(View(await proyAnfContext.ToListAsync()));
            }
        }
Exemplo n.º 15
0
        public async Task <IActionResult> AnalsisHorizontal(int?ana1, int?ana2)

        {
            var            user = this.User;
            List <Usuario> u    = _context.Users.Include(e => e.Idempresa).Where(e => e.UserName == user.Identity.Name).ToList();

            if (u[0].Idempresa != null)
            {
                var proyAnfContext = _context.Valoresdebalance.Where(x => x.Idempresa == u[0].Idempresa.Idempresa);
                if (proyAnfContext.Any())
                {
                    var xs = proyAnfContext.GroupBy(x => x.Anio).Select(x => new { Anio = x.Key, Buildings = x.Count() });
                    if (xs.Count() >= 2)
                    {
                        List <Catalogodecuenta> cuentas  = _context.Catalogodecuenta.Include(r => r.IdcuentaNavigation).Where(y => y.Idempresa == u[0].Idempresa.Idempresa).ToList();
                        List <Cuenta>           cuentasU = _context.Cuenta.ToList();
                        if (ana1 == null || ana2 == null)
                        {
                            ana1 = proyAnfContext.FirstOrDefault().Anio;
                            ana2 = ana1 - 1;
                        }
                        List <Valoresdebalance> AH1     = proyAnfContext.Include(x => x.Id.IdcuentaNavigation).Where(s => s.Anio == ana1).OrderBy(r => r.Id.IdcuentaNavigation.Nomcuenta).ToList();
                        List <Valoresdebalance> AH2     = proyAnfContext.Include(x => x.Id.IdcuentaNavigation).Where(s => s.Anio == ana2).OrderBy(r => r.Id.IdcuentaNavigation.Nomcuenta).ToList();
                        List <Valoresdebalance> vb      = new List <Valoresdebalance>();
                        List <Valoresdebalance> pasivo1 = new List <Valoresdebalance>();
                        List <Valoresdebalance> pasivo2 = new List <Valoresdebalance>();
                        List <Valoresdebalance> activo1 = new List <Valoresdebalance>();
                        List <Valoresdebalance> activo2 = new List <Valoresdebalance>();
                        Valoresdebalance        chance  = new Valoresdebalance();
                        string                             mensajeVirtud     = "";
                        string                             mensajeNegativo   = "";
                        string                             mensajeSugerencia = "";
                        double                             suma1             = 0;
                        double                             suma2             = 0;
                        Cuenta                             cuentaAct1Max     = new Cuenta();
                        double                             valorAct1Max      = 0;
                        Cuenta                             cuentaPas1Max     = new Cuenta();
                        double                             valorPas1Max      = 0;
                        Cuenta                             cuentaAct2Max     = new Cuenta();
                        double                             valorAct2Max      = 0;
                        Cuenta                             cuentaPas2Max     = new Cuenta();
                        double                             valorPas2Max      = 0;
                        Cuenta                             cuentaAct1Min     = new Cuenta();
                        double                             valorAct1Min      = 0;
                        Cuenta                             cuentaPas1Min     = new Cuenta();
                        double                             valorPas1Min      = 0;
                        Cuenta                             cuentaAct2Min     = new Cuenta();
                        double                             valorAct2Min      = 0;
                        Cuenta                             cuentaPas2Min     = new Cuenta();
                        double                             valorPas2Min      = 0;
                        Valoresdebalance                   lv  = new Valoresdebalance();
                        List <Valoresdebalance>            vb1 = new List <Valoresdebalance>();
                        Valoresdebalance                   lv1 = new Valoresdebalance();
                        List <AnalisisHorizontalViewModel> anV = new List <AnalisisHorizontalViewModel>();
                        foreach (Catalogodecuenta cs in cuentas)
                        {
                            lv = proyAnfContext.Where(l => l.Idcuenta == cs.Idcuenta && l.Anio == ana1).FirstOrDefault();
                            if (lv != null)
                            {
                                vb.Add(lv);
                            }
                        }
                        foreach (Catalogodecuenta cs in cuentas)
                        {
                            lv1 = proyAnfContext.Where(l => l.Idcuenta == cs.Idcuenta && l.Anio == ana2).FirstOrDefault();
                            if (lv1 != null)
                            {
                                vb1.Add(lv);
                            }
                        }
                        for (int i = 0; i < vb1.Count(); i++)
                        {
                            AnalisisHorizontalViewModel analiHorizon = new AnalisisHorizontalViewModel()
                            {
                                nombreCuenta    = AH1[i].Id.IdcuentaNavigation.Nomcuenta,
                                anio1           = (int)ana1,
                                anio2           = (int)ana2,
                                valorAnio1      = AH1[i].Valorcuenta,
                                valorAnio2      = AH2[i].Valorcuenta,
                                valorhorizontal = AH1[i].Valorcuenta - AH2[i].Valorcuenta
                            };

                            anV.Add(analiHorizon);
                        }

                        //calculo  para opinar
                        foreach (var dato in AH1)
                        {
                            if (dato.Id.Codcuentacatalogo.StartsWith("1"))
                            {
                                activo1.Add(dato);
                            }
                            if (dato.Id.Codcuentacatalogo.StartsWith("2"))
                            {
                                pasivo1.Add(dato);
                            }
                        }
                        foreach (var dato in AH2)
                        {
                            if (dato.Id.Codcuentacatalogo.StartsWith("1"))
                            {
                                activo2.Add(dato);
                            }
                            if (dato.Id.Codcuentacatalogo.StartsWith("2"))
                            {
                                pasivo2.Add(dato);
                            }
                        }
                        activo1 = activo1.OrderBy(r => r.Id.IdcuentaNavigation.Nomcuenta).ToList();
                        activo2 = activo2.OrderBy(r => r.Id.IdcuentaNavigation.Nomcuenta).ToList();
                        List <AV> valor = new List <AV>();
                        for (int i = 0; i < activo1.Count(); i++)
                        {
                            valor.Add(new AV
                            {
                                cuenta1    = activo1[i],
                                cuenta2    = activo2[i],
                                diferencia = activo1[i].Valorcuenta - activo2[i].Valorcuenta
                            });;
                        }
                        valor = valor.OrderBy(x => x.diferencia).ToList();



                        suma1 = activo1.Sum(r => r.Valorcuenta);
                        suma2 = activo2.Sum(r => r.Valorcuenta);
                        //activo maximo 1
                        chance        = activo1.OrderBy(r => r.Valorcuenta).LastOrDefault();
                        cuentaAct1Max = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                        valorAct1Max  = chance.Valorcuenta;
                        //activo maximo 2
                        chance        = activo2.OrderBy(r => r.Valorcuenta).LastOrDefault();
                        cuentaAct2Max = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                        valorAct2Max  = chance.Valorcuenta;
                        //activo minimo 1

                        chance        = activo1.OrderBy(r => r.Valorcuenta).FirstOrDefault();
                        cuentaAct1Min = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                        valorAct1Min  = chance.Valorcuenta;
                        //activo minimo 2
                        chance        = activo2.OrderBy(r => r.Valorcuenta).FirstOrDefault();
                        cuentaAct2Min = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                        valorAct2Min  = chance.Valorcuenta;
                        //pasivo maximo 1
                        chance        = pasivo1.OrderBy(r => r.Valorcuenta).LastOrDefault();
                        cuentaPas1Max = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                        valorPas1Max  = chance.Valorcuenta;
                        //pasivo maximo 2
                        chance = pasivo2.OrderBy(r => r.Valorcuenta).LastOrDefault();

                        cuentaPas2Max = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                        valorPas2Max  = chance.Valorcuenta;
                        //pasivo minimo 1
                        chance = pasivo1.OrderBy(r => r.Valorcuenta).FirstOrDefault();

                        cuentaPas1Min = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                        valorPas1Min  = chance.Valorcuenta;
                        //pasivo minimo 2
                        chance        = pasivo2.OrderBy(r => r.Valorcuenta).FirstOrDefault();
                        cuentaPas2Min = cuentasU.Where(x => x.Idcuenta == chance.Idcuenta).FirstOrDefault();
                        valorPas2Min  = chance.Valorcuenta;
                        //opinando como licenciado
                        int    cuen      = proyAnfContext.Where(l => l.Id.IdcuentaNavigation.Nomcuenta == "TOTAL ACTIVO" && l.Anio == ana1).FirstOrDefault().Idcuenta;
                        int    cuen2     = proyAnfContext.Where(x => x.Id.IdcuentaNavigation.Nomcuenta == "TOTAL ACTIVO" && x.Anio == ana2).FirstOrDefault().Idcuenta;
                        double cuentala  = proyAnfContext.Where(x => x.Idcuenta == cuen).FirstOrDefault().Valorcuenta;
                        double cuentala2 = proyAnfContext.Where(x => x.Idcuenta == cuen2).FirstOrDefault().Valorcuenta;
                        double totalpor  = Math.Abs(((cuentala - cuentala2) / cuentala) * 100);
                        //Opinión a favor
                        if (cuentala > cuentala2)
                        {
                            if (totalpor > 10)
                            {
                                mensajeVirtud = mensajeVirtud + "Su Total de activo aumentó un " + totalpor + "% en comparación al año " + ana2;
                            }
                            else
                            {
                                mensajeVirtud = mensajeVirtud + "Su Total de activo tuvo un pequeño aumento del " + totalpor + "% en comparación al año " + ana2;
                            }
                        }
                        else if (cuentala < cuentala2)
                        {
                            if (totalpor >= 20 || totalpor <= 40)
                            {
                                mensajeVirtud = mensajeVirtud + "Su Total activo disminuyó considerablemente un  " + totalpor + "% en comparación al año " + ana2;
                            }
                            else if (totalpor > 40)
                            {
                                mensajeVirtud = mensajeVirtud + "Su Total de activo disminuyó drasticamente un  " + totalpor + "% en comparación al año " + ana2;
                            }
                            else
                            {
                                mensajeVirtud = mensajeVirtud + "Su Total de activo disminuyó un " + totalpor + "% en comparación al año " + ana2;
                            }
                        }
                        else
                        {
                            mensajeVirtud = mensajeVirtud + "Su Total de activo se mantuvo intacto " + totalpor + "% en comparación al año " + ana2;
                        }

                        mensajeVirtud = mensajeVirtud + " El mayor aumento de activos fue con la cuenta " + valor.LastOrDefault().cuenta1.Id.IdcuentaNavigation.Nomcuenta
                                        + " con un aumento de " + Math.Abs(Math.Round(valor.LastOrDefault().diferencia, 2)) + " mientras que la mayor disminución en los activos fue " +
                                        valor.FirstOrDefault().cuenta1.Id.IdcuentaNavigation.Nomcuenta + " reduciendo $" + Math.Abs(Math.Round(valor.FirstOrDefault().diferencia, 2)) +
                                        " del año " + ana2;



                        ViewData["Anios"]    = new SelectList(xs, "Anio", "Anio");
                        ViewBag.mensajebueno = mensajeVirtud;
                        ViewBag.mensajemalo  = mensajeNegativo;
                        ViewBag.mensajemeh   = mensajeSugerencia;
                        ViewData["todo"]     = anV;
                        ViewData["an1"]      = ana1;
                        ViewData["an2"]      = ana2;
                        ViewBag.existe       = true;
                    }
                    else
                    {
                        ViewBag.existe = false;
                    }
                }
                else
                {
                    ViewBag.existe = false;
                }
                ViewBag.nocuenta = false;
                return(View(await proyAnfContext.ToListAsync()));
            }
            else
            {
                ViewBag.nocuenta = true;
                var proyAnfContext = _context.Valoresdebalance;
                return(View(await proyAnfContext.ToListAsync()));
            }
        }
Exemplo n.º 16
0
 // Token: 0x06000236 RID: 566 RVA: 0x00009D79 File Offset: 0x00008179
 public void eliminar_Miembro(Cuenta miembro)
 {
     this.miembros.Remove(miembro);
 }
Exemplo n.º 17
0
 // Token: 0x0600023B RID: 571 RVA: 0x00009F5D File Offset: 0x0000835D
 private void miembro_Acciones_Acabadas(Cuenta cuenta)
 {
     cuenta.logger.log_informacion("GRUPO", "Acciones acabadas");
     this.cuentas_acabadas[cuenta].Set();
 }
Exemplo n.º 18
0
        /// <summary>
        /// Ver descripción en clase base.
        /// </summary>
        /// <param name="cuenta">
        /// El objeto cuyos datos se muestran en el panel.
        /// </param>  
        public void setObjeto(Cuenta cuenta)
        {
            try {
                _cuenta = cuenta;

                if (_cuenta.Titular != null) {
                    _titular = _cuenta.Titular;
                    txtTitular.Text = _titular.ToString();
                    tabPagTitular.Enabled = true;
                    cargarComboTitular();
                    cargarDatosTitular();
                    btnVerTitular.Enabled = true;
                    btnEditTitular.Enabled = true;
                    btnVerCtoTitular.Enabled = true;
                    btnEditCtoTitular.Enabled = true;
                } else {
                    _titular = null;
                    txtTitular.Clear();
                    tabPagTitular.Enabled = false;
                    btnVerTitular.Enabled = false;
                    btnEditTitular.Enabled = false;
                    btnVerCtoTitular.Enabled = false;
                    btnEditCtoTitular.Enabled = false;
                }

                if (_cuenta.Garante != null) {
                    _garante = _cuenta.Garante;
                    txtGarante.Text = _garante.ToString();
                    tabPagGarante.Enabled = true;
                    cargarComboGarante();
                    cargarDatosGarante();
                    btnVerGarante.Enabled = true;
                    btnEditGarante.Enabled = true;
                    btnVerCtoGte.Enabled = true;
                    btnEditCtoGte.Enabled = true;
                } else {
                    _garante = null;
                    txtGarante.Clear();
                    tabPagGarante.Enabled = false;
                    btnVerGarante.Enabled = false;
                    btnEditGarante.Enabled = false;
                    btnVerCtoGte.Enabled = false;
                    btnEditCtoGte.Enabled = false;
                }
            } catch (Exception e) {
                throw new DataErrorException("DATA-SETNOK", e.ToString());
            }
        }
        private void Guardarbutton_Click(object sender, EventArgs e)
        {
            Cuenta c = new Cuenta(NombretextBox.Text, ApellidotextBox.Text, Convert.ToInt32(NumerotextBox.Text));

            richTextBox2.Text = c.Imprimir();
        }
Exemplo n.º 20
0
        public void get_Mapa_Cambiado(ClienteTcp cliente, string paquete)
        {
            Cuenta cuenta = cliente.cuenta;

            cuenta.juego.mapa.get_Evento_Mapa_Cambiado();
        }
Exemplo n.º 21
0
        public async Task <ActionResult <Cuenta> > PostCuenta(Cuenta cuenta)
        {
            await _cuentaRepository.PostCuentaAsync(cuenta);

            return(CreatedAtAction("GetCuenta", new { id = cuenta.Id }, cuenta));
        }
Exemplo n.º 22
0
        public bool ExisteLaCuenta(Cuenta cuenta)
        {
            List <Cuenta> cuentas = TraerCuentas();

            return(cuentas.Any(c => c.Equals(cuenta)));
        }
 private void volcarDatosCliente(Cuenta cuenta)
 {
     update = true;
     cbEstado.Items.Clear();
     cbEstado.Items.AddRange(new DAOEstadoCuenta().retrieveBase().ToArray());
     tbNroCuenta.Text = cuenta.numCuenta.ToString();
     dtFechaApertura.Value = (DateTime)cuenta.fechaCreacion;
     cbEstado.SelectedItem = new DAOEstadoCuenta().retrieveBase().Find(e => e.id == cuenta.estado);
     cbPais.SelectedItem = new DAOPais().retrieveBase().Find(p => p.id == cuenta.pais);
     cbMoneda.SelectedItem = new DAOMoneda().retrieveBase().Find(m => m.id == cuenta.tipoMoneda);
     cbTipoCuenta.SelectedItem = new DAOTipoCuenta().retrieveBase().Find(c => c.id == cuenta.tipoCuenta);
     tbSaldo.Text = cuenta.saldo.ToString();
 }
 /*
  * public IEnumerable<CuentaModels> ListCuentas()
  * {
  *  try
  *  {//Invocamos al método listar de la capa negocio "Data.Business"
  *      return Cuenta.ListCuentas();
  *  }
  *  catch (Exception ex)
  *  {
  *      throw new Exception(ex.Message);
  *  }
  * }
  */
 public static CuentaModels InsertarCuenta(CuentaModels cm)
 {
     return(Cuenta.InsertarCuenta(cm));
 }
 public Boolean cambiarEstadoCuenta(Cuenta c)
 {
     int value = DBAdapter.executeProcedureWithReturnValue("cambiarEstadoCuenta", c.ID, c.EstadoCuenta.Id);
     return value == 1;
 }
 public static float ConsultaSaldo(String Id)
 {
     return(Cuenta.ConsultaSaldo(Id));
 }
Exemplo n.º 27
0
 public ManejadorHechizos(Cuenta _cuenta) => cuenta = _cuenta;
Exemplo n.º 28
0
 public PeleaApi(Cuenta _cuenta, ManejadorAcciones _manejador_acciones)
 {
     cuenta             = _cuenta;
     manejador_acciones = _manejador_acciones;
 }
Exemplo n.º 29
0
 public void UpdateCuenta(Cuenta cuenta)
 {
     _unitOfWork.CuentaRepository.Update(cuenta);
     _unitOfWork.SaveChangesAsync();
 }
Exemplo n.º 30
0
        public static Asiento nuevoAsiento(Libro l, Asiento a)
        {
            Console.WriteLine("\nIngrese la fecha en formato dd-MM-yyyy :\n");
            a.Fecha = ValidarFecha(Console.ReadLine());

            Console.WriteLine("\nA continuación se cargarán las cuentas en el DEBE:\n");
            Console.WriteLine("\nIngrese el código de cuenta:\n");

            Cuenta cuenta = ValidarCode(l.Cuentas, Console.ReadLine());

            Console.WriteLine("\nIngrese el monto:\n");
            int monto = Validar(Console.ReadLine());

            cuenta.Monto = monto;
            a.Debe      += monto;
            a.CuentasDebe.Add(cuenta);
            Console.WriteLine("\n¿Desea cargar otra cuenta al DEBE?\n");
            Console.WriteLine("S -Si\n");
            Console.WriteLine("N -No\n");
            Boolean seguir = ValidarYN(Console.ReadLine());

            while (seguir)
            {
                Console.WriteLine("\nIngrese el código de cuenta:\n");
                cuenta = ValidarCode(l.Cuentas, Console.ReadLine());
                Console.WriteLine("\nIngrese el monto:\n");
                monto        = Validar(Console.ReadLine());
                cuenta.Monto = monto;
                a.Debe      += monto;
                a.CuentasDebe.Add(cuenta);
                Console.WriteLine("\n¿Desea cargar otra cuenta al DEBE?\n");
                Console.WriteLine("S -Si\n");
                Console.WriteLine("N -No\n");
                seguir = ValidarYN(Console.ReadLine());
            }

            Console.WriteLine("\nA continuación se cargarán las cuentas en el HABER:\n");
            Console.WriteLine("\nIngrese el código de cuenta:\n");
            cuenta = ValidarCode(l.Cuentas, Console.ReadLine());
            Console.WriteLine("\nIngrese el monto:\n");
            monto        = Validar(Console.ReadLine());
            a.Haber     += monto;
            cuenta.Monto = monto;
            a.CuentasHaber.Add(cuenta);
            Console.WriteLine("\n¿Desea cargar otra cuenta al HABER?\n");
            Console.WriteLine("S -Si\n");
            Console.WriteLine("N -No\n");
            Boolean seguir2 = ValidarYN(Console.ReadLine());

            while (seguir2)
            {
                Console.WriteLine("\nIngrese el código de cuenta:\n");
                cuenta = ValidarCode(l.Cuentas, Console.ReadLine());
                Console.WriteLine("\nIngrese el monto:\n");
                monto        = Validar(Console.ReadLine());
                a.Haber     += monto;
                cuenta.Monto = monto;
                a.CuentasHaber.Add(cuenta);
                Console.WriteLine("\n¿Desea cargar otra cuenta al HABER?\n");
                Console.WriteLine("S -Si\n");
                Console.WriteLine("N -No\n");
                seguir2 = ValidarYN(Console.ReadLine());
            }

            return(a);
        }
Exemplo n.º 31
0
 // Constructor
 internal InventarioGeneral(Cuenta _cuenta)
 {
     cuenta   = _cuenta;
     _objetos = new ConcurrentDictionary <uint, ObjetosInventario>();
 }
Exemplo n.º 32
0
 public InventarioApi(Cuenta _cuenta, ManejadorAcciones _manejar_acciones)
 {
     cuenta           = _cuenta;
     manejar_acciones = _manejar_acciones;
 }
Exemplo n.º 33
0
        public ActionResult EjemploCaptcha()
        {
            Cuenta cuenta = new Cuenta();

            return(View("EjemploCaptcha", cuenta));
        }
Exemplo n.º 34
0
 public int insertarCuentas(Cuenta C)
 {
     return(adc.insertarCuentas(C));
 }
Exemplo n.º 35
0
        public async Task get_Movimientos_Personajes(ClienteTcp cliente, string paquete)
        {
            Cuenta cuenta = cliente.cuenta;

            string[] separador_jugadores = paquete.Substring(3).Split('|'), informaciones;
            string   _loc6, nombre_template, tipo;

            for (int i = 0; i < separador_jugadores.Length; ++i)
            {
                _loc6 = separador_jugadores[i];
                if (_loc6.Length != 0)
                {
                    informaciones = _loc6.Substring(1).Split(';');
                    if (_loc6[0].Equals('+'))
                    {
                        Celda celda = cuenta.juego.mapa.celdas[short.Parse(informaciones[0])];
                        int   id    = int.Parse(informaciones[3]);
                        nombre_template = informaciones[4];
                        tipo            = informaciones[5];
                        if (tipo.Contains(","))
                        {
                            tipo = tipo.Split(',')[0];
                        }

                        switch (int.Parse(tipo))
                        {
                        case -1:
                        case -2:
                            if (cuenta.Estado_Cuenta == EstadoCuenta.LUCHANDO)
                            {
                                int  vida   = int.Parse(informaciones[12]);
                                byte pa     = byte.Parse(informaciones[13]);
                                byte pm     = byte.Parse(informaciones[14]);
                                byte equipo = byte.Parse(informaciones[15]);

                                cuenta.pelea.get_Agregar_Luchador(new Luchadores(id, true, vida, pa, pm, celda.id, vida, equipo));
                            }
                            break;

                        case -3:    //monstruos
                            string[] templates = nombre_template.Split(',');
                            string[] niveles   = informaciones[7].Split(',');

                            Monstruo monstruo = new Monstruo(id, int.Parse(templates[0]), celda, int.Parse(niveles[0]));
                            monstruo.lider_grupo = monstruo;

                            for (int m = 1; m < templates.Length; ++m)
                            {
                                monstruo.moobs_dentro_grupo.Add(new Monstruo(id, int.Parse(templates[m]), celda, int.Parse(niveles[m])));
                            }

                            cuenta.juego.mapa.agregar_Entidad(monstruo);
                            break;

                        case -4:    //NPC
                            cuenta.juego.mapa.agregar_Entidad(new Npcs(id, int.Parse(nombre_template), celda));
                            break;

                        case -5:
                            break;

                        case -6:
                            break;

                        case -7:
                        case -8:
                            break;

                        case -9:
                            break;

                        case -10:
                            break;

                        default:    // jugador
                            if (cuenta.Estado_Cuenta != EstadoCuenta.LUCHANDO)
                            {
                                if (cuenta.juego.personaje.id != id)
                                {
                                    if (nombre_template.StartsWith("[") || Extensiones.lista_mods.Contains(nombre_template))
                                    {
                                        cuenta.conexion.get_Desconectar_Socket();
                                    }

                                    cuenta.juego.mapa.agregar_Entidad(new Personaje(id, nombre_template, byte.Parse(informaciones[7].ToString()), celda));
                                }
                                else
                                {
                                    cuenta.juego.personaje.celda = celda;
                                }
                            }
                            else
                            {
                                int  vida   = int.Parse(informaciones[14]);
                                byte pa     = byte.Parse(informaciones[15]);
                                byte pm     = byte.Parse(informaciones[16]);
                                byte equipo = byte.Parse(informaciones[24]);

                                cuenta.pelea.get_Agregar_Luchador(new Luchadores(id, true, vida, pa, pm, celda.id, vida, equipo));

                                if (cuenta.juego.personaje.id == id && cuenta.pelea_extension.configuracion.posicionamiento != PosicionamientoInicioPelea.INMOVIL)
                                {
                                    await Task.Delay(300);

                                    /** la posicion es aleatoria pero el paquete GP siempre aparecera primero el team donde esta el pj **/
                                    short celda_posicion = cuenta.pelea.get_Celda_Mas_Cercana_O_Lejana(cuenta.pelea_extension.configuracion.posicionamiento == PosicionamientoInicioPelea.CERCA_DE_ENEMIGOS, cuenta.pelea.celdas_preparacion, cuenta.juego.mapa);

                                    if (celda_posicion != celda.id)
                                    {
                                        cuenta.conexion.enviar_Paquete("Gp" + celda_posicion);
                                    }
                                    else
                                    {
                                        cuenta.conexion.enviar_Paquete("GR1");
                                    }
                                }
                                else if (cuenta.juego.personaje.id == id)
                                {
                                    await Task.Delay(300);

                                    cuenta.conexion.enviar_Paquete("GR1");    //boton listo
                                }
                            }
                            break;
                        }
                    }
                    else if (_loc6[0].Equals('-'))
                    {
                        if (cuenta.Estado_Cuenta != EstadoCuenta.LUCHANDO)
                        {
                            int id = int.Parse(_loc6.Substring(1));
                            cuenta.juego.mapa.eliminar_Entidad(id);
                        }
                    }
                }
            }
        }
Exemplo n.º 36
0
 public int editarCuentas(Cuenta C)
 {
     return(adc.editarCuentas(C));
 }
Exemplo n.º 37
0
        public void get_Reiniciar_Pantalla(ClienteTcp cliente, string paquete)
        {
            Cuenta cuenta = cliente.cuenta;

            cuenta.conexion.enviar_Paquete("GC1");
        }
Exemplo n.º 38
0
 public bool CrearCuenta(Cuenta pCuenta, string pXml)
 {
     return LogicaNegocio.Instancia.CrearCuenta(pCuenta, pXml);
 }
 public Boolean deshabilitarCuenta(Cuenta c)
 {
     c.EstadoCuenta = new Estado(2, "Deshabilitada");
     return cambiarEstadoCuenta(c);
 }
Exemplo n.º 40
0
		public static void AssertExists(Cuenta request, int id)
		{
			if( request== default(Cuenta))
				throw new HttpError(
						string.Format("No existe Cuenta con Id:'{0}'", id));			
		}
Exemplo n.º 41
0
        public ActionResult procesarExcel(string archivo)
        {
            var modelExcel      = new Models.ExcelModel();
            var modelMantenedor = new Models.MantenedorModel();
            var selectEmpresas  = "";
            var empresas        = modelMantenedor.obtenerEmpresas();
            var selectRubros    = "";
            var rubros          = modelMantenedor.obtenerRubros();
            var selectGrupos    = "";
            var grupos          = modelMantenedor.obtenerGrupos();

            foreach (Empresa fila in empresas)
            {
                selectEmpresas += "<option value='" + fila.empresaId + "'>" + fila.razonSocial + "</option>";
            }
            foreach (Rubro fila in rubros)
            {
                selectRubros += "<option value='" + fila.rubroId + "'>" + fila.rubroNombre + "</option>";
            }
            foreach (Grupo fila in grupos)
            {
                selectGrupos += "<option value='" + fila.grupoId + "'>" + fila.grupoNombre + "</option>";
            }

            List <Cuenta> cuentas;

            cuentas = modelExcel.ObtenerCuentas(HostingEnvironment.ApplicationPhysicalPath + "Archivos\\Temporal\\" + archivo);
            string html     = "";
            int    contador = 0;
            bool   errores  = false;

            foreach (Cuenta cuenta in cuentas)
            {
                contador++;
                Cuenta c = modelMantenedor.IngresarActualizarCuenta(cuenta, SessionHandler.UsuarioId);

                if (c.id == -1)
                {
                    html   += "<tr class='danger' id='" + contador + "'>";
                    errores = true;
                }
                else
                {
                    html += "<tr>";
                }



                html += "<td>" + contador + "</td>";
                html += "<td>" + c.numero + "</td>";
                html += "<td>" + c.nombre + "</td>";

                html += "<td>";
                if (c.empresa.empresaId == -1)
                {
                    html += "<select name='empresas' class='form-control' >";
                    html += "<option value=''>" + c.empresa.razonSocial + " (Valor Erroneo) </option>" + selectEmpresas;
                    html += "</select>";
                }
                else
                {
                    html += c.empresa.razonSocial;
                }
                html += "</td>";


                html += "<td>";
                if (c.rubro.rubroId == -1)
                {
                    html += "<select name='rubros' class='form-control' >";
                    html += "<option value=''>" + c.rubro.rubroNombre + " (Valor Erroneo) </option>" + selectRubros;
                    html += "</select>";
                }
                else
                {
                    html += c.rubro.rubroNombre;
                }
                html += "</td>";

                html += "<td>";
                if (c.grupo.grupoId == -1)
                {
                    html += "<select name='grupos' class='form-control' >";
                    html += "<option value=''>" + c.grupo.grupoNombre + " (Valor Erroneo) </option>" + selectGrupos;
                    html += "</select>";
                }
                else
                {
                    html += c.grupo.grupoNombre;
                }
                html += "</td>";


                html += "<td>" + c.descripcion + "</td>";
                html += "<td>";
                if (c.id == -1)
                {
                    html += "FALLIDO <i class='fa fa-times-circle danger'></i>";
                }
                else
                {
                    if (c.insertUpdate)
                    {
                        html += "INSERTADA  <i class='fa fa-plus-circle' style='color:#4f4' ></i>";
                    }
                    else
                    {
                        html += "ACTUALIZADA <i class='fa fa-check-circle' style='color:#4f4' ></i>";
                    }
                }
                html += "</td>";
                html += "</tr>";
            }



            return(Json(new { response = "success", tabla = html, errores = errores }, JsonRequestBehavior.AllowGet));
        }
Exemplo n.º 42
0
        /// <summary>
        /// Ver descripción en clase base.
        /// </summary> 
        public void setObjeto(Cuenta cuenta)
        {
            try {
                _cuenta = cuenta;
                _convenioActivo = _cuenta.ConvenioActivo;

                cargarDatos();
            } catch (Exception e) {
                throw new DataErrorException("DATA-SETNOK", e.ToString());
            }
        }
 public Boolean Guardar(clsCuenta cuenta)
 {
     try
      {
          using (EntitiesContabilidad ent =new EntitiesContabilidad())
          {
              Cuenta ct = new Cuenta() {
              IdEmpresa=cuenta.IdEmpresa,
              IdCuenta = cuenta.IdCuenta,
              codigo_padre = cuenta.codigo_padre,
              nombre = cuenta.nombre,
              descripcion = cuenta.descripcion,
              IdNivelCuenta = cuenta.IdNivelCuenta,
              IdTipoCuenta = cuenta.IdTipoCuenta,
              naturaleza_cuenta = cuenta.naturaleza_cuenta,
              IdUsuario = 1,
              //FechaModificacion = cuenta.IdEmpresa
              };
              ent.AddToCuenta(ct);
              ent.SaveChanges();
          }
          return true;
      }
      catch (Exception)
      {
          return false;
      }
 }
Exemplo n.º 44
0
 public Manejador(Cuenta cuenta, Mapa mapa, PersonajeJuego personaje)
 {
     movimientos  = new Movimiento(cuenta, mapa, personaje);
     recoleccion  = new Recoleccion(cuenta, movimientos, mapa);
     interactivos = new Interactivo(cuenta, mapa, movimientos);
 }
Exemplo n.º 45
0
 public bool CrearCuenta(Cuenta pCuenta, string pXml)
 {
     return _DataAccess.CrearCuenta(pCuenta, pXml);
 }
Exemplo n.º 46
0
 // Token: 0x0600046F RID: 1135 RVA: 0x0001044E File Offset: 0x0000E84E
 public void set_Cuenta(Cuenta _cuenta)
 {
     this.cuenta = _cuenta;
     this.cuenta.juego.personaje.hechizos_actualizados += this.actualizar_Agregar_Lista_Hechizos;
 }
Exemplo n.º 47
0
        /// <summary>
        /// Este método se encarga de verificar que botones se deben
        /// mostrar y cuales no, de acuerdo al tipo de gestion que se
        /// está gestionando actualmente.
        /// </summary>
        private void establecerDatos()
        {
            _listConvenios.ObjetoMaster =
                _listHistDeudas.ObjetoMaster =
                _listGestiones.ObjetoMaster =
                _listPagos.ObjetoMaster =
                _listEstados.ObjetoMaster =
                _cuenta = _controlador.CuentaActual;

            if (_cuenta != null) {
                _convenioActivo = null;
                if (_cuenta.ConvenioActivo != null)
                    if (_cuenta.ConvenioActivo.convenioDebeCaer() &&
                        Sistema.Controlador.mostrar("PREGUNTA-BAJAR-CONVENIO", ENivelMensaje.PREGUNTA, null, false)
                        == DialogResult.Yes)
                        try {
                            _cuenta.bajarConvenioActivo();
                            _cuenta.save();
                        } catch (Exception e) {
                            Sistema.Controlador.mostrar("ERROR-FATAL", ENivelMensaje.ERROR, e.ToString(), true);
                        }
                    else {
                        _convenioActivo = _cuenta.ConvenioActivo;
                        _listCuotas.ObjetoMaster = _convenioActivo;
                    }

                _listCuentasTitular.ObjetoMaster = _cuenta.Titular;
                _listCuentasGarante.ObjetoMaster = _cuenta.Garante;
            }
        }
Exemplo n.º 48
0
        //
        // GET: /Cuentas/Details/5

        public ViewResult Details(int id)
        {
            Cuenta cuenta = db.Cuenta.Find(id);

            return(View(cuenta));
        }
Exemplo n.º 49
0
        private static MailMessage ConstruirMailMensaje(Correo correoOrigen, Cuenta cuenta)
        {
            var Mensaje = new MailMessage();

            var from = new MailAddress(cuenta.CorreoSalida, cuenta.NombreMostrar, Encoding.UTF8);

            Mensaje.From = from;


            var MAC_PRIN = (MailAddressCollection)ObtenerDestinatarios(TipoDestinatario.Principal, correoOrigen);

            foreach (MailAddress MA in MAC_PRIN)
            {
                Mensaje.To.Add(MA);
            }

            var MAC_CC = (MailAddressCollection)ObtenerDestinatarios(TipoDestinatario.Copia, correoOrigen);

            foreach (MailAddress MA in MAC_CC)
            {
                Mensaje.CC.Add(MA);
            }

            var MAC_CCO = (MailAddressCollection)ObtenerDestinatarios(TipoDestinatario.CopiaOculta, correoOrigen);

            foreach (MailAddress MA in MAC_CCO)
            {
                Mensaje.Bcc.Add(MA);
            }

            #region Creación de adjuntos

            //if (correoOrigen.correosAdjuntos.Count > 0)
            //{
            //    foreach (var adjunto in correoOrigen.correosAdjuntos)
            //    {
            //        if (!string.IsNullOrEmpty(adjunto.CADrutaArchivo))
            //        {
            //            var attachment = new Attachment(adjunto.CADrutaArchivo.Replace("<RutaArchivo>", "").Replace("</RutaArchivo>", ""), MediaTypeNames.Application.Octet);
            //            Mensaje.Attachments.Add(attachment);
            //        }
            //    }
            //}

            #endregion

            #region Creación del cuerpo del mensaje

            //Mensaje.AlternateViews.Add(AlternateView.CreateAlternateViewFromString(correoOrigen.CORmensajeTexto, Encoding.UTF8, "text/plain"));
            Mensaje.AlternateViews.Add(AlternateView.CreateAlternateViewFromString(correoOrigen.CORmensajeHTML, Encoding.UTF8, "text/html"));
            Mensaje.Subject         = correoOrigen.CORasunto;
            Mensaje.SubjectEncoding = Encoding.UTF8;

            #endregion

            #region Prioridad mensaje

            //switch (correoOrigen.CORprioridad)
            //{
            //    case "AL":
            //        Mensaje.Priority = MailPriority.High;
            //        break;
            //    case "NO":
            //        Mensaje.Priority = MailPriority.Normal;
            //        break;
            //    case "BA":
            //        Mensaje.Priority = MailPriority.Low;
            //        break;
            //    default:
            //        Mensaje.Priority = MailPriority.Normal;
            //        break;
            //}
            Mensaje.Priority = MailPriority.Normal;
            #endregion


            if (!string.IsNullOrEmpty(cuenta.CorreoRespuesta))
            {
                Mensaje.ReplyToList.Add(new MailAddress(cuenta.CorreoRespuesta, cuenta.NombreMostrar, Encoding.UTF8));
            }

            /* Depuracion: Enviar un mensaje si el mensaje se envio correctamente */
            Mensaje.DeliveryNotificationOptions = DeliveryNotificationOptions.Never;

            /* Confirmación de lectura */
            if (!string.IsNullOrEmpty(cuenta.CorreoConfirmacionLectura))
            {
                Mensaje.Headers.Add("Disposition-Notification-To", cuenta.CorreoConfirmacionLectura);
            }

            //Encabezado de mensaje. evitar filtros spam
            //  string messageId = Guid.NewGuid().ToString().Replace("-", "").ToLower() + this.CORcuenta.CCOusuario;
            Mensaje.Headers.Add("Message-ID", correoOrigen.Id.ToString());

            Mensaje.BodyEncoding = Encoding.UTF8;

            // Se agregó para omitir las validaciones de servidor que ejecuta google a servidores corporativos
            ServicePointManager.ServerCertificateValidationCallback =
                delegate(object s
                         , X509Certificate certificate
                         , X509Chain chain
                         , SslPolicyErrors sslPolicyErrors)
            {
                return(true);
            };
            return(Mensaje);
        }
 public Boolean tieneDeudas(Cuenta cuenta)
 {
     return DBAdapter.checkIfExists("tieneDeudas", cuenta.ID);
 }