示例#1
0
        public async Task <IActionResult> ObtenerFormatoSolicitudPagoXNumeroContrato([FromQuery(Name = "numeroContrato")] string numeroContrato,
                                                                                     [FromQuery(Name = "crp")] long crp)
        {
            FormatoSolicitudPagoDto formato = null;
            string listaCompromiso          = string.Empty;
            int    cantidadMaxima           = 0;

            try
            {
                formato = await _repo.ObtenerFormatoSolicitudPagoXCompromiso(crp);

                if (formato != null)
                {
                    List <long> listaCrp = await _repo.ObtenerListaCompromisoXNumeroContrato(numeroContrato);

                    listaCompromiso = string.Join(",", listaCrp);

                    var compromisos = await _repo.ObtenerInformacionFinancieraXListaCompromiso(numeroContrato, listaCrp);

                    var pagosRealizados = await _repo.ObtenerPagosRealizadosXListaCompromiso(listaCrp);

                    foreach (var item in compromisos)
                    {
                        formato = await _repo.ObtenerFormatoSolicitudPagoXCompromiso(item.Crp);

                        cantidadMaxima              = _planPagoRepository.ObtenerCantidadMaximaPlanPago(item.Crp, item.PciId);
                        item.CantidadMaxima         = cantidadMaxima > 0 ? cantidadMaxima : 0;
                        item.ValorPagadoFechaActual = formato.Cdp.ValorTotal - formato.Cdp.SaldoActual;

                        if (pagosRealizados != null)
                        {
                            var listaOrdenPago = from pr in pagosRealizados
                                                 where pr.Crp == item.Crp
                                                 group pr by pr.OrdenPago
                                                 into g
                                                 select new
                            {
                                name = g.Key
                            };

                            item.NumeroPagoFechaActual = listaOrdenPago.Count();
                        }
                    }
                    formato.PagosRealizados = pagosRealizados;
                    formato.Compromisos     = compromisos;
                    formato.ListaCompromiso = listaCompromiso;
                }
                return(Ok(formato));
            }
            catch (Exception)
            {
                throw;
            }

            throw new Exception($"No se pudo obtener información de la solicitud de pago");
        }
示例#2
0
        public async Task <IActionResult> ObtenerFormatoSolicitudPagoXId([FromQuery(Name = "formatoSolicitudPagoId")] int formatoSolicitudPagoId)
        {
            FormatoSolicitudPagoDto formato = null;

            try
            {
                valorPciId = User.FindFirst(ClaimTypes.Role).Value;
                if (!string.IsNullOrEmpty(valorPciId))
                {
                    pciId = int.Parse(valorPciId);
                }
                formato = await _repo.ObtenerFormatoSolicitudPagoXId(formatoSolicitudPagoId);

                if (formato != null)
                {
                    var CantidadMaxima = _planPagoRepository.ObtenerCantidadMaximaPlanPago(formato.Cdp.Crp, pciId);

                    formato.CantidadMaxima         = CantidadMaxima;
                    formato.ValorPagadoFechaActual = formato.Cdp.ValorTotal - formato.Cdp.SaldoActual;

                    FormatoCausacionyLiquidacionPagos formatoCausacion = await _procesoLiquidacion.ObtenerFormatoSolicitudPago(formato.PlanPagoId, pciId, formato.BaseCotizacion, formato.ActividadEconomica.Id);

                    formato.AportePension    = formatoCausacion.AportePension;
                    formato.AporteSalud      = formatoCausacion.AporteSalud;
                    formato.RiesgoLaboral    = formatoCausacion.RiesgoLaboral;
                    formato.FondoSolidaridad = formatoCausacion.FondoSolidaridad;

                    var pagosRealizados = await _repo.ObtenerPagosRealizadosXCompromiso(formato.Cdp.Crp, pciId);

                    if (pagosRealizados != null)
                    {
                        var listaOrdenPago = from pr in pagosRealizados
                                             group pr by pr.OrdenPago into g
                                             select new
                        {
                            name = g.Key
                        };

                        formato.NumeroPagoFechaActual = listaOrdenPago.Count();
                        formato.PagosRealizados       = pagosRealizados;
                    }
                }
                return(Ok(formato));
            }
            catch (Exception)
            {
                throw;
            }

            throw new Exception($"No se pudo obtener la lista de relaciones contables");
        }
示例#3
0
        public async Task <IActionResult> ObtenerFormatoSolicitudPago([FromQuery(Name = "crp")] int crp)
        {
            FormatoSolicitudPagoDto formato = null;
            string listaCompromiso          = string.Empty;

            try
            {
                valorPciId = User.FindFirst(ClaimTypes.Role).Value;
                if (!string.IsNullOrEmpty(valorPciId))
                {
                    pciId = int.Parse(valorPciId);
                }

                formato = await _repo.ObtenerFormatoSolicitudPago(crp, pciId);

                if (formato != null)
                {
                    var CantidadMaxima = _planPagoRepository.ObtenerCantidadMaximaPlanPago(formato.Cdp.Crp, pciId);
                    formato.CantidadMaxima         = CantidadMaxima;
                    formato.ValorPagadoFechaActual = formato.Cdp.ValorTotal - formato.Cdp.SaldoActual;

                    var pagosRealizados = await _repo.ObtenerPagosRealizadosXCompromiso(crp, pciId);

                    if (pagosRealizados != null)
                    {
                        var listaOrdenPago = from pr in pagosRealizados
                                             group pr by pr.OrdenPago into g
                                             select new
                        {
                            name = g.Key
                        };

                        formato.NumeroPagoFechaActual = listaOrdenPago.Count();
                        formato.PagosRealizados       = pagosRealizados;
                    }
                }
                return(Ok(formato));
            }
            catch (Exception)
            {
                throw;
            }

            throw new Exception($"No se pudo obtener información de la solicitud de pago");
        }
示例#4
0
        public async Task <IActionResult> ActualizarFormatoSolicitudPago(FormatoSolicitudPagoDto formatoDto)
        {
            DetalleFormatoSolicitudPago detalleSolicitud = null;

            await using var transaction = await _dataContext.Database.BeginTransactionAsync();

            try
            {
                usuarioId  = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
                valorPciId = User.FindFirst(ClaimTypes.Role).Value;
                if (!string.IsNullOrEmpty(valorPciId))
                {
                    pciId = int.Parse(valorPciId);
                }

                if (formatoDto != null)
                {
                    #region Actualizar solicitud de pago

                    var formatoBD = await _repo.ObtenerFormatoSolicitudPagoBase(formatoDto.FormatoSolicitudPagoId);

                    formatoBD.UsuarioIdModificacion     = usuarioId;
                    formatoBD.FechaModificacion         = _generalInterface.ObtenerFechaHoraActual();
                    formatoBD.ObservacionesModificacion = formatoDto.ObservacionesModificacion;
                    formatoBD.EstadoId = formatoDto.EstadoId;

                    if (formatoDto.EstadoId == (int)EstadoSolicitudPago.Rechazado)
                    {
                        var parametroLiquidacionTercero = await _terceroRepository.ObtenerParametrizacionLiquidacionXTercero(formatoDto.Tercero.TerceroId, pciId);

                        if (parametroLiquidacionTercero != null && parametroLiquidacionTercero.FacturaElectronicaId == 0)
                        {
                            formatoBD.NumeroFactura = string.Empty;
                        }
                    }

                    await _dataContext.SaveChangesAsync();

                    #endregion Actualizar solicitud de pago

                    #region Registrar Rubros Presupuestales

                    if (formatoDto.EstadoId == (int)EstadoSolicitudPago.Aprobado)
                    {
                        if (formatoDto.DetallesFormatoSolicitudPago != null && formatoDto.DetallesFormatoSolicitudPago.Count > 0)
                        {
                            foreach (var item in formatoDto.DetallesFormatoSolicitudPago)
                            {
                                if (item.ValorAPagar > 0)
                                {
                                    detalleSolicitud = new DetalleFormatoSolicitudPago();
                                    detalleSolicitud.FormatoSolicitudPagoId      = formatoBD.FormatoSolicitudPagoId;
                                    detalleSolicitud.RubroPresupuestalId         = item.RubroPresupuestal.Id;
                                    detalleSolicitud.ValorAPagar                 = item.ValorAPagar;
                                    detalleSolicitud.Dependencia                 = item.Dependencia;
                                    detalleSolicitud.ClavePresupuestalContableId = item.ClavePresupuestalContableId.HasValue ? item.ClavePresupuestalContableId : null;
                                    _dataContext.DetalleFormatoSolicitudPago.Add(detalleSolicitud);
                                }
                            }
                        }
                        await _dataContext.SaveChangesAsync();
                    }

                    #endregion Registrar Rubros Presupuestales

                    #region Actualizar el plan de pago

                    var cantidadPlanPagoxCompromiso = await _planPagoRepository.CantidadPlanPagoParaCompromiso(formatoBD.Crp, pciId);

                    if (cantidadPlanPagoxCompromiso > 1)
                    {
                        if (formatoDto.EstadoId == (int)EstadoSolicitudPago.Aprobado)
                        {
                            var planPagoBD = await _planPagoRepository.ObtenerPlanPagoBase(formatoDto.PlanPagoId);

                            planPagoBD.NumeroFactura            = formatoDto.NumeroFactura;
                            planPagoBD.ValorFacturado           = formatoDto.ValorFacturado;
                            planPagoBD.Observaciones            = formatoDto.Observaciones;
                            planPagoBD.NumeroRadicadoProveedor  = formatoDto.NumeroRadicadoProveedor;
                            planPagoBD.FechaRadicadoProveedor   = formatoDto.FechaRadicadoProveedor;
                            planPagoBD.NumeroRadicadoSupervisor = formatoDto.NumeroRadicadoSupervisor;
                            planPagoBD.FechaRadicadoSupervisor  = formatoDto.FechaRadicadoSupervisor;
                            planPagoBD.EstadoPlanPagoId         = (int)EstadoPlanPago.PorObligar;
                            planPagoBD.UsuarioIdModificacion    = usuarioId;
                            planPagoBD.FechaModificacion        = _generalInterface.ObtenerFechaHoraActual();
                            await _dataContext.SaveChangesAsync();
                        }
                        else
                        {
                            var planPagoBD = await _planPagoRepository.ObtenerPlanPagoBase(formatoDto.PlanPagoId);

                            planPagoBD.EstadoPlanPagoId      = (int)EstadoPlanPago.PorPagar;
                            planPagoBD.UsuarioIdModificacion = usuarioId;
                            planPagoBD.FechaModificacion     = _generalInterface.ObtenerFechaHoraActual();
                        }

                        await transaction.CommitAsync();
                    }

                    #endregion Actualizar el plan de pago

                    #region Actualizar Numeración

                    if (formatoDto.EstadoId == (int)EstadoSolicitudPago.Rechazado)
                    {
                        var parametroLiquidacionTercero = await _terceroRepository.ObtenerParametrizacionLiquidacionXTercero(formatoDto.Tercero.TerceroId, pciId);

                        if (parametroLiquidacionTercero != null && parametroLiquidacionTercero.FacturaElectronicaId == 0)
                        {
                            var numeracion = await _repo.ObtenerNumeracionxNumeroFactura(formatoDto.NumeroFactura);

                            if (numeracion != null)
                            {
                                numeracion.Utilizado = false;
                                numeracion.FormatoSolicitudPagoId = null;
                                await _dataContext.SaveChangesAsync();
                            }
                        }
                    }

                    #endregion Actualizar Numeración

                    return(Ok(formatoBD.FormatoSolicitudPagoId));
                }
            }
            catch (Exception)
            {
                throw;
            }

            throw new Exception($"No se pudo registrar el formato de liquidación");
        }