Kod: Tümünü seç
// ************************************************************************ //
// The types declared in this file were generated from data read from the
// WSDL File described below:
// WSDL : http://dev.gittigidiyor.com:8080/listingapi/ws/CategoryService?wsdl
// >Import : http://dev.gittigidiyor.com:8080/listingapi/ws/CategoryService?wsdl>0
// >Import : http://dev.gittigidiyor.com:8080/listingapi/ws/CategoryService?wsdl>1
// (09.01.2017 23:39:25 - - $Rev: 69934 $)
// ************************************************************************ //
unit CategoryService1;
interface
uses Soap.InvokeRegistry, Soap.SOAPHTTPClient, System.Types, Soap.XSBuiltIns;
const
IS_OPTN = $0001;
IS_UNBD = $0002;
IS_NLBL = $0004;
IS_UNQL = $0008;
IS_ATTR = $0010;
type
errorType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
categoryPermaType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
baseAuditType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
categoryAuditType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
baseResponse = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
categorySpecsServiceResponse = class; { "http://category.anonymous.ws.listingapi.gg.com"[Lit][GblCplx] }
categorySpecsWithDetailServiceResponse = class; { "http://category.anonymous.ws.listingapi.gg.com"[Lit][GblCplx] }
categoryServiceVariantResponse = class; { "http://category.anonymous.ws.listingapi.gg.com"[Lit][GblCplx] }
categoryPermaServiceResponse = class; { "http://category.anonymous.ws.listingapi.gg.com"[Lit][GblCplx] }
categorySpecValueType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
categoryServiceAuditResponse = class; { "http://category.anonymous.ws.listingapi.gg.com"[Lit][GblCplx] }
categorySpecType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
categoryType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
categoryVariantSpecType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
categorySpecWithDetailType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
categoryServiceResponse = class; { "http://category.anonymous.ws.listingapi.gg.com"[Lit][GblCplx] }
categoryVariantSpecValueType = class; { "http://category.anonymous.ws.listingapi.gg.com"[GblCplx] }
specs = array of categorySpecWithDetailType; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
categoryAudits = array of categoryAuditType; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
values = array of categorySpecValueType; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
specs2 = array of categorySpecType; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
categories = array of categoryPermaType; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
specs3 = array of categoryVariantSpecType; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
errorType = class(TRemotable)
private
FerrorId: string;
FerrorId_Specified: boolean;
FerrorCode: string;
FerrorCode_Specified: boolean;
Fmessage_: string;
Fmessage__Specified: boolean;
FviewMessage: string;
FviewMessage_Specified: boolean;
procedure SeterrorId(Index: Integer; const Astring: string);
function errorId_Specified(Index: Integer): boolean;
procedure SeterrorCode(Index: Integer; const Astring: string);
function errorCode_Specified(Index: Integer): boolean;
procedure Setmessage_(Index: Integer; const Astring: string);
function message__Specified(Index: Integer): boolean;
procedure SetviewMessage(Index: Integer; const Astring: string);
function viewMessage_Specified(Index: Integer): boolean;
published
property errorId: string Index (IS_OPTN or IS_UNQL) read FerrorId write SeterrorId stored errorId_Specified;
property errorCode: string Index (IS_OPTN or IS_UNQL) read FerrorCode write SeterrorCode stored errorCode_Specified;
property message_: string Index (IS_OPTN or IS_UNQL) read Fmessage_ write Setmessage_ stored message__Specified;
property viewMessage: string Index (IS_OPTN or IS_UNQL) read FviewMessage write SetviewMessage stored viewMessage_Specified;
end;
values2 = array of string; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
breadCrumbs = array of string; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
categoryPermaType = class(TRemotable)
private
FcategoryCode: string;
FcategoryCode_Specified: boolean;
FcategoryPerma: string;
FcategoryPerma_Specified: boolean;
FbreadCrumbs: breadCrumbs;
FbreadCrumbs_Specified: boolean;
procedure SetcategoryCode(Index: Integer; const Astring: string);
function categoryCode_Specified(Index: Integer): boolean;
procedure SetcategoryPerma(Index: Integer; const Astring: string);
function categoryPerma_Specified(Index: Integer): boolean;
procedure SetbreadCrumbs(Index: Integer; const AbreadCrumbs: breadCrumbs);
function breadCrumbs_Specified(Index: Integer): boolean;
published
property categoryCode: string Index (IS_OPTN or IS_UNQL) read FcategoryCode write SetcategoryCode stored categoryCode_Specified;
property categoryPerma: string Index (IS_OPTN or IS_UNQL) read FcategoryPerma write SetcategoryPerma stored categoryPerma_Specified;
property breadCrumbs: breadCrumbs Index (IS_OPTN or IS_UNQL) read FbreadCrumbs write SetbreadCrumbs stored breadCrumbs_Specified;
end;
baseAuditType = class(TRemotable)
private
FchangeType: string;
FchangeType_Specified: boolean;
procedure SetchangeType(Index: Integer; const Astring: string);
function changeType_Specified(Index: Integer): boolean;
published
property changeType: string Index (IS_OPTN or IS_UNQL) read FchangeType write SetchangeType stored changeType_Specified;
end;
categoryAuditType = class(baseAuditType)
private
FcategoryCode: string;
FcategoryCode_Specified: boolean;
procedure SetcategoryCode(Index: Integer; const Astring: string);
function categoryCode_Specified(Index: Integer): boolean;
published
property categoryCode: string Index (IS_OPTN or IS_UNQL) read FcategoryCode write SetcategoryCode stored categoryCode_Specified;
end;
stringArray = array of string; { "http://jaxb.dev.java.net/array"[Lit][GblCplx] }
baseResponse = class(TRemotable)
private
FackCode: string;
FackCode_Specified: boolean;
FresponseTime: string;
FresponseTime_Specified: boolean;
Ferror: errorType;
Ferror_Specified: boolean;
FtimeElapsed: string;
FtimeElapsed_Specified: boolean;
procedure SetackCode(Index: Integer; const Astring: string);
function ackCode_Specified(Index: Integer): boolean;
procedure SetresponseTime(Index: Integer; const Astring: string);
function responseTime_Specified(Index: Integer): boolean;
procedure Seterror(Index: Integer; const AerrorType: errorType);
function error_Specified(Index: Integer): boolean;
procedure SettimeElapsed(Index: Integer; const Astring: string);
function timeElapsed_Specified(Index: Integer): boolean;
public
destructor Destroy; override;
published
property ackCode: string Index (IS_OPTN or IS_UNQL) read FackCode write SetackCode stored ackCode_Specified;
property responseTime: string Index (IS_OPTN or IS_UNQL) read FresponseTime write SetresponseTime stored responseTime_Specified;
property error: errorType Index (IS_OPTN or IS_UNQL) read Ferror write Seterror stored error_Specified;
property timeElapsed: string Index (IS_OPTN or IS_UNQL) read FtimeElapsed write SettimeElapsed stored timeElapsed_Specified;
end;
categorySpecsServiceResponse = class(baseResponse)
private
Fspecs: specs2;
Fspecs_Specified: boolean;
procedure Setspecs(Index: Integer; const Aspecs2: specs2);
function specs_Specified(Index: Integer): boolean;
public
constructor Create; override;
destructor Destroy; override;
published
property specs: specs2 Index (IS_OPTN or IS_UNQL) read Fspecs write Setspecs stored specs_Specified;
end;
categorySpecsWithDetailServiceResponse = class(baseResponse)
private
Fspecs: specs;
Fspecs_Specified: boolean;
procedure Setspecs(Index: Integer; const Aspecs: specs);
function specs_Specified(Index: Integer): boolean;
public
constructor Create; override;
destructor Destroy; override;
published
property specs: specs Index (IS_OPTN or IS_UNQL) read Fspecs write Setspecs stored specs_Specified;
end;
categoryServiceVariantResponse = class(baseResponse)
private
FspecCount: Int64;
FspecCount_Specified: boolean;
Fspecs: specs3;
Fspecs_Specified: boolean;
procedure SetspecCount(Index: Integer; const AInt64: Int64);
function specCount_Specified(Index: Integer): boolean;
procedure Setspecs(Index: Integer; const Aspecs3: specs3);
function specs_Specified(Index: Integer): boolean;
public
constructor Create; override;
destructor Destroy; override;
published
property specCount: Int64 Index (IS_OPTN or IS_UNQL) read FspecCount write SetspecCount stored specCount_Specified;
property specs: specs3 Index (IS_OPTN or IS_UNQL) read Fspecs write Setspecs stored specs_Specified;
end;
categoryPermaServiceResponse = class(baseResponse)
private
FcategoryCount: Integer;
FcategoryCount_Specified: boolean;
Fcategories: categories;
Fcategories_Specified: boolean;
procedure SetcategoryCount(Index: Integer; const AInteger: Integer);
function categoryCount_Specified(Index: Integer): boolean;
procedure Setcategories(Index: Integer; const Acategories: categories);
function categories_Specified(Index: Integer): boolean;
public
constructor Create; override;
destructor Destroy; override;
published
property categoryCount: Integer Index (IS_OPTN or IS_UNQL) read FcategoryCount write SetcategoryCount stored categoryCount_Specified;
property categories: categories Index (IS_OPTN or IS_UNQL) read Fcategories write Setcategories stored categories_Specified;
end;
categorySpecValueType = class(TRemotable)
private
FspecId: Integer;
FspecId_Specified: boolean;
FparentSpecId: Integer;
FparentSpecId_Specified: boolean;
Fname_: string;
Fname__Specified: boolean;
procedure SetspecId(Index: Integer; const AInteger: Integer);
function specId_Specified(Index: Integer): boolean;
procedure SetparentSpecId(Index: Integer; const AInteger: Integer);
function parentSpecId_Specified(Index: Integer): boolean;
procedure Setname_(Index: Integer; const Astring: string);
function name__Specified(Index: Integer): boolean;
published
property specId: Integer Index (IS_ATTR or IS_OPTN) read FspecId write SetspecId stored specId_Specified;
property parentSpecId: Integer Index (IS_ATTR or IS_OPTN) read FparentSpecId write SetparentSpecId stored parentSpecId_Specified;
property name_: string Index (IS_OPTN or IS_UNQL) read Fname_ write Setname_ stored name__Specified;
end;
categoryServiceAuditResponse = class(baseResponse)
private
FtotalCount: Integer;
FtotalCount_Specified: boolean;
Fcount: Integer;
Fcount_Specified: boolean;
FcategoryAudits: categoryAudits;
FcategoryAudits_Specified: boolean;
procedure SettotalCount(Index: Integer; const AInteger: Integer);
function totalCount_Specified(Index: Integer): boolean;
procedure Setcount(Index: Integer; const AInteger: Integer);
function count_Specified(Index: Integer): boolean;
procedure SetcategoryAudits(Index: Integer; const AcategoryAudits: categoryAudits);
function categoryAudits_Specified(Index: Integer): boolean;
public
constructor Create; override;
destructor Destroy; override;
published
property totalCount: Integer Index (IS_OPTN or IS_UNQL) read FtotalCount write SettotalCount stored totalCount_Specified;
property count: Integer Index (IS_OPTN or IS_UNQL) read Fcount write Setcount stored count_Specified;
property categoryAudits: categoryAudits Index (IS_OPTN or IS_UNQL) read FcategoryAudits write SetcategoryAudits stored categoryAudits_Specified;
end;
categories2 = array of categoryType; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
specs4 = array of categorySpecType; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
specValues = array of categoryVariantSpecValueType; { "http://category.anonymous.ws.listingapi.gg.com"[Cplx] }
categorySpecType = class(TRemotable)
private
Fname_: string;
Fname__Specified: boolean;
Frequired: Boolean;
Frequired_Specified: boolean;
Ftype_: string;
Ftype__Specified: boolean;
Fvalues: values2;
Fvalues_Specified: boolean;
procedure Setname_(Index: Integer; const Astring: string);
function name__Specified(Index: Integer): boolean;
procedure Setrequired(Index: Integer; const ABoolean: Boolean);
function required_Specified(Index: Integer): boolean;
procedure Settype_(Index: Integer; const Astring: string);
function type__Specified(Index: Integer): boolean;
procedure Setvalues(Index: Integer; const Avalues2: values2);
function values_Specified(Index: Integer): boolean;
published
property name_: string Index (IS_ATTR or IS_OPTN) read Fname_ write Setname_ stored name__Specified;
property required: Boolean Index (IS_ATTR or IS_OPTN) read Frequired write Setrequired stored required_Specified;
property type_: string Index (IS_ATTR or IS_OPTN) read Ftype_ write Settype_ stored type__Specified;
property values: values2 Index (IS_OPTN or IS_UNQL) read Fvalues write Setvalues stored values_Specified;
end;
categoryType = class(TRemotable)
private
Fdeepest: Boolean;
Fdeepest_Specified: boolean;
FhasCatalog: Boolean;
FhasCatalog_Specified: boolean;
FcategoryCode: string;
FcategoryCode_Specified: boolean;
FcategoryName: string;
FcategoryName_Specified: boolean;
Fspecs: specs4;
Fspecs_Specified: boolean;
procedure Setdeepest(Index: Integer; const ABoolean: Boolean);
function deepest_Specified(Index: Integer): boolean;
procedure SethasCatalog(Index: Integer; const ABoolean: Boolean);
function hasCatalog_Specified(Index: Integer): boolean;
procedure SetcategoryCode(Index: Integer; const Astring: string);
function categoryCode_Specified(Index: Integer): boolean;
procedure SetcategoryName(Index: Integer; const Astring: string);
function categoryName_Specified(Index: Integer): boolean;
procedure Setspecs(Index: Integer; const Aspecs4: specs4);
function specs_Specified(Index: Integer): boolean;
public
destructor Destroy; override;
published
property deepest: Boolean Index (IS_ATTR or IS_OPTN) read Fdeepest write Setdeepest stored deepest_Specified;
property hasCatalog: Boolean Index (IS_ATTR or IS_OPTN) read FhasCatalog write SethasCatalog stored hasCatalog_Specified;
property categoryCode: string Index (IS_OPTN or IS_UNQL) read FcategoryCode write SetcategoryCode stored categoryCode_Specified;
property categoryName: string Index (IS_OPTN or IS_UNQL) read FcategoryName write SetcategoryName stored categoryName_Specified;
property specs: specs4 Index (IS_OPTN or IS_UNQL) read Fspecs write Setspecs stored specs_Specified;
end;
categoryVariantSpecType = class(TRemotable)
private
FnameId: Int64;
FnameId_Specified: boolean;
Fname_: string;
Fname__Specified: boolean;
Ftype_: string;
Ftype__Specified: boolean;
ForderNumber: Integer;
ForderNumber_Specified: boolean;
Fbase: Boolean;
Fbase_Specified: boolean;
FspecValues: specValues;
FspecValues_Specified: boolean;
procedure SetnameId(Index: Integer; const AInt64: Int64);
function nameId_Specified(Index: Integer): boolean;
procedure Setname_(Index: Integer; const Astring: string);
function name__Specified(Index: Integer): boolean;
procedure Settype_(Index: Integer; const Astring: string);
function type__Specified(Index: Integer): boolean;
procedure SetorderNumber(Index: Integer; const AInteger: Integer);
function orderNumber_Specified(Index: Integer): boolean;
procedure Setbase(Index: Integer; const ABoolean: Boolean);
function base_Specified(Index: Integer): boolean;
procedure SetspecValues(Index: Integer; const AspecValues: specValues);
function specValues_Specified(Index: Integer): boolean;
public
destructor Destroy; override;
published
property nameId: Int64 Index (IS_ATTR or IS_OPTN) read FnameId write SetnameId stored nameId_Specified;
property name_: string Index (IS_ATTR or IS_OPTN) read Fname_ write Setname_ stored name__Specified;
property type_: string Index (IS_ATTR or IS_OPTN) read Ftype_ write Settype_ stored type__Specified;
property orderNumber: Integer Index (IS_ATTR or IS_OPTN) read ForderNumber write SetorderNumber stored orderNumber_Specified;
property base: Boolean Index (IS_ATTR or IS_OPTN) read Fbase write Setbase stored base_Specified;
property specValues: specValues Index (IS_OPTN or IS_UNQL) read FspecValues write SetspecValues stored specValues_Specified;
end;
categorySpecWithDetailType = class(TRemotable)
private
Fname_: string;
Fname__Specified: boolean;
Frequired: Boolean;
Frequired_Specified: boolean;
Ftype_: string;
Ftype__Specified: boolean;
FspecId: Integer;
FspecId_Specified: boolean;
FchildSpecId: Integer;
FchildSpecId_Specified: boolean;
Fvalues: values;
Fvalues_Specified: boolean;
procedure Setname_(Index: Integer; const Astring: string);
function name__Specified(Index: Integer): boolean;
procedure Setrequired(Index: Integer; const ABoolean: Boolean);
function required_Specified(Index: Integer): boolean;
procedure Settype_(Index: Integer; const Astring: string);
function type__Specified(Index: Integer): boolean;
procedure SetspecId(Index: Integer; const AInteger: Integer);
function specId_Specified(Index: Integer): boolean;
procedure SetchildSpecId(Index: Integer; const AInteger: Integer);
function childSpecId_Specified(Index: Integer): boolean;
procedure Setvalues(Index: Integer; const Avalues: values);
function values_Specified(Index: Integer): boolean;
public
destructor Destroy; override;
published
property name_: string Index (IS_ATTR or IS_OPTN) read Fname_ write Setname_ stored name__Specified;
property required: Boolean Index (IS_ATTR or IS_OPTN) read Frequired write Setrequired stored required_Specified;
property type_: string Index (IS_ATTR or IS_OPTN) read Ftype_ write Settype_ stored type__Specified;
property specId: Integer Index (IS_ATTR or IS_OPTN) read FspecId write SetspecId stored specId_Specified;
property childSpecId: Integer Index (IS_ATTR or IS_OPTN) read FchildSpecId write SetchildSpecId stored childSpecId_Specified;
property values: values Index (IS_OPTN or IS_UNQL) read Fvalues write Setvalues stored values_Specified;
end;
categoryServiceResponse = class(baseResponse)
private
FcategoryCount: Integer;
FcategoryCount_Specified: boolean;
Fcategories: categories2;
Fcategories_Specified: boolean;
procedure SetcategoryCount(Index: Integer; const AInteger: Integer);
function categoryCount_Specified(Index: Integer): boolean;
procedure Setcategories(Index: Integer; const Acategories2: categories2);
function categories_Specified(Index: Integer): boolean;
public
constructor Create; override;
destructor Destroy; override;
published
property categoryCount: Integer Index (IS_OPTN or IS_UNQL) read FcategoryCount write SetcategoryCount stored categoryCount_Specified;
property categories: categories2 Index (IS_OPTN or IS_UNQL) read Fcategories write Setcategories stored categories_Specified;
end;
categoryVariantSpecValueType = class(TRemotable)
private
FvalueId: Int64;
FvalueId_Specified: boolean;
Fvalue: string;
Fvalue_Specified: boolean;
ForderNumber: Integer;
ForderNumber_Specified: boolean;
procedure SetvalueId(Index: Integer; const AInt64: Int64);
function valueId_Specified(Index: Integer): boolean;
procedure Setvalue(Index: Integer; const Astring: string);
function value_Specified(Index: Integer): boolean;
procedure SetorderNumber(Index: Integer; const AInteger: Integer);
function orderNumber_Specified(Index: Integer): boolean;
published
property valueId: Int64 Index (IS_ATTR or IS_OPTN) read FvalueId write SetvalueId stored valueId_Specified;
property value: string Index (IS_ATTR or IS_OPTN) read Fvalue write Setvalue stored value_Specified;
property orderNumber: Integer Index (IS_ATTR or IS_OPTN) read ForderNumber write SetorderNumber stored orderNumber_Specified;
end;
CategoryService = interface(IInvokable)
['{82374054-8B6E-ACCC-DE11-1E8E4140BA7F}']
// Cannot unwrap:
// - Input message has more than one part
// - Output part does not refer to an element
function getCategories(const startOffSet: Integer; const rowCount: Integer; const withSpecs: Boolean; const withDeepest: Boolean; const withCatalog: Boolean; const lang: string
): categoryServiceResponse; stdcall;
function getCategoriesByCodes(const categoryCodes: stringArray; const withSpecs: Boolean; const withDeepest: Boolean; const withCatalog: Boolean; const lang: string): categoryServiceResponse; stdcall;
function getCategoriesHavingVariantSpecs(const lang: string): categoryServiceResponse; stdcall;
function getCategory(const categoryCode: string; const withSpecs: Boolean; const withDeepest: Boolean; const withCatalog: Boolean; const lang: string): categoryServiceResponse; stdcall;
function getCategoryMetaData(const lang: string): categoryPermaServiceResponse; stdcall;
function getCategorySpecs(const categoryCode: string; const lang: string): categorySpecsServiceResponse; stdcall;
function getCategorySpecsWithDetail(const categoryCode: string; const lang: string): categorySpecsWithDetailServiceResponse; stdcall;
function getCategoryVariantSpecs(const categoryCode: string; const lang: string): categoryServiceVariantResponse; stdcall;
function getDeepestCategories(const startOffSet: Integer; const rowCount: Integer; const withSpecs: Boolean; const lang: string): categoryServiceResponse; stdcall;
function getDepositCategories(const lang: string): categoryServiceResponse; stdcall;
function getModifiedCategories(const changeTime: Int64; const startOffSet: Integer; const rowCount: Integer; const lang: string): categoryServiceAuditResponse; stdcall;
function getParentCategories(const withSpecs: Boolean; const withDeepest: Boolean; const withCatalog: Boolean; const lang: string): categoryServiceResponse; stdcall;
function getServiceName: string; stdcall;
function getSubCategories(const categoryCode: string; const withSpecs: Boolean; const withDeepest: Boolean; const withCatalog: Boolean; const lang: string): categoryServiceResponse; stdcall;
end;
function GetCategoryService(UseWSDL: Boolean=System.False; Addr: string=''; HTTPRIO: THTTPRIO = nil): CategoryService;
implementation
uses System.SysUtils;
function GetCategoryService(UseWSDL: Boolean; Addr: string; HTTPRIO: THTTPRIO): CategoryService;
const
defWSDL = 'http://dev.gittigidiyor.com:8080/listingapi/ws/CategoryService?wsdl';
defURL = 'http://dev.gittigidiyor.com:8080/listingapi/ws/CategoryService';
defSvc = 'CategoryServiceService';
defPrt = 'CategoryServicePort';
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 CategoryService);
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;
procedure errorType.SeterrorId(Index: Integer; const Astring: string);
begin
FerrorId := Astring;
FerrorId_Specified := True;
end;
function errorType.errorId_Specified(Index: Integer): boolean;
begin
Result := FerrorId_Specified;
end;
procedure errorType.SeterrorCode(Index: Integer; const Astring: string);
begin
FerrorCode := Astring;
FerrorCode_Specified := True;
end;
function errorType.errorCode_Specified(Index: Integer): boolean;
begin
Result := FerrorCode_Specified;
end;
procedure errorType.Setmessage_(Index: Integer; const Astring: string);
begin
Fmessage_ := Astring;
Fmessage__Specified := True;
end;
function errorType.message__Specified(Index: Integer): boolean;
begin
Result := Fmessage__Specified;
end;
procedure errorType.SetviewMessage(Index: Integer; const Astring: string);
begin
FviewMessage := Astring;
FviewMessage_Specified := True;
end;
function errorType.viewMessage_Specified(Index: Integer): boolean;
begin
Result := FviewMessage_Specified;
end;
procedure categoryPermaType.SetcategoryCode(Index: Integer; const Astring: string);
begin
FcategoryCode := Astring;
FcategoryCode_Specified := True;
end;
function categoryPermaType.categoryCode_Specified(Index: Integer): boolean;
begin
Result := FcategoryCode_Specified;
end;
procedure categoryPermaType.SetcategoryPerma(Index: Integer; const Astring: string);
begin
FcategoryPerma := Astring;
FcategoryPerma_Specified := True;
end;
function categoryPermaType.categoryPerma_Specified(Index: Integer): boolean;
begin
Result := FcategoryPerma_Specified;
end;
procedure categoryPermaType.SetbreadCrumbs(Index: Integer; const AbreadCrumbs: breadCrumbs);
begin
FbreadCrumbs := AbreadCrumbs;
FbreadCrumbs_Specified := True;
end;
function categoryPermaType.breadCrumbs_Specified(Index: Integer): boolean;
begin
Result := FbreadCrumbs_Specified;
end;
procedure baseAuditType.SetchangeType(Index: Integer; const Astring: string);
begin
FchangeType := Astring;
FchangeType_Specified := True;
end;
function baseAuditType.changeType_Specified(Index: Integer): boolean;
begin
Result := FchangeType_Specified;
end;
procedure categoryAuditType.SetcategoryCode(Index: Integer; const Astring: string);
begin
FcategoryCode := Astring;
FcategoryCode_Specified := True;
end;
function categoryAuditType.categoryCode_Specified(Index: Integer): boolean;
begin
Result := FcategoryCode_Specified;
end;
destructor baseResponse.Destroy;
begin
System.SysUtils.FreeAndNil(Ferror);
inherited Destroy;
end;
procedure baseResponse.SetackCode(Index: Integer; const Astring: string);
begin
FackCode := Astring;
FackCode_Specified := True;
end;
function baseResponse.ackCode_Specified(Index: Integer): boolean;
begin
Result := FackCode_Specified;
end;
procedure baseResponse.SetresponseTime(Index: Integer; const Astring: string);
begin
FresponseTime := Astring;
FresponseTime_Specified := True;
end;
function baseResponse.responseTime_Specified(Index: Integer): boolean;
begin
Result := FresponseTime_Specified;
end;
procedure baseResponse.Seterror(Index: Integer; const AerrorType: errorType);
begin
Ferror := AerrorType;
Ferror_Specified := True;
end;
function baseResponse.error_Specified(Index: Integer): boolean;
begin
Result := Ferror_Specified;
end;
procedure baseResponse.SettimeElapsed(Index: Integer; const Astring: string);
begin
FtimeElapsed := Astring;
FtimeElapsed_Specified := True;
end;
function baseResponse.timeElapsed_Specified(Index: Integer): boolean;
begin
Result := FtimeElapsed_Specified;
end;
constructor categorySpecsServiceResponse.Create;
begin
inherited Create;
FSerializationOptions := [xoLiteralParam];
end;
destructor categorySpecsServiceResponse.Destroy;
var
I: Integer;
begin
for I := 0 to System.Length(Fspecs)-1 do
System.SysUtils.FreeAndNil(Fspecs[I]);
System.SetLength(Fspecs, 0);
inherited Destroy;
end;
procedure categorySpecsServiceResponse.Setspecs(Index: Integer; const Aspecs2: specs2);
begin
Fspecs := Aspecs2;
Fspecs_Specified := True;
end;
function categorySpecsServiceResponse.specs_Specified(Index: Integer): boolean;
begin
Result := Fspecs_Specified;
end;
constructor categorySpecsWithDetailServiceResponse.Create;
begin
inherited Create;
FSerializationOptions := [xoLiteralParam];
end;
destructor categorySpecsWithDetailServiceResponse.Destroy;
var
I: Integer;
begin
for I := 0 to System.Length(Fspecs)-1 do
System.SysUtils.FreeAndNil(Fspecs[I]);
System.SetLength(Fspecs, 0);
inherited Destroy;
end;
procedure categorySpecsWithDetailServiceResponse.Setspecs(Index: Integer; const Aspecs: specs);
begin
Fspecs := Aspecs;
Fspecs_Specified := True;
end;
function categorySpecsWithDetailServiceResponse.specs_Specified(Index: Integer): boolean;
begin
Result := Fspecs_Specified;
end;
constructor categoryServiceVariantResponse.Create;
begin
inherited Create;
FSerializationOptions := [xoLiteralParam];
end;
destructor categoryServiceVariantResponse.Destroy;
var
I: Integer;
begin
for I := 0 to System.Length(Fspecs)-1 do
System.SysUtils.FreeAndNil(Fspecs[I]);
System.SetLength(Fspecs, 0);
inherited Destroy;
end;
procedure categoryServiceVariantResponse.SetspecCount(Index: Integer; const AInt64: Int64);
begin
FspecCount := AInt64;
FspecCount_Specified := True;
end;
function categoryServiceVariantResponse.specCount_Specified(Index: Integer): boolean;
begin
Result := FspecCount_Specified;
end;
procedure categoryServiceVariantResponse.Setspecs(Index: Integer; const Aspecs3: specs3);
begin
Fspecs := Aspecs3;
Fspecs_Specified := True;
end;
function categoryServiceVariantResponse.specs_Specified(Index: Integer): boolean;
begin
Result := Fspecs_Specified;
end;
constructor categoryPermaServiceResponse.Create;
begin
inherited Create;
FSerializationOptions := [xoLiteralParam];
end;
destructor categoryPermaServiceResponse.Destroy;
var
I: Integer;
begin
for I := 0 to System.Length(Fcategories)-1 do
System.SysUtils.FreeAndNil(Fcategories[I]);
System.SetLength(Fcategories, 0);
inherited Destroy;
end;
procedure categoryPermaServiceResponse.SetcategoryCount(Index: Integer; const AInteger: Integer);
begin
FcategoryCount := AInteger;
FcategoryCount_Specified := True;
end;
function categoryPermaServiceResponse.categoryCount_Specified(Index: Integer): boolean;
begin
Result := FcategoryCount_Specified;
end;
procedure categoryPermaServiceResponse.Setcategories(Index: Integer; const Acategories: categories);
begin
Fcategories := Acategories;
Fcategories_Specified := True;
end;
function categoryPermaServiceResponse.categories_Specified(Index: Integer): boolean;
begin
Result := Fcategories_Specified;
end;
procedure categorySpecValueType.SetspecId(Index: Integer; const AInteger: Integer);
begin
FspecId := AInteger;
FspecId_Specified := True;
end;
function categorySpecValueType.specId_Specified(Index: Integer): boolean;
begin
Result := FspecId_Specified;
end;
procedure categorySpecValueType.SetparentSpecId(Index: Integer; const AInteger: Integer);
begin
FparentSpecId := AInteger;
FparentSpecId_Specified := True;
end;
function categorySpecValueType.parentSpecId_Specified(Index: Integer): boolean;
begin
Result := FparentSpecId_Specified;
end;
procedure categorySpecValueType.Setname_(Index: Integer; const Astring: string);
begin
Fname_ := Astring;
Fname__Specified := True;
end;
function categorySpecValueType.name__Specified(Index: Integer): boolean;
begin
Result := Fname__Specified;
end;
constructor categoryServiceAuditResponse.Create;
begin
inherited Create;
FSerializationOptions := [xoLiteralParam];
end;
destructor categoryServiceAuditResponse.Destroy;
var
I: Integer;
begin
for I := 0 to System.Length(FcategoryAudits)-1 do
System.SysUtils.FreeAndNil(FcategoryAudits[I]);
System.SetLength(FcategoryAudits, 0);
inherited Destroy;
end;
procedure categoryServiceAuditResponse.SettotalCount(Index: Integer; const AInteger: Integer);
begin
FtotalCount := AInteger;
FtotalCount_Specified := True;
end;
function categoryServiceAuditResponse.totalCount_Specified(Index: Integer): boolean;
begin
Result := FtotalCount_Specified;
end;
procedure categoryServiceAuditResponse.Setcount(Index: Integer; const AInteger: Integer);
begin
Fcount := AInteger;
Fcount_Specified := True;
end;
function categoryServiceAuditResponse.count_Specified(Index: Integer): boolean;
begin
Result := Fcount_Specified;
end;
procedure categoryServiceAuditResponse.SetcategoryAudits(Index: Integer; const AcategoryAudits: categoryAudits);
begin
FcategoryAudits := AcategoryAudits;
FcategoryAudits_Specified := True;
end;
function categoryServiceAuditResponse.categoryAudits_Specified(Index: Integer): boolean;
begin
Result := FcategoryAudits_Specified;
end;
procedure categorySpecType.Setname_(Index: Integer; const Astring: string);
begin
Fname_ := Astring;
Fname__Specified := True;
end;
function categorySpecType.name__Specified(Index: Integer): boolean;
begin
Result := Fname__Specified;
end;
procedure categorySpecType.Setrequired(Index: Integer; const ABoolean: Boolean);
begin
Frequired := ABoolean;
Frequired_Specified := True;
end;
function categorySpecType.required_Specified(Index: Integer): boolean;
begin
Result := Frequired_Specified;
end;
procedure categorySpecType.Settype_(Index: Integer; const Astring: string);
begin
Ftype_ := Astring;
Ftype__Specified := True;
end;
function categorySpecType.type__Specified(Index: Integer): boolean;
begin
Result := Ftype__Specified;
end;
procedure categorySpecType.Setvalues(Index: Integer; const Avalues2: values2);
begin
Fvalues := Avalues2;
Fvalues_Specified := True;
end;
function categorySpecType.values_Specified(Index: Integer): boolean;
begin
Result := Fvalues_Specified;
end;
destructor categoryType.Destroy;
var
I: Integer;
begin
for I := 0 to System.Length(Fspecs)-1 do
System.SysUtils.FreeAndNil(Fspecs[I]);
System.SetLength(Fspecs, 0);
inherited Destroy;
end;
procedure categoryType.Setdeepest(Index: Integer; const ABoolean: Boolean);
begin
Fdeepest := ABoolean;
Fdeepest_Specified := True;
end;
function categoryType.deepest_Specified(Index: Integer): boolean;
begin
Result := Fdeepest_Specified;
end;
procedure categoryType.SethasCatalog(Index: Integer; const ABoolean: Boolean);
begin
FhasCatalog := ABoolean;
FhasCatalog_Specified := True;
end;
function categoryType.hasCatalog_Specified(Index: Integer): boolean;
begin
Result := FhasCatalog_Specified;
end;
procedure categoryType.SetcategoryCode(Index: Integer; const Astring: string);
begin
FcategoryCode := Astring;
FcategoryCode_Specified := True;
end;
function categoryType.categoryCode_Specified(Index: Integer): boolean;
begin
Result := FcategoryCode_Specified;
end;
procedure categoryType.SetcategoryName(Index: Integer; const Astring: string);
begin
FcategoryName := Astring;
FcategoryName_Specified := True;
end;
function categoryType.categoryName_Specified(Index: Integer): boolean;
begin
Result := FcategoryName_Specified;
end;
procedure categoryType.Setspecs(Index: Integer; const Aspecs4: specs4);
begin
Fspecs := Aspecs4;
Fspecs_Specified := True;
end;
function categoryType.specs_Specified(Index: Integer): boolean;
begin
Result := Fspecs_Specified;
end;
destructor categoryVariantSpecType.Destroy;
var
I: Integer;
begin
for I := 0 to System.Length(FspecValues)-1 do
System.SysUtils.FreeAndNil(FspecValues[I]);
System.SetLength(FspecValues, 0);
inherited Destroy;
end;
procedure categoryVariantSpecType.SetnameId(Index: Integer; const AInt64: Int64);
begin
FnameId := AInt64;
FnameId_Specified := True;
end;
function categoryVariantSpecType.nameId_Specified(Index: Integer): boolean;
begin
Result := FnameId_Specified;
end;
procedure categoryVariantSpecType.Setname_(Index: Integer; const Astring: string);
begin
Fname_ := Astring;
Fname__Specified := True;
end;
function categoryVariantSpecType.name__Specified(Index: Integer): boolean;
begin
Result := Fname__Specified;
end;
procedure categoryVariantSpecType.Settype_(Index: Integer; const Astring: string);
begin
Ftype_ := Astring;
Ftype__Specified := True;
end;
function categoryVariantSpecType.type__Specified(Index: Integer): boolean;
begin
Result := Ftype__Specified;
end;
procedure categoryVariantSpecType.SetorderNumber(Index: Integer; const AInteger: Integer);
begin
ForderNumber := AInteger;
ForderNumber_Specified := True;
end;
function categoryVariantSpecType.orderNumber_Specified(Index: Integer): boolean;
begin
Result := ForderNumber_Specified;
end;
procedure categoryVariantSpecType.Setbase(Index: Integer; const ABoolean: Boolean);
begin
Fbase := ABoolean;
Fbase_Specified := True;
end;
function categoryVariantSpecType.base_Specified(Index: Integer): boolean;
begin
Result := Fbase_Specified;
end;
procedure categoryVariantSpecType.SetspecValues(Index: Integer; const AspecValues: specValues);
begin
FspecValues := AspecValues;
FspecValues_Specified := True;
end;
function categoryVariantSpecType.specValues_Specified(Index: Integer): boolean;
begin
Result := FspecValues_Specified;
end;
destructor categorySpecWithDetailType.Destroy;
var
I: Integer;
begin
for I := 0 to System.Length(Fvalues)-1 do
System.SysUtils.FreeAndNil(Fvalues[I]);
System.SetLength(Fvalues, 0);
inherited Destroy;
end;
procedure categorySpecWithDetailType.Setname_(Index: Integer; const Astring: string);
begin
Fname_ := Astring;
Fname__Specified := True;
end;
function categorySpecWithDetailType.name__Specified(Index: Integer): boolean;
begin
Result := Fname__Specified;
end;
procedure categorySpecWithDetailType.Setrequired(Index: Integer; const ABoolean: Boolean);
begin
Frequired := ABoolean;
Frequired_Specified := True;
end;
function categorySpecWithDetailType.required_Specified(Index: Integer): boolean;
begin
Result := Frequired_Specified;
end;
procedure categorySpecWithDetailType.Settype_(Index: Integer; const Astring: string);
begin
Ftype_ := Astring;
Ftype__Specified := True;
end;
function categorySpecWithDetailType.type__Specified(Index: Integer): boolean;
begin
Result := Ftype__Specified;
end;
procedure categorySpecWithDetailType.SetspecId(Index: Integer; const AInteger: Integer);
begin
FspecId := AInteger;
FspecId_Specified := True;
end;
function categorySpecWithDetailType.specId_Specified(Index: Integer): boolean;
begin
Result := FspecId_Specified;
end;
procedure categorySpecWithDetailType.SetchildSpecId(Index: Integer; const AInteger: Integer);
begin
FchildSpecId := AInteger;
FchildSpecId_Specified := True;
end;
function categorySpecWithDetailType.childSpecId_Specified(Index: Integer): boolean;
begin
Result := FchildSpecId_Specified;
end;
procedure categorySpecWithDetailType.Setvalues(Index: Integer; const Avalues: values);
begin
Fvalues := Avalues;
Fvalues_Specified := True;
end;
function categorySpecWithDetailType.values_Specified(Index: Integer): boolean;
begin
Result := Fvalues_Specified;
end;
constructor categoryServiceResponse.Create;
begin
inherited Create;
FSerializationOptions := [xoLiteralParam];
end;
destructor categoryServiceResponse.Destroy;
var
I: Integer;
begin
for I := 0 to System.Length(Fcategories)-1 do
System.SysUtils.FreeAndNil(Fcategories[I]);
System.SetLength(Fcategories, 0);
inherited Destroy;
end;
procedure categoryServiceResponse.SetcategoryCount(Index: Integer; const AInteger: Integer);
begin
FcategoryCount := AInteger;
FcategoryCount_Specified := True;
end;
function categoryServiceResponse.categoryCount_Specified(Index: Integer): boolean;
begin
Result := FcategoryCount_Specified;
end;
procedure categoryServiceResponse.Setcategories(Index: Integer; const Acategories2: categories2);
begin
Fcategories := Acategories2;
Fcategories_Specified := True;
end;
function categoryServiceResponse.categories_Specified(Index: Integer): boolean;
begin
Result := Fcategories_Specified;
end;
procedure categoryVariantSpecValueType.SetvalueId(Index: Integer; const AInt64: Int64);
begin
FvalueId := AInt64;
FvalueId_Specified := True;
end;
function categoryVariantSpecValueType.valueId_Specified(Index: Integer): boolean;
begin
Result := FvalueId_Specified;
end;
procedure categoryVariantSpecValueType.Setvalue(Index: Integer; const Astring: string);
begin
Fvalue := Astring;
Fvalue_Specified := True;
end;
function categoryVariantSpecValueType.value_Specified(Index: Integer): boolean;
begin
Result := Fvalue_Specified;
end;
procedure categoryVariantSpecValueType.SetorderNumber(Index: Integer; const AInteger: Integer);
begin
ForderNumber := AInteger;
ForderNumber_Specified := True;
end;
function categoryVariantSpecValueType.orderNumber_Specified(Index: Integer): boolean;
begin
Result := ForderNumber_Specified;
end;
initialization
{ CategoryService }
InvRegistry.RegisterInterface(TypeInfo(CategoryService), 'http://category.anonymous.ws.listingapi.gg.com', '');
InvRegistry.RegisterDefaultSOAPAction(TypeInfo(CategoryService), '');
InvRegistry.RegisterInvokeOptions(TypeInfo(CategoryService), ioLiteral);
{ CategoryService.getCategories }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getCategories', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getCategoriesByCodes }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getCategoriesByCodes', 'categoryCodes', '',
'[Namespace="http://jaxb.dev.java.net/array", ArrayItemName="item"]');
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getCategoriesByCodes', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getCategoriesHavingVariantSpecs }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getCategoriesHavingVariantSpecs', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getCategory }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getCategory', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getCategoryMetaData }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getCategoryMetaData', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getCategorySpecs }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getCategorySpecs', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getCategorySpecsWithDetail }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getCategorySpecsWithDetail', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getCategoryVariantSpecs }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getCategoryVariantSpecs', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getDeepestCategories }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getDeepestCategories', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getDepositCategories }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getDepositCategories', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getModifiedCategories }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getModifiedCategories', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getParentCategories }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getParentCategories', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
{ CategoryService.getSubCategories }
InvRegistry.RegisterParamInfo(TypeInfo(CategoryService), 'getSubCategories', 'return', '',
'[Namespace="http://category.anonymous.ws.listingapi.gg.com"]');
RemClassRegistry.RegisterXSInfo(TypeInfo(specs), 'http://category.anonymous.ws.listingapi.gg.com', 'specs');
RemClassRegistry.RegisterXSInfo(TypeInfo(categoryAudits), 'http://category.anonymous.ws.listingapi.gg.com', 'categoryAudits');
RemClassRegistry.RegisterXSInfo(TypeInfo(values), 'http://category.anonymous.ws.listingapi.gg.com', 'values');
RemClassRegistry.RegisterXSInfo(TypeInfo(specs2), 'http://category.anonymous.ws.listingapi.gg.com', 'specs2', 'specs');
RemClassRegistry.RegisterXSInfo(TypeInfo(categories), 'http://category.anonymous.ws.listingapi.gg.com', 'categories');
RemClassRegistry.RegisterXSInfo(TypeInfo(specs3), 'http://category.anonymous.ws.listingapi.gg.com', 'specs3', 'specs');
RemClassRegistry.RegisterXSClass(errorType, 'http://category.anonymous.ws.listingapi.gg.com', 'errorType');
RemClassRegistry.RegisterExternalPropName(TypeInfo(errorType), 'message_', '[ExtName="message"]');
RemClassRegistry.RegisterXSInfo(TypeInfo(values2), 'http://category.anonymous.ws.listingapi.gg.com', 'values2', 'values');
RemClassRegistry.RegisterXSInfo(TypeInfo(breadCrumbs), 'http://category.anonymous.ws.listingapi.gg.com', 'breadCrumbs');
RemClassRegistry.RegisterXSClass(categoryPermaType, 'http://category.anonymous.ws.listingapi.gg.com', 'categoryPermaType');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categoryPermaType), 'breadCrumbs', '[ArrayItemName="breadCrumb"]');
RemClassRegistry.RegisterXSClass(baseAuditType, 'http://category.anonymous.ws.listingapi.gg.com', 'baseAuditType');
RemClassRegistry.RegisterXSClass(categoryAuditType, 'http://category.anonymous.ws.listingapi.gg.com', 'categoryAuditType');
RemClassRegistry.RegisterXSInfo(TypeInfo(stringArray), 'http://jaxb.dev.java.net/array', 'stringArray');
RemClassRegistry.RegisterSerializeOptions(TypeInfo(stringArray), [xoLiteralParam]);
RemClassRegistry.RegisterXSClass(baseResponse, 'http://category.anonymous.ws.listingapi.gg.com', 'baseResponse');
RemClassRegistry.RegisterXSClass(categorySpecsServiceResponse, 'http://category.anonymous.ws.listingapi.gg.com', 'categorySpecsServiceResponse');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categorySpecsServiceResponse), 'specs', '[ArrayItemName="spec"]');
RemClassRegistry.RegisterSerializeOptions(categorySpecsServiceResponse, [xoLiteralParam]);
RemClassRegistry.RegisterXSClass(categorySpecsWithDetailServiceResponse, 'http://category.anonymous.ws.listingapi.gg.com', 'categorySpecsWithDetailServiceResponse');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categorySpecsWithDetailServiceResponse), 'specs', '[ArrayItemName="spec"]');
RemClassRegistry.RegisterSerializeOptions(categorySpecsWithDetailServiceResponse, [xoLiteralParam]);
RemClassRegistry.RegisterXSClass(categoryServiceVariantResponse, 'http://category.anonymous.ws.listingapi.gg.com', 'categoryServiceVariantResponse');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categoryServiceVariantResponse), 'specs', '[ArrayItemName="spec"]');
RemClassRegistry.RegisterSerializeOptions(categoryServiceVariantResponse, [xoLiteralParam]);
RemClassRegistry.RegisterXSClass(categoryPermaServiceResponse, 'http://category.anonymous.ws.listingapi.gg.com', 'categoryPermaServiceResponse');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categoryPermaServiceResponse), 'categories', '[ArrayItemName="category"]');
RemClassRegistry.RegisterSerializeOptions(categoryPermaServiceResponse, [xoLiteralParam]);
RemClassRegistry.RegisterXSClass(categorySpecValueType, 'http://category.anonymous.ws.listingapi.gg.com', 'categorySpecValueType');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categorySpecValueType), 'name_', '[ExtName="name"]');
RemClassRegistry.RegisterXSClass(categoryServiceAuditResponse, 'http://category.anonymous.ws.listingapi.gg.com', 'categoryServiceAuditResponse');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categoryServiceAuditResponse), 'categoryAudits', '[ArrayItemName="categoryAudit"]');
RemClassRegistry.RegisterSerializeOptions(categoryServiceAuditResponse, [xoLiteralParam]);
RemClassRegistry.RegisterXSInfo(TypeInfo(categories2), 'http://category.anonymous.ws.listingapi.gg.com', 'categories2', 'categories');
RemClassRegistry.RegisterXSInfo(TypeInfo(specs4), 'http://category.anonymous.ws.listingapi.gg.com', 'specs4', 'specs');
RemClassRegistry.RegisterXSInfo(TypeInfo(specValues), 'http://category.anonymous.ws.listingapi.gg.com', 'specValues');
RemClassRegistry.RegisterXSClass(categorySpecType, 'http://category.anonymous.ws.listingapi.gg.com', 'categorySpecType');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categorySpecType), 'name_', '[ExtName="name"]');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categorySpecType), 'type_', '[ExtName="type"]');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categorySpecType), 'values', '[ArrayItemName="value"]');
RemClassRegistry.RegisterXSClass(categoryType, 'http://category.anonymous.ws.listingapi.gg.com', 'categoryType');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categoryType), 'specs', '[ArrayItemName="spec"]');
RemClassRegistry.RegisterXSClass(categoryVariantSpecType, 'http://category.anonymous.ws.listingapi.gg.com', 'categoryVariantSpecType');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categoryVariantSpecType), 'name_', '[ExtName="name"]');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categoryVariantSpecType), 'type_', '[ExtName="type"]');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categoryVariantSpecType), 'specValues', '[ArrayItemName="specValue"]');
RemClassRegistry.RegisterXSClass(categorySpecWithDetailType, 'http://category.anonymous.ws.listingapi.gg.com', 'categorySpecWithDetailType');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categorySpecWithDetailType), 'name_', '[ExtName="name"]');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categorySpecWithDetailType), 'type_', '[ExtName="type"]');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categorySpecWithDetailType), 'values', '[ArrayItemName="value"]');
RemClassRegistry.RegisterXSClass(categoryServiceResponse, 'http://category.anonymous.ws.listingapi.gg.com', 'categoryServiceResponse');
RemClassRegistry.RegisterExternalPropName(TypeInfo(categoryServiceResponse), 'categories', '[ArrayItemName="category"]');
RemClassRegistry.RegisterSerializeOptions(categoryServiceResponse, [xoLiteralParam]);
RemClassRegistry.RegisterXSClass(categoryVariantSpecValueType, 'http://category.anonymous.ws.listingapi.gg.com', 'categoryVariantSpecValueType');
end.
Kod: Tümünü seç
var
Result : categoryServiceResponse;
Category : CategoryService;
begin
Category:= GetCategoryService(False,'',nil);
Result := Category.getCategory('sgf', True, True, True,'tr');
result.categories :=????????