public int Delete(TipoCambio tipoCambio)
{
string delete = "UPDATE tipo_cambio SET estatus = @estatus WHERE id =@id ";
try
{
{
NpgsqlCommand cmd = new NpgsqlCommand(delete, con);
cmd.Parameters.AddWithValue("@estatus", tipoCambio.estatus);
cmd.Parameters.AddWithValue("@id", tipoCambio.id);
con.Open();
int cantFilAfec = cmd.ExecuteNonQuery();
con.Close();
return(cantFilAfec);
}
}
catch
{
con.Close();
throw;
}
finally
{
con.Close();
}
}
public JsonResult Crear(TipoCambio tipoCambio)
{
var jsonResponse = new JsonResponse();
if (ModelState.IsValid)
{
try
{
tipoCambio.IdEmpresa = IdEmpresa;
tipoCambio.FechaCreacion = FechaCreacion;
tipoCambio.FechaModificacion = FechaModificacion;
tipoCambio.UsuarioCreacion = UsuarioActual.IdEmpleado;
tipoCambio.UsuarioModifcacion = UsuarioActual.IdEmpleado;
tipoCambio.IdEmpresa = IdEmpresa;
TipoCambioBL.Instancia.Add(tipoCambio);
jsonResponse.Success = true;
jsonResponse.Message = "Se Proceso con exito.";
}
catch (Exception ex)
{
jsonResponse.Message = ex.Message;
}
}
else
{
jsonResponse.Message = "Por favor ingrese todos los campos requeridos";
}
return(Json(jsonResponse, JsonRequestBehavior.AllowGet));
}
public JsonResult Modificar(TipoCambio tipoCambio)
{
var jsonResponse = new JsonResponse();
if (ModelState.IsValid)
{
try
{
var tipoCambioOriginal = TipoCambioBL.Instancia.Single(tipoCambio.IdTipoCambio);
tipoCambioOriginal.IdEmpresa = IdEmpresa;
tipoCambioOriginal.Fecha = tipoCambio.Fecha;
tipoCambioOriginal.IdMoneda = tipoCambio.IdMoneda;
tipoCambioOriginal.ValorVenta = tipoCambio.ValorVenta;
tipoCambioOriginal.ValorCompra = tipoCambio.ValorCompra;
tipoCambioOriginal.TipoCalculo = tipoCambio.TipoCalculo;
tipoCambioOriginal.FechaModificacion = FechaModificacion;
tipoCambioOriginal.UsuarioModifcacion = UsuarioActual.IdEmpleado;
TipoCambioBL.Instancia.Update(tipoCambioOriginal);
jsonResponse.Success = true;
jsonResponse.Message = "Se Proceso con exito";
}
catch (Exception ex)
{
jsonResponse.Message = ex.Message;
}
}
else
{
jsonResponse.Message = "Por favor ingrese todos los campos requeridos";
}
return(Json(jsonResponse, JsonRequestBehavior.AllowGet));
}
private void ssMoneda_Search(object sender, EventArgs e)
{
try
{
FrmSelectedEntity FrmSeleccionarMoneda = new FrmSelectedEntity();
EntradaInventario.Moneda = (Moneda)FrmSeleccionarMoneda.GetSelectedEntity(typeof(Moneda), "Moneda");
String filtro = "";
if (EntradaInventario.Moneda != null)
{
if (EntradaInventario.Moneda.Simbolo.Equals("US $"))
{
filtro = "IDMoneda='" + EntradaInventario.Moneda.ID + "' and Fecha='" + EntradaInventario.FechaCreacion.Date + "'";
FrmSelectedEntity FrmSelectedMoneda = new FrmSelectedEntity();
TipoCambio tc = (TipoCambio)FrmSelectedMoneda.GetSelectedEntity(typeof(TipoCambio), "Tipo de Cambio", filtro);
EntradaInventario.TipoCambioFecha = tc.TipoCambioVenta;
}
else
{
EntradaInventario.TipoCambioFecha = 1;
}
}
}
catch (Exception ex)
{
Soft.Exceptions.SoftException.ShowException(ex);
}
Mostrar();
}
/// <summary>
/// Obtener el tipo de cambio para la fecha seleccionada.
/// </summary>
private void obtenerTipoCambio()
{
try
{
_fecha = dtpFecha.Value;
_tipo_cambio = _mantenimiento.obtenerTipoCambio(_fecha);
if (_tipo_cambio == null)
{
Excepcion.mostrarMensaje("ErrorTipoCambioNoRegistrado");
_fecha_valida = false;
}
else
{
_fecha_valida = true;
}
this.validarOpciones();
}
catch (Excepcion ex)
{
ex.mostrarMensaje();
}
}
public async Task <IActionResult> Index()
{
TipoCambioSoapClient client = new TipoCambioSoapClient(EndpointConfiguration.TipoCambioSoap);
//var result = await client.AddAsync(5, 8);
var result = await client.TipoCambioDiaAsync();
var ResultOfTipoCambioBank = result.Body.TipoCambioDiaResult.CambioDolar[0];
ViewBag.ResultOfBank = ResultOfTipoCambioBank;
var contextOptions = new DbContextOptionsBuilder <Models.DBContext>()
.UseSqlServer("Server=localhost;Database=DemoAzureInsight;User Id=elvis;Password=*Disdel100;")
.Options;
using var context = new Models.DBContext(contextOptions);
Models.TipoCambio NewValueTipoCambios = new TipoCambio();
NewValueTipoCambios.Fecha = Convert.ToDateTime(ResultOfTipoCambioBank.fecha);
NewValueTipoCambios.Referencia = Convert.ToDecimal(ResultOfTipoCambioBank.referencia);
context.Add <Models.TipoCambio>(NewValueTipoCambios);
context.SaveChanges();
List <Models.TipoCambio> AllData = context.TipoCambios.ToList();
ViewBag.AllData = AllData;
return(View());
}
public List <TipoCambio> listTipoCambio(TipoCambio cambio, int jtStartIndex, int jtPageSize, string jtSorting, out int total)
{
try
{
var sort = jtSorting.Split(' ');
using (var db = new DISEntities())
{
var query = db.TipoCambios.Where(a => (a.Periodo == cambio.Periodo || cambio.Periodo == "") &&
(a.Monto == cambio.Monto || cambio.Monto == 0)).ToList();
total = query.Count;
switch (sort[0])
{
case "Monto":
query = sort[1].Equals("ASC") ? query.OrderBy(a => a.Monto).Skip(jtStartIndex).Take(jtPageSize).ToList() : query.OrderByDescending(a => a.Monto).Skip(jtStartIndex).Take(jtPageSize).ToList();
break;
case "Periodo":
query = sort[1].Equals("ASC") ? query.OrderBy(a => a.Periodo).Skip(jtStartIndex).Take(jtPageSize).ToList() : query.OrderByDescending(a => a.Periodo).Skip(jtStartIndex).Take(jtPageSize).ToList();
break;
default:
query = query.OrderBy(a => a.IdTipoCambio).Skip(jtStartIndex).Take(jtPageSize).ToList();
break;
}
return(query);
}
}
catch (Exception ex)
{
throw (new Exception(ex.Message, ex.InnerException));
}
}
/// <summary>
/// Verificar si ya se registró el tipo de cambio para una fecha determinada.
/// </summary>
/// <param name="t">Objeto TipoCambio con los datos del tipo de cambio</param>
/// <returns>Valor booleano que indica si el tipo de cmabio ya fue registrado</returns>
public bool verificarTipoCambio(TipoCambio t)
{
bool existe = false;
SqlCommand comando = _manejador.obtenerProcedimiento("SelectExisteTipoCambio");
SqlDataReader datareader = null;
_manejador.agregarParametro(comando, "@fecha", t.Fecha, SqlDbType.Date);
try
{
datareader = _manejador.ejecutarConsultaDatos(comando);
if (datareader.Read())
{
short id_encontrado = (short)datareader["pk_ID"];
existe = id_encontrado != t.Id;
}
comando.Connection.Close();
}
catch (Exception)
{
comando.Connection.Close();
throw new Excepcion("ErrorVerificarTipoCambio");
}
return(existe);
}
public async Task <TipoCambio> fGetPorDia(int day, int month, int year)
{
try
{
TipoCambio respuesta = new TipoCambio();
string diaNumero = Convert.ToString(day);
DataTable dt = obtenerDatos(month, year);
string sCompra = (from DataRow dr in dt.AsEnumerable()
where Convert.ToString(dr["Dia"]) == diaNumero
select Convert.ToString(dr["Compra"])).FirstOrDefault();
string sVenta = (from DataRow dr in dt.AsEnumerable()
where Convert.ToString(dr["Dia"]) == diaNumero
select Convert.ToString(dr["Venta"])).FirstOrDefault();
respuesta.Fecha = string.Format("{0:00}", day) + "/" + string.Format("{0:00}", month) + "/" + string.Format("{0:0000}", year);
if (sCompra.Trim().Length > 0)
{
respuesta.Compra = double.Parse(sCompra);
}
if (sVenta.Trim().Length > 0)
{
respuesta.Venta = double.Parse(sVenta);
}
respuesta.Dia = day;
respuesta.Promedio = (respuesta.Compra + respuesta.Venta) / 2D;
return(await Task.FromResult(respuesta));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <List <TipoCambio> > fGetPorMes(int month, int year)
{
try
{
List <TipoCambio> lstTc = new List <TipoCambio>();
DataTable dt = obtenerDatos(month, year);
foreach (DataRow dr in dt.Rows)
{
string diaNumero = int.Parse(dr["Dia"].ToString()).ToString("00");
TipoCambio objTc = new TipoCambio()
{
Dia = int.Parse(diaNumero),
Fecha = diaNumero + "/" + string.Format("{0:00}", month) + "/" + string.Format("{0:0000}", year),
Compra = double.Parse(dr["Compra"].ToString()),
Venta = double.Parse(dr["Venta"].ToString()),
Promedio = (double.Parse(dr["Compra"].ToString()) + double.Parse(dr["Venta"].ToString())) / 2D
};
lstTc.Add(objTc);
}
return(await Task.FromResult(lstTc));
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Mostrar el tipo de cambio.
/// </summary>
private void mostrarTipoCambio()
{
try
{
DateTime fecha = dtpFecha.Value;
_tipo = _mantenimiento.obtenerTipoCambio(fecha);
if (_tipo != null)
{
nudCompra.Value = _tipo.Compra;
nudVenta.Value = _tipo.Venta;
nudCompraEuros.Value = _tipo.CompraEuros;
nudVentaEuros.Value = _tipo.VentaEuros;
}
else
{
nudCompra.Value = 1;
nudVenta.Value = 1;
nudCompraEuros.Value = 1;
nudVentaEuros.Value = 1;
}
}
catch (Excepcion ex)
{
ex.mostrarMensaje();
}
}
public List <TipoCambio> ListadoPorMes()
{
try
{
List <TipoCambio> lstTc = new List <TipoCambio>();
DataTable dt = obtenerDatos();
foreach (DataRow dr in dt.Rows)
{
diaNumero = int.Parse(dr["Dia"].ToString()).ToString("00");
TipoCambio objTc = new TipoCambio()
{
Dia = diaNumero,
Mes = this.mes,
Anio = this.anio,
Compra = decimal.Parse(dr["Compra"].ToString()),
Venta = decimal.Parse(dr["Venta"].ToString())
};
lstTc.Add(objTc);
}
return(lstTc);
}
catch (Exception ex)
{
throw ex;
}
}
//Funcion que calcula el tipo de cambio
public async Task <TipoCambioResponse> Calcular(string fecha, string tipotransaccion, string monedaOrigen, string monedaDestino, double monto)
{
var MontoDevuelto = 0.0;
var existingCambio = await _cambioRepository.FindByFechaAndTipoTransaccionAndMonedaOrigenAndMonedaDestino(fecha, tipotransaccion, monedaOrigen, monedaDestino);
if (existingCambio.TipoTransaccion == "Venta")
{
MontoDevuelto = monto / existingCambio.MontoCambio;
MontoDevuelto = Math.Round(MontoDevuelto, 2);
}
else if (existingCambio.TipoTransaccion == "Compra")
{
MontoDevuelto = existingCambio.MontoCambio * monto;
MontoDevuelto = Math.Round(MontoDevuelto, 2);
}
TipoCambio tipoCambio = new TipoCambio();
tipoCambio.FechaTipoCambio = existingCambio.FechaTipoCambio;
tipoCambio.TipoTransaccion = existingCambio.TipoTransaccion;
tipoCambio.MonedaOrigen = existingCambio.MonedaOrigen;
tipoCambio.MonedaDestino = existingCambio.MonedaDestino;
tipoCambio.MontoCambio = Math.Round(existingCambio.MontoCambio, 4);
tipoCambio.Monto = monto;
tipoCambio.MontoTipoCambio = MontoDevuelto;
return(new TipoCambioResponse(tipoCambio));
}
public TipoCambio obtenerTipoCambio()
{
TipoCambio tipo = new TipoCambio {
CompraDolares = 3.175M, VentaDolares = 3.345M
};
return(tipo);
}
public Proceso PrimerValor(DateTime fechaEvaluar, int paso)
{
Proceso proceso = new Proceso();
proceso.Tipo = "No Insertar";
TasaCambioDiaria tasaCambioDiaria = new TasaCambioDiaria();
List <TasaCambioDiaria> listaTCD = new List <TasaCambioDiaria>();
TipoCambio tipoCambio = new TipoCambio();
List <TipoCambio> lstTc = new List <TipoCambio>();
string Mes = fechaEvaluar.Month.ToString();
if (Mes.Length == 1)
{
Mes = "0" + Mes;
}
string Dia = fechaEvaluar.Day.ToString();
if (Dia.Length == 1)
{
Dia = "0" + Dia;
}
string Anio = fechaEvaluar.Year.ToString();
lstTc = ListadoPorMes();
// listado de sunat
int existe = lstTc.Where(c => c.Anio == Anio && c.Dia == Dia && c.Mes == Mes).Count();
if (existe > 0) //si existe el dia atual en el sunat
{
tipoCambio = lstTc.Where(c => c.Anio == Anio && c.Dia == Dia && c.Mes == Mes).FirstOrDefault();
tasaCambioDiaria.Fecha = new DateTime(int.Parse(tipoCambio.Anio), int.Parse(tipoCambio.Mes), int.Parse(tipoCambio.Dia));
tasaCambioDiaria.Compra = tipoCambio.Compra;
tasaCambioDiaria.Venta = tipoCambio.Venta;
tasaCambioDiaria.Proceso = "Insert-Sunat";
proceso.Tipo = "Insertar";
proceso.ListaBaseDatos = ListadoBaseDato();
proceso.TasaCambioDiaria = tasaCambioDiaria;
}
else // se busca el valor anterior en la tabla de ntx
{
listaTCD = db.TasaCambioDiaria.ToList();
tasaCambioDiaria = listaTCD.Last();
tipoCambio.Anio = Anio;
tipoCambio.Mes = Mes;
tipoCambio.Dia = Dia;
tipoCambio.Compra = tasaCambioDiaria.Compra;
tipoCambio.Venta = tasaCambioDiaria.Venta;
tasaCambioDiaria.Fecha = new DateTime(int.Parse(tipoCambio.Anio), int.Parse(tipoCambio.Mes), int.Parse(tipoCambio.Dia));
tasaCambioDiaria.Proceso = "Insert-No act Sunat";
proceso.Tipo = "Insertar";
proceso.ListaBaseDatos = ListadoBaseDato();
proceso.TasaCambioDiaria = tasaCambioDiaria;
}
GrabarValor(tasaCambioDiaria, paso);
return(proceso);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
TipoCambio tipocambio = await db.TipoCambios.FindAsync(id);
db.TipoCambios.Remove(tipocambio);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public TipoCambio Update(TipoCambio tipoCambio)
{
try
{
return(repository.Update(tipoCambio));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <ActionResult> Edit([Bind(Include = "TipoCambioId")] TipoCambio tipocambio)
{
if (ModelState.IsValid)
{
db.Entry(tipocambio).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(tipocambio));
}
//public CompraVenta(int id = 0, TipoTransaccion transaccion = TipoTransaccion.Compra, TipoCambio tipocambio = null, decimal monto_transaccion = 0, decimal monto_cambio = 0)
//{
// this.DB_ID = id;
// this._tipo_transaccion = transaccion;
// this._tipo_cambio = tipocambio;
// this._monto_cambio = monto_cambio;
// this._monto_transaccion = monto_transaccion;
//}
public CompraVenta(int id = 0, TipoTransaccion transaccion = TipoTransaccion.Compra, TipoCambio tipocambio = null, decimal monto_transaccion = 0, decimal monto_billete = 0, decimal monto_niquel = 0,
decimal monto_cambio = 0)
{
this.DB_ID = id;
this._tipo_transaccion = transaccion;
this._tipo_cambio = tipocambio;
this._monto_cambio = monto_cambio;
this._monto_transaccion = monto_transaccion;
this.MontoBillete = monto_billete;
this.MontoNiquel = monto_niquel;
}
public List <TipoCambio> GetTpoCambioPorIdProforma(int idProforma, int idTipoCaptura)
{
string consulta = "";
consulta += " select t.id, t.moneda_id, t.valor, t.fecha ";
consulta += " from tipo_cambio t, moneda m, empresa e, proforma p, centro_costo c ";
consulta += " where t.moneda_id = m.id ";
consulta += " and e.moneda_id = m.id ";
consulta += " and p.centro_costo_id = c.id ";
consulta += " and e.id = c.empresa_id ";
consulta += " and t.fec_modif = ( ";
switch (idTipoCaptura)
{
case Constantes.TipoCapturaContable: // Busca la fecha de inicio de mes para el tipo de cambio
consulta += " select min(fec_modif) from tipo_cambio where moneda_id = m.id";
consulta += " and extract(month from fecha) = extract(month from current_date) ";
break;
case Constantes.TipoCapturaFlujo: // Busca la ultima fecha del tipo de cambio
consulta += " select max(fec_modif) from tipo_cambio where moneda_id = m.id ";
break;
}
consulta += " ) ";
consulta += " and p.id = "+ idProforma;
try
{
List <TipoCambio> lstTipoCambio = new List <TipoCambio>();
con.Open();
NpgsqlCommand cmd = new NpgsqlCommand(consulta.Trim(), con);
NpgsqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
TipoCambio detTipoCambio = new TipoCambio();
detTipoCambio.id = Convert.ToInt64(rdr["id"]);
detTipoCambio.moneda_id = Convert.ToInt32(rdr["moneda_id"]);
detTipoCambio.valor = Convert.ToInt32(rdr["valor"]);
detTipoCambio.fec_modif = Convert.ToDateTime(rdr["fec_modif"]).ToString("yyyy/mm/dd");
lstTipoCambio.Add(detTipoCambio);
}
return(lstTipoCambio);
}
catch
{
throw;
}
finally
{
con.Close();
}
}
public async Task <ActionResult> Create([Bind(Include = "TipoCambioId")] TipoCambio tipocambio)
{
if (ModelState.IsValid)
{
db.TipoCambios.Add(tipocambio);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(tipocambio));
}
public Modelo(string nomeModelo, int qtdPortas, string motor, Categorias categoria, TipoCombustivel combustivel,
TipoCambio cambio, int fabID)
{
Nome = nomeModelo;
QuantidadePortas = qtdPortas;
Motor = motor;
Categoria = categoria;
Combustivel = combustivel;
Cambio = cambio;
FabricanteID = fabID;
Carros = new List <Carro>();
}
public Modelo(string nomeModelo, int qtdPortas, string motor, Categorias categoria, TipoCombustivel combustivel,
TipoCambio cambio, int fabID)
{
Nome = nomeModelo;
QuantidadePortas = qtdPortas;
Motor = motor;
Categoria = categoria;
Combustivel = combustivel;
Cambio = cambio;
FabricanteID = fabID;
Carros = new List<Carro>();
}
public async Task <ActionResult> Actualizar([FromBody] TipoCambioDto model)
{
var tipoCambio = new TipoCambio();
tipoCambio.ID = model.ID;
tipoCambio.Moneda = model.Moneda;
tipoCambio.ValorTipoCambio = model.ValorTipoCambio;
_context.TipoCambio.Update(tipoCambio);
_context.SaveChanges();
return(Ok());
}
public ActionResult Crear()
{
ViewData["Accion"] = "Crear";
var entidad = new TipoCambio
{
ValorCompra = 0, ValorVenta = 0, Fecha = DateTime.Now,
};
PrepararDatos(ref entidad);
return(PartialView("TipoCambioPanel", entidad));
}
public Transaccion(Cuenta cuentaDeAsiento, string referencia, string detalle, DateTime fechaFactura,
decimal balance, TipoCambio tipoCambio, Comportamiento comportamientoCuenta = Comportamiento.Credito, int id = 0, decimal montoTipoCambio = 1.00m)
{
this.CuentaDeAsiento = cuentaDeAsiento;
this.Referencia = referencia;
this.Detalle = detalle;
this.FechaFactura = fechaFactura;
this.Monto = balance;
this.TipoCambio = tipoCambio;
this.ComportamientoCuenta = comportamientoCuenta;
this.Id = id;
this.MontoTipoCambio = montoTipoCambio;
}
public IHttpActionResult TipoCambio(TipoCambio tipoCambio)
{
try
{
DataSet tipocambio = bancocentral.ObtenerIndicadoresEconomicos(tipoCambio.Indicador, tipoCambio.FechaInicio, tipoCambio.FechaFin, "Emilio Campos A", "N", "*****@*****.**", token);
var valor = tipocambio.Tables[0].Rows[0].ItemArray[2].ToString();
return(Ok(valor));
}
catch
{
return(NotFound());
}
}
public frmIngresoCompraVenta(ref Monedas monedadeposito, Deposito deposito)
{
InitializeComponent();
_tipocambio = _mantenimiento.obtenerTipoCambio(DateTime.Today);
_deposito = deposito;
_monedadeposito = monedadeposito;
if (_tipocambio == null)
{
_tipocambio = _mantenimiento.obtenerTipoCambio(DateTime.Today.AddDays(-1));
}
txtTipoCambioCompra.Text = _tipocambio.Compra.ToString();
txtTipoCambioVenta.Text = _tipocambio.Venta.ToString();
txtTipoCambioCompraEur.Text = _tipocambio.CompraEuros.ToString();
txtTipoCambioVentaEur.Text = _tipocambio.VentaEuros.ToString();
if (_deposito.CompraVenta != null)
{
txtMontoTransaccion.Text = _deposito.CompraVenta.MontoTransaccion.ToString();
if (_deposito.CompraVenta.TipoTransaccion == TipoTransaccion.Compra)
{
rdbCompra.Checked = true;
//rdbVenta.Checked = false;
}
else
{
if (_deposito.CompraVenta.TipoTransaccion == TipoTransaccion.Venta)
{
rdbVenta.Checked = true;
}
else
{
if (_deposito.CompraVenta.TipoTransaccion == TipoTransaccion.CompraEuros)
{
rdbcompraeur.Checked = true;
}
else
{
rdbventaeur.Checked = true;
}
}
//rdbCompra.Checked = false;
}
nudMontoBillete.Value = _deposito.CompraVenta.MontoBillete;
nudMontoNiquel.Value = _deposito.CompraVenta.MontoNiquel;
txtMontoCambio.Text = _deposito.CompraVenta.MontoCambio.ToString();
}
else
{
txtMontoTransaccion.Text = "0";
}
}
// GET: /TipoCambio/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoCambio tipocambio = await db.TipoCambios.FindAsync(id);
if (tipocambio == null)
{
return(HttpNotFound());
}
return(View(tipocambio));
}
public int insertaTCManual(TipoCambio modelo)
{
int iResult = 0;
try
{
iResult = (new TipoCambioLogic()).insertaTCManual(modelo);
}
catch (Exception ex)
{
throw ex;
}
return(iResult);
}
public void InsertarTipoCambio(TipoCambio tipoCambio)
{
using (var dbc = new SPC_BD())
{
var _tipoCambio = dbc.TipoCambio.Where(x => x.Fecha.Month == tipoCambio.Fecha.Month &&
x.Fecha.Year == tipoCambio.Fecha.Year)
.ToList();
_tipoCambio.ForEach(x => x.Estado = false);
dbc.TipoCambio.Add(tipoCambio);
dbc.SaveChanges();
}
}
