1package qnamaker 2 3// Copyright (c) Microsoft Corporation. All rights reserved. 4// Licensed under the MIT License. See License.txt in the project root for license information. 5// 6// Code generated by Microsoft (R) AutoRest Code Generator. 7// Changes may cause incorrect behavior and will be lost if the code is regenerated. 8 9import ( 10 "context" 11 "github.com/Azure/go-autorest/autorest" 12 "github.com/Azure/go-autorest/autorest/azure" 13 "github.com/Azure/go-autorest/autorest/validation" 14 "github.com/Azure/go-autorest/tracing" 15 "net/http" 16) 17 18// KnowledgebaseClient is the an API for QnAMaker Service 19type KnowledgebaseClient struct { 20 BaseClient 21} 22 23// NewKnowledgebaseClient creates an instance of the KnowledgebaseClient client. 24func NewKnowledgebaseClient(endpoint string) KnowledgebaseClient { 25 return KnowledgebaseClient{New(endpoint)} 26} 27 28// Create sends the create request. 29// Parameters: 30// createKbPayload - post body of the request. 31func (client KnowledgebaseClient) Create(ctx context.Context, createKbPayload CreateKbDTO) (result Operation, err error) { 32 if tracing.IsEnabled() { 33 ctx = tracing.StartSpan(ctx, fqdn+"/KnowledgebaseClient.Create") 34 defer func() { 35 sc := -1 36 if result.Response.Response != nil { 37 sc = result.Response.Response.StatusCode 38 } 39 tracing.EndSpan(ctx, sc, err) 40 }() 41 } 42 if err := validation.Validate([]validation.Validation{ 43 {TargetValue: createKbPayload, 44 Constraints: []validation.Constraint{{Target: "createKbPayload.Name", Name: validation.Null, Rule: true, 45 Chain: []validation.Constraint{{Target: "createKbPayload.Name", Name: validation.MaxLength, Rule: 100, Chain: nil}, 46 {Target: "createKbPayload.Name", Name: validation.MinLength, Rule: 1, Chain: nil}, 47 }}, 48 {Target: "createKbPayload.DefaultAnswerUsedForExtraction", Name: validation.Null, Rule: false, 49 Chain: []validation.Constraint{{Target: "createKbPayload.DefaultAnswerUsedForExtraction", Name: validation.MaxLength, Rule: 300, Chain: nil}, 50 {Target: "createKbPayload.DefaultAnswerUsedForExtraction", Name: validation.MinLength, Rule: 1, Chain: nil}, 51 }}, 52 {Target: "createKbPayload.Language", Name: validation.Null, Rule: false, 53 Chain: []validation.Constraint{{Target: "createKbPayload.Language", Name: validation.MaxLength, Rule: 100, Chain: nil}, 54 {Target: "createKbPayload.Language", Name: validation.MinLength, Rule: 1, Chain: nil}, 55 }}}}}); err != nil { 56 return result, validation.NewError("qnamaker.KnowledgebaseClient", "Create", err.Error()) 57 } 58 59 req, err := client.CreatePreparer(ctx, createKbPayload) 60 if err != nil { 61 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Create", nil, "Failure preparing request") 62 return 63 } 64 65 resp, err := client.CreateSender(req) 66 if err != nil { 67 result.Response = autorest.Response{Response: resp} 68 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Create", resp, "Failure sending request") 69 return 70 } 71 72 result, err = client.CreateResponder(resp) 73 if err != nil { 74 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Create", resp, "Failure responding to request") 75 return 76 } 77 78 return 79} 80 81// CreatePreparer prepares the Create request. 82func (client KnowledgebaseClient) CreatePreparer(ctx context.Context, createKbPayload CreateKbDTO) (*http.Request, error) { 83 urlParameters := map[string]interface{}{ 84 "Endpoint": client.Endpoint, 85 } 86 87 preparer := autorest.CreatePreparer( 88 autorest.AsContentType("application/json; charset=utf-8"), 89 autorest.AsPost(), 90 autorest.WithCustomBaseURL("{Endpoint}/qnamaker/v4.0", urlParameters), 91 autorest.WithPath("/knowledgebases/create"), 92 autorest.WithJSON(createKbPayload)) 93 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 94} 95 96// CreateSender sends the Create request. The method will close the 97// http.Response Body if it receives an error. 98func (client KnowledgebaseClient) CreateSender(req *http.Request) (*http.Response, error) { 99 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 100} 101 102// CreateResponder handles the response to the Create request. The method always 103// closes the http.Response Body. 104func (client KnowledgebaseClient) CreateResponder(resp *http.Response) (result Operation, err error) { 105 err = autorest.Respond( 106 resp, 107 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 108 autorest.ByUnmarshallingJSON(&result), 109 autorest.ByClosing()) 110 result.Response = autorest.Response{Response: resp} 111 return 112} 113 114// Delete sends the delete request. 115// Parameters: 116// kbID - knowledgebase id. 117func (client KnowledgebaseClient) Delete(ctx context.Context, kbID string) (result autorest.Response, err error) { 118 if tracing.IsEnabled() { 119 ctx = tracing.StartSpan(ctx, fqdn+"/KnowledgebaseClient.Delete") 120 defer func() { 121 sc := -1 122 if result.Response != nil { 123 sc = result.Response.StatusCode 124 } 125 tracing.EndSpan(ctx, sc, err) 126 }() 127 } 128 req, err := client.DeletePreparer(ctx, kbID) 129 if err != nil { 130 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Delete", nil, "Failure preparing request") 131 return 132 } 133 134 resp, err := client.DeleteSender(req) 135 if err != nil { 136 result.Response = resp 137 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Delete", resp, "Failure sending request") 138 return 139 } 140 141 result, err = client.DeleteResponder(resp) 142 if err != nil { 143 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Delete", resp, "Failure responding to request") 144 return 145 } 146 147 return 148} 149 150// DeletePreparer prepares the Delete request. 151func (client KnowledgebaseClient) DeletePreparer(ctx context.Context, kbID string) (*http.Request, error) { 152 urlParameters := map[string]interface{}{ 153 "Endpoint": client.Endpoint, 154 } 155 156 pathParameters := map[string]interface{}{ 157 "kbId": autorest.Encode("path", kbID), 158 } 159 160 preparer := autorest.CreatePreparer( 161 autorest.AsDelete(), 162 autorest.WithCustomBaseURL("{Endpoint}/qnamaker/v4.0", urlParameters), 163 autorest.WithPathParameters("/knowledgebases/{kbId}", pathParameters)) 164 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 165} 166 167// DeleteSender sends the Delete request. The method will close the 168// http.Response Body if it receives an error. 169func (client KnowledgebaseClient) DeleteSender(req *http.Request) (*http.Response, error) { 170 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 171} 172 173// DeleteResponder handles the response to the Delete request. The method always 174// closes the http.Response Body. 175func (client KnowledgebaseClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 176 err = autorest.Respond( 177 resp, 178 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 179 autorest.ByClosing()) 180 result.Response = resp 181 return 182} 183 184// Download sends the download request. 185// Parameters: 186// kbID - knowledgebase id. 187// environment - specifies whether environment is Test or Prod. 188// source - the source property filter to apply. Sample value: Editorial, smartLight%20FAQ.tsv . 189// changedSince - changedSince property is used to return all QnAs created or updated after a specific time 190// duration. The user can filter QnAs by seconds (s), minutes (m), hours (h) and days (d). The user may use any 191// integral value along with the suffix for time. For instance, the value of 5m returns all QnA pairs updated 192// or created in the last 5 minutes. 193func (client KnowledgebaseClient) Download(ctx context.Context, kbID string, environment EnvironmentType, source string, changedSince string) (result QnADocumentsDTO, err error) { 194 if tracing.IsEnabled() { 195 ctx = tracing.StartSpan(ctx, fqdn+"/KnowledgebaseClient.Download") 196 defer func() { 197 sc := -1 198 if result.Response.Response != nil { 199 sc = result.Response.Response.StatusCode 200 } 201 tracing.EndSpan(ctx, sc, err) 202 }() 203 } 204 req, err := client.DownloadPreparer(ctx, kbID, environment, source, changedSince) 205 if err != nil { 206 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Download", nil, "Failure preparing request") 207 return 208 } 209 210 resp, err := client.DownloadSender(req) 211 if err != nil { 212 result.Response = autorest.Response{Response: resp} 213 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Download", resp, "Failure sending request") 214 return 215 } 216 217 result, err = client.DownloadResponder(resp) 218 if err != nil { 219 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Download", resp, "Failure responding to request") 220 return 221 } 222 223 return 224} 225 226// DownloadPreparer prepares the Download request. 227func (client KnowledgebaseClient) DownloadPreparer(ctx context.Context, kbID string, environment EnvironmentType, source string, changedSince string) (*http.Request, error) { 228 urlParameters := map[string]interface{}{ 229 "Endpoint": client.Endpoint, 230 } 231 232 pathParameters := map[string]interface{}{ 233 "environment": autorest.Encode("path", environment), 234 "kbId": autorest.Encode("path", kbID), 235 } 236 237 queryParameters := map[string]interface{}{} 238 if len(source) > 0 { 239 queryParameters["source"] = autorest.Encode("query", source) 240 } 241 if len(changedSince) > 0 { 242 queryParameters["changedSince"] = autorest.Encode("query", changedSince) 243 } 244 245 preparer := autorest.CreatePreparer( 246 autorest.AsGet(), 247 autorest.WithCustomBaseURL("{Endpoint}/qnamaker/v4.0", urlParameters), 248 autorest.WithPathParameters("/knowledgebases/{kbId}/{environment}/qna", pathParameters), 249 autorest.WithQueryParameters(queryParameters)) 250 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 251} 252 253// DownloadSender sends the Download request. The method will close the 254// http.Response Body if it receives an error. 255func (client KnowledgebaseClient) DownloadSender(req *http.Request) (*http.Response, error) { 256 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 257} 258 259// DownloadResponder handles the response to the Download request. The method always 260// closes the http.Response Body. 261func (client KnowledgebaseClient) DownloadResponder(resp *http.Response) (result QnADocumentsDTO, err error) { 262 err = autorest.Respond( 263 resp, 264 azure.WithErrorUnlessStatusCode(http.StatusOK), 265 autorest.ByUnmarshallingJSON(&result), 266 autorest.ByClosing()) 267 result.Response = autorest.Response{Response: resp} 268 return 269} 270 271// GetDetails sends the get details request. 272// Parameters: 273// kbID - knowledgebase id. 274func (client KnowledgebaseClient) GetDetails(ctx context.Context, kbID string) (result KnowledgebaseDTO, err error) { 275 if tracing.IsEnabled() { 276 ctx = tracing.StartSpan(ctx, fqdn+"/KnowledgebaseClient.GetDetails") 277 defer func() { 278 sc := -1 279 if result.Response.Response != nil { 280 sc = result.Response.Response.StatusCode 281 } 282 tracing.EndSpan(ctx, sc, err) 283 }() 284 } 285 req, err := client.GetDetailsPreparer(ctx, kbID) 286 if err != nil { 287 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "GetDetails", nil, "Failure preparing request") 288 return 289 } 290 291 resp, err := client.GetDetailsSender(req) 292 if err != nil { 293 result.Response = autorest.Response{Response: resp} 294 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "GetDetails", resp, "Failure sending request") 295 return 296 } 297 298 result, err = client.GetDetailsResponder(resp) 299 if err != nil { 300 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "GetDetails", resp, "Failure responding to request") 301 return 302 } 303 304 return 305} 306 307// GetDetailsPreparer prepares the GetDetails request. 308func (client KnowledgebaseClient) GetDetailsPreparer(ctx context.Context, kbID string) (*http.Request, error) { 309 urlParameters := map[string]interface{}{ 310 "Endpoint": client.Endpoint, 311 } 312 313 pathParameters := map[string]interface{}{ 314 "kbId": autorest.Encode("path", kbID), 315 } 316 317 preparer := autorest.CreatePreparer( 318 autorest.AsGet(), 319 autorest.WithCustomBaseURL("{Endpoint}/qnamaker/v4.0", urlParameters), 320 autorest.WithPathParameters("/knowledgebases/{kbId}", pathParameters)) 321 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 322} 323 324// GetDetailsSender sends the GetDetails request. The method will close the 325// http.Response Body if it receives an error. 326func (client KnowledgebaseClient) GetDetailsSender(req *http.Request) (*http.Response, error) { 327 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 328} 329 330// GetDetailsResponder handles the response to the GetDetails request. The method always 331// closes the http.Response Body. 332func (client KnowledgebaseClient) GetDetailsResponder(resp *http.Response) (result KnowledgebaseDTO, err error) { 333 err = autorest.Respond( 334 resp, 335 azure.WithErrorUnlessStatusCode(http.StatusOK), 336 autorest.ByUnmarshallingJSON(&result), 337 autorest.ByClosing()) 338 result.Response = autorest.Response{Response: resp} 339 return 340} 341 342// ListAll sends the list all request. 343func (client KnowledgebaseClient) ListAll(ctx context.Context) (result KnowledgebasesDTO, err error) { 344 if tracing.IsEnabled() { 345 ctx = tracing.StartSpan(ctx, fqdn+"/KnowledgebaseClient.ListAll") 346 defer func() { 347 sc := -1 348 if result.Response.Response != nil { 349 sc = result.Response.Response.StatusCode 350 } 351 tracing.EndSpan(ctx, sc, err) 352 }() 353 } 354 req, err := client.ListAllPreparer(ctx) 355 if err != nil { 356 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "ListAll", nil, "Failure preparing request") 357 return 358 } 359 360 resp, err := client.ListAllSender(req) 361 if err != nil { 362 result.Response = autorest.Response{Response: resp} 363 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "ListAll", resp, "Failure sending request") 364 return 365 } 366 367 result, err = client.ListAllResponder(resp) 368 if err != nil { 369 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "ListAll", resp, "Failure responding to request") 370 return 371 } 372 373 return 374} 375 376// ListAllPreparer prepares the ListAll request. 377func (client KnowledgebaseClient) ListAllPreparer(ctx context.Context) (*http.Request, error) { 378 urlParameters := map[string]interface{}{ 379 "Endpoint": client.Endpoint, 380 } 381 382 preparer := autorest.CreatePreparer( 383 autorest.AsGet(), 384 autorest.WithCustomBaseURL("{Endpoint}/qnamaker/v4.0", urlParameters), 385 autorest.WithPath("/knowledgebases")) 386 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 387} 388 389// ListAllSender sends the ListAll request. The method will close the 390// http.Response Body if it receives an error. 391func (client KnowledgebaseClient) ListAllSender(req *http.Request) (*http.Response, error) { 392 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 393} 394 395// ListAllResponder handles the response to the ListAll request. The method always 396// closes the http.Response Body. 397func (client KnowledgebaseClient) ListAllResponder(resp *http.Response) (result KnowledgebasesDTO, err error) { 398 err = autorest.Respond( 399 resp, 400 azure.WithErrorUnlessStatusCode(http.StatusOK), 401 autorest.ByUnmarshallingJSON(&result), 402 autorest.ByClosing()) 403 result.Response = autorest.Response{Response: resp} 404 return 405} 406 407// Publish sends the publish request. 408// Parameters: 409// kbID - knowledgebase id. 410func (client KnowledgebaseClient) Publish(ctx context.Context, kbID string) (result autorest.Response, err error) { 411 if tracing.IsEnabled() { 412 ctx = tracing.StartSpan(ctx, fqdn+"/KnowledgebaseClient.Publish") 413 defer func() { 414 sc := -1 415 if result.Response != nil { 416 sc = result.Response.StatusCode 417 } 418 tracing.EndSpan(ctx, sc, err) 419 }() 420 } 421 req, err := client.PublishPreparer(ctx, kbID) 422 if err != nil { 423 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Publish", nil, "Failure preparing request") 424 return 425 } 426 427 resp, err := client.PublishSender(req) 428 if err != nil { 429 result.Response = resp 430 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Publish", resp, "Failure sending request") 431 return 432 } 433 434 result, err = client.PublishResponder(resp) 435 if err != nil { 436 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Publish", resp, "Failure responding to request") 437 return 438 } 439 440 return 441} 442 443// PublishPreparer prepares the Publish request. 444func (client KnowledgebaseClient) PublishPreparer(ctx context.Context, kbID string) (*http.Request, error) { 445 urlParameters := map[string]interface{}{ 446 "Endpoint": client.Endpoint, 447 } 448 449 pathParameters := map[string]interface{}{ 450 "kbId": autorest.Encode("path", kbID), 451 } 452 453 preparer := autorest.CreatePreparer( 454 autorest.AsPost(), 455 autorest.WithCustomBaseURL("{Endpoint}/qnamaker/v4.0", urlParameters), 456 autorest.WithPathParameters("/knowledgebases/{kbId}", pathParameters)) 457 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 458} 459 460// PublishSender sends the Publish request. The method will close the 461// http.Response Body if it receives an error. 462func (client KnowledgebaseClient) PublishSender(req *http.Request) (*http.Response, error) { 463 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 464} 465 466// PublishResponder handles the response to the Publish request. The method always 467// closes the http.Response Body. 468func (client KnowledgebaseClient) PublishResponder(resp *http.Response) (result autorest.Response, err error) { 469 err = autorest.Respond( 470 resp, 471 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 472 autorest.ByClosing()) 473 result.Response = resp 474 return 475} 476 477// Replace sends the replace request. 478// Parameters: 479// kbID - knowledgebase id. 480// replaceKb - an instance of ReplaceKbDTO which contains list of qnas to be uploaded 481func (client KnowledgebaseClient) Replace(ctx context.Context, kbID string, replaceKb ReplaceKbDTO) (result autorest.Response, err error) { 482 if tracing.IsEnabled() { 483 ctx = tracing.StartSpan(ctx, fqdn+"/KnowledgebaseClient.Replace") 484 defer func() { 485 sc := -1 486 if result.Response != nil { 487 sc = result.Response.StatusCode 488 } 489 tracing.EndSpan(ctx, sc, err) 490 }() 491 } 492 if err := validation.Validate([]validation.Validation{ 493 {TargetValue: replaceKb, 494 Constraints: []validation.Constraint{{Target: "replaceKb.QnAList", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 495 return result, validation.NewError("qnamaker.KnowledgebaseClient", "Replace", err.Error()) 496 } 497 498 req, err := client.ReplacePreparer(ctx, kbID, replaceKb) 499 if err != nil { 500 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Replace", nil, "Failure preparing request") 501 return 502 } 503 504 resp, err := client.ReplaceSender(req) 505 if err != nil { 506 result.Response = resp 507 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Replace", resp, "Failure sending request") 508 return 509 } 510 511 result, err = client.ReplaceResponder(resp) 512 if err != nil { 513 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Replace", resp, "Failure responding to request") 514 return 515 } 516 517 return 518} 519 520// ReplacePreparer prepares the Replace request. 521func (client KnowledgebaseClient) ReplacePreparer(ctx context.Context, kbID string, replaceKb ReplaceKbDTO) (*http.Request, error) { 522 urlParameters := map[string]interface{}{ 523 "Endpoint": client.Endpoint, 524 } 525 526 pathParameters := map[string]interface{}{ 527 "kbId": autorest.Encode("path", kbID), 528 } 529 530 preparer := autorest.CreatePreparer( 531 autorest.AsContentType("application/json; charset=utf-8"), 532 autorest.AsPut(), 533 autorest.WithCustomBaseURL("{Endpoint}/qnamaker/v4.0", urlParameters), 534 autorest.WithPathParameters("/knowledgebases/{kbId}", pathParameters), 535 autorest.WithJSON(replaceKb)) 536 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 537} 538 539// ReplaceSender sends the Replace request. The method will close the 540// http.Response Body if it receives an error. 541func (client KnowledgebaseClient) ReplaceSender(req *http.Request) (*http.Response, error) { 542 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 543} 544 545// ReplaceResponder handles the response to the Replace request. The method always 546// closes the http.Response Body. 547func (client KnowledgebaseClient) ReplaceResponder(resp *http.Response) (result autorest.Response, err error) { 548 err = autorest.Respond( 549 resp, 550 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 551 autorest.ByClosing()) 552 result.Response = resp 553 return 554} 555 556// Update sends the update request. 557// Parameters: 558// kbID - knowledgebase id. 559// updateKb - post body of the request. 560func (client KnowledgebaseClient) Update(ctx context.Context, kbID string, updateKb UpdateKbOperationDTO) (result Operation, err error) { 561 if tracing.IsEnabled() { 562 ctx = tracing.StartSpan(ctx, fqdn+"/KnowledgebaseClient.Update") 563 defer func() { 564 sc := -1 565 if result.Response.Response != nil { 566 sc = result.Response.Response.StatusCode 567 } 568 tracing.EndSpan(ctx, sc, err) 569 }() 570 } 571 req, err := client.UpdatePreparer(ctx, kbID, updateKb) 572 if err != nil { 573 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Update", nil, "Failure preparing request") 574 return 575 } 576 577 resp, err := client.UpdateSender(req) 578 if err != nil { 579 result.Response = autorest.Response{Response: resp} 580 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Update", resp, "Failure sending request") 581 return 582 } 583 584 result, err = client.UpdateResponder(resp) 585 if err != nil { 586 err = autorest.NewErrorWithError(err, "qnamaker.KnowledgebaseClient", "Update", resp, "Failure responding to request") 587 return 588 } 589 590 return 591} 592 593// UpdatePreparer prepares the Update request. 594func (client KnowledgebaseClient) UpdatePreparer(ctx context.Context, kbID string, updateKb UpdateKbOperationDTO) (*http.Request, error) { 595 urlParameters := map[string]interface{}{ 596 "Endpoint": client.Endpoint, 597 } 598 599 pathParameters := map[string]interface{}{ 600 "kbId": autorest.Encode("path", kbID), 601 } 602 603 preparer := autorest.CreatePreparer( 604 autorest.AsContentType("application/json; charset=utf-8"), 605 autorest.AsPatch(), 606 autorest.WithCustomBaseURL("{Endpoint}/qnamaker/v4.0", urlParameters), 607 autorest.WithPathParameters("/knowledgebases/{kbId}", pathParameters), 608 autorest.WithJSON(updateKb)) 609 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 610} 611 612// UpdateSender sends the Update request. The method will close the 613// http.Response Body if it receives an error. 614func (client KnowledgebaseClient) UpdateSender(req *http.Request) (*http.Response, error) { 615 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 616} 617 618// UpdateResponder handles the response to the Update request. The method always 619// closes the http.Response Body. 620func (client KnowledgebaseClient) UpdateResponder(resp *http.Response) (result Operation, err error) { 621 err = autorest.Respond( 622 resp, 623 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 624 autorest.ByUnmarshallingJSON(&result), 625 autorest.ByClosing()) 626 result.Response = autorest.Response{Response: resp} 627 return 628} 629