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