client.go raw

   1  // This file is auto-generated, don't edit it. Thanks.
   2  package client
   3  
   4  import (
   5  	"encoding/hex"
   6  
   7  	spi "github.com/alibabacloud-go/alibabacloud-gateway-spi/client"
   8  	models "github.com/alibabacloud-go/darabonba-openapi/v2/models"
   9  	openapiutil "github.com/alibabacloud-go/darabonba-openapi/v2/utils"
  10  	"github.com/alibabacloud-go/tea/dara"
  11  	credential "github.com/aliyun/credentials-go/credentials"
  12  )
  13  
  14  type Config = models.Config
  15  type GlobalParameters = models.GlobalParameters
  16  type Params = models.Params
  17  type OpenApiRequest = models.OpenApiRequest
  18  type Client struct {
  19  	DisableSDKError      *bool
  20  	Endpoint             *string
  21  	RegionId             *string
  22  	Protocol             *string
  23  	Method               *string
  24  	UserAgent            *string
  25  	EndpointRule         *string
  26  	EndpointMap          map[string]*string
  27  	Suffix               *string
  28  	ReadTimeout          *int
  29  	ConnectTimeout       *int
  30  	HttpProxy            *string
  31  	HttpsProxy           *string
  32  	Socks5Proxy          *string
  33  	Socks5NetWork        *string
  34  	NoProxy              *string
  35  	Network              *string
  36  	ProductId            *string
  37  	MaxIdleConns         *int
  38  	EndpointType         *string
  39  	OpenPlatformEndpoint *string
  40  	Credential           credential.Credential
  41  	SignatureVersion     *string
  42  	SignatureAlgorithm   *string
  43  	Headers              map[string]*string
  44  	Spi                  spi.ClientInterface
  45  	GlobalParameters     *openapiutil.GlobalParameters
  46  	Key                  *string
  47  	Cert                 *string
  48  	Ca                   *string
  49  	DisableHttp2         *bool
  50  	RetryOptions         *dara.RetryOptions
  51  	HttpClient           dara.HttpClient
  52  	TlsMinVersion        *string
  53  	AttributeMap         *spi.AttributeMap
  54  }
  55  
  56  // Description:
  57  //
  58  // # Init client with Config
  59  //
  60  // @param config - config contains the necessary information to create a client
  61  func NewClient(config *openapiutil.Config) (*Client, error) {
  62  	client := new(Client)
  63  	err := client.Init(config)
  64  	return client, err
  65  }
  66  
  67  func (client *Client) Init(config *openapiutil.Config) (_err error) {
  68  	if dara.IsNil(config) {
  69  		_err = &ClientError{
  70  			Code:    dara.String("ParameterMissing"),
  71  			Message: dara.String("'config' can not be unset"),
  72  		}
  73  		return _err
  74  	}
  75  
  76  	if (!dara.IsNil(config.AccessKeyId) && dara.StringValue(config.AccessKeyId) != "") && (!dara.IsNil(config.AccessKeySecret) && dara.StringValue(config.AccessKeySecret) != "") {
  77  		if !dara.IsNil(config.SecurityToken) && dara.StringValue(config.SecurityToken) != "" {
  78  			config.Type = dara.String("sts")
  79  		} else {
  80  			config.Type = dara.String("access_key")
  81  		}
  82  
  83  		credentialConfig := &credential.Config{
  84  			AccessKeyId:     config.AccessKeyId,
  85  			Type:            config.Type,
  86  			AccessKeySecret: config.AccessKeySecret,
  87  		}
  88  		credentialConfig.SecurityToken = config.SecurityToken
  89  		client.Credential, _err = credential.NewCredential(credentialConfig)
  90  		if _err != nil {
  91  			return _err
  92  		}
  93  
  94  	} else if !dara.IsNil(config.BearerToken) && dara.StringValue(config.BearerToken) != "" {
  95  		cc := &credential.Config{
  96  			Type:        dara.String("bearer"),
  97  			BearerToken: config.BearerToken,
  98  		}
  99  		client.Credential, _err = credential.NewCredential(cc)
 100  		if _err != nil {
 101  			return _err
 102  		}
 103  
 104  	} else if !dara.IsNil(config.Credential) {
 105  		client.Credential = config.Credential
 106  	}
 107  
 108  	client.Endpoint = config.Endpoint
 109  	client.EndpointType = config.EndpointType
 110  	client.Network = config.Network
 111  	client.Suffix = config.Suffix
 112  	client.Protocol = config.Protocol
 113  	client.Method = config.Method
 114  	client.RegionId = config.RegionId
 115  	client.UserAgent = config.UserAgent
 116  	client.ReadTimeout = config.ReadTimeout
 117  	client.ConnectTimeout = config.ConnectTimeout
 118  	client.HttpProxy = config.HttpProxy
 119  	client.HttpsProxy = config.HttpsProxy
 120  	client.NoProxy = config.NoProxy
 121  	client.Socks5Proxy = config.Socks5Proxy
 122  	client.Socks5NetWork = config.Socks5NetWork
 123  	client.MaxIdleConns = config.MaxIdleConns
 124  	client.SignatureVersion = config.SignatureVersion
 125  	client.SignatureAlgorithm = config.SignatureAlgorithm
 126  	client.GlobalParameters = config.GlobalParameters
 127  	client.Key = config.Key
 128  	client.Cert = config.Cert
 129  	client.Ca = config.Ca
 130  	client.DisableHttp2 = config.DisableHttp2
 131  	client.RetryOptions = config.RetryOptions
 132  	client.HttpClient = config.HttpClient
 133  	client.TlsMinVersion = config.TlsMinVersion
 134  	return nil
 135  }
 136  
 137  // Description:
 138  //
 139  // # Encapsulate the request and invoke the network
 140  //
 141  // @param action - api name
 142  //
 143  // @param version - product version
 144  //
 145  // @param protocol - http or https
 146  //
 147  // @param method - e.g. GET
 148  //
 149  // @param authType - authorization type e.g. AK
 150  //
 151  // @param bodyType - response body type e.g. String
 152  //
 153  // @param request - object of OpenApiRequest
 154  //
 155  // @param runtime - which controls some details of call api, such as retry times
 156  //
 157  // @return the response
 158  func (client *Client) DoRPCRequest(action *string, version *string, protocol *string, method *string, authType *string, bodyType *string, request *openapiutil.OpenApiRequest, runtime *dara.RuntimeOptions) (_result map[string]interface{}, _err error) {
 159  	_runtime := dara.NewRuntimeObject(map[string]interface{}{
 160  		"key":            dara.ToString(dara.Default(dara.StringValue(runtime.Key), dara.StringValue(client.Key))),
 161  		"cert":           dara.ToString(dara.Default(dara.StringValue(runtime.Cert), dara.StringValue(client.Cert))),
 162  		"ca":             dara.ToString(dara.Default(dara.StringValue(runtime.Ca), dara.StringValue(client.Ca))),
 163  		"readTimeout":    dara.ForceInt(dara.Default(dara.IntValue(runtime.ReadTimeout), dara.IntValue(client.ReadTimeout))),
 164  		"connectTimeout": dara.ForceInt(dara.Default(dara.IntValue(runtime.ConnectTimeout), dara.IntValue(client.ConnectTimeout))),
 165  		"httpProxy":      dara.ToString(dara.Default(dara.StringValue(runtime.HttpProxy), dara.StringValue(client.HttpProxy))),
 166  		"httpsProxy":     dara.ToString(dara.Default(dara.StringValue(runtime.HttpsProxy), dara.StringValue(client.HttpsProxy))),
 167  		"noProxy":        dara.ToString(dara.Default(dara.StringValue(runtime.NoProxy), dara.StringValue(client.NoProxy))),
 168  		"socks5Proxy":    dara.ToString(dara.Default(dara.StringValue(runtime.Socks5Proxy), dara.StringValue(client.Socks5Proxy))),
 169  		"socks5NetWork":  dara.ToString(dara.Default(dara.StringValue(runtime.Socks5NetWork), dara.StringValue(client.Socks5NetWork))),
 170  		"maxIdleConns":   dara.ForceInt(dara.Default(dara.IntValue(runtime.MaxIdleConns), dara.IntValue(client.MaxIdleConns))),
 171  		"retryOptions":   client.RetryOptions,
 172  		"ignoreSSL":      dara.BoolValue(runtime.IgnoreSSL),
 173  		"httpClient":     client.HttpClient,
 174  		"tlsMinVersion":  dara.StringValue(client.TlsMinVersion),
 175  	})
 176  
 177  	var retryPolicyContext *dara.RetryPolicyContext
 178  	var request_ *dara.Request
 179  	var response_ *dara.Response
 180  	var _resultErr error
 181  	retriesAttempted := int(0)
 182  	retryPolicyContext = &dara.RetryPolicyContext{
 183  		RetriesAttempted: retriesAttempted,
 184  	}
 185  
 186  	_result = make(map[string]interface{})
 187  	for dara.ShouldRetry(_runtime.RetryOptions, retryPolicyContext) {
 188  		_resultErr = nil
 189  		_backoffDelayTime := dara.GetBackoffDelay(_runtime.RetryOptions, retryPolicyContext)
 190  		dara.Sleep(_backoffDelayTime)
 191  
 192  		request_ = dara.NewRequest()
 193  		request_.Protocol = dara.String(dara.ToString(dara.Default(dara.StringValue(client.Protocol), dara.StringValue(protocol))))
 194  		request_.Method = method
 195  		request_.Pathname = dara.String("/")
 196  		globalQueries := make(map[string]*string)
 197  		globalHeaders := make(map[string]*string)
 198  		if !dara.IsNil(client.GlobalParameters) {
 199  			globalParams := client.GlobalParameters
 200  			if !dara.IsNil(globalParams.Queries) {
 201  				globalQueries = globalParams.Queries
 202  			}
 203  
 204  			if !dara.IsNil(globalParams.Headers) {
 205  				globalHeaders = globalParams.Headers
 206  			}
 207  
 208  		}
 209  
 210  		extendsHeaders := make(map[string]*string)
 211  		extendsQueries := make(map[string]*string)
 212  		if !dara.IsNil(runtime.ExtendsParameters) {
 213  			extendsParameters := runtime.ExtendsParameters
 214  			if !dara.IsNil(extendsParameters.Headers) {
 215  				extendsHeaders = extendsParameters.Headers
 216  			}
 217  
 218  			if !dara.IsNil(extendsParameters.Queries) {
 219  				extendsQueries = extendsParameters.Queries
 220  			}
 221  
 222  		}
 223  
 224  		request_.Query = dara.Merge(map[string]*string{
 225  			"Action":         action,
 226  			"Format":         dara.String("json"),
 227  			"Version":        version,
 228  			"Timestamp":      openapiutil.GetTimestamp(),
 229  			"SignatureNonce": openapiutil.GetNonce(),
 230  		}, globalQueries,
 231  			extendsQueries,
 232  			request.Query)
 233  		headers, _err := client.GetRpcHeaders()
 234  		if _err != nil {
 235  			retriesAttempted++
 236  			retryPolicyContext = &dara.RetryPolicyContext{
 237  				RetriesAttempted: retriesAttempted,
 238  				HttpRequest:      request_,
 239  				HttpResponse:     response_,
 240  				Exception:        _err,
 241  			}
 242  			_resultErr = _err
 243  			continue
 244  		}
 245  
 246  		if dara.IsNil(headers) {
 247  			// endpoint is setted in product client
 248  			request_.Headers = dara.Merge(map[string]*string{
 249  				"host":          client.Endpoint,
 250  				"x-acs-version": version,
 251  				"x-acs-action":  action,
 252  				"user-agent":    openapiutil.GetUserAgent(client.UserAgent),
 253  			}, globalHeaders,
 254  				extendsHeaders,
 255  				request.Headers)
 256  		} else {
 257  			request_.Headers = dara.Merge(map[string]*string{
 258  				"host":          client.Endpoint,
 259  				"x-acs-version": version,
 260  				"x-acs-action":  action,
 261  				"user-agent":    openapiutil.GetUserAgent(client.UserAgent),
 262  			}, globalHeaders,
 263  				extendsHeaders,
 264  				request.Headers,
 265  				headers)
 266  		}
 267  
 268  		if !dara.IsNil(request.Body) {
 269  			m := dara.ToMap(request.Body)
 270  			tmp := dara.ToMap(openapiutil.Query(m))
 271  			request_.Body = dara.ToReader(dara.ToFormString(tmp))
 272  			request_.Headers["content-type"] = dara.String("application/x-www-form-urlencoded")
 273  		}
 274  
 275  		if dara.StringValue(authType) != "Anonymous" {
 276  			if dara.IsNil(client.Credential) {
 277  				_err = &ClientError{
 278  					Code:    dara.String("InvalidCredentials"),
 279  					Message: dara.String("Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details."),
 280  				}
 281  				if dara.BoolValue(client.DisableSDKError) != true {
 282  					_err = dara.TeaSDKError(_err)
 283  				}
 284  				return _result, _err
 285  			}
 286  
 287  			credentialModel, _err := client.Credential.GetCredential()
 288  			if _err != nil {
 289  				retriesAttempted++
 290  				retryPolicyContext = &dara.RetryPolicyContext{
 291  					RetriesAttempted: retriesAttempted,
 292  					HttpRequest:      request_,
 293  					HttpResponse:     response_,
 294  					Exception:        _err,
 295  				}
 296  				_resultErr = _err
 297  				continue
 298  			}
 299  
 300  			if !dara.IsNil(credentialModel.ProviderName) {
 301  				request_.Headers["x-acs-credentials-provider"] = credentialModel.ProviderName
 302  			}
 303  
 304  			credentialType := dara.StringValue(credentialModel.Type)
 305  			if credentialType == "bearer" {
 306  				bearerToken := dara.StringValue(credentialModel.BearerToken)
 307  				request_.Query["BearerToken"] = dara.String(bearerToken)
 308  				request_.Query["SignatureType"] = dara.String("BEARERTOKEN")
 309  			} else if credentialType == "id_token" {
 310  				idToken := dara.StringValue(credentialModel.SecurityToken)
 311  				request_.Headers["x-acs-zero-trust-idtoken"] = dara.String(idToken)
 312  			} else {
 313  				accessKeyId := dara.StringValue(credentialModel.AccessKeyId)
 314  				accessKeySecret := dara.StringValue(credentialModel.AccessKeySecret)
 315  				securityToken := dara.StringValue(credentialModel.SecurityToken)
 316  				if !dara.IsNil(dara.String(securityToken)) && securityToken != "" {
 317  					request_.Query["SecurityToken"] = dara.String(securityToken)
 318  				}
 319  
 320  				request_.Query["SignatureMethod"] = dara.String("HMAC-SHA1")
 321  				request_.Query["SignatureVersion"] = dara.String("1.0")
 322  				request_.Query["AccessKeyId"] = dara.String(accessKeyId)
 323  				var t map[string]interface{}
 324  				if !dara.IsNil(request.Body) {
 325  					t = dara.ToMap(request.Body)
 326  				}
 327  
 328  				signedParam := dara.Merge(request_.Query,
 329  					openapiutil.Query(t))
 330  				request_.Query["Signature"] = openapiutil.GetRPCSignature(signedParam, request_.Method, dara.String(accessKeySecret))
 331  			}
 332  
 333  		}
 334  
 335  		response_, _err := dara.DoRequest(request_, _runtime)
 336  		if _err != nil {
 337  			retriesAttempted++
 338  			retryPolicyContext = &dara.RetryPolicyContext{
 339  				RetriesAttempted: retriesAttempted,
 340  				HttpRequest:      request_,
 341  				HttpResponse:     response_,
 342  				Exception:        _err,
 343  			}
 344  			_resultErr = _err
 345  			continue
 346  		}
 347  
 348  		_result, _err = doRPCRequest_opResponse(response_, client, bodyType)
 349  		if _err != nil {
 350  			retriesAttempted++
 351  			retryPolicyContext = &dara.RetryPolicyContext{
 352  				RetriesAttempted: retriesAttempted,
 353  				HttpRequest:      request_,
 354  				HttpResponse:     response_,
 355  				Exception:        _err,
 356  			}
 357  			_resultErr = _err
 358  			continue
 359  		}
 360  
 361  		return _result, _err
 362  	}
 363  	if dara.BoolValue(client.DisableSDKError) != true {
 364  		_resultErr = dara.TeaSDKError(_resultErr)
 365  	}
 366  	return _result, _resultErr
 367  }
 368  
 369  // Description:
 370  //
 371  // # Encapsulate the request and invoke the network
 372  //
 373  // @param action - api name
 374  //
 375  // @param version - product version
 376  //
 377  // @param protocol - http or https
 378  //
 379  // @param method - e.g. GET
 380  //
 381  // @param authType - authorization type e.g. AK
 382  //
 383  // @param pathname - pathname of every api
 384  //
 385  // @param bodyType - response body type e.g. String
 386  //
 387  // @param request - object of OpenApiRequest
 388  //
 389  // @param runtime - which controls some details of call api, such as retry times
 390  //
 391  // @return the response
 392  func (client *Client) DoROARequest(action *string, version *string, protocol *string, method *string, authType *string, pathname *string, bodyType *string, request *openapiutil.OpenApiRequest, runtime *dara.RuntimeOptions) (_result map[string]interface{}, _err error) {
 393  	_runtime := dara.NewRuntimeObject(map[string]interface{}{
 394  		"key":            dara.ToString(dara.Default(dara.StringValue(runtime.Key), dara.StringValue(client.Key))),
 395  		"cert":           dara.ToString(dara.Default(dara.StringValue(runtime.Cert), dara.StringValue(client.Cert))),
 396  		"ca":             dara.ToString(dara.Default(dara.StringValue(runtime.Ca), dara.StringValue(client.Ca))),
 397  		"readTimeout":    dara.ForceInt(dara.Default(dara.IntValue(runtime.ReadTimeout), dara.IntValue(client.ReadTimeout))),
 398  		"connectTimeout": dara.ForceInt(dara.Default(dara.IntValue(runtime.ConnectTimeout), dara.IntValue(client.ConnectTimeout))),
 399  		"httpProxy":      dara.ToString(dara.Default(dara.StringValue(runtime.HttpProxy), dara.StringValue(client.HttpProxy))),
 400  		"httpsProxy":     dara.ToString(dara.Default(dara.StringValue(runtime.HttpsProxy), dara.StringValue(client.HttpsProxy))),
 401  		"noProxy":        dara.ToString(dara.Default(dara.StringValue(runtime.NoProxy), dara.StringValue(client.NoProxy))),
 402  		"socks5Proxy":    dara.ToString(dara.Default(dara.StringValue(runtime.Socks5Proxy), dara.StringValue(client.Socks5Proxy))),
 403  		"socks5NetWork":  dara.ToString(dara.Default(dara.StringValue(runtime.Socks5NetWork), dara.StringValue(client.Socks5NetWork))),
 404  		"maxIdleConns":   dara.ForceInt(dara.Default(dara.IntValue(runtime.MaxIdleConns), dara.IntValue(client.MaxIdleConns))),
 405  		"retryOptions":   client.RetryOptions,
 406  		"ignoreSSL":      dara.BoolValue(runtime.IgnoreSSL),
 407  		"httpClient":     client.HttpClient,
 408  		"tlsMinVersion":  dara.StringValue(client.TlsMinVersion),
 409  	})
 410  
 411  	var retryPolicyContext *dara.RetryPolicyContext
 412  	var request_ *dara.Request
 413  	var response_ *dara.Response
 414  	var _resultErr error
 415  	retriesAttempted := int(0)
 416  	retryPolicyContext = &dara.RetryPolicyContext{
 417  		RetriesAttempted: retriesAttempted,
 418  	}
 419  
 420  	_result = make(map[string]interface{})
 421  	for dara.ShouldRetry(_runtime.RetryOptions, retryPolicyContext) {
 422  		_resultErr = nil
 423  		_backoffDelayTime := dara.GetBackoffDelay(_runtime.RetryOptions, retryPolicyContext)
 424  		dara.Sleep(_backoffDelayTime)
 425  
 426  		request_ = dara.NewRequest()
 427  		request_.Protocol = dara.String(dara.ToString(dara.Default(dara.StringValue(client.Protocol), dara.StringValue(protocol))))
 428  		request_.Method = method
 429  		request_.Pathname = pathname
 430  		globalQueries := make(map[string]*string)
 431  		globalHeaders := make(map[string]*string)
 432  		if !dara.IsNil(client.GlobalParameters) {
 433  			globalParams := client.GlobalParameters
 434  			if !dara.IsNil(globalParams.Queries) {
 435  				globalQueries = globalParams.Queries
 436  			}
 437  
 438  			if !dara.IsNil(globalParams.Headers) {
 439  				globalHeaders = globalParams.Headers
 440  			}
 441  
 442  		}
 443  
 444  		extendsHeaders := make(map[string]*string)
 445  		extendsQueries := make(map[string]*string)
 446  		if !dara.IsNil(runtime.ExtendsParameters) {
 447  			extendsParameters := runtime.ExtendsParameters
 448  			if !dara.IsNil(extendsParameters.Headers) {
 449  				extendsHeaders = extendsParameters.Headers
 450  			}
 451  
 452  			if !dara.IsNil(extendsParameters.Queries) {
 453  				extendsQueries = extendsParameters.Queries
 454  			}
 455  
 456  		}
 457  
 458  		request_.Headers = dara.Merge(map[string]*string{
 459  			"date":                    openapiutil.GetDateUTCString(),
 460  			"host":                    client.Endpoint,
 461  			"accept":                  dara.String("application/json"),
 462  			"x-acs-signature-nonce":   openapiutil.GetNonce(),
 463  			"x-acs-signature-method":  dara.String("HMAC-SHA1"),
 464  			"x-acs-signature-version": dara.String("1.0"),
 465  			"x-acs-version":           version,
 466  			"x-acs-action":            action,
 467  			"user-agent":              openapiutil.GetUserAgent(client.UserAgent),
 468  		}, globalHeaders,
 469  			extendsHeaders,
 470  			request.Headers)
 471  		if !dara.IsNil(request.Body) {
 472  			request_.Body = dara.ToReader(dara.Stringify(request.Body))
 473  			request_.Headers["content-type"] = dara.String("application/json; charset=utf-8")
 474  		}
 475  
 476  		request_.Query = dara.Merge(globalQueries,
 477  			extendsQueries)
 478  		if !dara.IsNil(request.Query) {
 479  			request_.Query = dara.Merge(request_.Query,
 480  				request.Query)
 481  		}
 482  
 483  		if dara.StringValue(authType) != "Anonymous" {
 484  			if dara.IsNil(client.Credential) {
 485  				_err = &ClientError{
 486  					Code:    dara.String("InvalidCredentials"),
 487  					Message: dara.String("Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details."),
 488  				}
 489  				if dara.BoolValue(client.DisableSDKError) != true {
 490  					_err = dara.TeaSDKError(_err)
 491  				}
 492  				return _result, _err
 493  			}
 494  
 495  			credentialModel, _err := client.Credential.GetCredential()
 496  			if _err != nil {
 497  				retriesAttempted++
 498  				retryPolicyContext = &dara.RetryPolicyContext{
 499  					RetriesAttempted: retriesAttempted,
 500  					HttpRequest:      request_,
 501  					HttpResponse:     response_,
 502  					Exception:        _err,
 503  				}
 504  				_resultErr = _err
 505  				continue
 506  			}
 507  
 508  			if !dara.IsNil(credentialModel.ProviderName) {
 509  				request_.Headers["x-acs-credentials-provider"] = credentialModel.ProviderName
 510  			}
 511  
 512  			credentialType := dara.StringValue(credentialModel.Type)
 513  			if credentialType == "bearer" {
 514  				bearerToken := dara.StringValue(credentialModel.BearerToken)
 515  				request_.Headers["x-acs-bearer-token"] = dara.String(bearerToken)
 516  				request_.Headers["x-acs-signature-type"] = dara.String("BEARERTOKEN")
 517  			} else if credentialType == "id_token" {
 518  				idToken := dara.StringValue(credentialModel.SecurityToken)
 519  				request_.Headers["x-acs-zero-trust-idtoken"] = dara.String(idToken)
 520  			} else {
 521  				accessKeyId := dara.StringValue(credentialModel.AccessKeyId)
 522  				accessKeySecret := dara.StringValue(credentialModel.AccessKeySecret)
 523  				securityToken := dara.StringValue(credentialModel.SecurityToken)
 524  				if !dara.IsNil(dara.String(securityToken)) && securityToken != "" {
 525  					request_.Headers["x-acs-accesskey-id"] = dara.String(accessKeyId)
 526  					request_.Headers["x-acs-security-token"] = dara.String(securityToken)
 527  				}
 528  
 529  				stringToSign := dara.StringValue(openapiutil.GetStringToSign(request_))
 530  				request_.Headers["authorization"] = dara.String("acs " + accessKeyId + ":" + dara.StringValue(openapiutil.GetROASignature(dara.String(stringToSign), dara.String(accessKeySecret))))
 531  			}
 532  
 533  		}
 534  
 535  		response_, _err := dara.DoRequest(request_, _runtime)
 536  		if _err != nil {
 537  			retriesAttempted++
 538  			retryPolicyContext = &dara.RetryPolicyContext{
 539  				RetriesAttempted: retriesAttempted,
 540  				HttpRequest:      request_,
 541  				HttpResponse:     response_,
 542  				Exception:        _err,
 543  			}
 544  			_resultErr = _err
 545  			continue
 546  		}
 547  
 548  		_result, _err = doROARequest_opResponse(response_, client, bodyType)
 549  		if _err != nil {
 550  			retriesAttempted++
 551  			retryPolicyContext = &dara.RetryPolicyContext{
 552  				RetriesAttempted: retriesAttempted,
 553  				HttpRequest:      request_,
 554  				HttpResponse:     response_,
 555  				Exception:        _err,
 556  			}
 557  			_resultErr = _err
 558  			continue
 559  		}
 560  
 561  		return _result, _err
 562  	}
 563  	if dara.BoolValue(client.DisableSDKError) != true {
 564  		_resultErr = dara.TeaSDKError(_resultErr)
 565  	}
 566  	return _result, _resultErr
 567  }
 568  
 569  // Description:
 570  //
 571  // # Encapsulate the request and invoke the network with form body
 572  //
 573  // @param action - api name
 574  //
 575  // @param version - product version
 576  //
 577  // @param protocol - http or https
 578  //
 579  // @param method - e.g. GET
 580  //
 581  // @param authType - authorization type e.g. AK
 582  //
 583  // @param pathname - pathname of every api
 584  //
 585  // @param bodyType - response body type e.g. String
 586  //
 587  // @param request - object of OpenApiRequest
 588  //
 589  // @param runtime - which controls some details of call api, such as retry times
 590  //
 591  // @return the response
 592  func (client *Client) DoROARequestWithForm(action *string, version *string, protocol *string, method *string, authType *string, pathname *string, bodyType *string, request *openapiutil.OpenApiRequest, runtime *dara.RuntimeOptions) (_result map[string]interface{}, _err error) {
 593  	_runtime := dara.NewRuntimeObject(map[string]interface{}{
 594  		"key":            dara.ToString(dara.Default(dara.StringValue(runtime.Key), dara.StringValue(client.Key))),
 595  		"cert":           dara.ToString(dara.Default(dara.StringValue(runtime.Cert), dara.StringValue(client.Cert))),
 596  		"ca":             dara.ToString(dara.Default(dara.StringValue(runtime.Ca), dara.StringValue(client.Ca))),
 597  		"readTimeout":    dara.ForceInt(dara.Default(dara.IntValue(runtime.ReadTimeout), dara.IntValue(client.ReadTimeout))),
 598  		"connectTimeout": dara.ForceInt(dara.Default(dara.IntValue(runtime.ConnectTimeout), dara.IntValue(client.ConnectTimeout))),
 599  		"httpProxy":      dara.ToString(dara.Default(dara.StringValue(runtime.HttpProxy), dara.StringValue(client.HttpProxy))),
 600  		"httpsProxy":     dara.ToString(dara.Default(dara.StringValue(runtime.HttpsProxy), dara.StringValue(client.HttpsProxy))),
 601  		"noProxy":        dara.ToString(dara.Default(dara.StringValue(runtime.NoProxy), dara.StringValue(client.NoProxy))),
 602  		"socks5Proxy":    dara.ToString(dara.Default(dara.StringValue(runtime.Socks5Proxy), dara.StringValue(client.Socks5Proxy))),
 603  		"socks5NetWork":  dara.ToString(dara.Default(dara.StringValue(runtime.Socks5NetWork), dara.StringValue(client.Socks5NetWork))),
 604  		"maxIdleConns":   dara.ForceInt(dara.Default(dara.IntValue(runtime.MaxIdleConns), dara.IntValue(client.MaxIdleConns))),
 605  		"retryOptions":   client.RetryOptions,
 606  		"ignoreSSL":      dara.BoolValue(runtime.IgnoreSSL),
 607  		"httpClient":     client.HttpClient,
 608  		"tlsMinVersion":  dara.StringValue(client.TlsMinVersion),
 609  	})
 610  
 611  	var retryPolicyContext *dara.RetryPolicyContext
 612  	var request_ *dara.Request
 613  	var response_ *dara.Response
 614  	var _resultErr error
 615  	retriesAttempted := int(0)
 616  	retryPolicyContext = &dara.RetryPolicyContext{
 617  		RetriesAttempted: retriesAttempted,
 618  	}
 619  
 620  	_result = make(map[string]interface{})
 621  	for dara.ShouldRetry(_runtime.RetryOptions, retryPolicyContext) {
 622  		_resultErr = nil
 623  		_backoffDelayTime := dara.GetBackoffDelay(_runtime.RetryOptions, retryPolicyContext)
 624  		dara.Sleep(_backoffDelayTime)
 625  
 626  		request_ = dara.NewRequest()
 627  		request_.Protocol = dara.String(dara.ToString(dara.Default(dara.StringValue(client.Protocol), dara.StringValue(protocol))))
 628  		request_.Method = method
 629  		request_.Pathname = pathname
 630  		globalQueries := make(map[string]*string)
 631  		globalHeaders := make(map[string]*string)
 632  		if !dara.IsNil(client.GlobalParameters) {
 633  			globalParams := client.GlobalParameters
 634  			if !dara.IsNil(globalParams.Queries) {
 635  				globalQueries = globalParams.Queries
 636  			}
 637  
 638  			if !dara.IsNil(globalParams.Headers) {
 639  				globalHeaders = globalParams.Headers
 640  			}
 641  
 642  		}
 643  
 644  		extendsHeaders := make(map[string]*string)
 645  		extendsQueries := make(map[string]*string)
 646  		if !dara.IsNil(runtime.ExtendsParameters) {
 647  			extendsParameters := runtime.ExtendsParameters
 648  			if !dara.IsNil(extendsParameters.Headers) {
 649  				extendsHeaders = extendsParameters.Headers
 650  			}
 651  
 652  			if !dara.IsNil(extendsParameters.Queries) {
 653  				extendsQueries = extendsParameters.Queries
 654  			}
 655  
 656  		}
 657  
 658  		request_.Headers = dara.Merge(map[string]*string{
 659  			"date":                    openapiutil.GetDateUTCString(),
 660  			"host":                    client.Endpoint,
 661  			"accept":                  dara.String("application/json"),
 662  			"x-acs-signature-nonce":   openapiutil.GetNonce(),
 663  			"x-acs-signature-method":  dara.String("HMAC-SHA1"),
 664  			"x-acs-signature-version": dara.String("1.0"),
 665  			"x-acs-version":           version,
 666  			"x-acs-action":            action,
 667  			"user-agent":              openapiutil.GetUserAgent(client.UserAgent),
 668  		}, globalHeaders,
 669  			extendsHeaders,
 670  			request.Headers)
 671  		if !dara.IsNil(request.Body) {
 672  			m := dara.ToMap(request.Body)
 673  			request_.Body = dara.ToReader(openapiutil.ToForm(m))
 674  			request_.Headers["content-type"] = dara.String("application/x-www-form-urlencoded")
 675  		}
 676  
 677  		request_.Query = dara.Merge(globalQueries,
 678  			extendsQueries)
 679  		if !dara.IsNil(request.Query) {
 680  			request_.Query = dara.Merge(request_.Query,
 681  				request.Query)
 682  		}
 683  
 684  		if dara.StringValue(authType) != "Anonymous" {
 685  			if dara.IsNil(client.Credential) {
 686  				_err = &ClientError{
 687  					Code:    dara.String("InvalidCredentials"),
 688  					Message: dara.String("Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details."),
 689  				}
 690  				if dara.BoolValue(client.DisableSDKError) != true {
 691  					_err = dara.TeaSDKError(_err)
 692  				}
 693  				return _result, _err
 694  			}
 695  
 696  			credentialModel, _err := client.Credential.GetCredential()
 697  			if _err != nil {
 698  				retriesAttempted++
 699  				retryPolicyContext = &dara.RetryPolicyContext{
 700  					RetriesAttempted: retriesAttempted,
 701  					HttpRequest:      request_,
 702  					HttpResponse:     response_,
 703  					Exception:        _err,
 704  				}
 705  				_resultErr = _err
 706  				continue
 707  			}
 708  
 709  			if !dara.IsNil(credentialModel.ProviderName) {
 710  				request_.Headers["x-acs-credentials-provider"] = credentialModel.ProviderName
 711  			}
 712  
 713  			credentialType := dara.StringValue(credentialModel.Type)
 714  			if credentialType == "bearer" {
 715  				bearerToken := dara.StringValue(credentialModel.BearerToken)
 716  				request_.Headers["x-acs-bearer-token"] = dara.String(bearerToken)
 717  				request_.Headers["x-acs-signature-type"] = dara.String("BEARERTOKEN")
 718  			} else if credentialType == "id_token" {
 719  				idToken := dara.StringValue(credentialModel.SecurityToken)
 720  				request_.Headers["x-acs-zero-trust-idtoken"] = dara.String(idToken)
 721  			} else {
 722  				accessKeyId := dara.StringValue(credentialModel.AccessKeyId)
 723  				accessKeySecret := dara.StringValue(credentialModel.AccessKeySecret)
 724  				securityToken := dara.StringValue(credentialModel.SecurityToken)
 725  				if !dara.IsNil(dara.String(securityToken)) && securityToken != "" {
 726  					request_.Headers["x-acs-accesskey-id"] = dara.String(accessKeyId)
 727  					request_.Headers["x-acs-security-token"] = dara.String(securityToken)
 728  				}
 729  
 730  				stringToSign := dara.StringValue(openapiutil.GetStringToSign(request_))
 731  				request_.Headers["authorization"] = dara.String("acs " + accessKeyId + ":" + dara.StringValue(openapiutil.GetROASignature(dara.String(stringToSign), dara.String(accessKeySecret))))
 732  			}
 733  
 734  		}
 735  
 736  		response_, _err := dara.DoRequest(request_, _runtime)
 737  		if _err != nil {
 738  			retriesAttempted++
 739  			retryPolicyContext = &dara.RetryPolicyContext{
 740  				RetriesAttempted: retriesAttempted,
 741  				HttpRequest:      request_,
 742  				HttpResponse:     response_,
 743  				Exception:        _err,
 744  			}
 745  			_resultErr = _err
 746  			continue
 747  		}
 748  
 749  		_result, _err = doROARequestWithForm_opResponse(response_, client, bodyType)
 750  		if _err != nil {
 751  			retriesAttempted++
 752  			retryPolicyContext = &dara.RetryPolicyContext{
 753  				RetriesAttempted: retriesAttempted,
 754  				HttpRequest:      request_,
 755  				HttpResponse:     response_,
 756  				Exception:        _err,
 757  			}
 758  			_resultErr = _err
 759  			continue
 760  		}
 761  
 762  		return _result, _err
 763  	}
 764  	if dara.BoolValue(client.DisableSDKError) != true {
 765  		_resultErr = dara.TeaSDKError(_resultErr)
 766  	}
 767  	return _result, _resultErr
 768  }
 769  
 770  // Description:
 771  //
 772  // # Encapsulate the request and invoke the network
 773  //
 774  // @param action - api name
 775  //
 776  // @param version - product version
 777  //
 778  // @param protocol - http or https
 779  //
 780  // @param method - e.g. GET
 781  //
 782  // @param authType - authorization type e.g. AK
 783  //
 784  // @param bodyType - response body type e.g. String
 785  //
 786  // @param request - object of OpenApiRequest
 787  //
 788  // @param runtime - which controls some details of call api, such as retry times
 789  //
 790  // @return the response
 791  func (client *Client) DoRequest(params *openapiutil.Params, request *openapiutil.OpenApiRequest, runtime *dara.RuntimeOptions) (_result map[string]interface{}, _err error) {
 792  	_runtime := dara.NewRuntimeObject(map[string]interface{}{
 793  		"key":            dara.ToString(dara.Default(dara.StringValue(runtime.Key), dara.StringValue(client.Key))),
 794  		"cert":           dara.ToString(dara.Default(dara.StringValue(runtime.Cert), dara.StringValue(client.Cert))),
 795  		"ca":             dara.ToString(dara.Default(dara.StringValue(runtime.Ca), dara.StringValue(client.Ca))),
 796  		"readTimeout":    dara.ForceInt(dara.Default(dara.IntValue(runtime.ReadTimeout), dara.IntValue(client.ReadTimeout))),
 797  		"connectTimeout": dara.ForceInt(dara.Default(dara.IntValue(runtime.ConnectTimeout), dara.IntValue(client.ConnectTimeout))),
 798  		"httpProxy":      dara.ToString(dara.Default(dara.StringValue(runtime.HttpProxy), dara.StringValue(client.HttpProxy))),
 799  		"httpsProxy":     dara.ToString(dara.Default(dara.StringValue(runtime.HttpsProxy), dara.StringValue(client.HttpsProxy))),
 800  		"noProxy":        dara.ToString(dara.Default(dara.StringValue(runtime.NoProxy), dara.StringValue(client.NoProxy))),
 801  		"socks5Proxy":    dara.ToString(dara.Default(dara.StringValue(runtime.Socks5Proxy), dara.StringValue(client.Socks5Proxy))),
 802  		"socks5NetWork":  dara.ToString(dara.Default(dara.StringValue(runtime.Socks5NetWork), dara.StringValue(client.Socks5NetWork))),
 803  		"maxIdleConns":   dara.ForceInt(dara.Default(dara.IntValue(runtime.MaxIdleConns), dara.IntValue(client.MaxIdleConns))),
 804  		"retryOptions":   client.RetryOptions,
 805  		"ignoreSSL":      dara.BoolValue(runtime.IgnoreSSL),
 806  		"httpClient":     client.HttpClient,
 807  		"tlsMinVersion":  dara.StringValue(client.TlsMinVersion),
 808  	})
 809  
 810  	var retryPolicyContext *dara.RetryPolicyContext
 811  	var request_ *dara.Request
 812  	var response_ *dara.Response
 813  	var _resultErr error
 814  	retriesAttempted := int(0)
 815  	retryPolicyContext = &dara.RetryPolicyContext{
 816  		RetriesAttempted: retriesAttempted,
 817  	}
 818  
 819  	_result = make(map[string]interface{})
 820  	for dara.ShouldRetry(_runtime.RetryOptions, retryPolicyContext) {
 821  		_resultErr = nil
 822  		_backoffDelayTime := dara.GetBackoffDelay(_runtime.RetryOptions, retryPolicyContext)
 823  		dara.Sleep(_backoffDelayTime)
 824  
 825  		request_ = dara.NewRequest()
 826  		request_.Protocol = dara.String(dara.ToString(dara.Default(dara.StringValue(client.Protocol), dara.StringValue(params.Protocol))))
 827  		request_.Method = params.Method
 828  		request_.Pathname = params.Pathname
 829  		globalQueries := make(map[string]*string)
 830  		globalHeaders := make(map[string]*string)
 831  		if !dara.IsNil(client.GlobalParameters) {
 832  			globalParams := client.GlobalParameters
 833  			if !dara.IsNil(globalParams.Queries) {
 834  				globalQueries = globalParams.Queries
 835  			}
 836  
 837  			if !dara.IsNil(globalParams.Headers) {
 838  				globalHeaders = globalParams.Headers
 839  			}
 840  
 841  		}
 842  
 843  		extendsHeaders := make(map[string]*string)
 844  		extendsQueries := make(map[string]*string)
 845  		if !dara.IsNil(runtime.ExtendsParameters) {
 846  			extendsParameters := runtime.ExtendsParameters
 847  			if !dara.IsNil(extendsParameters.Headers) {
 848  				extendsHeaders = extendsParameters.Headers
 849  			}
 850  
 851  			if !dara.IsNil(extendsParameters.Queries) {
 852  				extendsQueries = extendsParameters.Queries
 853  			}
 854  
 855  		}
 856  
 857  		request_.Query = dara.Merge(globalQueries,
 858  			extendsQueries,
 859  			request.Query)
 860  		// endpoint is setted in product client
 861  		request_.Headers = dara.Merge(map[string]*string{
 862  			"host":                  client.Endpoint,
 863  			"x-acs-version":         params.Version,
 864  			"x-acs-action":          params.Action,
 865  			"user-agent":            openapiutil.GetUserAgent(client.UserAgent),
 866  			"x-acs-date":            openapiutil.GetTimestamp(),
 867  			"x-acs-signature-nonce": openapiutil.GetNonce(),
 868  			"accept":                dara.String("application/json"),
 869  		}, globalHeaders,
 870  			extendsHeaders,
 871  			request.Headers)
 872  		if dara.StringValue(params.Style) == "RPC" {
 873  			headers, _err := client.GetRpcHeaders()
 874  			if _err != nil {
 875  				retriesAttempted++
 876  				retryPolicyContext = &dara.RetryPolicyContext{
 877  					RetriesAttempted: retriesAttempted,
 878  					HttpRequest:      request_,
 879  					HttpResponse:     response_,
 880  					Exception:        _err,
 881  				}
 882  				_resultErr = _err
 883  				continue
 884  			}
 885  
 886  			if !dara.IsNil(headers) {
 887  				request_.Headers = dara.Merge(request_.Headers,
 888  					headers)
 889  			}
 890  
 891  		}
 892  
 893  		signatureAlgorithm := dara.ToString(dara.Default(dara.StringValue(client.SignatureAlgorithm), "ACS3-HMAC-SHA256"))
 894  		hashedRequestPayload := openapiutil.Hash(dara.BytesFromString("", "utf-8"), dara.String(signatureAlgorithm))
 895  		if !dara.IsNil(request.Stream) {
 896  			tmp, _err := dara.ReadAsBytes(request.Stream)
 897  			if _err != nil {
 898  				retriesAttempted++
 899  				retryPolicyContext = &dara.RetryPolicyContext{
 900  					RetriesAttempted: retriesAttempted,
 901  					HttpRequest:      request_,
 902  					HttpResponse:     response_,
 903  					Exception:        _err,
 904  				}
 905  				_resultErr = _err
 906  				continue
 907  			}
 908  
 909  			hashedRequestPayload = openapiutil.Hash(tmp, dara.String(signatureAlgorithm))
 910  			request_.Body = dara.ToReader(tmp)
 911  			request_.Headers["content-type"] = dara.String("application/octet-stream")
 912  		} else {
 913  			if !dara.IsNil(request.Body) {
 914  				if dara.StringValue(params.ReqBodyType) == "byte" {
 915  					byteObj := []byte(dara.ToString(request.Body))
 916  					hashedRequestPayload = openapiutil.Hash(byteObj, dara.String(signatureAlgorithm))
 917  					request_.Body = dara.ToReader(byteObj)
 918  				} else if dara.StringValue(params.ReqBodyType) == "json" {
 919  					jsonObj := dara.Stringify(request.Body)
 920  					hashedRequestPayload = openapiutil.Hash(dara.ToBytes(jsonObj, "utf8"), dara.String(signatureAlgorithm))
 921  					request_.Body = dara.ToReader(dara.String(jsonObj))
 922  					request_.Headers["content-type"] = dara.String("application/json; charset=utf-8")
 923  				} else {
 924  					m := dara.ToMap(request.Body)
 925  					formObj := dara.StringValue(openapiutil.ToForm(m))
 926  					hashedRequestPayload = openapiutil.Hash(dara.ToBytes(formObj, "utf8"), dara.String(signatureAlgorithm))
 927  					request_.Body = dara.ToReader(dara.String(formObj))
 928  					request_.Headers["content-type"] = dara.String("application/x-www-form-urlencoded")
 929  				}
 930  
 931  			}
 932  
 933  		}
 934  
 935  		request_.Headers["x-acs-content-sha256"] = dara.String(hex.EncodeToString(hashedRequestPayload))
 936  		if dara.StringValue(params.AuthType) != "Anonymous" {
 937  			if dara.IsNil(client.Credential) {
 938  				_err = &ClientError{
 939  					Code:    dara.String("InvalidCredentials"),
 940  					Message: dara.String("Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details."),
 941  				}
 942  				if dara.BoolValue(client.DisableSDKError) != true {
 943  					_err = dara.TeaSDKError(_err)
 944  				}
 945  				return _result, _err
 946  			}
 947  
 948  			credentialModel, _err := client.Credential.GetCredential()
 949  			if _err != nil {
 950  				retriesAttempted++
 951  				retryPolicyContext = &dara.RetryPolicyContext{
 952  					RetriesAttempted: retriesAttempted,
 953  					HttpRequest:      request_,
 954  					HttpResponse:     response_,
 955  					Exception:        _err,
 956  				}
 957  				_resultErr = _err
 958  				continue
 959  			}
 960  
 961  			if !dara.IsNil(credentialModel.ProviderName) {
 962  				request_.Headers["x-acs-credentials-provider"] = credentialModel.ProviderName
 963  			}
 964  
 965  			authType := dara.StringValue(credentialModel.Type)
 966  			if authType == "bearer" {
 967  				bearerToken := dara.StringValue(credentialModel.BearerToken)
 968  				request_.Headers["x-acs-bearer-token"] = dara.String(bearerToken)
 969  				if dara.StringValue(params.Style) == "RPC" {
 970  					request_.Query["SignatureType"] = dara.String("BEARERTOKEN")
 971  				} else {
 972  					request_.Headers["x-acs-signature-type"] = dara.String("BEARERTOKEN")
 973  				}
 974  
 975  			} else if authType == "id_token" {
 976  				idToken := dara.StringValue(credentialModel.SecurityToken)
 977  				request_.Headers["x-acs-zero-trust-idtoken"] = dara.String(idToken)
 978  			} else {
 979  				accessKeyId := dara.StringValue(credentialModel.AccessKeyId)
 980  				accessKeySecret := dara.StringValue(credentialModel.AccessKeySecret)
 981  				securityToken := dara.StringValue(credentialModel.SecurityToken)
 982  				if !dara.IsNil(dara.String(securityToken)) && securityToken != "" {
 983  					request_.Headers["x-acs-accesskey-id"] = dara.String(accessKeyId)
 984  					request_.Headers["x-acs-security-token"] = dara.String(securityToken)
 985  				}
 986  
 987  				request_.Headers["Authorization"] = openapiutil.GetAuthorization(request_, dara.String(signatureAlgorithm), dara.String(hex.EncodeToString(hashedRequestPayload)), dara.String(accessKeyId), dara.String(accessKeySecret))
 988  			}
 989  
 990  		}
 991  
 992  		response_, _err := dara.DoRequest(request_, _runtime)
 993  		if _err != nil {
 994  			retriesAttempted++
 995  			retryPolicyContext = &dara.RetryPolicyContext{
 996  				RetriesAttempted: retriesAttempted,
 997  				HttpRequest:      request_,
 998  				HttpResponse:     response_,
 999  				Exception:        _err,
1000  			}
1001  			_resultErr = _err
1002  			continue
1003  		}
1004  
1005  		_result, _err = doRequest_opResponse(response_, client, params)
1006  		if _err != nil {
1007  			retriesAttempted++
1008  			retryPolicyContext = &dara.RetryPolicyContext{
1009  				RetriesAttempted: retriesAttempted,
1010  				HttpRequest:      request_,
1011  				HttpResponse:     response_,
1012  				Exception:        _err,
1013  			}
1014  			_resultErr = _err
1015  			continue
1016  		}
1017  
1018  		return _result, _err
1019  	}
1020  	if dara.BoolValue(client.DisableSDKError) != true {
1021  		_resultErr = dara.TeaSDKError(_resultErr)
1022  	}
1023  	return _result, _resultErr
1024  }
1025  
1026  // Description:
1027  //
1028  // # Encapsulate the request and invoke the network
1029  //
1030  // @param action - api name
1031  //
1032  // @param version - product version
1033  //
1034  // @param protocol - http or https
1035  //
1036  // @param method - e.g. GET
1037  //
1038  // @param authType - authorization type e.g. AK
1039  //
1040  // @param bodyType - response body type e.g. String
1041  //
1042  // @param request - object of OpenApiRequest
1043  //
1044  // @param runtime - which controls some details of call api, such as retry times
1045  //
1046  // @return the response
1047  func (client *Client) Execute(params *openapiutil.Params, request *openapiutil.OpenApiRequest, runtime *dara.RuntimeOptions) (_result map[string]interface{}, _err error) {
1048  	_runtime := dara.NewRuntimeObject(map[string]interface{}{
1049  		"key":            dara.ToString(dara.Default(dara.StringValue(runtime.Key), dara.StringValue(client.Key))),
1050  		"cert":           dara.ToString(dara.Default(dara.StringValue(runtime.Cert), dara.StringValue(client.Cert))),
1051  		"ca":             dara.ToString(dara.Default(dara.StringValue(runtime.Ca), dara.StringValue(client.Ca))),
1052  		"readTimeout":    dara.ForceInt(dara.Default(dara.IntValue(runtime.ReadTimeout), dara.IntValue(client.ReadTimeout))),
1053  		"connectTimeout": dara.ForceInt(dara.Default(dara.IntValue(runtime.ConnectTimeout), dara.IntValue(client.ConnectTimeout))),
1054  		"httpProxy":      dara.ToString(dara.Default(dara.StringValue(runtime.HttpProxy), dara.StringValue(client.HttpProxy))),
1055  		"httpsProxy":     dara.ToString(dara.Default(dara.StringValue(runtime.HttpsProxy), dara.StringValue(client.HttpsProxy))),
1056  		"noProxy":        dara.ToString(dara.Default(dara.StringValue(runtime.NoProxy), dara.StringValue(client.NoProxy))),
1057  		"socks5Proxy":    dara.ToString(dara.Default(dara.StringValue(runtime.Socks5Proxy), dara.StringValue(client.Socks5Proxy))),
1058  		"socks5NetWork":  dara.ToString(dara.Default(dara.StringValue(runtime.Socks5NetWork), dara.StringValue(client.Socks5NetWork))),
1059  		"maxIdleConns":   dara.ForceInt(dara.Default(dara.IntValue(runtime.MaxIdleConns), dara.IntValue(client.MaxIdleConns))),
1060  		"retryOptions":   client.RetryOptions,
1061  		"ignoreSSL":      dara.BoolValue(runtime.IgnoreSSL),
1062  		"httpClient":     client.HttpClient,
1063  		"tlsMinVersion":  dara.StringValue(client.TlsMinVersion),
1064  		"disableHttp2":   dara.ForceBoolean(dara.Default(dara.BoolValue(client.DisableHttp2), false)),
1065  	})
1066  
1067  	var retryPolicyContext *dara.RetryPolicyContext
1068  	var request_ *dara.Request
1069  	var response_ *dara.Response
1070  	var _resultErr error
1071  	retriesAttempted := int(0)
1072  	retryPolicyContext = &dara.RetryPolicyContext{
1073  		RetriesAttempted: retriesAttempted,
1074  	}
1075  
1076  	_result = make(map[string]interface{})
1077  	for dara.ShouldRetry(_runtime.RetryOptions, retryPolicyContext) {
1078  		_resultErr = nil
1079  		_backoffDelayTime := dara.GetBackoffDelay(_runtime.RetryOptions, retryPolicyContext)
1080  		dara.Sleep(_backoffDelayTime)
1081  
1082  		request_ = dara.NewRequest()
1083  		// spi = new Gateway();//Gateway implements SPI，这一步在产品 SDK 中实例化
1084  		headers, _err := client.GetRpcHeaders()
1085  		if _err != nil {
1086  			retriesAttempted++
1087  			retryPolicyContext = &dara.RetryPolicyContext{
1088  				RetriesAttempted: retriesAttempted,
1089  				HttpRequest:      request_,
1090  				HttpResponse:     response_,
1091  				Exception:        _err,
1092  			}
1093  			_resultErr = _err
1094  			continue
1095  		}
1096  
1097  		globalQueries := make(map[string]*string)
1098  		globalHeaders := make(map[string]*string)
1099  		if !dara.IsNil(client.GlobalParameters) {
1100  			globalParams := client.GlobalParameters
1101  			if !dara.IsNil(globalParams.Queries) {
1102  				globalQueries = globalParams.Queries
1103  			}
1104  
1105  			if !dara.IsNil(globalParams.Headers) {
1106  				globalHeaders = globalParams.Headers
1107  			}
1108  
1109  		}
1110  
1111  		extendsHeaders := make(map[string]*string)
1112  		extendsQueries := make(map[string]*string)
1113  		if !dara.IsNil(runtime.ExtendsParameters) {
1114  			extendsParameters := runtime.ExtendsParameters
1115  			if !dara.IsNil(extendsParameters.Headers) {
1116  				extendsHeaders = extendsParameters.Headers
1117  			}
1118  
1119  			if !dara.IsNil(extendsParameters.Queries) {
1120  				extendsQueries = extendsParameters.Queries
1121  			}
1122  
1123  		}
1124  
1125  		requestContext := &spi.InterceptorContextRequest{
1126  			Headers: dara.Merge(globalHeaders,
1127  				extendsHeaders,
1128  				request.Headers,
1129  				headers),
1130  			Query: dara.Merge(globalQueries,
1131  				extendsQueries,
1132  				request.Query),
1133  			Body:               request.Body,
1134  			Stream:             request.Stream,
1135  			HostMap:            request.HostMap,
1136  			Pathname:           params.Pathname,
1137  			ProductId:          client.ProductId,
1138  			Action:             params.Action,
1139  			Version:            params.Version,
1140  			Protocol:           dara.String(dara.ToString(dara.Default(dara.StringValue(client.Protocol), dara.StringValue(params.Protocol)))),
1141  			Method:             dara.String(dara.ToString(dara.Default(dara.StringValue(client.Method), dara.StringValue(params.Method)))),
1142  			AuthType:           params.AuthType,
1143  			BodyType:           params.BodyType,
1144  			ReqBodyType:        params.ReqBodyType,
1145  			Style:              params.Style,
1146  			Credential:         client.Credential,
1147  			SignatureVersion:   client.SignatureVersion,
1148  			SignatureAlgorithm: client.SignatureAlgorithm,
1149  			UserAgent:          openapiutil.GetUserAgent(client.UserAgent),
1150  		}
1151  		configurationContext := &spi.InterceptorContextConfiguration{
1152  			RegionId:     client.RegionId,
1153  			Endpoint:     dara.String(dara.ToString(dara.Default(dara.StringValue(request.EndpointOverride), dara.StringValue(client.Endpoint)))),
1154  			EndpointRule: client.EndpointRule,
1155  			EndpointMap:  client.EndpointMap,
1156  			EndpointType: client.EndpointType,
1157  			Network:      client.Network,
1158  			Suffix:       client.Suffix,
1159  		}
1160  		interceptorContext := &spi.InterceptorContext{
1161  			Request:       requestContext,
1162  			Configuration: configurationContext,
1163  		}
1164  		attributeMap := &spi.AttributeMap{}
1165  		if !dara.IsNil(client.AttributeMap) {
1166  			attributeMap = client.AttributeMap
1167  		}
1168  
1169  		// 1. spi.modifyConfiguration(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
1170  		_err = client.Spi.ModifyConfiguration(interceptorContext, attributeMap)
1171  		if _err != nil {
1172  			retriesAttempted++
1173  			retryPolicyContext = &dara.RetryPolicyContext{
1174  				RetriesAttempted: retriesAttempted,
1175  				HttpRequest:      request_,
1176  				HttpResponse:     response_,
1177  				Exception:        _err,
1178  			}
1179  			_resultErr = _err
1180  			continue
1181  		}
1182  
1183  		// 2. spi.modifyRequest(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
1184  		_err = client.Spi.ModifyRequest(interceptorContext, attributeMap)
1185  		if _err != nil {
1186  			retriesAttempted++
1187  			retryPolicyContext = &dara.RetryPolicyContext{
1188  				RetriesAttempted: retriesAttempted,
1189  				HttpRequest:      request_,
1190  				HttpResponse:     response_,
1191  				Exception:        _err,
1192  			}
1193  			_resultErr = _err
1194  			continue
1195  		}
1196  
1197  		request_.Protocol = interceptorContext.Request.Protocol
1198  		request_.Method = interceptorContext.Request.Method
1199  		request_.Pathname = interceptorContext.Request.Pathname
1200  		request_.Query = interceptorContext.Request.Query
1201  		request_.Body = interceptorContext.Request.Stream
1202  		request_.Headers = interceptorContext.Request.Headers
1203  		response_, _err := dara.DoRequest(request_, _runtime)
1204  		if _err != nil {
1205  			retriesAttempted++
1206  			retryPolicyContext = &dara.RetryPolicyContext{
1207  				RetriesAttempted: retriesAttempted,
1208  				HttpRequest:      request_,
1209  				HttpResponse:     response_,
1210  				Exception:        _err,
1211  			}
1212  			_resultErr = _err
1213  			continue
1214  		}
1215  
1216  		responseContext := &spi.InterceptorContextResponse{
1217  			StatusCode: response_.StatusCode,
1218  			Headers:    response_.Headers,
1219  			Body:       response_.Body,
1220  		}
1221  		interceptorContext.Response = responseContext
1222  		// 3. spi.modifyResponse(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
1223  		_err = client.Spi.ModifyResponse(interceptorContext, attributeMap)
1224  		if _err != nil {
1225  			retriesAttempted++
1226  			retryPolicyContext = &dara.RetryPolicyContext{
1227  				RetriesAttempted: retriesAttempted,
1228  				HttpRequest:      request_,
1229  				HttpResponse:     response_,
1230  				Exception:        _err,
1231  			}
1232  			_resultErr = _err
1233  			continue
1234  		}
1235  
1236  		_err = dara.Convert(map[string]interface{}{
1237  			"headers":    interceptorContext.Response.Headers,
1238  			"statusCode": dara.IntValue(interceptorContext.Response.StatusCode),
1239  			"body":       interceptorContext.Response.DeserializedBody,
1240  		}, &_result)
1241  
1242  		return _result, _err
1243  	}
1244  	if dara.BoolValue(client.DisableSDKError) != true {
1245  		_resultErr = dara.TeaSDKError(_resultErr)
1246  	}
1247  	return _result, _resultErr
1248  }
1249  
1250  func (client *Client) CallSSEApi(params *openapiutil.Params, request *openapiutil.OpenApiRequest, runtime *dara.RuntimeOptions, _yield chan *SSEResponse, _yieldErr chan error) {
1251  	defer close(_yield)
1252  	defer close(_yieldErr)
1253  	_runtime := dara.NewRuntimeObject(map[string]interface{}{
1254  		"key":            dara.ToString(dara.Default(dara.StringValue(runtime.Key), dara.StringValue(client.Key))),
1255  		"cert":           dara.ToString(dara.Default(dara.StringValue(runtime.Cert), dara.StringValue(client.Cert))),
1256  		"ca":             dara.ToString(dara.Default(dara.StringValue(runtime.Ca), dara.StringValue(client.Ca))),
1257  		"readTimeout":    dara.ForceInt(dara.Default(dara.IntValue(runtime.ReadTimeout), dara.IntValue(client.ReadTimeout))),
1258  		"connectTimeout": dara.ForceInt(dara.Default(dara.IntValue(runtime.ConnectTimeout), dara.IntValue(client.ConnectTimeout))),
1259  		"httpProxy":      dara.ToString(dara.Default(dara.StringValue(runtime.HttpProxy), dara.StringValue(client.HttpProxy))),
1260  		"httpsProxy":     dara.ToString(dara.Default(dara.StringValue(runtime.HttpsProxy), dara.StringValue(client.HttpsProxy))),
1261  		"noProxy":        dara.ToString(dara.Default(dara.StringValue(runtime.NoProxy), dara.StringValue(client.NoProxy))),
1262  		"socks5Proxy":    dara.ToString(dara.Default(dara.StringValue(runtime.Socks5Proxy), dara.StringValue(client.Socks5Proxy))),
1263  		"socks5NetWork":  dara.ToString(dara.Default(dara.StringValue(runtime.Socks5NetWork), dara.StringValue(client.Socks5NetWork))),
1264  		"maxIdleConns":   dara.ForceInt(dara.Default(dara.IntValue(runtime.MaxIdleConns), dara.IntValue(client.MaxIdleConns))),
1265  		"retryOptions":   client.RetryOptions,
1266  		"ignoreSSL":      dara.BoolValue(runtime.IgnoreSSL),
1267  		"httpClient":     client.HttpClient,
1268  		"tlsMinVersion":  dara.StringValue(client.TlsMinVersion),
1269  	})
1270  
1271  	var retryPolicyContext *dara.RetryPolicyContext
1272  	var request_ *dara.Request
1273  	var response_ *dara.Response
1274  	var _resultErr error
1275  	retriesAttempted := int(0)
1276  	retryPolicyContext = &dara.RetryPolicyContext{
1277  		RetriesAttempted: retriesAttempted,
1278  	}
1279  
1280  	for dara.ShouldRetry(_runtime.RetryOptions, retryPolicyContext) {
1281  		_resultErr = nil
1282  		_backoffDelayTime := dara.GetBackoffDelay(_runtime.RetryOptions, retryPolicyContext)
1283  		dara.Sleep(_backoffDelayTime)
1284  
1285  		request_ = dara.NewRequest()
1286  		request_.Protocol = dara.String(dara.ToString(dara.Default(dara.StringValue(client.Protocol), dara.StringValue(params.Protocol))))
1287  		request_.Method = params.Method
1288  		request_.Pathname = params.Pathname
1289  		globalQueries := make(map[string]*string)
1290  		globalHeaders := make(map[string]*string)
1291  		if !dara.IsNil(client.GlobalParameters) {
1292  			globalParams := client.GlobalParameters
1293  			if !dara.IsNil(globalParams.Queries) {
1294  				globalQueries = globalParams.Queries
1295  			}
1296  
1297  			if !dara.IsNil(globalParams.Headers) {
1298  				globalHeaders = globalParams.Headers
1299  			}
1300  
1301  		}
1302  
1303  		extendsHeaders := make(map[string]*string)
1304  		extendsQueries := make(map[string]*string)
1305  		if !dara.IsNil(runtime.ExtendsParameters) {
1306  			extendsParameters := runtime.ExtendsParameters
1307  			if !dara.IsNil(extendsParameters.Headers) {
1308  				extendsHeaders = extendsParameters.Headers
1309  			}
1310  
1311  			if !dara.IsNil(extendsParameters.Queries) {
1312  				extendsQueries = extendsParameters.Queries
1313  			}
1314  
1315  		}
1316  
1317  		request_.Query = dara.Merge(globalQueries,
1318  			extendsQueries,
1319  			request.Query)
1320  		// endpoint is setted in product client
1321  		request_.Headers = dara.Merge(map[string]*string{
1322  			"host":                  client.Endpoint,
1323  			"x-acs-version":         params.Version,
1324  			"x-acs-action":          params.Action,
1325  			"user-agent":            openapiutil.GetUserAgent(client.UserAgent),
1326  			"x-acs-date":            openapiutil.GetTimestamp(),
1327  			"x-acs-signature-nonce": openapiutil.GetNonce(),
1328  			"accept":                dara.String("application/json"),
1329  		}, extendsHeaders,
1330  			globalHeaders,
1331  			request.Headers)
1332  		if dara.StringValue(params.Style) == "RPC" {
1333  			headers, _err := client.GetRpcHeaders()
1334  			if _err != nil {
1335  				retriesAttempted++
1336  				retryPolicyContext = &dara.RetryPolicyContext{
1337  					RetriesAttempted: retriesAttempted,
1338  					HttpRequest:      request_,
1339  					HttpResponse:     response_,
1340  					Exception:        _err,
1341  				}
1342  				_resultErr = _err
1343  				continue
1344  			}
1345  
1346  			if !dara.IsNil(headers) {
1347  				request_.Headers = dara.Merge(request_.Headers,
1348  					headers)
1349  			}
1350  
1351  		}
1352  
1353  		signatureAlgorithm := dara.ToString(dara.Default(dara.StringValue(client.SignatureAlgorithm), "ACS3-HMAC-SHA256"))
1354  		hashedRequestPayload := openapiutil.Hash(dara.BytesFromString("", "utf-8"), dara.String(signatureAlgorithm))
1355  		if !dara.IsNil(request.Stream) {
1356  			tmp, _err := dara.ReadAsBytes(request.Stream)
1357  			if _err != nil {
1358  				retriesAttempted++
1359  				retryPolicyContext = &dara.RetryPolicyContext{
1360  					RetriesAttempted: retriesAttempted,
1361  					HttpRequest:      request_,
1362  					HttpResponse:     response_,
1363  					Exception:        _err,
1364  				}
1365  				_resultErr = _err
1366  				continue
1367  			}
1368  
1369  			hashedRequestPayload = openapiutil.Hash(tmp, dara.String(signatureAlgorithm))
1370  			request_.Body = dara.ToReader(tmp)
1371  			request_.Headers["content-type"] = dara.String("application/octet-stream")
1372  		} else {
1373  			if !dara.IsNil(request.Body) {
1374  				if dara.StringValue(params.ReqBodyType) == "byte" {
1375  					byteObj := []byte(dara.ToString(request.Body))
1376  					hashedRequestPayload = openapiutil.Hash(byteObj, dara.String(signatureAlgorithm))
1377  					request_.Body = dara.ToReader(byteObj)
1378  				} else if dara.StringValue(params.ReqBodyType) == "json" {
1379  					jsonObj := dara.Stringify(request.Body)
1380  					hashedRequestPayload = openapiutil.Hash(dara.ToBytes(jsonObj, "utf8"), dara.String(signatureAlgorithm))
1381  					request_.Body = dara.ToReader(dara.String(jsonObj))
1382  					request_.Headers["content-type"] = dara.String("application/json; charset=utf-8")
1383  				} else {
1384  					m := dara.ToMap(request.Body)
1385  					formObj := dara.StringValue(openapiutil.ToForm(m))
1386  					hashedRequestPayload = openapiutil.Hash(dara.ToBytes(formObj, "utf8"), dara.String(signatureAlgorithm))
1387  					request_.Body = dara.ToReader(dara.String(formObj))
1388  					request_.Headers["content-type"] = dara.String("application/x-www-form-urlencoded")
1389  				}
1390  
1391  			}
1392  
1393  		}
1394  
1395  		request_.Headers["x-acs-content-sha256"] = dara.String(hex.EncodeToString(hashedRequestPayload))
1396  		if dara.StringValue(params.AuthType) != "Anonymous" {
1397  			credentialModel, _err := client.Credential.GetCredential()
1398  			if _err != nil {
1399  				retriesAttempted++
1400  				retryPolicyContext = &dara.RetryPolicyContext{
1401  					RetriesAttempted: retriesAttempted,
1402  					HttpRequest:      request_,
1403  					HttpResponse:     response_,
1404  					Exception:        _err,
1405  				}
1406  				_resultErr = _err
1407  				continue
1408  			}
1409  
1410  			if !dara.IsNil(credentialModel.ProviderName) {
1411  				request_.Headers["x-acs-credentials-provider"] = credentialModel.ProviderName
1412  			}
1413  
1414  			authType := dara.StringValue(credentialModel.Type)
1415  			if authType == "bearer" {
1416  				bearerToken := dara.StringValue(credentialModel.BearerToken)
1417  				request_.Headers["x-acs-bearer-token"] = dara.String(bearerToken)
1418  			} else if authType == "id_token" {
1419  				idToken := dara.StringValue(credentialModel.SecurityToken)
1420  				request_.Headers["x-acs-zero-trust-idtoken"] = dara.String(idToken)
1421  			} else {
1422  				accessKeyId := dara.StringValue(credentialModel.AccessKeyId)
1423  				accessKeySecret := dara.StringValue(credentialModel.AccessKeySecret)
1424  				securityToken := dara.StringValue(credentialModel.SecurityToken)
1425  				if !dara.IsNil(dara.String(securityToken)) && securityToken != "" {
1426  					request_.Headers["x-acs-accesskey-id"] = dara.String(accessKeyId)
1427  					request_.Headers["x-acs-security-token"] = dara.String(securityToken)
1428  				}
1429  
1430  				request_.Headers["Authorization"] = openapiutil.GetAuthorization(request_, dara.String(signatureAlgorithm), dara.String(hex.EncodeToString(hashedRequestPayload)), dara.String(accessKeyId), dara.String(accessKeySecret))
1431  			}
1432  
1433  		}
1434  
1435  		response_, _err := dara.DoRequest(request_, _runtime)
1436  		if _err != nil {
1437  			retriesAttempted++
1438  			retryPolicyContext = &dara.RetryPolicyContext{
1439  				RetriesAttempted: retriesAttempted,
1440  				HttpRequest:      request_,
1441  				HttpResponse:     response_,
1442  				Exception:        _err,
1443  			}
1444  			_resultErr = _err
1445  			continue
1446  		}
1447  
1448  		callSSEApi_opResponse(_yield, _yieldErr, response_)
1449  		return
1450  	}
1451  	_yieldErr <- _resultErr
1452  	return
1453  }
1454  
1455  func (client *Client) CallApi(params *openapiutil.Params, request *openapiutil.OpenApiRequest, runtime *dara.RuntimeOptions) (_result map[string]interface{}, _err error) {
1456  	if dara.IsNil(params) {
1457  		_err = &ClientError{
1458  			Code:    dara.String("ParameterMissing"),
1459  			Message: dara.String("'params' can not be unset"),
1460  		}
1461  		return _result, _err
1462  	}
1463  
1464  	if dara.IsNil(client.SignatureVersion) || dara.StringValue(client.SignatureVersion) != "v4" {
1465  		if dara.IsNil(client.SignatureAlgorithm) || dara.StringValue(client.SignatureAlgorithm) != "v2" {
1466  			_body, _err := client.DoRequest(params, request, runtime)
1467  			if _err != nil {
1468  				return _result, _err
1469  			}
1470  			_result = _body
1471  			return _result, _err
1472  		} else if (dara.StringValue(params.Style) == "ROA") && (dara.StringValue(params.ReqBodyType) == "json") {
1473  			_body, _err := client.DoROARequest(params.Action, params.Version, params.Protocol, params.Method, params.AuthType, params.Pathname, params.BodyType, request, runtime)
1474  			if _err != nil {
1475  				return _result, _err
1476  			}
1477  			_result = _body
1478  			return _result, _err
1479  		} else if dara.StringValue(params.Style) == "ROA" {
1480  			_body, _err := client.DoROARequestWithForm(params.Action, params.Version, params.Protocol, params.Method, params.AuthType, params.Pathname, params.BodyType, request, runtime)
1481  			if _err != nil {
1482  				return _result, _err
1483  			}
1484  			_result = _body
1485  			return _result, _err
1486  		} else {
1487  			_body, _err := client.DoRPCRequest(params.Action, params.Version, params.Protocol, params.Method, params.AuthType, params.BodyType, request, runtime)
1488  			if _err != nil {
1489  				return _result, _err
1490  			}
1491  			_result = _body
1492  			return _result, _err
1493  		}
1494  
1495  	} else {
1496  		_body, _err := client.Execute(params, request, runtime)
1497  		if _err != nil {
1498  			return _result, _err
1499  		}
1500  		_result = _body
1501  		return _result, _err
1502  	}
1503  
1504  }
1505  
1506  // Description:
1507  //
1508  // # Get accesskey id by using credential
1509  //
1510  // @return accesskey id
1511  func (client *Client) GetAccessKeyId() (_result *string, _err error) {
1512  	if dara.IsNil(client.Credential) {
1513  		_result = dara.String("")
1514  		return _result, _err
1515  	}
1516  
1517  	accessKeyIdTmp, _err := client.Credential.GetAccessKeyId()
1518  	accessKeyId := dara.StringValue(accessKeyIdTmp)
1519  	if _err != nil {
1520  		return _result, _err
1521  	}
1522  
1523  	_result = dara.String(accessKeyId)
1524  	return _result, _err
1525  }
1526  
1527  // Description:
1528  //
1529  // # Get accesskey secret by using credential
1530  //
1531  // @return accesskey secret
1532  func (client *Client) GetAccessKeySecret() (_result *string, _err error) {
1533  	if dara.IsNil(client.Credential) {
1534  		_result = dara.String("")
1535  		return _result, _err
1536  	}
1537  
1538  	secretTmp, _err := client.Credential.GetAccessKeySecret()
1539  	secret := dara.StringValue(secretTmp)
1540  	if _err != nil {
1541  		return _result, _err
1542  	}
1543  
1544  	_result = dara.String(secret)
1545  	return _result, _err
1546  }
1547  
1548  // Description:
1549  //
1550  // # Get security token by using credential
1551  //
1552  // @return security token
1553  func (client *Client) GetSecurityToken() (_result *string, _err error) {
1554  	if dara.IsNil(client.Credential) {
1555  		_result = dara.String("")
1556  		return _result, _err
1557  	}
1558  
1559  	tokenTmp, _err := client.Credential.GetSecurityToken()
1560  	token := dara.StringValue(tokenTmp)
1561  	if _err != nil {
1562  		return _result, _err
1563  	}
1564  
1565  	_result = dara.String(token)
1566  	return _result, _err
1567  }
1568  
1569  // Description:
1570  //
1571  // # Get bearer token by credential
1572  //
1573  // @return bearer token
1574  func (client *Client) GetBearerToken() (_result *string, _err error) {
1575  	if dara.IsNil(client.Credential) {
1576  		_result = dara.String("")
1577  		return _result, _err
1578  	}
1579  
1580  	token := dara.StringValue(client.Credential.GetBearerToken())
1581  	_result = dara.String(token)
1582  	return _result, _err
1583  }
1584  
1585  // Description:
1586  //
1587  // # Get credential type by credential
1588  //
1589  // @return credential type e.g. access_key
1590  func (client *Client) GetType() (_result *string, _err error) {
1591  	if dara.IsNil(client.Credential) {
1592  		_result = dara.String("")
1593  		return _result, _err
1594  	}
1595  
1596  	authType := dara.StringValue(client.Credential.GetType())
1597  	_result = dara.String(authType)
1598  	return _result, _err
1599  }
1600  
1601  // Description:
1602  //
1603  // # If the endpointRule and config.endpoint are empty, throw error
1604  //
1605  // @param config - config contains the necessary information to create a client
1606  func (client *Client) CheckConfig(config *openapiutil.Config) (_err error) {
1607  	if dara.IsNil(client.EndpointRule) && dara.IsNil(config.Endpoint) {
1608  		_err = &ClientError{
1609  			Code:    dara.String("ParameterMissing"),
1610  			Message: dara.String("'config.endpoint' can not be empty"),
1611  		}
1612  		return _err
1613  	}
1614  
1615  	return _err
1616  }
1617  
1618  // Description:
1619  //
1620  // set gateway client
1621  //
1622  // @param spi - .
1623  func (client *Client) SetGatewayClient(spi spi.ClientInterface) (_err error) {
1624  	client.Spi = spi
1625  	return _err
1626  }
1627  
1628  // Description:
1629  //
1630  // set RPC header for debug
1631  //
1632  // @param headers - headers for debug, this header can be used only once.
1633  func (client *Client) SetRpcHeaders(headers map[string]*string) (_err error) {
1634  	client.Headers = headers
1635  	return _err
1636  }
1637  
1638  // Description:
1639  //
1640  // get RPC header for debug
1641  func (client *Client) GetRpcHeaders() (_result map[string]*string, _err error) {
1642  	headers := client.Headers
1643  	client.Headers = nil
1644  	_result = headers
1645  	return _result, _err
1646  }
1647  
1648  func (client *Client) GetAccessDeniedDetail(err map[string]interface{}) (_result map[string]interface{}) {
1649  	var accessDeniedDetail map[string]interface{}
1650  	if !dara.IsNil(err["AccessDeniedDetail"]) {
1651  		detail1 := dara.ToMap(err["AccessDeniedDetail"])
1652  		accessDeniedDetail = detail1
1653  	} else if !dara.IsNil(err["accessDeniedDetail"]) {
1654  		detail2 := dara.ToMap(err["accessDeniedDetail"])
1655  		accessDeniedDetail = detail2
1656  	}
1657  
1658  	_result = accessDeniedDetail
1659  	return _result
1660  }
1661  
1662  func doRPCRequest_opResponse(response_ *dara.Response, client *Client, bodyType *string) (_result map[string]interface{}, _err error) {
1663  	if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 600) {
1664  		_res, _err := dara.ReadAsJSON(response_.Body)
1665  		if _err != nil {
1666  			return _result, _err
1667  		}
1668  
1669  		err := dara.ToMap(_res)
1670  		requestId := dara.Default(err["RequestId"], err["requestId"])
1671  		code := dara.Default(err["Code"], err["code"])
1672  		if (dara.ToString(code) == "Throttling") || (dara.ToString(code) == "Throttling.User") || (dara.ToString(code) == "Throttling.Api") {
1673  			_err = &ThrottlingError{
1674  				StatusCode:  response_.StatusCode,
1675  				Code:        dara.String(dara.ToString(code)),
1676  				Message:     dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + dara.ToString(requestId)),
1677  				Description: dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
1678  				RetryAfter:  openapiutil.GetThrottlingTimeLeft(response_.Headers),
1679  				Data:        err,
1680  				RequestId:   dara.String(dara.ToString(requestId)),
1681  			}
1682  			return _result, _err
1683  		} else if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 500) {
1684  			_err = &ClientError{
1685  				StatusCode:         response_.StatusCode,
1686  				Code:               dara.String(dara.ToString(code)),
1687  				Message:            dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + dara.ToString(requestId)),
1688  				Description:        dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
1689  				Data:               err,
1690  				AccessDeniedDetail: client.GetAccessDeniedDetail(err),
1691  				RequestId:          dara.String(dara.ToString(requestId)),
1692  			}
1693  			return _result, _err
1694  		} else {
1695  			_err = &ServerError{
1696  				StatusCode:  response_.StatusCode,
1697  				Code:        dara.String(dara.ToString(code)),
1698  				Message:     dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + dara.ToString(requestId)),
1699  				Description: dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
1700  				Data:        err,
1701  				RequestId:   dara.String(dara.ToString(requestId)),
1702  			}
1703  			return _result, _err
1704  		}
1705  
1706  	}
1707  
1708  	if dara.StringValue(bodyType) == "binary" {
1709  		resp := map[string]interface{}{
1710  			"body":       response_.Body,
1711  			"headers":    response_.Headers,
1712  			"statusCode": dara.IntValue(response_.StatusCode),
1713  		}
1714  		_result = resp
1715  		return _result, _err
1716  	} else if dara.StringValue(bodyType) == "byte" {
1717  		byt, _err := dara.ReadAsBytes(response_.Body)
1718  		if _err != nil {
1719  			return _result, _err
1720  		}
1721  
1722  		_err = dara.Convert(map[string]interface{}{
1723  			"body":       byt,
1724  			"headers":    response_.Headers,
1725  			"statusCode": dara.IntValue(response_.StatusCode),
1726  		}, &_result)
1727  
1728  		return _result, _err
1729  	} else if dara.StringValue(bodyType) == "string" {
1730  		_str, _err := dara.ReadAsString(response_.Body)
1731  		if _err != nil {
1732  			return _result, _err
1733  		}
1734  
1735  		_err = dara.Convert(map[string]interface{}{
1736  			"body":       _str,
1737  			"headers":    response_.Headers,
1738  			"statusCode": dara.IntValue(response_.StatusCode),
1739  		}, &_result)
1740  
1741  		return _result, _err
1742  	} else if dara.StringValue(bodyType) == "json" {
1743  		obj, _err := dara.ReadAsJSON(response_.Body)
1744  		if _err != nil {
1745  			return _result, _err
1746  		}
1747  
1748  		res := dara.ToMap(obj)
1749  		_err = dara.Convert(map[string]interface{}{
1750  			"body":       res,
1751  			"headers":    response_.Headers,
1752  			"statusCode": dara.IntValue(response_.StatusCode),
1753  		}, &_result)
1754  
1755  		return _result, _err
1756  	} else if dara.StringValue(bodyType) == "array" {
1757  		arr, _err := dara.ReadAsJSON(response_.Body)
1758  		if _err != nil {
1759  			return _result, _err
1760  		}
1761  
1762  		_err = dara.Convert(map[string]interface{}{
1763  			"body":       arr,
1764  			"headers":    response_.Headers,
1765  			"statusCode": dara.IntValue(response_.StatusCode),
1766  		}, &_result)
1767  
1768  		return _result, _err
1769  	} else {
1770  		_err = dara.Convert(map[string]interface{}{
1771  			"headers":    response_.Headers,
1772  			"statusCode": dara.IntValue(response_.StatusCode),
1773  		}, &_result)
1774  
1775  		return _result, _err
1776  	}
1777  
1778  }
1779  
1780  func doROARequest_opResponse(response_ *dara.Response, client *Client, bodyType *string) (_result map[string]interface{}, _err error) {
1781  	if dara.IntValue(response_.StatusCode) == 204 {
1782  		_err = dara.Convert(map[string]map[string]*string{
1783  			"headers": response_.Headers,
1784  		}, &_result)
1785  
1786  		return _result, _err
1787  	}
1788  
1789  	if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 600) {
1790  		_res, _err := dara.ReadAsJSON(response_.Body)
1791  		if _err != nil {
1792  			return _result, _err
1793  		}
1794  
1795  		err := dara.ToMap(_res)
1796  		requestId := dara.ToString(dara.Default(err["RequestId"], err["requestId"]))
1797  		requestId = dara.ToString(dara.Default(requestId, err["requestid"]))
1798  		code := dara.ToString(dara.Default(err["Code"], err["code"]))
1799  		if (code == "Throttling") || (code == "Throttling.User") || (code == "Throttling.Api") {
1800  			_err = &ThrottlingError{
1801  				StatusCode:  response_.StatusCode,
1802  				Code:        dara.String(code),
1803  				Message:     dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + requestId),
1804  				Description: dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
1805  				RetryAfter:  openapiutil.GetThrottlingTimeLeft(response_.Headers),
1806  				Data:        err,
1807  				RequestId:   dara.String(requestId),
1808  			}
1809  			return _result, _err
1810  		} else if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 500) {
1811  			_err = &ClientError{
1812  				StatusCode:         response_.StatusCode,
1813  				Code:               dara.String(code),
1814  				Message:            dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + requestId),
1815  				Description:        dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
1816  				Data:               err,
1817  				AccessDeniedDetail: client.GetAccessDeniedDetail(err),
1818  				RequestId:          dara.String(requestId),
1819  			}
1820  			return _result, _err
1821  		} else {
1822  			_err = &ServerError{
1823  				StatusCode:  response_.StatusCode,
1824  				Code:        dara.String(code),
1825  				Message:     dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + requestId),
1826  				Description: dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
1827  				Data:        err,
1828  				RequestId:   dara.String(requestId),
1829  			}
1830  			return _result, _err
1831  		}
1832  
1833  	}
1834  
1835  	if dara.StringValue(bodyType) == "binary" {
1836  		resp := map[string]interface{}{
1837  			"body":       response_.Body,
1838  			"headers":    response_.Headers,
1839  			"statusCode": dara.IntValue(response_.StatusCode),
1840  		}
1841  		_result = resp
1842  		return _result, _err
1843  	} else if dara.StringValue(bodyType) == "byte" {
1844  		byt, _err := dara.ReadAsBytes(response_.Body)
1845  		if _err != nil {
1846  			return _result, _err
1847  		}
1848  
1849  		_err = dara.Convert(map[string]interface{}{
1850  			"body":       byt,
1851  			"headers":    response_.Headers,
1852  			"statusCode": dara.IntValue(response_.StatusCode),
1853  		}, &_result)
1854  
1855  		return _result, _err
1856  	} else if dara.StringValue(bodyType) == "string" {
1857  		_str, _err := dara.ReadAsString(response_.Body)
1858  		if _err != nil {
1859  			return _result, _err
1860  		}
1861  
1862  		_err = dara.Convert(map[string]interface{}{
1863  			"body":       _str,
1864  			"headers":    response_.Headers,
1865  			"statusCode": dara.IntValue(response_.StatusCode),
1866  		}, &_result)
1867  
1868  		return _result, _err
1869  	} else if dara.StringValue(bodyType) == "json" {
1870  		obj, _err := dara.ReadAsJSON(response_.Body)
1871  		if _err != nil {
1872  			return _result, _err
1873  		}
1874  
1875  		res := dara.ToMap(obj)
1876  		_err = dara.Convert(map[string]interface{}{
1877  			"body":       res,
1878  			"headers":    response_.Headers,
1879  			"statusCode": dara.IntValue(response_.StatusCode),
1880  		}, &_result)
1881  
1882  		return _result, _err
1883  	} else if dara.StringValue(bodyType) == "array" {
1884  		arr, _err := dara.ReadAsJSON(response_.Body)
1885  		if _err != nil {
1886  			return _result, _err
1887  		}
1888  
1889  		_err = dara.Convert(map[string]interface{}{
1890  			"body":       arr,
1891  			"headers":    response_.Headers,
1892  			"statusCode": dara.IntValue(response_.StatusCode),
1893  		}, &_result)
1894  
1895  		return _result, _err
1896  	} else {
1897  		_err = dara.Convert(map[string]interface{}{
1898  			"headers":    response_.Headers,
1899  			"statusCode": dara.IntValue(response_.StatusCode),
1900  		}, &_result)
1901  
1902  		return _result, _err
1903  	}
1904  
1905  }
1906  
1907  func doROARequestWithForm_opResponse(response_ *dara.Response, client *Client, bodyType *string) (_result map[string]interface{}, _err error) {
1908  	if dara.IntValue(response_.StatusCode) == 204 {
1909  		_err = dara.Convert(map[string]map[string]*string{
1910  			"headers": response_.Headers,
1911  		}, &_result)
1912  
1913  		return _result, _err
1914  	}
1915  
1916  	if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 600) {
1917  		_res, _err := dara.ReadAsJSON(response_.Body)
1918  		if _err != nil {
1919  			return _result, _err
1920  		}
1921  
1922  		err := dara.ToMap(_res)
1923  		requestId := dara.ToString(dara.Default(err["RequestId"], err["requestId"]))
1924  		code := dara.ToString(dara.Default(err["Code"], err["code"]))
1925  		if (code == "Throttling") || (code == "Throttling.User") || (code == "Throttling.Api") {
1926  			_err = &ThrottlingError{
1927  				StatusCode:  response_.StatusCode,
1928  				Code:        dara.String(code),
1929  				Message:     dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + requestId),
1930  				Description: dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
1931  				RetryAfter:  openapiutil.GetThrottlingTimeLeft(response_.Headers),
1932  				Data:        err,
1933  				RequestId:   dara.String(requestId),
1934  			}
1935  			return _result, _err
1936  		} else if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 500) {
1937  			_err = &ClientError{
1938  				StatusCode:         response_.StatusCode,
1939  				Code:               dara.String(code),
1940  				Message:            dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + requestId),
1941  				Description:        dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
1942  				Data:               err,
1943  				AccessDeniedDetail: client.GetAccessDeniedDetail(err),
1944  				RequestId:          dara.String(requestId),
1945  			}
1946  			return _result, _err
1947  		} else {
1948  			_err = &ServerError{
1949  				StatusCode:  response_.StatusCode,
1950  				Code:        dara.String(code),
1951  				Message:     dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + requestId),
1952  				Description: dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
1953  				Data:        err,
1954  				RequestId:   dara.String(requestId),
1955  			}
1956  			return _result, _err
1957  		}
1958  
1959  	}
1960  
1961  	if dara.StringValue(bodyType) == "binary" {
1962  		resp := map[string]interface{}{
1963  			"body":       response_.Body,
1964  			"headers":    response_.Headers,
1965  			"statusCode": dara.IntValue(response_.StatusCode),
1966  		}
1967  		_result = resp
1968  		return _result, _err
1969  	} else if dara.StringValue(bodyType) == "byte" {
1970  		byt, _err := dara.ReadAsBytes(response_.Body)
1971  		if _err != nil {
1972  			return _result, _err
1973  		}
1974  
1975  		_err = dara.Convert(map[string]interface{}{
1976  			"body":       byt,
1977  			"headers":    response_.Headers,
1978  			"statusCode": dara.IntValue(response_.StatusCode),
1979  		}, &_result)
1980  
1981  		return _result, _err
1982  	} else if dara.StringValue(bodyType) == "string" {
1983  		_str, _err := dara.ReadAsString(response_.Body)
1984  		if _err != nil {
1985  			return _result, _err
1986  		}
1987  
1988  		_err = dara.Convert(map[string]interface{}{
1989  			"body":       _str,
1990  			"headers":    response_.Headers,
1991  			"statusCode": dara.IntValue(response_.StatusCode),
1992  		}, &_result)
1993  
1994  		return _result, _err
1995  	} else if dara.StringValue(bodyType) == "json" {
1996  		obj, _err := dara.ReadAsJSON(response_.Body)
1997  		if _err != nil {
1998  			return _result, _err
1999  		}
2000  
2001  		res := dara.ToMap(obj)
2002  		_err = dara.Convert(map[string]interface{}{
2003  			"body":       res,
2004  			"headers":    response_.Headers,
2005  			"statusCode": dara.IntValue(response_.StatusCode),
2006  		}, &_result)
2007  
2008  		return _result, _err
2009  	} else if dara.StringValue(bodyType) == "array" {
2010  		arr, _err := dara.ReadAsJSON(response_.Body)
2011  		if _err != nil {
2012  			return _result, _err
2013  		}
2014  
2015  		_err = dara.Convert(map[string]interface{}{
2016  			"body":       arr,
2017  			"headers":    response_.Headers,
2018  			"statusCode": dara.IntValue(response_.StatusCode),
2019  		}, &_result)
2020  
2021  		return _result, _err
2022  	} else {
2023  		_err = dara.Convert(map[string]interface{}{
2024  			"headers":    response_.Headers,
2025  			"statusCode": dara.IntValue(response_.StatusCode),
2026  		}, &_result)
2027  
2028  		return _result, _err
2029  	}
2030  
2031  }
2032  
2033  func doRequest_opResponse(response_ *dara.Response, client *Client, params *openapiutil.Params) (_result map[string]interface{}, _err error) {
2034  	if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 600) {
2035  		err := map[string]interface{}{}
2036  		if !dara.IsNil(response_.Headers["content-type"]) && dara.StringValue(response_.Headers["content-type"]) == "text/xml;charset=utf-8" {
2037  			_str, _err := dara.ReadAsString(response_.Body)
2038  			if _err != nil {
2039  				return _result, _err
2040  			}
2041  
2042  			respMap := dara.ParseXml(_str, nil)
2043  			err = dara.ToMap(respMap["Error"])
2044  		} else {
2045  			_res, _err := dara.ReadAsJSON(response_.Body)
2046  			if _err != nil {
2047  				return _result, _err
2048  			}
2049  
2050  			err = dara.ToMap(_res)
2051  		}
2052  
2053  		requestId := dara.ToString(dara.Default(err["RequestId"], err["requestId"]))
2054  		code := dara.ToString(dara.Default(err["Code"], err["code"]))
2055  		if (code == "Throttling") || (code == "Throttling.User") || (code == "Throttling.Api") {
2056  			_err = &ThrottlingError{
2057  				StatusCode:  response_.StatusCode,
2058  				Code:        dara.String(code),
2059  				Message:     dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + requestId),
2060  				Description: dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
2061  				RetryAfter:  openapiutil.GetThrottlingTimeLeft(response_.Headers),
2062  				Data:        err,
2063  				RequestId:   dara.String(requestId),
2064  			}
2065  			return _result, _err
2066  		} else if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 500) {
2067  			_err = &ClientError{
2068  				StatusCode:         response_.StatusCode,
2069  				Code:               dara.String(code),
2070  				Message:            dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + requestId),
2071  				Description:        dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
2072  				Data:               err,
2073  				AccessDeniedDetail: client.GetAccessDeniedDetail(err),
2074  				RequestId:          dara.String(requestId),
2075  			}
2076  			return _result, _err
2077  		} else {
2078  			_err = &ServerError{
2079  				StatusCode:  response_.StatusCode,
2080  				Code:        dara.String(code),
2081  				Message:     dara.String("code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + requestId),
2082  				Description: dara.String(dara.ToString(dara.Default(err["Description"], err["description"]))),
2083  				Data:        err,
2084  				RequestId:   dara.String(requestId),
2085  			}
2086  			return _result, _err
2087  		}
2088  
2089  	}
2090  
2091  	if dara.StringValue(params.BodyType) == "binary" {
2092  		resp := map[string]interface{}{
2093  			"body":       response_.Body,
2094  			"headers":    response_.Headers,
2095  			"statusCode": dara.IntValue(response_.StatusCode),
2096  		}
2097  		_result = resp
2098  		return _result, _err
2099  	} else if dara.StringValue(params.BodyType) == "byte" {
2100  		byt, _err := dara.ReadAsBytes(response_.Body)
2101  		if _err != nil {
2102  			return _result, _err
2103  		}
2104  
2105  		_err = dara.Convert(map[string]interface{}{
2106  			"body":       byt,
2107  			"headers":    response_.Headers,
2108  			"statusCode": dara.IntValue(response_.StatusCode),
2109  		}, &_result)
2110  
2111  		return _result, _err
2112  	} else if dara.StringValue(params.BodyType) == "string" {
2113  		respStr, _err := dara.ReadAsString(response_.Body)
2114  		if _err != nil {
2115  			return _result, _err
2116  		}
2117  
2118  		_err = dara.Convert(map[string]interface{}{
2119  			"body":       respStr,
2120  			"headers":    response_.Headers,
2121  			"statusCode": dara.IntValue(response_.StatusCode),
2122  		}, &_result)
2123  
2124  		return _result, _err
2125  	} else if dara.StringValue(params.BodyType) == "json" {
2126  		obj, _err := dara.ReadAsJSON(response_.Body)
2127  		if _err != nil {
2128  			return _result, _err
2129  		}
2130  
2131  		res := dara.ToMap(obj)
2132  		_err = dara.Convert(map[string]interface{}{
2133  			"body":       res,
2134  			"headers":    response_.Headers,
2135  			"statusCode": dara.IntValue(response_.StatusCode),
2136  		}, &_result)
2137  
2138  		return _result, _err
2139  	} else if dara.StringValue(params.BodyType) == "array" {
2140  		arr, _err := dara.ReadAsJSON(response_.Body)
2141  		if _err != nil {
2142  			return _result, _err
2143  		}
2144  
2145  		_err = dara.Convert(map[string]interface{}{
2146  			"body":       arr,
2147  			"headers":    response_.Headers,
2148  			"statusCode": dara.IntValue(response_.StatusCode),
2149  		}, &_result)
2150  
2151  		return _result, _err
2152  	} else {
2153  		anything, _err := dara.ReadAsString(response_.Body)
2154  		if _err != nil {
2155  			return _result, _err
2156  		}
2157  
2158  		_err = dara.Convert(map[string]interface{}{
2159  			"body":       anything,
2160  			"headers":    response_.Headers,
2161  			"statusCode": dara.IntValue(response_.StatusCode),
2162  		}, &_result)
2163  
2164  		return _result, _err
2165  	}
2166  
2167  }
2168  
2169  func callSSEApi_opResponse(_yield chan *SSEResponse, _yieldErr chan error, response_ *dara.Response) {
2170  	if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 600) {
2171  		err := map[string]interface{}{}
2172  		if !dara.IsNil(response_.Headers["content-type"]) && dara.StringValue(response_.Headers["content-type"]) == "text/xml;charset=utf-8" {
2173  			_str, _err := dara.ReadAsString(response_.Body)
2174  			if _err != nil {
2175  				_yieldErr <- _err
2176  				return
2177  			}
2178  
2179  			respMap := dara.ParseXml(_str, nil)
2180  			err = dara.ToMap(respMap["Error"])
2181  		} else {
2182  			_res, _err := dara.ReadAsJSON(response_.Body)
2183  			if _err != nil {
2184  				_yieldErr <- _err
2185  				return
2186  			}
2187  
2188  			err = dara.ToMap(_res)
2189  		}
2190  
2191  		err["statusCode"] = response_.StatusCode
2192  		_err := dara.NewSDKError(map[string]interface{}{
2193  			"code":               dara.ToString(dara.Default(err["Code"], err["code"])),
2194  			"message":            "code: " + dara.ToString(dara.IntValue(response_.StatusCode)) + ", " + dara.ToString(dara.Default(err["Message"], err["message"])) + " request id: " + dara.ToString(dara.Default(err["RequestId"], err["requestId"])),
2195  			"data":               err,
2196  			"description":        dara.ToString(dara.Default(err["Description"], err["description"])),
2197  			"accessDeniedDetail": dara.Default(err["AccessDeniedDetail"], err["accessDeniedDetail"]),
2198  		})
2199  		_yieldErr <- _err
2200  		return
2201  	}
2202  
2203  	events := make(chan *dara.SSEEvent, 1)
2204  	dara.ReadAsSSE(response_.Body, events, _yieldErr)
2205  	for event := range events {
2206  		_yield <- &SSEResponse{
2207  			StatusCode: response_.StatusCode,
2208  			Headers:    response_.Headers,
2209  			Event:      event,
2210  		}
2211  	}
2212  	return
2213  }
2214