github.com/spinnaker/spin@v1.30.0/gateapi/api_application_controller.go (about)

     1  
     2  /*
     3   * Spinnaker API
     4   *
     5   * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
     6   *
     7   * API version: 1.0.0
     8   * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)
     9   */
    10  
    11  package swagger
    12  
    13  import (
    14  	"context"
    15  	"io/ioutil"
    16  	"net/http"
    17  	"net/url"
    18  	"strings"
    19  	"fmt"
    20  	"github.com/antihax/optional"
    21  )
    22  
    23  // Linger please
    24  var (
    25  	_ context.Context
    26  )
    27  
    28  type ApplicationControllerApiService service
    29  
    30  /* 
    31  ApplicationControllerApiService Cancel pipeline
    32   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
    33   * @param id id
    34   * @param optional nil or *ApplicationControllerApiCancelPipelineUsingPUTOpts - Optional Parameters:
    35       * @param "Reason" (optional.String) -  reason
    36  
    37  @return map[string]interface{}
    38  */
    39  
    40  type ApplicationControllerApiCancelPipelineUsingPUTOpts struct { 
    41  	Reason optional.String
    42  }
    43  
    44  func (a *ApplicationControllerApiService) CancelPipelineUsingPUT(ctx context.Context, id string, localVarOptionals *ApplicationControllerApiCancelPipelineUsingPUTOpts) (map[string]interface{}, *http.Response, error) {
    45  	var (
    46  		localVarHttpMethod = strings.ToUpper("Put")
    47  		localVarPostBody   interface{}
    48  		localVarFileName   string
    49  		localVarFileBytes  []byte
    50  		localVarReturnValue map[string]interface{}
    51  	)
    52  
    53  	// create path and map variables
    54  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/pipelines/{id}/cancel"
    55  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
    56  
    57  	localVarHeaderParams := make(map[string]string)
    58  	localVarQueryParams := url.Values{}
    59  	localVarFormParams := url.Values{}
    60  
    61  	if localVarOptionals != nil && localVarOptionals.Reason.IsSet() {
    62  		localVarQueryParams.Add("reason", parameterToString(localVarOptionals.Reason.Value(), ""))
    63  	}
    64  	// to determine the Content-Type header
    65  	localVarHttpContentTypes := []string{"application/json"}
    66  
    67  	// set Content-Type header
    68  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
    69  	if localVarHttpContentType != "" {
    70  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
    71  	}
    72  
    73  	// to determine the Accept header
    74  	localVarHttpHeaderAccepts := []string{"*/*"}
    75  
    76  	// set Accept header
    77  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
    78  	if localVarHttpHeaderAccept != "" {
    79  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
    80  	}
    81  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
    82  	if err != nil {
    83  		return localVarReturnValue, nil, err
    84  	}
    85  
    86  	localVarHttpResponse, err := a.client.callAPI(r)
    87  	if err != nil || localVarHttpResponse == nil {
    88  		return localVarReturnValue, localVarHttpResponse, err
    89  	}
    90  
    91  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
    92  	localVarHttpResponse.Body.Close()
    93  	if err != nil {
    94  		return localVarReturnValue, localVarHttpResponse, err
    95  	}
    96  
    97  	if localVarHttpResponse.StatusCode < 300 {
    98  		// If we succeed, return the data, otherwise pass on to decode error.
    99  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   100  		if err == nil { 
   101  			return localVarReturnValue, localVarHttpResponse, err
   102  		}
   103  	}
   104  
   105  	if localVarHttpResponse.StatusCode >= 300 {
   106  		newErr := GenericSwaggerError{
   107  			body: localVarBody,
   108  			error: localVarHttpResponse.Status,
   109  		}
   110  		
   111  		if localVarHttpResponse.StatusCode == 200 {
   112  			var v map[string]interface{}
   113  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   114  				if err != nil {
   115  					newErr.error = err.Error()
   116  					return localVarReturnValue, localVarHttpResponse, newErr
   117  				}
   118  				newErr.model = v
   119  				return localVarReturnValue, localVarHttpResponse, newErr
   120  		}
   121  		
   122  		return localVarReturnValue, localVarHttpResponse, newErr
   123  	}
   124  
   125  	return localVarReturnValue, localVarHttpResponse, nil
   126  }
   127  
   128  /* 
   129  ApplicationControllerApiService Cancel task
   130   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   131   * @param id id
   132  
   133  @return map[string]interface{}
   134  */
   135  func (a *ApplicationControllerApiService) CancelTaskUsingPUT(ctx context.Context, id string) (map[string]interface{}, *http.Response, error) {
   136  	var (
   137  		localVarHttpMethod = strings.ToUpper("Put")
   138  		localVarPostBody   interface{}
   139  		localVarFileName   string
   140  		localVarFileBytes  []byte
   141  		localVarReturnValue map[string]interface{}
   142  	)
   143  
   144  	// create path and map variables
   145  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/tasks/{id}/cancel"
   146  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
   147  
   148  	localVarHeaderParams := make(map[string]string)
   149  	localVarQueryParams := url.Values{}
   150  	localVarFormParams := url.Values{}
   151  
   152  	// to determine the Content-Type header
   153  	localVarHttpContentTypes := []string{"application/json"}
   154  
   155  	// set Content-Type header
   156  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   157  	if localVarHttpContentType != "" {
   158  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   159  	}
   160  
   161  	// to determine the Accept header
   162  	localVarHttpHeaderAccepts := []string{"*/*"}
   163  
   164  	// set Accept header
   165  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   166  	if localVarHttpHeaderAccept != "" {
   167  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   168  	}
   169  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   170  	if err != nil {
   171  		return localVarReturnValue, nil, err
   172  	}
   173  
   174  	localVarHttpResponse, err := a.client.callAPI(r)
   175  	if err != nil || localVarHttpResponse == nil {
   176  		return localVarReturnValue, localVarHttpResponse, err
   177  	}
   178  
   179  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   180  	localVarHttpResponse.Body.Close()
   181  	if err != nil {
   182  		return localVarReturnValue, localVarHttpResponse, err
   183  	}
   184  
   185  	if localVarHttpResponse.StatusCode < 300 {
   186  		// If we succeed, return the data, otherwise pass on to decode error.
   187  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   188  		if err == nil { 
   189  			return localVarReturnValue, localVarHttpResponse, err
   190  		}
   191  	}
   192  
   193  	if localVarHttpResponse.StatusCode >= 300 {
   194  		newErr := GenericSwaggerError{
   195  			body: localVarBody,
   196  			error: localVarHttpResponse.Status,
   197  		}
   198  		
   199  		if localVarHttpResponse.StatusCode == 200 {
   200  			var v map[string]interface{}
   201  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   202  				if err != nil {
   203  					newErr.error = err.Error()
   204  					return localVarReturnValue, localVarHttpResponse, newErr
   205  				}
   206  				newErr.model = v
   207  				return localVarReturnValue, localVarHttpResponse, newErr
   208  		}
   209  		
   210  		return localVarReturnValue, localVarHttpResponse, newErr
   211  	}
   212  
   213  	return localVarReturnValue, localVarHttpResponse, nil
   214  }
   215  
   216  /* 
   217  ApplicationControllerApiService Retrieve a list of applications
   218   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   219   * @param optional nil or *ApplicationControllerApiGetAllApplicationsUsingGETOpts - Optional Parameters:
   220       * @param "Account" (optional.String) -  filters results to only include applications deployed in the specified account
   221       * @param "Owner" (optional.String) -  filters results to only include applications owned by the specified email
   222  
   223  @return []interface{}
   224  */
   225  
   226  type ApplicationControllerApiGetAllApplicationsUsingGETOpts struct { 
   227  	Account optional.String
   228  	Owner optional.String
   229  }
   230  
   231  func (a *ApplicationControllerApiService) GetAllApplicationsUsingGET(ctx context.Context, localVarOptionals *ApplicationControllerApiGetAllApplicationsUsingGETOpts) ([]interface{}, *http.Response, error) {
   232  	var (
   233  		localVarHttpMethod = strings.ToUpper("Get")
   234  		localVarPostBody   interface{}
   235  		localVarFileName   string
   236  		localVarFileBytes  []byte
   237  		localVarReturnValue []interface{}
   238  	)
   239  
   240  	// create path and map variables
   241  	localVarPath := a.client.cfg.BasePath + "/applications"
   242  
   243  	localVarHeaderParams := make(map[string]string)
   244  	localVarQueryParams := url.Values{}
   245  	localVarFormParams := url.Values{}
   246  
   247  	if localVarOptionals != nil && localVarOptionals.Account.IsSet() {
   248  		localVarQueryParams.Add("account", parameterToString(localVarOptionals.Account.Value(), ""))
   249  	}
   250  	if localVarOptionals != nil && localVarOptionals.Owner.IsSet() {
   251  		localVarQueryParams.Add("owner", parameterToString(localVarOptionals.Owner.Value(), ""))
   252  	}
   253  	// to determine the Content-Type header
   254  	localVarHttpContentTypes := []string{}
   255  
   256  	// set Content-Type header
   257  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   258  	if localVarHttpContentType != "" {
   259  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   260  	}
   261  
   262  	// to determine the Accept header
   263  	localVarHttpHeaderAccepts := []string{"*/*"}
   264  
   265  	// set Accept header
   266  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   267  	if localVarHttpHeaderAccept != "" {
   268  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   269  	}
   270  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   271  	if err != nil {
   272  		return localVarReturnValue, nil, err
   273  	}
   274  
   275  	localVarHttpResponse, err := a.client.callAPI(r)
   276  	if err != nil || localVarHttpResponse == nil {
   277  		return localVarReturnValue, localVarHttpResponse, err
   278  	}
   279  
   280  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   281  	localVarHttpResponse.Body.Close()
   282  	if err != nil {
   283  		return localVarReturnValue, localVarHttpResponse, err
   284  	}
   285  
   286  	if localVarHttpResponse.StatusCode < 300 {
   287  		// If we succeed, return the data, otherwise pass on to decode error.
   288  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   289  		if err == nil { 
   290  			return localVarReturnValue, localVarHttpResponse, err
   291  		}
   292  	}
   293  
   294  	if localVarHttpResponse.StatusCode >= 300 {
   295  		newErr := GenericSwaggerError{
   296  			body: localVarBody,
   297  			error: localVarHttpResponse.Status,
   298  		}
   299  		
   300  		if localVarHttpResponse.StatusCode == 200 {
   301  			var v []interface{}
   302  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   303  				if err != nil {
   304  					newErr.error = err.Error()
   305  					return localVarReturnValue, localVarHttpResponse, newErr
   306  				}
   307  				newErr.model = v
   308  				return localVarReturnValue, localVarHttpResponse, newErr
   309  		}
   310  		
   311  		return localVarReturnValue, localVarHttpResponse, newErr
   312  	}
   313  
   314  	return localVarReturnValue, localVarHttpResponse, nil
   315  }
   316  
   317  /* 
   318  ApplicationControllerApiService Retrieve a list of an application&#39;s configuration revision history
   319   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   320   * @param application application
   321   * @param optional nil or *ApplicationControllerApiGetApplicationHistoryUsingGETOpts - Optional Parameters:
   322       * @param "Limit" (optional.Int32) -  limit
   323  
   324  @return []interface{}
   325  */
   326  
   327  type ApplicationControllerApiGetApplicationHistoryUsingGETOpts struct { 
   328  	Limit optional.Int32
   329  }
   330  
   331  func (a *ApplicationControllerApiService) GetApplicationHistoryUsingGET(ctx context.Context, application string, localVarOptionals *ApplicationControllerApiGetApplicationHistoryUsingGETOpts) ([]interface{}, *http.Response, error) {
   332  	var (
   333  		localVarHttpMethod = strings.ToUpper("Get")
   334  		localVarPostBody   interface{}
   335  		localVarFileName   string
   336  		localVarFileBytes  []byte
   337  		localVarReturnValue []interface{}
   338  	)
   339  
   340  	// create path and map variables
   341  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/history"
   342  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   343  
   344  	localVarHeaderParams := make(map[string]string)
   345  	localVarQueryParams := url.Values{}
   346  	localVarFormParams := url.Values{}
   347  
   348  	if localVarOptionals != nil && localVarOptionals.Limit.IsSet() {
   349  		localVarQueryParams.Add("limit", parameterToString(localVarOptionals.Limit.Value(), ""))
   350  	}
   351  	// to determine the Content-Type header
   352  	localVarHttpContentTypes := []string{}
   353  
   354  	// set Content-Type header
   355  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   356  	if localVarHttpContentType != "" {
   357  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   358  	}
   359  
   360  	// to determine the Accept header
   361  	localVarHttpHeaderAccepts := []string{"*/*"}
   362  
   363  	// set Accept header
   364  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   365  	if localVarHttpHeaderAccept != "" {
   366  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   367  	}
   368  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   369  	if err != nil {
   370  		return localVarReturnValue, nil, err
   371  	}
   372  
   373  	localVarHttpResponse, err := a.client.callAPI(r)
   374  	if err != nil || localVarHttpResponse == nil {
   375  		return localVarReturnValue, localVarHttpResponse, err
   376  	}
   377  
   378  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   379  	localVarHttpResponse.Body.Close()
   380  	if err != nil {
   381  		return localVarReturnValue, localVarHttpResponse, err
   382  	}
   383  
   384  	if localVarHttpResponse.StatusCode < 300 {
   385  		// If we succeed, return the data, otherwise pass on to decode error.
   386  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   387  		if err == nil { 
   388  			return localVarReturnValue, localVarHttpResponse, err
   389  		}
   390  	}
   391  
   392  	if localVarHttpResponse.StatusCode >= 300 {
   393  		newErr := GenericSwaggerError{
   394  			body: localVarBody,
   395  			error: localVarHttpResponse.Status,
   396  		}
   397  		
   398  		if localVarHttpResponse.StatusCode == 200 {
   399  			var v []interface{}
   400  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   401  				if err != nil {
   402  					newErr.error = err.Error()
   403  					return localVarReturnValue, localVarHttpResponse, newErr
   404  				}
   405  				newErr.model = v
   406  				return localVarReturnValue, localVarHttpResponse, newErr
   407  		}
   408  		
   409  		return localVarReturnValue, localVarHttpResponse, newErr
   410  	}
   411  
   412  	return localVarReturnValue, localVarHttpResponse, nil
   413  }
   414  
   415  /* 
   416  ApplicationControllerApiService Retrieve an application&#39;s details
   417   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   418   * @param application application
   419   * @param optional nil or *ApplicationControllerApiGetApplicationUsingGETOpts - Optional Parameters:
   420       * @param "Expand" (optional.Bool) -  expand
   421  
   422  @return map[string]interface{}
   423  */
   424  
   425  type ApplicationControllerApiGetApplicationUsingGETOpts struct { 
   426  	Expand optional.Bool
   427  }
   428  
   429  func (a *ApplicationControllerApiService) GetApplicationUsingGET(ctx context.Context, application string, localVarOptionals *ApplicationControllerApiGetApplicationUsingGETOpts) (map[string]interface{}, *http.Response, error) {
   430  	var (
   431  		localVarHttpMethod = strings.ToUpper("Get")
   432  		localVarPostBody   interface{}
   433  		localVarFileName   string
   434  		localVarFileBytes  []byte
   435  		localVarReturnValue map[string]interface{}
   436  	)
   437  
   438  	// create path and map variables
   439  	localVarPath := a.client.cfg.BasePath + "/applications/{application}"
   440  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   441  
   442  	localVarHeaderParams := make(map[string]string)
   443  	localVarQueryParams := url.Values{}
   444  	localVarFormParams := url.Values{}
   445  
   446  	if localVarOptionals != nil && localVarOptionals.Expand.IsSet() {
   447  		localVarQueryParams.Add("expand", parameterToString(localVarOptionals.Expand.Value(), ""))
   448  	}
   449  	// to determine the Content-Type header
   450  	localVarHttpContentTypes := []string{}
   451  
   452  	// set Content-Type header
   453  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   454  	if localVarHttpContentType != "" {
   455  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   456  	}
   457  
   458  	// to determine the Accept header
   459  	localVarHttpHeaderAccepts := []string{"*/*"}
   460  
   461  	// set Accept header
   462  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   463  	if localVarHttpHeaderAccept != "" {
   464  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   465  	}
   466  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   467  	if err != nil {
   468  		return localVarReturnValue, nil, err
   469  	}
   470  
   471  	localVarHttpResponse, err := a.client.callAPI(r)
   472  	if err != nil || localVarHttpResponse == nil {
   473  		return localVarReturnValue, localVarHttpResponse, err
   474  	}
   475  
   476  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   477  	localVarHttpResponse.Body.Close()
   478  	if err != nil {
   479  		return localVarReturnValue, localVarHttpResponse, err
   480  	}
   481  
   482  	if localVarHttpResponse.StatusCode < 300 {
   483  		// If we succeed, return the data, otherwise pass on to decode error.
   484  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   485  		if err == nil { 
   486  			return localVarReturnValue, localVarHttpResponse, err
   487  		}
   488  	}
   489  
   490  	if localVarHttpResponse.StatusCode >= 300 {
   491  		newErr := GenericSwaggerError{
   492  			body: localVarBody,
   493  			error: localVarHttpResponse.Status,
   494  		}
   495  		
   496  		if localVarHttpResponse.StatusCode == 200 {
   497  			var v map[string]interface{}
   498  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   499  				if err != nil {
   500  					newErr.error = err.Error()
   501  					return localVarReturnValue, localVarHttpResponse, newErr
   502  				}
   503  				newErr.model = v
   504  				return localVarReturnValue, localVarHttpResponse, newErr
   505  		}
   506  		
   507  		return localVarReturnValue, localVarHttpResponse, newErr
   508  	}
   509  
   510  	return localVarReturnValue, localVarHttpResponse, nil
   511  }
   512  
   513  /* 
   514  ApplicationControllerApiService Retrieve a pipeline configuration
   515   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   516   * @param application application
   517   * @param pipelineName pipelineName
   518  
   519  @return map[string]interface{}
   520  */
   521  func (a *ApplicationControllerApiService) GetPipelineConfigUsingGET(ctx context.Context, application string, pipelineName string) (map[string]interface{}, *http.Response, error) {
   522  	var (
   523  		localVarHttpMethod = strings.ToUpper("Get")
   524  		localVarPostBody   interface{}
   525  		localVarFileName   string
   526  		localVarFileBytes  []byte
   527  		localVarReturnValue map[string]interface{}
   528  	)
   529  
   530  	// create path and map variables
   531  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/pipelineConfigs/{pipelineName}"
   532  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   533  	localVarPath = strings.Replace(localVarPath, "{"+"pipelineName"+"}", fmt.Sprintf("%v", pipelineName), -1)
   534  
   535  	localVarHeaderParams := make(map[string]string)
   536  	localVarQueryParams := url.Values{}
   537  	localVarFormParams := url.Values{}
   538  
   539  	// to determine the Content-Type header
   540  	localVarHttpContentTypes := []string{}
   541  
   542  	// set Content-Type header
   543  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   544  	if localVarHttpContentType != "" {
   545  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   546  	}
   547  
   548  	// to determine the Accept header
   549  	localVarHttpHeaderAccepts := []string{"*/*"}
   550  
   551  	// set Accept header
   552  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   553  	if localVarHttpHeaderAccept != "" {
   554  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   555  	}
   556  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   557  	if err != nil {
   558  		return localVarReturnValue, nil, err
   559  	}
   560  
   561  	localVarHttpResponse, err := a.client.callAPI(r)
   562  	if err != nil || localVarHttpResponse == nil {
   563  		return localVarReturnValue, localVarHttpResponse, err
   564  	}
   565  
   566  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   567  	localVarHttpResponse.Body.Close()
   568  	if err != nil {
   569  		return localVarReturnValue, localVarHttpResponse, err
   570  	}
   571  
   572  	if localVarHttpResponse.StatusCode < 300 {
   573  		// If we succeed, return the data, otherwise pass on to decode error.
   574  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   575  		if err == nil { 
   576  			return localVarReturnValue, localVarHttpResponse, err
   577  		}
   578  	}
   579  
   580  	if localVarHttpResponse.StatusCode >= 300 {
   581  		newErr := GenericSwaggerError{
   582  			body: localVarBody,
   583  			error: localVarHttpResponse.Status,
   584  		}
   585  		
   586  		if localVarHttpResponse.StatusCode == 200 {
   587  			var v map[string]interface{}
   588  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   589  				if err != nil {
   590  					newErr.error = err.Error()
   591  					return localVarReturnValue, localVarHttpResponse, newErr
   592  				}
   593  				newErr.model = v
   594  				return localVarReturnValue, localVarHttpResponse, newErr
   595  		}
   596  		
   597  		return localVarReturnValue, localVarHttpResponse, newErr
   598  	}
   599  
   600  	return localVarReturnValue, localVarHttpResponse, nil
   601  }
   602  
   603  /* 
   604  ApplicationControllerApiService Retrieve a list of an application&#39;s pipeline configurations
   605   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   606   * @param application application
   607  
   608  @return []interface{}
   609  */
   610  func (a *ApplicationControllerApiService) GetPipelineConfigsForApplicationUsingGET(ctx context.Context, application string) ([]interface{}, *http.Response, error) {
   611  	var (
   612  		localVarHttpMethod = strings.ToUpper("Get")
   613  		localVarPostBody   interface{}
   614  		localVarFileName   string
   615  		localVarFileBytes  []byte
   616  		localVarReturnValue []interface{}
   617  	)
   618  
   619  	// create path and map variables
   620  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/pipelineConfigs"
   621  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   622  
   623  	localVarHeaderParams := make(map[string]string)
   624  	localVarQueryParams := url.Values{}
   625  	localVarFormParams := url.Values{}
   626  
   627  	// to determine the Content-Type header
   628  	localVarHttpContentTypes := []string{}
   629  
   630  	// set Content-Type header
   631  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   632  	if localVarHttpContentType != "" {
   633  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   634  	}
   635  
   636  	// to determine the Accept header
   637  	localVarHttpHeaderAccepts := []string{"*/*"}
   638  
   639  	// set Accept header
   640  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   641  	if localVarHttpHeaderAccept != "" {
   642  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   643  	}
   644  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   645  	if err != nil {
   646  		return localVarReturnValue, nil, err
   647  	}
   648  
   649  	localVarHttpResponse, err := a.client.callAPI(r)
   650  	if err != nil || localVarHttpResponse == nil {
   651  		return localVarReturnValue, localVarHttpResponse, err
   652  	}
   653  
   654  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   655  	localVarHttpResponse.Body.Close()
   656  	if err != nil {
   657  		return localVarReturnValue, localVarHttpResponse, err
   658  	}
   659  
   660  	if localVarHttpResponse.StatusCode < 300 {
   661  		// If we succeed, return the data, otherwise pass on to decode error.
   662  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   663  		if err == nil { 
   664  			return localVarReturnValue, localVarHttpResponse, err
   665  		}
   666  	}
   667  
   668  	if localVarHttpResponse.StatusCode >= 300 {
   669  		newErr := GenericSwaggerError{
   670  			body: localVarBody,
   671  			error: localVarHttpResponse.Status,
   672  		}
   673  		
   674  		if localVarHttpResponse.StatusCode == 200 {
   675  			var v []interface{}
   676  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   677  				if err != nil {
   678  					newErr.error = err.Error()
   679  					return localVarReturnValue, localVarHttpResponse, newErr
   680  				}
   681  				newErr.model = v
   682  				return localVarReturnValue, localVarHttpResponse, newErr
   683  		}
   684  		
   685  		return localVarReturnValue, localVarHttpResponse, newErr
   686  	}
   687  
   688  	return localVarReturnValue, localVarHttpResponse, nil
   689  }
   690  
   691  /* 
   692  ApplicationControllerApiService Retrieve a list of an application&#39;s pipeline executions
   693   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   694   * @param application application
   695   * @param optional nil or *ApplicationControllerApiGetPipelinesUsingGETOpts - Optional Parameters:
   696       * @param "Expand" (optional.Bool) -  expand
   697       * @param "Limit" (optional.Int32) -  limit
   698       * @param "Statuses" (optional.String) -  statuses
   699  
   700  @return []interface{}
   701  */
   702  
   703  type ApplicationControllerApiGetPipelinesUsingGETOpts struct { 
   704  	Expand optional.Bool
   705  	Limit optional.Int32
   706  	Statuses optional.String
   707  }
   708  
   709  func (a *ApplicationControllerApiService) GetPipelinesUsingGET(ctx context.Context, application string, localVarOptionals *ApplicationControllerApiGetPipelinesUsingGETOpts) ([]interface{}, *http.Response, error) {
   710  	var (
   711  		localVarHttpMethod = strings.ToUpper("Get")
   712  		localVarPostBody   interface{}
   713  		localVarFileName   string
   714  		localVarFileBytes  []byte
   715  		localVarReturnValue []interface{}
   716  	)
   717  
   718  	// create path and map variables
   719  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/pipelines"
   720  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   721  
   722  	localVarHeaderParams := make(map[string]string)
   723  	localVarQueryParams := url.Values{}
   724  	localVarFormParams := url.Values{}
   725  
   726  	if localVarOptionals != nil && localVarOptionals.Expand.IsSet() {
   727  		localVarQueryParams.Add("expand", parameterToString(localVarOptionals.Expand.Value(), ""))
   728  	}
   729  	if localVarOptionals != nil && localVarOptionals.Limit.IsSet() {
   730  		localVarQueryParams.Add("limit", parameterToString(localVarOptionals.Limit.Value(), ""))
   731  	}
   732  	if localVarOptionals != nil && localVarOptionals.Statuses.IsSet() {
   733  		localVarQueryParams.Add("statuses", parameterToString(localVarOptionals.Statuses.Value(), ""))
   734  	}
   735  	// to determine the Content-Type header
   736  	localVarHttpContentTypes := []string{}
   737  
   738  	// set Content-Type header
   739  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   740  	if localVarHttpContentType != "" {
   741  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   742  	}
   743  
   744  	// to determine the Accept header
   745  	localVarHttpHeaderAccepts := []string{"*/*"}
   746  
   747  	// set Accept header
   748  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   749  	if localVarHttpHeaderAccept != "" {
   750  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   751  	}
   752  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   753  	if err != nil {
   754  		return localVarReturnValue, nil, err
   755  	}
   756  
   757  	localVarHttpResponse, err := a.client.callAPI(r)
   758  	if err != nil || localVarHttpResponse == nil {
   759  		return localVarReturnValue, localVarHttpResponse, err
   760  	}
   761  
   762  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   763  	localVarHttpResponse.Body.Close()
   764  	if err != nil {
   765  		return localVarReturnValue, localVarHttpResponse, err
   766  	}
   767  
   768  	if localVarHttpResponse.StatusCode < 300 {
   769  		// If we succeed, return the data, otherwise pass on to decode error.
   770  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   771  		if err == nil { 
   772  			return localVarReturnValue, localVarHttpResponse, err
   773  		}
   774  	}
   775  
   776  	if localVarHttpResponse.StatusCode >= 300 {
   777  		newErr := GenericSwaggerError{
   778  			body: localVarBody,
   779  			error: localVarHttpResponse.Status,
   780  		}
   781  		
   782  		if localVarHttpResponse.StatusCode == 200 {
   783  			var v []interface{}
   784  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   785  				if err != nil {
   786  					newErr.error = err.Error()
   787  					return localVarReturnValue, localVarHttpResponse, newErr
   788  				}
   789  				newErr.model = v
   790  				return localVarReturnValue, localVarHttpResponse, newErr
   791  		}
   792  		
   793  		return localVarReturnValue, localVarHttpResponse, newErr
   794  	}
   795  
   796  	return localVarReturnValue, localVarHttpResponse, nil
   797  }
   798  
   799  /* 
   800  ApplicationControllerApiService Retrieve a pipeline strategy configuration
   801   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   802   * @param application application
   803   * @param strategyName strategyName
   804  
   805  @return map[string]interface{}
   806  */
   807  func (a *ApplicationControllerApiService) GetStrategyConfigUsingGET(ctx context.Context, application string, strategyName string) (map[string]interface{}, *http.Response, error) {
   808  	var (
   809  		localVarHttpMethod = strings.ToUpper("Get")
   810  		localVarPostBody   interface{}
   811  		localVarFileName   string
   812  		localVarFileBytes  []byte
   813  		localVarReturnValue map[string]interface{}
   814  	)
   815  
   816  	// create path and map variables
   817  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/strategyConfigs/{strategyName}"
   818  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   819  	localVarPath = strings.Replace(localVarPath, "{"+"strategyName"+"}", fmt.Sprintf("%v", strategyName), -1)
   820  
   821  	localVarHeaderParams := make(map[string]string)
   822  	localVarQueryParams := url.Values{}
   823  	localVarFormParams := url.Values{}
   824  
   825  	// to determine the Content-Type header
   826  	localVarHttpContentTypes := []string{}
   827  
   828  	// set Content-Type header
   829  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   830  	if localVarHttpContentType != "" {
   831  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   832  	}
   833  
   834  	// to determine the Accept header
   835  	localVarHttpHeaderAccepts := []string{"*/*"}
   836  
   837  	// set Accept header
   838  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   839  	if localVarHttpHeaderAccept != "" {
   840  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   841  	}
   842  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   843  	if err != nil {
   844  		return localVarReturnValue, nil, err
   845  	}
   846  
   847  	localVarHttpResponse, err := a.client.callAPI(r)
   848  	if err != nil || localVarHttpResponse == nil {
   849  		return localVarReturnValue, localVarHttpResponse, err
   850  	}
   851  
   852  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   853  	localVarHttpResponse.Body.Close()
   854  	if err != nil {
   855  		return localVarReturnValue, localVarHttpResponse, err
   856  	}
   857  
   858  	if localVarHttpResponse.StatusCode < 300 {
   859  		// If we succeed, return the data, otherwise pass on to decode error.
   860  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   861  		if err == nil { 
   862  			return localVarReturnValue, localVarHttpResponse, err
   863  		}
   864  	}
   865  
   866  	if localVarHttpResponse.StatusCode >= 300 {
   867  		newErr := GenericSwaggerError{
   868  			body: localVarBody,
   869  			error: localVarHttpResponse.Status,
   870  		}
   871  		
   872  		if localVarHttpResponse.StatusCode == 200 {
   873  			var v map[string]interface{}
   874  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   875  				if err != nil {
   876  					newErr.error = err.Error()
   877  					return localVarReturnValue, localVarHttpResponse, newErr
   878  				}
   879  				newErr.model = v
   880  				return localVarReturnValue, localVarHttpResponse, newErr
   881  		}
   882  		
   883  		return localVarReturnValue, localVarHttpResponse, newErr
   884  	}
   885  
   886  	return localVarReturnValue, localVarHttpResponse, nil
   887  }
   888  
   889  /* 
   890  ApplicationControllerApiService Retrieve a list of an application&#39;s pipeline strategy configurations
   891   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   892   * @param application application
   893  
   894  @return []interface{}
   895  */
   896  func (a *ApplicationControllerApiService) GetStrategyConfigsForApplicationUsingGET(ctx context.Context, application string) ([]interface{}, *http.Response, error) {
   897  	var (
   898  		localVarHttpMethod = strings.ToUpper("Get")
   899  		localVarPostBody   interface{}
   900  		localVarFileName   string
   901  		localVarFileBytes  []byte
   902  		localVarReturnValue []interface{}
   903  	)
   904  
   905  	// create path and map variables
   906  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/strategyConfigs"
   907  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
   908  
   909  	localVarHeaderParams := make(map[string]string)
   910  	localVarQueryParams := url.Values{}
   911  	localVarFormParams := url.Values{}
   912  
   913  	// to determine the Content-Type header
   914  	localVarHttpContentTypes := []string{}
   915  
   916  	// set Content-Type header
   917  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   918  	if localVarHttpContentType != "" {
   919  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   920  	}
   921  
   922  	// to determine the Accept header
   923  	localVarHttpHeaderAccepts := []string{"*/*"}
   924  
   925  	// set Accept header
   926  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   927  	if localVarHttpHeaderAccept != "" {
   928  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   929  	}
   930  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   931  	if err != nil {
   932  		return localVarReturnValue, nil, err
   933  	}
   934  
   935  	localVarHttpResponse, err := a.client.callAPI(r)
   936  	if err != nil || localVarHttpResponse == nil {
   937  		return localVarReturnValue, localVarHttpResponse, err
   938  	}
   939  
   940  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   941  	localVarHttpResponse.Body.Close()
   942  	if err != nil {
   943  		return localVarReturnValue, localVarHttpResponse, err
   944  	}
   945  
   946  	if localVarHttpResponse.StatusCode < 300 {
   947  		// If we succeed, return the data, otherwise pass on to decode error.
   948  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   949  		if err == nil { 
   950  			return localVarReturnValue, localVarHttpResponse, err
   951  		}
   952  	}
   953  
   954  	if localVarHttpResponse.StatusCode >= 300 {
   955  		newErr := GenericSwaggerError{
   956  			body: localVarBody,
   957  			error: localVarHttpResponse.Status,
   958  		}
   959  		
   960  		if localVarHttpResponse.StatusCode == 200 {
   961  			var v []interface{}
   962  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
   963  				if err != nil {
   964  					newErr.error = err.Error()
   965  					return localVarReturnValue, localVarHttpResponse, newErr
   966  				}
   967  				newErr.model = v
   968  				return localVarReturnValue, localVarHttpResponse, newErr
   969  		}
   970  		
   971  		return localVarReturnValue, localVarHttpResponse, newErr
   972  	}
   973  
   974  	return localVarReturnValue, localVarHttpResponse, nil
   975  }
   976  
   977  /* 
   978  ApplicationControllerApiService Get task details
   979   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   980   * @param id id
   981   * @param taskDetailsId taskDetailsId
   982   * @param optional nil or *ApplicationControllerApiGetTaskDetailsUsingGETOpts - Optional Parameters:
   983       * @param "XRateLimitApp" (optional.String) -  X-RateLimit-App
   984  
   985  @return map[string]interface{}
   986  */
   987  
   988  type ApplicationControllerApiGetTaskDetailsUsingGETOpts struct { 
   989  	XRateLimitApp optional.String
   990  }
   991  
   992  func (a *ApplicationControllerApiService) GetTaskDetailsUsingGET(ctx context.Context, id string, taskDetailsId string, localVarOptionals *ApplicationControllerApiGetTaskDetailsUsingGETOpts) (map[string]interface{}, *http.Response, error) {
   993  	var (
   994  		localVarHttpMethod = strings.ToUpper("Get")
   995  		localVarPostBody   interface{}
   996  		localVarFileName   string
   997  		localVarFileBytes  []byte
   998  		localVarReturnValue map[string]interface{}
   999  	)
  1000  
  1001  	// create path and map variables
  1002  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/tasks/{id}/details/{taskDetailsId}"
  1003  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
  1004  	localVarPath = strings.Replace(localVarPath, "{"+"taskDetailsId"+"}", fmt.Sprintf("%v", taskDetailsId), -1)
  1005  
  1006  	localVarHeaderParams := make(map[string]string)
  1007  	localVarQueryParams := url.Values{}
  1008  	localVarFormParams := url.Values{}
  1009  
  1010  	// to determine the Content-Type header
  1011  	localVarHttpContentTypes := []string{}
  1012  
  1013  	// set Content-Type header
  1014  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1015  	if localVarHttpContentType != "" {
  1016  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1017  	}
  1018  
  1019  	// to determine the Accept header
  1020  	localVarHttpHeaderAccepts := []string{"*/*"}
  1021  
  1022  	// set Accept header
  1023  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1024  	if localVarHttpHeaderAccept != "" {
  1025  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1026  	}
  1027  	if localVarOptionals != nil && localVarOptionals.XRateLimitApp.IsSet() {
  1028  		localVarHeaderParams["X-RateLimit-App"] = parameterToString(localVarOptionals.XRateLimitApp.Value(), "")
  1029  	}
  1030  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1031  	if err != nil {
  1032  		return localVarReturnValue, nil, err
  1033  	}
  1034  
  1035  	localVarHttpResponse, err := a.client.callAPI(r)
  1036  	if err != nil || localVarHttpResponse == nil {
  1037  		return localVarReturnValue, localVarHttpResponse, err
  1038  	}
  1039  
  1040  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1041  	localVarHttpResponse.Body.Close()
  1042  	if err != nil {
  1043  		return localVarReturnValue, localVarHttpResponse, err
  1044  	}
  1045  
  1046  	if localVarHttpResponse.StatusCode < 300 {
  1047  		// If we succeed, return the data, otherwise pass on to decode error.
  1048  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1049  		if err == nil { 
  1050  			return localVarReturnValue, localVarHttpResponse, err
  1051  		}
  1052  	}
  1053  
  1054  	if localVarHttpResponse.StatusCode >= 300 {
  1055  		newErr := GenericSwaggerError{
  1056  			body: localVarBody,
  1057  			error: localVarHttpResponse.Status,
  1058  		}
  1059  		
  1060  		if localVarHttpResponse.StatusCode == 200 {
  1061  			var v map[string]interface{}
  1062  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1063  				if err != nil {
  1064  					newErr.error = err.Error()
  1065  					return localVarReturnValue, localVarHttpResponse, newErr
  1066  				}
  1067  				newErr.model = v
  1068  				return localVarReturnValue, localVarHttpResponse, newErr
  1069  		}
  1070  		
  1071  		return localVarReturnValue, localVarHttpResponse, newErr
  1072  	}
  1073  
  1074  	return localVarReturnValue, localVarHttpResponse, nil
  1075  }
  1076  
  1077  /* 
  1078  ApplicationControllerApiService Get task
  1079   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1080   * @param id id
  1081  
  1082  @return map[string]interface{}
  1083  */
  1084  func (a *ApplicationControllerApiService) GetTaskUsingGET(ctx context.Context, id string) (map[string]interface{}, *http.Response, error) {
  1085  	var (
  1086  		localVarHttpMethod = strings.ToUpper("Get")
  1087  		localVarPostBody   interface{}
  1088  		localVarFileName   string
  1089  		localVarFileBytes  []byte
  1090  		localVarReturnValue map[string]interface{}
  1091  	)
  1092  
  1093  	// create path and map variables
  1094  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/tasks/{id}"
  1095  	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", fmt.Sprintf("%v", id), -1)
  1096  
  1097  	localVarHeaderParams := make(map[string]string)
  1098  	localVarQueryParams := url.Values{}
  1099  	localVarFormParams := url.Values{}
  1100  
  1101  	// to determine the Content-Type header
  1102  	localVarHttpContentTypes := []string{}
  1103  
  1104  	// set Content-Type header
  1105  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1106  	if localVarHttpContentType != "" {
  1107  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1108  	}
  1109  
  1110  	// to determine the Accept header
  1111  	localVarHttpHeaderAccepts := []string{"*/*"}
  1112  
  1113  	// set Accept header
  1114  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1115  	if localVarHttpHeaderAccept != "" {
  1116  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1117  	}
  1118  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1119  	if err != nil {
  1120  		return localVarReturnValue, nil, err
  1121  	}
  1122  
  1123  	localVarHttpResponse, err := a.client.callAPI(r)
  1124  	if err != nil || localVarHttpResponse == nil {
  1125  		return localVarReturnValue, localVarHttpResponse, err
  1126  	}
  1127  
  1128  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1129  	localVarHttpResponse.Body.Close()
  1130  	if err != nil {
  1131  		return localVarReturnValue, localVarHttpResponse, err
  1132  	}
  1133  
  1134  	if localVarHttpResponse.StatusCode < 300 {
  1135  		// If we succeed, return the data, otherwise pass on to decode error.
  1136  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1137  		if err == nil { 
  1138  			return localVarReturnValue, localVarHttpResponse, err
  1139  		}
  1140  	}
  1141  
  1142  	if localVarHttpResponse.StatusCode >= 300 {
  1143  		newErr := GenericSwaggerError{
  1144  			body: localVarBody,
  1145  			error: localVarHttpResponse.Status,
  1146  		}
  1147  		
  1148  		if localVarHttpResponse.StatusCode == 200 {
  1149  			var v map[string]interface{}
  1150  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1151  				if err != nil {
  1152  					newErr.error = err.Error()
  1153  					return localVarReturnValue, localVarHttpResponse, newErr
  1154  				}
  1155  				newErr.model = v
  1156  				return localVarReturnValue, localVarHttpResponse, newErr
  1157  		}
  1158  		
  1159  		return localVarReturnValue, localVarHttpResponse, newErr
  1160  	}
  1161  
  1162  	return localVarReturnValue, localVarHttpResponse, nil
  1163  }
  1164  
  1165  /* 
  1166  ApplicationControllerApiService Retrieve a list of an application&#39;s tasks
  1167   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1168   * @param application application
  1169   * @param optional nil or *ApplicationControllerApiGetTasksUsingGETOpts - Optional Parameters:
  1170       * @param "Limit" (optional.Int32) -  limit
  1171       * @param "Page" (optional.Int32) -  page
  1172       * @param "Statuses" (optional.String) -  statuses
  1173  
  1174  @return []interface{}
  1175  */
  1176  
  1177  type ApplicationControllerApiGetTasksUsingGETOpts struct { 
  1178  	Limit optional.Int32
  1179  	Page optional.Int32
  1180  	Statuses optional.String
  1181  }
  1182  
  1183  func (a *ApplicationControllerApiService) GetTasksUsingGET(ctx context.Context, application string, localVarOptionals *ApplicationControllerApiGetTasksUsingGETOpts) ([]interface{}, *http.Response, error) {
  1184  	var (
  1185  		localVarHttpMethod = strings.ToUpper("Get")
  1186  		localVarPostBody   interface{}
  1187  		localVarFileName   string
  1188  		localVarFileBytes  []byte
  1189  		localVarReturnValue []interface{}
  1190  	)
  1191  
  1192  	// create path and map variables
  1193  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/tasks"
  1194  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
  1195  
  1196  	localVarHeaderParams := make(map[string]string)
  1197  	localVarQueryParams := url.Values{}
  1198  	localVarFormParams := url.Values{}
  1199  
  1200  	if localVarOptionals != nil && localVarOptionals.Limit.IsSet() {
  1201  		localVarQueryParams.Add("limit", parameterToString(localVarOptionals.Limit.Value(), ""))
  1202  	}
  1203  	if localVarOptionals != nil && localVarOptionals.Page.IsSet() {
  1204  		localVarQueryParams.Add("page", parameterToString(localVarOptionals.Page.Value(), ""))
  1205  	}
  1206  	if localVarOptionals != nil && localVarOptionals.Statuses.IsSet() {
  1207  		localVarQueryParams.Add("statuses", parameterToString(localVarOptionals.Statuses.Value(), ""))
  1208  	}
  1209  	// to determine the Content-Type header
  1210  	localVarHttpContentTypes := []string{}
  1211  
  1212  	// set Content-Type header
  1213  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1214  	if localVarHttpContentType != "" {
  1215  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1216  	}
  1217  
  1218  	// to determine the Accept header
  1219  	localVarHttpHeaderAccepts := []string{"*/*"}
  1220  
  1221  	// set Accept header
  1222  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1223  	if localVarHttpHeaderAccept != "" {
  1224  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1225  	}
  1226  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1227  	if err != nil {
  1228  		return localVarReturnValue, nil, err
  1229  	}
  1230  
  1231  	localVarHttpResponse, err := a.client.callAPI(r)
  1232  	if err != nil || localVarHttpResponse == nil {
  1233  		return localVarReturnValue, localVarHttpResponse, err
  1234  	}
  1235  
  1236  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1237  	localVarHttpResponse.Body.Close()
  1238  	if err != nil {
  1239  		return localVarReturnValue, localVarHttpResponse, err
  1240  	}
  1241  
  1242  	if localVarHttpResponse.StatusCode < 300 {
  1243  		// If we succeed, return the data, otherwise pass on to decode error.
  1244  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1245  		if err == nil { 
  1246  			return localVarReturnValue, localVarHttpResponse, err
  1247  		}
  1248  	}
  1249  
  1250  	if localVarHttpResponse.StatusCode >= 300 {
  1251  		newErr := GenericSwaggerError{
  1252  			body: localVarBody,
  1253  			error: localVarHttpResponse.Status,
  1254  		}
  1255  		
  1256  		if localVarHttpResponse.StatusCode == 200 {
  1257  			var v []interface{}
  1258  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1259  				if err != nil {
  1260  					newErr.error = err.Error()
  1261  					return localVarReturnValue, localVarHttpResponse, newErr
  1262  				}
  1263  				newErr.model = v
  1264  				return localVarReturnValue, localVarHttpResponse, newErr
  1265  		}
  1266  		
  1267  		return localVarReturnValue, localVarHttpResponse, newErr
  1268  	}
  1269  
  1270  	return localVarReturnValue, localVarHttpResponse, nil
  1271  }
  1272  
  1273  /* 
  1274  ApplicationControllerApiService Invoke pipeline config
  1275   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1276   * @param application application
  1277   * @param pipelineName pipelineName
  1278   * @param optional nil or *ApplicationControllerApiInvokePipelineConfigUsingPOSTOpts - Optional Parameters:
  1279       * @param "Trigger" (optional.Interface of interface{}) -  trigger
  1280       * @param "User" (optional.String) -  user
  1281  
  1282  @return HttpEntity
  1283  */
  1284  
  1285  type ApplicationControllerApiInvokePipelineConfigUsingPOSTOpts struct { 
  1286  	Trigger optional.Interface
  1287  	User optional.String
  1288  }
  1289  
  1290  func (a *ApplicationControllerApiService) InvokePipelineConfigUsingPOST(ctx context.Context, application string, pipelineName string, localVarOptionals *ApplicationControllerApiInvokePipelineConfigUsingPOSTOpts) (HttpEntity, *http.Response, error) {
  1291  	var (
  1292  		localVarHttpMethod = strings.ToUpper("Post")
  1293  		localVarPostBody   interface{}
  1294  		localVarFileName   string
  1295  		localVarFileBytes  []byte
  1296  		localVarReturnValue HttpEntity
  1297  	)
  1298  
  1299  	// create path and map variables
  1300  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/pipelineConfigs/{pipelineName}"
  1301  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
  1302  	localVarPath = strings.Replace(localVarPath, "{"+"pipelineName"+"}", fmt.Sprintf("%v", pipelineName), -1)
  1303  
  1304  	localVarHeaderParams := make(map[string]string)
  1305  	localVarQueryParams := url.Values{}
  1306  	localVarFormParams := url.Values{}
  1307  
  1308  	if localVarOptionals != nil && localVarOptionals.User.IsSet() {
  1309  		localVarQueryParams.Add("user", parameterToString(localVarOptionals.User.Value(), ""))
  1310  	}
  1311  	// to determine the Content-Type header
  1312  	localVarHttpContentTypes := []string{"application/json"}
  1313  
  1314  	// set Content-Type header
  1315  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1316  	if localVarHttpContentType != "" {
  1317  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1318  	}
  1319  
  1320  	// to determine the Accept header
  1321  	localVarHttpHeaderAccepts := []string{"*/*"}
  1322  
  1323  	// set Accept header
  1324  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1325  	if localVarHttpHeaderAccept != "" {
  1326  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1327  	}
  1328  	// body params
  1329  	if localVarOptionals != nil && localVarOptionals.Trigger.IsSet() {
  1330  		
  1331  		localVarOptionalTrigger, localVarOptionalTriggerok := localVarOptionals.Trigger.Value().(interface{})
  1332  		if !localVarOptionalTriggerok {
  1333  				return localVarReturnValue, nil, reportError("trigger should be interface{}")
  1334  		}
  1335  		localVarPostBody = &localVarOptionalTrigger
  1336  	}
  1337  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1338  	if err != nil {
  1339  		return localVarReturnValue, nil, err
  1340  	}
  1341  
  1342  	localVarHttpResponse, err := a.client.callAPI(r)
  1343  	if err != nil || localVarHttpResponse == nil {
  1344  		return localVarReturnValue, localVarHttpResponse, err
  1345  	}
  1346  
  1347  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1348  	localVarHttpResponse.Body.Close()
  1349  	if err != nil {
  1350  		return localVarReturnValue, localVarHttpResponse, err
  1351  	}
  1352  
  1353  	if localVarHttpResponse.StatusCode < 300 {
  1354  		// If we succeed, return the data, otherwise pass on to decode error.
  1355  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1356  		if err == nil { 
  1357  			return localVarReturnValue, localVarHttpResponse, err
  1358  		}
  1359  	}
  1360  
  1361  	if localVarHttpResponse.StatusCode >= 300 {
  1362  		newErr := GenericSwaggerError{
  1363  			body: localVarBody,
  1364  			error: localVarHttpResponse.Status,
  1365  		}
  1366  		
  1367  		if localVarHttpResponse.StatusCode == 200 {
  1368  			var v HttpEntity
  1369  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1370  				if err != nil {
  1371  					newErr.error = err.Error()
  1372  					return localVarReturnValue, localVarHttpResponse, newErr
  1373  				}
  1374  				newErr.model = v
  1375  				return localVarReturnValue, localVarHttpResponse, newErr
  1376  		}
  1377  		
  1378  		return localVarReturnValue, localVarHttpResponse, newErr
  1379  	}
  1380  
  1381  	return localVarReturnValue, localVarHttpResponse, nil
  1382  }
  1383  
  1384  /* 
  1385  ApplicationControllerApiService Create task
  1386   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  1387   * @param application application
  1388   * @param map_ map
  1389  
  1390  @return map[string]interface{}
  1391  */
  1392  func (a *ApplicationControllerApiService) TaskUsingPOST(ctx context.Context, application string, map_ interface{}) (map[string]interface{}, *http.Response, error) {
  1393  	var (
  1394  		localVarHttpMethod = strings.ToUpper("Post")
  1395  		localVarPostBody   interface{}
  1396  		localVarFileName   string
  1397  		localVarFileBytes  []byte
  1398  		localVarReturnValue map[string]interface{}
  1399  	)
  1400  
  1401  	// create path and map variables
  1402  	localVarPath := a.client.cfg.BasePath + "/applications/{application}/tasks"
  1403  	localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", fmt.Sprintf("%v", application), -1)
  1404  
  1405  	localVarHeaderParams := make(map[string]string)
  1406  	localVarQueryParams := url.Values{}
  1407  	localVarFormParams := url.Values{}
  1408  
  1409  	// to determine the Content-Type header
  1410  	localVarHttpContentTypes := []string{"application/json"}
  1411  
  1412  	// set Content-Type header
  1413  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1414  	if localVarHttpContentType != "" {
  1415  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1416  	}
  1417  
  1418  	// to determine the Accept header
  1419  	localVarHttpHeaderAccepts := []string{"*/*"}
  1420  
  1421  	// set Accept header
  1422  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1423  	if localVarHttpHeaderAccept != "" {
  1424  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1425  	}
  1426  	// body params
  1427  	localVarPostBody = &map_
  1428  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1429  	if err != nil {
  1430  		return localVarReturnValue, nil, err
  1431  	}
  1432  
  1433  	localVarHttpResponse, err := a.client.callAPI(r)
  1434  	if err != nil || localVarHttpResponse == nil {
  1435  		return localVarReturnValue, localVarHttpResponse, err
  1436  	}
  1437  
  1438  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
  1439  	localVarHttpResponse.Body.Close()
  1440  	if err != nil {
  1441  		return localVarReturnValue, localVarHttpResponse, err
  1442  	}
  1443  
  1444  	if localVarHttpResponse.StatusCode < 300 {
  1445  		// If we succeed, return the data, otherwise pass on to decode error.
  1446  		err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1447  		if err == nil { 
  1448  			return localVarReturnValue, localVarHttpResponse, err
  1449  		}
  1450  	}
  1451  
  1452  	if localVarHttpResponse.StatusCode >= 300 {
  1453  		newErr := GenericSwaggerError{
  1454  			body: localVarBody,
  1455  			error: localVarHttpResponse.Status,
  1456  		}
  1457  		
  1458  		if localVarHttpResponse.StatusCode == 200 {
  1459  			var v map[string]interface{}
  1460  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
  1461  				if err != nil {
  1462  					newErr.error = err.Error()
  1463  					return localVarReturnValue, localVarHttpResponse, newErr
  1464  				}
  1465  				newErr.model = v
  1466  				return localVarReturnValue, localVarHttpResponse, newErr
  1467  		}
  1468  		
  1469  		return localVarReturnValue, localVarHttpResponse, newErr
  1470  	}
  1471  
  1472  	return localVarReturnValue, localVarHttpResponse, nil
  1473  }