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());
}
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;
}
}
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"));
}
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));
}
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);
}
}
/// <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));
}
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;
}
}
/// <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);
}
public void AddTiposActivo(TipoActivosDto tiposActivoDto)
{
TipoActivo tipoActivo = new TipoActivo();
tipoActivo.Nombre = tiposActivoDto.Nombre;
tipoActivo.Descripcion = tiposActivoDto.Descripcion;
tipoActivoRepo.Add(tipoActivo);
}
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);
}
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));
}
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;
}
}
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));
}
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));
}
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
}
// 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));
}
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);
}
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);
}
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);
}