IWebNode - SOAPHttpTrans
jvdn
I'm using C++bulder 2007 to migrate a c++builder 6.0 Project. And for the
moment I run into a problem with the intreface of IWebNode
here it is
// CodeGear C++Builder
// Copyright (c) 1995, 2007 by CodeGear
// All rights reserved
// (DO NOT EDIT: machine generated header) 'Webnode.pas' rev: 11.00
#ifndef WebnodeHPP
#define WebnodeHPP
#pragma delphiheader begin
#pragma option push
#pragma option -w- // All warnings off
#pragma option -Vx // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp> // Pascal unit
#include <Sysinit.hpp> // Pascal unit
#include <Classes.hpp> // Pascal unit
#include <Intfinfo.hpp> // Pascal unit
#include <Wsdlintf.hpp> // Pascal unit
#include <Soapattachintf.hpp> // Pascal unit
//-- user
supplied -----------------------------------------------------------
namespace Webnode
{
//-- type
declarations -------------------------------------------------------
__interface IWebNode;
typedef System::DelphiInterface<IWebNode> _di_IWebNode;
__interface INTERFACE_UUID("{77DB2644-0C12-4C0A-920E-89579DB9CC16}")
IWebNode : public IInterface
{
public:
virtual void __fastcall Execute(const AnsiString DataMsg, Classes::TStream*
Response) = 0 /* overload */;
virtual void __fastcall BeforeExecute(const Intfinfo::TIntfMetaData
&IntfMD, const Intfinfo::TIntfMethEntry &MethMD, int MethodIndex,
Soapattachintf::_di_IMimeAttachmentHandler AttachHandler) = 0 ;
virtual void __fastcall Execute(const Classes::TStream* Request,
Classes::TStream* Response) = 0 /* overload */;
virtual Classes::TStream* __fastcall Execute(const Classes::TStream*
Request) = 0 /* overload */;
virtual AnsiString __fastcall GetMimeBoundary(void) = 0 ;
virtual void __fastcall SetMimeBoundary(AnsiString Value) = 0 ;
__property AnsiString MimeBoundary = {read=GetMimeBoundary,
write=SetMimeBoundary};
};
//-- var, const,
procedure ---------------------------------------------------
} /* namespace Webnode */
using namespace Webnode;
#pragma pack(pop)
#pragma option pop
#pragma delphiheader end.
//-- end
unit ----------------------------------------------------------------
#endif // Webnode
and the itnerface that SOAPHttpTrans implements. We have the version
delevired with c++Builder 6.0 but i can't get the code to compile becaouse
of interfeace in connsistancies.
here the SOAPHttpTras part
procedure BeforeExecute(const IntfMD: TIntfMetaData; const MethMD:
TIntfMethEntry); virtual;
procedure Execute(const DataMsg: WideString; Resp: TStream); virtual;
that gives the problem the rest of SOAPHttpTras.pas is added here
I hope somone can give me a hint hou to implement the interface.
Regard jvdn
{*******************************************************}
{ }
{ Borland Delphi Visual Component Library }
{ SOAP Transports }
{ }
{ Copyright (c) 2001 Inprise Corporation }
{ }
{*******************************************************}
{$IFDEF LINUX}
{$DEFINE USE_INDY}
{$ENDIF}
{$IFDEF MSWINDOWS}
//{$DEFINE USE_INDY}
{$ENDIF}
unit SOAPHTTPTrans;
interface
uses
SysUtils, Classes, WebNode, WSDLNode, Types, IntfInfo,
{$IFDEF USE_INDY}
IdHTTP;
{$ELSE}
WinSock, WinInet;
(*$HPPEMIT '#pragma link "wininet.lib"' *)
{$ENDIF}
type
SOAPInvokeOptions = (soNoValueForEmptySOAPAction, soIgnoreInvalidCerts);
TSOAPInvokeOptions= set of SOAPInvokeOptions;
THTTPReqResp = class;
{ Provides access to HTTPReqResp component }
IHTTPReqResp = interface
['{5FA6A197-32DE-4225-BC85-216CB80D1561}']
function GetHTTPReqResp: THTTPReqResp;
end;
THTTPReqResp = class(TComponent, IInterface, IWebNode, IHTTPReqResp)
private
FUserSetURL: Boolean;
FRefCount: Integer;
FOwnerIsComponent: Boolean;
FConnected: Boolean;
FURL: string;
FAgent: string;
FUserName: string;
FPassword: string;
FURLHost: string;
FURLSite: string;
FURLPort: Integer;
FURLScheme: Integer;
FProxy: string;
FProxyByPass: string;
{$IFNDEF USE_INDY}
FInetRoot: HINTERNET;
FInetConnect: HINTERNET;
{$ENDIF}
FWSDLView: TWSDLView;
FSoapAction: string;
FUseUTF8InHeader: Boolean;
FInvokeOptions: TSOAPInvokeOptions;
procedure SetURL(const Value: string);
function GetSOAPAction: string;
procedure SetSOAPAction(const SOAPAction: string);
procedure SetWSDLView(const WSDLVIew: TWSDLView);
function GetSOAPActionHeader: string;
procedure InitURL(const Value: string);
procedure SetUsername(const NameValue: string);
procedure SetPassword(const PasswordValue: string);
procedure SetProxy(const ProxyValue: string);
protected
function _AddRef: Integer; stdcall;
function _Release: Integer; stdcall;
public
constructor Create(Owner: TComponent); override;
class function NewInstance: TObject; override;
procedure AfterConstruction; override;
destructor Destroy; override;
function GetHTTPReqResp: THTTPReqResp;
{$IFNDEF USE_INDY}
procedure Check(Error: Boolean; ShowSOAPAction: Boolean = True);
procedure Connect(Value: Boolean);
function Send(const S: WideString): Integer;
function SendGet: Integer;
procedure Receive(Context: Integer; Resp: TStream);
{$ENDIF}
{$IFDEF USE_INDY}
procedure SetupIndy(IndyHttp: TIDHttp);
{$ENDIF}
procedure Get(Resp: TStream); virtual;
{IWebNode}
procedure BeforeExecute(const IntfMD: TIntfMetaData; const MethMD:
TIntfMethEntry); virtual;
procedure Execute(const DataMsg: WideString; Resp: TStream); virtual;
property URL: string read FURL write SetURL;
property SoapAction: string read GetSOAPAction write SetSOAPAction;
published
property WSDLView: TWSDLView read FWSDLView write SetWSDLView;
property Agent: string read FAgent write FAgent;
property UserName: string read FUserName write SetUserName;
property Password: string read FPassword write SetPassword;
property Proxy: string read FProxy write SetProxy;
property ProxyByPass: string read FProxyByPass write FProxyByPass;
property UseUTF8InHeader: Boolean read FUseUTF8InHeader write
FUseUTF8InHeader;
property InvokeOptions: TSOAPInvokeOptions read FInvokeOptions write
FInvokeOptions;
end;
implementation
uses Variants, SOAPConst, XMLDoc, XMLIntf, WSDLIntf, InvokeRegistry,
WSDLItems,
{$IFDEF MSWINDOWS}
Windows,
{$ENDIF}
{$IFNDEF USE_INDY}
xmldom;
{$ELSE}
IdIntercept, IdSSLIntercept, IdException, IdURI, IdGlobal;
{$ENDIF}
constructor THTTPReqResp.Create(Owner: TComponent);
begin
inherited;
{$IFNDEF USE_INDY}
FInetRoot := nil;
FInetConnect := nil;
{$ENDIF}
FUserSetURL := False;
FInvokeOptions := [soIgnoreInvalidCerts];
FAgent := 'Borland SOAP 1.1';
end;
destructor THTTPReqResp.Destroy;
begin
{$IFNDEF USE_INDY}
if Assigned(FInetConnect) then
InternetCloseHandle(FInetConnect);
FInetConnect := nil;
if Assigned(FInetRoot) then
InternetCloseHandle(FInetRoot);
FInetRoot := nil;
{$ENDIF}
FConnected := False;
inherited;
end;
class function THTTPReqResp.NewInstance: TObject;
begin
Result := inherited NewInstance;
THTTPReqResp(Result).FRefCount := 1;
end;
procedure THTTPReqResp.AfterConstruction;
begin
inherited;
FOwnerIsComponent := Assigned(Owner) and (Owner is TComponent);
InterlockedDecrement(FRefCount);
end;
{ IInterface }
function THTTPReqResp._AddRef: Integer;
begin
Result := InterlockedIncrement(FRefCount)
end;
function THTTPReqResp._Release: Integer;
begin
Result := InterlockedDecrement(FRefCount);
{ If we are not being used as a TComponent, then use refcount to manage
our
lifetime as with TInterfacedObject. }
if (Result = 0) and not FOwnerIsComponent then
Destroy;
end;
{$IFNDEF USE_INDY}
procedure THTTPReqResp.Check(Error: Boolean; ShowSOAPAction: Boolean);
var
ErrCode: Integer;
S: string;
begin
ErrCode := GetLastError;
if Error and (ErrCode <> 0) then
begin
SetLength(S, 256);
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM or FORMAT_MESSAGE_FROM_HMODULE,
Pointer(GetModuleHandle('wininet.dll')),
ErrCode, 0, PChar(S), Length(S), nil);
SetLength(S, StrLen(PChar(S)));
while (Length(S) > 0) and (S[Length(S)] in [#10, #13]) do
SetLength(S, Length(S) - 1);
raise Exception.CreateFmt('%s - URL:%s - SOAPAction:%s', [S, FURL,
SoapAction]); { Do not localize }
end;
end;
{$ENDIF}
function THTTPReqResp.GetHTTPReqResp: THTTPReqResp;
begin
Result := Self;
end;
function THTTPReqResp.GetSOAPAction: string;
begin
if (FSoapAction = '') and not (soNoValueForEmptySOAPAction in
FInvokeOptions) then
Result := '""'
else
Result := FSoapAction;
end;
procedure THTTPReqResp.SetSOAPAction(const SOAPAction: string);
begin
FSoapAction := SOAPAction;
end;
procedure THTTPReqResp.SetWSDLView(const WSDLVIew: TWSDLView);
begin
FWSDLView := WSDLView;
end;
procedure THTTPReqResp.SetURL(const Value: string);
begin
if Value <> '' then
FUserSetURL := True
else
FUserSetURL := False;
InitURL(Value);
{$IFNDEF USE_INDY}
{ Here we always disconnect if a new URL comes in...
this ensures that we don't keep a connection to
a wrong host }
Connect(False);
{$ENDIF}
end;
procedure THTTPReqResp.InitURL(const Value: string);
{$IFNDEF USE_INDY}
var
URLComp: TURLComponents;
P: PChar;
{$ELSE}
const
http = 'http://';
var
IndyHTTP: TIDHttp;
URI, Protocol, Host, path, Document, Port, Bookmark: string;
{$ENDIF}
begin
if Value <> '' then
begin
{$IFNDEF USE_INDY}
FillChar(URLComp, SizeOf(URLComp), 0);
URLComp.dwStructSize := SizeOf(URLComp);
URLComp.dwSchemeLength := 1;
URLComp.dwHostNameLength := 1;
URLComp.dwURLPathLength := 1;
P := PChar(Value);
InternetCrackUrl(P, 0, 0, URLComp);
if not (URLComp.nScheme in [INTERNET_SCHEME_HTTP,
INTERNET_SCHEME_HTTPS]) then
raise Exception.CreateFmt(SInvalidURL, [Value]);
FURLScheme := URLComp.nScheme;
FURLPort := URLComp.nPort;
FURLHost := Copy(Value, URLComp.lpszHostName - P + 1,
URLComp.dwHostNameLength);
FURLSite := Copy(Value, URLComp.lpszUrlPath - P + 1,
URLComp.dwUrlPathLength);
{$ELSE}
IndyHTTP := TIDHttp.Create(Nil);
try
URI := Value;
ParseURI(URI, Protocol, Host, Path, Document, Port, Bookmark);
if Port <> '' then
FURLPort := StrToInt(Port)
else
FURLPort := IndyHTTP.Port;
if Host <> '' then
FURLHost := Host
else
FURLHost := Copy(Value, Length(http)+1,
Pos(':' + IntToStr(FURLPort), Value) - (Length(http)+1));
FURLSite := StringReplace(Value, IndyHTTP.ProtoHeader +
'://' + FURLHost + '/', '', [rfIgnoreCase]);
finally
IndyHTTP.Free;
end;
{$ENDIF}
end else
begin
FURLPort := 0;
FURLHost := '';
FURLSite := '';
FURLScheme := 0;
end;
FURL := Value;
end;
procedure THTTPReqResp.SetUsername(const NameValue: string);
begin
FUserName := NameValue;
if Assigned(WSDLView) then
WSDLView.UserName := NameValue;
end;
procedure THTTPReqResp.SetPassword(const PasswordValue: string);
begin
FPassword := PasswordValue;
if Assigned(WSDLView) then
WSDLView.Password := PasswordValue;
end;
procedure THTTPReqResp.SetProxy(const ProxyValue: string);
begin
FProxy := ProxyValue;
if Assigned(WSDLView) then
WSDLView.Proxy := ProxyValue;
end;
const
MaxStatusTest = 4096;
function THTTPReqResp.GetSOAPActionHeader: string;
begin
if (SoapAction = '') then
Result := SHTTPSoapAction + ':'
else if (SoapAction = '""') then
Result := SHTTPSoapAction + ': ""'
else
Result := SHTTPSoapAction + ': ' + '"' + SoapAction + '"';
end;
{$IFNDEF USE_INDY}
procedure THTTPReqResp.Connect(Value: Boolean);
var
AccessType: Integer;
begin
if Value then
begin
{ Yes, but what if we're connected to a different Host/Port?? }
{ So take advantage of a cached handle, we'll assume that
Connect(False) will be called explicitly when we're switching
Host. To that end, SetURL always disconnects }
if (FConnected) then
Exit;
{ Proxy?? }
if Length(FProxy) > 0 then
AccessType := INTERNET_OPEN_TYPE_PROXY
else
AccessType := INTERNET_OPEN_TYPE_PRECONFIG;
{ Also, could switch to new API introduced in IE4/Preview2}
if InternetAttemptConnect(0) <> ERROR_SUCCESS then
SysUtils.Abort;
FInetRoot := InternetOpen(PChar(FAgent), AccessType, PChar(FProxy),
PChar(FProxyByPass), 0);
Check(not Assigned(FInetRoot));
try
FInetConnect := InternetConnect(FInetRoot, PChar(FURLHost), FURLPort,
PChar(FUserName),
PChar(FPassword), INTERNET_SERVICE_HTTP, 0, Cardinal(Self));
Check(not Assigned(FInetConnect));
FConnected := True;
except
InternetCloseHandle(FInetRoot);
FInetRoot := nil;
end;
end
else
begin
if Assigned(FInetConnect) then
InternetCloseHandle(FInetConnect);
FInetConnect := nil;
if Assigned(FInetRoot) then
InternetCloseHandle(FInetRoot);
FInetRoot := nil;
FConnected := False;
end;
end;
procedure THTTPReqResp.Receive(Context: Integer; Resp: TStream);
var
Size, Downloaded, Status, Len, Index: DWord;
S: string;
begin
Len := SizeOf(Status);
Index := 0;
if HttpQueryInfo(Pointer(Context), HTTP_QUERY_STATUS_CODE or
HTTP_QUERY_FLAG_NUMBER,
@Status, Len, Index) and (Status >= 300) and (Status <> 500) then
begin
Index := 0;
Size := MaxStatusTest;
SetLength(S, Size);
if HttpQueryInfo(Pointer(Context), HTTP_QUERY_STATUS_TEXT, @S[1], Size,
Index) then
begin
SetLength(S, Size);
raise Exception.CreateFmt('%s (%d) - ''%s''', [S, Status, FURL]);
end;
end;
Len := 0;
repeat
Check(not InternetQueryDataAvailable(Pointer(Context), Size, 0, 0));
if Size > 0 then
begin
SetLength(S, Size);
Check(not InternetReadFile(Pointer(Context), @S[1], Size,
Downloaded));
Resp.Write(S[1], Size);
end;
until Size = 0;
end;
function THTTPReqResp.Send(const S: WideString): Integer;
var
Request: HINTERNET;
RetVal, Flags: DWord;
P: Pointer;
AcceptTypes: array of PChar;
ActionHeader: string;
WireData: string;
ContentHeader: string;
sHeader: PChar;
begin
if UseUTF8InHeader then
ContentHeader := ContentHeaderUTF8
else
ContentHeader := ContentHeaderNoUTF8;
{ Connect }
Connect(True);
SetLength(AcceptTypes, 2);
AcceptTypes[0] := PChar('text/xml'); { Do not localize }
AcceptTypes[1] := nil;
Flags := INTERNET_FLAG_KEEP_CONNECTION or INTERNET_FLAG_NO_CACHE_WRITE;
if FURLScheme = INTERNET_SCHEME_HTTPS then
begin
Flags := Flags or INTERNET_FLAG_SECURE;
if (soIgnoreInvalidCerts in InvokeOptions) then
Flags := Flags or (INTERNET_FLAG_IGNORE_CERT_CN_INVALID or
INTERNET_FLAG_IGNORE_CERT_DATE_INVALID);
end;
Request := nil;
try
Request := HttpOpenRequest(FInetConnect, 'POST', PChar(FURLSite), nil,
nil, Pointer(AcceptTypes), Flags, Integer(Self));
Check(not Assigned(Request));
{ SOAPAction header }
ActionHeader:= GetSOAPActionHeader;
HttpAddRequestHeaders(Request, PChar(ActionHeader),
Length(ActionHeader), HTTP_ADDREQ_FLAG_ADD);
{ Content-Type }
HttpAddRequestHeaders(Request, PChar(ContentHeader),
Length(ContentHeader), HTTP_ADDREQ_FLAG_ADD);
WireData := UTF8Encode(S);
while True do
begin
sHeader := 'Connection: close';
Check(not HttpSendRequest(Request, sHeader, Length(sHeader),
@WireData[1], Length(WireData)));
// Original, doesn't close the connection and keep ports "locked"
//Check(not HttpSendRequest(Request, nil, 0, @WireData[1],
Length(WireData)));
RetVal := InternetErrorDlg(GetDesktopWindow(), Request, GetLastError,
FLAGS_ERROR_UI_FILTER_FOR_ERRORS or
FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS or
FLAGS_ERROR_UI_FLAGS_GENERATE_DATA, P);
case RetVal of
ERROR_SUCCESS: break;
ERROR_CANCELLED: SysUtils.Abort;
ERROR_INTERNET_FORCE_RETRY: {Retry the operation};
end;
end;
except
if (Request <> nil) then
InternetCloseHandle(Request);
Request := nil;
Connect(False);
end;
Result := Integer(Request);
end;
function THTTPReqResp.SendGet: Integer;
var
Request: HINTERNET;
LastError, RetVal, Flags, FlagsLen: DWord;
P: Pointer;
AcceptTypes: array of PChar;
begin
{ Connect }
Connect(True);
SetLength(AcceptTypes, 2);
AcceptTypes[0] := PChar('*/*'); { Do not localize }
AcceptTypes[1] := nil;
Flags := INTERNET_FLAG_DONT_CACHE;
if FURLScheme = INTERNET_SCHEME_HTTPS then
begin
Flags := Flags or INTERNET_FLAG_SECURE;
if (soIgnoreInvalidCerts in InvokeOptions) then
Flags := Flags or (INTERNET_FLAG_IGNORE_CERT_CN_INVALID or
INTERNET_FLAG_IGNORE_CERT_DATE_INVALID);
end;
Request := nil;
try
Request := HttpOpenRequest(FInetConnect, 'GET', PChar(FURLSite), nil,
nil, Pointer(AcceptTypes), Flags, Integer(Self));
Check(not Assigned(Request), False);
while True do
begin
if (not HttpSendRequest(Request, nil, 0, nil, 0)) then
begin
LastError := GetLastError;
{ Handle INVALID_CA discreetly }
if (LastError = ERROR_INTERNET_INVALID_CA) then
begin
FlagsLen := SizeOf(Flags);
InternetQueryOption(Request, INTERNET_OPTION_SECURITY_FLAGS,
Pointer(@Flags), FlagsLen);
Flags := Flags or SECURITY_FLAG_IGNORE_UNKNOWN_CA;
InternetSetOption(Request, INTERNET_OPTION_SECURITY_FLAGS,
Pointer(@Flags), FlagsLen);
end
else
begin
RetVal := InternetErrorDlg(GetDesktopWindow(), Request, LastError,
FLAGS_ERROR_UI_FILTER_FOR_ERRORS or
FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS or
FLAGS_ERROR_UI_FLAGS_GENERATE_DATA, P);
case RetVal of
ERROR_CANCELLED: SysUtils.Abort;
ERROR_SUCCESS: break;
ERROR_INTERNET_FORCE_RETRY: {Retry the operation};
end;
end;
end
else
break;
end;
except
if (Request <> nil) then
InternetCloseHandle(Request);
Request := nil;
Connect(False);
end;
Result := Integer(Request);
end;
{$ENDIF}
{$IFDEF USE_INDY}
procedure THTTPReqResp.SetupIndy(IndyHttp: TIDHttp);
var
ContentHeader, ActionHeader: string;
Protocol, Host, path, Document, Port, Bookmark: string;
begin
if UseUTF8InHeader then
ContentHeader := ContentHeaderUTF8
else
ContentHeader := ContentHeaderNoUTF8;
{ SOAP-Action }
ActionHeader := GetSOAPActionHeader;
IndyHttp.Request.Accept := 'text/xml';
IndyHttp.Request.UserAgent := Self.Agent;
{ UserName/Password for Basic Authentication }
IndyHttp.Request.Username := FUserName;
IndyHttp.Request.Password := FPassword;
IndyHttp.Request.ExtraHeaders.Add(ActionHeader);
IndyHttp.Request.Location := FUrl;
{ Proxy and potentially username/password combination }
if FProxy <> '' then
begin
ParseURI(FProxy, Protocol, Host, path, Document, Port, Bookmark);
IndyHttp.Request.ProxyServer := Host;
IndyHttp.Request.ProxyPort := StrToInt(Port);
IndyHttp.Request.ProxyUsername := FUserName;
IndyHttp.Request.ProxyPassword := FPassword;
end;
IndyHttp.Request.Connection := Self.FURL;
IndyHttp.Request.ContentType := 'text/xml'; { do not localize }
IndyHttp.Host := FUrlHost;
IndyHttp.Port := FUrlPort;
end;
{$ENDIF}
procedure THTTPReqResp.Get(Resp: TStream);
{$IFNDEF USE_INDY}
var
Context: Integer;
{$ENDIF}
{$IFDEF USE_INDY}
procedure LoadFromURL(URL: string; Stream: TStream);
var
IndyHTTP: TIDHttp;
Protocol, Host, path, Document, Port, Bookmark: string;
begin
IndyHTTP := TIDHttp.Create(Nil);
try
IndyHttp.Request.Accept := 'text/xml, text/html,
application/octet-stream';
IndyHttp.Request.UserAgent := 'Mozilla/3.0 (compatible; Indy
Library)'; { Do not localize }
IndyHttp.Request.ContentType := 'text/xml'; { Do not localize }
IndyHttp.Request.Location := URL;
IndyHttp.Request.Connection := URL;
{ IndyHttp.Intercept := FIntercept; }
IndyHttp.Get(URL, Stream);
if FProxy <> '' then
begin
ParseURI(FProxy, Protocol, Host, path, Document, Port, Bookmark);
IndyHttp.Request.ProxyServer := Host;
IndyHttp.Request.ProxyPort := StrToInt(Port);
IndyHttp.Request.ProxyUsername := FUserName;
IndyHttp.Request.ProxyPassword := FPassword;
end;
finally
IndyHTTP.Free;
end;
end;
{$ENDIF}
begin
{ GETs require a URL }
if URL = '' then
raise Exception.Create(SEmptyURL);
{$IFDEF USE_INDY}
{ GET with INDY }
LoadFromURL(URL, Resp);
{$ELSE}
Context := SendGet;
try
Receive(Context, Resp);
finally
if Context <> 0 then
InternetCloseHandle(Pointer(Context));
Connect(False);
end;
{$ENDIF}
end;
{ Here the RIO can perform any transports specific setup before call - XML
serialization is done }
procedure THTTPReqResp.BeforeExecute(const IntfMD: TIntfMetaData; const
MethMD: TIntfMethEntry);
var
MethName: InvString;
Binding: InvString;
QBinding: IQualifiedName;
begin
if FUserSetURL then
begin
MethName := InvRegistry.GetMethExternalName(IntfMD.Info, MethMD.Name);
FSoapAction := InvRegistry.GetActionURIOfInfo(IntfMD.Info, MethName);
end
else
begin
{ User did *NOT* set a URL }
if WSDLView <> nil then
begin
{ Make sure WSDL is active }
WSDLView.Activate;
QBinding := WSDLView.WSDL.GetBindingForServicePort(WSDLView.Service,
WSDLView.Port);
if QBinding <> nil then
begin
Binding := QBinding.Name;
MethName:= InvRegistry.GetMethExternalName(WSDLView.IntfInfo,
WSDLView.Operation);
{ TODO: Pass in QBinding here to fix namespace issues }
FSoapAction := WSDLView.WSDL.GetSoapOperationAttribute(Binding,
MethName, WSDLIntf.SSoapAction);
end;
{NOTE: In case we can't get the SOAPAction - see if we have something
in the registry }
{ It can't hurt:) }
if FSoapAction = '' then
InvRegistry.GetActionURIOfInfo(IntfMD.Info, MethName);
{ Retrieve URL }
FURL := WSDLView.WSDL.GetSoapAddressForServicePort(WSDLView.Service,
WSDLView.Port);
if (FURL = '') then
raise Exception.CreateFmt(sCantGetURL, [WSDLView.Service,
WSDLView.Port, WSDLView.WSDL.FileName]);
InitURL(FURL);
end
else
raise Exception.Create(sNoWSDLURL);
end;
end;
procedure THTTPReqResp.Execute(const DataMsg: WideString; Resp: TStream);
{$IFDEF USE_INDY}
procedure PostData(const DataMsg: WideString; Response: TStream);
var
IndyHTTP: TIDHttp;
Strings: TStrings;
WireData: string;
begin
IndyHTTP := TIDHttp.Create(Nil);
try
SetupIndy(IndyHTTP);
WireData := UTF8Encode(DataMsg);
Strings := TStringList.Create;
try
Strings.Add(WireData);
IndyHttp.Post(FUrl, Strings, Resp);
finally
Strings.Free;
end;
finally
FreeAndNil(IndyHTTP);
end;
end;
{$ENDIF}
{$IFNDEF USE_INDY}
var
Context: Integer;
{$ENDIF}
begin
{$IFNDEF USE_INDY}
Context := Send(DataMsg);
try
try
Receive(Context, Resp);
except
Connect(False);
end;
finally
if Context <> 0 then
InternetCloseHandle(Pointer(Context));
{ Connect(False);}
end;
{$ELSE}
PostData(DataMsg, Resp);
{$ENDIF}
end;
end.
Jean-Marie Babet
IWebNode changed from C++Builder6 (mainly to cater for attachment support).
If you have code that implemented the earlier interface, when you move to
the newer C++Builder you'll need to update your class to implement the new
methods. If you can provide some context about the code I may be able to
provide suggestions on how to proceed. Are you simply customizing one of the
classes that implements IWebNode already, if yes, you can simply delegate to
the VCL implementation of these methods.
Please give me some more context so I may be able to provide more
information.
Cheers,
Bruneau.