github.com/NaverCloudPlatform/ncloud-sdk-go-v2@v1.6.13/services/vredis/v2_api.go (about)

     1  /*
     2   * vredis
     3   *
     4   * <br/>https://ncloud.apigw.ntruss.com/vredis/v2
     5   *
     6   * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)
     7   */
     8  
     9  package vredis
    10  
    11  import (
    12  	"bytes"
    13  	"encoding/base64"
    14  	"encoding/json"
    15  	"fmt"
    16  	"io/ioutil"
    17  	"net/url"
    18  	"reflect"
    19  	"strings"
    20  
    21  	"golang.org/x/net/context"
    22  )
    23  
    24  // Linger please
    25  var (
    26  	_ context.Context
    27  )
    28  
    29  type V2ApiService service
    30  
    31  /* V2ApiService
    32  
    33  @param createCloudRedisConfigGroupRequest createCloudRedisConfigGroupRequest
    34  @return *CreateCloudRedisConfigGroupResponse*/
    35  func (a *V2ApiService) CreateCloudRedisConfigGroup(createCloudRedisConfigGroupRequest *CreateCloudRedisConfigGroupRequest) (*CreateCloudRedisConfigGroupResponse, error) {
    36  	var (
    37  		localVarHttpMethod = strings.ToUpper("Post")
    38  		localVarPostBody   interface{}
    39  		localVarFileName   string
    40  		localVarFileBytes  []byte
    41  		successPayload     CreateCloudRedisConfigGroupResponse
    42  	)
    43  
    44  	// create path and map variables
    45  	localVarPath := a.client.cfg.BasePath + "/createCloudRedisConfigGroup"
    46  
    47  	localVarHeaderParams := make(map[string]string)
    48  	localVarQueryParams := url.Values{}
    49  	localVarFormParams := url.Values{}
    50  
    51  	// to determine the Content-Type header
    52  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
    53  
    54  	// set Content-Type header
    55  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
    56  	if localVarHttpContentType != "" {
    57  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
    58  	}
    59  
    60  	// to determine the Accept header
    61  	localVarHttpHeaderAccepts := []string{}
    62  
    63  	// set Accept header
    64  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
    65  	if localVarHttpHeaderAccept != "" {
    66  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
    67  	}
    68  	// body params
    69  	localVarPostBody = createCloudRedisConfigGroupRequest
    70  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
    71  	if v.IsValid() && v.CanAddr() {
    72  		ptr := v.Addr().Interface().(**string)
    73  		if *ptr != nil {
    74  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
    75  		}
    76  	}
    77  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
    78  	if err != nil {
    79  		return &successPayload, err
    80  	}
    81  
    82  	localVarHttpResponse, err := a.client.callAPI(r)
    83  	if err != nil || localVarHttpResponse == nil {
    84  		return &successPayload, err
    85  	}
    86  	defer localVarHttpResponse.Body.Close()
    87  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
    88  
    89  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
    90  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
    91  	}
    92  
    93  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
    94  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
    95  			return &successPayload, err
    96  		}
    97  	}
    98  
    99  	return &successPayload, err
   100  }
   101  
   102  /* V2ApiService [Only Ncloud Gov]
   103  @param addCloudRedisUserListRequest addCloudRedisUserListRequest
   104  @return *AddCloudRedisUserListResponse*/
   105  func (a *V2ApiService) AddCloudRedisUserList(addCloudRedisUserListRequest *AddCloudRedisUserListRequest) (*AddCloudRedisUserListResponse, error) {
   106  	if !strings.Contains(a.client.cfg.BasePath, "apigw.gov-ntruss.com") {
   107  		return nil, fmt.Errorf("only Ncloud Gov can use")
   108  	}
   109  
   110  	var (
   111  		localVarHttpMethod = strings.ToUpper("Post")
   112  		localVarPostBody   interface{}
   113  		localVarFileName   string
   114  		localVarFileBytes  []byte
   115  		successPayload     AddCloudRedisUserListResponse
   116  	)
   117  
   118  	// create path and map variables
   119  	localVarPath := a.client.cfg.BasePath + "/addCloudRedisUserList"
   120  
   121  	localVarHeaderParams := make(map[string]string)
   122  	localVarQueryParams := url.Values{}
   123  	localVarFormParams := url.Values{}
   124  
   125  	// to determine the Content-Type header
   126  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   127  
   128  	// set Content-Type header
   129  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   130  	if localVarHttpContentType != "" {
   131  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   132  	}
   133  
   134  	// to determine the Accept header
   135  	localVarHttpHeaderAccepts := []string{}
   136  
   137  	// set Accept header
   138  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   139  	if localVarHttpHeaderAccept != "" {
   140  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   141  	}
   142  	// body params
   143  	localVarPostBody = addCloudRedisUserListRequest
   144  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   145  	if v.IsValid() && v.CanAddr() {
   146  		ptr := v.Addr().Interface().(**string)
   147  		if *ptr != nil {
   148  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   149  		}
   150  	}
   151  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   152  	if err != nil {
   153  		return &successPayload, err
   154  	}
   155  
   156  	localVarHttpResponse, err := a.client.callAPI(r)
   157  	if err != nil || localVarHttpResponse == nil {
   158  		return &successPayload, err
   159  	}
   160  	defer localVarHttpResponse.Body.Close()
   161  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   162  
   163  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   164  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   165  	}
   166  
   167  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   168  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   169  			return &successPayload, err
   170  		}
   171  	}
   172  
   173  	return &successPayload, err
   174  }
   175  
   176  /* V2ApiService [Only Ncloud Gov]
   177  @param deleteCloudRedisUserListRequest deleteCloudRedisUserListRequest
   178  @return *DeleteCloudRedisUserListResponse*/
   179  func (a *V2ApiService) DeleteCloudRedisUserList(deleteCloudRedisUserListRequest *DeleteCloudRedisUserListRequest) (*DeleteCloudRedisUserListResponse, error) {
   180  	if !strings.Contains(a.client.cfg.BasePath, "apigw.gov-ntruss.com") {
   181  		return nil, fmt.Errorf("only Ncloud Gov can use")
   182  	}
   183  
   184  	var (
   185  		localVarHttpMethod = strings.ToUpper("Post")
   186  		localVarPostBody   interface{}
   187  		localVarFileName   string
   188  		localVarFileBytes  []byte
   189  		successPayload     DeleteCloudRedisUserListResponse
   190  	)
   191  
   192  	// create path and map variables
   193  	localVarPath := a.client.cfg.BasePath + "/deleteCloudRedisUserList"
   194  
   195  	localVarHeaderParams := make(map[string]string)
   196  	localVarQueryParams := url.Values{}
   197  	localVarFormParams := url.Values{}
   198  
   199  	// to determine the Content-Type header
   200  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   201  
   202  	// set Content-Type header
   203  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   204  	if localVarHttpContentType != "" {
   205  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   206  	}
   207  
   208  	// to determine the Accept header
   209  	localVarHttpHeaderAccepts := []string{}
   210  
   211  	// set Accept header
   212  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   213  	if localVarHttpHeaderAccept != "" {
   214  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   215  	}
   216  	// body params
   217  	localVarPostBody = deleteCloudRedisUserListRequest
   218  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   219  	if v.IsValid() && v.CanAddr() {
   220  		ptr := v.Addr().Interface().(**string)
   221  		if *ptr != nil {
   222  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   223  		}
   224  	}
   225  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   226  	if err != nil {
   227  		return &successPayload, err
   228  	}
   229  
   230  	localVarHttpResponse, err := a.client.callAPI(r)
   231  	if err != nil || localVarHttpResponse == nil {
   232  		return &successPayload, err
   233  	}
   234  	defer localVarHttpResponse.Body.Close()
   235  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   236  
   237  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   238  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   239  	}
   240  
   241  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   242  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   243  			return &successPayload, err
   244  		}
   245  	}
   246  
   247  	return &successPayload, err
   248  }
   249  
   250  /* V2ApiService [Only Ncloud Gov]
   251  @param getCloudRedisUserListRequest getCloudRedisUserListRequest
   252  @return *GetCloudRedisUserListResponse*/
   253  func (a *V2ApiService) GetCloudRedisUserList(getCloudRedisUserListRequest *GetCloudRedisUserListRequest) (*GetCloudRedisUserListResponse, error) {
   254  	if !strings.Contains(a.client.cfg.BasePath, "apigw.gov-ntruss.com") {
   255  		return nil, fmt.Errorf("only Ncloud Gov can use")
   256  	}
   257  
   258  	var (
   259  		localVarHttpMethod = strings.ToUpper("Post")
   260  		localVarPostBody   interface{}
   261  		localVarFileName   string
   262  		localVarFileBytes  []byte
   263  		successPayload     GetCloudRedisUserListResponse
   264  	)
   265  
   266  	// create path and map variables
   267  	localVarPath := a.client.cfg.BasePath + "/getCloudRedisUserList"
   268  
   269  	localVarHeaderParams := make(map[string]string)
   270  	localVarQueryParams := url.Values{}
   271  	localVarFormParams := url.Values{}
   272  
   273  	// to determine the Content-Type header
   274  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   275  
   276  	// set Content-Type header
   277  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   278  	if localVarHttpContentType != "" {
   279  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   280  	}
   281  
   282  	// to determine the Accept header
   283  	localVarHttpHeaderAccepts := []string{}
   284  
   285  	// set Accept header
   286  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   287  	if localVarHttpHeaderAccept != "" {
   288  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   289  	}
   290  	// body params
   291  	localVarPostBody = getCloudRedisUserListRequest
   292  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   293  	if v.IsValid() && v.CanAddr() {
   294  		ptr := v.Addr().Interface().(**string)
   295  		if *ptr != nil {
   296  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   297  		}
   298  	}
   299  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   300  	if err != nil {
   301  		return &successPayload, err
   302  	}
   303  
   304  	localVarHttpResponse, err := a.client.callAPI(r)
   305  	if err != nil || localVarHttpResponse == nil {
   306  		return &successPayload, err
   307  	}
   308  	defer localVarHttpResponse.Body.Close()
   309  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   310  
   311  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   312  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   313  	}
   314  
   315  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   316  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   317  			return &successPayload, err
   318  		}
   319  	}
   320  
   321  	return &successPayload, err
   322  }
   323  
   324  /* V2ApiService
   325  
   326  @param createCloudRedisInstanceRequest createCloudRedisInstanceRequest
   327  @return *CreateCloudRedisInstanceResponse*/
   328  func (a *V2ApiService) CreateCloudRedisInstance(createCloudRedisInstanceRequest *CreateCloudRedisInstanceRequest) (*CreateCloudRedisInstanceResponse, error) {
   329  	var (
   330  		localVarHttpMethod = strings.ToUpper("Post")
   331  		localVarPostBody   interface{}
   332  		localVarFileName   string
   333  		localVarFileBytes  []byte
   334  		successPayload     CreateCloudRedisInstanceResponse
   335  	)
   336  
   337  	// create path and map variables
   338  	localVarPath := a.client.cfg.BasePath + "/createCloudRedisInstance"
   339  
   340  	localVarHeaderParams := make(map[string]string)
   341  	localVarQueryParams := url.Values{}
   342  	localVarFormParams := url.Values{}
   343  
   344  	// to determine the Content-Type header
   345  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   346  
   347  	// set Content-Type header
   348  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   349  	if localVarHttpContentType != "" {
   350  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   351  	}
   352  
   353  	// to determine the Accept header
   354  	localVarHttpHeaderAccepts := []string{}
   355  
   356  	// set Accept header
   357  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   358  	if localVarHttpHeaderAccept != "" {
   359  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   360  	}
   361  	// body params
   362  	localVarPostBody = createCloudRedisInstanceRequest
   363  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   364  	if v.IsValid() && v.CanAddr() {
   365  		ptr := v.Addr().Interface().(**string)
   366  		if *ptr != nil {
   367  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   368  		}
   369  	}
   370  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   371  	if err != nil {
   372  		return &successPayload, err
   373  	}
   374  
   375  	localVarHttpResponse, err := a.client.callAPI(r)
   376  	if err != nil || localVarHttpResponse == nil {
   377  		return &successPayload, err
   378  	}
   379  	defer localVarHttpResponse.Body.Close()
   380  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   381  
   382  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   383  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   384  	}
   385  
   386  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   387  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   388  			return &successPayload, err
   389  		}
   390  	}
   391  
   392  	return &successPayload, err
   393  }
   394  
   395  /* V2ApiService
   396  
   397  @param deleteCloudRedisConfigGroupRequest deleteCloudRedisConfigGroupRequest
   398  @return *DeleteCloudRedisConfigGroupResponse*/
   399  func (a *V2ApiService) DeleteCloudRedisConfigGroup(deleteCloudRedisConfigGroupRequest *DeleteCloudRedisConfigGroupRequest) (*DeleteCloudRedisConfigGroupResponse, error) {
   400  	var (
   401  		localVarHttpMethod = strings.ToUpper("Post")
   402  		localVarPostBody   interface{}
   403  		localVarFileName   string
   404  		localVarFileBytes  []byte
   405  		successPayload     DeleteCloudRedisConfigGroupResponse
   406  	)
   407  
   408  	// create path and map variables
   409  	localVarPath := a.client.cfg.BasePath + "/deleteCloudRedisConfigGroup"
   410  
   411  	localVarHeaderParams := make(map[string]string)
   412  	localVarQueryParams := url.Values{}
   413  	localVarFormParams := url.Values{}
   414  
   415  	// to determine the Content-Type header
   416  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   417  
   418  	// set Content-Type header
   419  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   420  	if localVarHttpContentType != "" {
   421  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   422  	}
   423  
   424  	// to determine the Accept header
   425  	localVarHttpHeaderAccepts := []string{}
   426  
   427  	// set Accept header
   428  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   429  	if localVarHttpHeaderAccept != "" {
   430  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   431  	}
   432  	// body params
   433  	localVarPostBody = deleteCloudRedisConfigGroupRequest
   434  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   435  	if v.IsValid() && v.CanAddr() {
   436  		ptr := v.Addr().Interface().(**string)
   437  		if *ptr != nil {
   438  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   439  		}
   440  	}
   441  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   442  	if err != nil {
   443  		return &successPayload, err
   444  	}
   445  
   446  	localVarHttpResponse, err := a.client.callAPI(r)
   447  	if err != nil || localVarHttpResponse == nil {
   448  		return &successPayload, err
   449  	}
   450  	defer localVarHttpResponse.Body.Close()
   451  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   452  
   453  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   454  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   455  	}
   456  
   457  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   458  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   459  			return &successPayload, err
   460  		}
   461  	}
   462  
   463  	return &successPayload, err
   464  }
   465  
   466  /* V2ApiService
   467  
   468  @param deleteCloudRedisInstanceRequest deleteCloudRedisInstanceRequest
   469  @return *DeleteCloudRedisInstanceResponse*/
   470  func (a *V2ApiService) DeleteCloudRedisInstance(deleteCloudRedisInstanceRequest *DeleteCloudRedisInstanceRequest) (*DeleteCloudRedisInstanceResponse, error) {
   471  	var (
   472  		localVarHttpMethod = strings.ToUpper("Post")
   473  		localVarPostBody   interface{}
   474  		localVarFileName   string
   475  		localVarFileBytes  []byte
   476  		successPayload     DeleteCloudRedisInstanceResponse
   477  	)
   478  
   479  	// create path and map variables
   480  	localVarPath := a.client.cfg.BasePath + "/deleteCloudRedisInstance"
   481  
   482  	localVarHeaderParams := make(map[string]string)
   483  	localVarQueryParams := url.Values{}
   484  	localVarFormParams := url.Values{}
   485  
   486  	// to determine the Content-Type header
   487  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   488  
   489  	// set Content-Type header
   490  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   491  	if localVarHttpContentType != "" {
   492  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   493  	}
   494  
   495  	// to determine the Accept header
   496  	localVarHttpHeaderAccepts := []string{}
   497  
   498  	// set Accept header
   499  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   500  	if localVarHttpHeaderAccept != "" {
   501  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   502  	}
   503  	// body params
   504  	localVarPostBody = deleteCloudRedisInstanceRequest
   505  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   506  	if v.IsValid() && v.CanAddr() {
   507  		ptr := v.Addr().Interface().(**string)
   508  		if *ptr != nil {
   509  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   510  		}
   511  	}
   512  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   513  	if err != nil {
   514  		return &successPayload, err
   515  	}
   516  
   517  	localVarHttpResponse, err := a.client.callAPI(r)
   518  	if err != nil || localVarHttpResponse == nil {
   519  		return &successPayload, err
   520  	}
   521  	defer localVarHttpResponse.Body.Close()
   522  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   523  
   524  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   525  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   526  	}
   527  
   528  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   529  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   530  			return &successPayload, err
   531  		}
   532  	}
   533  
   534  	return &successPayload, err
   535  }
   536  
   537  /* V2ApiService
   538  
   539  @param getCloudRedisBackupDetailListRequest getCloudRedisBackupDetailListRequest
   540  @return *GetCloudRedisBackupDetailListResponse*/
   541  func (a *V2ApiService) GetCloudRedisBackupDetailList(getCloudRedisBackupDetailListRequest *GetCloudRedisBackupDetailListRequest) (*GetCloudRedisBackupDetailListResponse, error) {
   542  	var (
   543  		localVarHttpMethod = strings.ToUpper("Post")
   544  		localVarPostBody   interface{}
   545  		localVarFileName   string
   546  		localVarFileBytes  []byte
   547  		successPayload     GetCloudRedisBackupDetailListResponse
   548  	)
   549  
   550  	// create path and map variables
   551  	localVarPath := a.client.cfg.BasePath + "/getCloudRedisBackupDetailList"
   552  
   553  	localVarHeaderParams := make(map[string]string)
   554  	localVarQueryParams := url.Values{}
   555  	localVarFormParams := url.Values{}
   556  
   557  	// to determine the Content-Type header
   558  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   559  
   560  	// set Content-Type header
   561  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   562  	if localVarHttpContentType != "" {
   563  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   564  	}
   565  
   566  	// to determine the Accept header
   567  	localVarHttpHeaderAccepts := []string{}
   568  
   569  	// set Accept header
   570  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   571  	if localVarHttpHeaderAccept != "" {
   572  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   573  	}
   574  	// body params
   575  	localVarPostBody = getCloudRedisBackupDetailListRequest
   576  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   577  	if v.IsValid() && v.CanAddr() {
   578  		ptr := v.Addr().Interface().(**string)
   579  		if *ptr != nil {
   580  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   581  		}
   582  	}
   583  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   584  	if err != nil {
   585  		return &successPayload, err
   586  	}
   587  
   588  	localVarHttpResponse, err := a.client.callAPI(r)
   589  	if err != nil || localVarHttpResponse == nil {
   590  		return &successPayload, err
   591  	}
   592  	defer localVarHttpResponse.Body.Close()
   593  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   594  
   595  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   596  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   597  	}
   598  
   599  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   600  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   601  			return &successPayload, err
   602  		}
   603  	}
   604  
   605  	return &successPayload, err
   606  }
   607  
   608  /* V2ApiService
   609  
   610  @param getCloudRedisBackupListRequest getCloudRedisBackupListRequest
   611  @return *GetCloudRedisBackupListResponse*/
   612  func (a *V2ApiService) GetCloudRedisBackupList(getCloudRedisBackupListRequest *GetCloudRedisBackupListRequest) (*GetCloudRedisBackupListResponse, error) {
   613  	var (
   614  		localVarHttpMethod = strings.ToUpper("Post")
   615  		localVarPostBody   interface{}
   616  		localVarFileName   string
   617  		localVarFileBytes  []byte
   618  		successPayload     GetCloudRedisBackupListResponse
   619  	)
   620  
   621  	// create path and map variables
   622  	localVarPath := a.client.cfg.BasePath + "/getCloudRedisBackupList"
   623  
   624  	localVarHeaderParams := make(map[string]string)
   625  	localVarQueryParams := url.Values{}
   626  	localVarFormParams := url.Values{}
   627  
   628  	// to determine the Content-Type header
   629  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   630  
   631  	// set Content-Type header
   632  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   633  	if localVarHttpContentType != "" {
   634  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   635  	}
   636  
   637  	// to determine the Accept header
   638  	localVarHttpHeaderAccepts := []string{}
   639  
   640  	// set Accept header
   641  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   642  	if localVarHttpHeaderAccept != "" {
   643  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   644  	}
   645  	// body params
   646  	localVarPostBody = getCloudRedisBackupListRequest
   647  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   648  	if v.IsValid() && v.CanAddr() {
   649  		ptr := v.Addr().Interface().(**string)
   650  		if *ptr != nil {
   651  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   652  		}
   653  	}
   654  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   655  	if err != nil {
   656  		return &successPayload, err
   657  	}
   658  
   659  	localVarHttpResponse, err := a.client.callAPI(r)
   660  	if err != nil || localVarHttpResponse == nil {
   661  		return &successPayload, err
   662  	}
   663  	defer localVarHttpResponse.Body.Close()
   664  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   665  
   666  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   667  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   668  	}
   669  
   670  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   671  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   672  			return &successPayload, err
   673  		}
   674  	}
   675  
   676  	return &successPayload, err
   677  }
   678  
   679  /* V2ApiService
   680  
   681  @param getCloudRedisConfigGroupListRequest getCloudRedisConfigGroupListRequest
   682  @return *GetCloudRedisConfigGroupListResponse*/
   683  func (a *V2ApiService) GetCloudRedisConfigGroupList(getCloudRedisConfigGroupListRequest *GetCloudRedisConfigGroupListRequest) (*GetCloudRedisConfigGroupListResponse, error) {
   684  	var (
   685  		localVarHttpMethod = strings.ToUpper("Post")
   686  		localVarPostBody   interface{}
   687  		localVarFileName   string
   688  		localVarFileBytes  []byte
   689  		successPayload     GetCloudRedisConfigGroupListResponse
   690  	)
   691  
   692  	// create path and map variables
   693  	localVarPath := a.client.cfg.BasePath + "/getCloudRedisConfigGroupList"
   694  
   695  	localVarHeaderParams := make(map[string]string)
   696  	localVarQueryParams := url.Values{}
   697  	localVarFormParams := url.Values{}
   698  
   699  	// to determine the Content-Type header
   700  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   701  
   702  	// set Content-Type header
   703  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   704  	if localVarHttpContentType != "" {
   705  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   706  	}
   707  
   708  	// to determine the Accept header
   709  	localVarHttpHeaderAccepts := []string{}
   710  
   711  	// set Accept header
   712  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   713  	if localVarHttpHeaderAccept != "" {
   714  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   715  	}
   716  	// body params
   717  	localVarPostBody = getCloudRedisConfigGroupListRequest
   718  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   719  	if v.IsValid() && v.CanAddr() {
   720  		ptr := v.Addr().Interface().(**string)
   721  		if *ptr != nil {
   722  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   723  		}
   724  	}
   725  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   726  	if err != nil {
   727  		return &successPayload, err
   728  	}
   729  
   730  	localVarHttpResponse, err := a.client.callAPI(r)
   731  	if err != nil || localVarHttpResponse == nil {
   732  		return &successPayload, err
   733  	}
   734  	defer localVarHttpResponse.Body.Close()
   735  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   736  
   737  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   738  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   739  	}
   740  
   741  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   742  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   743  			return &successPayload, err
   744  		}
   745  	}
   746  
   747  	return &successPayload, err
   748  }
   749  
   750  /* V2ApiService
   751  
   752  @param getCloudRedisImageProductListRequest getCloudRedisImageProductListRequest
   753  @return *GetCloudRedisImageProductListResponse*/
   754  func (a *V2ApiService) GetCloudRedisImageProductList(getCloudRedisImageProductListRequest *GetCloudRedisImageProductListRequest) (*GetCloudRedisImageProductListResponse, error) {
   755  	var (
   756  		localVarHttpMethod = strings.ToUpper("Post")
   757  		localVarPostBody   interface{}
   758  		localVarFileName   string
   759  		localVarFileBytes  []byte
   760  		successPayload     GetCloudRedisImageProductListResponse
   761  	)
   762  
   763  	// create path and map variables
   764  	localVarPath := a.client.cfg.BasePath + "/getCloudRedisImageProductList"
   765  
   766  	localVarHeaderParams := make(map[string]string)
   767  	localVarQueryParams := url.Values{}
   768  	localVarFormParams := url.Values{}
   769  
   770  	// to determine the Content-Type header
   771  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   772  
   773  	// set Content-Type header
   774  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   775  	if localVarHttpContentType != "" {
   776  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   777  	}
   778  
   779  	// to determine the Accept header
   780  	localVarHttpHeaderAccepts := []string{}
   781  
   782  	// set Accept header
   783  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   784  	if localVarHttpHeaderAccept != "" {
   785  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   786  	}
   787  	// body params
   788  	localVarPostBody = getCloudRedisImageProductListRequest
   789  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   790  	if v.IsValid() && v.CanAddr() {
   791  		ptr := v.Addr().Interface().(**string)
   792  		if *ptr != nil {
   793  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   794  		}
   795  	}
   796  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   797  	if err != nil {
   798  		return &successPayload, err
   799  	}
   800  
   801  	localVarHttpResponse, err := a.client.callAPI(r)
   802  	if err != nil || localVarHttpResponse == nil {
   803  		return &successPayload, err
   804  	}
   805  	defer localVarHttpResponse.Body.Close()
   806  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   807  
   808  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   809  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   810  	}
   811  
   812  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   813  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   814  			return &successPayload, err
   815  		}
   816  	}
   817  
   818  	return &successPayload, err
   819  }
   820  
   821  /* V2ApiService
   822  
   823  @param getCloudRedisInstanceDetailRequest getCloudRedisInstanceDetailRequest
   824  @return *GetCloudRedisInstanceDetailResponse*/
   825  func (a *V2ApiService) GetCloudRedisInstanceDetail(getCloudRedisInstanceDetailRequest *GetCloudRedisInstanceDetailRequest) (*GetCloudRedisInstanceDetailResponse, error) {
   826  	var (
   827  		localVarHttpMethod = strings.ToUpper("Post")
   828  		localVarPostBody   interface{}
   829  		localVarFileName   string
   830  		localVarFileBytes  []byte
   831  		successPayload     GetCloudRedisInstanceDetailResponse
   832  	)
   833  
   834  	// create path and map variables
   835  	localVarPath := a.client.cfg.BasePath + "/getCloudRedisInstanceDetail"
   836  
   837  	localVarHeaderParams := make(map[string]string)
   838  	localVarQueryParams := url.Values{}
   839  	localVarFormParams := url.Values{}
   840  
   841  	// to determine the Content-Type header
   842  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   843  
   844  	// set Content-Type header
   845  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   846  	if localVarHttpContentType != "" {
   847  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   848  	}
   849  
   850  	// to determine the Accept header
   851  	localVarHttpHeaderAccepts := []string{}
   852  
   853  	// set Accept header
   854  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   855  	if localVarHttpHeaderAccept != "" {
   856  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   857  	}
   858  	// body params
   859  	localVarPostBody = getCloudRedisInstanceDetailRequest
   860  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   861  	if v.IsValid() && v.CanAddr() {
   862  		ptr := v.Addr().Interface().(**string)
   863  		if *ptr != nil {
   864  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   865  		}
   866  	}
   867  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   868  	if err != nil {
   869  		return &successPayload, err
   870  	}
   871  
   872  	localVarHttpResponse, err := a.client.callAPI(r)
   873  	if err != nil || localVarHttpResponse == nil {
   874  		return &successPayload, err
   875  	}
   876  	defer localVarHttpResponse.Body.Close()
   877  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   878  
   879  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   880  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   881  	}
   882  
   883  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   884  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   885  			return &successPayload, err
   886  		}
   887  	}
   888  
   889  	return &successPayload, err
   890  }
   891  
   892  /* V2ApiService
   893  
   894  @param getCloudRedisInstanceListRequest getCloudRedisInstanceListRequest
   895  @return *GetCloudRedisInstanceListResponse*/
   896  func (a *V2ApiService) GetCloudRedisInstanceList(getCloudRedisInstanceListRequest *GetCloudRedisInstanceListRequest) (*GetCloudRedisInstanceListResponse, error) {
   897  	var (
   898  		localVarHttpMethod = strings.ToUpper("Post")
   899  		localVarPostBody   interface{}
   900  		localVarFileName   string
   901  		localVarFileBytes  []byte
   902  		successPayload     GetCloudRedisInstanceListResponse
   903  	)
   904  
   905  	// create path and map variables
   906  	localVarPath := a.client.cfg.BasePath + "/getCloudRedisInstanceList"
   907  
   908  	localVarHeaderParams := make(map[string]string)
   909  	localVarQueryParams := url.Values{}
   910  	localVarFormParams := url.Values{}
   911  
   912  	// to determine the Content-Type header
   913  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   914  
   915  	// set Content-Type header
   916  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   917  	if localVarHttpContentType != "" {
   918  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   919  	}
   920  
   921  	// to determine the Accept header
   922  	localVarHttpHeaderAccepts := []string{}
   923  
   924  	// set Accept header
   925  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   926  	if localVarHttpHeaderAccept != "" {
   927  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   928  	}
   929  	// body params
   930  	localVarPostBody = getCloudRedisInstanceListRequest
   931  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   932  	if v.IsValid() && v.CanAddr() {
   933  		ptr := v.Addr().Interface().(**string)
   934  		if *ptr != nil {
   935  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   936  		}
   937  	}
   938  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   939  	if err != nil {
   940  		return &successPayload, err
   941  	}
   942  
   943  	localVarHttpResponse, err := a.client.callAPI(r)
   944  	if err != nil || localVarHttpResponse == nil {
   945  		return &successPayload, err
   946  	}
   947  	defer localVarHttpResponse.Body.Close()
   948  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   949  
   950  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   951  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   952  	}
   953  
   954  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   955  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   956  			return &successPayload, err
   957  		}
   958  	}
   959  
   960  	return &successPayload, err
   961  }
   962  
   963  /* V2ApiService
   964  
   965  @param getCloudRedisProductListRequest getCloudRedisProductListRequest
   966  @return *GetCloudRedisProductListResponse*/
   967  func (a *V2ApiService) GetCloudRedisProductList(getCloudRedisProductListRequest *GetCloudRedisProductListRequest) (*GetCloudRedisProductListResponse, error) {
   968  	var (
   969  		localVarHttpMethod = strings.ToUpper("Post")
   970  		localVarPostBody   interface{}
   971  		localVarFileName   string
   972  		localVarFileBytes  []byte
   973  		successPayload     GetCloudRedisProductListResponse
   974  	)
   975  
   976  	// create path and map variables
   977  	localVarPath := a.client.cfg.BasePath + "/getCloudRedisProductList"
   978  
   979  	localVarHeaderParams := make(map[string]string)
   980  	localVarQueryParams := url.Values{}
   981  	localVarFormParams := url.Values{}
   982  
   983  	// to determine the Content-Type header
   984  	localVarHttpContentTypes := []string{"application/x-www-form-urlencoded"}
   985  
   986  	// set Content-Type header
   987  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   988  	if localVarHttpContentType != "" {
   989  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   990  	}
   991  
   992  	// to determine the Accept header
   993  	localVarHttpHeaderAccepts := []string{}
   994  
   995  	// set Accept header
   996  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   997  	if localVarHttpHeaderAccept != "" {
   998  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   999  	}
  1000  	// body params
  1001  	localVarPostBody = getCloudRedisProductListRequest
  1002  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1003  	if v.IsValid() && v.CanAddr() {
  1004  		ptr := v.Addr().Interface().(**string)
  1005  		if *ptr != nil {
  1006  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1007  		}
  1008  	}
  1009  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1010  	if err != nil {
  1011  		return &successPayload, err
  1012  	}
  1013  
  1014  	localVarHttpResponse, err := a.client.callAPI(r)
  1015  	if err != nil || localVarHttpResponse == nil {
  1016  		return &successPayload, err
  1017  	}
  1018  	defer localVarHttpResponse.Body.Close()
  1019  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1020  
  1021  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
  1022  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1023  	}
  1024  
  1025  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
  1026  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
  1027  			return &successPayload, err
  1028  		}
  1029  	}
  1030  
  1031  	return &successPayload, err
  1032  }