Ejemplo n.º 1
0
        /// <summary>
        /// Mueve el pago a la Consulta de Pagos Por Facturar
        /// </summary>
        /// <param name="pagoID"></param>
        public void MoverAFacturar(int pagoID)
        {
            object pago    = null;
            string mensaje = "No se puede actualizar el pago, el cliente no cuenta con crédito en tipo de moneda ";

            if (ETipoEmpresa.Idealease == (ETipoEmpresa)this.Vista.UnidadOperativaID)
            {
                pago = new PagoUnidadContratoBOF {
                    PagoID = pagoID
                }
            }
            ;
            else
            {
                pago = new PagoContratoPSLBOF {
                    PagoContratoID = pagoID
                }
            };

            MonitorCreditoClienteBR monitorCreditoBR = new MonitorCreditoClienteBR();
            var usr = new UsuarioBO {
                Id = Vista.UsuarioID
            };
            var adscripcion = new AdscripcionBO {
                UnidadOperativa = new UnidadOperativaBO {
                    Id = Vista.UnidadOperativaID
                }
            };
            var seguridadBO = new SeguridadBO(Guid.Empty, usr, adscripcion);

            if (monitorCreditoBR.LiberarPagoCredito(FacadeBR.ObtenerConexion(), ref pago, seguridadBO))
            {
                // Si es correcto, se quita el pago de la lista de pagos no-facturados.
                if (pago is PagoUnidadContratoBOF || pago is PagoUnidadContratoBO)
                {
                    this.Vista.PagosConsultados.Remove(Vista.PagosConsultados.First(p => p.PagoID == (pago as PagoUnidadContratoBO).PagoID));
                }
                else if (pago is PagoContratoPSLBO)
                {
                    this.Vista.PagosConsultadosPSL.Remove(Vista.PagosConsultadosPSL.First(p => p.PagoContratoID == (pago as PagoContratoPSLBO).PagoContratoID));
                }

                Vista.ActualizarMarcadoresEnviarAFacturar();
                Vista.CargarPagosConsultados();
            }
            else
            {
                if (pago is PagoUnidadContratoBOF || pago is PagoUnidadContratoBO)
                {
                    mensaje += (pago as PagoUnidadContratoBO).Divisa.MonedaDestino.Codigo;
                }
                else if (pago is PagoContratoPSLBO)
                {
                    mensaje += (pago as PagoContratoPSLBO).Divisa.MonedaDestino.Codigo;
                }

                Vista.MostrarMensaje(mensaje, ETipoMensajeIU.INFORMACION);
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Consultar los pagos en base a filtro proporcionados
        /// </summary>
        /// <param name="bof"></param>
        private void Consultar(PagoUnidadContratoBOF bof)
        {
            var resultado = Controlador.ConsultarFiltroSinCuentas(dataContext, bof);

            Vista.PagosConsultados = resultado;

            Vista.CargarPagosConsultados();
        }
        /// <summary>
        /// Obtiene los Pagos del Contrato
        /// </summary>
        /// <param name="contratoId">Identificador del Contrato al cual pertencen los pagos</param>
        /// <returns></returns>
        private List <PagoUnidadContratoManttoBO> ObtenerPagosContrato(int?contratoId)
        {
            //SC0026, Utilización de clase concreta segun el tipo de contrato
            var pagoUnidadContrato = new PagoUnidadContratoBOF
            {
                ReferenciaContrato = new ReferenciaContratoBO {
                    ReferenciaContratoID = contratoId
                }
            };
            List <PagoUnidadContratoBO> pagoUnidad = pagoCtrl.Consultar(dctx, pagoUnidadContrato);

            return(pagoUnidad.Cast <PagoUnidadContratoManttoBO>().ToList());
        }
        /// <summary>
        /// Consultar los pagos en base a filtro proporcionados
        /// </summary>
        /// <param name="bof"></param>
        private void Consultar(PagoUnidadContratoBOF bof)
        {
            List <PagoUnidadContratoBO> listaPagos = new List <PagoUnidadContratoBO>();

            listaPagos = Controlador.ConsultarFiltroSinCuentas(dataContext, bof);

            if (Vista.UltimosPagos == null)
            {
                Vista.UltimosPagos = new List <PagoUnidadContratoBO>();
                Vista.UltimosPagos.AddRange(listaPagos);
            }
            Vista.PagosConsultados = listaPagos;

            Vista.CargarPagosConsultados();
        }
        private short UltimoPago(int?contratoId)
        {
            var pagoBR = new PagoUnidadContratoBR();

            //SC0026, Utilización de clase concreta segun el tipo de contrato
            var pago = new PagoUnidadContratoBOF
            {
                ReferenciaContrato = new ReferenciaContratoBO {
                    ReferenciaContratoID = contratoId
                }
            };

            var pagos = pagoBR.Consultar(dataContext, pago);

            var max = pagos.Max(p => p.NumeroPago);

            return(max ?? 0);
        }
        /// <summary>
        /// Valida los campos necesarios para poder realizar el cambio de sucursal
        /// </summary>
        /// <returns>Cadena que contiene los elementos que faltan por completar</returns>
        private string ValidarCampos()
        {
            String s = String.Empty;

            if (this.vista.SucursalIdNueva == null)
            {
                s = String.IsNullOrEmpty(s) ? "SucursalId" : ", SucursalId";
            }
            if (this.vista.SucursalNombreNueva == null)
            {
                s = String.IsNullOrEmpty(s) ? "Nombre Sucursal" : ", Nombre Sucursal";
            }
            if (!String.IsNullOrEmpty(s))
            {
                return("Los siguientes campos no pueden estar vacios: " + s);
            }

            if (this.vista.SucursalIdAntigua == this.vista.SucursalIdNueva)
            {
                return("El contrato ya pertenece a la Sucursal de " + this.vista.SucursalNombreAntigua + ", seleccione otra Sucursal");
            }

            PagoUnidadContratoBR  pagoBr = new PagoUnidadContratoBR();
            PagoUnidadContratoBOF pago   = new PagoUnidadContratoBOF()
            {
                ReferenciaContrato = new ReferenciaContratoBO()
                {
                    ReferenciaContratoID = this.vista.ContratoId
                }, EnviadoFacturacion = false, Activo = true
            };
            DateTime fechaHoy             = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 23, 59, 59);
            var      listaPagosPendientes = pagoBr.Consultar(this.dataContext, pago);

            if (listaPagosPendientes.Any())
            {
                if (listaPagosPendientes.Any(x => x.FechaVencimiento < fechaHoy))
                {
                    return("Aún existen pagos pendientes por enviar a Facturar del Día de Hoy. Envie los pagos a facturar para poder cambiar el Contrato de Sucursal");
                }
            }

            return(String.Empty);
        }
        private List <PagoUnidadContratoFSLBO> ObtenerPagos(ContratoFSLBO contrato, DateTime FechaCierre)
        {
            var pagoBR = new PagoUnidadContratoBR();

            var pago = new PagoUnidadContratoBOF
            {
                ReferenciaContrato = new ReferenciaContratoBO {
                    ReferenciaContratoID = contrato.ContratoID, UnidadOperativa = new UnidadOperativaBO {
                        Id = vista.UnidadOperativaContratoID
                    }
                },
                Facturado = false,
                FechaVencimientoInicial = FechaCierre, Sucursales = new List <SucursalBO> {
                    contrato.Sucursal
                },
            };

            var pagos = pagoBR.ConsultarFiltroSinCuentas(dataContext, pago, true);

            return(pagos.Cast <PagoUnidadContratoFSLBO>().ToList());
        }
        /// <summary>
        /// Determina si es posible generar el pago adicional del contrato
        /// </summary>
        /// <returns>Devuelve la inconsitencia encontrada para genera el pago adicional</returns>
        private string ValidarPagoAdicional()
        {
            if (this.vista.TipoContrato == null)
            {
                return("No se ha seleccionado del Departamento del Contrato");
            }
            if (this.vista.SucursalID == null)
            {
                return("No se ha seleccionado la Sucursal del Contrato");
            }
            if (String.IsNullOrEmpty(this.vista.FolioContrato))
            {
                return("No se ha introducido el Folio del Contrato");
            }

            ContratoBO contratoBo = null;

            List <ContratoBO> contratos = new List <ContratoBO>();

            switch (vista.TipoContrato)
            {
            case ETipoContrato.RD:
                contratoBo = new ContratoRDBO {
                    NumeroContrato = vista.FolioContrato, Sucursal = new SucursalBO {
                        Id = vista.SucursalID
                    }, Estatus = EEstatusContrato.EnCurso
                };
                var contratosRD = new ContratoRDBR().Consultar(this.dctx, (ContratoRDBO)contratoBo);
                contratos.AddRange(contratosRD);
                break;

            case ETipoContrato.FSL:
                contratoBo = new ContratoFSLBO {
                    NumeroContrato = vista.FolioContrato, Sucursal = new SucursalBO {
                        Id = vista.SucursalID
                    }, Estatus = EEstatusContrato.EnCurso
                };
                var contratosFsl = new ContratoFSLBR().Consultar(this.dctx, (ContratoFSLBO)contratoBo);
                contratos.AddRange(contratosFsl);
                break;

            case ETipoContrato.CM:
            case ETipoContrato.SD:
                contratoBo = new ContratoManttoBO {
                    NumeroContrato = vista.FolioContrato, Tipo = vista.TipoContrato, Sucursal = new SucursalBO {
                        Id = vista.SucursalID
                    }, Estatus = EEstatusContrato.EnCurso
                };
                var contratosMantto = new ContratoManttoBR().Consultar(this.dctx, (ContratoManttoBO)contratoBo);
                contratos.AddRange(contratosMantto);
                break;
            }

            if (!contratos.Any())
            {
                return("No se encontró el Contrato solicitado");
            }
            switch (vista.TipoContrato)
            {
            case ETipoContrato.RD:
                var contratoRD = contratos.FirstOrDefault() as ContratoRDBO;
                if (!String.IsNullOrEmpty(TiempoMaximoRecepcionRD))
                {
                    if (DateTime.Now < contratoRD.FechaPromesaDevolucion.Value.AddHours(int.Parse(TiempoMaximoRecepcionRD)))
                    {
                        return("Deben pasar al menos " + TiempoMaximoRecepcionRD + " hrs para poder generar un pago adicional después de la Fecha de Promesa de Devolución.");
                    }
                }

                break;
            }
            this.vista.ContratoID = contratos.FirstOrDefault().ContratoID;

            PagoUnidadContratoBO pagoBo = new PagoUnidadContratoBOF {
                ReferenciaContrato = new ReferenciaContratoBO()
                {
                    ReferenciaContratoID = this.vista.ContratoID
                }
            };
            PagoUnidadContratoBR pagoBr = new PagoUnidadContratoBR();
            var pagos = pagoBr.Consultar(this.dctx, (PagoUnidadContratoBO)pagoBo);

            if (!pagos.Any())
            {
                return("No se han generado Pagos para el Contrato");
            }

            var ultimoPago = pagos.Last(x => x.Activo.Value);

            if (ultimoPago.EnviadoFacturacion != null && !ultimoPago.EnviadoFacturacion.Value)
            {
                return("No se ha Facturado el Último Pago Activo del Contrato");
            }

            this.ultimoPagoContrato = ultimoPago;

            return(null);
        }
        /// <summary>
        /// Metodo que genera el pago adicional
        /// </summary>
        public void GenerarPagoAdicional()
        {
            try
            {
                string validacion = this.ValidarPagoAdicional();
                if (!String.IsNullOrEmpty(validacion))
                {
                    this.vista.MostrarMensaje("No se puede generar el pago Adicional: " + validacion, ETipoMensajeIU.INFORMACION);
                    return;
                }

                ContratoBO        contratoBo     = null;
                IGeneradorPagosBR generadorPagos = null;
                SeguridadBO       seguridadBo    = this.CrearObjetoSeguridad();
                List <ContratoBO> contratos      = new List <ContratoBO>();
                switch (vista.TipoContrato)
                {
                case ETipoContrato.RD:
                    contratoBo = new ContratoRDBO {
                        ContratoID = this.vista.ContratoID
                    };
                    var contratosRd = new ContratoRDBR().ConsultarCompleto(this.dctx, (ContratoRDBO)contratoBo, false);
                    contratos.AddRange(contratosRd);
                    generadorPagos = new GeneradorPagoRDBR();
                    break;

                case ETipoContrato.FSL:
                    contratoBo = new ContratoFSLBO {
                        ContratoID = this.vista.ContratoID
                    };
                    var contratosFsl = new ContratoFSLBR().ConsultarCompleto(this.dctx, (ContratoFSLBO)contratoBo);
                    contratos.AddRange(contratosFsl);
                    generadorPagos = new GeneradorPagosFSLBR();
                    break;

                case ETipoContrato.CM:
                case ETipoContrato.SD:
                    contratoBo = new ContratoManttoBO {
                        ContratoID = this.vista.ContratoID
                    };
                    var contratosMantto = new ContratoManttoBR().ConsultarCompleto(this.dctx, (ContratoManttoBO)contratoBo, true, false);
                    contratos.AddRange(contratosMantto);
                    generadorPagos = new GeneradorPagosManttoBR();
                    break;
                }
                if (generadorPagos == null)
                {
                    throw new Exception("No se pudo determinar el Tipo del Pago a Generar.");
                }

                generadorPagos.GenerarPagoAdicional(this.dctx, contratos.First(), (ultimoPagoContrato.NumeroPago.Value + 1), seguridadBo, false, true);
                PagoUnidadContratoBO pagoBo = new PagoUnidadContratoBOF {
                    ReferenciaContrato = new ReferenciaContratoBO()
                    {
                        ReferenciaContratoID = this.vista.ContratoID
                    }
                };
                PagoUnidadContratoBR pagoBr = new PagoUnidadContratoBR();
                var pagos = pagoBr.Consultar(this.dctx, (PagoUnidadContratoBO)pagoBo);

                this.Inicializar();

                this.vista.MostrarMensaje("El pago " + pagos.Last().NumeroPago.ToString() + " con Fecha " + pagos.Last().FechaVencimiento.Value.ToShortDateString() + " se ha Creado con Éxito.", ETipoMensajeIU.EXITO);
            }
            catch (Exception ex)
            {
                this.vista.MostrarMensaje("Error al generar el pago Adicional", ETipoMensajeIU.ERROR, NombreClase + ".GenerarPagoAdicional: " + ex.GetBaseException().Message);
            }
        }
        /// <summary>
        /// Realiza la impresión del Historico de Pagos para una referencia de Contrato Seleccionada
        /// </summary>
        public void ImprimirPagos()
        {
            try
            {
                var numeroContrato = Vista.NumeroContrato;

                // Validar la Informacion de la Referencia de Contrato Seleccionada
                var msg = ValidarDatos(numeroContrato);

                if (!string.IsNullOrEmpty(msg))
                {
                    Vista.MostrarMensaje(msg, ETipoMensajeIU.ADVERTENCIA);
                    return;
                }


                // Validar la existencia de folio del contrato
                var contratoBR = new ContratoBR();
                var contratos  = contratoBR.Consultar(dataContext, new ContratoProxyBO {
                    NumeroContrato = numeroContrato.ToUpper()
                });
                if (!contratos.Any())
                {
                    Vista.MostrarMensaje("No existe un Contrato con el Folio proporcionado.", ETipoMensajeIU.ADVERTENCIA);
                    return;
                }

                var referencia = contratos.First();
                var usuario    = new UsuarioBO {
                    Id = Vista.UsuarioId
                };
                var unidadOperativa = new UnidadOperativaBO {
                    Id = Vista.UnidadOperativaId
                };
                var sucursales = ConsultarSucursales(usuario, unidadOperativa);

                // Validar que el contrato pertenezca a una sucursal del usuario
                if (sucursales.All(x => x.Id != referencia.Sucursal.Id))
                {
                    Vista.MostrarMensaje("El Folio del Contrato proporcionado pertence a una sucursal no asignada al usuario.", ETipoMensajeIU.ADVERTENCIA);
                    return;
                }

                // Validar la existencia de Pagos del Contrato
                int conteo = 0;
                ReferenciaContratoBO referenciaContrato = new ReferenciaContratoBO {
                    ReferenciaContratoID = referencia.ContratoID, UnidadOperativa = unidadOperativa
                };

                switch (referencia.Tipo)
                {
                case ETipoContrato.RO:
                case ETipoContrato.RE:
                case ETipoContrato.ROC:
                    PagoContratoPSLBOF pagoPsl = new PagoContratoPSLBOF()
                    {
                        ReferenciaContrato = referenciaContrato, Sucursales = sucursales
                    };
                    PagoContratoPSLBR pagosPslBR = new PagoContratoPSLBR();
                    conteo = pagosPslBR.ContarPagos(dataContext, pagoPsl);
                    break;

                default:
                    PagoUnidadContratoBOF pago = new PagoUnidadContratoBOF {
                        ReferenciaContrato = referenciaContrato, Sucursales = sucursales
                    };
                    PagoUnidadContratoBR pagosBR = new PagoUnidadContratoBR();
                    conteo = pagosBR.ContarPagos(dataContext, pago);
                    break;
                }

                if (conteo == 0)
                {
                    Vista.MostrarMensaje("El contrato no cuenta con pagos generados.", ETipoMensajeIU.ADVERTENCIA);
                    return;
                }

                //Obtener Datos de Reporte
                var adscripcion = new AdscripcionBO {
                    UnidadOperativa = unidadOperativa
                };
                var seguridad      = new SeguridadBO(Guid.Empty, usuario, adscripcion);
                var imprmirPagosBR = new ImprimirPagosBR();
                var datosReporte   = imprmirPagosBR.ObtenerDatosHistoricoPagos(dataContext,
                                                                               referenciaContrato, unidadOperativa, seguridad, this.Vista.URLLogoEmpresa);

                Vista.EstablecerPaqueteNavegacionImprimir(codigoImprimirHistorico, datosReporte);
                Vista.IrAImprimirHistorico();
            }
            catch (Exception ex)
            {
                var strMetodo = new StackFrame().GetMethod().Name;
                var strMsg    = string.Format("{0}.{1}: {2}", nombreClase, strMetodo, ex.Message);
                Vista.MostrarMensaje("Inconsistencias al Desplegar los Pagos del Contrato", ETipoMensajeIU.ERROR, strMsg);
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Actualiza los marcadores de conteo de los pagos
        /// </summary>
        public void ActualizarMarcadores()
        {
            int TotalFacturar    = 0;
            int TotalNoFacturado = 0;

            if (ETipoEmpresa.Idealease == (ETipoEmpresa)this.Vista.UnidadOperativaID)
            {
                //Pagos por Facturar
                var bof = new PagoUnidadContratoBOF
                {
                    Sucursales            = Vista.SucursalesUsuario,
                    Activo                = true,
                    EnviadoFacturacion    = false,
                    FechaVencimientoFinal = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 23, 59, 59),
                    Facturado             = false,
                    ReferenciaContrato    = new ReferenciaContratoBO
                    {
                        UnidadOperativa = new UnidadOperativaBO {
                            Id = Vista.UnidadOperativaID
                        }
                    },
                    FacturaEnCeros   = false,
                    BloqueadoCredito = false
                };
                TotalFacturar = Controlador.ContarPagos(dataContext, bof);

                // Pagos No Facturados
                bof = new PagoUnidadContratoBOF
                {
                    Sucursales         = Vista.SucursalesUsuario,
                    Activo             = true,
                    BloqueadoCredito   = true,
                    ReferenciaContrato = new ReferenciaContratoBO
                    {
                        UnidadOperativa = new UnidadOperativaBO {
                            Id = Vista.UnidadOperativaID
                        }
                    },
                    FacturaEnCeros = false
                };
                TotalNoFacturado = Controlador.ContarPagos(dataContext, bof);
            }
            else
            {
                //Pagos por Facturar
                var bof = new PagoContratoPSLBOF
                {
                    Sucursales            = Vista.SucursalesUsuario,
                    Activo                = true,
                    EnviadoFacturacion    = false,
                    FechaVencimientoFinal = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 23, 59, 59),
                    Facturado             = false,
                    ReferenciaContrato    = new ReferenciaContratoBO
                    {
                        UnidadOperativa = new UnidadOperativaBO {
                            Id = Vista.UnidadOperativaID
                        }
                    },
                    FacturaEnCeros   = false,
                    BloqueadoCredito = false
                };
                TotalFacturar = ControladorPSL.ContarPagos(dataContext, bof);

                // Pagos No Facturados
                bof = new PagoContratoPSLBOF
                {
                    Sucursales         = Vista.SucursalesUsuario,
                    Activo             = true,
                    BloqueadoCredito   = true,
                    ReferenciaContrato = new ReferenciaContratoBO
                    {
                        UnidadOperativa = new UnidadOperativaBO {
                            Id = Vista.UnidadOperativaID
                        }
                    },
                    FacturaEnCeros = false
                };
                TotalNoFacturado = ControladorPSL.ContarPagos(dataContext, bof);
            }

            Vista.TotalFacturar    = TotalFacturar;
            Vista.TotalNoFacturado = TotalNoFacturado;
        }
        /// <summary>
        /// Decide que controlador usar para consultar pagos
        /// </summary>
        private List <PagoUnidadContratoBO> ConsultarPagos(Int32?pagoId, Int32?referenciaContratoId, Int32?unidadId, ETipoContrato?tipoContrato, Boolean esCompleto)
        {
            var listaPagos = new List <PagoUnidadContratoBO>();
            PagoUnidadContratoBR pagoBr = null;
            PagoUnidadContratoBO pago   = new PagoUnidadContratoBOF();

            switch (tipoContrato)
            {
            case ETipoContrato.FSL:
                pagoBr = new PagoUnidadContratoFSLBR();
                pago   = new PagoUnidadContratoFSLBO()
                {
                    Tarifa = new TarifaPagoEquipoBO()
                };
                break;

            case ETipoContrato.RD:
                pagoBr = new PagoUnidadContratoRDBR();
                pago   = new PagoUnidadContratoRDBO()
                {
                    Tarifa = new TarifaPagoEquipoBO()
                };
                break;

            case ETipoContrato.CM:
            case ETipoContrato.SD:
                pagoBr = new PagoUnidadContratoBR();
                pago   = new PagoUnidadContratoManttoBO(tipoContrato.Value)
                {
                    Tarifa = new TarifaPagoEquipoBO()
                };
                break;
            }

            if (pagoId != null)
            {
                pago.PagoID = pagoId;
            }
            if (referenciaContratoId != null)
            {
                pago.ReferenciaContrato = new ReferenciaContratoBO()
                {
                    ReferenciaContratoID = referenciaContratoId
                }
            }
            ;
            if (unidadId != null)
            {
                pago.Unidad = new UnidadBO()
                {
                    UnidadID = unidadId
                }
            }
            ;

            switch (tipoContrato)
            {
            case ETipoContrato.FSL:
                listaPagos.AddRange(esCompleto ? ((PagoUnidadContratoFSLBR)pagoBr).ConsultarCompleto(this.dataContext, (PagoUnidadContratoFSLBO)pago, true) : ((PagoUnidadContratoFSLBR)pagoBr).Consultar(this.dataContext, (PagoUnidadContratoFSLBO)pago));
                break;

            case ETipoContrato.RD:
                listaPagos.AddRange(esCompleto ? ((PagoUnidadContratoRDBR)pagoBr).ConsultarCompleto(this.dataContext, (PagoUnidadContratoRDBO)pago) : ((PagoUnidadContratoRDBR)pagoBr).Consultar(this.dataContext, (PagoUnidadContratoRDBO)pago));
                break;

            case ETipoContrato.CM:
            case ETipoContrato.SD:
                listaPagos.AddRange(esCompleto ? pagoBr.ConsultarCompleto(this.dataContext, pago) : pagoBr.Consultar(this.dataContext, pago));
                break;
            }

            return(listaPagos);
        }