client_context_func.go raw

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