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:

zusammenfalten · markieren

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 := 'service@iloxx.de';
  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

zusammenfalten · markieren

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:

zusammenfalten · markieren

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

Was bedeutet knallt? Fehler?

Ja, Schutzverletung. Ich komm aber nicht drauf warum die auftritt ...

Ist resp nil, oder hat es einen Wert?

resp:= sService.ppvAddOrder(addO).ppvAddOrderResult; (Ich gehe davon aus dass es die AV dann in der nächsten Zeile auftritt).

Falls nil => die Delphi SOAP Library konnte die Server Response nicht richtig interpretieren, und gab nil zurück.

Ja, die resp ist nil ... aber wie kann das sein?