github.com/grokify/go-ringcentral-client@v0.3.31/engagedigital/v1/client/api_interventions.go (about)

     1  /*
     2   * Engage Digital API
     3   *
     4   * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
     5   *
     6   * API version: 1.0
     7   * Generated by: OpenAPI Generator (https://openapi-generator.tech)
     8   */
     9  
    10  package engagedigital
    11  
    12  import (
    13  	"context"
    14  	"fmt"
    15  	"github.com/antihax/optional"
    16  	"io/ioutil"
    17  	"net/http"
    18  	"net/url"
    19  	"reflect"
    20  	"strings"
    21  )
    22  
    23  // Linger please
    24  var (
    25  	_ context.Context
    26  )
    27  
    28  type InterventionsApiService service
    29  
    30  /*
    31  InterventionsApiService Cancelling an intervention
    32  This method cancels (destroys) an intervention. It renders intervention itself. If token’s user does not have “read” on intervention’s source a 404 HTTP response will be returned.  Caveats:  * If the intervention is already being canceled, it will return a 409 error. * To be able to close an intervention, it must meet the following criteria otherwise a 403 will be raised:   * Intervention MUST NOT already be closed  * Intervention MUST NOT have agent replies   * Access-Token agent MUST have read access on the source  Authorization​: no, but it renders an error if intervention can’t be destroyed (see caveats).
    33   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
    34   * @param interventionId
    35  @return Intervention
    36  */
    37  func (a *InterventionsApiService) CancelIntervention(ctx context.Context, interventionId string) (Intervention, *http.Response, error) {
    38  	var (
    39  		localVarHttpMethod   = http.MethodDelete
    40  		localVarPostBody     interface{}
    41  		localVarFormFileName string
    42  		localVarFileName     string
    43  		localVarFileBytes    []byte
    44  		localVarReturnValue  Intervention
    45  	)
    46  
    47  	// create path and map variables
    48  	localVarPath := a.client.cfg.BasePath + "/interventions/{interventionId}/cancel"
    49  	localVarPath = strings.Replace(localVarPath, "{"+"interventionId"+"}", fmt.Sprintf("%v", interventionId), -1)
    50  
    51  	localVarHeaderParams := make(map[string]string)
    52  	localVarQueryParams := url.Values{}
    53  	localVarFormParams := url.Values{}
    54  
    55  	// to determine the Content-Type header
    56  	localVarHttpContentTypes := []string{}
    57  
    58  	// set Content-Type header
    59  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
    60  	if localVarHttpContentType != "" {
    61  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
    62  	}
    63  
    64  	// to determine the Accept header
    65  	localVarHttpHeaderAccepts := []string{"application/json"}
    66  
    67  	// set Accept header
    68  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
    69  	if localVarHttpHeaderAccept != "" {
    70  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
    71  	}
    72  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
    73  	if err != nil {
    74  		return localVarReturnValue, nil, err
    75  	}
    76  
    77  	localVarHttpResponse, err := a.client.callAPI(r)
    78  	if err != nil || localVarHttpResponse == nil {
    79  		return localVarReturnValue, localVarHttpResponse, err
    80  	}
    81  
    82  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
    83  	localVarHttpResponse.Body.Close()
    84  	if err != nil {
    85  		return localVarReturnValue, localVarHttpResponse, err
    86  	}
    87  
    88  	if localVarHttpResponse.StatusCode >= 300 {
    89  		newErr := GenericOpenAPIError{
    90  			body:  localVarBody,
    91  			error: localVarHttpResponse.Status,
    92  		}
    93  		if localVarHttpResponse.StatusCode == 200 {
    94  			var v Intervention
    95  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
    96  			if err != nil {
    97  				newErr.error = err.Error()
    98  				return localVarReturnValue, localVarHttpResponse, newErr
    99  			}
   100  			newErr.model = v
   101  			return localVarReturnValue, localVarHttpResponse, newErr
   102  		}
   103  		return localVarReturnValue, localVarHttpResponse, newErr
   104  	}
   105  
   106  	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   107  	if err != nil {
   108  		newErr := GenericOpenAPIError{
   109  			body:  localVarBody,
   110  			error: err.Error(),
   111  		}
   112  		return localVarReturnValue, localVarHttpResponse, newErr
   113  	}
   114  
   115  	return localVarReturnValue, localVarHttpResponse, nil
   116  }
   117  
   118  /*
   119  InterventionsApiService Categorizing an intervention
   120  This method updates the categories of an intervention. If token’s user does not have “read” on the intervention’s source a 404 HTTP response will be returned.  Authorization​: no.
   121   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   122   * @param interventionId
   123   * @param categoryIds
   124  @return Intervention
   125  */
   126  func (a *InterventionsApiService) CategorizeIntervention(ctx context.Context, interventionId string, categoryIds []string) (Intervention, *http.Response, error) {
   127  	var (
   128  		localVarHttpMethod   = http.MethodPut
   129  		localVarPostBody     interface{}
   130  		localVarFormFileName string
   131  		localVarFileName     string
   132  		localVarFileBytes    []byte
   133  		localVarReturnValue  Intervention
   134  	)
   135  
   136  	// create path and map variables
   137  	localVarPath := a.client.cfg.BasePath + "/interventions/{interventionId}/update_categories"
   138  	localVarPath = strings.Replace(localVarPath, "{"+"interventionId"+"}", fmt.Sprintf("%v", interventionId), -1)
   139  
   140  	localVarHeaderParams := make(map[string]string)
   141  	localVarQueryParams := url.Values{}
   142  	localVarFormParams := url.Values{}
   143  
   144  	t := categoryIds
   145  	if reflect.TypeOf(t).Kind() == reflect.Slice {
   146  		s := reflect.ValueOf(t)
   147  		for i := 0; i < s.Len(); i++ {
   148  			localVarQueryParams.Add("category_ids[]", parameterToString(s.Index(i), "multi"))
   149  		}
   150  	} else {
   151  		localVarQueryParams.Add("category_ids[]", parameterToString(t, "multi"))
   152  	}
   153  	// to determine the Content-Type header
   154  	localVarHttpContentTypes := []string{}
   155  
   156  	// set Content-Type header
   157  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   158  	if localVarHttpContentType != "" {
   159  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   160  	}
   161  
   162  	// to determine the Accept header
   163  	localVarHttpHeaderAccepts := []string{"application/json"}
   164  
   165  	// set Accept header
   166  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   167  	if localVarHttpHeaderAccept != "" {
   168  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   169  	}
   170  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
   171  	if err != nil {
   172  		return localVarReturnValue, nil, err
   173  	}
   174  
   175  	localVarHttpResponse, err := a.client.callAPI(r)
   176  	if err != nil || localVarHttpResponse == nil {
   177  		return localVarReturnValue, localVarHttpResponse, err
   178  	}
   179  
   180  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   181  	localVarHttpResponse.Body.Close()
   182  	if err != nil {
   183  		return localVarReturnValue, localVarHttpResponse, err
   184  	}
   185  
   186  	if localVarHttpResponse.StatusCode >= 300 {
   187  		newErr := GenericOpenAPIError{
   188  			body:  localVarBody,
   189  			error: localVarHttpResponse.Status,
   190  		}
   191  		if localVarHttpResponse.StatusCode == 200 {
   192  			var v Intervention
   193  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   194  			if err != nil {
   195  				newErr.error = err.Error()
   196  				return localVarReturnValue, localVarHttpResponse, newErr
   197  			}
   198  			newErr.model = v
   199  			return localVarReturnValue, localVarHttpResponse, newErr
   200  		}
   201  		return localVarReturnValue, localVarHttpResponse, newErr
   202  	}
   203  
   204  	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   205  	if err != nil {
   206  		newErr := GenericOpenAPIError{
   207  			body:  localVarBody,
   208  			error: err.Error(),
   209  		}
   210  		return localVarReturnValue, localVarHttpResponse, newErr
   211  	}
   212  
   213  	return localVarReturnValue, localVarHttpResponse, nil
   214  }
   215  
   216  /*
   217  InterventionsApiService Closing an intervention
   218  This method closes an intervention. Caveats:  * If the intervention is already being closed, it will return a 409 error. * To be able to close an intervention, it must meet the following criteria otherwise a 403 will be raised:    * Intervention MUST NOT already be closed    * Intervention MUST have agent replies   * Access-Token agent MUST be the owner of the intervention or have the permission to edit permissions    * Access-Token agent MUST have read access on the source  Authorization​: no, but it renders an error if intervention can’t be closed (see caveats)
   219   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   220   * @param interventionId
   221  @return Intervention
   222  */
   223  func (a *InterventionsApiService) CloseIntervention(ctx context.Context, interventionId string) (Intervention, *http.Response, error) {
   224  	var (
   225  		localVarHttpMethod   = http.MethodPut
   226  		localVarPostBody     interface{}
   227  		localVarFormFileName string
   228  		localVarFileName     string
   229  		localVarFileBytes    []byte
   230  		localVarReturnValue  Intervention
   231  	)
   232  
   233  	// create path and map variables
   234  	localVarPath := a.client.cfg.BasePath + "/interventions/{interventionId}/close"
   235  	localVarPath = strings.Replace(localVarPath, "{"+"interventionId"+"}", fmt.Sprintf("%v", interventionId), -1)
   236  
   237  	localVarHeaderParams := make(map[string]string)
   238  	localVarQueryParams := url.Values{}
   239  	localVarFormParams := url.Values{}
   240  
   241  	// to determine the Content-Type header
   242  	localVarHttpContentTypes := []string{}
   243  
   244  	// set Content-Type header
   245  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   246  	if localVarHttpContentType != "" {
   247  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   248  	}
   249  
   250  	// to determine the Accept header
   251  	localVarHttpHeaderAccepts := []string{"application/json"}
   252  
   253  	// set Accept header
   254  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   255  	if localVarHttpHeaderAccept != "" {
   256  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   257  	}
   258  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
   259  	if err != nil {
   260  		return localVarReturnValue, nil, err
   261  	}
   262  
   263  	localVarHttpResponse, err := a.client.callAPI(r)
   264  	if err != nil || localVarHttpResponse == nil {
   265  		return localVarReturnValue, localVarHttpResponse, err
   266  	}
   267  
   268  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   269  	localVarHttpResponse.Body.Close()
   270  	if err != nil {
   271  		return localVarReturnValue, localVarHttpResponse, err
   272  	}
   273  
   274  	if localVarHttpResponse.StatusCode >= 300 {
   275  		newErr := GenericOpenAPIError{
   276  			body:  localVarBody,
   277  			error: localVarHttpResponse.Status,
   278  		}
   279  		if localVarHttpResponse.StatusCode == 200 {
   280  			var v Intervention
   281  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   282  			if err != nil {
   283  				newErr.error = err.Error()
   284  				return localVarReturnValue, localVarHttpResponse, newErr
   285  			}
   286  			newErr.model = v
   287  			return localVarReturnValue, localVarHttpResponse, newErr
   288  		}
   289  		return localVarReturnValue, localVarHttpResponse, newErr
   290  	}
   291  
   292  	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   293  	if err != nil {
   294  		newErr := GenericOpenAPIError{
   295  			body:  localVarBody,
   296  			error: err.Error(),
   297  		}
   298  		return localVarReturnValue, localVarHttpResponse, newErr
   299  	}
   300  
   301  	return localVarReturnValue, localVarHttpResponse, nil
   302  }
   303  
   304  /*
   305  InterventionsApiService Creating an intervention
   306  This method creates a new intervention or reopen it. In case of success it renders the intervention, otherwise, it renders an error (422 HTTP code). This method opens intervention as access token’s user.  Authorization​: no, but it renders an error if intervention can’t be created or reopened (already opened, etc.).
   307   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   308   * @param contentId The content to create intervention on (mandatory).
   309  @return GetAllInterventionsResponse
   310  */
   311  func (a *InterventionsApiService) CreateIntervention(ctx context.Context, contentId string) (GetAllInterventionsResponse, *http.Response, error) {
   312  	var (
   313  		localVarHttpMethod   = http.MethodPost
   314  		localVarPostBody     interface{}
   315  		localVarFormFileName string
   316  		localVarFileName     string
   317  		localVarFileBytes    []byte
   318  		localVarReturnValue  GetAllInterventionsResponse
   319  	)
   320  
   321  	// create path and map variables
   322  	localVarPath := a.client.cfg.BasePath + "/interventions"
   323  
   324  	localVarHeaderParams := make(map[string]string)
   325  	localVarQueryParams := url.Values{}
   326  	localVarFormParams := url.Values{}
   327  
   328  	localVarQueryParams.Add("content_id", parameterToString(contentId, ""))
   329  	// to determine the Content-Type header
   330  	localVarHttpContentTypes := []string{}
   331  
   332  	// set Content-Type header
   333  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   334  	if localVarHttpContentType != "" {
   335  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   336  	}
   337  
   338  	// to determine the Accept header
   339  	localVarHttpHeaderAccepts := []string{"application/json"}
   340  
   341  	// set Accept header
   342  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   343  	if localVarHttpHeaderAccept != "" {
   344  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   345  	}
   346  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
   347  	if err != nil {
   348  		return localVarReturnValue, nil, err
   349  	}
   350  
   351  	localVarHttpResponse, err := a.client.callAPI(r)
   352  	if err != nil || localVarHttpResponse == nil {
   353  		return localVarReturnValue, localVarHttpResponse, err
   354  	}
   355  
   356  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   357  	localVarHttpResponse.Body.Close()
   358  	if err != nil {
   359  		return localVarReturnValue, localVarHttpResponse, err
   360  	}
   361  
   362  	if localVarHttpResponse.StatusCode >= 300 {
   363  		newErr := GenericOpenAPIError{
   364  			body:  localVarBody,
   365  			error: localVarHttpResponse.Status,
   366  		}
   367  		if localVarHttpResponse.StatusCode == 200 {
   368  			var v GetAllInterventionsResponse
   369  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   370  			if err != nil {
   371  				newErr.error = err.Error()
   372  				return localVarReturnValue, localVarHttpResponse, newErr
   373  			}
   374  			newErr.model = v
   375  			return localVarReturnValue, localVarHttpResponse, newErr
   376  		}
   377  		return localVarReturnValue, localVarHttpResponse, newErr
   378  	}
   379  
   380  	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   381  	if err != nil {
   382  		newErr := GenericOpenAPIError{
   383  			body:  localVarBody,
   384  			error: err.Error(),
   385  		}
   386  		return localVarReturnValue, localVarHttpResponse, newErr
   387  	}
   388  
   389  	return localVarReturnValue, localVarHttpResponse, nil
   390  }
   391  
   392  /*
   393  InterventionsApiService Getting all interventions
   394  This method renders interventions ordered by creation date (descending). Only interventions in sources where token’s user has “read” permission are returned.  Authorization​: no.
   395   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   396   * @param optional nil or *GetAllInterventionsOpts - Optional Parameters:
   397   * @param "ThreadId" (optional.String) -  To filter interventions on given thread id.
   398   * @param "UserId" (optional.String) -  To filter interventions on given user id.
   399   * @param "IdentityGroupId" (optional.String) -  To filter interventions on given identity_group_id. This will return interventions associated to any identity in the indentity_group.
   400   * @param "IdentityId" (optional.Interface of []string) -  To filter interventions on given identity_id(s). Can be a single value or an array.
   401   * @param "Sort" (optional.String) -  To change the criteria chosen to sort the interventions. The value can be “created_at” or “updated_at”.
   402   * @param "Offset" (optional.Int32) -  The record index to start. Default value is 0.
   403   * @param "Limit" (optional.Int32) -  The max number of records to return. Default value is 30, max value is 150.
   404  @return GetAllInterventionsResponse
   405  */
   406  
   407  type GetAllInterventionsOpts struct {
   408  	ThreadId        optional.String
   409  	UserId          optional.String
   410  	IdentityGroupId optional.String
   411  	IdentityId      optional.Interface
   412  	Sort            optional.String
   413  	Offset          optional.Int32
   414  	Limit           optional.Int32
   415  }
   416  
   417  func (a *InterventionsApiService) GetAllInterventions(ctx context.Context, localVarOptionals *GetAllInterventionsOpts) (GetAllInterventionsResponse, *http.Response, error) {
   418  	var (
   419  		localVarHttpMethod   = http.MethodGet
   420  		localVarPostBody     interface{}
   421  		localVarFormFileName string
   422  		localVarFileName     string
   423  		localVarFileBytes    []byte
   424  		localVarReturnValue  GetAllInterventionsResponse
   425  	)
   426  
   427  	// create path and map variables
   428  	localVarPath := a.client.cfg.BasePath + "/interventions"
   429  
   430  	localVarHeaderParams := make(map[string]string)
   431  	localVarQueryParams := url.Values{}
   432  	localVarFormParams := url.Values{}
   433  
   434  	if localVarOptionals != nil && localVarOptionals.ThreadId.IsSet() {
   435  		localVarQueryParams.Add("thread_id", parameterToString(localVarOptionals.ThreadId.Value(), ""))
   436  	}
   437  	if localVarOptionals != nil && localVarOptionals.UserId.IsSet() {
   438  		localVarQueryParams.Add("user_id", parameterToString(localVarOptionals.UserId.Value(), ""))
   439  	}
   440  	if localVarOptionals != nil && localVarOptionals.IdentityGroupId.IsSet() {
   441  		localVarQueryParams.Add("identity_group_id", parameterToString(localVarOptionals.IdentityGroupId.Value(), ""))
   442  	}
   443  	if localVarOptionals != nil && localVarOptionals.IdentityId.IsSet() {
   444  		t := localVarOptionals.IdentityId.Value()
   445  		if reflect.TypeOf(t).Kind() == reflect.Slice {
   446  			s := reflect.ValueOf(t)
   447  			for i := 0; i < s.Len(); i++ {
   448  				localVarQueryParams.Add("identity_id", parameterToString(s.Index(i), "multi"))
   449  			}
   450  		} else {
   451  			localVarQueryParams.Add("identity_id", parameterToString(t, "multi"))
   452  		}
   453  	}
   454  	if localVarOptionals != nil && localVarOptionals.Sort.IsSet() {
   455  		localVarQueryParams.Add("sort", parameterToString(localVarOptionals.Sort.Value(), ""))
   456  	}
   457  	if localVarOptionals != nil && localVarOptionals.Offset.IsSet() {
   458  		localVarQueryParams.Add("offset", parameterToString(localVarOptionals.Offset.Value(), ""))
   459  	}
   460  	if localVarOptionals != nil && localVarOptionals.Limit.IsSet() {
   461  		localVarQueryParams.Add("limit", parameterToString(localVarOptionals.Limit.Value(), ""))
   462  	}
   463  	// to determine the Content-Type header
   464  	localVarHttpContentTypes := []string{}
   465  
   466  	// set Content-Type header
   467  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   468  	if localVarHttpContentType != "" {
   469  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   470  	}
   471  
   472  	// to determine the Accept header
   473  	localVarHttpHeaderAccepts := []string{"application/json"}
   474  
   475  	// set Accept header
   476  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   477  	if localVarHttpHeaderAccept != "" {
   478  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   479  	}
   480  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
   481  	if err != nil {
   482  		return localVarReturnValue, nil, err
   483  	}
   484  
   485  	localVarHttpResponse, err := a.client.callAPI(r)
   486  	if err != nil || localVarHttpResponse == nil {
   487  		return localVarReturnValue, localVarHttpResponse, err
   488  	}
   489  
   490  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   491  	localVarHttpResponse.Body.Close()
   492  	if err != nil {
   493  		return localVarReturnValue, localVarHttpResponse, err
   494  	}
   495  
   496  	if localVarHttpResponse.StatusCode >= 300 {
   497  		newErr := GenericOpenAPIError{
   498  			body:  localVarBody,
   499  			error: localVarHttpResponse.Status,
   500  		}
   501  		if localVarHttpResponse.StatusCode == 200 {
   502  			var v GetAllInterventionsResponse
   503  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   504  			if err != nil {
   505  				newErr.error = err.Error()
   506  				return localVarReturnValue, localVarHttpResponse, newErr
   507  			}
   508  			newErr.model = v
   509  			return localVarReturnValue, localVarHttpResponse, newErr
   510  		}
   511  		return localVarReturnValue, localVarHttpResponse, newErr
   512  	}
   513  
   514  	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   515  	if err != nil {
   516  		newErr := GenericOpenAPIError{
   517  			body:  localVarBody,
   518  			error: err.Error(),
   519  		}
   520  		return localVarReturnValue, localVarHttpResponse, newErr
   521  	}
   522  
   523  	return localVarReturnValue, localVarHttpResponse, nil
   524  }
   525  
   526  /*
   527  InterventionsApiService Getting an intervention from its id
   528  This method renders an intervention from given id. If token’s user does not have “read” on intervention’s source a 404 HTTP response will be returned.  Authorization​: no.
   529   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   530   * @param interventionId
   531  @return Intervention
   532  */
   533  func (a *InterventionsApiService) GetIntervention(ctx context.Context, interventionId string) (Intervention, *http.Response, error) {
   534  	var (
   535  		localVarHttpMethod   = http.MethodGet
   536  		localVarPostBody     interface{}
   537  		localVarFormFileName string
   538  		localVarFileName     string
   539  		localVarFileBytes    []byte
   540  		localVarReturnValue  Intervention
   541  	)
   542  
   543  	// create path and map variables
   544  	localVarPath := a.client.cfg.BasePath + "/interventions/{interventionId}"
   545  	localVarPath = strings.Replace(localVarPath, "{"+"interventionId"+"}", fmt.Sprintf("%v", interventionId), -1)
   546  
   547  	localVarHeaderParams := make(map[string]string)
   548  	localVarQueryParams := url.Values{}
   549  	localVarFormParams := url.Values{}
   550  
   551  	// to determine the Content-Type header
   552  	localVarHttpContentTypes := []string{}
   553  
   554  	// set Content-Type header
   555  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   556  	if localVarHttpContentType != "" {
   557  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   558  	}
   559  
   560  	// to determine the Accept header
   561  	localVarHttpHeaderAccepts := []string{"application/json"}
   562  
   563  	// set Accept header
   564  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   565  	if localVarHttpHeaderAccept != "" {
   566  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   567  	}
   568  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
   569  	if err != nil {
   570  		return localVarReturnValue, nil, err
   571  	}
   572  
   573  	localVarHttpResponse, err := a.client.callAPI(r)
   574  	if err != nil || localVarHttpResponse == nil {
   575  		return localVarReturnValue, localVarHttpResponse, err
   576  	}
   577  
   578  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   579  	localVarHttpResponse.Body.Close()
   580  	if err != nil {
   581  		return localVarReturnValue, localVarHttpResponse, err
   582  	}
   583  
   584  	if localVarHttpResponse.StatusCode >= 300 {
   585  		newErr := GenericOpenAPIError{
   586  			body:  localVarBody,
   587  			error: localVarHttpResponse.Status,
   588  		}
   589  		if localVarHttpResponse.StatusCode == 200 {
   590  			var v Intervention
   591  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   592  			if err != nil {
   593  				newErr.error = err.Error()
   594  				return localVarReturnValue, localVarHttpResponse, newErr
   595  			}
   596  			newErr.model = v
   597  			return localVarReturnValue, localVarHttpResponse, newErr
   598  		}
   599  		return localVarReturnValue, localVarHttpResponse, newErr
   600  	}
   601  
   602  	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   603  	if err != nil {
   604  		newErr := GenericOpenAPIError{
   605  			body:  localVarBody,
   606  			error: err.Error(),
   607  		}
   608  		return localVarReturnValue, localVarHttpResponse, newErr
   609  	}
   610  
   611  	return localVarReturnValue, localVarHttpResponse, nil
   612  }
   613  
   614  /*
   615  InterventionsApiService Reassigning an intervention
   616  This method updates the user in charge of the intervention  Authorization​: Only users who can update interventions.
   617   * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
   618   * @param interventionId
   619   * @param userId
   620  @return Intervention
   621  */
   622  func (a *InterventionsApiService) ReassignIntervention(ctx context.Context, interventionId string, userId string) (Intervention, *http.Response, error) {
   623  	var (
   624  		localVarHttpMethod   = http.MethodPut
   625  		localVarPostBody     interface{}
   626  		localVarFormFileName string
   627  		localVarFileName     string
   628  		localVarFileBytes    []byte
   629  		localVarReturnValue  Intervention
   630  	)
   631  
   632  	// create path and map variables
   633  	localVarPath := a.client.cfg.BasePath + "/interventions/{interventionId}/reassign"
   634  	localVarPath = strings.Replace(localVarPath, "{"+"interventionId"+"}", fmt.Sprintf("%v", interventionId), -1)
   635  
   636  	localVarHeaderParams := make(map[string]string)
   637  	localVarQueryParams := url.Values{}
   638  	localVarFormParams := url.Values{}
   639  
   640  	localVarQueryParams.Add("user_id", parameterToString(userId, ""))
   641  	// to determine the Content-Type header
   642  	localVarHttpContentTypes := []string{}
   643  
   644  	// set Content-Type header
   645  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   646  	if localVarHttpContentType != "" {
   647  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   648  	}
   649  
   650  	// to determine the Accept header
   651  	localVarHttpHeaderAccepts := []string{"application/json"}
   652  
   653  	// set Accept header
   654  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   655  	if localVarHttpHeaderAccept != "" {
   656  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   657  	}
   658  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
   659  	if err != nil {
   660  		return localVarReturnValue, nil, err
   661  	}
   662  
   663  	localVarHttpResponse, err := a.client.callAPI(r)
   664  	if err != nil || localVarHttpResponse == nil {
   665  		return localVarReturnValue, localVarHttpResponse, err
   666  	}
   667  
   668  	localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
   669  	localVarHttpResponse.Body.Close()
   670  	if err != nil {
   671  		return localVarReturnValue, localVarHttpResponse, err
   672  	}
   673  
   674  	if localVarHttpResponse.StatusCode >= 300 {
   675  		newErr := GenericOpenAPIError{
   676  			body:  localVarBody,
   677  			error: localVarHttpResponse.Status,
   678  		}
   679  		if localVarHttpResponse.StatusCode == 200 {
   680  			var v Intervention
   681  			err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   682  			if err != nil {
   683  				newErr.error = err.Error()
   684  				return localVarReturnValue, localVarHttpResponse, newErr
   685  			}
   686  			newErr.model = v
   687  			return localVarReturnValue, localVarHttpResponse, newErr
   688  		}
   689  		return localVarReturnValue, localVarHttpResponse, newErr
   690  	}
   691  
   692  	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
   693  	if err != nil {
   694  		newErr := GenericOpenAPIError{
   695  			body:  localVarBody,
   696  			error: err.Error(),
   697  		}
   698  		return localVarReturnValue, localVarHttpResponse, newErr
   699  	}
   700  
   701  	return localVarReturnValue, localVarHttpResponse, nil
   702  }