Jump to content
Sign in to follow this  
pessantiago

HTTPRIO DELPHI

Recommended Posts

pessantiago

Boas é o seguinte estou a usar um webservice em modo de testes

queria saber como é que envio o batchid , já importei o wsdl.

 

Sei que o batchList é um objecto do tipo array mas nao encontro a propriedade batchID

    <v1:getBatches>

         <v1:batchIdList>

            <v1:batchId>17727028</v1:batchId>

         </v1:batchIdList>

      </v1:getBatches>

link:

https://www.fidelidade.pt/b2b/PT/b2bplatform/servicesb2b/BrokersIntegration/Paginas/getBatches.aspx

 

já depois de ter o header enviado, da me erro de memoria algum consegue dar uma ajuda..

obrigado

var

  lService: BrokerIntegrationSoap;

     // pedido
     Lpedido: getbatches;

  begi

  HTTPRIO2.HTTPWebNode.UseUTF8InHeader:=True ;

  lService := GetBrokerIntegrationSoap(False, '', HTTPRIO2);

   

Lpedido := getBatches.Create;
    Lpedido.batchIdList.batchId[1]:=337433239;
 lService.getBatches(Lpedido);

end;

PAS da importação 

******************************************************************** //

unit BrokerIntegration;

interface

uses InvokeRegistry, SOAPHTTPClient, Types, XSBuiltIns;

const
  IS_OPTN = $0001;
  IS_UNBD = $0002;
  IS_NLBL = $0004;
  IS_UNQL = $0008;
  IS_REF  = $0080;


type

  // ************************************************************************ //
  // The following types, referred to in the WSDL document are not being represented
  // in this file. They are either aliases[@] of other types represented or were referred
  // to but never[!] declared in the document. The types from the latter category
  // typically map to predefined/known XML or Embarcadero types; however, they could also
  // indicate incorrect WSDL documents that failed to declare or import a schema type.
  // ************************************************************************ //
  // !:anyType         - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:long            - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:string          - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:boolean         - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:date            - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:int             - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:base64Binary    - "http://www.w3.org/2001/XMLSchema"[Gbl]

  getBatches           = class;                 { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[Lit][GblElm] }
  searchBatchesResponse = class;                { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[Lit][GblElm] }
  getBatchesResponse   = class;                 { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[Lit][GblElm] }
  BatchIdListType      = class;                 { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[GblCplx] }
  ArrayOfApplicationalUser = class;             { "urn:/microsoft/multichannelframework/"[GblCplx] }
  ArrayOfApplicationalUserSystem = class;       { "urn:/microsoft/multichannelframework/"[GblCplx] }
  ArrayOfSystemUser    = class;                 { "urn:/microsoft/multichannelframework/"[GblCplx] }
  ArrayOfSystemUserSystem = class;              { "urn:/microsoft/multichannelframework/"[GblCplx] }
  OperationResultType  = class;                 { "urn:fidelidade.com/schema/SharedResources/OperationResult/V1"[GblCplx] }
  operationResult      = class;                 { "urn:fidelidade.com/schema/SharedResources/OperationResult/V1"[GblElm] }
  ErrorNativeEntryType = class;                 { "urn:fidelidade.com/schema/SharedResources/OperationResult/V1"[GblCplx] }
  ErrorType            = class;                 { "urn:fidelidade.com/schema/SharedResources/OperationResult/V1"[GblCplx] }
  searchBatches        = class;                 { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[Lit][GblElm] }
  AxisValues2          = class;                 { "urn:/microsoft/multichannelframework/"[Hdr][GblCplx] }
  AxisValues           = class;                 { "urn:/microsoft/multichannelframework/"[Hdr][GblElm] }
  BatchInfoType        = class;                 { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[GblCplx] }
  BatchDataListType    = class;                 { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[GblCplx] }
  BatchListType        = class;                 { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[GblCplx] }
  BatchDataType        = class;                 { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[GblCplx] }

  {$SCOPEDENUMS ON}
  { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[GblSmpl] }
  DeliveredType = (YES, NO);

  { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[GblSmpl] }
  BatchDataFormatType = (CSV, XML);

  {$SCOPEDENUMS OFF}



  // ************************************************************************ //
  // XML       : getBatches, global, <element>
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // Serializtn: [xoLiteralParam]
  // Info      : Wrapper
  // ************************************************************************ //
  getBatches = class(TRemotable)
  private
    FbatchIdList: BatchIdListType;
  public
    constructor Create; override;
    destructor Destroy; override;
  published
    property batchIdList: BatchIdListType  read FbatchIdList write FbatchIdList;
  end;



  // ************************************************************************ //
  // XML       : searchBatchesResponse, global, <element>
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // Serializtn: [xoLiteralParam]
  // Info      : Wrapper
  // ************************************************************************ //
  searchBatchesResponse = class(TRemotable)
  private
    FoperationResult: operationResult;
    FbatchList: BatchListType;
    FbatchList_Specified: boolean;
    procedure SetbatchList(Index: Integer; const ABatchListType: BatchListType);
    function  batchList_Specified(Index: Integer): boolean;
  public
    constructor Create; override;
    destructor Destroy; override;
  published
    property operationResult: operationResult  Index (IS_REF) read FoperationResult write FoperationResult;
    property batchList:       BatchListType    Index (IS_OPTN) read FbatchList write SetbatchList stored batchList_Specified;
  end;



  // ************************************************************************ //
  // XML       : getBatchesResponse, global, <element>
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // Serializtn: [xoLiteralParam]
  // Info      : Wrapper
  // ************************************************************************ //
  getBatchesResponse = class(TRemotable)
  private
    FoperationResult: operationResult;
    FbatchDataList: BatchDataListType;
    FbatchDataList_Specified: boolean;
    procedure SetbatchDataList(Index: Integer; const ABatchDataListType: BatchDataListType);
    function  batchDataList_Specified(Index: Integer): boolean;
  public
    constructor Create; override;
    destructor Destroy; override;
  published
    property operationResult: operationResult    Index (IS_REF) read FoperationResult write FoperationResult;
    property batchDataList:   BatchDataListType  Index (IS_OPTN) read FbatchDataList write SetbatchDataList stored batchDataList_Specified;
  end;

  Array_Of_ErrorNativeEntryType = array of ErrorNativeEntryType;   { "urn:fidelidade.com/schema/SharedResources/OperationResult/V1"[GblUbnd] }
  Array_Of_BatchDataType = array of BatchDataType;   { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[GblUbnd] }
  Array_Of_BatchInfoType = array of BatchInfoType;   { "urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1"[GblUbnd] }
  Array_Of_long = array of Int64;               { "http://www.w3.org/2001/XMLSchema"[GblUbnd] }


  // ************************************************************************ //
  // XML       : BatchIdListType, global, <complexType>
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // ************************************************************************ //
  BatchIdListType = class(TRemotable)
  private
    FbatchId: Array_Of_long;
  public
    function   GetInt64Array(Index: Integer): Int64;
    procedure  SetInt64Array(Index: Integer; const Item: Int64);
    function   GetInt64ArrayLength: Integer;
    procedure  SetInt64ArrayLength(Len: Integer);

    property   Int64Array[Index: Integer]: Int64 read GetInt64Array write SetInt64Array; default;
    property   Len: Integer read GetInt64ArrayLength write SetInt64ArrayLength;
  published
    property batchId: Array_Of_long  Index (IS_UNBD) read FbatchId write FbatchId;
  end;

  Array_Of_string = array of string;            { "http://www.w3.org/2001/XMLSchema"[GblUbnd] }


  // ************************************************************************ //
  // XML       : ArrayOfApplicationalUser, global, <complexType>
  // Namespace : urn:/microsoft/multichannelframework/
  // ************************************************************************ //
  ArrayOfApplicationalUser = class(TRemotable)
  private
    FItem: Array_Of_string;
    FItem_Specified: boolean;
    procedure SetItem(Index: Integer; const AArray_Of_string: Array_Of_string);
    function  Item_Specified(Index: Integer): boolean;
  public
    function   GetstringArray(Index: Integer): string;
    procedure  SetstringArray(Index: Integer; const Item: string);
    function   GetstringArrayLength: Integer;
    procedure  SetstringArrayLength(Len: Integer);

    property   stringArray[Index: Integer]: string read GetstringArray write SetstringArray; default;
    property   Len: Integer read GetstringArrayLength write SetstringArrayLength;
  published
    property Item: Array_Of_string  Index (IS_OPTN or IS_UNBD or IS_NLBL or IS_UNQL) read FItem write SetItem stored Item_Specified;
  end;



  // ************************************************************************ //
  // XML       : ArrayOfApplicationalUserSystem, global, <complexType>
  // Namespace : urn:/microsoft/multichannelframework/
  // ************************************************************************ //
  ArrayOfApplicationalUserSystem = class(TRemotable)
  private
    FItem: Array_Of_string;
    FItem_Specified: boolean;
    procedure SetItem(Index: Integer; const AArray_Of_string: Array_Of_string);
    function  Item_Specified(Index: Integer): boolean;
  public
    function   GetstringArray(Index: Integer): string;
    procedure  SetstringArray(Index: Integer; const Item: string);
    function   GetstringArrayLength: Integer;
    procedure  SetstringArrayLength(Len: Integer);

    property   stringArray[Index: Integer]: string read GetstringArray write SetstringArray; default;
    property   Len: Integer read GetstringArrayLength write SetstringArrayLength;
  published
    property Item: Array_Of_string  Index (IS_OPTN or IS_UNBD or IS_NLBL or IS_UNQL) read FItem write SetItem stored Item_Specified;
  end;



  // ************************************************************************ //
  // XML       : ArrayOfSystemUser, global, <complexType>
  // Namespace : urn:/microsoft/multichannelframework/
  // ************************************************************************ //
  ArrayOfSystemUser = class(TRemotable)
  private
    FItem: Array_Of_string;
    FItem_Specified: boolean;
    procedure SetItem(Index: Integer; const AArray_Of_string: Array_Of_string);
    function  Item_Specified(Index: Integer): boolean;
  public
    function   GetstringArray(Index: Integer): string;
    procedure  SetstringArray(Index: Integer; const Item: string);
    function   GetstringArrayLength: Integer;
    procedure  SetstringArrayLength(Len: Integer);

    property   stringArray[Index: Integer]: string read GetstringArray write SetstringArray; default;
    property   Len: Integer read GetstringArrayLength write SetstringArrayLength;
  published
    property Item: Array_Of_string  Index (IS_OPTN or IS_UNBD or IS_NLBL or IS_UNQL) read FItem write SetItem stored Item_Specified;
  end;



  // ************************************************************************ //
  // XML       : ArrayOfSystemUserSystem, global, <complexType>
  // Namespace : urn:/microsoft/multichannelframework/
  // ************************************************************************ //
  ArrayOfSystemUserSystem = class(TRemotable)
  private
    FItem: Array_Of_string;
    FItem_Specified: boolean;
    procedure SetItem(Index: Integer; const AArray_Of_string: Array_Of_string);
    function  Item_Specified(Index: Integer): boolean;
  public
    function   GetstringArray(Index: Integer): string;
    procedure  SetstringArray(Index: Integer; const Item: string);
    function   GetstringArrayLength: Integer;
    procedure  SetstringArrayLength(Len: Integer);

    property   stringArray[Index: Integer]: string read GetstringArray write SetstringArray; default;
    property   Len: Integer read GetstringArrayLength write SetstringArrayLength;
  published
    property Item: Array_Of_string  Index (IS_OPTN or IS_UNBD or IS_NLBL or IS_UNQL) read FItem write SetItem stored Item_Specified;
  end;



  // ************************************************************************ //
  // XML       : OperationResultType, global, <complexType>
  // Namespace : urn:fidelidade.com/schema/SharedResources/OperationResult/V1
  // ************************************************************************ //
  OperationResultType = class(TRemotable)
  private
    Fsucceeded: Boolean;
    Ferror: ErrorType;
    Ferror_Specified: boolean;
    procedure Seterror(Index: Integer; const AErrorType: ErrorType);
    function  error_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property succeeded: Boolean    read Fsucceeded write Fsucceeded;
    property error:     ErrorType  Index (IS_OPTN) read Ferror write Seterror stored error_Specified;
  end;



  // ************************************************************************ //
  // XML       : operationResult, global, <element>
  // Namespace : urn:fidelidade.com/schema/SharedResources/OperationResult/V1
  // ************************************************************************ //
  operationResult = class(OperationResultType)
  private
  published
  end;



  // ************************************************************************ //
  // XML       : ErrorNativeEntryType, global, <complexType>
  // Namespace : urn:fidelidade.com/schema/SharedResources/OperationResult/V1
  // ************************************************************************ //
  ErrorNativeEntryType = class(TRemotable)
  private
    Fcode: string;
    Fmessage_: string;
    Fdetail: Variant;
    Fdetail_Specified: boolean;
    Fsource: string;
    Fsource_Specified: boolean;
    procedure Setdetail(Index: Integer; const AVariant: Variant);
    function  detail_Specified(Index: Integer): boolean;
    procedure Setsource(Index: Integer; const Astring: string);
    function  source_Specified(Index: Integer): boolean;
  published
    property code:     string   read Fcode write Fcode;
    property message_: string   read Fmessage_ write Fmessage_;
    property detail:   Variant  Index (IS_OPTN) read Fdetail write Setdetail stored detail_Specified;
    property source:   string   Index (IS_OPTN) read Fsource write Setsource stored source_Specified;
  end;



  // ************************************************************************ //
  // XML       : ErrorType, global, <complexType>
  // Namespace : urn:fidelidade.com/schema/SharedResources/OperationResult/V1
  // ************************************************************************ //
  ErrorType = class(TRemotable)
  private
    Fcode: string;
    Fmessage_: string;
    Fdetail: Variant;
    Fdetail_Specified: boolean;
    Fsource: string;
    Fsource_Specified: boolean;
    Fnative: Array_Of_ErrorNativeEntryType;
    Fnative_Specified: boolean;
    procedure Setdetail(Index: Integer; const AVariant: Variant);
    function  detail_Specified(Index: Integer): boolean;
    procedure Setsource(Index: Integer; const Astring: string);
    function  source_Specified(Index: Integer): boolean;
    procedure Setnative(Index: Integer; const AArray_Of_ErrorNativeEntryType: Array_Of_ErrorNativeEntryType);
    function  native_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property code:     string                         read Fcode write Fcode;
    property message_: string                         read Fmessage_ write Fmessage_;
    property detail:   Variant                        Index (IS_OPTN) read Fdetail write Setdetail stored detail_Specified;
    property source:   string                         Index (IS_OPTN) read Fsource write Setsource stored source_Specified;
    property native:   Array_Of_ErrorNativeEntryType  Index (IS_OPTN or IS_UNBD) read Fnative write Setnative stored native_Specified;
  end;



  // ************************************************************************ //
  // XML       : searchBatches, global, <element>
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // Serializtn: [xoLiteralParam]
  // Info      : Wrapper
  // ************************************************************************ //
  searchBatches = class(TRemotable)
  private
    FfromDate: TXSDate;
    FtoDate: TXSDate;
    Ftype_: string;
    Ftype__Specified: boolean;
    Fdelivered: DeliveredType;
    Fdelivered_Specified: boolean;
    procedure Settype_(Index: Integer; const Astring: string);
    function  type__Specified(Index: Integer): boolean;
    procedure Setdelivered(Index: Integer; const ADeliveredType: DeliveredType);
    function  delivered_Specified(Index: Integer): boolean;
  public
    constructor Create; override;
    destructor Destroy; override;
  published
    property fromDate:  TXSDate        read FfromDate write FfromDate;
    property toDate:    TXSDate        read FtoDate write FtoDate;
    property type_:     string         Index (IS_OPTN) read Ftype_ write Settype_ stored type__Specified;
    property delivered: DeliveredType  Index (IS_OPTN) read Fdelivered write Setdelivered stored delivered_Specified;
  end;



  // ************************************************************************ //
  // XML       : AxisValues, global, <complexType>
  // Namespace : urn:/microsoft/multichannelframework/
  // Info      : Header
  // ************************************************************************ //
  AxisValues2 = class(TSOAPHeader)
  private
    FUser: string;
    FSolution: string;
    FSolutionUser: string;
    FSolutionUser_Specified: boolean;
    FBusinessTarget: string;
    FBusinessTarget_Specified: boolean;
    FSaF: string;
    FSaF_Specified: boolean;
    FSolutionSession: string;
    FSolutionSession_Specified: boolean;
    FDelegation: string;
    FDelegation_Specified: boolean;
    FCommercialChannel: string;
    FCommercialChannel_Specified: boolean;
    FCommunicationsProtocol: string;
    FCommunicationsProtocol_Specified: boolean;
    FApplicationalUser: ArrayOfApplicationalUser;
    FApplicationalUser_Specified: boolean;
    FApplicationalUserSystem: ArrayOfApplicationalUserSystem;
    FApplicationalUserSystem_Specified: boolean;
    FSystemUser: ArrayOfSystemUser;
    FSystemUser_Specified: boolean;
    FSystemUserSystem: ArrayOfSystemUserSystem;
    FSystemUserSystem_Specified: boolean;
    FProxy: Integer;
    procedure SetSolutionUser(Index: Integer; const Astring: string);
    function  SolutionUser_Specified(Index: Integer): boolean;
    procedure SetBusinessTarget(Index: Integer; const Astring: string);
    function  BusinessTarget_Specified(Index: Integer): boolean;
    procedure SetSaF(Index: Integer; const Astring: string);
    function  SaF_Specified(Index: Integer): boolean;
    procedure SetSolutionSession(Index: Integer; const Astring: string);
    function  SolutionSession_Specified(Index: Integer): boolean;
    procedure SetDelegation(Index: Integer; const Astring: string);
    function  Delegation_Specified(Index: Integer): boolean;
    procedure SetCommercialChannel(Index: Integer; const Astring: string);
    function  CommercialChannel_Specified(Index: Integer): boolean;
    procedure SetCommunicationsProtocol(Index: Integer; const Astring: string);
    function  CommunicationsProtocol_Specified(Index: Integer): boolean;
    procedure SetApplicationalUser(Index: Integer; const AArrayOfApplicationalUser: ArrayOfApplicationalUser);
    function  ApplicationalUser_Specified(Index: Integer): boolean;
    procedure SetApplicationalUserSystem(Index: Integer; const AArrayOfApplicationalUserSystem: ArrayOfApplicationalUserSystem);
    function  ApplicationalUserSystem_Specified(Index: Integer): boolean;
    procedure SetSystemUser(Index: Integer; const AArrayOfSystemUser: ArrayOfSystemUser);
    function  SystemUser_Specified(Index: Integer): boolean;
    procedure SetSystemUserSystem(Index: Integer; const AArrayOfSystemUserSystem: ArrayOfSystemUserSystem);
    function  SystemUserSystem_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property User:                    string                          Index (IS_UNQL) read FUser write FUser;
    property Solution:                string                          Index (IS_UNQL) read FSolution write FSolution;
    property SolutionUser:            string                          Index (IS_OPTN or IS_UNQL) read FSolutionUser write SetSolutionUser stored SolutionUser_Specified;
    property BusinessTarget:          string                          Index (IS_OPTN or IS_UNQL) read FBusinessTarget write SetBusinessTarget stored BusinessTarget_Specified;
    property SaF:                     string                          Index (IS_OPTN or IS_UNQL) read FSaF write SetSaF stored SaF_Specified;
    property SolutionSession:         string                          Index (IS_OPTN or IS_UNQL) read FSolutionSession write SetSolutionSession stored SolutionSession_Specified;
    property Delegation:              string                          Index (IS_OPTN or IS_UNQL) read FDelegation write SetDelegation stored Delegation_Specified;
    property CommercialChannel:       string                          Index (IS_OPTN or IS_UNQL) read FCommercialChannel write SetCommercialChannel stored CommercialChannel_Specified;
    property CommunicationsProtocol:  string                          Index (IS_OPTN or IS_UNQL) read FCommunicationsProtocol write SetCommunicationsProtocol stored CommunicationsProtocol_Specified;
    property ApplicationalUser:       ArrayOfApplicationalUser        Index (IS_OPTN or IS_UNQL) read FApplicationalUser write SetApplicationalUser stored ApplicationalUser_Specified;
    property ApplicationalUserSystem: ArrayOfApplicationalUserSystem  Index (IS_OPTN or IS_UNQL) read FApplicationalUserSystem write SetApplicationalUserSystem stored ApplicationalUserSystem_Specified;
    property SystemUser:              ArrayOfSystemUser               Index (IS_OPTN or IS_UNQL) read FSystemUser write SetSystemUser stored SystemUser_Specified;
    property SystemUserSystem:        ArrayOfSystemUserSystem         Index (IS_OPTN or IS_UNQL) read FSystemUserSystem write SetSystemUserSystem stored SystemUserSystem_Specified;
    property Proxy:                   Integer                         Index (IS_UNQL) read FProxy write FProxy;
  end;



  // ************************************************************************ //
  // XML       : AxisValues, global, <element>
  // Namespace : urn:/microsoft/multichannelframework/
  // Info      : Header
  // ************************************************************************ //
  AxisValues = class(AxisValues2)
  private
  published
  end;



  // ************************************************************************ //
  // XML       : BatchInfoType, global, <complexType>
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // ************************************************************************ //
  BatchInfoType = class(TRemotable)
  private
    FbatchId: Int64;
    Fdate: TXSDate;
    Ftype_: string;
    Fdelivered: DeliveredType;
    FbatchDataFormat: BatchDataFormatType;
    FbatchDataFormatVersion: string;
    FtotalRecords: Integer;
  public
    destructor Destroy; override;
  published
    property batchId:                Int64                read FbatchId write FbatchId;
    property date:                   TXSDate              read Fdate write Fdate;
    property type_:                  string               read Ftype_ write Ftype_;
    property delivered:              DeliveredType        read Fdelivered write Fdelivered;
    property batchDataFormat:        BatchDataFormatType  read FbatchDataFormat write FbatchDataFormat;
    property batchDataFormatVersion: string               read FbatchDataFormatVersion write FbatchDataFormatVersion;
    property totalRecords:           Integer              read FtotalRecords write FtotalRecords;
  end;



  // ************************************************************************ //
  // XML       : BatchDataListType, global, <complexType>
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // ************************************************************************ //
  BatchDataListType = class(TRemotable)
  private
    FbatchData: Array_Of_BatchDataType;
    FbatchData_Specified: boolean;
    procedure SetbatchData(Index: Integer; const AArray_Of_BatchDataType: Array_Of_BatchDataType);
    function  batchData_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
    function   GetBatchDataTypeArray(Index: Integer): BatchDataType;
    procedure  SetBatchDataTypeArray(Index: Integer; const Item: BatchDataType);
    function   GetBatchDataTypeArrayLength: Integer;
    procedure  SetBatchDataTypeArrayLength(Len: Integer);

    property   BatchDataTypeArray[Index: Integer]: BatchDataType read GetBatchDataTypeArray write SetBatchDataTypeArray; default;
    property   Len: Integer read GetBatchDataTypeArrayLength write SetBatchDataTypeArrayLength;
  published
    property batchData: Array_Of_BatchDataType  Index (IS_OPTN or IS_UNBD) read FbatchData write SetbatchData stored batchData_Specified;
  end;



  // ************************************************************************ //
  // XML       : BatchListType, global, <complexType>
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // ************************************************************************ //
  BatchListType = class(TRemotable)
  private
    Fbatch: Array_Of_BatchInfoType;
    Fbatch_Specified: boolean;
    procedure Setbatch(Index: Integer; const AArray_Of_BatchInfoType: Array_Of_BatchInfoType);
    function  batch_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
    function   GetBatchInfoTypeArray(Index: Integer): BatchInfoType;
    procedure  SetBatchInfoTypeArray(Index: Integer; const Item: BatchInfoType);
    function   GetBatchInfoTypeArrayLength: Integer;
    procedure  SetBatchInfoTypeArrayLength(Len: Integer);

    property   BatchInfoTypeArray[Index: Integer]: BatchInfoType read GetBatchInfoTypeArray write SetBatchInfoTypeArray; default;
    property   Len: Integer read GetBatchInfoTypeArrayLength write SetBatchInfoTypeArrayLength;
  published
    property batch: Array_Of_BatchInfoType  Index (IS_OPTN or IS_UNBD) read Fbatch write Setbatch stored batch_Specified;
  end;



  // ************************************************************************ //
  // XML       : BatchDataType, global, <complexType>
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // ************************************************************************ //
  BatchDataType = class(TRemotable)
  private
    FbatchId: Int64;
    FbatchData: TByteDynArray;
  published
    property batchId:   Int64          read FbatchId write FbatchId;
    property batchData: TByteDynArray  read FbatchData write FbatchData;
  end;


  // ************************************************************************ //
  // Namespace : urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1
  // soapAction: urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1/%operationName%
  // transport : http://schemas.xmlsoap.org/soap/http
  // style     : document
  // use       : literal
  // binding   : BrokerIntegrationSoap11
  // service   : BrokerIntegrationService
  // port      : BrokerIntegrationSoap11
  // URL       : https://sbxb2bconnect.fidelidade.pt/B2B/Integration/BrokerIntegration/V1
  // ************************************************************************ //
  BrokerIntegrationSoap = interface(IInvokable)
  ['{2592F4A0-3ADE-CEC4-3FBF-90C224FB2BEB}']

    // Cannot unwrap:
    //     - More than one strictly out element was found
    // Headers: AxisValuesMsgPart:pIn
    function  searchBatches(const parameters: searchBatches): searchBatchesResponse; stdcall;

    // Cannot unwrap:
    //     - More than one strictly out element was found
    // Headers: AxisValuesMsgPart:pIn
    function  getBatches(const parameters: getBatches): getBatchesResponse; stdcall;
  end;

function GetBrokerIntegrationSoap(UseWSDL: Boolean=System.False; Addr: string=''; HTTPRIO: THTTPRIO = nil): BrokerIntegrationSoap;


implementation
  uses SysUtils;

function GetBrokerIntegrationSoap(UseWSDL: Boolean; Addr: string; HTTPRIO: THTTPRIO): BrokerIntegrationSoap;
const
  defWSDL = 'C:\Users\Downloads\BrokerIntegrationWSDL\BrokerIntegration.wsdl';
  defURL  = 'https://sbxb2bconnect.fidelidade.pt/B2B/Integration/BrokerIntegration/V1';
  defSvc  = 'BrokerIntegrationService';
  defPrt  = 'BrokerIntegrationSoap11';
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 BrokerIntegrationSoap);
    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;


constructor getBatches.Create;
begin
  inherited Create;
  FSerializationOptions := [xoLiteralParam];
end;

destructor getBatches.Destroy;
begin
  SysUtils.FreeAndNil(FbatchIdList);
  inherited Destroy;
end;

constructor searchBatchesResponse.Create;
begin
  inherited Create;
  FSerializationOptions := [xoLiteralParam];
end;

destructor searchBatchesResponse.Destroy;
begin
  SysUtils.FreeAndNil(FoperationResult);
  SysUtils.FreeAndNil(FbatchList);
  inherited Destroy;
end;

procedure searchBatchesResponse.SetbatchList(Index: Integer; const ABatchListType: BatchListType);
begin
  FbatchList := ABatchListType;
  FbatchList_Specified := True;
end;

function searchBatchesResponse.batchList_Specified(Index: Integer): boolean;
begin
  Result := FbatchList_Specified;
end;

constructor getBatchesResponse.Create;
begin
  inherited Create;
  FSerializationOptions := [xoLiteralParam];
end;

destructor getBatchesResponse.Destroy;
begin
  SysUtils.FreeAndNil(FoperationResult);
  SysUtils.FreeAndNil(FbatchDataList);
  inherited Destroy;
end;

procedure getBatchesResponse.SetbatchDataList(Index: Integer; const ABatchDataListType: BatchDataListType);
begin
  FbatchDataList := ABatchDataListType;
  FbatchDataList_Specified := True;
end;

function getBatchesResponse.batchDataList_Specified(Index: Integer): boolean;
begin
  Result := FbatchDataList_Specified;
end;

function BatchIdListType.GetInt64Array(Index: Integer): Int64;
begin
  Result := FbatchId[Index];
end;

procedure BatchIdListType.SetInt64Array(Index: Integer; const Item: Int64);
begin
   FbatchId[Index] := Item;
end;

function BatchIdListType.GetInt64ArrayLength: Integer;
begin
  if Assigned(FbatchId) then
    Result := System.Length(FbatchId)
  else
    Result := 0;
end;

procedure BatchIdListType.SetInt64ArrayLength(Len: Integer);
begin
  System.SetLength(FbatchId, Len);
end;

function ArrayOfApplicationalUser.GetstringArray(Index: Integer): string;
begin
  Result := FItem[Index];
end;

procedure ArrayOfApplicationalUser.SetstringArray(Index: Integer; const Item: string);
begin
   FItem[Index] := Item;
end;

function ArrayOfApplicationalUser.GetstringArrayLength: Integer;
begin
  if Assigned(FItem) then
    Result := System.Length(FItem)
  else
    Result := 0;
end;

procedure ArrayOfApplicationalUser.SetstringArrayLength(Len: Integer);
begin
  System.SetLength(FItem, Len);
end;

procedure ArrayOfApplicationalUser.SetItem(Index: Integer; const AArray_Of_string: Array_Of_string);
begin
  FItem := AArray_Of_string;
  FItem_Specified := True;
end;

function ArrayOfApplicationalUser.Item_Specified(Index: Integer): boolean;
begin
  Result := FItem_Specified;
end;

function ArrayOfApplicationalUserSystem.GetstringArray(Index: Integer): string;
begin
  Result := FItem[Index];
end;

procedure ArrayOfApplicationalUserSystem.SetstringArray(Index: Integer; const Item: string);
begin
   FItem[Index] := Item;
end;

function ArrayOfApplicationalUserSystem.GetstringArrayLength: Integer;
begin
  if Assigned(FItem) then
    Result := System.Length(FItem)
  else
    Result := 0;
end;

procedure ArrayOfApplicationalUserSystem.SetstringArrayLength(Len: Integer);
begin
  System.SetLength(FItem, Len);
end;

procedure ArrayOfApplicationalUserSystem.SetItem(Index: Integer; const AArray_Of_string: Array_Of_string);
begin
  FItem := AArray_Of_string;
  FItem_Specified := True;
end;

function ArrayOfApplicationalUserSystem.Item_Specified(Index: Integer): boolean;
begin
  Result := FItem_Specified;
end;

function ArrayOfSystemUser.GetstringArray(Index: Integer): string;
begin
  Result := FItem[Index];
end;

procedure ArrayOfSystemUser.SetstringArray(Index: Integer; const Item: string);
begin
   FItem[Index] := Item;
end;

function ArrayOfSystemUser.GetstringArrayLength: Integer;
begin
  if Assigned(FItem) then
    Result := System.Length(FItem)
  else
    Result := 0;
end;

procedure ArrayOfSystemUser.SetstringArrayLength(Len: Integer);
begin
  System.SetLength(FItem, Len);
end;

procedure ArrayOfSystemUser.SetItem(Index: Integer; const AArray_Of_string: Array_Of_string);
begin
  FItem := AArray_Of_string;
  FItem_Specified := True;
end;

function ArrayOfSystemUser.Item_Specified(Index: Integer): boolean;
begin
  Result := FItem_Specified;
end;

function ArrayOfSystemUserSystem.GetstringArray(Index: Integer): string;
begin
  Result := FItem[Index];
end;

procedure ArrayOfSystemUserSystem.SetstringArray(Index: Integer; const Item: string);
begin
   FItem[Index] := Item;
end;

function ArrayOfSystemUserSystem.GetstringArrayLength: Integer;
begin
  if Assigned(FItem) then
    Result := System.Length(FItem)
  else
    Result := 0;
end;

procedure ArrayOfSystemUserSystem.SetstringArrayLength(Len: Integer);
begin
  System.SetLength(FItem, Len);
end;

procedure ArrayOfSystemUserSystem.SetItem(Index: Integer; const AArray_Of_string: Array_Of_string);
begin
  FItem := AArray_Of_string;
  FItem_Specified := True;
end;

function ArrayOfSystemUserSystem.Item_Specified(Index: Integer): boolean;
begin
  Result := FItem_Specified;
end;

destructor OperationResultType.Destroy;
begin
  SysUtils.FreeAndNil(Ferror);
  inherited Destroy;
end;

procedure OperationResultType.Seterror(Index: Integer; const AErrorType: ErrorType);
begin
  Ferror := AErrorType;
  Ferror_Specified := True;
end;

function OperationResultType.error_Specified(Index: Integer): boolean;
begin
  Result := Ferror_Specified;
end;

procedure ErrorNativeEntryType.Setdetail(Index: Integer; const AVariant: Variant);
begin
  Fdetail := AVariant;
  Fdetail_Specified := True;
end;

function ErrorNativeEntryType.detail_Specified(Index: Integer): boolean;
begin
  Result := Fdetail_Specified;
end;

procedure ErrorNativeEntryType.Setsource(Index: Integer; const Astring: string);
begin
  Fsource := Astring;
  Fsource_Specified := True;
end;

function ErrorNativeEntryType.source_Specified(Index: Integer): boolean;
begin
  Result := Fsource_Specified;
end;

destructor ErrorType.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(Fnative)-1 do
    SysUtils.FreeAndNil(Fnative[I]);
  System.SetLength(Fnative, 0);
  inherited Destroy;
end;

procedure ErrorType.Setdetail(Index: Integer; const AVariant: Variant);
begin
  Fdetail := AVariant;
  Fdetail_Specified := True;
end;

function ErrorType.detail_Specified(Index: Integer): boolean;
begin
  Result := Fdetail_Specified;
end;

procedure ErrorType.Setsource(Index: Integer; const Astring: string);
begin
  Fsource := Astring;
  Fsource_Specified := True;
end;

function ErrorType.source_Specified(Index: Integer): boolean;
begin
  Result := Fsource_Specified;
end;

procedure ErrorType.Setnative(Index: Integer; const AArray_Of_ErrorNativeEntryType: Array_Of_ErrorNativeEntryType);
begin
  Fnative := AArray_Of_ErrorNativeEntryType;
  Fnative_Specified := True;
end;

function ErrorType.native_Specified(Index: Integer): boolean;
begin
  Result := Fnative_Specified;
end;

constructor searchBatches.Create;
begin
  inherited Create;
  FSerializationOptions := [xoLiteralParam];
end;

destructor searchBatches.Destroy;
begin
  SysUtils.FreeAndNil(FfromDate);
  SysUtils.FreeAndNil(FtoDate);
  inherited Destroy;
end;

procedure searchBatches.Settype_(Index: Integer; const Astring: string);
begin
  Ftype_ := Astring;
  Ftype__Specified := True;
end;

function searchBatches.type__Specified(Index: Integer): boolean;
begin
  Result := Ftype__Specified;
end;

procedure searchBatches.Setdelivered(Index: Integer; const ADeliveredType: DeliveredType);
begin
  Fdelivered := ADeliveredType;
  Fdelivered_Specified := True;
end;

function searchBatches.delivered_Specified(Index: Integer): boolean;
begin
  Result := Fdelivered_Specified;
end;

destructor AxisValues2.Destroy;
begin
  SysUtils.FreeAndNil(FApplicationalUser);
  SysUtils.FreeAndNil(FApplicationalUserSystem);
  SysUtils.FreeAndNil(FSystemUser);
  SysUtils.FreeAndNil(FSystemUserSystem);
  inherited Destroy;
end;

procedure AxisValues2.SetSolutionUser(Index: Integer; const Astring: string);
begin
  FSolutionUser := Astring;
  FSolutionUser_Specified := True;
end;

function AxisValues2.SolutionUser_Specified(Index: Integer): boolean;
begin
  Result := FSolutionUser_Specified;
end;

procedure AxisValues2.SetBusinessTarget(Index: Integer; const Astring: string);
begin
  FBusinessTarget := Astring;
  FBusinessTarget_Specified := True;
end;

function AxisValues2.BusinessTarget_Specified(Index: Integer): boolean;
begin
  Result := FBusinessTarget_Specified;
end;

procedure AxisValues2.SetSaF(Index: Integer; const Astring: string);
begin
  FSaF := Astring;
  FSaF_Specified := True;
end;

function AxisValues2.SaF_Specified(Index: Integer): boolean;
begin
  Result := FSaF_Specified;
end;

procedure AxisValues2.SetSolutionSession(Index: Integer; const Astring: string);
begin
  FSolutionSession := Astring;
  FSolutionSession_Specified := True;
end;

function AxisValues2.SolutionSession_Specified(Index: Integer): boolean;
begin
  Result := FSolutionSession_Specified;
end;

procedure AxisValues2.SetDelegation(Index: Integer; const Astring: string);
begin
  FDelegation := Astring;
  FDelegation_Specified := True;
end;

function AxisValues2.Delegation_Specified(Index: Integer): boolean;
begin
  Result := FDelegation_Specified;
end;

procedure AxisValues2.SetCommercialChannel(Index: Integer; const Astring: string);
begin
  FCommercialChannel := Astring;
  FCommercialChannel_Specified := True;
end;

function AxisValues2.CommercialChannel_Specified(Index: Integer): boolean;
begin
  Result := FCommercialChannel_Specified;
end;

procedure AxisValues2.SetCommunicationsProtocol(Index: Integer; const Astring: string);
begin
  FCommunicationsProtocol := Astring;
  FCommunicationsProtocol_Specified := True;
end;

function AxisValues2.CommunicationsProtocol_Specified(Index: Integer): boolean;
begin
  Result := FCommunicationsProtocol_Specified;
end;

procedure AxisValues2.SetApplicationalUser(Index: Integer; const AArrayOfApplicationalUser: ArrayOfApplicationalUser);
begin
  FApplicationalUser := AArrayOfApplicationalUser;
  FApplicationalUser_Specified := True;
end;

function AxisValues2.ApplicationalUser_Specified(Index: Integer): boolean;
begin
  Result := FApplicationalUser_Specified;
end;

procedure AxisValues2.SetApplicationalUserSystem(Index: Integer; const AArrayOfApplicationalUserSystem: ArrayOfApplicationalUserSystem);
begin
  FApplicationalUserSystem := AArrayOfApplicationalUserSystem;
  FApplicationalUserSystem_Specified := True;
end;

function AxisValues2.ApplicationalUserSystem_Specified(Index: Integer): boolean;
begin
  Result := FApplicationalUserSystem_Specified;
end;

procedure AxisValues2.SetSystemUser(Index: Integer; const AArrayOfSystemUser: ArrayOfSystemUser);
begin
  FSystemUser := AArrayOfSystemUser;
  FSystemUser_Specified := True;
end;

function AxisValues2.SystemUser_Specified(Index: Integer): boolean;
begin
  Result := FSystemUser_Specified;
end;

procedure AxisValues2.SetSystemUserSystem(Index: Integer; const AArrayOfSystemUserSystem: ArrayOfSystemUserSystem);
begin
  FSystemUserSystem := AArrayOfSystemUserSystem;
  FSystemUserSystem_Specified := True;
end;

function AxisValues2.SystemUserSystem_Specified(Index: Integer): boolean;
begin
  Result := FSystemUserSystem_Specified;
end;

destructor BatchInfoType.Destroy;
begin
  SysUtils.FreeAndNil(Fdate);
  inherited Destroy;
end;

destructor BatchDataListType.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FbatchData)-1 do
    SysUtils.FreeAndNil(FbatchData[I]);
  System.SetLength(FbatchData, 0);
  inherited Destroy;
end;

function BatchDataListType.GetBatchDataTypeArray(Index: Integer): BatchDataType;
begin
  Result := FbatchData[Index];
end;

procedure BatchDataListType.SetBatchDataTypeArray(Index: Integer; const Item: BatchDataType);
begin
   FbatchData[Index] := Item;
end;

function BatchDataListType.GetBatchDataTypeArrayLength: Integer;
begin
  if Assigned(FbatchData) then
    Result := System.Length(FbatchData)
  else
    Result := 0;
end;

procedure BatchDataListType.SetBatchDataTypeArrayLength(Len: Integer);
begin
  System.SetLength(FbatchData, Len);
end;

procedure BatchDataListType.SetbatchData(Index: Integer; const AArray_Of_BatchDataType: Array_Of_BatchDataType);
begin
  FbatchData := AArray_Of_BatchDataType;
  FbatchData_Specified := True;
end;

function BatchDataListType.batchData_Specified(Index: Integer): boolean;
begin
  Result := FbatchData_Specified;
end;

destructor BatchListType.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(Fbatch)-1 do
    SysUtils.FreeAndNil(Fbatch[I]);
  System.SetLength(Fbatch, 0);
  inherited Destroy;
end;

function BatchListType.GetBatchInfoTypeArray(Index: Integer): BatchInfoType;
begin
  Result := Fbatch[Index];
end;

procedure BatchListType.SetBatchInfoTypeArray(Index: Integer; const Item: BatchInfoType);
begin
   Fbatch[Index] := Item;
end;

function BatchListType.GetBatchInfoTypeArrayLength: Integer;
begin
  if Assigned(Fbatch) then
    Result := System.Length(Fbatch)
  else
    Result := 0;
end;

procedure BatchListType.SetBatchInfoTypeArrayLength(Len: Integer);
begin
  System.SetLength(Fbatch, Len);
end;

procedure BatchListType.Setbatch(Index: Integer; const AArray_Of_BatchInfoType: Array_Of_BatchInfoType);
begin
  Fbatch := AArray_Of_BatchInfoType;
  Fbatch_Specified := True;
end;

function BatchListType.batch_Specified(Index: Integer): boolean;
begin
  Result := Fbatch_Specified;
end;

initialization
  { BrokerIntegrationSoap }
  InvRegistry.RegisterInterface(TypeInfo(BrokerIntegrationSoap), 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'UTF-8');
  InvRegistry.RegisterDefaultSOAPAction(TypeInfo(BrokerIntegrationSoap), 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1/%operationName%');
  InvRegistry.RegisterInvokeOptions(TypeInfo(BrokerIntegrationSoap), ioDocument);
  InvRegistry.RegisterInvokeOptions(TypeInfo(BrokerIntegrationSoap), ioLiteral);
  InvRegistry.RegisterHeaderClass(TypeInfo(BrokerIntegrationSoap), AxisValues, 'AxisValuesMsgPart', 'urn:/microsoft/multichannelframework/');
  RemClassRegistry.RegisterXSClass(getBatches, 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'getBatches');
  RemClassRegistry.RegisterSerializeOptions(getBatches, [xoLiteralParam]);
  RemClassRegistry.RegisterXSClass(searchBatchesResponse, 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'searchBatchesResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(searchBatchesResponse), 'operationResult', '[Namespace="urn:fidelidade.com/schema/SharedResources/OperationResult/V1"]');
  RemClassRegistry.RegisterSerializeOptions(searchBatchesResponse, [xoLiteralParam]);
  RemClassRegistry.RegisterXSClass(getBatchesResponse, 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'getBatchesResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(getBatchesResponse), 'operationResult', '[Namespace="urn:fidelidade.com/schema/SharedResources/OperationResult/V1"]');
  RemClassRegistry.RegisterSerializeOptions(getBatchesResponse, [xoLiteralParam]);
  RemClassRegistry.RegisterXSInfo(TypeInfo(Array_Of_ErrorNativeEntryType), 'urn:fidelidade.com/schema/SharedResources/OperationResult/V1', 'Array_Of_ErrorNativeEntryType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(Array_Of_BatchDataType), 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'Array_Of_BatchDataType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(Array_Of_BatchInfoType), 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'Array_Of_BatchInfoType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(Array_Of_long), 'http://www.w3.org/2001/XMLSchema', 'Array_Of_long');
  RemClassRegistry.RegisterXSClass(BatchIdListType, 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'BatchIdListType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(Array_Of_string), 'http://www.w3.org/2001/XMLSchema', 'Array_Of_string');
  RemClassRegistry.RegisterXSClass(ArrayOfApplicationalUser, 'urn:/microsoft/multichannelframework/', 'ArrayOfApplicationalUser');
  RemClassRegistry.RegisterXSClass(ArrayOfApplicationalUserSystem, 'urn:/microsoft/multichannelframework/', 'ArrayOfApplicationalUserSystem');
  RemClassRegistry.RegisterXSClass(ArrayOfSystemUser, 'urn:/microsoft/multichannelframework/', 'ArrayOfSystemUser');
  RemClassRegistry.RegisterXSClass(ArrayOfSystemUserSystem, 'urn:/microsoft/multichannelframework/', 'ArrayOfSystemUserSystem');
  RemClassRegistry.RegisterXSClass(OperationResultType, 'urn:fidelidade.com/schema/SharedResources/OperationResult/V1', 'OperationResultType');
  RemClassRegistry.RegisterXSClass(operationResult, 'urn:fidelidade.com/schema/SharedResources/OperationResult/V1', 'operationResult');
  RemClassRegistry.RegisterXSClass(ErrorNativeEntryType, 'urn:fidelidade.com/schema/SharedResources/OperationResult/V1', 'ErrorNativeEntryType');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ErrorNativeEntryType), 'message_', '[ExtName="message"]');
  RemClassRegistry.RegisterXSClass(ErrorType, 'urn:fidelidade.com/schema/SharedResources/OperationResult/V1', 'ErrorType');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ErrorType), 'message_', '[ExtName="message"]');
  RemClassRegistry.RegisterXSInfo(TypeInfo(DeliveredType), 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'DeliveredType');
  RemClassRegistry.RegisterXSClass(searchBatches, 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'searchBatches');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(searchBatches), 'type_', '[ExtName="type"]');
  RemClassRegistry.RegisterSerializeOptions(searchBatches, [xoLiteralParam]);
  RemClassRegistry.RegisterXSClass(AxisValues2, 'urn:/microsoft/multichannelframework/', 'AxisValues2', 'AxisValues');
  RemClassRegistry.RegisterXSClass(AxisValues, 'urn:/microsoft/multichannelframework/', 'AxisValues');
  RemClassRegistry.RegisterXSInfo(TypeInfo(BatchDataFormatType), 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'BatchDataFormatType');
  RemClassRegistry.RegisterXSClass(BatchInfoType, 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'BatchInfoType');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(BatchInfoType), 'type_', '[ExtName="type"]');
  RemClassRegistry.RegisterXSClass(BatchDataListType, 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'BatchDataListType');
  RemClassRegistry.RegisterXSClass(BatchListType, 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'BatchListType');
  RemClassRegistry.RegisterXSClass(BatchDataType, 'urn:fidelidade.com/ws/B2B/Integration/BrokerIntegration/V1', 'BatchDataType');

end.

 

Edited by pessantiago

Share this post


Link to post
Share on other sites
pessantiago
Em 15/06/2018 às 10:58, pessantiago disse:

Boas é o seguinte estou a usar um webservice em modo de testes

queria saber como é que envio o batchid , já importei o wsdl.

 

Sei que o batchList é um objecto do tipo array mas nao encontro a propriedade batchID


    <v1:getBatches>

         <v1:batchIdList>

            <v1:batchId>17727028</v1:batchId>

         </v1:batchIdList>

      </v1:getBatches>

link:

https://www.fidelidade.pt/b2b/PT/b2bplatform/servicesb2b/BrokersIntegration/Paginas/getBatches.aspx

editei a questão incial 

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
Sign in to follow this  

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.