/// <summary>
/// Remueve un Obligado Solidario al Contrato
/// </summary>
/// <param name="obligado">Obligado Solidario a remover del contrato</param>
public void RemoverObligadoSolidarioContrato(ObligadoSolidarioBO obligado)
{
try
{
if (obligado != null && obligado.Id != null)
{
if (vista.ObligadosSolidariosContrato.Find(obl => obligado.Id == obl.Id) != null)
{
var Obligados =
new List <ObligadoSolidarioBO>(vista.ObligadosSolidariosContrato);
Obligados.Remove(obligado);
vista.ObligadosSolidariosContrato = Obligados;
}
else
{
throw new Exception("El Obligado Solidario proporcionado no se encuentra asignado al contrato.");
}
}
else
{
throw new Exception(
"Se requiere de un Obligado Solidario seleccionado valido para realizar la operación.");
}
}
catch (Exception ex)
{
vista.MostrarMensaje("Inconsistencias al intertar remover un Obligado Solidario del Contrato", ETipoMensajeIU.ERROR, NombreClase + ".RemoverObligadoSolidarioContrato: " + ex.Message);
}
}
/// <summary>
/// Convierte un obligado solidario en aval
/// </summary>
/// <param name="obligado">obligado solidario que se desea transformar</param>
/// <returns>Aval resultante de la ocnversion</returns>
private AvalBO ObligadoAAval(ObligadoSolidarioBO obligado)
{
if (obligado == null)
{
return(null);
}
AvalBO aval;
switch (obligado.TipoObligado)
{
case ETipoObligadoSolidario.Fisico:
aval = new AvalFisicoBO(obligado);
break;
case ETipoObligadoSolidario.Moral:
aval = new AvalMoralBO(obligado);
if (obligado is ObligadoSolidarioMoralBO && ((ObligadoSolidarioMoralBO)obligado).Representantes != null)
{
((AvalMoralBO)aval).Representantes = new List <RepresentanteLegalBO>(((ObligadoSolidarioMoralBO)obligado).Representantes);
}
break;
default:
aval = new AvalProxyBO(obligado);
break;
}
return(aval);
}
public void AgregarObligadoSolidario(bool?validarEscritura = true)
{
string s;
if (String.IsNullOrEmpty(s = this.presentadorObligado.ValidarDatos(validarEscritura)))
{
List <ObligadoSolidarioBO> obligados = new List <ObligadoSolidarioBO>(this.vista.ObligadosSolidarios);
ObligadoSolidarioBO obligado = presentadorObligado.ObtenerDatos();
obligado.Auditoria = new AuditoriaBO
{
FC = vista.FC,
UC = vista.UC,
FUA = vista.FUA,
UUA = vista.UUA
};
obligado.Activo = true;
obligados.Add(obligado);
vista.ObligadosSolidarios = obligados;
vista.ActualizarObligadosSolidarios();
presentadorObligado.EliminarRepresentantes();
presentadorObligado.PrepararNuevo();
}
else
{
vista.MostrarMensaje("Se requiere los siguientes datos del Obligado Solidario: " + s.Substring(2), ETipoMensajeIU.ADVERTENCIA);
}
}
public void QuitarObligadoSolidario(ObligadoSolidarioBO obligado)
{
try
{
if (obligado != null)
{
if (this.vista.ObligadosSolidarios.Contains(obligado))
{
List <ObligadoSolidarioBO> obligados = new List <ObligadoSolidarioBO>(this.vista.ObligadosSolidarios);
obligados.Remove(obligado);
this.vista.ObligadosSolidarios = obligados;
this.vista.ActualizarObligadosSolidarios();
}
else
{
throw new Exception("El Obligado Solidario proporcionado no se encuentra en la lista");
}
}
else
{
throw new Exception("Se requiere un Obligado Solidario válido para la operación");
}
}
catch (Exception ex)
{
this.vista.MostrarMensaje("Inconsistencias al intentar quitar un Obligado Solidario de la lista", ETipoMensajeIU.ERROR, nombreClase + ".QuitarObligadoSolidario: " + ex.Message);
}
}
public void ActualizarObligadoSolidario()
{
string s;
try
{
if (String.IsNullOrEmpty(s = presentadorObligado.ValidarDatos()))
{
ObligadoSolidarioBO bo = presentadorObligado.ObtenerDatos();
ActualizarDatosObligadoSolidario(bo.Id);
presentadorObligado.PrepararNuevo();
HabilitarAgregarObligado();
presentadorObligado.ModoCreacion();
ActualizarVistaObligadosSolidarios();
}
else
{
MostrarMensaje("Se requiere los siguientes campos del Obligado Solidario:" + s.Substring(2), ETipoMensajeIU.INFORMACION);
}
}
catch (Exception ex)
{
this.MostrarMensaje("Error al Actualizar los datos de un Obligado Solidario", ETipoMensajeIU.ERROR, this.nombreClase + ".ActualizarRepresentanteLegal:" + ex.Message);
}
}
public void MostrarDatos(ObligadoSolidarioBO obligado)
{
if (obligado == null)
{
throw new Exception("Obligado Solidario no debe estar vacío");
}
if (obligado.DireccionPersona == null)
{
throw new Exception("la dirección del obligado solidario no debe estar vacía");
}
vista.Nombre = obligado.Nombre;
vista.Telefono = obligado.Telefono;
vista.Direccion = obligado.DireccionPersona.Calle;
vista.ObligadoID = obligado.Id;
vista.TipoObligadoSolidario = obligado.TipoObligado;
vista.RFC = obligado.RFC;
#region SC0005
if (obligado.TipoObligado == ETipoObligadoSolidario.Moral)
{
vista.RepresentantesInactivos = new List <RepresentanteLegalBO>();
vista.RepresentantesLegales = new List <RepresentanteLegalBO>(((ObligadoSolidarioMoralBO)obligado).Representantes);
vista.ActualizarRepresentantesLegales();
vista.ActaConstitutiva = obligado.ActaConstitutiva;
vista.EstablecerAcciones(true);
}
#endregion SC0005
}
/// <summary>
/// Agrega un Obligados Solidario al Contrato
/// </summary>
/// <param name="obligado">Obligado Solidario a Agregar al Contrato</param>
/// <param name="representantes">Representantes Legales del Obligado Solidario</param>
public void AgregarObligadoSolidarioContrato(ObligadoSolidarioBO obligado, List <RepresentanteLegalBO> representantes)
{
try
{
if (representantes == null)
{
vista.MostrarMensaje("Es necesario seleccionar al menos un representante legal, para el obligado solidarío.", ETipoMensajeIU.ADVERTENCIA);
}
if (representantes.Count <= 0)
{
vista.MostrarMensaje("Es necesario seleccionar al menos un representante legal, para el obligado solidarío.", ETipoMensajeIU.ADVERTENCIA);
}
if (obligado != null && obligado.Id != null)
{
if (vista.ObligadosSolidariosContrato.Find(obl => obligado.Id == obl.Id) == null)
{
if (obligado.DireccionPersona == null || string.IsNullOrEmpty(obligado.DireccionPersona.Calle))
{
var cciBR = new CuentaClienteIdealeaseBR();
List <ObligadoSolidarioBO> obls = cciBR.ConsultarObligadosSolidarios(dataContext, obligado, new CuentaClienteIdealeaseBO());
ObligadoSolidarioBO encontrado = obls.Find(ob => ob.Id == obligado.Id);
if (encontrado != null)
{
obligado = encontrado;
}
}
//SC0005
((ObligadoSolidarioMoralBO)obligado).Representantes = representantes;
var Obligados = new List <ObligadoSolidarioBO>(vista.ObligadosSolidariosContrato)
{
obligado
};
vista.ObligadosSolidariosContrato = Obligados;
}
else
{
vista.MostrarMensaje("El Obligado Solidario seleccionado ya se encuentra asignado al contrato.", ETipoMensajeIU.ADVERTENCIA);
}
}
else
{
vista.MostrarMensaje("Se requiere de un Obligado Solidario seleccionado valido para agregar al contrato.", ETipoMensajeIU.ADVERTENCIA);
}
}
catch (Exception ex)
{
vista.MostrarMensaje("Inconsistencias al intentar agregar un Obligado Solidario al contrato.", ETipoMensajeIU.ERROR, NombreClase + ".AgregarObligadoSolidarioContrato :" + ex.Message);
}
}
public void QuitarObligadoSolidario(ObligadoSolidarioBO obligado)
{
try
{
if (obligado != null)
{
if (obligado.Id != null)
{
ObligadoSolidarioBO bo = this.vista.Obligados.Find(o => o.Id == obligado.Id);
if (bo != null)
{
List <ObligadoSolidarioBO> boActivos = this.vista.Obligados;
List <ObligadoSolidarioBO> boInactivos = this.vista.ObligadosInactivos;
boActivos.Remove(bo);
bo.Activo = false;
bo.Auditoria.FUA = this.vista.FUA;
bo.Auditoria.UUA = this.vista.UUA;
boInactivos.Add(bo);
this.vista.Obligados = boActivos;
this.vista.ObligadosInactivos = boInactivos;
this.vista.ActualizarObligadosSolidarios();
}
else
{
throw new Exception("El Obligado Solidario proporcionado no se encuentra en la lista");
}
}
else
{
if (this.vista.Obligados.Contains(obligado))
{
List <ObligadoSolidarioBO> obligados = new List <ObligadoSolidarioBO>(this.vista.Obligados);
obligados.Remove(obligado);
this.vista.Obligados = obligados;
this.vista.ActualizarObligadosSolidarios();
}
else
{
throw new Exception("El Obligado Solidario proporcionado no se encuentra en la lista");
}
}
}
else
{
throw new Exception("Se requiere un Obligado Solidario válido para la operación");
}
}
catch (Exception ex)
{
this.vista.MostrarMensaje("Inconsistencias al intentar quitar el Obligado Solidario de la lista", ETipoMensajeIU.ERROR, nombreClase + ".QuitarObligadoSolidario: " + ex.Message);
}
}
public void EditarObligadoSolidario(ObligadoSolidarioBO bo)
{
try
{
this.presentadorRepresentante.PrepararNuevo();
this.HabilitarEdicionObligado();
this.DatoAInterfazObligado(bo);
presentadorObligado.ModoEdicion();
}
catch (Exception ex)
{
this.MostrarMensaje("Error al editar un Obligado Solidario", ETipoMensajeIU.ERROR, nombreClase + ".EditarObligadoSolidario" + ex.Message);
}
}
public void ObtenerRepresentanteOS(ObligadoSolidarioBO obligado)
{
var cuentaBR = new CuentaClienteIdealeaseBR();
try
{
if (obligado != null && obligado.Id != null)
{
List <ObligadoSolidarioBO> obligs = cuentaBR.ConsultarObligadosSolidarios(dataContext, obligado, new CuentaClienteIdealeaseBO {
Id = vista.CuentaClienteID
});
if (obligs == null)
{
return;
}
if (obligs.Count <= 0)
{
return;
}
if (obligs.Count > 1)
{
throw new Exception("La consulta ha devuelto más de un valor, esto podría significar un conflicto en el sistema, verifique su información por favor");
}
ObligadoSolidarioBO oblig = obligs[0];
if (oblig.TipoObligado == ETipoObligadoSolidario.Moral)
{
vista.RepresentantesObligado = cuentaBR.ConsultarRepresentantesLegales(dataContext, new CuentaClienteIdealeaseBO {
Id = vista.CuentaClienteID
}, obligado, new RepresentanteLegalBO {
Activo = true
});
vista.MostrarRepresentantesObligados(true);
}
else
{
vista.RepresentantesObligado = new List <RepresentanteLegalBO>();
}
}
}
catch (Exception ex)
{
vista.MostrarMensaje("Inconsistencias al intentar agregar un Obligado Solidario al contrato.", ETipoMensajeIU.ERROR, NombreClase + ".ObtenerRepresentanteOS :" + ex.Message);
}
}
private void ActualizarDatosObligadoSolidario(int?id)
{
ObligadoSolidarioBO obligadoSolidarioList = vista.Obligados.Find(o => o.Id == id);
ObligadoSolidarioBO obligadoSolidarioTmp = presentadorObligado.ObtenerDatos();
if (obligadoSolidarioList.TipoObligado == ETipoObligadoSolidario.Moral)
{
((ObligadoSolidarioMoralBO)obligadoSolidarioList).Representantes =
((ObligadoSolidarioMoralBO)obligadoSolidarioTmp).Representantes;
}
obligadoSolidarioList.Nombre = obligadoSolidarioTmp.Nombre;
obligadoSolidarioList.DireccionPersona.Calle = obligadoSolidarioTmp.DireccionPersona.Calle;
obligadoSolidarioList.Telefono = obligadoSolidarioTmp.Telefono;
obligadoSolidarioList.ActaConstitutiva = obligadoSolidarioTmp.ActaConstitutiva;
obligadoSolidarioList.RFC = obligadoSolidarioTmp.RFC;
}
public ObligadoSolidarioBO ConsultarObligadoSolidario(ObligadoSolidarioBO obligado)
{
ObligadoSolidarioBO obligadoa = null;
try
{
if (obligado != null && obligado.Id != null)
{
if (vista.ObligadosSolidariosContrato.Find(obl => obligado.Id == obl.Id) == null)
{
if (obligado.DireccionPersona == null || string.IsNullOrEmpty(obligado.DireccionPersona.Calle))
{
var cciBR = new CuentaClienteIdealeaseBR();
List <ObligadoSolidarioBO> obls = cciBR.ConsultarObligadosSolidarios(dataContext, obligado, new CuentaClienteIdealeaseBO());
ObligadoSolidarioBO encontrado = obls.Find(ob => ob.Id == obligado.Id);
if (encontrado != null)
{
obligadoa = encontrado;
}
}
}
else
{
vista.MostrarMensaje("El Obligado Solidario seleccionado ya se encuentra asignado al contrato.", ETipoMensajeIU.ADVERTENCIA);
}
}
else
{
vista.MostrarMensaje("Se requiere de un Obligado Solidario seleccionado valido para agregar al contrato.", ETipoMensajeIU.ADVERTENCIA);
}
return(obligadoa);
}
catch (Exception ex)
{
throw new Exception("Inconsistencias al intentar consultar un Obligado Solidario al contrato." + ex.Message);
}
}
public void MostrarDetalleObligado(ObligadoSolidarioBO obligado)
{
vista.MostrarDetalleObligado(((ObligadoSolidarioMoralBO)obligado).Representantes);
}
public void MostrarDatos(ObligadoSolidarioBO obligado)
{
this.presentador.MostrarDatos(obligado);
}
private void DatoAInterfazObligado(ObligadoSolidarioBO obligado)
{
presentadorObligado.MostrarDatos(obligado);
}
