public ClsFEXRequest Convertir( FexCabecera cabFex )
        {
            ClsFEXRequest cab = new ClsFEXRequest();
            cab.Id = cabFex.Id;
            cab.Tipo_cbte = (short)cabFex.TipoComprobante;
            cab.Fecha_cbte = cabFex.FechaComprobante;
            cab.Punto_vta = (short)cabFex.PuntoDeVenta;
            cab.Cbte_nro = cabFex.ComprobanteNumero;
            cab.Tipo_expo = (short) cabFex.TipoExportacion;
            cab.Permiso_existente = cabFex.PermisoExistente;
            cab.Dst_cmp = (short)cabFex.PaisDestinoComprobante;
            cab.Cliente = cabFex.Cliente;
            cab.Cuit_pais_cliente = cabFex.CuitPaisCliente;
            cab.Domicilio_cliente = cabFex.DomicilioCliente;
            cab.Id_impositivo = cabFex.IdImpositivo;
            cab.Moneda_Id = cabFex.MonedaId;
            cab.Moneda_ctz = cabFex.MonedaCotizacion;
            cab.Obs_comerciales = cabFex.ObservacionesComerciales;
            cab.Obs = cabFex.Observaciones;
            cab.Forma_pago = cabFex.FormaDePagoDescripcion;
            cab.Incoterms = cabFex.ClausulaDeVenta;
            cab.Incoterms_Ds = cabFex.ClausulaDeVentaInformacionComplementaria;
            cab.Idioma_cbte = (short) cabFex.IdiomaComprobante;
            cab.Permisos = this.ConvertirPermisos( cabFex.Permisos );
            cab.Cmps_asoc = this.ConvertirComprobantesAsociados( cabFex.ComprobantesAsociados );
            cab.Items = this.ConvertirItems( cabFex.Items );
            cab.Imp_total = this.ObtenerValorImporteTotal( cabFex.ImporteTotal );

            return cab;
        }
Example #2
0
        public FEXResponseAuthorize AutorizarComprobanteExportacion(ClsFEXAuthRequest fexAuthRequest, ClsFEXRequest fexRequest)
        {
            AfipWrapperServiceClient client = new AfipWrapperServiceClient();

            ClientCredentialHelper.SetCredentials(client.ClientCredentials);
            try
            {
                var t = client.AutorizarComprobanteExportacion(fexAuthRequest, fexRequest);
                client.Close();
                return(t);
            }
            catch
            {
                if (client.State != System.ServiceModel.CommunicationState.Closed)
                {
                    client.Abort();
                }

                throw;
            }
        }
 /// <remarks/>
 public void FEXAuthorizeAsync( ClsFEXAuthRequest Auth, ClsFEXRequest Cmp, object userState )
 {
     if ( ( this.FEXAuthorizeOperationCompleted == null ) )
         {
             this.FEXAuthorizeOperationCompleted = new System.Threading.SendOrPostCallback( this.OnFEXAuthorizeOperationCompleted );
         }
         this.InvokeAsync( "FEXAuthorize", new object[] {
                 Auth,
                 Cmp}, this.FEXAuthorizeOperationCompleted, userState );
 }
 /// <remarks/>
 public void FEXAuthorizeAsync( ClsFEXAuthRequest Auth, ClsFEXRequest Cmp )
 {
     this.FEXAuthorizeAsync( Auth, Cmp, null );
 }
 public FEXResponseAuthorize FEXAuthorize( ClsFEXAuthRequest Auth, ClsFEXRequest Cmp )
 {
     object[] results = this.Invoke( "FEXAuthorize", new object[] {
                 Auth,
                 Cmp} );
         return ( (FEXResponseAuthorize) ( results[0] ) );
 }
 /// <remarks/>
 public System.IAsyncResult BeginFEXAuthorize( ClsFEXAuthRequest Auth, ClsFEXRequest Cmp, System.AsyncCallback callback, object asyncState )
 {
     return this.BeginInvoke( "FEXAuthorize", new object[] {
                 Auth,
                 Cmp}, callback, asyncState );
 }
Example #7
0
        private FEXResponseAuthorize AutorizarComprobantes(ClsFEXAuthRequest feXAuthRequest, ClsFEXRequest feXCAERequest)
        {
            WsfeClient client = new WsfeClient();

            return(client.AutorizarComprobanteExportacion(feXAuthRequest, feXCAERequest));
        }
Example #8
0
        public CorridaAutorizacionDto AutorizarComprobantesParaWsFeX(CorridaAutorizacionDto corridaDto)
        {
            try
            {
                this.corridaDto = corridaDto;
                string pathArchivoOrigen = corridaDto.PathArchivo;

                if (string.IsNullOrEmpty(corridaDto.PathArchivo))
                {
                    this.Log("ERROR: No se ha ingresado el path del archivo");
                }

                // Marco la corrida como en proceso en la base de datos
                if (this.corridaSvc.MarcarCorridaEnProceso(corridaDto.Id))
                {
                    // Inicio Proceso
                    this.Log(string.Format("Iniciando procesamiento de archivo {0}...", this.nombreDeArchivo));

                    // Valido el Esquema de Xml
                    this.Log(string.Format("Validando esquema de archivo"));
                    string xmlSchemaPath = "";

                    if (!this.ValidarEsquemaXml(corridaDto.PathArchivo, xmlSchemaPath))
                    {
                        StringBuilder sb = new StringBuilder();
                        sb.AppendLine("ERROR: el formato del archivo es invalido");
                        sb.AppendLine(this.validacionesEsquema.ToString());
                        this.Log(sb.ToString());
                        return(null);
                    }

                    // Leo archivo XML y lo paso a string
                    this.Log("Leyendo archivo...");
                    string xmlString = LeerArchivo(corridaDto.PathArchivo);

                    // Reemplazo <Lote></Lote> por <FeCAEReq></FeCAEReq>
                    xmlString = xmlString.Replace("<FacturaExportacion>", "<ClsFEXRequest>").Replace("</FacturaExportacion>", "</ClsFEXRequest>");

                    // Deserealizo el XML y obtengo solo la parte del request
                    ClsFEXRequest feXCAERequest = null;
                    try
                    {
                        feXCAERequest = DeserializarXml <ClsFEXRequest>(xmlString, "http://ar.gov.afip.dif.fexv1/");

                        //feXCAERequest = new ClsFEXRequest();
                        //feXCAERequest.Id = 1;
                        //feXCAERequest.Fecha_cbte = "20120820";
                        //feXCAERequest.Punto_vta = 19;
                        //feXCAERequest.Cbte_nro = 1;
                        //feXCAERequest.Tipo_expo = 1;
                        //feXCAERequest.Permiso_existente = "S";
                        //feXCAERequest.Permisos = new Permiso[2];
                        //feXCAERequest.Permisos[0] = new Permiso();
                        //feXCAERequest.Permisos[0].Dst_merc = 203;
                        //feXCAERequest.Permisos[1] = new Permiso();
                        //feXCAERequest.Permisos[1].Id_permiso = "09052EC01006154G";
                        //feXCAERequest.Permisos[1].Dst_merc = 202;
                        //feXCAERequest.Dst_cmp = 203;
                        //feXCAERequest.Cliente = "Joao Da Silva";
                        //feXCAERequest.Cuit_pais_cliente = 50000000016;
                        //feXCAERequest.Domicilio_cliente = "Rua 76 km 34.5 Alagoas";
                        //feXCAERequest.Id_impositivo = "PJ54482221-l";
                        //feXCAERequest.Moneda_Id = "012";
                        //feXCAERequest.Moneda_ctz = 0.51M;
                        //feXCAERequest.Obs_comerciales = "Sin observaciones";
                        //feXCAERequest.Imp_total = 500;
                        //feXCAERequest.Forma_pago = "Contado";
                        //feXCAERequest.Incoterms = "CIF";
                        //feXCAERequest.Incoterms_Ds = "Texto dic.";
                        //feXCAERequest.Idioma_cbte = 1;
                        //feXCAERequest.Items = new Item[1];
                        //feXCAERequest.Items[0] = new Item();
                        //feXCAERequest.Items[0].Pro_codigo = "PRO1";
                        //feXCAERequest.Items[0].Pro_ds = "Producto Tipo 1 Exportacion MERCOSUR ISO 9001";
                        //feXCAERequest.Items[0].Pro_qty = 2;
                        //feXCAERequest.Items[0].Pro_umed = 7;
                        //feXCAERequest.Items[0].Pro_precio_uni = 250;
                        //feXCAERequest.Items[0].Pro_total_item = 500;

                        //feXCAERequest.Cmps_asoc = new Cmp_asoc[0];

                        //var revisar = SerializarXml<ClsFEXRequest>(feXCAERequest);
                        //revisar = revisar.ToString();
                    }
                    catch (Exception ex)
                    {
                        this.Log("El formato del archivo es inválido.");
                        return(null);
                    }

                    // Obtengo Ticket de Autorizacion
                    this.Log("Iniciando comunicacion con la AFIP");
                    ClsFEXAuthRequest feXAuthRequest = this.ObtenerTicketWSFeX();

                    // Cargo los comprobantes que estan autorizados en la AFIP
                    // pero que no fueron cargados en la DB por problemas en
                    // la comunicacion
                    //-------------------------------------
                    //-------------------------------------
                    // IMPORTANTE!!!!!!
                    //-------------------------------------
                    //-------------------------------------
                    // El siguiente codigo tiene que refactorearse según como trabaja este nuevo servicio
                    // ByAd TODO: this.CargarComprobantesYaAutorizados(feAuthRequest, feCAERequest);


                    // Remover Comprobantes que ya han sido autorizados
                    //string resultado = this.RemoverComprobantesAutorizados(feAuthRequest, feCAERequest);
                    //if (!string.IsNullOrEmpty(resultado))
                    //{
                    //    this.Log(resultado);
                    //    feCAERequest.FeCabReq.CantReg = feCAERequest.FeDetReq.Count();
                    //}
                    //-------------------------------------
                    //-------------------------------------
                    //-------------------------------------

                    if (feXCAERequest != null)
                    {
                        // Autorizar Comprobantes con la AFIP
                        this.Log("Autorizando Comprobantes con la AFIP...");
                        FEXResponseAuthorize feXCAEResponse = this.AutorizarComprobantes(feXAuthRequest, feXCAERequest);

                        // Proceso Resultado AFIP
                        this.Log("Procesando respuesta de la AFIP...");
                        corridaDto = this.corridaSvc.ProcesarCorridaWsFeX(corridaDto, feXCAEResponse, feXCAERequest);
                    }
                    else
                    {
                        // Todos los comprobantes del archivo ya tienen un CAE asignado
                        // y existen en DB
                        this.Log("Todos los comprobantes del archivo ya han sido autorizados");
                    }

                    // Muevo el archivo a una carpeta de procesados
                    GuardarArchivoProcesado(pathArchivoOrigen);

                    this.Log("Fin procesamiento de archivo.");
                }
                else
                {
                    this.Log("La corrida ya se está ejecutando");
                }

                return(corridaDto);
            }
            catch (Exception ex)
            {
                string detalle = string.Format("ex.Message: {0} ex.StackTrace: {1}", ex.Message, ex.StackTrace);
                this.Log(string.Format("ERROR: Se ha producido un error. Contactese con el administrador. Error: {0}", ex.Message), detalle);
                return(null);
            }
            finally
            {
                this.Log(CorridaService.FinCorridaMsg);
            }
        }
Example #9
0
        public CorridaAutorizacionDto ProcesarCorridaWsFeX(CorridaAutorizacionDto corridaDto, FEXResponseAuthorize feXCAEResponse, ClsFEXRequest feXCAERequest)
        {
            using (var ctx = new FacturaElectronicaEntities())
            {
                CorridaAutorizacion corrida = ctx.CorridaAutorizacions.Where(c => c.Id == corridaDto.Id).First();

                // Procesar Cabecera
                DetalleCabecera    cabecera  = new DetalleCabecera();
                ClsFEXOutAuthorize feCabResp = feXCAEResponse.FEXResultAuth;
                if (feCabResp != null)
                {
                    cabecera.CantReg    = 1; // ByAd: revisar
                    cabecera.CUIT       = feCabResp.Cuit;
                    cabecera.CbteTipo   = feCabResp.Cbte_tipo;
                    cabecera.FchProceso = DateTime.Now; // ByAd: revisar
                    cabecera.Resultado  = feCabResp.Resultado;
                    cabecera.PtoVta     = feCabResp.Punto_vta;

                    corrida.DetalleCabeceras.Add(cabecera);

                    TipoComprobanteDto tipoCbteDto = cbteSvc.ObtenerTipoComprobantePorCodigoAfip(cabecera.CbteTipo);
                    int tipoCbteId;
                    if (tipoCbteDto != null)
                    {
                        tipoCbteId = tipoCbteDto.Id;
                    }

                    // Procesar Comprobantes
                    DetalleComprobante     detalleCbte       = null;
                    ObservacionComprobante observacionesCbte = null;

                    detalleCbte           = new DetalleComprobante();
                    detalleCbte.Concepto  = 1; // ByAd revisar: aca es prdoucto, servicios o ambos
                    detalleCbte.DocTipo   = 80;
                    detalleCbte.DocNro    = feCabResp.Cuit;
                    detalleCbte.CbteDesde = feCabResp.Cbte_nro;
                    detalleCbte.CbteHasta = feCabResp.Cbte_nro;
                    detalleCbte.CbteFch   = DateTimeHelper.ConvertyyyyMMddToDate(feCabResp.Fch_cbte);
                    detalleCbte.Resultado = feCabResp.Resultado;

                    if (feCabResp.Resultado == ResultadoCbte.Aprobado)
                    {
                        detalleCbte.CAE       = feCabResp.Cae;
                        detalleCbte.CAEFchVto = DateTimeHelper.ConvertyyyyMMddToDate(feCabResp.Fch_venc_Cae);

                        // Si fue aprobado agrego una entidad Comprobante
                        Comprobante comprobante = new Comprobante();
                        comprobante.CAE = detalleCbte.CAE;
                        comprobante.CAEFechaVencimiento = detalleCbte.CAEFchVto;
                        comprobante.CbteDesde           = detalleCbte.CbteDesde;
                        comprobante.CbteHasta           = detalleCbte.CbteHasta;
                        comprobante.CbteFecha           = detalleCbte.CbteFch;
                        comprobante.PtoVta          = cabecera.PtoVta;
                        comprobante.FechaDeCarga    = DateTime.Now;
                        comprobante.TipoComprobante = ctx.TipoComprobantes.Where(tc => tc.CodigoAfip == cabecera.CbteTipo).FirstOrDefault();
                        if (detalleCbte.DocTipo == 80) // CUIT
                        {
                            ClienteDto clienteDto = clienteSvc.ObtenerClientePorCuit(detalleCbte.DocNro);
                            if (clienteDto != null)
                            {
                                comprobante.ClienteId = clienteDto.Id;
                            }
                        }
                        // #TODO: borrar
                        //EstadoComprobanteDto estadoDto = this.cbteSvc.ObtenerEstado(CodigoEstadoCbte.NoVisualizado);
                        //if (estadoDto != null)
                        //{
                        //    comprobante.EstadoId = estadoDto.Id;
                        //}
                        detalleCbte.Comprobantes.Add(comprobante);
                    }
                    else
                    {
                        if (!String.IsNullOrEmpty(feCabResp.Motivos_Obs))
                        {
                            observacionesCbte      = new ObservacionComprobante();
                            observacionesCbte.Code = 1; // ByAd: hardcodeado, ya que este tipo no recibe
                            observacionesCbte.Msg  = feCabResp.Motivos_Obs;
                            detalleCbte.ObservacionComprobantes.Add(observacionesCbte);
                        }
                    }

                    corrida.DetalleComprobantes.Add(detalleCbte);
                }

                if (feXCAEResponse.FEXEvents != null && !String.IsNullOrEmpty(feXCAEResponse.FEXEvents.EventMsg))
                {
                    // Procesar Eventos
                    DetalleEvento detalleEvento = null;
                    detalleEvento      = new DetalleEvento();
                    detalleEvento.Code = feXCAEResponse.FEXEvents.EventCode;
                    detalleEvento.Msg  = feXCAEResponse.FEXEvents.EventMsg;
                    corrida.DetalleEventos.Add(detalleEvento);
                }
                if (feXCAEResponse.FEXErr != null && !String.IsNullOrEmpty(feXCAEResponse.FEXErr.ErrMsg))
                {
                    // Procesar Errores
                    DetalleError detalleError = null;
                    detalleError      = new DetalleError();
                    detalleError.Code = feXCAEResponse.FEXErr.ErrCode;
                    detalleError.Msg  = feXCAEResponse.FEXErr.ErrMsg;
                    corrida.DetalleErrores.Add(detalleError);
                }

                corrida.Procesada = true;

                ctx.SaveChanges();
                return(ToCorridaDto(corrida, ctx.TipoDocumentoes.ToList(), ctx.TipoComprobantes.ToList(), ctx.TipoConceptoes.ToList()));
            }
        }
Example #10
0
        public FEXResponseAuthorize AutorizarComprobanteExportacion(ClsFEXAuthRequest fexAuthRequest, ClsFEXRequest fexRequest)
        {
            try
            {
                using (Ws.Wsfex.ServiceSoapClient client = new Ws.Wsfex.ServiceSoapClient())
                {
                    return(client.FEXAuthorize(fexAuthRequest, fexRequest));
                }
            }

            catch (Exception ex)
            {
                throw new Exception(errorWsfe + ex.Message);
            }
        }