Example #1
0
        public List <Ingreso> BuscarReclamoRut(string Rut) // Funcion que entrega una Lista de Reclamos, para buscar reclamos vía rut, recibe un string que debería ser un Rut (de la forma 19)
        {
            var l = new List <Ingreso>();

            using (var conn = new SqlConnection(Str))
            {
                string consulta = "SELECT reclamo.id, usuarios.nombre, usuarios.apellido, usuarios.rut, usuarios.correo, usuarios.telefono, tipoReclamo.id, reclamo.comentarios, reclamo.fecha, reclamo.pdf, reclamo.sla_id  from reclamo INNER JOIN usuarios on reclamo.rut=usuarios.rut INNER JOIN tipoReclamo on reclamo.area=tipoReclamo.id where reclamo.rut =\'" + Rut + "\'";
                var    cmd      = new SqlCommand(consulta, conn);
                conn.Open();
                var reader = cmd.ExecuteReader();
                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        var ide = Convert.ToInt32(reader[0]);
                        var nom = reader[1].ToString();
                        var ape = reader[2].ToString();
                        var rut = reader[3].ToString();
                        var ema = reader[4].ToString();
                        var tel = Convert.ToInt32(reader[5]);
                        var tip = reader[6].ToString();
                        var com = reader[7].ToString();
                        var fec = Convert.ToDateTime(reader[8]);
                        var pdf = reader[9].ToString();
                        var sla = Convert.ToDateTime(reader[10]);
                        var r   = new Ingreso(ide, nom, ape, rut, ema, tel, tip, com, fec, pdf, sla);
                        l.Add(r);
                    }
                }
            }
            return(l);
        }
Example #2
0
        private void BtnTotalDia_Click(object sender, EventArgs e)
        {
            limpiarVariables();
            //Traer los pagos del dia para registarlo
            if (c1cboCia.SelectedIndex != -1 & CboSede.SelectedIndex != -1 & DtpFechaIni.Value != null & CboCajero.SelectedIndex != -1)
            {
                DataTable DtCuadreCaja = new DataTable();

                Empresa      = c1cboCia.Columns["NomEmpresa"].Value.ToString();
                Sede         = CboSede.Columns["NomSede"].Value.ToString();
                EmpresaID    = c1cboCia.SelectedValue.ToString();
                SedeID       = CboSede.SelectedValue.ToString();
                Cajero       = CboCajero.Columns["Usuario"].Value.ToString();
                CajeroID     = Convert.ToInt32(CboCajero.SelectedValue);
                FechaIni     = Convert.ToDateTime(DtpFechaIni.Value.ToShortDateString());
                FechaFin     = FechaIni.AddDays(1);
                DtCuadreCaja = ObjCL_VentaCon.GetCuadreCaja(FechaIni, FechaFin, CajeroID, EmpresaID, SedeID);

                //mostrar en la pantalla
                Ingreso            = Convert.ToDecimal(DtCuadreCaja.Rows[0]["PAGADO"]);
                Egreso             = Convert.ToDecimal(DtCuadreCaja.Rows[1]["PAGADO"]);
                TotalVenta         = Convert.ToDecimal(DtCuadreCaja.Rows[2]["PAGADO"]);
                TotalEntregar      = Ingreso - Egreso + TotalVenta;
                LblIngreso.Text    = Ingreso.ToString("C");
                LblEgreso.Text     = Egreso.ToString("C");
                LblTotalPagos.Text = TotalVenta.ToString("C");
                LblEntregar.Text   = TotalEntregar.ToString("C");
            }
        }
Example #3
0
        public List <Ingreso> ListadoReclamosActivos() // Función ListadoReclamos, retorna una Lista (l) con todos los reclamos existentes en la base de datos
        {
            var l = new List <Ingreso>();              // generamos la variable Listado

            using (var conn = new SqlConnection(Str))
            {
                // ejecutamos la consulta
                var consulta = "SELECT reclamo.id, usuarios.nombre, usuarios.apellido, usuarios.rut, usuarios.correo, usuarios.telefono, tipoReclamo.nombre, reclamo.comentarios, reclamo.fecha, reclamo.pdf, slareclamo.fecha_sla  from reclamo INNER JOIN usuarios on reclamo.rut=usuarios.rut INNER JOIN tipoReclamo on reclamo.area=tipoReclamo.id INNER JOIN slareclamo on reclamo.sla_id=slareclamo.id where reclamo.estado = 1 ORDER BY slareclamo.fecha_sla";
                var cmd      = new SqlCommand(consulta, conn);
                conn.Open();
                var reader = cmd.ExecuteReader();
                while (reader.Read()) // guardamos todos los datos en un reclamo (r)
                {
                    var ide = Convert.ToInt32(reader[0]);
                    var nom = reader[1].ToString();
                    var ape = reader[2].ToString();
                    var rut = reader[3].ToString();
                    var ema = reader[4].ToString();
                    var tel = Convert.ToInt32(reader[5]);
                    var tip = reader[6].ToString();
                    var com = reader[7].ToString();
                    var fec = Convert.ToDateTime(reader[8]);
                    var pdf = reader[9].ToString();
                    var sla = Convert.ToDateTime(reader[10]);
                    var r   = new Ingreso(ide, nom, ape, rut, ema, tel, tip, com, fec, pdf, sla);
                    l.Add(r); // agregamos cada reclamo r a nuestra lista (l)
                }
            }
            return(l); // retornamos la lista
        }
Example #4
0
        public void Inicializado()
        {
            ingresoDA = new IngresoDA();
            ingreso   = new Ingreso();

            clienteDA = new ClienteDA();
            cambioDA  = new CambioDA();

            artTemp = new LC();
            dtpFechaCambio.Value = DateTime.Now;

            cambio    = new Cambio();
            cambioOld = new Cambio();
            ObtenerDatosCambio();

            BindingList <Cambio> cambios = new BindingList <Cambio>();

            cambios.Add(cambio);
            dgvLaptopsSeleccionados.DataSource = cambios;
            vistaEquipos.OptionsBehavior.AutoPopulateColumns = false;
            vistaEquipos.OptionsSelection.MultiSelect        = true;

            tablaSede             = ingresoDA.ListarSede();
            cmbSede.DataSource    = tablaSede;
            cmbSede.DisplayMember = "nombreSede";
            cmbSede.ValueMember   = "idSede";
        }
Example #5
0
        public async Task <IActionResult> Create([Bind("IngresoId,FechaIngreso,TipoIngresoId,PacienteId,UnidadId, CondicionLlegada, CentroProcedencia,TelefonoAlterno,RelacionPaciente,Oficio,Preeindicaciones,CondicionEspecial")] Ingreso ingreso)
        {
            var pacienteID = ingreso.PacienteId;

            ingreso.estado = true;
            if (ModelState.IsValid)
            {
                //Agregando servicio
                _context.Add(ingreso);
                await _context.SaveChangesAsync();

                var ingresoConId = await _context.Ingresos.OrderByDescending(x => x.IngresoId).FirstOrDefaultAsync(x => x.IngresoId == ingreso.IngresoId);

                //Agreando un servicio al ingreso
                Servicio servicio = new Servicio()
                {
                    IngresoId   = ingresoConId.IngresoId,
                    Nombre      = "Ingreso",
                    Descripcion = "Costos por ingreso",
                    Monto       = 2000
                };
                _context.Servicios.Add(servicio);
                await _context.SaveChangesAsync();


                return(RedirectToAction(nameof(Index)));
            }
            ViewData["PacienteId"]    = new SelectList(_context.Pacientes, "PacienteId", "PacienteId", ingreso.PacienteId);
            ViewData["TipoIngresoId"] = new SelectList(_context.TipoIngresos, "TipoIngresoId", "TipoIngresoId", ingreso.TipoIngresoId);
            ViewData["UnidadId"]      = new SelectList(_context.Unidades, "Id", "Id", ingreso.UnidadId);
            return(View(ingreso));
        }
Example #6
0
        public void GuardarIngreso(Ingreso ingreso)
        {
            SqlConnection conn = new SqlConnection(cnn);
            String        sql  = "insert into ingreso (nombreApellido,dni,autoIngresado,fechaIngreso) values(@val1,@val2,@val3,@val4)";

            try
            {
                conn.Open();
                SqlCommand cmd = new SqlCommand(sql, conn);
                cmd.Parameters.AddWithValue("@val1", ingreso.NombreApellido);
                cmd.Parameters.AddWithValue("@val2", ingreso.Dni);
                cmd.Parameters.AddWithValue("@val3", ingreso.AutoIngresado);
                cmd.Parameters.AddWithValue("@val4", ingreso.FechaIngreso);
                cmd.CommandType = CommandType.Text;
                cmd.ExecuteNonQuery();
            }
            catch (System.Data.SqlClient.SqlException ex)
            {
                string msg = "error ";
                msg += ex.Message;
                throw new Exception(msg);
            }
            finally
            {
                conn.Close();
            }
        }
 /// <summary>
 /// Método que autentifica si el usuario existe y la contraseña
 /// </summary>
 /// <param name="ingreso">Recibe un ingreso como parámetro</param>
 /// <returns>Retorna la persona ingresada o un nulo si no existe</returns>
 public Ingreso Autentificar(Ingreso ingreso)
 {
     try
     {
         Ingreso i = new Ingreso();
         using (NpgsqlConnection con = new NpgsqlConnection(Configuracion.CadenaConexion))
         {
             con.Open();
             string        sql = @"SELECT id, usuario, password FROM ingresar WHERE usuario = :usu and password = :con";
             NpgsqlCommand cmd = new NpgsqlCommand(sql, con);
             cmd.Parameters.AddWithValue(":usu", ingreso.Usuario);
             cmd.Parameters.AddWithValue(":con", ingreso.Password);
             NpgsqlDataReader reader = cmd.ExecuteReader();
             if (reader.Read())
             {
                 i.Id       = reader.GetInt32(0);
                 i.Usuario  = reader.GetString(1);
                 i.Password = reader.GetString(2);
             }
         }
         return(i);
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #8
0
 void CargarDatosAlFormulario()
 {
     ingresoEditando       = IngresoBL.BuscarPorId((int)idIngreso);
     txtNumeroCCF.Text     = ingresoEditando.NumeroCCF;
     dtpFechaIngreso.Value = ingresoEditando.FechaIngreso;
     lblUsuario.Text       = ingresoEditando.Usuario;
     marca = MarcaBL.BuscarPorId(ingresoEditando.IdMarca);
     lblNombreMarca.Text         = marca.Nombre;
     lblComentarioMarca.Text     = marca.Comentario;
     listadoViejoDetallesIngreso = DetalleIngresoBL.ObtenerTodos(ingresoEditando.Id);
     if (listadoViejoDetallesIngreso != null)
     {
         for (int i = 0; i < listadoViejoDetallesIngreso.Count; i++)
         {
             dgvListadoDetallesIngreso.Rows.Add();
             dgvListadoDetallesIngreso.Rows[i].Cells[0].Value = listadoViejoDetallesIngreso[i].Id;
             dgvListadoDetallesIngreso.Rows[i].Cells[1].Value = listadoViejoDetallesIngreso[i].Cantidad;
             dgvListadoDetallesIngreso.Rows[i].Cells[2].Value = listadoViejoDetallesIngreso[i].Producto;
             dgvListadoDetallesIngreso.Rows[i].Cells[3].Value = listadoViejoDetallesIngreso[i].Descripcion;
             dgvListadoDetallesIngreso.Rows[i].Cells[4].Value = listadoViejoDetallesIngreso[i].PrecioUnitario;
             dgvListadoDetallesIngreso.Rows[i].Cells[5].Value = listadoViejoDetallesIngreso[i].SubTotal;
             listadoDetallesIngreso.Add(listadoViejoDetallesIngreso[i]);
         }
         CalcularTotales();
     }
 }
Example #9
0
        public Ingreso UpdateIngreso(Ingreso ingreso)
        {
            context.Entry(ingreso).State = EntityState.Modified;
            context.SaveChanges();

            return(ingreso);
        }
        protected void btnRegistrarConCuenta_Click(object sender, EventArgs e)
        {
            if (pass1.Text.Equals(pass2.Text))
            {
                String pass = pass1.Text;
                String corr = txbcorreo.Text;
                //registrar login
                Ingreso log = new Ingreso(corr, pass, "cliente");
                new ManejadorIngreso().registrarLogin(log);

                cliente_creado = new ManejadorCliente().registrarClienteBL(cliente);
                if (cliente_creado)
                {
                    ClientScript.RegisterStartupScript(GetType(), "invocarfuncion", "mensaje();", true);
                    //mostrarAlerta("Cliente y cuenta registrados correctamente", true);
                }
                else
                {
                    mostrarAlerta("*Error en registro de cliente", false);
                }
            }
            else
            {
                mostrarAlerta("*Contraseñas invalidas", false);
            }
            //ingresoDIV.Visible = false;
            //habilitarCampos();
            limpiarCampos();
        }
Example #11
0
        private void prepararDatosEnSeleccion(DataGridViewRow tuplaSeleccionada)
        {
            String  idIngreso = tuplaSeleccionada.Cells[0].Value.ToString();
            Ingreso ingreso   = controller.getIngresoById(idIngreso);

            prepararIngresoAMostrar(ingreso);
        }
Example #12
0
        public static List <Ingreso> ObtenerTodos(string pCondicion = "%")
        {
            string consulta = string.Concat("IF ISNUMERIC(@pCondicion)=1 SELECT i.Id, i.IdUsuario, CONCAT(u.Nombres, SPACE(1), u.Apellidos) ",
                                            "Usuario, i.IdMarca, m.Nombre Marca, i.FechaIngreso, i.NumeroCCF, i.Sumas, i.Iva, i.Total FROM Ingreso i JOIN Usuario u on ",
                                            "i.IdUsuario = u.Id join Marca m on i.IdMarca = m.Id WHERE CONCAT(u.Nombres, SPACE(1), u.Apellidos) LIKE CONCAT(@pCondicion, '%') ",
                                            "OR m.Nombre LIKE CONCAT(@pCondicion, '%') OR @pCondicion = DATENAME(MONTH, i.FechaIngreso) OR @pCondicion = DATEPART(YEAR, i.FechaIngreso) ",
                                            "ELSE SELECT i.Id, i.IdUsuario, CONCAT(u.Nombres, SPACE(1), u.Apellidos) Usuario, i.IdMarca, m.Nombre Marca, i.FechaIngreso, i.NumeroCCF, ",
                                            "i.Sumas, i.Iva, i.Total FROM Ingreso i JOIN Usuario u on i.IdUsuario = u.Id join Marca m on i.IdMarca = m.Id WHERE CONCAT(u.Nombres, ",
                                            "SPACE(1), u.Apellidos) LIKE CONCAT(@pCondicion, '%') OR m.Nombre LIKE CONCAT(@pCondicion, '%') OR @pCondicion = DATENAME(MONTH, i.FechaIngreso)");
            SqlCommand comando = ComunDB.ObtenerComando();

            comando.CommandText = consulta;
            comando.Parameters.AddWithValue("@pCondicion", pCondicion);
            SqlDataReader  reader        = ComunDB.EjecutarComandoReader(comando);
            List <Ingreso> listaIngresos = new List <Ingreso>();

            while (reader.Read())
            {
                Ingreso ingreso = new Ingreso();
                ingreso.Id           = reader.GetInt32(0);
                ingreso.IdUsuario    = reader.GetByte(1);
                ingreso.Usuario      = reader.GetString(2);
                ingreso.IdMarca      = reader.GetInt32(3);
                ingreso.Marca        = reader.GetString(4);
                ingreso.FechaIngreso = reader.GetDateTime(5);
                ingreso.NumeroCCF    = reader.GetString(6);
                ingreso.Sumas        = (reader[7] != DBNull.Value) ? (double)reader.GetDecimal(7) : 0;
                ingreso.Iva          = (reader[8] != DBNull.Value) ? (double)reader.GetDecimal(8) : 0;
                ingreso.Total        = (reader[9] != DBNull.Value) ? (double)reader.GetDecimal(9) : 0;
                listaIngresos.Add(ingreso);
            }
            return(listaIngresos);
        }
Example #13
0
        public static Ingreso BuscarPorId(int pId)
        {
            string consulta = string.Concat("SELECT i.Id, i.IdUsuario, CONCAT(u.Nombres, SPACE(1), u.Apellidos) Usuario, i.IdMarca, m.Nombre ",
                                            "Marca, i.FechaIngreso, i.NumeroCCF, i.Sumas, i.Iva, i.Total FROM Ingreso i JOIN Usuario u on i.IdUsuario = u.Id join Marca m on i.IdMarca = m.Id ",
                                            "WHERE i.Id = @Id");
            SqlCommand comando = ComunDB.ObtenerComando();

            comando.CommandText = consulta;
            comando.Parameters.AddWithValue("@Id", pId);
            SqlDataReader reader  = ComunDB.EjecutarComandoReader(comando);
            Ingreso       ingreso = new Ingreso();

            while (reader.Read())
            {
                ingreso.Id           = reader.GetInt32(0);
                ingreso.IdUsuario    = reader.GetByte(1);
                ingreso.Usuario      = reader.GetString(2);
                ingreso.IdMarca      = reader.GetInt32(3);
                ingreso.Marca        = reader.GetString(4);
                ingreso.FechaIngreso = reader.GetDateTime(5);
                ingreso.NumeroCCF    = reader.GetString(6);
                ingreso.Sumas        = (reader[7] != DBNull.Value) ? (double)reader.GetDecimal(7) : 0;
                ingreso.Iva          = (reader[8] != DBNull.Value) ? (double)reader.GetDecimal(8) : 0;
                ingreso.Total        = (reader[9] != DBNull.Value) ? (double)reader.GetDecimal(9) : 0;
            }
            return(ingreso);
        }
Example #14
0
        }//insertarIngreso


        /// <summary>
        /// Este método actualizará la información de un ingreso del sistema
        /// </summary>
        /// <param name="ingreso"></param>
        /// <returns>Boolean</returns>
        public Boolean actualizarIngreso(Ingreso ingreso)
        {
            SqlConnection connection = new SqlConnection(this.conectionString);
            String sqlStoreProcedure = "sp_actualizarIngresos";
            SqlCommand cmdActualizar = new SqlCommand(sqlStoreProcedure, connection);
            cmdActualizar.CommandType = System.Data.CommandType.StoredProcedure;
            cmdActualizar.Parameters.Add(new SqlParameter("@id", ingreso.Id));
            cmdActualizar.Parameters.Add(new SqlParameter("@fecha", ingreso.Fecha));
            cmdActualizar.Parameters.Add(new SqlParameter("@hora", ingreso.Hora));
            cmdActualizar.Parameters.Add(new SqlParameter("@concepto", ingreso.Concepto));
            cmdActualizar.Parameters.Add(new SqlParameter("@total", ingreso.Total));
            cmdActualizar.Parameters.Add(new SqlParameter("@id_usuario", ingreso.Usuario));


            cmdActualizar.Connection.Open();
            if (cmdActualizar.ExecuteNonQuery() > 0)
            {
                cmdActualizar.Connection.Close();
                return true;
            }
            else
            {
                cmdActualizar.Connection.Close();
                return false;
            }
        }//actualiazarIngreso
Example #15
0
 private void validatorIngreso(Ingreso ingreso)
 {
     if (!Regex.IsMatch(ingreso.Nombre, @"^[a-zA-Z]+$"))
     {
         throw new BusinessExeption("El Nombre no bebe tener numeros.");
     }
     if (!Regex.IsMatch(ingreso.Apellido, @"^[a-zA-Z]+$"))
     {
         throw new BusinessExeption("El Apellido no bebe tener numeros.");
     }
     if (Regex.IsMatch(ingreso.Identificacion, @"^[a-zA-Z]+$"))
     {
         throw new BusinessExeption("La Identificacion debe tener solo numeros.");
     }
     if (Regex.IsMatch(ingreso.Edad, @"^[a-zA-Z]+$"))
     {
         throw new BusinessExeption("La Edad debe tener solo numeros.");
     }
     string[] casas =
     {
         "Gryffindor", "Hufflepuff", "Ravenclaw", "Slytherin"
     };
     if (!Array.Exists(casas, ele => ele == ingreso.Casa))
     {
         throw new BusinessExeption("Debe ingresar una de estas casas Gryffindor, Hufflepuff, Ravenclaw, Slytherin");
     }
 }
        public IActionResult AgregarIngreso(double aporte)
        {
            Usuario usuario = HttpContext.Session.Get <Usuario>("UsuarioLogueado");


            if (usuario != null)
            {
                Usuario usuarioBase  = db.Usuarios.FirstOrDefault(u => u.Mail.Equals(usuario.Mail));
                Ingreso nuevoIngreso = new Ingreso()
                {
                    Aporte      = aporte,
                    fecha       = DateTime.Now,
                    mailUsuario = usuarioBase.Mail
                };



                db.Ingresos.Add(nuevoIngreso);
                db.SaveChanges();

                return(RedirectToAction("ResultadoIngreso", "User"));
            }

            else
            {
                ViewBag.IngresoError = true;
                return(RedirectToAction("ResultadoIngreso", "User"));
            }
        }
Example #17
0
        public Ingreso GetReclamo(int id)             // Función GetReclamo, retorna un Reclamo (r) y recibe un Id, con el cuál se ubica el reclamo en la base de datos
        {
            Ingreso r = null;                         // creamos un reclamo nulo para empezar

            using (var conn = new SqlConnection(Str)) // iniciamos la consulta relacional
            {
                string consulta = "SELECT reclamo.id, usuarios.nombre, usuarios.apellido, usuarios.rut, usuarios.correo, usuarios.telefono, tipoReclamo.nombre, reclamo.comentarios, reclamo.fecha, reclamo.pdf, slareclamo.fecha_sla  from reclamo INNER JOIN usuarios on reclamo.rut=usuarios.rut INNER JOIN tipoReclamo on reclamo.area=tipoReclamo.id INNER JOIN slareclamo on reclamo.sla_id=slareclamo.id where reclamo.id = " + id;
                var    cmd      = new SqlCommand(consulta, conn);
                conn.Open();
                var reader = cmd.ExecuteReader(); // ejecutamos los parámetros
                while (reader.Read())             // leemos los datos
                {                                 // y guardamos el reclamo en la variable r
                    var ide = Convert.ToInt32(reader[0]);
                    var nom = reader[1].ToString();
                    var ape = reader[2].ToString();
                    var rut = reader[3].ToString();
                    var ema = reader[4].ToString();
                    var tel = Convert.ToInt32(reader[5]);
                    var tip = reader[6].ToString();
                    var com = reader[7].ToString();
                    var fec = Convert.ToDateTime(reader[8]);
                    var pdf = reader[9].ToString();
                    var sla = Convert.ToDateTime(reader[10]);
                    r = new Ingreso(ide, nom, ape, rut, ema, tel, tip, com, fec, pdf, sla);
                }
            }
            return(r); // retornamos r
        }
Example #18
0
        private void btnIngresoDetalle_Click(object sender, EventArgs e)
        {
            Ingreso            ingresoSeleccionado = controller.getIngresoById(txtIdIngreso.Text);
            FormIngresoDetalle form = new FormIngresoDetalle(ingresoSeleccionado);

            form.ShowDialog();
        }
Example #19
0
        public IHttpActionResult Ingreso([FromUri] int accountId, Ingreso ingreso)
        {
            var Account = db.Cuentas.Find(accountId);

            if (Account == null)
            {
                return(Ok("Esta cuenta no existe."));
            }
            if (Account.TipoCuentaId == 1)
            {
                Account.Monto = Account.Monto + ingreso.Monto;
            }
            else
            {
                Account.Monto = Account.Monto - ingreso.Monto;
            }

            var montostring = ingreso.Monto.ToString();

            if (ingreso.Descripcion == null || montostring == "0")
            {
                return(Ok(new { message = "Todos los campos tienen que tener un valor." }));
            }

            db.Entry(Account).State = EntityState.Modified;
            //db.SaveChanges();

            db.Ingresos.Add(ingreso);
            db.SaveChanges();

            return(Ok(new { message = "El ingreso se realizo con exito." }));
        }
Example #20
0
        private static bool EntraEnPeriodo(Egreso egreso, Ingreso ingreso)
        {
            // return egreso.fechaEgreso.CompareTo(ingreso.fechaDesde) >= 0 && egreso.fechaEgreso.CompareTo(ingreso.fechaHasta) <= 0;
            bool resultado = DateTime.Compare(egreso.fechaEgreso, ingreso.fechaDesde) >= 0 && DateTime.Compare(egreso.fechaEgreso, ingreso.fechaHasta) <= 0;

            return(resultado);
        }
Example #21
0
        public Ingreso AddIngreso(Ingreso ingreso)
        {
            context.Ingresos.Add(ingreso);
            context.SaveChanges();

            return(ingreso);
        }
Example #22
0
        public string Insertar(Ingreso Obj)
        {
            string        Rpta   = "";
            SqlConnection SqlCon = new SqlConnection();

            try
            {
                SqlCon = Conexion.getInstancia().CrearConexion();
                SqlCommand Comando = new SqlCommand("ingreso_insertar", SqlCon);
                Comando.CommandType = CommandType.StoredProcedure;
                Comando.Parameters.Add("@idproveedor", SqlDbType.Int).Value           = Obj.IdProveedor;
                Comando.Parameters.Add("@idusuario", SqlDbType.Int).Value             = Obj.IdUsuario;
                Comando.Parameters.Add("@tipo_comprobante", SqlDbType.VarChar).Value  = Obj.TipoComprobante;
                Comando.Parameters.Add("@serie_comprobante", SqlDbType.VarChar).Value = Obj.SerieComprobante;
                Comando.Parameters.Add("@num_comprobante", SqlDbType.VarChar).Value   = Obj.NumComprobante;
                Comando.Parameters.Add("@impuesto", SqlDbType.Decimal).Value          = Obj.Impuesto;
                Comando.Parameters.Add("@total", SqlDbType.Decimal).Value             = Obj.Total;
                Comando.Parameters.Add("@detalle", SqlDbType.Structured).Value        = Obj.Detalles;
                SqlCon.Open();
                Comando.ExecuteNonQuery();
                Rpta = "OK";
            }
            catch (Exception ex)
            {
                Rpta = ex.Message;
            }
            finally
            {
                if (SqlCon.State == ConnectionState.Open)
                {
                    SqlCon.Close();
                }
            }
            return(Rpta);
        }
Example #23
0
        public Ingreso DeleteIngreso(Ingreso ingreso)
        {
            context.Ingresos.Remove(ingreso);
            context.SaveChanges();

            return(ingreso);
        }
Example #24
0
        public async Task <ActionResult <Ingreso> > PostIngreso(Ingreso ingreso)
        {
            _context.Ingresos.Add(ingreso);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetIngreso", new { id = ingreso.idIngreso }, ingreso));
        }
Example #25
0
        public void UpdateIngreso(Ingreso ingreso, int idIngreso)
        {
            SqlConnection conn = new SqlConnection(cnn);
            string        sql  = "update ingreso set nombreApellido=@val1, dni=@val2, autoIngresado=@val3, fechaIngreso=@val4 where idIngreso=@val5";

            try
            {
                conn.Open();
                SqlCommand cmd = new SqlCommand(sql, conn);

                cmd.Parameters.AddWithValue("@val1", ingreso.NombreApellido);
                cmd.Parameters.AddWithValue("@val2", ingreso.Dni);
                cmd.Parameters.AddWithValue("@val3", ingreso.AutoIngresado);
                cmd.Parameters.AddWithValue("@val4", ingreso.FechaIngreso);
                cmd.Parameters.AddWithValue("@val5", idIngreso.ToString());
                cmd.CommandType = CommandType.Text;
                cmd.ExecuteNonQuery();
            }
            catch (System.Data.SqlClient.SqlException ex)
            {
                string msg = "error";
                msg += ex.Message;
                throw new Exception(msg);
            }
            finally
            {
                conn.Close();
            }
        }
Example #26
0
 public async Task <IActionResult> PutIngreso(int id, Ingreso ingreso)
 {
     //valido que el id sea diferente
     if (id != ingreso.idIngreso)
     {
         return(BadRequest());
     }
     _context.Entry(ingreso).State = EntityState.Modified;
     //a revisar que lo que subamos por medio de la api no sea basura
     try
     {
         await _context.SaveChangesAsync();
     }
     //ESTO PORQUE REVIERTE LA OPERACION SI EN CASO HAY ERROR
     //POR EJEMPLO QUE EL ID YA EXISTE.
     catch (DbUpdateConcurrencyException)
     {
         if (IngresoExists(id))
         {
             return(NotFound());
         }
         else
         {
             throw;
         }
     }
     return(NoContent());
 }
Example #27
0
        public async Task <IActionResult> PutIngreso(int id, Ingreso ingreso)
        {
            if (id != ingreso.idIngreso)
            {
                return(BadRequest());                             // si es diferente no da un badrequest
            }
            _context.Entry(ingreso).State = EntityState.Modified; /*indicar al dbcontexr con el entity que lo que hay en ingreso
                                                                   *  vamos a realizar una modificacion , las entidad ya tiene las propiedades
                                                                   *    o informacion que vamos a guardar*/

            /*el manejo de erro try nos evitará  tener problemas a evitar que si hay error que la api no falle*/
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)//esto lo que hara un rollback a la operacion que se esta realizando
            {
                if (!IngresoExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;// por si desconocemos el error
                }
            }
            return(NoContent());
        }
        public async Task <IActionResult> PutIngreso(int id, Ingreso ingreso)
        {
            if (id != ingreso.idIngreso)
            {
                return(BadRequest());
            }

            _context.Entry(ingreso).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!IngresoExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Example #29
0
        public async Task <IActionResult> Edit(int id, [Bind("IngresoId,FechaIngreso,TipoIngresoId,PacienteId,UnidadId,estado")] Ingreso ingreso)
        {
            if (id != ingreso.IngresoId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(ingreso);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!IngresoExists(ingreso.IngresoId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["PacienteId"]    = new SelectList(_context.Pacientes, "PacienteId", "PacienteId", ingreso.PacienteId);
            ViewData["TipoIngresoId"] = new SelectList(_context.TipoIngresos, "TipoIngresoId", "TipoIngresoId", ingreso.TipoIngresoId);
            ViewData["UnidadId"]      = new SelectList(_context.Unidades, "Id", "Id", ingreso.UnidadId);
            return(View(ingreso));
        }
Example #30
0
        public Ingreso BuscarReclamoId(int id) // Función que busca un reclamo dado un ID
        {
            Ingreso r = null;

            using (var conn = new SqlConnection(Str))
            {
                string consulta = "SELECT reclamo.id, usuarios.nombre, usuarios.apellido, usuarios.rut, usuarios.correo, usuarios.telefono, tipoReclamo.id, reclamo.comentarios, reclamo.fecha, reclamo.pdf, reclamo.sla_id  from reclamo INNER JOIN usuarios on reclamo.rut=usuarios.rut INNER JOIN tipoReclamo on reclamo.area=tipoReclamo.id where reclamo.id = " + id;
                var    cmd      = new SqlCommand(consulta, conn);
                conn.Open();
                var reader = cmd.ExecuteReader();
                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        var ide = Convert.ToInt32(reader[0]);
                        var nom = reader[1].ToString();
                        var ape = reader[2].ToString();
                        var rut = reader[3].ToString();
                        var ema = reader[4].ToString();
                        var tel = Convert.ToInt32(reader[5]);
                        var tip = reader[6].ToString();
                        var com = reader[7].ToString();
                        var fec = Convert.ToDateTime(reader[8]);
                        var pdf = reader[9].ToString();
                        var sla = Convert.ToDateTime(reader[10]);
                        r = new Ingreso(ide, nom, ape, rut, ema, tel, tip, com, fec, pdf, sla);
                    }
                }
                else
                {
                    throw new Exception("No se encontró el ID, vuelva a intentarlo");
                }
            }
            return(r);
        }
Example #31
0
        public static bool Insertar(Ingreso ingreso)
        {
            bool retorno = false;
            try
            {
                using (var db = new MiniSubControlDb())
                {
                    db.Ingreso.Add(ingreso);
                    db.SaveChanges();
                    retorno = true;
                }
            }
            catch (Exception ex)
            {

                throw ex;
            }

            return retorno;
        }
        public static void ValidateAndThrowHttpError(this ComprobanteIngresoRetencion request, 
                                                     ComprobanteIngresoRetencion oldData,
                                                     ComprobanteIngreso ce,
                                                     ComprobanteIngresoItem cei,
                                                     Ingreso egreso,
                                                     PresupuestoItem pi,
                                                     string ruleSet)
        {
            IngresoCIRet ret = new IngresoCIRet(){
                Ingreso= egreso,
                Cei=cei,
                Ce=ce,
                OldRet= oldData,
                Ret= request,
                Pi=pi
            };

            IngresoCIRetValidator av = new IngresoCIRetValidator();
            av.ValidateAndThrowHttpError(ret, ruleSet);
        }
Example #33
0
        static void CheckOldAndNew(Ingreso oldData, Ingreso request,
                                           DALProxy proxy,
                                           int idUsuario)
        {
            oldData.ValidateAndThrowHttpError(Operaciones.Update);

            Ingresos egresos= new Ingresos(){Nuevo=request, Viejo=oldData};
            IngresosValidator ev = new IngresosValidator();
            ev.ValidateAndThrowHttpError(egresos,Operaciones.Update);

            oldData.CheckSucursal(proxy, idUsuario);

            var data = new Ingreso();
            data.PopulateWith(oldData);

            if( request.Fecha!=default(DateTime) && request.Fecha!=data.Fecha)
            {
                data.Fecha=request.Fecha;
                data.Periodo= data.Fecha.ObtenerPeriodo();
            }

            data.CheckPeriodo(proxy);

            if(request.IdTercero!=default(int) && request.IdTercero!=data.IdTercero)
            {
                data.IdTercero=request.IdTercero;
                var tercero=data.CheckTercero(proxy);
                data.NombreDocumentoTercero=tercero.NombreDocumento;
                data.NombreTercero=tercero.Nombre;
                data.DocumentoTercero=tercero.Documento;
                data.DVTercero= tercero.DigitoVerificacion;
            }
			            
            if(!request.Descripcion.IsNullOrEmpty() && request.Descripcion!=data.Descripcion)
                data.Descripcion=request.Descripcion;

            if(request.DiasCredito!=data.DiasCredito) data.DiasCredito=request.DiasCredito;

            request.PopulateWith(data);
        }
Example #34
0
        static void CheckOldAndNew(Ingreso egreso, IngresoItem request, IngresoItem oldData,
                                           DALProxy proxy,
                                           int idUsuario)
        {
            egreso.ValidateAndThrowHttpError(Operaciones.Update);
            egreso.CheckPeriodo(proxy);

            oldData.CheckCentro(proxy,egreso.IdSucursal, idUsuario);

            IngresoItem data = new IngresoItem();
            data.PopulateWith(oldData);

            if(request.IdCentro!=default(int) && request.IdCentro!=data.IdCentro)
            {
                data.IdCentro=request.IdCentro;
                data.CheckCentro(proxy, egreso.IdSucursal, idUsuario);
            }

            if(request.IdPresupuestoItem!=default(int) && request.IdPresupuestoItem!= data.IdPresupuestoItem)
                data.IdPresupuestoItem= request.IdPresupuestoItem;

            if(request.TipoPartida!=default(short) && request.TipoPartida!=data.TipoPartida)
                data.TipoPartida=request.TipoPartida;

            if(request.Valor!=default(decimal) && request.Valor!=data.Valor)
                data.Valor=request.Valor;

            request.PopulateWith(data);
        }   
Example #35
0
        static void CheckBeforePatch(Ingreso oldData, Ingreso request,
                                             DALProxy proxy,
                                             int idUsuario,
                                             string operacion)
        {
            oldData.ValidateAndThrowHttpError(operacion);
            Ingresos egresos= new Ingresos(){Nuevo=request, Viejo=oldData};
            IngresosValidator ev = new IngresosValidator();
            ev.ValidateAndThrowHttpError(egresos,operacion);

            oldData.CheckSucursal(proxy,idUsuario);
            oldData.CheckPeriodo(proxy);

            request.PopulateWith(oldData);
        }
Example #36
0
 static void CheckSaldo(Ingreso request, decimal saldo)
 {
     if(saldo!=request.Saldo)
         throw new HttpError(string.Format("El Ingreso:'{0}' NO puede ser Reversado. Revise los comprobantes de Ingreso",
                                               request.Numero ));            
 }
 static void ValidateAndThrowHttpError(this ComprobanteIngresoItem request,
                                                ComprobanteIngreso comprobante,
                                                Ingreso ingreso,string ruleSet)
 {
     request.ValidateAndThrowHttpError(new ComprobanteIngresoItem(), comprobante,
                                       ingreso, ruleSet);
 }
        static void ValidateAndThrowHttpError(this ComprobanteIngresoItem request,
                                                       ComprobanteIngresoItem oldData,
                                                       ComprobanteIngreso comprobante,
                                                       Ingreso ingreso,string ruleSet)
        {
            IngresoCI ece= new IngresoCI(){
                Ingreso=ingreso,
                Ce= comprobante,
                Cei= request,
                OldCei= oldData,
            };
            IngresoCIValidator av = new IngresoCIValidator();

            av.ValidateAndThrowHttpError(ece,ruleSet );
        }
 public static void ValidateAndThrowHttpError(this ComprobanteIngresoRetencion request, 
                                              ComprobanteIngreso ce,
                                              ComprobanteIngresoItem cei,
                                              Ingreso egreso,
                                              PresupuestoItem pi,
                                              string ruleSet)
 {
     request.ValidateAndThrowHttpError(new ComprobanteIngresoRetencion(),
                                       ce, cei, egreso, pi, ruleSet);
 }