public async Task <List <CobEstadoDeCuenta> > GetAllDocumentoMadre(string idCliente)
        {
            List <CobEstadoDeCuenta> result = new List <CobEstadoDeCuenta>();

            //var result3 = await(from u in _context.CobEstadoDeCuenta
            //               join ur in _context.CobTransacciones on u.Rpdct equals ur.Transaccion

            //               where u.IdCliente== idCliente && ur.DocumentoMadre == true
            //               select u).ToListAsync();

            var estadoCuenta = await _context.CobEstadoDeCuenta.Where(X => X.IdCliente.Trim() == idCliente.Trim() && X.Rpaap != 0).OrderBy(x => x.Id).ToListAsync();

            //var estadoCuenta = await _context.CobEstadoDeCuenta.Where(X => X.IdCliente.Trim() == idCliente.Trim() ).OrderBy(x => x.Id).ToListAsync();

            var transacciones = await _context.CobTransacciones.ToListAsync();

            if (estadoCuenta != null)
            {
                foreach (var item in estadoCuenta)
                {
                    CobEstadoDeCuenta estadoCuentaItem = new CobEstadoDeCuenta();
                    var transaccion = transacciones.Where(x => x.Transaccion == item.Rpdct).FirstOrDefault();
                    if (transaccion != null)
                    {
                        if (transaccion.DocumentoMadre)
                        {
                            result.Add(item);
                        }
                    }
                }
            }


            return(result);
        }
예제 #2
0
        public async Task UpdateCobEstadoCuenta(List <EstadoCuentaSap> estadoCuentaSaps, string idCliente)
        {
            foreach (var item    in estadoCuentaSaps)
            {
                CobEstadoDeCuenta cobEstadoDeCuenta = new CobEstadoDeCuenta();

                var estaddoCuentaSearch = await _unitOfWork.CobEstadoDeCuentaRepository.GetByDocumentoSap(item.DocumentoSAP);

                if (estaddoCuentaSearch == null)
                {
                    cobEstadoDeCuenta.DocumentoSap = item.DocumentoSAP;
                    cobEstadoDeCuenta.Rpdoc        = double.Parse(item.DocumentoExterno);

                    var claseDocumento = GetListClaseDocumento().Where(x => x.ClaseDocumento == item.ClaseDoc).FirstOrDefault();
                    if (claseDocumento != null)
                    {
                        cobEstadoDeCuenta.Rpdct = claseDocumento.TipoLegacy;
                    }

                    cobEstadoDeCuenta.Rpkco     = "01406";
                    cobEstadoDeCuenta.Rpsfx     = "001";
                    cobEstadoDeCuenta.Rpan8     = double.Parse(item.Cliente);
                    cobEstadoDeCuenta.Rpag      = decimal.ToDouble(item.Monto);
                    cobEstadoDeCuenta.Rpaap     = decimal.ToDouble(item.Saldo);
                    cobEstadoDeCuenta.IdCliente = item.Cliente;
                    var cliente = _unitOfWork.MtrClienteRepository.GetById(item.Cliente);
                    cobEstadoDeCuenta.Vendedor         = cliente.Vendedor1.Trim();
                    cobEstadoDeCuenta.OficinaVenta     = cliente.OficinaVenta.Trim();
                    cobEstadoDeCuenta.BaseImponible    = item.BaseImponible;
                    cobEstadoDeCuenta.Iva              = item.Impuesto;
                    cobEstadoDeCuenta.MontoOriginal    = item.Monto;
                    cobEstadoDeCuenta.FechaDocumento   = item.FechaDoc;
                    cobEstadoDeCuenta.FechaVencimiento = item.FechaVencimiento;
                    cobEstadoDeCuenta.Moneda           = item.Moneda;
                    await _unitOfWork.CobEstadoDeCuentaRepository.Add(cobEstadoDeCuenta);

                    await _unitOfWork.SaveChangesAsync();
                }
                else
                {
                    //estaddoCuentaSearch.DocumentoSap = item.DocumentoSAP;
                    estaddoCuentaSearch.Rpdoc = double.Parse(item.DocumentoExterno);
                    var claseDocumento = GetListClaseDocumento().Where(x => x.ClaseDocumento == item.ClaseDoc).FirstOrDefault();
                    if (claseDocumento != null)
                    {
                        estaddoCuentaSearch.Rpdct = claseDocumento.TipoLegacy;
                    }

                    estaddoCuentaSearch.Rpan8     = double.Parse(item.Cliente);
                    estaddoCuentaSearch.Rpag      = decimal.ToDouble(item.Monto);
                    estaddoCuentaSearch.Rpaap     = decimal.ToDouble(item.Saldo);
                    estaddoCuentaSearch.IdCliente = item.Cliente;
                    var cliente = _unitOfWork.MtrClienteRepository.GetById(item.Cliente);
                    estaddoCuentaSearch.Vendedor         = cliente.Vendedor1;
                    estaddoCuentaSearch.OficinaVenta     = cliente.OficinaVenta;
                    estaddoCuentaSearch.BaseImponible    = item.BaseImponible;
                    estaddoCuentaSearch.Iva              = item.Impuesto;
                    estaddoCuentaSearch.MontoOriginal    = item.Monto;
                    estaddoCuentaSearch.FechaDocumento   = item.FechaDoc;
                    estaddoCuentaSearch.FechaVencimiento = item.FechaVencimiento;
                    estaddoCuentaSearch.Moneda           = item.Moneda;
                    _unitOfWork.CobEstadoDeCuentaRepository.Update(estaddoCuentaSearch);
                    await _unitOfWork.SaveChangesAsync();
                }
            }



            var estadoCuenta = await _unitOfWork.CobEstadoDeCuentaRepository.GetAllDocumentoMadre(idCliente);

            foreach (var item in estadoCuenta)
            {
                var estadoCuentaSap = estadoCuentaSaps.Where(x => x.DocumentoSAP == item.DocumentoSap).FirstOrDefault();
                if (estadoCuentaSap == null)
                {
                    var estaddoCuentaSearch = await _unitOfWork.CobEstadoDeCuentaRepository.GetByDocumentoSap(item.DocumentoSap);

                    estaddoCuentaSearch.Rpaap = 0;
                    _unitOfWork.CobEstadoDeCuentaRepository.Update(estaddoCuentaSearch);
                    await _unitOfWork.SaveChangesAsync();
                }
            }
        }
예제 #3
0
        public async Task <ReciboDto> GeneraReciboDto(long recibo)
        {
            ReciboDto                    result                     = new ReciboDto();
            CobGeneralCobranza           cobGeneralCobranza         = new CobGeneralCobranza();
            List <CobGrabacionCobranzas> listaCobGrabacionCobranzas = new List <CobGrabacionCobranzas>();

            try
            {
                //Crea Objeto General cobranzas
                cobGeneralCobranza = await GetGeneralCobranzaPorDocumento(recibo);

                CobGeneralCobranzaDto generalCobranzasDtos = _mapper.Map <CobGeneralCobranzaDto>(cobGeneralCobranza);

                MtrCliente cliente = await _mtrClienteService.GetByIdAsync(generalCobranzasDtos.IdCliente);

                MtrVendedor vendedor = await _mtrVendedorService.GetByIdAsync(cliente.Vendedor1);

                generalCobranzasDtos.NombreCliente          = cliente.NoRegTribut + " " + cliente.Nombre.Trim();
                generalCobranzasDtos.IdCliente              = generalCobranzasDtos.IdCliente.Trim();
                generalCobranzasDtos.FechaTransaccionString = generalCobranzasDtos.FechaTransaccion.ToShortDateString();
                generalCobranzasDtos.NombreVendedor         = vendedor.Nombre;
                generalCobranzasDtos.vendedor         = vendedor.Codigo;
                generalCobranzasDtos.CorreoVendedor   = vendedor.EMail;
                generalCobranzasDtos.TelefonoVendedor = vendedor.TlfCelular;



                decimal decimalValue = generalCobranzasDtos.MontoTransaccion;
                generalCobranzasDtos.MontoTransaccionString = string.Format("{0:N}", decimalValue); // 1,234,567.00


                //creamos el objeto
                Moneda oMoneda = new Moneda();

                //primer parametro es la cantidad en string
                //segundo parametro es si queremos que sea mayuscula
                //tercer parametro la moneda


                MtrTipoMoneda tipoMoneda = await _mtrTipoMonedaService.GetById((long)cobGeneralCobranza.IdMtrTipoMoneda);

                string MonedaString = tipoMoneda.Descripcion;



                string resultado = oMoneda.Convertir(generalCobranzasDtos.MontoTransaccion.ToString(), true, MonedaString);
                generalCobranzasDtos.MontoLetras = resultado;


                decimal?detalleValue = generalCobranzasDtos.TotalDetalleCobrado;
                generalCobranzasDtos.TotalDetalleCobradoString = string.Format("{0:N}", detalleValue);
                generalCobranzasDtos.Status = EstatusRecibo(cobGeneralCobranza);

                MtrBancos banco = await _mtrBancosService.GetByCodigo(generalCobranzasDtos.IdBanco);

                generalCobranzasDtos.NombreBanco = banco.Nombre;

                CobTipoTransaccion tipoTransaccion = await _cobTipoTransaccionService.GetById(generalCobranzasDtos.IdTipoTransaccion);

                generalCobranzasDtos.NombreTipoTransaccion = tipoTransaccion.NombreTipoTransaccion;
                generalCobranzasDtos.FlagImpuesto          = tipoTransaccion.FlagImpuesto;


                MtrTipoMoneda mtrTipoMoneda = await _mtrTipoMonedaService.GetById((long)generalCobranzasDtos.IdMtrTipoMoneda);

                generalCobranzasDtos.NombreTipoMoneda = mtrTipoMoneda.Descripcion;



                listaCobGrabacionCobranzas = _unitOfWork.CobGrabacionCobranzasRepository.GetByDocumento(recibo);
                listaCobGrabacionCobranzas = listaCobGrabacionCobranzas.Where(x => x.DocumentoSap == "").ToList();

                List <CobGrabacionCobranzaDto> listaCobGrabacionCobranzasDto = _mapper.Map <List <CobGrabacionCobranzaDto> >(listaCobGrabacionCobranzas);

                foreach (CobGrabacionCobranzaDto item in listaCobGrabacionCobranzasDto)
                {
                    item.CuentaBancaria = banco.CodContable;
                    item.Moneda         = mtrTipoMoneda.Descripcion;
                    if (item.Transaccion == "RU")
                    {
                        item.DocAfectaMostrar = item.Cotizacion;
                    }
                    else
                    {
                        item.DocAfectaMostrar = item.DocAfectaSap;
                    }

                    decimalValue      = (decimal)item.Monto;
                    item.MontoMostrar = string.Format("{0:N}", decimalValue); // 1,234,567.00

                    CobEstadoDeCuenta cobEstadoDeCuenta = await _cobEstadoCuentaService.GetEstadoCuentaById(item.DocAfecta);

                    if (cobEstadoDeCuenta != null)
                    {
                        decimalValue              = (decimal)cobEstadoDeCuenta.BaseImponible;
                        item.BaseImponible        = (decimal)cobEstadoDeCuenta.BaseImponible;
                        item.BaseImponibleMostrar = string.Format("{0:N}", decimalValue); // 1,234,567.00
                        decimalValue              = (decimal)cobEstadoDeCuenta.Iva;
                        item.Iva        = (decimal)cobEstadoDeCuenta.Iva;
                        item.IvaMostrar = string.Format("{0:N}", decimalValue); // 1,234,567.00
                        decimalValue    = (decimal)cobEstadoDeCuenta.MontoOriginal;

                        item.MontoOriginalMostrar = string.Format("{0:N}", decimalValue); // 1,234,567.00
                        item.FechaDocumento       = cobEstadoDeCuenta.FechaDocumento;
                        DateTime fechaDocumento = (DateTime)cobEstadoDeCuenta.FechaDocumento;
                        item.FechaDocumentoString = fechaDocumento.ToShortDateString();
                    }

                    //List<CobPagosRetencionesDto> listCobPagosRetencionesDto = new List<CobPagosRetencionesDto>();
                    List <CobPagosRetenciones> listCobPagosRetenciones = _unitOfWork.CobPagosRetencionesRepository.GetByIdCobranzas(item.Id);

                    List <CobPagosRetencionesDto> listCobPagosRetencionesDto = _mapper.Map <List <CobPagosRetencionesDto> >(listCobPagosRetenciones);

                    if (listCobPagosRetencionesDto != null && listCobPagosRetencionesDto.Count > 0)
                    {
                        foreach (CobPagosRetencionesDto itemRet in listCobPagosRetencionesDto)
                        {
                            decimalValue        = itemRet.Monto;
                            itemRet.MontoString = string.Format("{0:N}", decimalValue); // 1,234,567.00

                            CobTransacciones transaccion = await _cobTransaccionesService.GetById(itemRet.IdTransaccion);

                            if (transaccion != null)
                            {
                                itemRet.NombreTransaccion = transaccion.NombreTransaccion;
                                itemRet.TxOrigen          = transaccion.TipoSap;
                            }
                            itemRet.FechaComprobanteString = itemRet.FechaComprobante.ToShortDateString();
                        }
                    }


                    item.CobPagosRetencionesDto = listCobPagosRetencionesDto;
                }



                result.CobGeneralCobranzaDto   = generalCobranzasDtos;
                result.CobGrabacionCobranzaDto = listaCobGrabacionCobranzasDto;

                return(result);
            }
            catch (Exception e)
            {
                string message = e.Message;
                throw;
            }
        }
 public void Update(CobEstadoDeCuenta entity)
 {
     _context.CobEstadoDeCuenta.Update(entity);
 }
 public async Task Add(CobEstadoDeCuenta entity)
 {
     await _context.CobEstadoDeCuenta.AddAsync(entity);
 }
예제 #6
0
        public async Task <IActionResult> GetAllGrabacionCobranza(CobGrabacionCobranzasQueryFilter filters)
        {
            PagedList <CobGrabacionCobranzas> listaCobGrabacionCobranzas;

            listaCobGrabacionCobranzas = _cobGrabacionCobranzasService.GetCobGrabacionCobranzas(filters);

            IEnumerable <CobGrabacionCobranzaDto> listaCobGrabacionCobranzasDto = _mapper.Map <IEnumerable <CobGrabacionCobranzaDto> >(listaCobGrabacionCobranzas);

            foreach (CobGrabacionCobranzaDto item in listaCobGrabacionCobranzasDto)
            {
                if (item.Transaccion == "RU")
                {
                    item.DocAfectaMostrar = item.Cotizacion;
                }
                else
                {
                    item.DocAfectaMostrar = item.DocAfectaSap;
                }

                decimal decimalValue = (decimal)item.Monto;
                item.MontoMostrar = string.Format("{0:N}", decimalValue); // 1,234,567.00

                CobEstadoDeCuenta cobEstadoDeCuenta = await _cobEstadoCuentaService.GetEstadoCuentaById(item.DocAfecta);

                if (cobEstadoDeCuenta != null)
                {
                    decimalValue              = (decimal)cobEstadoDeCuenta.BaseImponible;
                    item.BaseImponible        = (decimal)cobEstadoDeCuenta.BaseImponible;
                    item.BaseImponibleMostrar = string.Format("{0:N}", decimalValue); // 1,234,567.00
                    decimalValue              = (decimal)cobEstadoDeCuenta.Iva;
                    item.Iva        = (decimal)cobEstadoDeCuenta.Iva;
                    item.IvaMostrar = string.Format("{0:N}", decimalValue); // 1,234,567.00
                    decimalValue    = (decimal)cobEstadoDeCuenta.MontoOriginal;

                    item.MontoOriginalMostrar = string.Format("{0:N}", decimalValue); // 1,234,567.00
                    item.FechaDocumento       = cobEstadoDeCuenta.FechaDocumento;
                    DateTime fechaDocumento = (DateTime)cobEstadoDeCuenta.FechaDocumento;
                    item.FechaDocumentoString = fechaDocumento.ToShortDateString();

                    CobEstadoCuentaDto estadoCuentaDto = _mapper.Map <CobEstadoCuentaDto>(cobEstadoDeCuenta);

                    MtrCliente cliente = await _mtrClienteService.GetByIdAsync(estadoCuentaDto.IdCliente);



                    estadoCuentaDto.Saldo               = estadoCuentaDto.Rpaap;
                    decimalValue                        = (decimal)estadoCuentaDto.Saldo;
                    estadoCuentaDto.SaldoString         = string.Format("{0:N}", decimalValue); // 1,234,567.00
                    decimalValue                        = (decimal)estadoCuentaDto.Iva;
                    estadoCuentaDto.IvaString           = string.Format("{0:N}", decimalValue); // 1,234,567.00
                    decimalValue                        = (decimal)estadoCuentaDto.MontoOriginal;
                    estadoCuentaDto.MontoOriginalString = string.Format("{0:N}", decimalValue); // 1,234,567.00
                    decimalValue                        = (decimal)estadoCuentaDto.BaseImponible;
                    estadoCuentaDto.BaseImponibleString = string.Format("{0:N}", decimalValue); // 1,234,567.00
                    estadoCuentaDto.searchText          = estadoCuentaDto.Rpdct + "-" + estadoCuentaDto.Rpdoc.ToString() + "- Cliente: " + cliente.Nombre.Trim() + "- Saldo: " + estadoCuentaDto.SaldoString;


                    item.CobEstadoCuentaDto = estadoCuentaDto;
                }
            }



            Metadata metadata = new Metadata
            {
                TotalCount      = listaCobGrabacionCobranzas.TotalCount,
                PageSize        = listaCobGrabacionCobranzas.PageSize,
                CurrentPage     = listaCobGrabacionCobranzas.CurrentPage,
                TotalPage       = listaCobGrabacionCobranzas.TotalPage,
                HasNextPage     = listaCobGrabacionCobranzas.HasNextPage,
                HasPreviousPage = listaCobGrabacionCobranzas.HasPreviousPage,
                NextPageUrl     = "",   // _uriService.GetGeneralCobranzaPaginationUri(filters, "").ToString(),
                PreviousPageUrl = ""    // _uriService.GetGeneralCobranzaPaginationUri(filters, "").ToString(),
            };

            ApiResponse <IEnumerable <CobGrabacionCobranzaDto> > response = new ApiResponse <IEnumerable <CobGrabacionCobranzaDto> >(listaCobGrabacionCobranzasDto)
            {
                Meta = metadata
            };

            return(Ok(response));
        }
예제 #7
0
        public async Task <IActionResult> Update(CobGrabacionCobranzaDto cobGrabacionCobranzaDto)
        {
            CobGrabacionCobranzaDto resultDto = new CobGrabacionCobranzaDto();
            Metadata metadata = new Metadata
            {
                IsValid = true,
                Message = ""
            };



            ApiResponse <CobGrabacionCobranzaDto> response = new ApiResponse <CobGrabacionCobranzaDto>(resultDto);



            CobGrabacionCobranzas cobGrabacionCobranza = _mapper.Map <CobGrabacionCobranzas>(cobGrabacionCobranzaDto);

            CobGeneralCobranza generalCobranza = await _generalCobranzaService.GetGeneralCobranzaPorDocumento((long)cobGrabacionCobranza.Documento);

            MtrTipoMoneda tipomoneda = await _mtrTipoMonedaService.GetById((long)generalCobranza.IdMtrTipoMoneda);

            CobEstadoDeCuenta estadoCuenta = await _cobEstadoCuentaService.GetEstadoCuentaById(cobGrabacionCobranzaDto.DocAfecta);

            if (estadoCuenta != null)
            {
                CobGrabacionCobranzas grabacionActual = await _cobGrabacionCobranzasService.GetById(cobGrabacionCobranzaDto.Id);



                if (cobGrabacionCobranzaDto.Transaccion != "RU")
                {
                    if (generalCobranza.IdTipoTransaccion != "RET")
                    {
                        bool existeMonedaDocumentoMonedaPago = await _cobMatrixMonedaValidaPagoService.ExisteMonedaDocumentoMonedaPago(estadoCuenta.Moneda, tipomoneda.Descripcion);

                        if (!existeMonedaDocumentoMonedaPago)
                        {
                            metadata.IsValid = false;

                            metadata.Message = "Esta intentando grabar cobro en moneda no valida a el Recibo";

                            response.Meta = metadata;
                            return(Ok(response));
                        }
                    }


                    decimal totalAfectadoDocumento = _cobGrabacionCobranzasService.TotalAfectadoDocumento((long)cobGrabacionCobranzaDto.Documento, cobGrabacionCobranzaDto.DocAfecta);


                    decimal totalAfectadoDocumentoResta = totalAfectadoDocumento - (decimal)grabacionActual.Monto;


                    if (totalAfectadoDocumentoResta + (decimal)cobGrabacionCobranzaDto.Monto > (decimal)estadoCuenta.Rpaap)
                    {
                        metadata.IsValid = false;

                        metadata.Message = "Esta intentando grabar monto superior al saldo del documento:" + "Total registrado en recibo: " + totalAfectadoDocumento.ToString() + "Saldo documento: " + estadoCuenta.Rpaap.ToString();

                        response.Meta = metadata;
                        return(Ok(response));
                    }
                }
            }


            CobGrabacionCobranzas grabacionCobranzaActual = await _cobGrabacionCobranzasService.GetById(cobGrabacionCobranzaDto.Id);

            if (grabacionCobranzaActual.DocumentoSap.Length > 1)
            {
                metadata.IsValid = false;

                metadata.Message = "Esta intentando modificar un cobro ya contabilizado";

                response.Meta = metadata;
                return(Ok(response));
            }


            CobGrabacionCobranzas cobranza = await _cobGrabacionCobranzasService.Update(cobGrabacionCobranza);

            if (cobranza != null)
            {
                resultDto        = _mapper.Map <CobGrabacionCobranzaDto>(cobranza);
                metadata.IsValid = true;
                metadata.Message = "Actualizado Satisfactoriamente";
            }
            else
            {
                metadata.IsValid = false;

                metadata.Message = "Registro No actualizado";
            }



            //ApiResponse<CobGrabacionCobranzaDto> response = new ApiResponse<CobGrabacionCobranzaDto>(resultDto)
            //{
            //    Meta = metadata,
            //};
            response.Meta = metadata;
            response.Data = resultDto;
            return(Ok(response));
        }
예제 #8
0
        public async Task <IActionResult> Insert(CobGrabacionCobranzaDto cobGrabacionCobranzaDto)
        {
            CobGrabacionCobranzaDto resultDto = new CobGrabacionCobranzaDto();

            Metadata metadata = new Metadata
            {
                IsValid = true,
                Message = ""
            };
            ApiResponse <CobGrabacionCobranzaDto> response = new ApiResponse <CobGrabacionCobranzaDto>(resultDto);

            try
            {
                CobGeneralCobranza generalCobranza = await _generalCobranzaService.GetGeneralCobranzaPorDocumento((long)cobGrabacionCobranzaDto.Documento);

                if (cobGrabacionCobranzaDto.Transaccion == "RU" && generalCobranza.FlagPagoMas != true)
                {
                    OfdCotizacion cotizacion = new OfdCotizacion();


                    cotizacion = await _ofdCotizacionService.GetCotizacion(cobGrabacionCobranzaDto.Cotizacion);

                    if (cotizacion != null)
                    {
                        if (cotizacion.IdCliente == generalCobranza.IdCliente)
                        {
                            metadata.IsValid = true;
                            metadata.Message = "";
                        }
                        else
                        {
                            metadata.IsValid = false;
                            metadata.Message = "Cotizacion no pertenece a este cliente!!! " + generalCobranza.IdCliente;
                            response.Meta    = metadata;
                            response.Data    = resultDto;
                            return(Ok(response));
                        }
                    }
                    else
                    {
                        metadata.IsValid = false;
                        metadata.Message = "Cotizacion no existe!!!";
                        response.Meta    = metadata;
                        response.Data    = resultDto;

                        return(Ok(response));
                    }
                }



                CobGrabacionCobranzas cobGrabacionCobranza = _mapper.Map <CobGrabacionCobranzas>(cobGrabacionCobranzaDto);


                MtrTipoMoneda tipomoneda = await _mtrTipoMonedaService.GetById((long)generalCobranza.IdMtrTipoMoneda);

                bool dividirPagoImpuesto       = false;
                CobEstadoDeCuenta estadoCuenta = await _cobEstadoCuentaService.GetEstadoCuentaById(cobGrabacionCobranzaDto.DocAfecta);

                if (estadoCuenta != null)
                {
                    if (cobGrabacionCobranzaDto.Transaccion != "RU")
                    {
                        if (generalCobranza.IdTipoTransaccion != "RET")
                        {
                            bool existeMonedaDocumentoMonedaPago = await _cobMatrixMonedaValidaPagoService.ExisteMonedaDocumentoMonedaPago(estadoCuenta.Moneda, tipomoneda.Descripcion);

                            if (!existeMonedaDocumentoMonedaPago)
                            {
                                metadata.IsValid = false;

                                metadata.Message = "Esta intentando grabar cobro en moneda no valida a el Recibo";

                                response.Meta = metadata;
                                return(Ok(response));
                            }

                            decimal totalAfectadoDocumento = _cobGrabacionCobranzasService.TotalAfectadoDocumento((long)cobGrabacionCobranzaDto.Documento, cobGrabacionCobranzaDto.DocAfecta);
                            if (totalAfectadoDocumento + (decimal)cobGrabacionCobranzaDto.Monto > (decimal)estadoCuenta.Rpaap)
                            {
                                metadata.IsValid = false;

                                metadata.Message = "Esta intentando grabar monto superior al saldo del documento:" + "Total registrado en recibo: " + totalAfectadoDocumento.ToString() + "Saldo documento: " + estadoCuenta.Rpaap.ToString();
                                return(Ok(response));
                            }
                        }
                    }


                    if (cobGrabacionCobranzaDto.Monto > estadoCuenta.BaseImponible && cobGrabacionCobranzaDto.Transaccion != "RE" && tipomoneda.Descripcion == estadoCuenta.Moneda)
                    {
                        dividirPagoImpuesto = true;
                    }
                }

                if (!dividirPagoImpuesto)
                {
                    cobGrabacionCobranza.PagoCorrespondeIva = false;
                    CobGrabacionCobranzas cobranza = await _cobGrabacionCobranzasService.Insert(cobGrabacionCobranza);

                    if (cobranza != null)
                    {
                        resultDto        = _mapper.Map <CobGrabacionCobranzaDto>(cobranza);
                        metadata.IsValid = true;
                        metadata.Message = "Creado Satisfactoriamente";
                    }
                    else
                    {
                        metadata.IsValid = false;

                        metadata.Message = "Registro No actualizado";
                    }
                }
                else
                {
                    CobGrabacionCobranzas cobGrabacionCobranzaImpuesto = _mapper.Map <CobGrabacionCobranzas>(cobGrabacionCobranzaDto);


                    decimal?montoGrabado = cobGrabacionCobranza.Monto;
                    cobGrabacionCobranza.Monto = estadoCuenta.BaseImponible;


                    cobGrabacionCobranza.PagoCorrespondeIva = false;
                    CobGrabacionCobranzas cobranza = await _cobGrabacionCobranzasService.Insert(cobGrabacionCobranza);


                    cobGrabacionCobranzaImpuesto.Monto = montoGrabado - estadoCuenta.BaseImponible;
                    cobGrabacionCobranzaImpuesto.PagoCorrespondeIva = true;
                    CobGrabacionCobranzas cobranzaImpuesto = await _cobGrabacionCobranzasService.Insert(cobGrabacionCobranzaImpuesto);

                    if (cobranza != null)
                    {
                        resultDto        = _mapper.Map <CobGrabacionCobranzaDto>(cobranza);
                        metadata.IsValid = true;
                        metadata.Message = "Creado Satisfactoriamente";
                    }
                    else
                    {
                        metadata.IsValid = false;

                        metadata.Message = "Registro No actualizado";
                    }
                }

                //ApiResponse<CobGrabacionCobranzaDto> response = new ApiResponse<CobGrabacionCobranzaDto>(resultDto)
                //{
                //    Meta = metadata,
                //};
                response.Meta = metadata;
                response.Data = resultDto;

                return(Ok(response));
            }
            catch (Exception ex)
            {
                metadata.IsValid = false;

                metadata.Message = ex.InnerException.Message;

                response.Meta = metadata;
                response.Data = resultDto;
                //ApiResponse<CobGrabacionCobranzaDto> response = new ApiResponse<CobGrabacionCobranzaDto>(resultDto)
                //{
                //    Meta = metadata,
                //};
                return(Ok(response));
            }
        }