9 respuestas en este tema

[giulichajari]

Hola amigos, para desarrollar factura electronica de AFIP, segun las especificaciones hay que mandar un archivo xml con los datos de la factura al webservice de AFIP.

Generara el xml ya lo he logrado, utilizando el data binding y el xsd.

El caso es que importe el servicio de homologacion con WSDL Importer:

delphi

ServiceSoap = interface(IInvokable)
  ['{05274D74-5C3D-E536-980E-D9CE5D67F5D9}']
    function  FECAESolicitar(const Auth: FEAuthRequest; const FeCAEReq: FECAERequest): FECAEResponse; stdcall;
    function  FECompTotXRequest(const Auth: FEAuthRequest): FERegXReqResponse; stdcall;
    function  FEDummy: DummyResponse; stdcall;
    function  FECompUltimoAutorizado(const Auth: FEAuthRequest; const PtoVta: Integer; const CbteTipo: Integer): FERecuperaLastCbteResponse; stdcall;
    function  FECompConsultar(const Auth: FEAuthRequest; const FeCompConsReq: FECompConsultaReq): FECompConsultaResponse; stdcall;
    function  FECAEARegInformativo(const Auth: FEAuthRequest; const FeCAEARegInfReq: FECAEARequest): FECAEAResponse; stdcall;
    function  FECAEASolicitar(const Auth: FEAuthRequest; const Periodo: Integer; const Orden: SmallInt): FECAEAGetResponse; stdcall;
    function  FECAEASinMovimientoConsultar(const Auth: FEAuthRequest; const CAEA: string; const PtoVta: Integer): FECAEASinMovConsResponse; stdcall;
    function  FECAEASinMovimientoInformar(const Auth: FEAuthRequest; const PtoVta: Integer; const CAEA: string): FECAEASinMovResponse; stdcall;
    function  FECAEAConsultar(const Auth: FEAuthRequest; const Periodo: Integer; const Orden: SmallInt): FECAEAGetResponse; stdcall;
    function  FEParamGetCotizacion(const Auth: FEAuthRequest; const MonId: string): FECotizacionResponse; stdcall;
    function  FEParamGetTiposTributos(const Auth: FEAuthRequest): FETributoResponse; stdcall;
    function  FEParamGetTiposMonedas(const Auth: FEAuthRequest): MonedaResponse; stdcall;
    function  FEParamGetTiposIva(const Auth: FEAuthRequest): IvaTipoResponse; stdcall;
    function  FEParamGetTiposOpcional(const Auth: FEAuthRequest): OpcionalTipoResponse; stdcall;
    function  FEParamGetTiposConcepto(const Auth: FEAuthRequest): ConceptoTipoResponse; stdcall;
    function  FEParamGetPtosVenta(const Auth: FEAuthRequest): FEPtoVentaResponse; stdcall;
    function  FEParamGetTiposCbte(const Auth: FEAuthRequest): CbteTipoResponse; stdcall;
    function  FEParamGetTiposDoc(const Auth: FEAuthRequest): DocTipoResponse; stdcall;
    function  FEParamGetTiposPaises(const Auth: FEAuthRequest): FEPaisResponse; stdcall;
  end;
 
function GetServiceSoap(UseWSDL: Boolean=System.False; Addr: string=''; HTTPRIO: THTTPRIO = nil): ServiceSoap;
 
 
implementation
  uses System.SysUtils;
 
function GetServiceSoap(UseWSDL: Boolean; Addr: string; HTTPRIO: THTTPRIO): ServiceSoap;
const
  defWSDL = 'https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL';
  defURL  = 'https://wswhomo.afip.gov.ar/wsfev1/service.asmx';
  defSvc  = 'Service';
  defPrt  = 'ServiceSoap';
var
  RIO: THTTPRIO;
begin
  Result := nil;
  if (Addr = '') then
  begin
    if UseWSDL then
      Addr := defWSDL
    else
      Addr := defURL;
  end;
  if HTTPRIO = nil then
    RIO := THTTPRIO.Create(nil)
  else
    RIO := HTTPRIO;
  try
    Result := (RIO as ServiceSoap);
    if UseWSDL then
    begin
      RIO.WSDLLocation := Addr;
      RIO.Service := defSvc;
      RIO.Port := defPrt;
    end else
      RIO.URL := Addr;
  finally
    if (Result = nil) and (HTTPRIO = nil) then
      RIO.Free;
  end;
end;
 
 
destructor FECAEResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FFeDetResp)-1 do
    System.SysUtils.FreeAndNil(FFeDetResp[I]);
  System.SetLength(FFeDetResp, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  System.SysUtils.FreeAndNil(FFeCabResp);
  inherited Destroy;
end;
 
procedure FECAEResponse.SetFeCabResp(Index: Integer; const AFECAECabResponse: FECAECabResponse);
begin
  FFeCabResp := AFECAECabResponse;
  FFeCabResp_Specified := True;
end;
 
function FECAEResponse.FeCabResp_Specified(Index: Integer): boolean;
begin
  Result := FFeCabResp_Specified;
end;
 
procedure FECAEResponse.SetFeDetResp(Index: Integer; const AArrayOfFECAEDetResponse: ArrayOfFECAEDetResponse);
begin
  FFeDetResp := AArrayOfFECAEDetResponse;
  FFeDetResp_Specified := True;
end;
 
function FECAEResponse.FeDetResp_Specified(Index: Integer): boolean;
begin
  Result := FFeDetResp_Specified;
end;
 
procedure FECAEResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FECAEResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
procedure FECAEResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FECAEResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
destructor DocTipoResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure DocTipoResponse.SetResultGet(Index: Integer; const AArrayOfDocTipo: ArrayOfDocTipo);
begin
  FResultGet := AArrayOfDocTipo;
  FResultGet_Specified := True;
end;
 
function DocTipoResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure DocTipoResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function DocTipoResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure DocTipoResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function DocTipoResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor CbteTipoResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure CbteTipoResponse.SetResultGet(Index: Integer; const AArrayOfCbteTipo: ArrayOfCbteTipo);
begin
  FResultGet := AArrayOfCbteTipo;
  FResultGet_Specified := True;
end;
 
function CbteTipoResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure CbteTipoResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function CbteTipoResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure CbteTipoResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function CbteTipoResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor FEPaisResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure FEPaisResponse.SetResultGet(Index: Integer; const AArrayOfPaisTipo: ArrayOfPaisTipo);
begin
  FResultGet := AArrayOfPaisTipo;
  FResultGet_Specified := True;
end;
 
function FEPaisResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure FEPaisResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FEPaisResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FEPaisResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FEPaisResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor OpcionalTipoResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure OpcionalTipoResponse.SetResultGet(Index: Integer; const AArrayOfOpcionalTipo: ArrayOfOpcionalTipo);
begin
  FResultGet := AArrayOfOpcionalTipo;
  FResultGet_Specified := True;
end;
 
function OpcionalTipoResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure OpcionalTipoResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function OpcionalTipoResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure OpcionalTipoResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function OpcionalTipoResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor IvaTipoResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure IvaTipoResponse.SetResultGet(Index: Integer; const AArrayOfIvaTipo: ArrayOfIvaTipo);
begin
  FResultGet := AArrayOfIvaTipo;
  FResultGet_Specified := True;
end;
 
function IvaTipoResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure IvaTipoResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function IvaTipoResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure IvaTipoResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function IvaTipoResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor FEPtoVentaResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure FEPtoVentaResponse.SetResultGet(Index: Integer; const AArrayOfPtoVenta: ArrayOfPtoVenta);
begin
  FResultGet := AArrayOfPtoVenta;
  FResultGet_Specified := True;
end;
 
function FEPtoVentaResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure FEPtoVentaResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FEPtoVentaResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FEPtoVentaResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FEPtoVentaResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor ConceptoTipoResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure ConceptoTipoResponse.SetResultGet(Index: Integer; const AArrayOfConceptoTipo: ArrayOfConceptoTipo);
begin
  FResultGet := AArrayOfConceptoTipo;
  FResultGet_Specified := True;
end;
 
function ConceptoTipoResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure ConceptoTipoResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function ConceptoTipoResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure ConceptoTipoResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function ConceptoTipoResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor FECAERequest.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FFeDetReq)-1 do
    System.SysUtils.FreeAndNil(FFeDetReq[I]);
  System.SetLength(FFeDetReq, 0);
  System.SysUtils.FreeAndNil(FFeCabReq);
  inherited Destroy;
end;
 
procedure FECAERequest.SetFeCabReq(Index: Integer; const AFECAECabRequest: FECAECabRequest);
begin
  FFeCabReq := AFECAECabRequest;
  FFeCabReq_Specified := True;
end;
 
function FECAERequest.FeCabReq_Specified(Index: Integer): boolean;
begin
  Result := FFeCabReq_Specified;
end;
 
procedure FECAERequest.SetFeDetReq(Index: Integer; const AArrayOfFECAEDetRequest: ArrayOfFECAEDetRequest);
begin
  FFeDetReq := AArrayOfFECAEDetRequest;
  FFeDetReq_Specified := True;
end;
 
function FECAERequest.FeDetReq_Specified(Index: Integer): boolean;
begin
  Result := FFeDetReq_Specified;
end;
 
procedure Opcional.SetId(Index: Integer; const Astring: string);
begin
  FId := Astring;
  FId_Specified := True;
end;
 
function Opcional.Id_Specified(Index: Integer): boolean;
begin
  Result := FId_Specified;
end;
 
procedure Opcional.SetValor(Index: Integer; const Astring: string);
begin
  FValor := Astring;
  FValor_Specified := True;
end;
 
function Opcional.Valor_Specified(Index: Integer): boolean;
begin
  Result := FValor_Specified;
end;
 
procedure Moneda.SetId(Index: Integer; const Astring: string);
begin
  FId := Astring;
  FId_Specified := True;
end;
 
function Moneda.Id_Specified(Index: Integer): boolean;
begin
  Result := FId_Specified;
end;
 
procedure Moneda.SetDesc(Index: Integer; const Astring: string);
begin
  FDesc := Astring;
  FDesc_Specified := True;
end;
 
function Moneda.Desc_Specified(Index: Integer): boolean;
begin
  Result := FDesc_Specified;
end;
 
procedure Moneda.SetFchDesde(Index: Integer; const Astring: string);
begin
  FFchDesde := Astring;
  FFchDesde_Specified := True;
end;
 
function Moneda.FchDesde_Specified(Index: Integer): boolean;
begin
  Result := FFchDesde_Specified;
end;
 
procedure Moneda.SetFchHasta(Index: Integer; const Astring: string);
begin
  FFchHasta := Astring;
  FFchHasta_Specified := True;
end;
 
function Moneda.FchHasta_Specified(Index: Integer): boolean;
begin
  Result := FFchHasta_Specified;
end;
 
procedure PaisTipo.SetDesc(Index: Integer; const Astring: string);
begin
  FDesc := Astring;
  FDesc_Specified := True;
end;
 
function PaisTipo.Desc_Specified(Index: Integer): boolean;
begin
  Result := FDesc_Specified;
end;
 
procedure IvaTipo.SetId(Index: Integer; const Astring: string);
begin
  FId := Astring;
  FId_Specified := True;
end;
 
function IvaTipo.Id_Specified(Index: Integer): boolean;
begin
  Result := FId_Specified;
end;
 
procedure IvaTipo.SetDesc(Index: Integer; const Astring: string);
begin
  FDesc := Astring;
  FDesc_Specified := True;
end;
 
function IvaTipo.Desc_Specified(Index: Integer): boolean;
begin
  Result := FDesc_Specified;
end;
 
procedure IvaTipo.SetFchDesde(Index: Integer; const Astring: string);
begin
  FFchDesde := Astring;
  FFchDesde_Specified := True;
end;
 
function IvaTipo.FchDesde_Specified(Index: Integer): boolean;
begin
  Result := FFchDesde_Specified;
end;
 
procedure IvaTipo.SetFchHasta(Index: Integer; const Astring: string);
begin
  FFchHasta := Astring;
  FFchHasta_Specified := True;
end;
 
function IvaTipo.FchHasta_Specified(Index: Integer): boolean;
begin
  Result := FFchHasta_Specified;
end;
 
procedure OpcionalTipo.SetId(Index: Integer; const Astring: string);
begin
  FId := Astring;
  FId_Specified := True;
end;
 
function OpcionalTipo.Id_Specified(Index: Integer): boolean;
begin
  Result := FId_Specified;
end;
 
procedure OpcionalTipo.SetDesc(Index: Integer; const Astring: string);
begin
  FDesc := Astring;
  FDesc_Specified := True;
end;
 
function OpcionalTipo.Desc_Specified(Index: Integer): boolean;
begin
  Result := FDesc_Specified;
end;
 
procedure OpcionalTipo.SetFchDesde(Index: Integer; const Astring: string);
begin
  FFchDesde := Astring;
  FFchDesde_Specified := True;
end;
 
function OpcionalTipo.FchDesde_Specified(Index: Integer): boolean;
begin
  Result := FFchDesde_Specified;
end;
 
procedure OpcionalTipo.SetFchHasta(Index: Integer; const Astring: string);
begin
  FFchHasta := Astring;
  FFchHasta_Specified := True;
end;
 
function OpcionalTipo.FchHasta_Specified(Index: Integer): boolean;
begin
  Result := FFchHasta_Specified;
end;
 
procedure FEAuthRequest.SetToken(Index: Integer; const Astring: string);
begin
  FToken := Astring;
  FToken_Specified := True;
end;
 
function FEAuthRequest.Token_Specified(Index: Integer): boolean;
begin
  Result := FToken_Specified;
end;
 
procedure FEAuthRequest.SetSign(Index: Integer; const Astring: string);
begin
  FSign := Astring;
  FSign_Specified := True;
end;
 
function FEAuthRequest.Sign_Specified(Index: Integer): boolean;
begin
  Result := FSign_Specified;
end;
 
procedure FECabResponse.SetFchProceso(Index: Integer; const Astring: string);
begin
  FFchProceso := Astring;
  FFchProceso_Specified := True;
end;
 
function FECabResponse.FchProceso_Specified(Index: Integer): boolean;
begin
  Result := FFchProceso_Specified;
end;
 
procedure FECabResponse.SetResultado(Index: Integer; const Astring: string);
begin
  FResultado := Astring;
  FResultado_Specified := True;
end;
 
function FECabResponse.Resultado_Specified(Index: Integer): boolean;
begin
  Result := FResultado_Specified;
end;
 
procedure FECabResponse.SetReproceso(Index: Integer; const Astring: string);
begin
  FReproceso := Astring;
  FReproceso_Specified := True;
end;
 
function FECabResponse.Reproceso_Specified(Index: Integer): boolean;
begin
  Result := FReproceso_Specified;
end;
 
procedure CbteAsoc.SetCuit(Index: Integer; const Astring: string);
begin
  FCuit := Astring;
  FCuit_Specified := True;
end;
 
function CbteAsoc.Cuit_Specified(Index: Integer): boolean;
begin
  Result := FCuit_Specified;
end;
 
procedure CbteAsoc.SetCbteFch(Index: Integer; const Astring: string);
begin
  FCbteFch := Astring;
  FCbteFch_Specified := True;
end;
 
function CbteAsoc.CbteFch_Specified(Index: Integer): boolean;
begin
  Result := FCbteFch_Specified;
end;
 
procedure CbteTipo.SetDesc(Index: Integer; const Astring: string);
begin
  FDesc := Astring;
  FDesc_Specified := True;
end;
 
function CbteTipo.Desc_Specified(Index: Integer): boolean;
begin
  Result := FDesc_Specified;
end;
 
procedure CbteTipo.SetFchDesde(Index: Integer; const Astring: string);
begin
  FFchDesde := Astring;
  FFchDesde_Specified := True;
end;
 
function CbteTipo.FchDesde_Specified(Index: Integer): boolean;
begin
  Result := FFchDesde_Specified;
end;
 
procedure CbteTipo.SetFchHasta(Index: Integer; const Astring: string);
begin
  FFchHasta := Astring;
  FFchHasta_Specified := True;
end;
 
function CbteTipo.FchHasta_Specified(Index: Integer): boolean;
begin
  Result := FFchHasta_Specified;
end;
 
procedure PtoVenta.SetEmisionTipo(Index: Integer; const Astring: string);
begin
  FEmisionTipo := Astring;
  FEmisionTipo_Specified := True;
end;
 
function PtoVenta.EmisionTipo_Specified(Index: Integer): boolean;
begin
  Result := FEmisionTipo_Specified;
end;
 
procedure PtoVenta.SetBloqueado(Index: Integer; const Astring: string);
begin
  FBloqueado := Astring;
  FBloqueado_Specified := True;
end;
 
function PtoVenta.Bloqueado_Specified(Index: Integer): boolean;
begin
  Result := FBloqueado_Specified;
end;
 
procedure PtoVenta.SetFchBaja(Index: Integer; const Astring: string);
begin
  FFchBaja := Astring;
  FFchBaja_Specified := True;
end;
 
function PtoVenta.FchBaja_Specified(Index: Integer): boolean;
begin
  Result := FFchBaja_Specified;
end;
 
procedure DocTipo.SetDesc(Index: Integer; const Astring: string);
begin
  FDesc := Astring;
  FDesc_Specified := True;
end;
 
function DocTipo.Desc_Specified(Index: Integer): boolean;
begin
  Result := FDesc_Specified;
end;
 
procedure DocTipo.SetFchDesde(Index: Integer; const Astring: string);
begin
  FFchDesde := Astring;
  FFchDesde_Specified := True;
end;
 
function DocTipo.FchDesde_Specified(Index: Integer): boolean;
begin
  Result := FFchDesde_Specified;
end;
 
procedure DocTipo.SetFchHasta(Index: Integer; const Astring: string);
begin
  FFchHasta := Astring;
  FFchHasta_Specified := True;
end;
 
function DocTipo.FchHasta_Specified(Index: Integer): boolean;
begin
  Result := FFchHasta_Specified;
end;
 
procedure ConceptoTipo.SetDesc(Index: Integer; const Astring: string);
begin
  FDesc := Astring;
  FDesc_Specified := True;
end;
 
function ConceptoTipo.Desc_Specified(Index: Integer): boolean;
begin
  Result := FDesc_Specified;
end;
 
procedure ConceptoTipo.SetFchDesde(Index: Integer; const Astring: string);
begin
  FFchDesde := Astring;
  FFchDesde_Specified := True;
end;
 
function ConceptoTipo.FchDesde_Specified(Index: Integer): boolean;
begin
  Result := FFchDesde_Specified;
end;
 
procedure ConceptoTipo.SetFchHasta(Index: Integer; const Astring: string);
begin
  FFchHasta := Astring;
  FFchHasta_Specified := True;
end;
 
function ConceptoTipo.FchHasta_Specified(Index: Integer): boolean;
begin
  Result := FFchHasta_Specified;
end;
 
destructor FEDetRequest.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FCbtesAsoc)-1 do
    System.SysUtils.FreeAndNil(FCbtesAsoc[I]);
  System.SetLength(FCbtesAsoc, 0);
  for I := 0 to System.Length(FTributos)-1 do
    System.SysUtils.FreeAndNil(FTributos[I]);
  System.SetLength(FTributos, 0);
  for I := 0 to System.Length(FIva)-1 do
    System.SysUtils.FreeAndNil(FIva[I]);
  System.SetLength(FIva, 0);
  for I := 0 to System.Length(FOpcionales)-1 do
    System.SysUtils.FreeAndNil(FOpcionales[I]);
  System.SetLength(FOpcionales, 0);
  for I := 0 to System.Length(FCompradores)-1 do
    System.SysUtils.FreeAndNil(FCompradores[I]);
  System.SetLength(FCompradores, 0);
  inherited Destroy;
end;
 
procedure FEDetRequest.SetCbteFch(Index: Integer; const Astring: string);
begin
  FCbteFch := Astring;
  FCbteFch_Specified := True;
end;
 
function FEDetRequest.CbteFch_Specified(Index: Integer): boolean;
begin
  Result := FCbteFch_Specified;
end;
 
procedure FEDetRequest.SetFchServDesde(Index: Integer; const Astring: string);
begin
  FFchServDesde := Astring;
  FFchServDesde_Specified := True;
end;
 
function FEDetRequest.FchServDesde_Specified(Index: Integer): boolean;
begin
  Result := FFchServDesde_Specified;
end;
 
procedure FEDetRequest.SetFchServHasta(Index: Integer; const Astring: string);
begin
  FFchServHasta := Astring;
  FFchServHasta_Specified := True;
end;
 
function FEDetRequest.FchServHasta_Specified(Index: Integer): boolean;
begin
  Result := FFchServHasta_Specified;
end;
 
procedure FEDetRequest.SetFchVtoPago(Index: Integer; const Astring: string);
begin
  FFchVtoPago := Astring;
  FFchVtoPago_Specified := True;
end;
 
function FEDetRequest.FchVtoPago_Specified(Index: Integer): boolean;
begin
  Result := FFchVtoPago_Specified;
end;
 
procedure FEDetRequest.SetMonId(Index: Integer; const Astring: string);
begin
  FMonId := Astring;
  FMonId_Specified := True;
end;
 
function FEDetRequest.MonId_Specified(Index: Integer): boolean;
begin
  Result := FMonId_Specified;
end;
 
procedure FEDetRequest.SetCbtesAsoc(Index: Integer; const AArrayOfCbteAsoc: ArrayOfCbteAsoc);
begin
  FCbtesAsoc := AArrayOfCbteAsoc;
  FCbtesAsoc_Specified := True;
end;
 
function FEDetRequest.CbtesAsoc_Specified(Index: Integer): boolean;
begin
  Result := FCbtesAsoc_Specified;
end;
 
procedure FEDetRequest.SetTributos(Index: Integer; const AArrayOfTributo: ArrayOfTributo);
begin
  FTributos := AArrayOfTributo;
  FTributos_Specified := True;
end;
 
function FEDetRequest.Tributos_Specified(Index: Integer): boolean;
begin
  Result := FTributos_Specified;
end;
 
procedure FEDetRequest.SetIva(Index: Integer; const AArrayOfAlicIva: ArrayOfAlicIva);
begin
  FIva := AArrayOfAlicIva;
  FIva_Specified := True;
end;
 
function FEDetRequest.Iva_Specified(Index: Integer): boolean;
begin
  Result := FIva_Specified;
end;
 
procedure FEDetRequest.SetOpcionales(Index: Integer; const AArrayOfOpcional: ArrayOfOpcional);
begin
  FOpcionales := AArrayOfOpcional;
  FOpcionales_Specified := True;
end;
 
function FEDetRequest.Opcionales_Specified(Index: Integer): boolean;
begin
  Result := FOpcionales_Specified;
end;
 
procedure FEDetRequest.SetCompradores(Index: Integer; const AArrayOfComprador: ArrayOfComprador);
begin
  FCompradores := AArrayOfComprador;
  FCompradores_Specified := True;
end;
 
function FEDetRequest.Compradores_Specified(Index: Integer): boolean;
begin
  Result := FCompradores_Specified;
end;
 
procedure Tributo.SetDesc(Index: Integer; const Astring: string);
begin
  FDesc := Astring;
  FDesc_Specified := True;
end;
 
function Tributo.Desc_Specified(Index: Integer): boolean;
begin
  Result := FDesc_Specified;
end;
 
destructor FEDetResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FObservaciones)-1 do
    System.SysUtils.FreeAndNil(FObservaciones[I]);
  System.SetLength(FObservaciones, 0);
  inherited Destroy;
end;
 
procedure FEDetResponse.SetCbteFch(Index: Integer; const Astring: string);
begin
  FCbteFch := Astring;
  FCbteFch_Specified := True;
end;
 
function FEDetResponse.CbteFch_Specified(Index: Integer): boolean;
begin
  Result := FCbteFch_Specified;
end;
 
procedure FEDetResponse.SetResultado(Index: Integer; const Astring: string);
begin
  FResultado := Astring;
  FResultado_Specified := True;
end;
 
function FEDetResponse.Resultado_Specified(Index: Integer): boolean;
begin
  Result := FResultado_Specified;
end;
 
procedure FEDetResponse.SetObservaciones(Index: Integer; const AArrayOfObs: ArrayOfObs);
begin
  FObservaciones := AArrayOfObs;
  FObservaciones_Specified := True;
end;
 
function FEDetResponse.Observaciones_Specified(Index: Integer): boolean;
begin
  Result := FObservaciones_Specified;
end;
 
procedure FECAEDetResponse.SetCAE(Index: Integer; const Astring: string);
begin
  FCAE := Astring;
  FCAE_Specified := True;
end;
 
function FECAEDetResponse.CAE_Specified(Index: Integer): boolean;
begin
  Result := FCAE_Specified;
end;
 
procedure FECAEDetResponse.SetCAEFchVto(Index: Integer; const Astring: string);
begin
  FCAEFchVto := Astring;
  FCAEFchVto_Specified := True;
end;
 
function FECAEDetResponse.CAEFchVto_Specified(Index: Integer): boolean;
begin
  Result := FCAEFchVto_Specified;
end;
 
destructor FECAEASinMovConsResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure FECAEASinMovConsResponse.SetResultGet(Index: Integer; const AArrayOfFECAEASinMov: ArrayOfFECAEASinMov);
begin
  FResultGet := AArrayOfFECAEASinMov;
  FResultGet_Specified := True;
end;
 
function FECAEASinMovConsResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure FECAEASinMovConsResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FECAEASinMovConsResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FECAEASinMovConsResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FECAEASinMovConsResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
procedure FECAEASinMov.SetCAEA(Index: Integer; const Astring: string);
begin
  FCAEA := Astring;
  FCAEA_Specified := True;
end;
 
function FECAEASinMov.CAEA_Specified(Index: Integer): boolean;
begin
  Result := FCAEA_Specified;
end;
 
procedure FECAEASinMov.SetFchProceso(Index: Integer; const Astring: string);
begin
  FFchProceso := Astring;
  FFchProceso_Specified := True;
end;
 
function FECAEASinMov.FchProceso_Specified(Index: Integer): boolean;
begin
  Result := FFchProceso_Specified;
end;
 
destructor FECAEAGet.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FObservaciones)-1 do
    System.SysUtils.FreeAndNil(FObservaciones[I]);
  System.SetLength(FObservaciones, 0);
  inherited Destroy;
end;
 
procedure FECAEAGet.SetCAEA(Index: Integer; const Astring: string);
begin
  FCAEA := Astring;
  FCAEA_Specified := True;
end;
 
function FECAEAGet.CAEA_Specified(Index: Integer): boolean;
begin
  Result := FCAEA_Specified;
end;
 
procedure FECAEAGet.SetFchVigDesde(Index: Integer; const Astring: string);
begin
  FFchVigDesde := Astring;
  FFchVigDesde_Specified := True;
end;
 
function FECAEAGet.FchVigDesde_Specified(Index: Integer): boolean;
begin
  Result := FFchVigDesde_Specified;
end;
 
procedure FECAEAGet.SetFchVigHasta(Index: Integer; const Astring: string);
begin
  FFchVigHasta := Astring;
  FFchVigHasta_Specified := True;
end;
 
function FECAEAGet.FchVigHasta_Specified(Index: Integer): boolean;
begin
  Result := FFchVigHasta_Specified;
end;
 
procedure FECAEAGet.SetFchTopeInf(Index: Integer; const Astring: string);
begin
  FFchTopeInf := Astring;
  FFchTopeInf_Specified := True;
end;
 
function FECAEAGet.FchTopeInf_Specified(Index: Integer): boolean;
begin
  Result := FFchTopeInf_Specified;
end;
 
procedure FECAEAGet.SetFchProceso(Index: Integer; const Astring: string);
begin
  FFchProceso := Astring;
  FFchProceso_Specified := True;
end;
 
function FECAEAGet.FchProceso_Specified(Index: Integer): boolean;
begin
  Result := FFchProceso_Specified;
end;
 
procedure FECAEAGet.SetObservaciones(Index: Integer; const AArrayOfObs: ArrayOfObs);
begin
  FObservaciones := AArrayOfObs;
  FObservaciones_Specified := True;
end;
 
function FECAEAGet.Observaciones_Specified(Index: Integer): boolean;
begin
  Result := FObservaciones_Specified;
end;
 
procedure FECAEADetResponse.SetCAEA(Index: Integer; const Astring: string);
begin
  FCAEA := Astring;
  FCAEA_Specified := True;
end;
 
function FECAEADetResponse.CAEA_Specified(Index: Integer): boolean;
begin
  Result := FCAEA_Specified;
end;
 
destructor FECAEAGetResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  System.SysUtils.FreeAndNil(FResultGet);
  inherited Destroy;
end;
 
procedure FECAEAGetResponse.SetResultGet(Index: Integer; const AFECAEAGet: FECAEAGet);
begin
  FResultGet := AFECAEAGet;
  FResultGet_Specified := True;
end;
 
function FECAEAGetResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure FECAEAGetResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FECAEAGetResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FECAEAGetResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FECAEAGetResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor FECAEASinMovResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure FECAEASinMovResponse.SetResultado(Index: Integer; const Astring: string);
begin
  FResultado := Astring;
  FResultado_Specified := True;
end;
 
function FECAEASinMovResponse.Resultado_Specified(Index: Integer): boolean;
begin
  Result := FResultado_Specified;
end;
 
procedure FECAEASinMovResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FECAEASinMovResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FECAEASinMovResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FECAEASinMovResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
procedure TributoTipo.SetDesc(Index: Integer; const Astring: string);
begin
  FDesc := Astring;
  FDesc_Specified := True;
end;
 
function TributoTipo.Desc_Specified(Index: Integer): boolean;
begin
  Result := FDesc_Specified;
end;
 
procedure TributoTipo.SetFchDesde(Index: Integer; const Astring: string);
begin
  FFchDesde := Astring;
  FFchDesde_Specified := True;
end;
 
function TributoTipo.FchDesde_Specified(Index: Integer): boolean;
begin
  Result := FFchDesde_Specified;
end;
 
procedure TributoTipo.SetFchHasta(Index: Integer; const Astring: string);
begin
  FFchHasta := Astring;
  FFchHasta_Specified := True;
end;
 
function TributoTipo.FchHasta_Specified(Index: Integer): boolean;
begin
  Result := FFchHasta_Specified;
end;
 
destructor MonedaResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure MonedaResponse.SetResultGet(Index: Integer; const AArrayOfMoneda: ArrayOfMoneda);
begin
  FResultGet := AArrayOfMoneda;
  FResultGet_Specified := True;
end;
 
function MonedaResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure MonedaResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function MonedaResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure MonedaResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function MonedaResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor FECotizacionResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  System.SysUtils.FreeAndNil(FResultGet);
  inherited Destroy;
end;
 
procedure FECotizacionResponse.SetResultGet(Index: Integer; const ACotizacion: Cotizacion);
begin
  FResultGet := ACotizacion;
  FResultGet_Specified := True;
end;
 
function FECotizacionResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure FECotizacionResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FECotizacionResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FECotizacionResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FECotizacionResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
procedure Cotizacion.SetMonId(Index: Integer; const Astring: string);
begin
  FMonId := Astring;
  FMonId_Specified := True;
end;
 
function Cotizacion.MonId_Specified(Index: Integer): boolean;
begin
  Result := FMonId_Specified;
end;
 
procedure Cotizacion.SetFchCotiz(Index: Integer; const Astring: string);
begin
  FFchCotiz := Astring;
  FFchCotiz_Specified := True;
end;
 
function Cotizacion.FchCotiz_Specified(Index: Integer): boolean;
begin
  Result := FFchCotiz_Specified;
end;
 
destructor FETributoResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FResultGet)-1 do
    System.SysUtils.FreeAndNil(FResultGet[I]);
  System.SetLength(FResultGet, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure FETributoResponse.SetResultGet(Index: Integer; const AArrayOfTributoTipo: ArrayOfTributoTipo);
begin
  FResultGet := AArrayOfTributoTipo;
  FResultGet_Specified := True;
end;
 
function FETributoResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure FETributoResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FETributoResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FETributoResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FETributoResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
procedure DummyResponse.SetAppServer(Index: Integer; const Astring: string);
begin
  FAppServer := Astring;
  FAppServer_Specified := True;
end;
 
function DummyResponse.AppServer_Specified(Index: Integer): boolean;
begin
  Result := FAppServer_Specified;
end;
 
procedure DummyResponse.SetDbServer(Index: Integer; const Astring: string);
begin
  FDbServer := Astring;
  FDbServer_Specified := True;
end;
 
function DummyResponse.DbServer_Specified(Index: Integer): boolean;
begin
  Result := FDbServer_Specified;
end;
 
procedure DummyResponse.SetAuthServer(Index: Integer; const Astring: string);
begin
  FAuthServer := Astring;
  FAuthServer_Specified := True;
end;
 
function DummyResponse.AuthServer_Specified(Index: Integer): boolean;
begin
  Result := FAuthServer_Specified;
end;
 
destructor FERecuperaLastCbteResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure FERecuperaLastCbteResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FERecuperaLastCbteResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FERecuperaLastCbteResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FERecuperaLastCbteResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
destructor FERegXReqResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  inherited Destroy;
end;
 
procedure FERegXReqResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FERegXReqResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FERegXReqResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FERegXReqResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
procedure Obs.SetMsg(Index: Integer; const Astring: string);
begin
  FMsg := Astring;
  FMsg_Specified := True;
end;
 
function Obs.Msg_Specified(Index: Integer): boolean;
begin
  Result := FMsg_Specified;
end;
 
procedure Evt.SetMsg(Index: Integer; const Astring: string);
begin
  FMsg := Astring;
  FMsg_Specified := True;
end;
 
function Evt.Msg_Specified(Index: Integer): boolean;
begin
  Result := FMsg_Specified;
end;
 
procedure Err.SetMsg(Index: Integer; const Astring: string);
begin
  FMsg := Astring;
  FMsg_Specified := True;
end;
 
function Err.Msg_Specified(Index: Integer): boolean;
begin
  Result := FMsg_Specified;
end;
 
destructor FECompConsultaResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  System.SysUtils.FreeAndNil(FResultGet);
  inherited Destroy;
end;
 
procedure FECompConsultaResponse.SetResultGet(Index: Integer; const AFECompConsResponse: FECompConsResponse);
begin
  FResultGet := AFECompConsResponse;
  FResultGet_Specified := True;
end;
 
function FECompConsultaResponse.ResultGet_Specified(Index: Integer): boolean;
begin
  Result := FResultGet_Specified;
end;
 
procedure FECompConsultaResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FECompConsultaResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
procedure FECompConsultaResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FECompConsultaResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
procedure FECAEADetRequest.SetCAEA(Index: Integer; const Astring: string);
begin
  FCAEA := Astring;
  FCAEA_Specified := True;
end;
 
function FECAEADetRequest.CAEA_Specified(Index: Integer): boolean;
begin
  Result := FCAEA_Specified;
end;
 
procedure FECAEADetRequest.SetCbteFchHsGen(Index: Integer; const Astring: string);
begin
  FCbteFchHsGen := Astring;
  FCbteFchHsGen_Specified := True;
end;
 
function FECAEADetRequest.CbteFchHsGen_Specified(Index: Integer): boolean;
begin
  Result := FCbteFchHsGen_Specified;
end;
 
destructor FECAEAResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FFeDetResp)-1 do
    System.SysUtils.FreeAndNil(FFeDetResp[I]);
  System.SetLength(FFeDetResp, 0);
  for I := 0 to System.Length(FEvents)-1 do
    System.SysUtils.FreeAndNil(FEvents[I]);
  System.SetLength(FEvents, 0);
  for I := 0 to System.Length(FErrors)-1 do
    System.SysUtils.FreeAndNil(FErrors[I]);
  System.SetLength(FErrors, 0);
  System.SysUtils.FreeAndNil(FFeCabResp);
  inherited Destroy;
end;
 
procedure FECAEAResponse.SetFeCabResp(Index: Integer; const AFECAEACabResponse: FECAEACabResponse);
begin
  FFeCabResp := AFECAEACabResponse;
  FFeCabResp_Specified := True;
end;
 
function FECAEAResponse.FeCabResp_Specified(Index: Integer): boolean;
begin
  Result := FFeCabResp_Specified;
end;
 
procedure FECAEAResponse.SetFeDetResp(Index: Integer; const AArrayOfFECAEADetResponse: ArrayOfFECAEADetResponse);
begin
  FFeDetResp := AArrayOfFECAEADetResponse;
  FFeDetResp_Specified := True;
end;
 
function FECAEAResponse.FeDetResp_Specified(Index: Integer): boolean;
begin
  Result := FFeDetResp_Specified;
end;
 
procedure FECAEAResponse.SetEvents(Index: Integer; const AArrayOfEvt: ArrayOfEvt);
begin
  FEvents := AArrayOfEvt;
  FEvents_Specified := True;
end;
 
function FECAEAResponse.Events_Specified(Index: Integer): boolean;
begin
  Result := FEvents_Specified;
end;
 
procedure FECAEAResponse.SetErrors(Index: Integer; const AArrayOfErr: ArrayOfErr);
begin
  FErrors := AArrayOfErr;
  FErrors_Specified := True;
end;
 
function FECAEAResponse.Errors_Specified(Index: Integer): boolean;
begin
  Result := FErrors_Specified;
end;
 
destructor FECompConsResponse.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FObservaciones)-1 do
    System.SysUtils.FreeAndNil(FObservaciones[I]);
  System.SetLength(FObservaciones, 0);
  inherited Destroy;
end;
 
procedure FECompConsResponse.SetResultado(Index: Integer; const Astring: string);
begin
  FResultado := Astring;
  FResultado_Specified := True;
end;
 
function FECompConsResponse.Resultado_Specified(Index: Integer): boolean;
begin
  Result := FResultado_Specified;
end;
 
procedure FECompConsResponse.SetCodAutorizacion(Index: Integer; const Astring: string);
begin
  FCodAutorizacion := Astring;
  FCodAutorizacion_Specified := True;
end;
 
function FECompConsResponse.CodAutorizacion_Specified(Index: Integer): boolean;
begin
  Result := FCodAutorizacion_Specified;
end;
 
procedure FECompConsResponse.SetEmisionTipo(Index: Integer; const Astring: string);
begin
  FEmisionTipo := Astring;
  FEmisionTipo_Specified := True;
end;
 
function FECompConsResponse.EmisionTipo_Specified(Index: Integer): boolean;
begin
  Result := FEmisionTipo_Specified;
end;
 
procedure FECompConsResponse.SetFchVto(Index: Integer; const Astring: string);
begin
  FFchVto := Astring;
  FFchVto_Specified := True;
end;
 
function FECompConsResponse.FchVto_Specified(Index: Integer): boolean;
begin
  Result := FFchVto_Specified;
end;
 
procedure FECompConsResponse.SetFchProceso(Index: Integer; const Astring: string);
begin
  FFchProceso := Astring;
  FFchProceso_Specified := True;
end;
 
function FECompConsResponse.FchProceso_Specified(Index: Integer): boolean;
begin
  Result := FFchProceso_Specified;
end;
 
procedure FECompConsResponse.SetObservaciones(Index: Integer; const AArrayOfObs: ArrayOfObs);
begin
  FObservaciones := AArrayOfObs;
  FObservaciones_Specified := True;
end;
 
function FECompConsResponse.Observaciones_Specified(Index: Integer): boolean;
begin
  Result := FObservaciones_Specified;
end;
 
destructor FECAEARequest.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FFeDetReq)-1 do
    System.SysUtils.FreeAndNil(FFeDetReq[I]);
  System.SetLength(FFeDetReq, 0);
  System.SysUtils.FreeAndNil(FFeCabReq);
  inherited Destroy;
end;
 
procedure FECAEARequest.SetFeCabReq(Index: Integer; const AFECAEACabRequest: FECAEACabRequest);
begin
  FFeCabReq := AFECAEACabRequest;
  FFeCabReq_Specified := True;
end;
 
function FECAEARequest.FeCabReq_Specified(Index: Integer): boolean;
begin
  Result := FFeCabReq_Specified;
end;
 
procedure FECAEARequest.SetFeDetReq(Index: Integer; const AArrayOfFECAEADetRequest: ArrayOfFECAEADetRequest);
begin
  FFeDetReq := AArrayOfFECAEADetRequest;
  FFeDetReq_Specified := True;
end;
 
function FECAEARequest.FeDetReq_Specified(Index: Integer): boolean;
begin
  Result := FFeDetReq_Specified;
end;
 
initialization
  { ServiceSoap }
  InvRegistry.RegisterInterface(TypeInfo(ServiceSoap), 'http://ar.gov.afip.dif.FEV1/', 'utf-8');
  InvRegistry.RegisterDefaultSOAPAction(TypeInfo(ServiceSoap), 'http://ar.gov.afip.dif.FEV1/%operationName%');
  InvRegistry.RegisterInvokeOptions(TypeInfo(ServiceSoap), ioDocument);
  { ServiceSoap.FECAESolicitar }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FECAESolicitar', '',
                                 '[ReturnName="FECAESolicitarResult"]', IS_OPTN);
  { ServiceSoap.FECompTotXRequest }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FECompTotXRequest', '',
                                 '[ReturnName="FECompTotXRequestResult"]', IS_OPTN);
  { ServiceSoap.FEDummy }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEDummy', '',
                                 '[ReturnName="FEDummyResult"]', IS_OPTN);
  { ServiceSoap.FECompUltimoAutorizado }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FECompUltimoAutorizado', '',
                                 '[ReturnName="FECompUltimoAutorizadoResult"]', IS_OPTN);
  { ServiceSoap.FECompConsultar }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FECompConsultar', '',
                                 '[ReturnName="FECompConsultarResult"]', IS_OPTN);
  { ServiceSoap.FECAEARegInformativo }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FECAEARegInformativo', '',
                                 '[ReturnName="FECAEARegInformativoResult"]', IS_OPTN);
  { ServiceSoap.FECAEASolicitar }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FECAEASolicitar', '',
                                 '[ReturnName="FECAEASolicitarResult"]', IS_OPTN);
  { ServiceSoap.FECAEASinMovimientoConsultar }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FECAEASinMovimientoConsultar', '',
                                 '[ReturnName="FECAEASinMovimientoConsultarResult"]', IS_OPTN);
  { ServiceSoap.FECAEASinMovimientoInformar }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FECAEASinMovimientoInformar', '',
                                 '[ReturnName="FECAEASinMovimientoInformarResult"]', IS_OPTN);
  { ServiceSoap.FECAEAConsultar }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FECAEAConsultar', '',
                                 '[ReturnName="FECAEAConsultarResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetCotizacion }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetCotizacion', '',
                                 '[ReturnName="FEParamGetCotizacionResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetTiposTributos }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetTiposTributos', '',
                                 '[ReturnName="FEParamGetTiposTributosResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetTiposMonedas }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetTiposMonedas', '',
                                 '[ReturnName="FEParamGetTiposMonedasResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetTiposIva }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetTiposIva', '',
                                 '[ReturnName="FEParamGetTiposIvaResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetTiposOpcional }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetTiposOpcional', '',
                                 '[ReturnName="FEParamGetTiposOpcionalResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetTiposConcepto }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetTiposConcepto', '',
                                 '[ReturnName="FEParamGetTiposConceptoResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetPtosVenta }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetPtosVenta', '',
                                 '[ReturnName="FEParamGetPtosVentaResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetTiposCbte }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetTiposCbte', '',
                                 '[ReturnName="FEParamGetTiposCbteResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetTiposDoc }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetTiposDoc', '',
                                 '[ReturnName="FEParamGetTiposDocResult"]', IS_OPTN);
  { ServiceSoap.FEParamGetTiposPaises }
  InvRegistry.RegisterMethodInfo(TypeInfo(ServiceSoap), 'FEParamGetTiposPaises', '',
                                 '[ReturnName="FEParamGetTiposPaisesResult"]', IS_OPTN);
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfConceptoTipo), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfConceptoTipo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfIvaTipo), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfIvaTipo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfOpcionalTipo), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfOpcionalTipo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfPtoVenta), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfPtoVenta');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfDocTipo), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfDocTipo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfPaisTipo), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfPaisTipo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfCbteTipo), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfCbteTipo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfComprador), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfComprador');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfErr), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfErr');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfFECAEDetResponse), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfFECAEDetResponse');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfEvt), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfEvt');
  RemClassRegistry.RegisterXSClass(FECAEResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECAEResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEResponse), 'FeDetResp', '[ArrayItemName="FECAEDetResponse"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterXSClass(DocTipoResponse, 'http://ar.gov.afip.dif.FEV1/', 'DocTipoResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(DocTipoResponse), 'ResultGet', '[ArrayItemName="DocTipo"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(DocTipoResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(DocTipoResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(CbteTipoResponse, 'http://ar.gov.afip.dif.FEV1/', 'CbteTipoResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(CbteTipoResponse), 'ResultGet', '[ArrayItemName="CbteTipo"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(CbteTipoResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(CbteTipoResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(FEPaisResponse, 'http://ar.gov.afip.dif.FEV1/', 'FEPaisResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEPaisResponse), 'ResultGet', '[ArrayItemName="PaisTipo"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEPaisResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEPaisResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(OpcionalTipoResponse, 'http://ar.gov.afip.dif.FEV1/', 'OpcionalTipoResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(OpcionalTipoResponse), 'ResultGet', '[ArrayItemName="OpcionalTipo"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(OpcionalTipoResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(OpcionalTipoResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(IvaTipoResponse, 'http://ar.gov.afip.dif.FEV1/', 'IvaTipoResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(IvaTipoResponse), 'ResultGet', '[ArrayItemName="IvaTipo"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(IvaTipoResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(IvaTipoResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(FEPtoVentaResponse, 'http://ar.gov.afip.dif.FEV1/', 'FEPtoVentaResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEPtoVentaResponse), 'ResultGet', '[ArrayItemName="PtoVenta"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEPtoVentaResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEPtoVentaResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(ConceptoTipoResponse, 'http://ar.gov.afip.dif.FEV1/', 'ConceptoTipoResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ConceptoTipoResponse), 'ResultGet', '[ArrayItemName="ConceptoTipo"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ConceptoTipoResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ConceptoTipoResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfFECAEDetRequest), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfFECAEDetRequest');
  RemClassRegistry.RegisterXSClass(FECAERequest, 'http://ar.gov.afip.dif.FEV1/', 'FECAERequest');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAERequest), 'FeDetReq', '[ArrayItemName="FECAEDetRequest"]');
  RemClassRegistry.RegisterXSClass(Opcional, 'http://ar.gov.afip.dif.FEV1/', 'Opcional');
  RemClassRegistry.RegisterXSClass(Moneda, 'http://ar.gov.afip.dif.FEV1/', 'Moneda');
  RemClassRegistry.RegisterXSClass(PaisTipo, 'http://ar.gov.afip.dif.FEV1/', 'PaisTipo');
  RemClassRegistry.RegisterXSClass(IvaTipo, 'http://ar.gov.afip.dif.FEV1/', 'IvaTipo');
  RemClassRegistry.RegisterXSClass(OpcionalTipo, 'http://ar.gov.afip.dif.FEV1/', 'OpcionalTipo');
  RemClassRegistry.RegisterXSClass(FEAuthRequest, 'http://ar.gov.afip.dif.FEV1/', 'FEAuthRequest');
  RemClassRegistry.RegisterXSClass(FECabRequest, 'http://ar.gov.afip.dif.FEV1/', 'FECabRequest');
  RemClassRegistry.RegisterXSClass(FECAECabRequest, 'http://ar.gov.afip.dif.FEV1/', 'FECAECabRequest');
  RemClassRegistry.RegisterXSClass(FECabResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECabResponse');
  RemClassRegistry.RegisterXSClass(FECAECabResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECAECabResponse');
  RemClassRegistry.RegisterXSClass(CbteAsoc, 'http://ar.gov.afip.dif.FEV1/', 'CbteAsoc');
  RemClassRegistry.RegisterXSClass(CbteTipo, 'http://ar.gov.afip.dif.FEV1/', 'CbteTipo');
  RemClassRegistry.RegisterXSClass(PtoVenta, 'http://ar.gov.afip.dif.FEV1/', 'PtoVenta');
  RemClassRegistry.RegisterXSClass(DocTipo, 'http://ar.gov.afip.dif.FEV1/', 'DocTipo');
  RemClassRegistry.RegisterXSClass(ConceptoTipo, 'http://ar.gov.afip.dif.FEV1/', 'ConceptoTipo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfTributo), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfTributo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfAlicIva), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfAlicIva');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfOpcional), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfOpcional');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfCbteAsoc), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfCbteAsoc');
  RemClassRegistry.RegisterXSClass(FEDetRequest, 'http://ar.gov.afip.dif.FEV1/', 'FEDetRequest');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEDetRequest), 'CbtesAsoc', '[ArrayItemName="CbteAsoc"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEDetRequest), 'Tributos', '[ArrayItemName="Tributo"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEDetRequest), 'Iva', '[ArrayItemName="AlicIva"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEDetRequest), 'Opcionales', '[ArrayItemName="Opcional"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEDetRequest), 'Compradores', '[ArrayItemName="Comprador"]');
  RemClassRegistry.RegisterXSClass(FECAEDetRequest, 'http://ar.gov.afip.dif.FEV1/', 'FECAEDetRequest');
  RemClassRegistry.RegisterXSClass(Tributo, 'http://ar.gov.afip.dif.FEV1/', 'Tributo');
  RemClassRegistry.RegisterXSClass(Comprador, 'http://ar.gov.afip.dif.FEV1/', 'Comprador');
  RemClassRegistry.RegisterXSClass(AlicIva, 'http://ar.gov.afip.dif.FEV1/', 'AlicIva');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfObs), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfObs');
  RemClassRegistry.RegisterXSClass(FEDetResponse, 'http://ar.gov.afip.dif.FEV1/', 'FEDetResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FEDetResponse), 'Observaciones', '[ArrayItemName="Obs"]');
  RemClassRegistry.RegisterXSClass(FECAEDetResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECAEDetResponse');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfFECAEASinMov), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfFECAEASinMov');
  RemClassRegistry.RegisterXSClass(FECAEASinMovConsResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECAEASinMovConsResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEASinMovConsResponse), 'ResultGet', '[ArrayItemName="FECAEASinMov"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEASinMovConsResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEASinMovConsResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(FECAEASinMov, 'http://ar.gov.afip.dif.FEV1/', 'FECAEASinMov');
  RemClassRegistry.RegisterXSClass(FECAEAGet, 'http://ar.gov.afip.dif.FEV1/', 'FECAEAGet');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEAGet), 'Observaciones', '[ArrayItemName="Obs"]');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfFECAEADetResponse), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfFECAEADetResponse');
  RemClassRegistry.RegisterXSClass(FECAEADetResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECAEADetResponse');
  RemClassRegistry.RegisterXSClass(FECAEAGetResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECAEAGetResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEAGetResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEAGetResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(FECAEASinMovResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECAEASinMovResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEASinMovResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEASinMovResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(TributoTipo, 'http://ar.gov.afip.dif.FEV1/', 'TributoTipo');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfMoneda), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfMoneda');
  RemClassRegistry.RegisterXSClass(MonedaResponse, 'http://ar.gov.afip.dif.FEV1/', 'MonedaResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(MonedaResponse), 'ResultGet', '[ArrayItemName="Moneda"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(MonedaResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(MonedaResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfTributoTipo), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfTributoTipo');
  RemClassRegistry.RegisterXSClass(FECotizacionResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECotizacionResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECotizacionResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECotizacionResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(Cotizacion, 'http://ar.gov.afip.dif.FEV1/', 'Cotizacion');
  RemClassRegistry.RegisterXSClass(FETributoResponse, 'http://ar.gov.afip.dif.FEV1/', 'FETributoResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FETributoResponse), 'ResultGet', '[ArrayItemName="TributoTipo"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FETributoResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FETributoResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(DummyResponse, 'http://ar.gov.afip.dif.FEV1/', 'DummyResponse');
  RemClassRegistry.RegisterXSClass(FERecuperaLastCbteResponse, 'http://ar.gov.afip.dif.FEV1/', 'FERecuperaLastCbteResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FERecuperaLastCbteResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FERecuperaLastCbteResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(FECompConsultaReq, 'http://ar.gov.afip.dif.FEV1/', 'FECompConsultaReq');
  RemClassRegistry.RegisterXSClass(FERegXReqResponse, 'http://ar.gov.afip.dif.FEV1/', 'FERegXReqResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FERegXReqResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FERegXReqResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(Obs, 'http://ar.gov.afip.dif.FEV1/', 'Obs');
  RemClassRegistry.RegisterXSClass(Evt, 'http://ar.gov.afip.dif.FEV1/', 'Evt');
  RemClassRegistry.RegisterXSClass(Err, 'http://ar.gov.afip.dif.FEV1/', 'Err');
  RemClassRegistry.RegisterXSClass(FECompConsultaResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECompConsultaResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECompConsultaResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECompConsultaResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterXSClass(FECAEADetRequest, 'http://ar.gov.afip.dif.FEV1/', 'FECAEADetRequest');
  RemClassRegistry.RegisterXSClass(FECAEAResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECAEAResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEAResponse), 'FeDetResp', '[ArrayItemName="FECAEADetResponse"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEAResponse), 'Events', '[ArrayItemName="Evt"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEAResponse), 'Errors', '[ArrayItemName="Err"]');
  RemClassRegistry.RegisterXSClass(FECAEACabResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECAEACabResponse');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfFECAEADetRequest), 'http://ar.gov.afip.dif.FEV1/', 'ArrayOfFECAEADetRequest');
  RemClassRegistry.RegisterXSClass(FECompConsResponse, 'http://ar.gov.afip.dif.FEV1/', 'FECompConsResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECompConsResponse), 'Observaciones', '[ArrayItemName="Obs"]');
  RemClassRegistry.RegisterXSClass(FECAEARequest, 'http://ar.gov.afip.dif.FEV1/', 'FECAEARequest');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(FECAEARequest), 'FeDetReq', '[ArrayItemName="FECAEADetRequest"]');
  RemClassRegistry.RegisterXSClass(FECAEACabRequest, 'http://ar.gov.afip.dif.FEV1/', 'FECAEACabRequest');
 
end.

Pero al hacer lo siguiente:

delphi

procedure TComprobante.envio(factura: IXMLDocument);
var
RIOFactura:THTTPRIO;
XMLRESPUESTA:IXMLDocument;
content,expira,nodo:string;
nodohijo,nodohijosign,startnode,startnodesign:IXMLNode;
begin
 
  RIOFactura:=THTTPRIO.Create(nil);
  with RIOFactura do
    begin
      WSDLLocation:='https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL';
      Port:='Service';
      Service:='ServiceSoap';
 
    end;
 
 
   XMLRESPUESTA:=NewXMLDocument;
   content:=(RIOFactura as serviceSoap).FECAESolicitar(factura);
   XMLRESPUESTA.XML.Text:=content;
   XMLRESPUESTA.Active:=True;
   XMLRESPUESTA.SaveToFile(ExtractFilePath(Application.ExeName) + 'respuestafcxml.xml');
 
 
 
end;

envio es un metodo que toma el xml como veran y quise enviarselo a FECAESolicitar y obviamente no coinciden los tipos.

Por lo que parece no debo armar un xml?? Debo crear todas las clases TRemotable? o hay otra manera de usar el componente HTTPRio para llamar al metodo?

[giulichajari]

Hola amigos, para desarrollar factura electronica de AFIP, segun las especificaciones hay que mandar un archivo xml con los datos de la factura al webservice de AFIP.

Generara el xml ya lo he logrado, utilizando el data binding y el xsd.

El caso es que importe el servicio de homologacion con WSDL Importer:

delphi

// ************************************************************************ //
// The types declared in this file were generated from data read from the
// WSDL File described below:
// WSDL     : https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL
//  >Import : https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL>0
// Encoding : utf-8
// Version  : 1.0
// (01/04/2020 19:48:54 - - $Rev: 93209 $)
// ************************************************************************ //
 
 
  ServiceSoap = interface(IInvokable)
  ['{05274D74-5C3D-E536-980E-D9CE5D67F5D9}']
    function  FECAESolicitar(const Auth: FEAuthRequest; const FeCAEReq: FECAERequest): FECAEResponse; stdcall;
    function  FECompTotXRequest(const Auth: FEAuthRequest): FERegXReqResponse; stdcall;
    function  FEDummy: DummyResponse; stdcall;
    function  FECompUltimoAutorizado(const Auth: FEAuthRequest; const PtoVta: Integer; const CbteTipo: Integer): FERecuperaLastCbteResponse; stdcall;
    function  FECompConsultar(const Auth: FEAuthRequest; const FeCompConsReq: FECompConsultaReq): FECompConsultaResponse; stdcall;
    function  FECAEARegInformativo(const Auth: FEAuthRequest; const FeCAEARegInfReq: FECAEARequest): FECAEAResponse; stdcall;
    function  FECAEASolicitar(const Auth: FEAuthRequest; const Periodo: Integer; const Orden: SmallInt): FECAEAGetResponse; stdcall;
    function  FECAEASinMovimientoConsultar(const Auth: FEAuthRequest; const CAEA: string; const PtoVta: Integer): FECAEASinMovConsResponse; stdcall;
    function  FECAEASinMovimientoInformar(const Auth: FEAuthRequest; const PtoVta: Integer; const CAEA: string): FECAEASinMovResponse; stdcall;
    function  FECAEAConsultar(const Auth: FEAuthRequest; const Periodo: Integer; const Orden: SmallInt): FECAEAGetResponse; stdcall;
    function  FEParamGetCotizacion(const Auth: FEAuthRequest; const MonId: string): FECotizacionResponse; stdcall;
    function  FEParamGetTiposTributos(const Auth: FEAuthRequest): FETributoResponse; stdcall;
    function  FEParamGetTiposMonedas(const Auth: FEAuthRequest): MonedaResponse; stdcall;
    function  FEParamGetTiposIva(const Auth: FEAuthRequest): IvaTipoResponse; stdcall;
    function  FEParamGetTiposOpcional(const Auth: FEAuthRequest): OpcionalTipoResponse; stdcall;
    function  FEParamGetTiposConcepto(const Auth: FEAuthRequest): ConceptoTipoResponse; stdcall;
    function  FEParamGetPtosVenta(const Auth: FEAuthRequest): FEPtoVentaResponse; stdcall;
    function  FEParamGetTiposCbte(const Auth: FEAuthRequest): CbteTipoResponse; stdcall;
    function  FEParamGetTiposDoc(const Auth: FEAuthRequest): DocTipoResponse; stdcall;
    function  FEParamGetTiposPaises(const Auth: FEAuthRequest): FEPaisResponse; stdcall;
  end;

Pero al hacer lo siguiente:

delphi

procedure TComprobante.envio(factura: IXMLDocument);
var
RIOFactura:THTTPRIO;
XMLRESPUESTA:IXMLDocument;
content,expira,nodo:string;
nodohijo,nodohijosign,startnode,startnodesign:IXMLNode;
begin
 
  RIOFactura:=THTTPRIO.Create(nil);
  with RIOFactura do
    begin
      WSDLLocation:='https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL';
      Port:='Service';
      Service:='ServiceSoap';
 
    end;
 
 
   XMLRESPUESTA:=NewXMLDocument;
   content:=(RIOFactura as serviceSoap).FECAESolicitar(factura);
   XMLRESPUESTA.XML.Text:=content;
   XMLRESPUESTA.Active:=True;
   XMLRESPUESTA.SaveToFile(ExtractFilePath(Application.ExeName) + 'respuestafcxml.xml');
 
 
 
end;

envio es un metodo que toma el xml como veran y quise enviarselo a FECAESolicitar y obviamente no coinciden los tipos.

Por lo que parece no debo armar un xml?? Debo crear todas las clases TRemotable? o hay otra manera de usar el componente HTTPRio para llamar al metodo?

[egostar]

Hola amigos, para desarrollar factura electronica de AFIP, segun las especificaciones hay que mandar un archivo xml con los datos de la factura al webservice de AFIP.

Generara el xml ya lo he logrado, utilizando el data binding y el xsd.

El caso es que importe el servicio de homologacion con WSDL Importer:

delphi

....

envio es un metodo que toma el xml como veran y quise enviarselo a FECAESolicitar y obviamente no coinciden los tipos.

Por lo que parece no debo armar un xml?? Debo crear todas las clases TRemotable? o hay otra manera de usar el componente HTTPRio para llamar al metodo?

 

Hola giulichajari

 

Lo que tienes que hacer es descargar el WSDL y todos los XSD del servicio web a un directorio de tu computadora y ajustar todas las rutas en los xml descargados y después realizar la importación del WSDL.

 

Con eso asegurarás que tienes acceso a las definiciones de los tipos de datos requeridos.

 

Saludos

 

PD: Espero que todos estén bien así como sus familiares y amigos.

[giulichajari]

Hola giulichajari

 

Lo que tienes que hacer es descargar el WSDL y todos los XSD del servicio web a un directorio de tu computadora y ajustar todas las rutas en los xml descargados y después realizar la importación del WSDL.

 

Con eso asegurarás que tienes acceso a las definiciones de los tipos de datos requeridos.

 

Saludos

 

PD: Espero que todos estén bien así como sus familiares y amigos.

Gracias ego por estar ahi..Estamos mas que bien..Te comento que modifique el metodo envio haciendo uso de la creacion de clases y no obtengo ningun error pero no puedo obtener el cae,pero ya es un avance.(nose porque no registra la factura).

delphi

procedure TComprobante.envio();
var
RIOFactura:THTTPRIO;
CUITEmisor:string;
      hoy:TDate;
request:FEAuthRequest;
archivoini:TIniFile;
cae:FECAERequest;
content:FECAEResponse;
FeDetResp:FECAEDetResponse;
cabecera:FECAECabRequest;
detalle:FECAEDetRequest;
movimiento:ArrayOfFECAEDetRequest;
error:ArrayOfErr;
RioComp:THTTPRIO;
responseUltCte:FERecuperaLastCbteResponse;
resp:ArrayOfFECAEDetRequest;
begin
 
     hoy:=StrToDate(FormatDateTime('yy/mm/dd',now));
    archivoini:=TIniFile.Create(ExtractFilePath(Application.ExeName) + 'caja.ini');
    CUITEmisor:= archivoini.ReadString('AFIP','CUIT','');
    //creamos objeto request
   request:=FEAuthRequest.Create;
   request.Token:=self.token;
   request.sign:=self.sign;
   request.Cuit:= StrToInt64(CUITEmisor);
 
   //obtenemos ultimo comprobante asociado.
    RioComp:=THTTPRIO.Create(nil);
  with RIOComp do
    begin
      WSDLLocation:='https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL';
      Port:='ServiceSoap';
      Service:='Service';
 
    end;
    //objeto de respuesta
    responseUltCte:=FERecuperaLastCbteResponse.Create;
    //invocamos el metodo
   responseUltCte:=(RioComp as serviceSoap).FECompUltimoAutorizado(request,1,011);
    error:=responseUltCte.Errors;
 
   if error<>nil then
       begin
         ShowMessage(error[0].Msg);
       end;
   //creamos cabecera del comprobante
   cabecera:=FECAECabRequest.Create;
   cabecera.CantReg:=DataModule1.cdsticket.RecordCount;
   cabecera.PtoVta:=1;
   cabecera.CbteTipo:=011;
   //creamos el detalle
   detalle:=FECAEDetRequest.Create;
   detalle.Concepto:=1;
   detalle.DocTipo:=80;
   detalle.DocNro:=27204172418;
   detalle.CbteDesde:=responseUltCte.CbteNro + 1;
 
   detalle.CbteHasta:=responseUltCte.CbteNro + 1;
   detalle.CbteFch:=FormatDateTime('yyyymmdd',now);
   detalle.ImpTotal:=DataModule1.cdstickettotal.AsVariant;
   ShowMessage(FloatToStr(detalle.ImpTotal));
   detalle.ImpTotConc:=0;
   detalle.ImpNeto:=DataModule1.cdstickettotal.AsVariant;
   detalle.ImpOpEx:=0;
   detalle.ImpTrib:=0;
   detalle.ImpIVA:=0;
   detalle.FchVtoPago:=DateToStr(hoy);
   detalle.MonId:='PES';
   detalle.MonCotiz:=0;
   //movieminto
  SetLength(movimiento,1);
   movimiento[0]:=detalle;
   //creamos el objeto request
   cae:=FECAERequest.Create;
 
   //asignamos la cabecera
   cae.FeCabReq:=cabecera;
   cae.FeDetReq:=movimiento;
   content:=FECAEResponse.Create;
   //creamos objeto rio
  RIOFactura:=THTTPRIO.Create(nil);
  with RIOFactura do
    begin
      WSDLLocation:='https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL';
      Port:='ServiceSoap';
      Service:='Service';
 
    end;
    //invocamos el metodo
   content:=(RIOFactura as serviceSoap).FECAESolicitar(request,cae);
 
      if content.Errors<>nil then
       begin
          ShowMessage(content.Errors[0].Msg);
       end
       else
       begin
         ShowMessage(content.FeDetResp[0].CAE);
       end;
 
 
 
 
 
end;

[giulichajari]

Es decir.. Como veran evaluo si el array de errores contiene algo y no me devuelve nada entonces me muestra el showmessage del cae pero vacio.

Probe colocar mal un campo y me devuelve el error. Pero asi sin errores no registra la factura.

Enviado desde mi SNE-LX3 mediante Tapatalk

[Delphius]

Es decir.. Como veran evaluo si el array de errores contiene algo y no me devuelve nada entonces me muestra el showmessage del cae pero vacio.

Probe colocar mal un campo y me devuelve el error. Pero asi sin errores no registra la factura.

Enviado desde mi SNE-LX3 mediante Tapatalk

No he usado nunca este componente, ni he tenido la oportunidad de estudiar el tema de la Factura Electrónica con la AFIP en Delphi.

Lo que me llama la atención es que estás intentando acceder a la posición 0 del vector FeDetResp. ¿Es realmente asi como debe accederse?

 

¿No es posible mostrar el contenido del Response entero para ver que te está devolviendo exactamente?

 

Saludos,

[giulichajari]

No he usado nunca este componente, ni he tenido la oportunidad de estudiar el tema de la Factura Electrónica con la AFIP en Delphi.

Lo que me llama la atención es que estás intentando acceder a la posición 0 del vector FeDetResp. ¿Es realmente asi como debe accederse?

 

¿No es posible mostrar el contenido del Response entero para ver que te está devolviendo exactamente?

 

Saludos,

GraciasDelphius. Los arrays dinamicos se inicializan en 0. Seguramente debe haber un error en la confeccion de la factura pero no me lo dice cual es.

[giulichajari]

Lo q no se es como obtener el xml del response a partir del codigo del wsdl importer.. O si queda en la maquina.

Enviado desde mi SNE-LX3 mediante Tapatalk

[giulichajari]

Bueno finalmente encontre este thread:

 

http://delphiaccess....cute#entry98228

 

Y logre visualizar el response utilizando el evento afterexecute del componente RIO, la fecha de vto de pago no debe informarse para concepto 1. Solo es para 2 y 3.

[egostar]

Bueno finalmente encontre este thread:

 

http://delphiaccess....cute#entry98228

 

Y logre visualizar el response utilizando el evento afterexecute del componente RIO, la fecha de vto de pago no debe informarse para concepto 1. Solo es para 2 y 3.

 

Que bien que has podido obtener el RESPONSE. Efectivamente, con eso lo que haces es cachar el REQUEST y el RESPONSE en forma "pura" por decirlo de alguna manera. Lo raro es que no puedas obtener la información desde la clase que se implementa. 

 

Saludos