Ejemplo n.º 1
0
        public async Task <IActionResult> PutTipoActivo(long id, TipoActivo tipoActivo)
        {
            if (id != tipoActivo.Id)
            {
                return(BadRequest());
            }

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

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

            return(NoContent());
        }
Ejemplo n.º 2
0
        public TipoActivo GetTipoActivoByID(int id)
        {
            TipoActivo tipoActivo = null;

            try
            {
                using (MyContext ctx = new MyContext())
                {
                    ctx.Configuration.LazyLoadingEnabled = false;
                    tipoActivo = ctx.TipoActivo.Find(id);
                }

                return(tipoActivo);
            }
            catch (DbUpdateException dbEx)
            {
                string mensaje = "";
                Log.Error(dbEx, System.Reflection.MethodBase.GetCurrentMethod(), ref mensaje);
                throw new Exception(mensaje);
            }
            catch (Exception ex)
            {
                string mensaje = "";
                Log.Error(ex, System.Reflection.MethodBase.GetCurrentMethod(), ref mensaje);
                throw;
            }
        }
Ejemplo n.º 3
0
        public async Task <ActionResult <TipoActivo> > PostTipoActivo(TipoActivo tipoActivo)
        {
            _context.TipoActivos.Add(tipoActivo);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetTipoActivo", new { id = tipoActivo.Id }, tipoActivo));
        }
        public ActionResult NuevoTipoActivoPOST(TipoActivo infoTipoActivo)
        {
            string             mensajesTipoActivo = string.Empty;
            MensajesTipoActivo msjTipoActivo      = new MensajesTipoActivo();

            try
            {
                TipoActivoAccDatos objTipoActivoAccDatos = new TipoActivoAccDatos((string)Session["NickUsuario"]);
                msjTipoActivo = objTipoActivoAccDatos.RegistrarTipoActivo(infoTipoActivo);
                if (msjTipoActivo.OperacionExitosa)
                {
                    mensajesTipoActivo  = string.Format("El tipo de activo \"{0}\" ha sido registrada exitosamente.", infoTipoActivo.NombreTipoActivo);
                    TempData["Mensaje"] = mensajesTipoActivo;
                    Logs.Info(mensajesTipoActivo);
                }
                else
                {
                    mensajesTipoActivo       = string.Format("No se ha podido registrar el tipo de activo \"{0}\": {1}", infoTipoActivo.NombreTipoActivo, msjTipoActivo.MensajeError);
                    TempData["MensajeError"] = mensajesTipoActivo;
                    Logs.Error(mensajesTipoActivo);
                }
            }
            catch (Exception e)
            {
                Logs.Error(string.Format("{0}: {1}", mensajesTipoActivo, e.Message));
                return(View());
            }
            return(RedirectToAction("ModificarTipoActivo", "TipoActivo"));
        }
Ejemplo n.º 5
0
        private void btnBuscarTipoAct_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(txtCCC.Text))
            {
                MessageBox.Show("La cuenta contable compra es obligatoria ", "Error");
                return;
            }

            if (string.IsNullOrWhiteSpace(txtCCD.Text))
            {
                MessageBox.Show("Lacuenta contable depreciación es obligatoria ", "Error");
                return;
            }

            TipoActivo tipoActivo = new TipoActivo();

            tipoActivo.Descripcion                = cmbDescTipoAct.Text;
            tipoActivo.cuentaContableCompra       = Convert.ToInt32(txtCCC.Text);
            tipoActivo.cuentaContableDepreciacion = Convert.ToInt32(txtCCD.Text);
            tipoActivo.Estado = cmbEstadoTA.Text;

            db.TipoActivo.Add(tipoActivo);
            db.SaveChanges();

            MessageBox.Show("Datos guardados correctamente");

            LlenarGrid();
            cmbDescTipoAct.Text = "";
            txtCCC.Text         = "";
            txtCCD.Text         = "";
            cmbEstadoTA.Text    = "";
        }
        public ActionResult Edit(int?id)
        {
            IServiceTipoActivo _ServiceTipoActivo = new ServiceTipoActivo();
            TipoActivo         tipoActivo         = null;

            try
            {
                // Si va null
                if (id == null)
                {
                    return(RedirectToAction("List"));
                }

                tipoActivo = _ServiceTipoActivo.GetTipoActivoByID(id.Value);
                // Response.StatusCode = 500;
                return(View(tipoActivo));
            }
            catch (Exception ex)
            {
                // Salvar el error en un archivo
                Log.Error(ex, MethodBase.GetCurrentMethod());
                TempData["Message"] = "Error al procesar los datos! " + ex.Message;
                TempData.Keep();
                // Redireccion a la captura del Error
                return(RedirectToAction("Default", "Error"));
            }
        }
        public ActionResult ModificarEstadoTipoActivo(TipoActivo infoTipoActivo)
        {
            string             mensajesTipoActivo = string.Empty;
            MensajesTipoActivo msjTipoActivo      = new MensajesTipoActivo();

            try
            {
                TipoActivoAccDatos objTipoActivoAccDatos = new TipoActivoAccDatos((string)Session["NickUsuario"]);
                msjTipoActivo = objTipoActivoAccDatos.ActualizarTipoActivo(infoTipoActivo, true);
                if (msjTipoActivo.OperacionExitosa)
                {
                    mensajesTipoActivo = string.Format("El tipo de activo con ID: {0} ha sido modificado correctamente.", infoTipoActivo.IdTipoActivo);
                    Logs.Info(mensajesTipoActivo);
                }
                else
                {
                    mensajesTipoActivo = string.Format("No se ha podido actualizar el tipo de activo con ID: {0}: {1}", infoTipoActivo.IdTipoActivo, msjTipoActivo.MensajeError);
                    Logs.Error(mensajesTipoActivo);
                }
            }
            catch (Exception e)
            {
                Logs.Error(string.Format("{0}: {1}", mensajesTipoActivo, e.Message));
            }
            return(Json(msjTipoActivo, JsonRequestBehavior.AllowGet));
        }
Ejemplo n.º 8
0
        private void btnAceptar_Click(object sender, EventArgs e)
        {
            try
            {
                string     code       = txtCodigo.Text;
                string     name       = txtNombre.Text;
                int        index      = cmbTipoActivo.SelectedIndex;
                TipoActivo tipoActivo = (TipoActivo)Enum.GetValues(typeof(TipoActivo)).GetValue(index);

                validateActivoFijo(code, name, out decimal valor, out decimal valorR);

                ActivoFijo activoFijo = new ActivoFijo()
                {
                    codigo        = code,
                    nombre        = name,
                    tipoActivo    = tipoActivo,
                    valor         = valor,
                    valorResidual = valorR
                };

                activoFijoModel.add(activoFijo);
                MessageBox.Show("Activo agregado satisfactoriamente");
                dgvActivos.DataSource = activoFijoModel.getAll();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Mensaje de error",
                                MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Método para ingresar un nuevo Tipo de Activo en la base de datos.
        /// </summary>
        /// <param name="infoTipoActivo"></param>
        /// <returns></returns>
        public MensajesTipoActivo RegistroTipoActivo(TipoActivo infoTipoActivo)
        {
            MensajesTipoActivo msjTipoActivo = new MensajesTipoActivo();

            try
            {
                NpgsqlTransaction tran = conn_BD.BeginTransaction();
                using (NpgsqlCommand cmd = new NpgsqlCommand("INSERT INTO public.dcicc_tipoactivos(id_categoriaact, nombre_tipoact, descripcion_tipoact,vidautil_tipoact, habilitado_tipoact)VALUES(@ic, @nt, @dt, @vua,@ht)", conn_BD))
                {
                    cmd.Parameters.Add("ic", NpgsqlTypes.NpgsqlDbType.Integer).Value  = infoTipoActivo.IdCategoriaActivo;
                    cmd.Parameters.Add("nt", NpgsqlTypes.NpgsqlDbType.Varchar).Value  = infoTipoActivo.NombreTipoActivo.Trim();
                    cmd.Parameters.Add("dt", NpgsqlTypes.NpgsqlDbType.Varchar).Value  = !string.IsNullOrEmpty(infoTipoActivo.DescripcionTipoActivo) ? (object)infoTipoActivo.DescripcionTipoActivo.Trim() : DBNull.Value;
                    cmd.Parameters.Add("vua", NpgsqlTypes.NpgsqlDbType.Integer).Value = infoTipoActivo.VidaUtilTipoActivo;
                    cmd.Parameters.Add("ht", NpgsqlTypes.NpgsqlDbType.Boolean).Value  = infoTipoActivo.HabilitadoTipoActivo;
                    cmd.ExecuteNonQuery();
                }
                tran.Commit();
                conn_BD.Close();
                msjTipoActivo.OperacionExitosa = true;
            }
            catch (Exception e)
            {
                conn_BD.Close();
                msjTipoActivo.OperacionExitosa = false;
                msjTipoActivo.MensajeError     = e.Message;
            }
            return(msjTipoActivo);
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Descripcion,CuentaCompra,CuentaDepreciacion,IdEstado")] TipoActivo tipoActivo)
        {
            if (id != tipoActivo.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(tipoActivo);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!TipoActivoExists(tipoActivo.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdEstado"] = new SelectList(_context.Estado, "Id", "Descripcion", tipoActivo.IdEstado);
            return(View(tipoActivo));
        }
Ejemplo n.º 11
0
        public void DeleteTipoActivo(int id)
        {
            int returno;

            try
            {
                using (MyContext ctx = new MyContext())
                {
                    ctx.Configuration.LazyLoadingEnabled = false;
                    TipoActivo tipoActivo = new TipoActivo()
                    {
                        IdTipoActivo = id
                    };
                    ctx.Entry(tipoActivo).State = EntityState.Deleted;
                    returno = ctx.SaveChanges();
                }
            }
            catch (DbUpdateException dbEx)
            {
                string mensaje = "";
                Log.Error(dbEx, System.Reflection.MethodBase.GetCurrentMethod(), ref mensaje);
                throw new Exception(mensaje);
            }
            catch (Exception ex)
            {
                string mensaje = "";
                Log.Error(ex, System.Reflection.MethodBase.GetCurrentMethod(), ref mensaje);
                throw;
            }
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Método para actualizar el estado de un Tipo de Activo en la base de datos.
        /// </summary>
        /// <param name="infoTipoActivo"></param>
        /// <returns></returns>
        public MensajesTipoActivo ActualizacionEstadoTipoActivo(TipoActivo infoTipoActivo)
        {
            MensajesTipoActivo msjTipoActivo = new MensajesTipoActivo();

            try
            {
                NpgsqlTransaction tran = conn_BD.BeginTransaction();
                using (NpgsqlCommand cmd = new NpgsqlCommand("UPDATE public.dcicc_tipoactivos SET habilitado_tipoact=@ht WHERE id_tipoact=@it", conn_BD))
                {
                    cmd.Parameters.Add("ht", NpgsqlTypes.NpgsqlDbType.Boolean).Value = infoTipoActivo.HabilitadoTipoActivo;
                    cmd.Parameters.Add("it", NpgsqlTypes.NpgsqlDbType.Integer).Value = infoTipoActivo.IdTipoActivo;
                    cmd.ExecuteNonQuery();
                }
                tran.Commit();
                conn_BD.Close();
                msjTipoActivo.OperacionExitosa = true;
            }
            catch (Exception e)
            {
                conn_BD.Close();
                msjTipoActivo.OperacionExitosa = false;
                msjTipoActivo.MensajeError     = e.Message;
            }
            return(msjTipoActivo);
        }
Ejemplo n.º 13
0
        public void AddTiposActivo(TipoActivosDto tiposActivoDto)
        {
            TipoActivo tipoActivo = new TipoActivo();

            tipoActivo.Nombre      = tiposActivoDto.Nombre;
            tipoActivo.Descripcion = tiposActivoDto.Descripcion;
            tipoActivoRepo.Add(tipoActivo);
        }
Ejemplo n.º 14
0
        public ActionResult DeleteConfirmed(int id)
        {
            TipoActivo tipoActivo = db.TipoActivo.Find(id);

            db.TipoActivo.Remove(tipoActivo);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
        public TipoActivo GetTipoActivoById(int id)
        {
            TipoActivo tipoActivo = db.TipoActivo
                                    .Where(ic => ic.Id == id)
                                    .FirstOrDefault();

            return(tipoActivo);
        }
        private TipoActivo GetTipoActivoById(TipoActivo item)
        {
            var tipoActivoResult = _listadoInspeccionRepository.GetTipoActivoById(item.Id);

            if (tipoActivoResult is null)
            {
                throw new CenturyException(new CenturyError(CenturyError.TipoError.NoEncontrado, "TipoActivo no encontrado con llave (id) == (" + item.Id.ToString() + ")", "TipoActivo"));
            }
            return(tipoActivoResult);
        }
Ejemplo n.º 17
0
 public ActionResult Edit([Bind(Include = "Id,Descripcion,CuentaContableCompra,CuentaContableDepreciacion,Estado")] TipoActivo tipoActivo)
 {
     if (ModelState.IsValid)
     {
         db.Entry(tipoActivo).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(tipoActivo));
 }
Ejemplo n.º 18
0
 public ActionResult Edit([Bind(Include = "TipoActivoID,NombreTipo,EstadoID")] TipoActivo tipoActivo)
 {
     if (ModelState.IsValid)
     {
         db.Entry(tipoActivo).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(tipoActivo));
 }
        public TipoActivo Save(TipoActivo tipoActivo)
        {
            int        retorno     = 0;
            TipoActivo oTipoActivo = null;

            try
            {
                using (MyContext ctx = new MyContext())
                {
                    ctx.Configuration.LazyLoadingEnabled = false;
                    oTipoActivo = GetTipoActivoByID(tipoActivo.TipoActivoID);
                    if (oTipoActivo == null)
                    {
                        ctx.TipoActivo.Add(tipoActivo);
                    }
                    else
                    {
                        ctx.Entry(tipoActivo).State = EntityState.Modified;
                    }
                    retorno = ctx.SaveChanges();


#if !DEBUG
                    // Error por exception
                    int x = 0;
                    x = 25 / x;

                    // Error por Entity Framework
                    // Forzar un error por duplicidad
                    // bodega.IdBodega = 1;
                    // ctx.Bodega.Add(bodega);
                    // retorno = ctx.SaveChanges();
#endif
                }

                if (retorno >= 0)
                {
                    oTipoActivo = GetTipoActivoByID(tipoActivo.TipoActivoID);
                }

                return(oTipoActivo);
            }
            catch (DbUpdateException dbEx)
            {
                string mensaje = "";
                Log.Error(dbEx, System.Reflection.MethodBase.GetCurrentMethod(), ref mensaje);
                throw new Exception(mensaje);
            }
            catch (Exception ex)
            {
                string mensaje = "";
                Log.Error(ex, System.Reflection.MethodBase.GetCurrentMethod(), ref mensaje);
                throw;
            }
        }
Ejemplo n.º 20
0
        public ActionResult Create([Bind(Include = "Id,Descripcion,CuentaContableCompra,CuentaContableDepreciacion,Estado")] TipoActivo tipoActivo)
        {
            if (ModelState.IsValid)
            {
                db.TipoActivo.Add(tipoActivo);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(tipoActivo));
        }
Ejemplo n.º 21
0
        public ActionResult Create([Bind(Include = "TipoActivoID,NombreTipo,EstadoID")] TipoActivo tipoActivo)
        {
            if (ModelState.IsValid)
            {
                db.TipoActivos.Add(tipoActivo);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(tipoActivo));
        }
        public async Task <IActionResult> Create([Bind("Id,Descripcion,CuentaCompra,CuentaDepreciacion,IdEstado")] TipoActivo tipoActivo)
        {
            if (ModelState.IsValid)
            {
                _context.Add(tipoActivo);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdEstado"] = new SelectList(_context.Estado, "Id", "Descripcion", tipoActivo.IdEstado);
            return(View(tipoActivo));
        }
Ejemplo n.º 23
0
        public void AddTipoActivo()
        {
            //Arrange
            Repository <TipoActivo> tipoActivo = new TipoActivoRepository();
            TipoActivo newTipoActivo           = new TipoActivo();

            newTipoActivo.Nombre      = "Bienes Inmuebles";
            newTipoActivo.Descripcion = "Bienes Inmuebles";
            //Act
            tipoActivo.Add(newTipoActivo);
            //Assert
        }
Ejemplo n.º 24
0
        // GET: TipoActivoes/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            TipoActivo tipoActivo = db.TipoActivo.Find(id);

            if (tipoActivo == null)
            {
                return(HttpNotFound());
            }
            return(View(tipoActivo));
        }
Ejemplo n.º 25
0
        public MensajesTipoActivo ActualizarEstadoTipoActivo([FromBody] TipoActivo infoTipoActivo)
        {
            MensajesTipoActivo        msjTipoActivo = new MensajesTipoActivo();
            ActualizacionesTipoActivo objActualizacionesTipoActivoBD = new ActualizacionesTipoActivo();

            msjTipoActivo = objActualizacionesTipoActivoBD.ActualizacionEstadoTipoActivo(infoTipoActivo);
            if (msjTipoActivo.OperacionExitosa)
            {
                Logs.Info(string.Format("Actualización de estado de Tipo de Activo con ID: {0} realizada exitosamente.", infoTipoActivo.IdTipoActivo));
            }
            else
            {
                Logs.Error(msjTipoActivo.MensajeError);
            }
            return(msjTipoActivo);
        }
Ejemplo n.º 26
0
        public MensajesTipoActivo RegistrarTipoActivo([FromBody] TipoActivo infoTipoActivo)
        {
            MensajesTipoActivo    msjTipoActivo = new MensajesTipoActivo();
            InsercionesTipoActivo objInsercionesTipoActivoBD = new InsercionesTipoActivo();

            msjTipoActivo = objInsercionesTipoActivoBD.RegistroTipoActivo(infoTipoActivo);
            if (msjTipoActivo.OperacionExitosa)
            {
                Logs.Info(string.Format("Registro de Tipo de Activo \"{0}\" realizado exitosamente.", infoTipoActivo.NombreTipoActivo));
            }
            else
            {
                Logs.Error(msjTipoActivo.MensajeError);
            }
            return(msjTipoActivo);
        }
        /// <summary>
        /// Método para actualizar un Tipo de Activo en la base de datos.
        /// </summary>
        /// <param name="infoTipoActivo"></param>
        /// <param name="actEstado">Boolean para definir si se actualizará solo el estado o todo el registro</param>
        /// <returns></returns>
        public MensajesTipoActivo ActualizarTipoActivo(TipoActivo infoTipoActivo, bool actEstado)
        {
            MensajesTipoActivo msjTipoActivo = new MensajesTipoActivo();

            try
            {
                var response = client_Service.PostAsJsonAsync(actEstado ? "TipoActivo/ActualizarEstadoTipoActivo" : "TipoActivo/ActualizarTipoActivo", infoTipoActivo).Result;
                if (response.IsSuccessStatusCode)
                {
                    var TipoActivoJson = response.Content.ReadAsStringAsync().Result;
                    msjTipoActivo = JsonConvert.DeserializeObject <MensajesTipoActivo>(TipoActivoJson);
                }
            }
            catch (Exception e)
            {
                Logs.Error(string.Format("Error en la conexión para actualizar una tipo de activo: {0}", e.Message));
            }
            return(msjTipoActivo);
        }
Ejemplo n.º 28
0
        public TipoActivo Save(TipoActivo tipoActivo)
        {
            int        retorno     = 0;
            TipoActivo oTipoActivo = null;

            try
            {
                using (MyContext ctx = new MyContext())
                {
                    ctx.Configuration.LazyLoadingEnabled = false;
                    oTipoActivo = GetTipoActivoByID(tipoActivo.IdTipoActivo);
                    if (oTipoActivo == null)
                    {
                        ctx.TipoActivo.Add(tipoActivo);
                    }
                    else
                    {
                        ctx.Entry(tipoActivo).State = EntityState.Modified;
                    }
                    retorno = ctx.SaveChanges();
                }

                if (retorno >= 0)
                {
                    oTipoActivo = GetTipoActivoByID(tipoActivo.IdTipoActivo);
                }

                return(oTipoActivo);
            }
            catch (DbUpdateException dbEx)
            {
                string mensaje = "";
                Log.Error(dbEx, System.Reflection.MethodBase.GetCurrentMethod(), ref mensaje);
                throw new Exception(mensaje);
            }
            catch (Exception ex)
            {
                string mensaje = "";
                Log.Error(ex, System.Reflection.MethodBase.GetCurrentMethod(), ref mensaje);
                throw;
            }
        }
        public ActionResult Save(TipoActivo tipoActivo)
        {
            string errores = "";

            try
            {
                // Es valido
                if (ModelState.IsValid)
                {
                    ServiceTipoActivo _ServiceTipoActivo = new ServiceTipoActivo();
                    _ServiceTipoActivo.Save(tipoActivo);
                }
                else
                {
                    // Valida Errores si Javascript está deshabilitado
                    //Util.ValidateErrors(this);

                    TempData["Message"] = "Error al procesar los datos! " + errores;
                    TempData.Keep();

                    return(View("Create", tipoActivo));
                }

                // redirigir
                return(RedirectToAction("List"));
            }
            catch (Exception ex)
            {
                // Salvar el error en un archivo
                Log.Error(ex, MethodBase.GetCurrentMethod());
                TempData["Message"] = "Error al procesar los datos! " + ex.Message;
                TempData.Keep();
                // Redireccion a la captura del Error
                return(RedirectToAction("Default", "Error"));
            }
        }
        public ListadoInspeccion UpdateListadoInspeccion(ListadoInspeccion listadoInspeccion, TipoActivo tipoActivo)
        {
            listadoInspeccion.SetTipoActivo(null);

            db.Set <ListadoInspeccion_TipoActivo>().Add(new ListadoInspeccion_TipoActivo()
            {
                ListadoInspeccionId = listadoInspeccion.Id,
                TipoActivoId        = tipoActivo.Id
            });

            db.Set <ListadoInspeccion>().Update(listadoInspeccion);
            return(listadoInspeccion);
        }