public static List <TipoInsumo> listar()
{
List <TipoInsumo> listado = new List <TipoInsumo>();
ManagerAcessoDato acessoDatos = new ManagerAcessoDato();
TipoInsumo tipo = new TipoInsumo();
try
{
acessoDatos.setearConsulta("select id,descripcion from tiposInsumos where estado=1");
acessoDatos.abrirConexion();
acessoDatos.ejecutarConsulta();
while (acessoDatos.Lector.Read())
{
tipo = new TipoInsumo();
tipo.id = (int)acessoDatos.Lector["id"];
tipo.descripcion = (string)acessoDatos.Lector["descripcion"].ToString();
listado.Add(tipo);
}
return(listado);
}
catch (Exception ex)
{
throw ex;
}
finally
{
acessoDatos.cerrarConexion();
}
}
public TipoInsumo buscarTipoInsumo(int idTipoInsumo)
{
SqlConnection connection = SQL.Conexion.getConnection();
try
{
connection.Open();
SqlCommand command = new SqlCommand("SELECT * FROM tipoInsumo WHERE idTipoInsumo = " + idTipoInsumo + ";", connection);
SqlDataReader reader = command.ExecuteReader();
if (reader.HasRows)
{
reader.Read();
TipoInsumo tipoInsumo = new TipoInsumo(reader.GetInt32(0), reader.GetString(1));
connection.Close();
return(tipoInsumo);
}
else
{
connection.Close();
return(null);
}
}
catch
{
connection.Close();
return(null);
}
}
public ActionResult DeleteConfirmed(int id)
{
TipoInsumo tipoInsumo = db.TiposInsumo.Find(id);
db.TiposInsumo.Remove(tipoInsumo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public TipoInsumoVo(TipoInsumo tipoInsumo)
{
Id = tipoInsumo.Id;
Descripcion = tipoInsumo.Descripcion;
Codigo = tipoInsumo.Codigo;
Empresa = tipoInsumo.Empresa;
Linea = tipoInsumo.Linea;
}
public ActionResult Edit([Bind(Include = "id,nombre")] TipoInsumo tipoInsumo)
{
if (ModelState.IsValid)
{
db.Entry(tipoInsumo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoInsumo));
}
public ActionResult Create([Bind(Include = "id,nombre")] TipoInsumo tipoInsumo)
{
if (ModelState.IsValid)
{
db.TiposInsumo.Add(tipoInsumo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoInsumo));
}
public async Task Create(TipoInsumo model)
{
try
{
_db.dbSetTipoInsumo.Add(model);
await _db.SaveChangesAsync();
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public IActionResult Post([FromBody] TipoInsumo tipoInsumo)
{
try
{
_tipoInsumoRepository.Adicionar(tipoInsumo);
return(Created("api/TipoInsumo", tipoInsumo));
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
// GET: TiposInsumo/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoInsumo tipoInsumo = db.TiposInsumo.Find(id);
if (tipoInsumo == null)
{
return(HttpNotFound());
}
return(View(tipoInsumo));
}
public TipoInsumo buscarTipoInsumo(string idTipoInsumo)
{
TipoInsumo tipoInsumo = insumoDAO.buscarTipoInsumo(Convert.ToInt32(idTipoInsumo));
if (tipoInsumo != null)
{
return(tipoInsumo);
}
else
{
HttpContext.Current.Response.Write("<script>window.alert('Error al obtener tipo insumo');</script>");
return(null);
}
}
public async Task Update(TipoInsumo model)
{
try
{
var _model = await _db.dbSetTipoInsumo.FirstOrDefaultAsync(e => e.TipoInsumoId == model.TipoInsumoId);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateEstado(TipoInsumo model)
{
try
{
var _model = await _db.dbSetTipoInsumo.FirstOrDefaultAsync(e => e.TipoInsumoId == model.TipoInsumoId);
if (_model != null)
{
_model.EstadoDisponible = model.EstadoDisponible;
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public string CrearTipoInsumo(TipoInsumoDTO TipoInsumo)
{
try
{
var tipoInsumo = new TipoInsumo()
{
Codigo = TipoInsumo.Codigo,
Descripcion = TipoInsumo.Descripcion
};
db.TiposInsumos.Add(tipoInsumo);
db.SaveChanges();
return("Ok");
}
catch (Exception ex)
{
return(ex.Message);
}
}
public override object Parse(int empresa, int linea, IData data)
{
var item = GetConsumo(empresa, linea, data);
if (data.Operation == (int)Operation.Delete)
{
return(item);
}
var codigoLinea = data[Properties.Consumo.Linea];
if (codigoLinea != null)
{
var l = GetLinea(empresa, data[Properties.Consumo.Linea]);
if (l != null)
{
linea = l.Id;
}
}
Coche vehiculo = null;
var internoVehiculo = data[Properties.Consumo.Vehiculo];
if (internoVehiculo != null || item.Vehiculo != null)
{
vehiculo = DaoFactory.CocheDAO.FindByInterno(new[] { empresa }, new[] { linea }, internoVehiculo);
if (vehiculo == null && item.Vehiculo == null)
{
vehiculo = DaoFactory.CocheDAO.FindByInterno(new[] { empresa }, new[] { linea }, "(Generico)");
if (vehiculo == null)
{
throw new EntityParserException("No se encontró el vehículo con interno " + internoVehiculo);
}
}
}
else
{
ThrowProperty("Vehiculo");
}
Proveedor proveedor = null;
var codigoProveedor = data[Properties.Consumo.Proveedor];
if (codigoProveedor != null || item.Proveedor != null)
{
if (codigoProveedor == string.Empty)
{
proveedor = DaoFactory.ProveedorDAO.FindByCode(new[] { empresa }, new[] { linea }, "ST");
if (proveedor == null)
{
var tipoProveedor = DaoFactory.TipoProveedorDAO.FindByCode(new[] { empresa }, new[] { linea }, "G");
if (tipoProveedor == null)
{
tipoProveedor = new TipoProveedor
{
Baja = false,
Codigo = "G",
Descripcion = "Generico",
Empresa = vehiculo.Empresa
};
DaoFactory.TipoProveedorDAO.SaveOrUpdate(tipoProveedor);
}
proveedor = new Proveedor
{
Codigo = "ST",
Descripcion = "Stock",
Empresa = vehiculo.Empresa,
TipoProveedor = tipoProveedor
};
DaoFactory.ProveedorDAO.SaveOrUpdate(proveedor);
}
}
else
{
proveedor = DaoFactory.ProveedorDAO.FindByCode(new[] { empresa }, new[] { linea }, codigoProveedor);
}
if (proveedor == null && item.Proveedor == null)
{
throw new EntityParserException("No se encontro el Proveedor con código " + codigoProveedor);
}
}
else
{
ThrowProperty("Proveedor");
}
Insumo insumo = null;
var codigoInsumo = data[Properties.Consumo.Insumo];
if (codigoInsumo != null)
{
if (codigoInsumo == string.Empty)
{
insumo = DaoFactory.InsumoDAO.FindByCode(new[] { empresa }, new[] { linea }, "FF");
if (insumo == null)
{
var tipoInsumo = DaoFactory.TipoInsumoDAO.FindByCode(new[] { empresa }, new[] { linea }, "G");
var unidadMedida = DaoFactory.UnidadMedidaDAO.FindByCode("U");
if (tipoInsumo == null)
{
tipoInsumo = new TipoInsumo
{
Codigo = "G",
DeCombustible = false,
Descripcion = "Generico",
Empresa = vehiculo.Empresa
};
DaoFactory.TipoInsumoDAO.SaveOrUpdate(tipoInsumo);
}
if (unidadMedida == null)
{
unidadMedida = new UnidadMedida
{
Codigo = "U",
Descripcion = "Unidad",
Simbolo = "Un"
};
DaoFactory.UnidadMedidaDAO.SaveOrUpdate(unidadMedida);
}
insumo = new Insumo
{
Codigo = "FF",
Descripcion = "Fondo Fijo",
Empresa = vehiculo.Empresa,
Linea = vehiculo.Linea,
TipoInsumo = tipoInsumo,
UnidadMedida = unidadMedida
};
DaoFactory.InsumoDAO.SaveOrUpdate(insumo);
}
}
else
{
insumo = DaoFactory.InsumoDAO.FindByCode(new[] { empresa }, new[] { linea }, codigoInsumo);
}
}
int igmt;
int.TryParse(data[Properties.Consumo.Gmt], out igmt);
var fecha = data[Properties.Consumo.Fecha];
if (fecha != null || item.Fecha != default(DateTime))
{
if (!fecha.AsDateTime().HasValue&& item.Fecha == default(DateTime))
{
throw new EntityParserException("La Fecha no es válida: " + fecha);
}
}
else
{
ThrowProperty("Fecha");
}
Empleado empleado = null;
var legajoEmpleado = data[Properties.Consumo.Empleado];
if (legajoEmpleado != null)
{
empleado = DaoFactory.EmpleadoDAO.FindByLegajo(empresa, linea, legajoEmpleado);
}
item.NumeroFactura = data[Properties.Consumo.NroFactura].Truncate(64);
if (vehiculo != null)
{
item.Vehiculo = vehiculo;
}
if (legajoEmpleado != null)
{
item.Empleado = empleado;
}
if (fecha.AsDateTime().HasValue)
{
item.Fecha = fecha.AsDateTime().Value.AddHours(-igmt);
}
if (data[Properties.Consumo.Km].AsDouble().HasValue)
{
item.KmDeclarados = data[Properties.Consumo.Km].AsDouble() ?? 0;
}
if (proveedor != null)
{
item.Proveedor = proveedor;
}
item.Deposito = null;
item.DepositoDestino = null;
item.Estado = ConsumoCabecera.Estados.Pagado;
item.TipoMovimiento = ConsumoCabecera.TiposMovimiento.ProveedorAVehiculo;
if (insumo != null)
{
var detalle = new ConsumoDetalle
{
ConsumoCabecera = item,
Insumo = insumo,
//Cambiar mapeo Tel3
ImporteTotal = data[Properties.Consumo.ImporteUnitario].AsDouble() ?? 0,
Cantidad = data[Properties.Consumo.Cantidad].AsDouble() ?? 1
};
detalle.ImporteUnitario = detalle.ImporteTotal / detalle.Cantidad;
item.Detalles.Add(detalle);
insumo.ValorReferencia = detalle.ImporteUnitario;
DaoFactory.InsumoDAO.SaveOrUpdate(insumo);
if (item.Vehiculo != null)
{
DaoFactory.MovOdometroVehiculoDAO.ResetByVehicleAndInsumo(item.Vehiculo, insumo);
}
}
item.ImporteTotal = item.Detalles.Cast <ConsumoDetalle>().Select(d => d.ImporteTotal).Sum();
return(item);
}
public async Task <IHttpActionResult> Update([FromBody] TipoInsumo model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try { log.Info(new MDCSet(this.ControllerContext.RouteData));
await _entityRepo.Update(model);
return(Ok("Registro actualizado exitosamente!")); }
catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e)); }
}
public async Task <IHttpActionResult> UpdateEstado([FromBody] TipoInsumo model)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
await _entityRepo.UpdateEstado(model);
return(Ok());
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
