SOAP WSDL Problem

[fränk0815]

Hallo, ich hab lange nicht mehr mit Delphi gearbeitet und bitte daher um Verständnis wenn ich doofe Fragen frag

Ich versuche mich grad mit einem SOAP-CLIENT der mich zur Verzweiflung bringt, anbei mal ein bissel Code, eventuell kann mir hier jemand auf die Sprünge helfen.

Zuerst der Aufruf:

Delphi-Quellcode:

procedure TfMain.Button1Click(Sender: TObject);
var
  sService: ppvapiSoap;
  rqst: ppvOrderRequest;
  addO: ppvAddOrder;
  resp: ppvOrderResponse;
  Partner: PartnerCredentials;
  User: UserCredentials;
  Settings: ServiceSettings;
  oLabel: OrderLabel;
  myAddress: ShipAddress;
  i: integer;
  sStream: TBytesStream;
  EncString: AnsiString;
  s: string;
  oArr: ArrayOfPpvOrderData;
begin
  sService:= GetppvapiSoap(False, '', HTTPRIO1);
  rqst:= ppvOrderRequest.Create;

  Partner:= PartnerCredentials.Create;
  Partner.PartnerKey:= '576B695166487A4550446962475634485939305645673D3D';
  Partner.PartnerName:= 'testpartner.1';
  rqst.PartnerCredentials:= Partner;

  User:= UserCredentials.Create;
  User.UserID:= 1838179;
  User.UserToken:= 'QoooOadR';
  rqst.UserCredentials:= User;

  rqst.Version:= 102;
  rqst.OrderAction:= OrderActionType.addOrder;
  rqst.ShipDate:= FormatDateTime('DD.MM.YYYY',Now);

  Settings:= ServiceSettings.Create;
  Settings.ErrorLanguage:= ErrorLanguageType.German;
  Settings.CountrySettings:= CountrySettingType.Alpha3;
  Settings.ZipCodeSetting:= ZipCodeSettingType.ZipCodeAsSingleValue;
  rqst.ServiceSettings:= Settings;

  oLabel:= OrderLabel.Create;
  oLabel.LabelSize:= iloxx.LabelSizeType.MultiLabel_A4;
  oLabel.LabelStartPosition:= LabelStartPositionType.UpperLeft;

  rqst.OrderLabel:= oLabel;

  oArr:= rqst.ppvOrderDataArray;
  i:= Length(oArr);
  SetLength(oArr, Length(oArr) + 1);

  oArr[i]:= ppvOrderData.Create;
  oArr[i].PartnerOrderReference:= 'B1001';  //Lieferscheinnummer, wird benötigt wegen Zuordnung in Sendungsdatenimport
  oArr[i].TrackURL:= '';
  oArr[i].Customer:= '0815';
  oArr[i].Reference:= 'B1001';
  oArr[i].Content:= 'Paketinhalt';
  //oArr[i].Weight.DecimalString:= '0.00'; //SoapStrToFloat('0,00');
  oArr[i].ShipService:= ShipServiceType.dpdNormalpaket;
  //oArr[i].CODAmount.DecimalString:= '0.00'; //SoapStrToFloat('0,00');

  myAddress:= ShipAddress.Create();
  s:= 'Testfirma';
  myAddress.Company:= s;
  myAddress.SexCode := SexCodeType.Female;
  s := 'Lilly Lox';
  myAddress.Name_ := s;
  s:= 'Gutenstetter Str. 8b';
  myAddress.Street := s;
  s := '90449';
  myAddress.ZipCode := s;
  myAddress.City := 'Nürnberg';
  myAddress.State := '';
  s := 'DEU';
  myAddress.Country := s;
  s := '';
  myAddress.Phone := s;
  s := '[e-mail]';
  myAddress.Mail := s;

  oArr[i].ShipAddress:= myAddress;

  addO:= ppvAddOrder.Create;
  addO.ppvOrderRequest:= rqst;

  resp:= sService.ppvAddOrder(addO).ppvAddOrderResult;

  if resp.Ack = Acktype.Success then

HIER knallt es dann

Delphi-Quellcode:

  begin
    if length(resp.ResponseDataArray) > 0 then
    begin
      for i := 0 to High(resp.ResponseDataArray) do showmessage( resp.ResponseDataArray[i].ParcelNumber + ' ' + resp.ResponseDataArray[i].PartnerOrderReference);    //hier diesendungsnummer zur Liste hinzufügen
    end else ShowMessage('Keine ResponseData');

    ShowMessage(resp.LabelPDFStream);

    EncString:= resp.LabelPDFStream;

    //sStream:= TMemoryStream.Create;
    //sStream.WriteBuffer(Pointer(s)^, Length(s));

    sStream:= TBytesStream.Create(DecodeBase64(EncString));

    sStream.SaveToFile(ExtractFilePath(Application.ExeName) + 'testlabel.pdf');
    sStream.Free;

  end
  else ShowMessage(':-(');

end;

Die zugehörige WSDL-Import Datei sieht wie folgt aus:

Delphi-Quellcode:

// ************************************************************************ //
// Die in dieser Datei deklarierten Typen wurden aus Daten der unten
// beschriebenen WSDL-Datei generiert:

// WSDL     : E:\Entwicklung\iloxx\wsdl\iloxx.wsdl
//  >Import : E:\Entwicklung\iloxx\wsdl\iloxx.wsdl>0
// Codierung : utf-8
// Codegen  : [wfSkipUnusedTypes-, wfAllowOutParameters+]
// Version: 1.0
// (09.07.2014 10:11:40 - - $Rev: 70145 $)
// ************************************************************************ //

unit iloxx;

interface

uses Soap.InvokeRegistry, Soap.SOAPHTTPClient, System.Types, Soap.XSBuiltIns;

const
  IS_OPTN = $0001;
  IS_UNBD = $0002;
  IS_UNQL = $0008;


type

  // ************************************************************************ //
  // Die folgenden Typen, auf die im WSDL-Dokument Bezug genommen wird, sind in dieser Datei
  // nicht repräsentiert. Sie sind entweder Aliase[@] anderer repräsentierter Typen oder auf sie wurde Bezug genommen,
  // aber sie sind in diesem Dokument nicht[!] deklariert. Die Typen aus letzterer Kategorie
  // sind in der Regel vordefinierten/bekannten XML- oder Embarcadero-Typen zugeordnet; sie könnten aber auf
  // ein inkorrektes WSDL-Dokument hinweisen, das einen Schematyp nicht deklariert oder importiert hat.
  // ************************************************************************ //
  // !:decimal         - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:string          - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:int             - "http://www.w3.org/2001/XMLSchema"[Gbl]

  ppvGetDailyTransactionList = class;           { "http://iloxx.de/"[Lit][GblCplx] }
  ppvGetDailyTransactionListResponse = class;   { "http://iloxx.de/"[Lit][GblCplx] }
  ppvAddOrder          = class;                 { "http://iloxx.de/"[Lit][GblCplx] }
  ppvAddOrderResponse  = class;                 { "http://iloxx.de/"[Lit][GblCplx] }
  OrderLabel           = class;                 { "http://iloxx.de/"[GblCplx] }
  ShipAddress          = class;                 { "http://iloxx.de/"[GblCplx] }
  ResponseData         = class;                 { "http://iloxx.de/"[GblCplx] }
  ppvOrderData         = class;                 { "http://iloxx.de/"[GblCplx] }
  UserCredentials      = class;                 { "http://iloxx.de/"[GblCplx] }
  ppvOrderResponse     = class;                 { "http://iloxx.de/"[GblCplx] }
  ppvOrderRequest      = class;                 { "http://iloxx.de/"[GblCplx] }
  ppvDailyTransactionResponse = class;          { "http://iloxx.de/"[GblCplx] }
  ppvDailyTransactionRequest = class;           { "http://iloxx.de/"[GblCplx] }
  ErrorData            = class;                 { "http://iloxx.de/"[GblCplx] }
  PartnerCredentials   = class;                 { "http://iloxx.de/"[GblCplx] }
  ServiceSettings      = class;                 { "http://iloxx.de/"[GblCplx] }

  {$SCOPEDENUMS ON}
  { "http://iloxx.de/"[GblSmpl] }
  LabelStartPositionType = (UpperLeft, UpperRight, LowerLeft, LowerRight);

  { "http://iloxx.de/"[GblSmpl] }
  ShipServiceType = (
      dpdNormalpaket,
      dpdNormalpaketCOD,
      dpdNormalpaketFlex,
      dpdExpress10,
      dpdExpress10COD,
      dpdExpress12,
      dpdExpress12COD,
      dpdExpress18,
      dpdExpress18COD,
      dpdExpressSamstag12,
      dpdExpressSamstag12COD,
      dpdShopRetoure,
      dpdRetourePickup
  );

  { "http://iloxx.de/"[GblSmpl] }
  CountrySettingType = (Alpha3, ISO3166);

  { "http://iloxx.de/"[GblSmpl] }
  ErrorLanguageType = (German, English);

  { "http://iloxx.de/"[GblSmpl] }
  LabelSizeType = (MultiLabel_A4, SingleLabel_A6);

  { "http://iloxx.de/"[GblSmpl] }
  ZipCodeSettingType = (ZipCodeAsSingleValue, ZipCodeInlineCityName);

  { "http://iloxx.de/"[GblSmpl] }
  DailyTransactionListType = (noSelection, DPD, Grosspaket);

  { "http://iloxx.de/"[GblSmpl] }
  SexCodeType = (NoSexCode, Male, Female);

  { "http://iloxx.de/"[GblSmpl] }
  AckType = (Success, Failure);

  { "http://iloxx.de/"[GblSmpl] }
  OrderActionType = (check, addOrder);

  {$SCOPEDENUMS OFF}

  ArrayOfErrorData = array of ErrorData;        { "http://iloxx.de/"[GblCplx] }
  ArrayOfResponseData = array of ResponseData;   { "http://iloxx.de/"[GblCplx] }


  // ************************************************************************ //
  // XML       : ppvGetDailyTransactionList, global, <complexType>
  // Namespace : http://iloxx.de/
  // Serializtn: [xoLiteralParam]
  // Info      : Wrapper
  // ************************************************************************ //
  ppvGetDailyTransactionList = class(TRemotable)
  private
    FppvDailyTransactionRequest: ppvDailyTransactionRequest;
    FppvDailyTransactionRequest_Specified: boolean;
    procedure SetppvDailyTransactionRequest(Index: Integer; const AppvDailyTransactionRequest: ppvDailyTransactionRequest);
    function  ppvDailyTransactionRequest_Specified(Index: Integer): boolean;
  public
    constructor Create; override;
    destructor Destroy; override;
  published
    property ppvDailyTransactionRequest: ppvDailyTransactionRequest  Index (IS_OPTN or IS_UNQL) read FppvDailyTransactionRequest write SetppvDailyTransactionRequest stored ppvDailyTransactionRequest_Specified;
  end;



  // ************************************************************************ //
  // XML       : ppvGetDailyTransactionListResponse, global, <complexType>
  // Namespace : http://iloxx.de/
  // Serializtn: [xoLiteralParam]
  // Info      : Wrapper
  // ************************************************************************ //
  ppvGetDailyTransactionListResponse = class(TRemotable)
  private
    FppvGetDailyTransactionListResult: ppvDailyTransactionResponse;
    FppvGetDailyTransactionListResult_Specified: boolean;
    procedure SetppvGetDailyTransactionListResult(Index: Integer; const AppvDailyTransactionResponse: ppvDailyTransactionResponse);
    function  ppvGetDailyTransactionListResult_Specified(Index: Integer): boolean;
  public
    constructor Create; override;
    destructor Destroy; override;
  published
    property ppvGetDailyTransactionListResult: ppvDailyTransactionResponse  Index (IS_OPTN or IS_UNQL) read FppvGetDailyTransactionListResult write SetppvGetDailyTransactionListResult stored ppvGetDailyTransactionListResult_Specified;
  end;



  // ************************************************************************ //
  // XML       : ppvAddOrder, global, <complexType>
  // Namespace : http://iloxx.de/
  // Serializtn: [xoLiteralParam]
  // Info      : Wrapper
  // ************************************************************************ //
  ppvAddOrder = class(TRemotable)
  private
    FppvOrderRequest: ppvOrderRequest;
    FppvOrderRequest_Specified: boolean;
    procedure SetppvOrderRequest(Index: Integer; const AppvOrderRequest: ppvOrderRequest);
    function  ppvOrderRequest_Specified(Index: Integer): boolean;
  public
    constructor Create; override;
    destructor Destroy; override;
  published
    property ppvOrderRequest: ppvOrderRequest  Index (IS_OPTN or IS_UNQL) read FppvOrderRequest write SetppvOrderRequest stored ppvOrderRequest_Specified;
  end;



  // ************************************************************************ //
  // XML       : ppvAddOrderResponse, global, <complexType>
  // Namespace : http://iloxx.de/
  // Serializtn: [xoLiteralParam]
  // Info      : Wrapper
  // ************************************************************************ //
  ppvAddOrderResponse = class(TRemotable)
  private
    FppvAddOrderResult: ppvOrderResponse;
    FppvAddOrderResult_Specified: boolean;
    procedure SetppvAddOrderResult(Index: Integer; const AppvOrderResponse: ppvOrderResponse);
    function  ppvAddOrderResult_Specified(Index: Integer): boolean;
  public
    constructor Create; override;
    destructor Destroy; override;
  published
    property ppvAddOrderResult: ppvOrderResponse  Index (IS_OPTN or IS_UNQL) read FppvAddOrderResult write SetppvAddOrderResult stored ppvAddOrderResult_Specified;
  end;



  // ************************************************************************ //
  // XML       : OrderLabel, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  OrderLabel = class(TRemotable)
  private
    FLabelSize: LabelSizeType;
    FLabelStartPosition: LabelStartPositionType;
  published
    property LabelSize:          LabelSizeType           Index (IS_UNQL) read FLabelSize write FLabelSize;
    property LabelStartPosition: LabelStartPositionType  Index (IS_UNQL) read FLabelStartPosition write FLabelStartPosition;
  end;

  ArrayOfPpvOrderData = array of ppvOrderData;   { "http://iloxx.de/"[GblCplx] }


  // ************************************************************************ //
  // XML       : ShipAddress, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  ShipAddress = class(TRemotable)
  private
    FCompany: string;
    FCompany_Specified: boolean;
    FSexCode: SexCodeType;
    FName_: string;
    FName__Specified: boolean;
    FStreet: string;
    FStreet_Specified: boolean;
    FZipCode: string;
    FZipCode_Specified: boolean;
    FCity: string;
    FCity_Specified: boolean;
    FState: string;
    FState_Specified: boolean;
    FCountry: string;
    FCountry_Specified: boolean;
    FPhone: string;
    FPhone_Specified: boolean;
    FMail: string;
    FMail_Specified: boolean;
    procedure SetCompany(Index: Integer; const Astring: string);
    function  Company_Specified(Index: Integer): boolean;
    procedure SetName_(Index: Integer; const Astring: string);
    function  Name__Specified(Index: Integer): boolean;
    procedure SetStreet(Index: Integer; const Astring: string);
    function  Street_Specified(Index: Integer): boolean;
    procedure SetZipCode(Index: Integer; const Astring: string);
    function  ZipCode_Specified(Index: Integer): boolean;
    procedure SetCity(Index: Integer; const Astring: string);
    function  City_Specified(Index: Integer): boolean;
    procedure SetState(Index: Integer; const Astring: string);
    function  State_Specified(Index: Integer): boolean;
    procedure SetCountry(Index: Integer; const Astring: string);
    function  Country_Specified(Index: Integer): boolean;
    procedure SetPhone(Index: Integer; const Astring: string);
    function  Phone_Specified(Index: Integer): boolean;
    procedure SetMail(Index: Integer; const Astring: string);
    function  Mail_Specified(Index: Integer): boolean;
  published
    property Company: string       Index (IS_OPTN or IS_UNQL) read FCompany write SetCompany stored Company_Specified;
    property SexCode: SexCodeType  Index (IS_UNQL) read FSexCode write FSexCode;
    property Name_:   string       Index (IS_OPTN or IS_UNQL) read FName_ write SetName_ stored Name__Specified;
    property Street:  string       Index (IS_OPTN or IS_UNQL) read FStreet write SetStreet stored Street_Specified;
    property ZipCode: string       Index (IS_OPTN or IS_UNQL) read FZipCode write SetZipCode stored ZipCode_Specified;
    property City:    string       Index (IS_OPTN or IS_UNQL) read FCity write SetCity stored City_Specified;
    property State:   string       Index (IS_OPTN or IS_UNQL) read FState write SetState stored State_Specified;
    property Country: string       Index (IS_OPTN or IS_UNQL) read FCountry write SetCountry stored Country_Specified;
    property Phone:   string       Index (IS_OPTN or IS_UNQL) read FPhone write SetPhone stored Phone_Specified;
    property Mail:    string       Index (IS_OPTN or IS_UNQL) read FMail write SetMail stored Mail_Specified;
  end;



  // ************************************************************************ //
  // XML       : ResponseData, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  ResponseData = class(TRemotable)
  private
    FPartnerOrderReference: string;
    FPartnerOrderReference_Specified: boolean;
    FParcelNumber: string;
    FParcelNumber_Specified: boolean;
    procedure SetPartnerOrderReference(Index: Integer; const Astring: string);
    function  PartnerOrderReference_Specified(Index: Integer): boolean;
    procedure SetParcelNumber(Index: Integer; const Astring: string);
    function  ParcelNumber_Specified(Index: Integer): boolean;
  published
    property PartnerOrderReference: string  Index (IS_OPTN or IS_UNQL) read FPartnerOrderReference write SetPartnerOrderReference stored PartnerOrderReference_Specified;
    property ParcelNumber:          string  Index (IS_OPTN or IS_UNQL) read FParcelNumber write SetParcelNumber stored ParcelNumber_Specified;
  end;



  // ************************************************************************ //
  // XML       : ppvOrderData, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  ppvOrderData = class(TRemotable)
  private
    FPartnerOrderReference: string;
    FPartnerOrderReference_Specified: boolean;
    FCustomer: string;
    FCustomer_Specified: boolean;
    FReference: string;
    FReference_Specified: boolean;
    FContent: string;
    FContent_Specified: boolean;
    FWeight: TXSDecimal;
    FShipService: ShipServiceType;
    FCODAmount: TXSDecimal;
    FShipAddress: ShipAddress;
    FShipAddress_Specified: boolean;
    FTrackURL: string;
    FTrackURL_Specified: boolean;
    procedure SetPartnerOrderReference(Index: Integer; const Astring: string);
    function  PartnerOrderReference_Specified(Index: Integer): boolean;
    procedure SetCustomer(Index: Integer; const Astring: string);
    function  Customer_Specified(Index: Integer): boolean;
    procedure SetReference(Index: Integer; const Astring: string);
    function  Reference_Specified(Index: Integer): boolean;
    procedure SetContent(Index: Integer; const Astring: string);
    function  Content_Specified(Index: Integer): boolean;
    procedure SetShipAddress(Index: Integer; const AShipAddress: ShipAddress);
    function  ShipAddress_Specified(Index: Integer): boolean;
    procedure SetTrackURL(Index: Integer; const Astring: string);
    function  TrackURL_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property PartnerOrderReference: string           Index (IS_OPTN or IS_UNQL) read FPartnerOrderReference write SetPartnerOrderReference stored PartnerOrderReference_Specified;
    property Customer:              string           Index (IS_OPTN or IS_UNQL) read FCustomer write SetCustomer stored Customer_Specified;
    property Reference:             string           Index (IS_OPTN or IS_UNQL) read FReference write SetReference stored Reference_Specified;
    property Content:               string           Index (IS_OPTN or IS_UNQL) read FContent write SetContent stored Content_Specified;
    property Weight:                TXSDecimal       Index (IS_UNQL) read FWeight write FWeight;
    property ShipService:           ShipServiceType  Index (IS_UNQL) read FShipService write FShipService;
    property CODAmount:             TXSDecimal       Index (IS_UNQL) read FCODAmount write FCODAmount;
    property ShipAddress:           ShipAddress      Index (IS_OPTN or IS_UNQL) read FShipAddress write SetShipAddress stored ShipAddress_Specified;
    property TrackURL:              string           Index (IS_OPTN or IS_UNQL) read FTrackURL write SetTrackURL stored TrackURL_Specified;
  end;



  // ************************************************************************ //
  // XML       : UserCredentials, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  UserCredentials = class(TRemotable)
  private
    FUserID: Integer;
    FUserToken: string;
    FUserToken_Specified: boolean;
    procedure SetUserToken(Index: Integer; const Astring: string);
    function  UserToken_Specified(Index: Integer): boolean;
  published
    property UserID:    Integer  Index (IS_UNQL) read FUserID write FUserID;
    property UserToken: string   Index (IS_OPTN or IS_UNQL) read FUserToken write SetUserToken stored UserToken_Specified;
  end;



  // ************************************************************************ //
  // XML       : ppvOrderResponse, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  ppvOrderResponse = class(TRemotable)
  private
    FVersion: Integer;
    FAck: AckType;
    FLabelPDFStream: string;
    FLabelPDFStream_Specified: boolean;
    FResponseDataArray: ArrayOfResponseData;
    FResponseDataArray_Specified: boolean;
    FErrorDataArray: ArrayOfErrorData;
    FErrorDataArray_Specified: boolean;
    procedure SetLabelPDFStream(Index: Integer; const Astring: string);
    function  LabelPDFStream_Specified(Index: Integer): boolean;
    procedure SetResponseDataArray(Index: Integer; const AArrayOfResponseData: ArrayOfResponseData);
    function  ResponseDataArray_Specified(Index: Integer): boolean;
    procedure SetErrorDataArray(Index: Integer; const AArrayOfErrorData: ArrayOfErrorData);
    function  ErrorDataArray_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property Version:           Integer              Index (IS_UNQL) read FVersion write FVersion;
    property Ack:               AckType              Index (IS_UNQL) read FAck write FAck;
    property LabelPDFStream:    string               Index (IS_OPTN or IS_UNQL) read FLabelPDFStream write SetLabelPDFStream stored LabelPDFStream_Specified;
    property ResponseDataArray: ArrayOfResponseData  Index (IS_OPTN or IS_UNQL) read FResponseDataArray write SetResponseDataArray stored ResponseDataArray_Specified;
    property ErrorDataArray:    ArrayOfErrorData     Index (IS_OPTN or IS_UNQL) read FErrorDataArray write SetErrorDataArray stored ErrorDataArray_Specified;
  end;



  // ************************************************************************ //
  // XML       : ppvOrderRequest, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  ppvOrderRequest = class(TRemotable)
  private
    FVersion: Integer;
    FOrderAction: OrderActionType;
    FServiceSettings: ServiceSettings;
    FServiceSettings_Specified: boolean;
    FPartnerCredentials: PartnerCredentials;
    FPartnerCredentials_Specified: boolean;
    FUserCredentials: UserCredentials;
    FUserCredentials_Specified: boolean;
    FOrderLabel: OrderLabel;
    FOrderLabel_Specified: boolean;
    FShipDate: string;
    FShipDate_Specified: boolean;
    FppvOrderDataArray: ArrayOfPpvOrderData;
    FppvOrderDataArray_Specified: boolean;
    procedure SetServiceSettings(Index: Integer; const AServiceSettings: ServiceSettings);
    function  ServiceSettings_Specified(Index: Integer): boolean;
    procedure SetPartnerCredentials(Index: Integer; const APartnerCredentials: PartnerCredentials);
    function  PartnerCredentials_Specified(Index: Integer): boolean;
    procedure SetUserCredentials(Index: Integer; const AUserCredentials: UserCredentials);
    function  UserCredentials_Specified(Index: Integer): boolean;
    procedure SetOrderLabel(Index: Integer; const AOrderLabel: OrderLabel);
    function  OrderLabel_Specified(Index: Integer): boolean;
    procedure SetShipDate(Index: Integer; const Astring: string);
    function  ShipDate_Specified(Index: Integer): boolean;
    procedure SetppvOrderDataArray(Index: Integer; const AArrayOfPpvOrderData: ArrayOfPpvOrderData);
    function  ppvOrderDataArray_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property Version:            Integer              Index (IS_UNQL) read FVersion write FVersion;
    property OrderAction:        OrderActionType      Index (IS_UNQL) read FOrderAction write FOrderAction;
    property ServiceSettings:    ServiceSettings      Index (IS_OPTN or IS_UNQL) read FServiceSettings write SetServiceSettings stored ServiceSettings_Specified;
    property PartnerCredentials: PartnerCredentials   Index (IS_OPTN or IS_UNQL) read FPartnerCredentials write SetPartnerCredentials stored PartnerCredentials_Specified;
    property UserCredentials:    UserCredentials      Index (IS_OPTN or IS_UNQL) read FUserCredentials write SetUserCredentials stored UserCredentials_Specified;
    property OrderLabel:         OrderLabel           Index (IS_OPTN or IS_UNQL) read FOrderLabel write SetOrderLabel stored OrderLabel_Specified;
    property ShipDate:           string               Index (IS_OPTN or IS_UNQL) read FShipDate write SetShipDate stored ShipDate_Specified;
    property ppvOrderDataArray:  ArrayOfPpvOrderData  Index (IS_OPTN or IS_UNQL) read FppvOrderDataArray write SetppvOrderDataArray stored ppvOrderDataArray_Specified;
  end;



  // ************************************************************************ //
  // XML       : ppvDailyTransactionResponse, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  ppvDailyTransactionResponse = class(TRemotable)
  private
    FVersion: Integer;
    FAck: AckType;
    FTransactionListPDFStream: string;
    FTransactionListPDFStream_Specified: boolean;
    FTransactionListPDFUrl: string;
    FTransactionListPDFUrl_Specified: boolean;
    FErrorDataArray: ArrayOfErrorData;
    FErrorDataArray_Specified: boolean;
    procedure SetTransactionListPDFStream(Index: Integer; const Astring: string);
    function  TransactionListPDFStream_Specified(Index: Integer): boolean;
    procedure SetTransactionListPDFUrl(Index: Integer; const Astring: string);
    function  TransactionListPDFUrl_Specified(Index: Integer): boolean;
    procedure SetErrorDataArray(Index: Integer; const AArrayOfErrorData: ArrayOfErrorData);
    function  ErrorDataArray_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property Version:                  Integer           Index (IS_UNQL) read FVersion write FVersion;
    property Ack:                      AckType           Index (IS_UNQL) read FAck write FAck;
    property TransactionListPDFStream: string            Index (IS_OPTN or IS_UNQL) read FTransactionListPDFStream write SetTransactionListPDFStream stored TransactionListPDFStream_Specified;
    property TransactionListPDFUrl:    string            Index (IS_OPTN or IS_UNQL) read FTransactionListPDFUrl write SetTransactionListPDFUrl stored TransactionListPDFUrl_Specified;
    property ErrorDataArray:           ArrayOfErrorData  Index (IS_OPTN or IS_UNQL) read FErrorDataArray write SetErrorDataArray stored ErrorDataArray_Specified;
  end;



  // ************************************************************************ //
  // XML       : ppvDailyTransactionRequest, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  ppvDailyTransactionRequest = class(TRemotable)
  private
    FVersion: Integer;
    FPartnerCredentials: PartnerCredentials;
    FPartnerCredentials_Specified: boolean;
    FUserCredentials: UserCredentials;
    FUserCredentials_Specified: boolean;
    FTransactionListDate: string;
    FTransactionListDate_Specified: boolean;
    FTransactionListType: DailyTransactionListType;
    procedure SetPartnerCredentials(Index: Integer; const APartnerCredentials: PartnerCredentials);
    function  PartnerCredentials_Specified(Index: Integer): boolean;
    procedure SetUserCredentials(Index: Integer; const AUserCredentials: UserCredentials);
    function  UserCredentials_Specified(Index: Integer): boolean;
    procedure SetTransactionListDate(Index: Integer; const Astring: string);
    function  TransactionListDate_Specified(Index: Integer): boolean;
  public
    destructor Destroy; override;
  published
    property Version:             Integer                   Index (IS_UNQL) read FVersion write FVersion;
    property PartnerCredentials:  PartnerCredentials        Index (IS_OPTN or IS_UNQL) read FPartnerCredentials write SetPartnerCredentials stored PartnerCredentials_Specified;
    property UserCredentials:     UserCredentials           Index (IS_OPTN or IS_UNQL) read FUserCredentials write SetUserCredentials stored UserCredentials_Specified;
    property TransactionListDate: string                    Index (IS_OPTN or IS_UNQL) read FTransactionListDate write SetTransactionListDate stored TransactionListDate_Specified;
    property TransactionListType: DailyTransactionListType  Index (IS_UNQL) read FTransactionListType write FTransactionListType;
  end;



  // ************************************************************************ //
  // XML       : ErrorData, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  ErrorData = class(TRemotable)
  private
    FErrorID: Integer;
    FErrorMsg: string;
    FErrorMsg_Specified: boolean;
    procedure SetErrorMsg(Index: Integer; const Astring: string);
    function  ErrorMsg_Specified(Index: Integer): boolean;
  published
    property ErrorID:  Integer  Index (IS_UNQL) read FErrorID write FErrorID;
    property ErrorMsg: string   Index (IS_OPTN or IS_UNQL) read FErrorMsg write SetErrorMsg stored ErrorMsg_Specified;
  end;



  // ************************************************************************ //
  // XML       : PartnerCredentials, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  PartnerCredentials = class(TRemotable)
  private
    FPartnerName: string;
    FPartnerName_Specified: boolean;
    FPartnerKey: string;
    FPartnerKey_Specified: boolean;
    procedure SetPartnerName(Index: Integer; const Astring: string);
    function  PartnerName_Specified(Index: Integer): boolean;
    procedure SetPartnerKey(Index: Integer; const Astring: string);
    function  PartnerKey_Specified(Index: Integer): boolean;
  published
    property PartnerName: string  Index (IS_OPTN or IS_UNQL) read FPartnerName write SetPartnerName stored PartnerName_Specified;
    property PartnerKey:  string  Index (IS_OPTN or IS_UNQL) read FPartnerKey write SetPartnerKey stored PartnerKey_Specified;
  end;



  // ************************************************************************ //
  // XML       : ServiceSettings, global, <complexType>
  // Namespace : http://iloxx.de/
  // ************************************************************************ //
  ServiceSettings = class(TRemotable)
  private
    FErrorLanguage: ErrorLanguageType;
    FCountrySettings: CountrySettingType;
    FZipCodeSetting: ZipCodeSettingType;
  published
    property ErrorLanguage:   ErrorLanguageType   Index (IS_UNQL) read FErrorLanguage write FErrorLanguage;
    property CountrySettings: CountrySettingType  Index (IS_UNQL) read FCountrySettings write FCountrySettings;
    property ZipCodeSetting:  ZipCodeSettingType  Index (IS_UNQL) read FZipCodeSetting write FZipCodeSetting;
  end;


  // ************************************************************************ //
  // Namespace : http://iloxx.de/
  // soapAction: http://iloxx.de/%operationName%
  // Transport : http://schemas.xmlsoap.org/soap/http
  // Stil     : rpc
  // Verwenden von       : literal
  // Bindung   : ppvapiSoap
  // Service   : ppvapiSoap
  // Port      : ppvapiSoapPort
  // URL       : http://qa.www.iloxx.de/iloxxapi/ppvapi.asmx
  // ************************************************************************ //
  ppvapiSoap = interface(IInvokable)
  ['{83F99BFC-CA1B-1248-1861-9C271EA1A7EE}']

    // Entpacken nicht möglich:
    //     - Eingabe-Part verweist auf kein Element
    //     - Ausgabe-Part verweist auf kein Element
    function  ppvAddOrder(const ppvAddOrder: ppvAddOrder): ppvAddOrderResponse; stdcall;

    // Entpacken nicht möglich:
    //     - Eingabe-Part verweist auf kein Element
    //     - Ausgabe-Part verweist auf kein Element
    function  ppvGetDailyTransactionList(const ppvGetDailyTransactionList: ppvGetDailyTransactionList): ppvGetDailyTransactionListResponse; stdcall;
  end;

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


implementation
  uses System.SysUtils;

function GetppvapiSoap(UseWSDL: Boolean; Addr: string; HTTPRIO: THTTPRIO): ppvapiSoap;
const
  defWSDL = 'E:\Entwicklung\iloxx\wsdl\iloxx.wsdl';
  defURL  = 'http://qa.www.iloxx.de/iloxxapi/ppvapi.asmx';
  defSvc  = 'ppvapiSoap';
  defPrt  = 'ppvapiSoapPort';
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 ppvapiSoap);
    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 ppvGetDailyTransactionList.Create;
begin
  inherited Create;
  FSerializationOptions := [xoLiteralParam];
end;

destructor ppvGetDailyTransactionList.Destroy;
begin
  System.SysUtils.FreeAndNil(FppvDailyTransactionRequest);
  inherited Destroy;
end;

procedure ppvGetDailyTransactionList.SetppvDailyTransactionRequest(Index: Integer; const AppvDailyTransactionRequest: ppvDailyTransactionRequest);
begin
  FppvDailyTransactionRequest := AppvDailyTransactionRequest;
  FppvDailyTransactionRequest_Specified := True;
end;

function ppvGetDailyTransactionList.ppvDailyTransactionRequest_Specified(Index: Integer): boolean;
begin
  Result := FppvDailyTransactionRequest_Specified;
end;

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

destructor ppvGetDailyTransactionListResponse.Destroy;
begin
  System.SysUtils.FreeAndNil(FppvGetDailyTransactionListResult);
  inherited Destroy;
end;

procedure ppvGetDailyTransactionListResponse.SetppvGetDailyTransactionListResult(Index: Integer; const AppvDailyTransactionResponse: ppvDailyTransactionResponse);
begin
  FppvGetDailyTransactionListResult := AppvDailyTransactionResponse;
  FppvGetDailyTransactionListResult_Specified := True;
end;

function ppvGetDailyTransactionListResponse.ppvGetDailyTransactionListResult_Specified(Index: Integer): boolean;
begin
  Result := FppvGetDailyTransactionListResult_Specified;
end;

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

destructor ppvAddOrder.Destroy;
begin
  System.SysUtils.FreeAndNil(FppvOrderRequest);
  inherited Destroy;
end;

procedure ppvAddOrder.SetppvOrderRequest(Index: Integer; const AppvOrderRequest: ppvOrderRequest);
begin
  FppvOrderRequest := AppvOrderRequest;
  FppvOrderRequest_Specified := True;
end;

function ppvAddOrder.ppvOrderRequest_Specified(Index: Integer): boolean;
begin
  Result := FppvOrderRequest_Specified;
end;

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

destructor ppvAddOrderResponse.Destroy;
begin
  System.SysUtils.FreeAndNil(FppvAddOrderResult);
  inherited Destroy;
end;

procedure ppvAddOrderResponse.SetppvAddOrderResult(Index: Integer; const AppvOrderResponse: ppvOrderResponse);
begin
  FppvAddOrderResult := AppvOrderResponse;
  FppvAddOrderResult_Specified := True;
end;

function ppvAddOrderResponse.ppvAddOrderResult_Specified(Index: Integer): boolean;
begin
  Result := FppvAddOrderResult_Specified;
end;

procedure ShipAddress.SetCompany(Index: Integer; const Astring: string);
begin
  FCompany := Astring;
  FCompany_Specified := True;
end;

function ShipAddress.Company_Specified(Index: Integer): boolean;
begin
  Result := FCompany_Specified;
end;

procedure ShipAddress.SetName_(Index: Integer; const Astring: string);
begin
  FName_ := Astring;
  FName__Specified := True;
end;

function ShipAddress.Name__Specified(Index: Integer): boolean;
begin
  Result := FName__Specified;
end;

procedure ShipAddress.SetStreet(Index: Integer; const Astring: string);
begin
  FStreet := Astring;
  FStreet_Specified := True;
end;

function ShipAddress.Street_Specified(Index: Integer): boolean;
begin
  Result := FStreet_Specified;
end;

procedure ShipAddress.SetZipCode(Index: Integer; const Astring: string);
begin
  FZipCode := Astring;
  FZipCode_Specified := True;
end;

function ShipAddress.ZipCode_Specified(Index: Integer): boolean;
begin
  Result := FZipCode_Specified;
end;

procedure ShipAddress.SetCity(Index: Integer; const Astring: string);
begin
  FCity := Astring;
  FCity_Specified := True;
end;

function ShipAddress.City_Specified(Index: Integer): boolean;
begin
  Result := FCity_Specified;
end;

procedure ShipAddress.SetState(Index: Integer; const Astring: string);
begin
  FState := Astring;
  FState_Specified := True;
end;

function ShipAddress.State_Specified(Index: Integer): boolean;
begin
  Result := FState_Specified;
end;

procedure ShipAddress.SetCountry(Index: Integer; const Astring: string);
begin
  FCountry := Astring;
  FCountry_Specified := True;
end;

function ShipAddress.Country_Specified(Index: Integer): boolean;
begin
  Result := FCountry_Specified;
end;

procedure ShipAddress.SetPhone(Index: Integer; const Astring: string);
begin
  FPhone := Astring;
  FPhone_Specified := True;
end;

function ShipAddress.Phone_Specified(Index: Integer): boolean;
begin
  Result := FPhone_Specified;
end;

procedure ShipAddress.SetMail(Index: Integer; const Astring: string);
begin
  FMail := Astring;
  FMail_Specified := True;
end;

function ShipAddress.Mail_Specified(Index: Integer): boolean;
begin
  Result := FMail_Specified;
end;

procedure ResponseData.SetPartnerOrderReference(Index: Integer; const Astring: string);
begin
  FPartnerOrderReference := Astring;
  FPartnerOrderReference_Specified := True;
end;

function ResponseData.PartnerOrderReference_Specified(Index: Integer): boolean;
begin
  Result := FPartnerOrderReference_Specified;
end;

procedure ResponseData.SetParcelNumber(Index: Integer; const Astring: string);
begin
  FParcelNumber := Astring;
  FParcelNumber_Specified := True;
end;

function ResponseData.ParcelNumber_Specified(Index: Integer): boolean;
begin
  Result := FParcelNumber_Specified;
end;

destructor ppvOrderData.Destroy;
begin
  System.SysUtils.FreeAndNil(FWeight);
  System.SysUtils.FreeAndNil(FCODAmount);
  System.SysUtils.FreeAndNil(FShipAddress);
  inherited Destroy;
end;

procedure ppvOrderData.SetPartnerOrderReference(Index: Integer; const Astring: string);
begin
  FPartnerOrderReference := Astring;
  FPartnerOrderReference_Specified := True;
end;

function ppvOrderData.PartnerOrderReference_Specified(Index: Integer): boolean;
begin
  Result := FPartnerOrderReference_Specified;
end;

procedure ppvOrderData.SetCustomer(Index: Integer; const Astring: string);
begin
  FCustomer := Astring;
  FCustomer_Specified := True;
end;

function ppvOrderData.Customer_Specified(Index: Integer): boolean;
begin
  Result := FCustomer_Specified;
end;

procedure ppvOrderData.SetReference(Index: Integer; const Astring: string);
begin
  FReference := Astring;
  FReference_Specified := True;
end;

function ppvOrderData.Reference_Specified(Index: Integer): boolean;
begin
  Result := FReference_Specified;
end;

procedure ppvOrderData.SetContent(Index: Integer; const Astring: string);
begin
  FContent := Astring;
  FContent_Specified := True;
end;

function ppvOrderData.Content_Specified(Index: Integer): boolean;
begin
  Result := FContent_Specified;
end;

procedure ppvOrderData.SetShipAddress(Index: Integer; const AShipAddress: ShipAddress);
begin
  FShipAddress := AShipAddress;
  FShipAddress_Specified := True;
end;

function ppvOrderData.ShipAddress_Specified(Index: Integer): boolean;
begin
  Result := FShipAddress_Specified;
end;

procedure ppvOrderData.SetTrackURL(Index: Integer; const Astring: string);
begin
  FTrackURL := Astring;
  FTrackURL_Specified := True;
end;

function ppvOrderData.TrackURL_Specified(Index: Integer): boolean;
begin
  Result := FTrackURL_Specified;
end;

procedure UserCredentials.SetUserToken(Index: Integer; const Astring: string);
begin
  FUserToken := Astring;
  FUserToken_Specified := True;
end;

function UserCredentials.UserToken_Specified(Index: Integer): boolean;
begin
  Result := FUserToken_Specified;
end;

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

procedure ppvOrderResponse.SetLabelPDFStream(Index: Integer; const Astring: string);
begin
  FLabelPDFStream := Astring;
  FLabelPDFStream_Specified := True;
end;

function ppvOrderResponse.LabelPDFStream_Specified(Index: Integer): boolean;
begin
  Result := FLabelPDFStream_Specified;
end;

procedure ppvOrderResponse.SetResponseDataArray(Index: Integer; const AArrayOfResponseData: ArrayOfResponseData);
begin
  FResponseDataArray := AArrayOfResponseData;
  FResponseDataArray_Specified := True;
end;

function ppvOrderResponse.ResponseDataArray_Specified(Index: Integer): boolean;
begin
  Result := FResponseDataArray_Specified;
end;

procedure ppvOrderResponse.SetErrorDataArray(Index: Integer; const AArrayOfErrorData: ArrayOfErrorData);
begin
  FErrorDataArray := AArrayOfErrorData;
  FErrorDataArray_Specified := True;
end;

function ppvOrderResponse.ErrorDataArray_Specified(Index: Integer): boolean;
begin
  Result := FErrorDataArray_Specified;
end;

destructor ppvOrderRequest.Destroy;
var
  I: Integer;
begin
  for I := 0 to System.Length(FppvOrderDataArray)-1 do
    System.SysUtils.FreeAndNil(FppvOrderDataArray[I]);
  System.SetLength(FppvOrderDataArray, 0);
  System.SysUtils.FreeAndNil(FServiceSettings);
  System.SysUtils.FreeAndNil(FPartnerCredentials);
  System.SysUtils.FreeAndNil(FUserCredentials);
  System.SysUtils.FreeAndNil(FOrderLabel);
  inherited Destroy;
end;

procedure ppvOrderRequest.SetServiceSettings(Index: Integer; const AServiceSettings: ServiceSettings);
begin
  FServiceSettings := AServiceSettings;
  FServiceSettings_Specified := True;
end;

function ppvOrderRequest.ServiceSettings_Specified(Index: Integer): boolean;
begin
  Result := FServiceSettings_Specified;
end;

procedure ppvOrderRequest.SetPartnerCredentials(Index: Integer; const APartnerCredentials: PartnerCredentials);
begin
  FPartnerCredentials := APartnerCredentials;
  FPartnerCredentials_Specified := True;
end;

function ppvOrderRequest.PartnerCredentials_Specified(Index: Integer): boolean;
begin
  Result := FPartnerCredentials_Specified;
end;

procedure ppvOrderRequest.SetUserCredentials(Index: Integer; const AUserCredentials: UserCredentials);
begin
  FUserCredentials := AUserCredentials;
  FUserCredentials_Specified := True;
end;

function ppvOrderRequest.UserCredentials_Specified(Index: Integer): boolean;
begin
  Result := FUserCredentials_Specified;
end;

procedure ppvOrderRequest.SetOrderLabel(Index: Integer; const AOrderLabel: OrderLabel);
begin
  FOrderLabel := AOrderLabel;
  FOrderLabel_Specified := True;
end;

function ppvOrderRequest.OrderLabel_Specified(Index: Integer): boolean;
begin
  Result := FOrderLabel_Specified;
end;

procedure ppvOrderRequest.SetShipDate(Index: Integer; const Astring: string);
begin
  FShipDate := Astring;
  FShipDate_Specified := True;
end;

function ppvOrderRequest.ShipDate_Specified(Index: Integer): boolean;
begin
  Result := FShipDate_Specified;
end;

procedure ppvOrderRequest.SetppvOrderDataArray(Index: Integer; const AArrayOfPpvOrderData: ArrayOfPpvOrderData);
begin
  FppvOrderDataArray := AArrayOfPpvOrderData;
  FppvOrderDataArray_Specified := True;
end;

function ppvOrderRequest.ppvOrderDataArray_Specified(Index: Integer): boolean;
begin
  Result := FppvOrderDataArray_Specified;
end;

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

procedure ppvDailyTransactionResponse.SetTransactionListPDFStream(Index: Integer; const Astring: string);
begin
  FTransactionListPDFStream := Astring;
  FTransactionListPDFStream_Specified := True;
end;

function ppvDailyTransactionResponse.TransactionListPDFStream_Specified(Index: Integer): boolean;
begin
  Result := FTransactionListPDFStream_Specified;
end;

procedure ppvDailyTransactionResponse.SetTransactionListPDFUrl(Index: Integer; const Astring: string);
begin
  FTransactionListPDFUrl := Astring;
  FTransactionListPDFUrl_Specified := True;
end;

function ppvDailyTransactionResponse.TransactionListPDFUrl_Specified(Index: Integer): boolean;
begin
  Result := FTransactionListPDFUrl_Specified;
end;

procedure ppvDailyTransactionResponse.SetErrorDataArray(Index: Integer; const AArrayOfErrorData: ArrayOfErrorData);
begin
  FErrorDataArray := AArrayOfErrorData;
  FErrorDataArray_Specified := True;
end;

function ppvDailyTransactionResponse.ErrorDataArray_Specified(Index: Integer): boolean;
begin
  Result := FErrorDataArray_Specified;
end;

destructor ppvDailyTransactionRequest.Destroy;
begin
  System.SysUtils.FreeAndNil(FPartnerCredentials);
  System.SysUtils.FreeAndNil(FUserCredentials);
  inherited Destroy;
end;

procedure ppvDailyTransactionRequest.SetPartnerCredentials(Index: Integer; const APartnerCredentials: PartnerCredentials);
begin
  FPartnerCredentials := APartnerCredentials;
  FPartnerCredentials_Specified := True;
end;

function ppvDailyTransactionRequest.PartnerCredentials_Specified(Index: Integer): boolean;
begin
  Result := FPartnerCredentials_Specified;
end;

procedure ppvDailyTransactionRequest.SetUserCredentials(Index: Integer; const AUserCredentials: UserCredentials);
begin
  FUserCredentials := AUserCredentials;
  FUserCredentials_Specified := True;
end;

function ppvDailyTransactionRequest.UserCredentials_Specified(Index: Integer): boolean;
begin
  Result := FUserCredentials_Specified;
end;

procedure ppvDailyTransactionRequest.SetTransactionListDate(Index: Integer; const Astring: string);
begin
  FTransactionListDate := Astring;
  FTransactionListDate_Specified := True;
end;

function ppvDailyTransactionRequest.TransactionListDate_Specified(Index: Integer): boolean;
begin
  Result := FTransactionListDate_Specified;
end;

procedure ErrorData.SetErrorMsg(Index: Integer; const Astring: string);
begin
  FErrorMsg := Astring;
  FErrorMsg_Specified := True;
end;

function ErrorData.ErrorMsg_Specified(Index: Integer): boolean;
begin
  Result := FErrorMsg_Specified;
end;

procedure PartnerCredentials.SetPartnerName(Index: Integer; const Astring: string);
begin
  FPartnerName := Astring;
  FPartnerName_Specified := True;
end;

function PartnerCredentials.PartnerName_Specified(Index: Integer): boolean;
begin
  Result := FPartnerName_Specified;
end;

procedure PartnerCredentials.SetPartnerKey(Index: Integer; const Astring: string);
begin
  FPartnerKey := Astring;
  FPartnerKey_Specified := True;
end;

function PartnerCredentials.PartnerKey_Specified(Index: Integer): boolean;
begin
  Result := FPartnerKey_Specified;
end;

initialization
  { ppvapiSoap }
  InvRegistry.RegisterInterface(TypeInfo(ppvapiSoap), 'http://iloxx.de/', 'utf-8');
  InvRegistry.RegisterDefaultSOAPAction(TypeInfo(ppvapiSoap), 'http://iloxx.de/%operationName%');
  InvRegistry.RegisterInvokeOptions(TypeInfo(ppvapiSoap), ioLiteral);
  { ppvapiSoap.ppvAddOrder }
  InvRegistry.RegisterParamInfo(TypeInfo(ppvapiSoap), 'ppvAddOrder', 'ppvAddOrder', '',
                                '[Namespace="http://iloxx.de/"]');
  InvRegistry.RegisterParamInfo(TypeInfo(ppvapiSoap), 'ppvAddOrder', 'ppvAddOrderResponse', '',
                                '[Namespace="http://iloxx.de/"]');
  { ppvapiSoap.ppvGetDailyTransactionList }
  InvRegistry.RegisterParamInfo(TypeInfo(ppvapiSoap), 'ppvGetDailyTransactionList', 'ppvGetDailyTransactionList', '',
                                '[Namespace="http://iloxx.de/"]');
  InvRegistry.RegisterParamInfo(TypeInfo(ppvapiSoap), 'ppvGetDailyTransactionList', 'ppvGetDailyTransactionListResponse', '',
                                '[Namespace="http://iloxx.de/"]');
  RemClassRegistry.RegisterXSInfo(TypeInfo(LabelStartPositionType), 'http://iloxx.de/', 'LabelStartPositionType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ShipServiceType), 'http://iloxx.de/', 'ShipServiceType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(CountrySettingType), 'http://iloxx.de/', 'CountrySettingType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ErrorLanguageType), 'http://iloxx.de/', 'ErrorLanguageType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(LabelSizeType), 'http://iloxx.de/', 'LabelSizeType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ZipCodeSettingType), 'http://iloxx.de/', 'ZipCodeSettingType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfErrorData), 'http://iloxx.de/', 'ArrayOfErrorData');
  RemClassRegistry.RegisterXSInfo(TypeInfo(DailyTransactionListType), 'http://iloxx.de/', 'DailyTransactionListType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(SexCodeType), 'http://iloxx.de/', 'SexCodeType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfResponseData), 'http://iloxx.de/', 'ArrayOfResponseData');
  RemClassRegistry.RegisterXSInfo(TypeInfo(AckType), 'http://iloxx.de/', 'AckType');
  RemClassRegistry.RegisterXSClass(ppvGetDailyTransactionList, 'http://iloxx.de/', 'ppvGetDailyTransactionList');
  RemClassRegistry.RegisterSerializeOptions(ppvGetDailyTransactionList, [xoLiteralParam]);
  RemClassRegistry.RegisterXSClass(ppvGetDailyTransactionListResponse, 'http://iloxx.de/', 'ppvGetDailyTransactionListResponse');
  RemClassRegistry.RegisterSerializeOptions(ppvGetDailyTransactionListResponse, [xoLiteralParam]);
  RemClassRegistry.RegisterXSClass(ppvAddOrder, 'http://iloxx.de/', 'ppvAddOrder');
  RemClassRegistry.RegisterSerializeOptions(ppvAddOrder, [xoLiteralParam]);
  RemClassRegistry.RegisterXSClass(ppvAddOrderResponse, 'http://iloxx.de/', 'ppvAddOrderResponse');
  RemClassRegistry.RegisterSerializeOptions(ppvAddOrderResponse, [xoLiteralParam]);
  RemClassRegistry.RegisterXSClass(OrderLabel, 'http://iloxx.de/', 'OrderLabel');
  RemClassRegistry.RegisterXSInfo(TypeInfo(ArrayOfPpvOrderData), 'http://iloxx.de/', 'ArrayOfPpvOrderData');
  RemClassRegistry.RegisterXSClass(ShipAddress, 'http://iloxx.de/', 'ShipAddress');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ShipAddress), 'Name_', '[ExtName="Name"]');
  RemClassRegistry.RegisterXSClass(ResponseData, 'http://iloxx.de/', 'ResponseData');
  RemClassRegistry.RegisterXSClass(ppvOrderData, 'http://iloxx.de/', 'ppvOrderData');
  RemClassRegistry.RegisterXSInfo(TypeInfo(OrderActionType), 'http://iloxx.de/', 'OrderActionType');
  RemClassRegistry.RegisterXSClass(UserCredentials, 'http://iloxx.de/', 'UserCredentials');
  RemClassRegistry.RegisterXSClass(ppvOrderResponse, 'http://iloxx.de/', 'ppvOrderResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ppvOrderResponse), 'ResponseDataArray', '[ArrayItemName="item"]');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ppvOrderResponse), 'ErrorDataArray', '[ArrayItemName="item"]');
  RemClassRegistry.RegisterXSClass(ppvOrderRequest, 'http://iloxx.de/', 'ppvOrderRequest');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ppvOrderRequest), 'ppvOrderDataArray', '[ArrayItemName="item"]');
  RemClassRegistry.RegisterXSClass(ppvDailyTransactionResponse, 'http://iloxx.de/', 'ppvDailyTransactionResponse');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(ppvDailyTransactionResponse), 'ErrorDataArray', '[ArrayItemName="item"]');
  RemClassRegistry.RegisterXSClass(ppvDailyTransactionRequest, 'http://iloxx.de/', 'ppvDailyTransactionRequest');
  RemClassRegistry.RegisterXSClass(ErrorData, 'http://iloxx.de/', 'ErrorData');
  RemClassRegistry.RegisterXSClass(PartnerCredentials, 'http://iloxx.de/', 'PartnerCredentials');
  RemClassRegistry.RegisterXSClass(ServiceSettings, 'http://iloxx.de/', 'ServiceSettings');

end.

Vermutlich mache ich nur einen saudämlichen Fehler, leider weis ich ned wo