private void SetearEnItemsEspecificacionesObligatoriasSegunComprobante( FeCabecera cabFe, ComprobanteType comprobante )
 {
     foreach ( ItemType item in comprobante.arrayItems )
     {
         item.importeIVASpecified = (cabFe.TipoComprobante >= 1 && cabFe.TipoComprobante <= 3);
     }
 }
        private FECAECabRequest ConvertirCabecera( FeCabecera cabFe )
        {
            FECAECabRequest cab = new FECAECabRequest();
            cab.CantReg = cabFe.CantidadDeRegistros;
            cab.CbteTipo = (int)cabFe.TipoComprobante;
            cab.PtoVta = cabFe.PuntoDeVenta;

            return cab;
        }
        public CAECabeceraRespuesta ConvertirCabecera( FeCabecera feCab, Autorizacion feAut )
        {
            CAECabeceraRespuesta caeCab = new CAECabeceraRespuesta();
            caeCab.PuntoDeVenta = feCab.PuntoDeVenta;
            caeCab.TipoComprobante = feCab.TipoComprobante;
            caeCab.CantidadDeRegistros = feCab.CantidadDeRegistros;
            caeCab.Cuit = feAut.Cuit;

            return caeCab;
        }
        public ComprobanteType Convertir( FeCabecera cabFe )
        {
            WrapperDetalleMTXCA wdm = new WrapperDetalleMTXCA();
            ComprobanteType comprobante = wdm.Convertir( cabFe.DetalleComprobantes[0] );

            this.SetearEnItemsEspecificacionesObligatoriasSegunComprobante( cabFe, comprobante );

            comprobante.numeroPuntoVenta = (short) cabFe.PuntoDeVenta;
            comprobante.codigoTipoComprobante = (short) cabFe.TipoComprobante;

            return comprobante;
        }
        public CAERespuestaFe ObtenerCae( FeCabecera cabFe, Autorizacion aut )
        {
            if ( aut == null )
            {
                ArgumentNullException ex = new ArgumentNullException( "aut", "Se debe indicar una autorización" );
                throw ex;
            }

            AuthRequestType feAut = this.ObtenerAuthReq( aut );

            CAERespuestaFe respuesta = this.SolicitarCAE( cabFe, feAut );

            return respuesta;
        }
 public void Convertir( FeCabecera fc )
 {
     fc.TipoComprobante = this.ConvertirInt( fc.TipoComprobante, this.contenedorDeDatosEq.ComprobantesItemsEquivalencias );
     foreach ( FeDetalle detalle in fc.DetalleComprobantes )
     {
         detalle.Concepto = this.ConvertirInt( detalle.Concepto, this.contenedorDeDatosEq.ConceptosItemsEquivalencias );
         detalle.DocumentoTipo = this.ConvertirInt( detalle.DocumentoTipo, this.contenedorDeDatosEq.TiposDocumentoItemsEquivalencias );
         detalle.MonedaId = this.ConvertirString( detalle.MonedaId, this.contenedorDeDatosEq.MonedasItemsEquivalencias );
         foreach ( IVA iva in detalle.Iva )
         {
             iva.Id = this.ConvertirInt( iva.Id, this.contenedorDeDatosEq.TiposDeIvaItemsEquivalencias );
         }
         foreach ( TributoComprobante tributo in detalle.Tributos )
         {
             tributo.Id = this.ConvertirShort( tributo.Id, this.contenedorDeDatosEq.TiposDeTributoItemsEquivalencias );
         }
     }
 }
        public FECAERequest Convertir( FeCabecera cabFe )
        {
            FECAECabRequest cab = this.ConvertirCabecera( cabFe );

            int i = 0;
            FECAEDetRequest[] detalleComprobantes = new FECAEDetRequest[cabFe.DetalleComprobantes.Count];
            WrapperDetalleFe wdf = new WrapperDetalleFe();
            foreach ( FeDetalle detalle in cabFe.DetalleComprobantes )
            {
                detalleComprobantes[i] = wdf.Convertir( detalle );
                i++;
            }

            FECAERequest feCaeRequest = new FECAERequest();
            feCaeRequest.FeCabReq = cab;
            feCaeRequest.FeDetReq = detalleComprobantes;

            return feCaeRequest;
        }
        public FeCabecera ObtenerProcesar( FeCabecera feCab, int ultimoNroWs )
        {
            FeCabecera feCabRetorno = new FeCabecera();
            foreach ( FeDetalle det in feCab.DetalleComprobantes )
            {
                if ( det.ComprobanteDesde > ultimoNroWs )
                {
                    feCabRetorno.DetalleComprobantes.Add( det );
                }
            }
            if ( feCabRetorno.DetalleComprobantes.Count == 0 )
            {
                feCabRetorno = null;
            }
            else
            {
                this.AsignarDatosCabecera( feCab, feCabRetorno );
            }

            return feCabRetorno;
        }
        public CAERespuestaFe ReprocesarComprobantes( FeCabecera cabFe, Autorizacion feAut )
        {
            ConversorConsultaCaeARespuestaCae conversor = new ConversorConsultaCaeARespuestaCae();
            CAERespuestaFe retorno = new CAERespuestaFe();
            WrapperCabeceraFe wrapperFe = new WrapperCabeceraFe();
            List<Observacion> diferencias;

            retorno.Cabecera = conversor.ConvertirCabecera( cabFe, feAut );

            ConsultasWSMTXCA consultas = new ConsultasWSMTXCA( this.wsfe, this.logueador );
            CAEDetalleRespuesta respuestaReproceso;
            retorno.Detalle = new List<CAEDetalleRespuesta>();

            foreach ( FeDetalle lote in cabFe.DetalleComprobantes )
            {
                respuestaReproceso = consultas.DatosDeComprobante( feAut, cabFe.TipoComprobante, (int) lote.ComprobanteDesde, cabFe.PuntoDeVenta );
                diferencias = wrapperFe.Comparar( respuestaReproceso, lote );

                if ( diferencias.Count > 0 )
                {
                    respuestaReproceso.Resultado = "R";
                    respuestaReproceso.Cae = "";
                    respuestaReproceso.Observaciones = diferencias;
                }
                retorno.Detalle.Add( respuestaReproceso );
            }
            this.logueador.LoguearObservaciones( retorno.Detalle, cabFe );

            return retorno;
        }
 private void AsignarDatosCabecera( FeCabecera feCabOrigen, FeCabecera feCabDestino )
 {
     feCabDestino.CantidadDeRegistros = feCabDestino.DetalleComprobantes.Count;
     feCabDestino.PuntoDeVenta = feCabOrigen.PuntoDeVenta;
     feCabDestino.TipoComprobante = feCabOrigen.TipoComprobante;
 }
        private CAERespuestaFe SolicitarCAE( FeCabecera cabFe, AuthRequestType aut )
        {
            ComprobanteType comprobante = this.ObtenerCaeRequest( cabFe );

            SerializadorRequest serializador = new SerializadorRequest();
            serializador.Serializar<ComprobanteType>( comprobante );

            ManagerErroresFe managerErrores = new ManagerErroresFe( this.logueador );
            ResultadoSimpleType resultado;
            ComprobanteCAEResponseType caeResponse;
            CodigoDescripcionType[] observaciones = null;
            CodigoDescripcionType[] errores = null;
            CodigoDescripcionType evento;
            resultado = this.wsfe.autorizarComprobante( aut, comprobante, out caeResponse, out observaciones, out errores, out evento );

            if (this.HuboSolicitudesRechazadas( errores ))
            {
                this.GenerarBackupArchivoSerializado(serializador, comprobante);
            }

            managerErrores.CapturarError( errores, cabFe );

            WrapperCaeRespuestaMTXCA wcrm = new WrapperCaeRespuestaMTXCA();

            return wcrm.Convertir( resultado, caeResponse, observaciones, errores );
        }
 private ComprobanteType ObtenerCaeRequest( FeCabecera cabFe )
 {
     WrapperCabeceraMTXCA wc = new WrapperCabeceraMTXCA();
     return wc.Convertir( cabFe );
 }
 public CAERespuestaFe ObtenerCae( Autorizacion autorizacion, FeCabecera cabFe )
 {
     CAERespuestaFe Respuesta;
     try
     {
         int ultimoNro = this.ObtenerUltimoNumeroDeComprobante( autorizacion, cabFe.PuntoDeVenta, cabFe.TipoComprobante );
         this.Logueos_ObtenerCaeWSFE( cabFe, ultimoNro );
         FeDetalle item = cabFe.DetalleComprobantes[0];
         if ( item.ComprobanteDesde > ultimoNro + 1 )
         {
             Respuesta = this.Respuesta_UltimoComprobante( cabFe, ultimoNro, autorizacion );
         }
         else
         {
             FraccionadorDeLotesFe fdl = new FraccionadorDeLotesFe();
             FeCabecera feCabProcesar = fdl.ObtenerProcesar( cabFe, ultimoNro );
             FeCabecera feCabReprocesar = fdl.ObtenerReprocesar( cabFe, ultimoNro );
             Respuesta = this.ObtenerRespuestasUnificadas( autorizacion, feCabProcesar, feCabReprocesar );
         }
     }
     catch ( ExcepcionFe ex )
     {
         this.mensajeDeError = ex.Message;
         throw ex;
     }
     return Respuesta;
 }
        private CAERespuestaFe Respuesta_UltimoComprobante( FeCabecera cabFe, int ultimoNro, Autorizacion autorizacion )
        {
            string numero = this.FormatearNumero( cabFe, ultimoNro );
            string tipoComprobante = this.consultas.ObtenerCodigoComprobante( autorizacion, cabFe.TipoComprobante );

            CAERespuestaFe Respuesta = new CAERespuestaFe();
            Respuesta.Cabecera = new CAECabeceraRespuesta();
            Respuesta.Detalle = new List<CAEDetalleRespuesta>();
            Respuesta.Cabecera.CantidadDeRegistros = 1;
            Respuesta.Cabecera.FechaProceso = DateTime.Today.ToString();
            Respuesta.Cabecera.PuntoDeVenta = cabFe.PuntoDeVenta;
            Respuesta.Cabecera.TipoComprobante = cabFe.TipoComprobante;
            Respuesta.Cabecera.Resultado = "R";
            CAEDetalleRespuesta Detalle = new CAEDetalleRespuesta();
            Detalle.Observaciones = new List<Observacion>();
            Observacion Obs = new Observacion();
            Detalle.Cae = "";
            Detalle.CaeFechaVencimiento = "";
            Detalle.Resultado = "R";
            Obs.Mensaje = "El próximo comprobante " + tipoComprobante + " a procesar debe ser el número " + numero;
            Detalle.Observaciones.Add( Obs );
            Respuesta.Detalle.Add( Detalle );
            return Respuesta;
        }
        private CAERespuestaFe ObtenerRespuestasUnificadas( Autorizacion autorizacion, FeCabecera procesar, FeCabecera reprocesar )
        {
            CAERespuestaFe retorno = null;
            if ( procesar != null )
            {
                try
                {
                    this.logueador.Loguear( "Consultando Afip......\r\n" );
                    this.logueador.Loguear( procesar.Serializar() );

                    CAERespuestaFe respuestaProcesar = this.servidorFe.ObtenerCae( procesar, autorizacion );

                    this.logueador.Loguear( "Respuesta Afip.......\r\n" );
                    this.logueador.Loguear( respuestaProcesar.Serializar() );

                    retorno = respuestaProcesar;
                }
                catch ( ExcepcionFe ex )
                {
                    this.mensajeDeError = ex.Message;
                    throw ex;
                }
                foreach ( CAEDetalleRespuesta respuesta in retorno.Detalle )
                {
                    if ( (respuesta.Resultado.Trim() == "O" || respuesta.Resultado.Trim() == "R") && respuesta.Observaciones != null )
                    {
                        foreach ( Observacion observacion in respuesta.Observaciones )
                        {
                            this.logueador.Loguear( observacion.Mensaje );
                        }
                    }
                }
            }
            if ( reprocesar != null )
            {
                this.logueador.Loguear( "Consultando Afip......\r\n" );
                this.logueador.Loguear( reprocesar.Serializar() );

                CAERespuestaFe respuestaReprocesar = this.servidorFe.ReprocesarComprobantes( reprocesar, autorizacion );
                this.logueador.Loguear( "Respuesta Afip.......\r\n" );
                this.logueador.Loguear( respuestaReprocesar.Serializar() );

                if ( retorno == null )
                {
                    retorno = respuestaReprocesar;
                }
                else
                {
                    retorno.Unir( respuestaReprocesar );
                }
            }

            retorno.Detalle = this.OrdenarDetalle( retorno.Detalle );

            return retorno;
        }
        private void Logueos_ObtenerCaeWSFE( FeCabecera cabFe, int ultimoNro )
        {
            this.logueador.Loguear( "* Ultimo número " );
            this.logueador.Loguear( "Punto de venta : " + cabFe.PuntoDeVenta.ToString() );
            this.logueador.Loguear( "Tipo comprobante : " + cabFe.TipoComprobante.ToString() );
            this.logueador.Loguear( "Número : " + ultimoNro.ToString() );
            this.logueador.Loguear( "*" );

            this.logueador.Loguear( "* Solicitados " );
            this.logueador.Loguear( "Punto de venta : " + cabFe.PuntoDeVenta.ToString() );
            this.logueador.Loguear( "Tipo comprobante : " + cabFe.TipoComprobante.ToString() );

            foreach ( FeDetalle item in cabFe.DetalleComprobantes )
            {
                this.logueador.Loguear( "Desde : " + item.ComprobanteDesde.ToString() );
                this.logueador.Loguear( "Hasta : " + item.ComprobanteHasta.ToString() );
            }
        }
 private string FormatearNumero( FeCabecera cabFe, int ultimoNro )
 {
     string numero = cabFe.PuntoDeVenta.ToString().PadLeft( 4, '0' ) + "-" + ( ultimoNro + 1 ).ToString().PadLeft( 8, '0' );
     return numero;
 }
 private FECAERequest ObtenerCaeRequest( FeCabecera cabFe )
 {
     WrapperCabeceraFe wc = new WrapperCabeceraFe();
     return wc.Convertir( cabFe );
 }
        private CAERespuestaFe SolicitarCAE( FeCabecera cabFe, FEAuthRequest aut )
        {
            FECAERequest feCaeRequest = this.ObtenerCaeRequest( cabFe );

            SerializadorRequest serializador = new SerializadorRequest();
            serializador.Serializar<FECAERequest>( feCaeRequest );

            FECAEResponse caeResponse = this.wsfe.FECAESolicitar( aut, feCaeRequest );
            ManagerErroresFe managerErrores = new ManagerErroresFe( this.logueador );

            if (this.HuboSolicitudesRechazadas( caeResponse ))
            {
                this.GenerarBackupArchivoSerializado(serializador, feCaeRequest);
            }

            managerErrores.CapturarError(caeResponse.Errors, cabFe);

            WrapperCaeRespuestaFe wcrf = new WrapperCaeRespuestaFe();

            return wcrf.Convertir( caeResponse );
        }
        public CAERespuestaFe ObtenerCaeWSFE( ConfiguracionWS config, FeCabecera cabFe )
        {
            Autorizacion aut = this.IniciarWSAA( config );
            this.AplicarConfiguracionWS( this.funcionesFe.Wsfe, config );

            return this.funcionesFe.ObtenerCae( aut, cabFe );
        }