Les types de données SOAP et les types de données 1000

// Procedure SendClaim;
// 
var inst:TACwsiattachement;
    body:TACClaimDetailType;
    content: TBinaryContent;
begin
  // Objet gestionnaire de binaire
  content := TBinaryContent.Create;
 
  // Chargement de l’objet avec une image
 content.LoadFromFile('d:\Mes documents\Mes images\white house.jpg');
 
  // Descriptif de l’image attendu par le service
 
  body := ClassManager.CreateInstance('TACClaimDetailType');
  body.Name := 'White house';
 
  //
  inst := ClassManager.CreateInstance('TACwsiattachement');
  inst.sendClaim(body,content.base64Binary);
end;

Type
  InteropService = Class(TServiceLocal)
  Procedure echoBase64(const input:base64Binary; out output:base64Binary); 
 end;
 
Procedure InteropService.echoBase64(const input:base64Binary; out output:base64Binary);
begin
  output := input;
end;

Type
  ICinteropservice = Class(TServiceDistant)
  public
    Procedure echoBase64(const input:base64Binary; out output:base64Binary);
  end;
 
Procedure ICinteropservice.echoBase64(const input:base64Binary; out output:base64Binary);
begin
 //Remote procedure, do not code
end;

//Procedure echoBase64;
var inst:ICinteropService;
    sin:string;
    sout:base64binary;
    contin,contout:TBinaryContent;
begin
  inst := ClassManager.CreateInstance('ICinteropService');
 
  // Une chaine a transmettre
  sin := 'coucou';
 
  // Converti la chaine en utilisant un BinaryContent
  // 
  contin := TBinaryContent.Create;
  contin.AsString := sin;
 
  // appel du service
  // sout contient la réponse encodée
  inst.echoBase64(contin.base64Binary,sout);
 
  // converti la réponse 
  //
  contout := TBinaryContent.Create;
  contout.base64Binary := sout;
 
  // compare le résultat
  //
  if sin<>contout.AsString
     then showMessage('echoBase64 failed')
     else showMessage('echoBase64 OK');
end;

//Procedure echoBase64_2;
var inst:ICinteropService;
    lsin,lsout:TStringList;
    sout: base64binary;
begin
  inst := ClassManager.CreateInstance('ICinteropService');
  lsin := TStringList.Create;
 
  lsin.LoadFromFile('c:\myText-1.txt');
 
  inst.echoBase64(lsin.base64binary,sout);
  lsout := TStringlist.Create;
  lsout.base64Binary := sout;
  lsout.SaveToFile('c:\myText-2.txt');
end;

//Procedure echoBase64_3;
var inst:ICinteropService;
    lsin,lsout:TStringList;
    sout: base64Binary;
begin
  inst := ClassManager.CreateInstance('ICinteropService');
  lsin := TStringList.Create;
  lsin.LoadFromFile('c:\myText-1.txt');
 
  inst.echoBase64(lsin.getAsBase64Binary(b64ZlibNoSig),sout);
 
  lsout := TStringlist.Create;
  lsout.setAsBase64Binary(sout,b64ZLibNoSig);
  lsout.SaveToFile('c:\myText-3.txt');
end;

//Défini un énuméré.
EchoNum = (cstEcho1, cstEcho2) ;
 
//Procedure echoEnum(input:EchoEnum; out output:EchoEnum);
begin
  output := input;
end;

ICEchoNum = (cstEcho1,cstEcho2) ;
 
// Procedure echoEnum;
//
var inst:ICinteropService; sin,sout:ICEchoEnum;
begin
  sin := cstEcho1;
  inst := ClassManager.CreateInstance('ICinteropService');
  inst.echoEnum(cstEcho1,sout);
  if sin<>sout
     then showMessage('echoEnum failed')
     else showMessage('echoEnum OK');
end;

//Procedure echoStruct;
//
var inst:DSService; structin,structout:DSSOAPStruct;
begin
  // La structure est une classe 1000
  structin := ClassManager.CreateInstance('DSSOAPStruct');
  structin.varString := 'coucou';
  structin.varInt := 1;
  structin.varFloat := 1.0;
 
  // appel du service
  inst := ClassManager.CreateInstance('DSService');
 
  // l’instance en retour est créée par le framework
  inst.echoStruct(structin,structout);
 
  showMessage('Result:'+structout.varString);
end;

Procedure echoArrayOfString(const input:Array of string; out output:Array of string);
var idx:Integer;
begin
  // Implémentation du service
  // Copie le tableau élément par élément.
  //
  for idx:=0 to length(input)-1 do
   output[idx] := input[idx];
End ;

Procedure echoArrayOfString ;
var inst:ICinteropService; sin,sout:Array of string;
    idx:Integer; s1,s2:string;
begin
  inst := ICinteropService.Create;
 
  // Initialise le tableau par une constante
  sin := ['Ah','que','coucou'];
 
  // Appel du service, sout sera initialisée 
  // par la couche soap
  inst.echoArrayOfString(sin,sout);
 
 
  // Verification
  // 
  s1 := '';
 
  for idx:=0 to length(sin)-1 do
   s1 := s1+sin[idx];
 
  s2 := '';
  for idx:=0 to length(sout)-1 do
   s2 := s2+sout[idx];
 
  if s1<>s2
     then showMessage('echoArrayString failed :'+s1+':'+s2)
     else showMessage('echoArrayString OK');
end;

Type
  InteropStruct1 = Class(TitObject)
  public
    InteropStruct2List: CompositionList of InteropStruct2;
    InteropStruct2Ref: InteropStruct2;
    InteropStruct3Ref: InteropStruct3;
    oidInteropStruct2Ref: string;
    oidInteropStruct3Ref: string;
    unCode1: string;
  end;
 
  InteropStruct2 = Class(TitObject)
  public
    InteropStruct1Ref: InteropStruct1;
    oidInteropStruct1Ref: string;
    unCode2: string;
  end;
 
  InteropStruct3 = Class(TitObject)
  public
    unCode3: string;
  end;
 
  InteropService = Class(Service)
  public
    Procedure echoStruct1Array(const input:InteropStruct1List; out output:InteropStruct1List);
  end;

Procedure echoStructArray;
var inst:ICinteropService;
    sin,sout:ICInteropStruct1List;
    s1i,s1o:ICInteropStruct1;
    idx:Integer; s2:ICInteropStruct2;
begin
  inst := ICinteropService.Create;
 
  // Force l’appel distant
  inst.LoopMode := mlmNone;
 
  // Création de la liste d’appel.
  //
  sin := ClassManager.CreateObjectList('ICInteropStruct1');
  //
  s1i := ICInteropStruct1.Create;
  s1i.unCode1 := 'code1';
 
  for idx:=0 to 1 do
   begin
     s2 := ICInteropStruct2.Create;
     s2.unCode2 := 'code1-'+inttostr(idx);
     s1i.InteropStruct2List.AddRef(s2);
   end;
  sin.AddRef(s1i);
 
  // Appel du service
  // la liste sout sera initialisée 
  // par la couche soap
 
  inst.echoStruct1Array(sin,sout);
 
 
  // Vérification
  //
  if sin.Count<>sout.Count then
   begin
     showMessage('echoStruct1Array failed, struct count');
     Exit;
   end;
 
  // Test du premier élément
  s1i := sin.Refs[0];
  s1o := sout.Refs[0];
  if s1i.unCode1<>s1o.unCode1 then
   begin
     showMessage('echoStruct1Array failed, struc1.unCode1');
     Exit;
   end;
  //
  //
  if s1i.InteropStruct2List.Count<>s1o.InteropStruct2List.Count then
   begin
     showMessage('echoStruct1Array failed, struc1.struct2.count');
     Exit;
   end;
 
  // Test de la liste imbriquée
  //
  for idx:=0 to s1i.InteropStruct2List.Count-1 do
   if (s1i.InteropStruct2List.Refs[idx].unCode2<>s1o.InteropStruct2List.Refs[idx].unCode2) then
    begin
     showMessage('echoStruct1Array failed, struc1.struct2[].unCode2');
     Exit;
    end;
 
  showMessage('echoStruct1 OK');
end;

unit InterpServicePackage
interface
Type
  InteropService = Class(TitObject)
  public
    Procedure echoStruct5(const input:InteropStruct5; out output:InteropStruct5);
  end;
 
  InteropStringWrapper = Class(TitObject)
  // cette classe a l’option Wrapper de type simple coché dans ses propriétés soap
  public
    data : string; // les classes wrapper doivent avoir un attribut data
  end;
 
  Interopstruct5 = Class(TitObject)
  public
    unArrayOfString: List of InteropStringWrapper;
    unCode: string;
  end;
 
Implementation
 
{InteropService}
 
Procedure InteropService.echoStruct5(const input:InteropStruct5; out output:InteropStruct5);
begin
  output := input;
end;
 
end.

Procedure TestInteropService.echoStruct5;
var inst:ICinteropService;
    sin,sout:ICInteropStruct5;
    wrp:ICWrapperOfString;
    idx:Integer;
    ss,stag: string;
begin
  inst := ICinteropService.Create;
  sin := ICInteropStruct5.Create;
  sin.unCode := 'code5';
  for idx:=0 to 1 do
   begin
     wrp := ICWrapperOfString.Create;
     wrp.data := 'data-'+inttostr(idx);
     sin.unArrayOfString.AddRef(wrp);
   end;
 
  inst.echoStruct5(sin,sout);
 
  ss := ''; stag := #13;
  for idx:=0 to sout.unArrayOfString.Count-1 do
   begin
     ss := ss+stag+sout.unArrayOfString.refs[idx].data;
   end;
  showMessage('echoStruct5 :'+ss);
end;