private DateTime DeterminarFechaAplicacion(int diaCorte, _MovimientoCuenta movimiento)
{
DateTime fechaAplicacion = DateTime.Now;
if (movimiento.Oo_TipoMovimiento.St_Tipo.Equals("S"))
{
//determinando la fecha de aplicacion para las compras o gastos en la fecha de corte
diaCorte = CuentaSeleccionada.In_DiaCorte;
int diasDespuesDeCorte = movimiento.Dt_fecha.Day - diaCorte;
if (diasDespuesDeCorte >= 0)
{
//esta dentro del periodo muerto, por lo tanto se aplica hasta la proxima fecha de corte
fechaAplicacion = movimiento.Dt_fecha.AddMonths(1);
//le resto los dias sobrantes para que quede en la fecha de corte
fechaAplicacion = fechaAplicacion.AddDays(diasDespuesDeCorte * -1);
}
else
{
fechaAplicacion = movimiento.Dt_fecha.AddDays(diasDespuesDeCorte * -1);
}
fechaAplicacion = new DateTime(fechaAplicacion.Year, fechaAplicacion.Month, fechaAplicacion.Day);
}
else
{
fechaAplicacion = movimiento.Dt_fecha;
}
return(fechaAplicacion);
}
private void BorrarMovimientoPareja(_MovimientoCuenta movimiento)
{
_Cuenta cuentaAfectada = movimiento.Oo_MovimientoPareja.Oo_Cuenta;
if (cuentaAfectada != null && cuentaAfectada.Ll_MovimientosSimulados != null)
{
for (int i = 0; i < cuentaAfectada.Ll_MovimientosSimulados.Count; i++)
{
if (cuentaAfectada.Ll_MovimientosSimulados[i].Id == movimiento.Oo_MovimientoPareja.Id)
{
cuentaAfectada.Ll_MovimientosSimulados.RemoveAt(i);
cuentaAfectada.EsModificado = true;
manejador.Guardar(cuentaAfectada);
return;
}
}
}
if (cuentaAfectada != null && cuentaAfectada.Ll_Movimientos != null)
{
for (int i = 0; i < cuentaAfectada.Ll_Movimientos.Count; i++)
{
if (cuentaAfectada.Ll_Movimientos[i].Id == movimiento.Oo_MovimientoPareja.Id)
{
cuentaAfectada.Ll_Movimientos.RemoveAt(i);
cuentaAfectada.EsModificado = true;
manejador.Guardar(cuentaAfectada);
return;
}
}
}
}
void txt_MouseLeave(object sender, EventArgs e)
{
Label txt = (Label)sender;
_MovimientoCuenta movimiento = (_MovimientoCuenta)txt.Tag;
txt.ForeColor = movimiento.ColorMovimiento1;
}
void txt_MouseEnter(object sender, EventArgs e)
{
Label txt = (Label)sender;
txt.ForeColor = Color.Blue;
_MovimientoCuenta movimiento = (_MovimientoCuenta)txt.Tag;
toolTip1.SetToolTip(txt, movimiento.St_detalleMovimiento);
}
private void BorrarMovimientoDeListado(List <_MovimientoCuenta> movimientos, _MovimientoCuenta movimientoBorrar)
{
for (int i = 0; i < movimientos.Count; i++)
{
if (movimientos[i].Id == movimientoBorrar.Id)
{
movimientos.RemoveAt(i);
break;
}
}
}
void txt_MouseUp(object sender, MouseEventArgs e)
{
Label txt = (Label)sender;
_MovimientoCuenta movimiento = (_MovimientoCuenta)txt.Tag;
txt.ForeColor = movimiento.ColorMovimiento1;
if (!movimiento.Bo_EstaAplicadoAlSaldo && movimiento.Bo_EsSimulado)
{
//Herramientas.Forms.Mensajes.Informacion("El saldo es igual a 0");
CambiarMovimiento(movimiento);
}
}
private List <_MovimientoCuenta> GeneraMovimientoDeIntereses(int diaCorte, int diasPago)
{
List <_MovimientoCuenta> retorno = new List <_MovimientoCuenta>();
_TipoMovimiento tipoInteres = null; // manejador.Cargar<_TipoMovimiento>("select * from _TipoMovimiento where estaDeshabilitado = 'False' and _st_Nombre = 'Intereses Mensuales'");
if (tipoInteres == null)
{
tipoInteres = new _TipoMovimiento();
}
//tipoInteres.EsModificado = true;
tipoInteres.St_Nombre = "(Simulado) - Intereses Mensuales";
tipoInteres.St_Tipo = "S";
tipoInteres.Do_MultiplicadorSigno = 1;
//manejador.Guardar(tipoInteres);
//agregando movimientos de intereses;
TimeSpan resta = dtp_fechaHasta.Value - DateTime.Now;
int diasTotales = Herramientas.Conversiones.Formatos.DoubleRedondeoAEnteroArriba(resta.TotalDays);
DateTime fechaPartida = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
DateTime proximaFechaPago = CalcularProximaFechaPago(fechaPartida, diaCorte, diasPago);
for (int i = 0; i < diasTotales; i++)
{
DateTime fechaRecorrido = fechaPartida.AddDays(1 * i);
if (fechaRecorrido == proximaFechaPago)
{
_MovimientoCuenta movimientoIntereses = new _MovimientoCuenta();
movimientoIntereses.Do_Importe = 0;
movimientoIntereses.Oo_TipoMovimiento = tipoInteres;
movimientoIntereses.Dt_fecha = proximaFechaPago;
movimientoIntereses.Dt_fechaAplicacion = proximaFechaPago;
movimientoIntereses.Bo_EsSimulado = true;
retorno.Add(movimientoIntereses);
//calculando la proxima fecha
proximaFechaPago = CalcularProximaFechaPago(proximaFechaPago, diaCorte, diasPago);
}
}
return(retorno);
}
private void RegistrarMovimientoEnCuenta(_Cuenta Cuenta)
{
try
{
//validaciones
String labelCuentasTrans = "[@fuente->@destino] ";
if (Cuenta == null)
{
Herramientas.Forms.Mensajes.Advertencia("Seleccione una cuenta.");
return;
}
if (cmb_tipoMovimiento.SelectedItem == null)
{
Herramientas.Forms.Mensajes.Advertencia("Seleccione un tipo de movimiento");
return;
}
if (chb_varios.Checked && txt_cantidad.Text.Trim().Equals(""))
{
Herramientas.Forms.Mensajes.Advertencia("Seleccione una cantidad de movimientos.");
return;
}
if (chb_varios.Checked && !chb_cadaMes.Checked && txt_cadaDias.Text.Trim().Equals(""))
{
Herramientas.Forms.Mensajes.Advertencia("Seleccione una frecuencia para los movimientos.");
return;
}
if (txt_importe.Text.Trim().Equals(""))
{
Herramientas.Forms.Mensajes.Advertencia("Introduzca un importe para el movimiento.");
return;
}
if (!EsSimulacion && Cuenta == null)
{
Herramientas.Forms.Mensajes.Advertencia("Seleccione una cuenta");
return;
}
//checando si se hara un movimiento a otra cuenta
_Cuenta cuentaAAfectar = null;
_TipoMovimiento tipoMovimientoCuentaAAfectar = null;
if (cmb_CuentasAAfectar.SelectedIndex >= 0)
{
cuentaAAfectar = cuentas[cmb_CuentasAAfectar.SelectedIndex];
if (cmb_TiposdeMovimiento.SelectedItem == null)
{
Herramientas.Forms.Mensajes.Exclamacion("Debes seleccionar el tipo de movimiento para la cuenta a afectar.");
return;
}
tipoMovimientoCuentaAAfectar = tiposMovimientos[cmb_TiposdeMovimiento.SelectedIndex];
if (tiposMovimientos[cmb_tipoMovimiento.SelectedIndex].Do_MultiplicadorSigno == tiposMovimientos[cmb_TiposdeMovimiento.SelectedIndex].Do_MultiplicadorSigno)
{
Herramientas.Forms.Mensajes.Exclamacion("Debes seleccionar movimientos de cuenta que sean opuestos.");
return;
}
}
//se crea el movimiento
_MovimientoCuenta movimiento = new _MovimientoCuenta();
movimiento.EsModificado = true;
movimiento.Oo_TipoMovimiento = tiposMovimientos[cmb_tipoMovimiento.SelectedIndex];
double importe = Convert.ToDouble(txt_importe.Text);
String pre = "";
//se determina el sentido de la operacion
if (cuentaAAfectar != null)
{
if ((movimiento.Oo_TipoMovimiento.Do_MultiplicadorSigno) == 1)
{
labelCuentasTrans = labelCuentasTrans.Replace("@fuente", Cuenta.St_NombreCuenta).Replace("@destino", cuentaAAfectar.St_NombreCuenta);
}
else
{
labelCuentasTrans = labelCuentasTrans.Replace("@fuente", cuentaAAfectar.St_NombreCuenta).Replace("@destino", Cuenta.St_NombreCuenta);
}
if (!txt_detalleMovimiento.Text.Trim().Equals(""))
{
labelCuentasTrans += " | " + txt_detalleMovimiento.Text;
}
}
else
{
labelCuentasTrans = "";
}
//se calcula el importe y se agrega el prefijo de los pagos
movimiento.St_detalleMovimiento = labelCuentasTrans;
if (chb_varios.Checked)
{
pre = " de " + txt_cantidad.Text;
if (!txt_detalleMovimiento.Text.Trim().Equals(""))
{
pre += " | ";
}
else
{
pre += " | " + movimiento.Oo_TipoMovimiento.St_Nombre;
}
//si se divide en multiples pagos, se divide entre el numero de pagos, si no el importe se repite
if (movimiento.Oo_TipoMovimiento.Bo_SeDivideEnMultiplesPagos)
{
importe = importe / Convert.ToDouble(txt_cantidad.Text);
}
//se agrega el pago numero 1 de varios
movimiento.St_detalleMovimiento += "1" + pre;
}
else if (labelCuentasTrans.Equals(""))
{
movimiento.St_detalleMovimiento = movimiento.Oo_TipoMovimiento.St_Nombre;
}
//se agrega la bandera para saber si es movimiento simulado
movimiento.Bo_EsSimulado = EsSimulacion;
movimiento.Do_Importe = importe;
movimiento.Dt_fecha = dtp_fecha.Value;
//se determina la fecha de aplicacion, si es de ahorro es inmediato, sino se calcula las fechas de corte y pago
if (Cuenta.Bo_EsDeAhorro || movimiento.Oo_TipoMovimiento.Bo_SeAplicaInmediato)
{
movimiento.Dt_fechaAplicacion = movimiento.Dt_fecha;
}
else
{
movimiento.Dt_fechaAplicacion = DeterminarFechaAplicacion(Cuenta.In_DiaCorte, movimiento);
}
if (!txt_detalleMovimiento.Text.Trim().Equals("") && labelCuentasTrans.Equals(""))
{
movimiento.St_detalleMovimiento += " | " + txt_detalleMovimiento.Text;
}
//se crea el movimiento relacionado si se da el caso
_MovimientoCuenta movimientoRelacionado = null;
if (cuentaAAfectar != null)
{
movimientoRelacionado = new _MovimientoCuenta();
movimientoRelacionado.EsModificado = true;
movimientoRelacionado.Bo_EsSimulado = EsSimulacion;
movimientoRelacionado.St_detalleMovimiento = movimiento.St_detalleMovimiento;
movimientoRelacionado.Do_Importe = movimiento.Do_Importe;
movimientoRelacionado.Oo_TipoMovimiento = tipoMovimientoCuentaAAfectar;
movimientoRelacionado.Dt_fecha = movimiento.Dt_fecha;
if (cuentaAAfectar.Bo_EsDeAhorro || movimientoRelacionado.Oo_TipoMovimiento.Bo_SeAplicaInmediato)
{
movimientoRelacionado.Dt_fechaAplicacion = movimientoRelacionado.Dt_fecha;
}
else
{
movimientoRelacionado.Dt_fechaAplicacion = DeterminarFechaAplicacion(cuentaAAfectar.In_DiaCorte, movimientoRelacionado);
}
movimientoRelacionado.Oo_Cuenta = cuentaAAfectar;
movimientoRelacionado.Oo_MovimientoPareja = movimiento;
movimiento.Oo_MovimientoPareja = movimientoRelacionado;
if (cuentaAAfectar.Ll_Movimientos == null)
{
cuentaAAfectar.Ll_Movimientos = new List <_MovimientoCuenta>();
}
if (cuentaAAfectar.Ll_MovimientosSimulados == null)
{
cuentaAAfectar.Ll_MovimientosSimulados = new List <_MovimientoCuenta>();
}
cuentaAAfectar.EsModificado = true;
}
//si no es una simulacion y el movimiento es antes o igual a hoy, se calcula el saldo de la cuenta
double saldoCuentaAnterior = Cuenta.Do_saldo;
//se obtiene el factor para saber el sentido de los movimientos
double multiplicadorCuenta = 1;
if (Cuenta.Bo_EsDeAhorro)
{
multiplicadorCuenta = -1;
}
if (!EsSimulacion && movimiento.Dt_fechaAplicacion <= DateTime.Now)
{
movimiento.Bo_EstaAplicadoAlSaldo = true;
//el multiplicador determina si el dinero entra o sale dependiendo si es credito o ahorro
movimiento.Do_Saldo = Cuenta.Do_saldo + (movimiento.Do_Importe * movimiento.Oo_TipoMovimiento.Do_MultiplicadorSigno * multiplicadorCuenta);
//si la cuenta es de ahorro y deseas retirar mas del saldo, se manda el error
if (Cuenta.Bo_EsDeAhorro && movimiento.Do_Saldo < 0)
{
Herramientas.Forms.Mensajes.Exclamacion("No cuenta con saldo suficiente en la cuenta para realizar el registro.");
return;
}
else
{
Cuenta.Do_saldo = movimiento.Do_Saldo;
}
}
//calcular en saldo
if (cuentaAAfectar != null)
{
if (!EsSimulacion && movimientoRelacionado.Dt_fechaAplicacion <= DateTime.Now)
{
double multiplicadorCuentaAsociada = 1;
if (cuentaAAfectar.Bo_EsDeAhorro)
{
multiplicadorCuentaAsociada = -1;
}
movimientoRelacionado.Bo_EstaAplicadoAlSaldo = true;
movimientoRelacionado.Do_Saldo = cuentaAAfectar.Do_saldo + (movimientoRelacionado.Do_Importe * movimientoRelacionado.Oo_TipoMovimiento.Do_MultiplicadorSigno * multiplicadorCuentaAsociada);
//lo mismo para la cuenta relacionada
if (cuentaAAfectar.Bo_EsDeAhorro && movimientoRelacionado.Do_Saldo < 0)
{
Cuenta.Do_saldo = saldoCuentaAnterior;
Herramientas.Forms.Mensajes.Exclamacion("No cuenta con saldo suficiente en la cuenta para realizar el registro.");
return;
}
else
{
cuentaAAfectar.Do_saldo = movimientoRelacionado.Do_Saldo;
}
}
}
if (Cuenta.Ll_Movimientos == null)
{
Cuenta.Ll_Movimientos = new List <_MovimientoCuenta>();
}
movimiento.Oo_Cuenta = Cuenta;
//si no es simulacion se actualiza para guardar los movimientos
if (!EsSimulacion)
{
Cuenta.EsModificado = true;
Cuenta.Ll_Movimientos.Add(movimiento);
if (cuentaAAfectar != null)
{
cuentaAAfectar.Ll_Movimientos.Add(movimientoRelacionado);
}
}
else
{
//si es simulacion, solo se agrega el movimiento a los movimientos simulados
MovimientosSimulados.Add(movimiento);
if (cuentaAAfectar != null)
{
cuentaAAfectar.Ll_MovimientosSimulados.Add(movimientoRelacionado);
}
}
//en esta seccion se agregan los movimientos pendientes de los varios anteriores
if (chb_varios.Checked)
{
int cantidad = Convert.ToInt32(txt_cantidad.Text);
cantidad--; //restamos el que ya se agrego
int frecuencia = 0;
if (!chb_cadaMes.Checked)
{
frecuencia = Convert.ToInt32(txt_cadaDias.Text);
}
for (int i = 1; i <= cantidad; i++)
{
_MovimientoCuenta movimientoFuturo = new _MovimientoCuenta();
movimientoFuturo.EsModificado = true;
movimientoFuturo.Bo_EsSimulado = EsSimulacion;
movimientoFuturo.Do_Importe = importe;
movimientoFuturo.St_detalleMovimiento = labelCuentasTrans + (i + 1) + pre + txt_detalleMovimiento.Text;
movimientoFuturo.Oo_Cuenta = Cuenta;
movimientoFuturo.Bo_EstaAplicadoAlSaldo = false;
//se crea el movimento relacionado si se da el caso
_MovimientoCuenta movimientoFuturoRelacionado = null;
if (cuentaAAfectar != null)
{
movimientoFuturoRelacionado = new _MovimientoCuenta();
movimientoFuturoRelacionado.EsModificado = true;
movimientoFuturoRelacionado.Bo_EsSimulado = EsSimulacion;
movimientoFuturoRelacionado.Do_Importe = importe;
movimientoFuturoRelacionado.St_detalleMovimiento = movimientoFuturo.St_detalleMovimiento;
movimientoFuturoRelacionado.Oo_Cuenta = cuentaAAfectar;
movimientoFuturoRelacionado.Oo_MovimientoPareja = movimientoFuturo;
movimientoFuturo.Oo_MovimientoPareja = movimientoFuturoRelacionado;
movimientoFuturoRelacionado.Bo_EstaAplicadoAlSaldo = false;
}
//se determina la proxima fecha ya sea un mes o dias
if (chb_cadaMes.Checked)
{
movimientoFuturo.Dt_fecha = dtp_fecha.Value.AddMonths(1 * i);
}
else
{
movimientoFuturo.Dt_fecha = dtp_fecha.Value.AddDays(frecuencia * i);
}
//se le asigna el tipo de movimiento
movimientoFuturo.Oo_TipoMovimiento = tiposMovimientos[cmb_tipoMovimiento.SelectedIndex];
//si es cuenta de ahorro, la fecha es inmediata y si no se calcula como anteriormente se hizo
if (Cuenta.Bo_EsDeAhorro || movimientoFuturo.Oo_TipoMovimiento.Bo_SeAplicaInmediato)
{
movimientoFuturo.Dt_fechaAplicacion = movimientoFuturo.Dt_fecha;
}
else
{
movimientoFuturo.Dt_fechaAplicacion = DeterminarFechaAplicacion(Cuenta.In_DiaCorte, movimientoFuturo);
}
//se determina la fecha del movimiento relacionado futuro
if (cuentaAAfectar != null)
{
movimientoFuturoRelacionado.Dt_fecha = movimientoFuturo.Dt_fecha;
movimientoFuturoRelacionado.Oo_TipoMovimiento = movimientoRelacionado.Oo_TipoMovimiento;
if (cuentaAAfectar.Bo_EsDeAhorro || movimientoFuturoRelacionado.Oo_TipoMovimiento.Bo_SeAplicaInmediato)
{
movimientoFuturoRelacionado.Dt_fechaAplicacion = movimientoFuturoRelacionado.Dt_fecha;
}
else
{
movimientoFuturoRelacionado.Dt_fechaAplicacion = DeterminarFechaAplicacion(cuentaAAfectar.In_DiaCorte, movimientoFuturoRelacionado);
}
}
//si no es una simulacion, se agrega a los movimientos normales, si si entonces a los movimientos simulados
if (!EsSimulacion)
{
Cuenta.Ll_Movimientos.Add(movimientoFuturo);
if (cuentaAAfectar != null)
{
cuentaAAfectar.Ll_Movimientos.Add(movimientoFuturoRelacionado);
}
}
else
{
MovimientosSimulados.Add(movimientoFuturo);
if (cuentaAAfectar != null)
{
cuentaAAfectar.Ll_MovimientosSimulados.Add(movimientoFuturoRelacionado);
}
}
}
}
//la cuenta se guarda
manejador.IniciarTransaccion();
manejador.Guardar(Cuenta);
if (cuentaAAfectar != null)
{
manejador.Guardar(cuentaAAfectar);
}
manejador.TerminarTransaccion();
CargarCuentasAAfectar();
if (!EsSimulacion)
{
Limpiar();
Herramientas.Forms.Mensajes.Informacion("Guardado con éxito.");
CargarCuentaSeleccionada();
}
else
{
Hide();
}
}
catch (Exception ex)
{
manejador.DeshacerTransaccion();
Herramientas.Forms.Mensajes.Error(ex.Message);
}
}
private void CambiarMovimiento(_MovimientoCuenta movimiento)
{
try
{
if (new DateTime(movimiento.Dt_fechaAplicacion.Year, movimiento.Dt_fechaAplicacion.Month, movimiento.Dt_fechaAplicacion.Day) != new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day))
{
if (Herramientas.Forms.Mensajes.PreguntaAdvertenciaSIoNO("El movimiento simulado esta programado para una fecha posterior, ¿desea cambiar su fecha de aplicación para el dia de hoy?"))
{
movimiento.Dt_fechaAplicacion = DateTime.Now;
}
else
{
return;
}
}
if (!Herramientas.Forms.Mensajes.PreguntaAdvertenciaSIoNO("¿Desea aplicar el movimiento simulado como movimiento real?"))
{
return;
}
BorrarMovimientoDeListado(Cuenta.Ll_MovimientosSimulados, movimiento);
double multiplicador = 1;
if (Cuenta.Bo_EsDeAhorro)
{
multiplicador = -1;
}
double importe = movimiento.Do_Importe * movimiento.Oo_TipoMovimiento.Do_MultiplicadorSigno * multiplicador;
Cuenta.Do_saldo = Cuenta.Do_saldo + importe;
movimiento.Do_Saldo = Cuenta.Do_saldo;
Cuenta.Ll_Movimientos.Add(movimiento);
movimiento.Bo_EsSimulado = false;
movimiento.EsModificado = true;
movimiento.Bo_EstaAplicadoAlSaldo = true;
Cuenta.EsModificado = true;
_Cuenta cuentaAsociada = null;
if (movimiento.Oo_MovimientoPareja != null)
{
cuentaAsociada = movimiento.Oo_MovimientoPareja.Oo_Cuenta;
BorrarMovimientoDeListado(cuentaAsociada.Ll_MovimientosSimulados, movimiento.Oo_MovimientoPareja);
double multiplicador2 = 1;
if (cuentaAsociada.Bo_EsDeAhorro)
{
multiplicador2 = -1;
}
double importe2 = movimiento.Oo_MovimientoPareja.Do_Importe * movimiento.Oo_MovimientoPareja.Oo_TipoMovimiento.Do_MultiplicadorSigno * multiplicador2;
cuentaAsociada.Do_saldo = cuentaAsociada.Do_saldo + importe2;
movimiento.Oo_MovimientoPareja.Do_Saldo = cuentaAsociada.Do_saldo;
movimiento.Oo_MovimientoPareja.Bo_EsSimulado = false;
movimiento.Oo_MovimientoPareja.Bo_EstaAplicadoAlSaldo = true;
cuentaAsociada.Ll_Movimientos.Add(movimiento.Oo_MovimientoPareja);
cuentaAsociada.EsModificado = true;
movimiento.Oo_MovimientoPareja.EsModificado = true;
}
manejador.IniciarTransaccion();
if (cuentaAsociada != null)
{
manejador.Guardar(cuentaAsociada);
}
manejador.Guardar(Cuenta);
manejador.TerminarTransaccion();
actualizarSaldosEvento();
Herramientas.Forms.Mensajes.Informacion("Movimiento aplicado con éxito.");
}
catch (Exception ex)
{
manejador.DeshacerTransaccion();
Herramientas.Forms.Mensajes.Error(ex.Message);
}
}
private void btn_borrarMovimientoSimulado_Click(object sender, EventArgs e)
{
if (CuentaSeleccionada == null)
{
Herramientas.Forms.Mensajes.Exclamacion("Seleccione una cuenta primero!");
return;
}
if (!Herramientas.Forms.Mensajes.PreguntaAdvertenciaSIoNO("¿Está seguro que desea eliminar el movimiento seleccionado?"))
{
return;
}
int filaSeleccionada = dgv_proyeccion.CurrentRow.Index;
_MovimientoCuenta movimientoE = movimientosSimuladosTemp[filaSeleccionada];
if (movimientoE != null && !movimientoE.Bo_EsSimulado)
{
if (!Herramientas.Forms.Mensajes.PreguntaAdvertenciaSIoNO("El movimiento que desea eliminar no es simulado, ¿desea continuar?"))
{
return;
}
}
if (dgv_proyeccion.CurrentRow.Index >= 0)
{
if (movimientoE != null)
{
if (!movimientoE.Bo_EsSimulado && new DateTime(movimientoE.Dt_fechaAplicacion.Year, movimientoE.Dt_fechaAplicacion.Month, movimientoE.Dt_fechaAplicacion.Day) <= new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day))
{
Herramientas.Forms.Mensajes.Exclamacion("No es posible eliminar el movimiento que seleccionó porque ya fue aplicado al saldo.");
return;
}
try
{
manejador.IniciarTransaccion();
if (movimientoE.Oo_MovimientoPareja != null)
{
BorrarMovimientoPareja(movimientoE);
}
if (CuentaSeleccionada.Ll_MovimientosSimulados != null)
{
CuentaSeleccionada.Ll_MovimientosSimulados.Remove(movimientoE);
}
if (CuentaSeleccionada.Ll_Movimientos != null)
{
CuentaSeleccionada.Ll_Movimientos.Remove(movimientoE);
}
CuentaSeleccionada.EsModificado = true;
manejador.Guardar(CuentaSeleccionada);
manejador.TerminarTransaccion();
Herramientas.Forms.Mensajes.Informacion("Movimiento eliminado con éxito");
GenerarProyeccion(CuentaSeleccionada);
}
catch (Exception ex)
{
Herramientas.Forms.Mensajes.Error(ex.Message);
}
}
else
{
Herramientas.Forms.Mensajes.Exclamacion("No es posible eliminar el movimiento que seleccionó.");
}
}
else
{
Herramientas.Forms.Mensajes.Exclamacion("Seleccione el movimiento a eliminar");
}
}
