knowledgebase.go

Documentation: github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v4.0/qnamaker

     1  package 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  
     9  import (
    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
    19  type KnowledgebaseClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewKnowledgebaseClient creates an instance of the KnowledgebaseClient client.
    24  func 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.
    31  func (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.
    82  func (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.
    98  func (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.
   104  func (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.
   117  func (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.
   151  func (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.
   169  func (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.
   175  func (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.
   193  func (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.
   227  func (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.
   255  func (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.
   261  func (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.
   274  func (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.
   308  func (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.
   326  func (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.
   332  func (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.
   343  func (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.
   377  func (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.
   391  func (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.
   397  func (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.
   410  func (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.
   444  func (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.
   462  func (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.
   468  func (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
   481  func (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.
   521  func (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.
   541  func (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.
   547  func (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.
   560  func (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.
   594  func (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.
   614  func (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.
   620  func (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
View as plain text