largepersongroup.go

Documentation: github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v1.0/face

     1  package face
     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  // LargePersonGroupClient is the an API for face detection, verification, and identification.
    19  type LargePersonGroupClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewLargePersonGroupClient creates an instance of the LargePersonGroupClient client.
    24  func NewLargePersonGroupClient(endpoint string) LargePersonGroupClient {
    25  	return LargePersonGroupClient{New(endpoint)}
    26  }
    27  
    28  // Create create a new large person group with user-specified largePersonGroupId, name, an optional userData and
    29  // recognitionModel.
    30  // <br /> A large person group is the container of the uploaded person data, including face recognition feature, and up
    31  // to 1,000,000
    32  // people.
    33  // <br /> After creation, use [LargePersonGroup Person -
    34  // Create](https://docs.microsoft.com/rest/api/cognitiveservices/face/largepersongroupperson/create) to add person into
    35  // the group, and call [LargePersonGroup -
    36  // Train](https://docs.microsoft.com/rest/api/cognitiveservices/face/largepersongroup/train) to get this group ready
    37  // for [Face - Identify](https://docs.microsoft.com/rest/api/cognitiveservices/face/face/identify).
    38  // <br /> No image will be stored. Only the person's extracted face features and userData will be stored on server
    39  // until [LargePersonGroup Person -
    40  // Delete](https://docs.microsoft.com/rest/api/cognitiveservices/face/largepersongroupperson/delete) or
    41  // [LargePersonGroup - Delete](https://docs.microsoft.com/rest/api/cognitiveservices/face/largepersongroup/delete) is
    42  // called.
    43  // <br/>'recognitionModel' should be specified to associate with this large person group. The default value for
    44  // 'recognitionModel' is 'recognition_01', if the latest model needed, please explicitly specify the model you need in
    45  // this parameter. New faces that are added to an existing large person group will use the recognition model that's
    46  // already associated with the collection. Existing face features in a large person group can't be updated to features
    47  // extracted by another version of recognition model.
    48  // * 'recognition_01': The default recognition model for [LargePersonGroup -
    49  // Create](https://docs.microsoft.com/rest/api/cognitiveservices/face/largepersongroup/create). All those large person
    50  // groups created before 2019 March are bonded with this recognition model.
    51  // * 'recognition_02': Recognition model released in 2019 March.
    52  // * 'recognition_03': Recognition model released in 2020 May. 'recognition_03' is recommended since its overall
    53  // accuracy is improved compared with 'recognition_01' and 'recognition_02'.
    54  //
    55  // Large person group quota:
    56  // * Free-tier subscription quota: 1,000 large person groups.
    57  // * S0-tier subscription quota: 1,000,000 large person groups.
    58  // Parameters:
    59  // largePersonGroupID - id referencing a particular large person group.
    60  // body - request body for creating new large person group.
    61  func (client LargePersonGroupClient) Create(ctx context.Context, largePersonGroupID string, body MetaDataContract) (result autorest.Response, err error) {
    62  	if tracing.IsEnabled() {
    63  		ctx = tracing.StartSpan(ctx, fqdn+"/LargePersonGroupClient.Create")
    64  		defer func() {
    65  			sc := -1
    66  			if result.Response != nil {
    67  				sc = result.Response.StatusCode
    68  			}
    69  			tracing.EndSpan(ctx, sc, err)
    70  		}()
    71  	}
    72  	if err := validation.Validate([]validation.Validation{
    73  		{TargetValue: largePersonGroupID,
    74  			Constraints: []validation.Constraint{{Target: "largePersonGroupID", Name: validation.MaxLength, Rule: 64, Chain: nil},
    75  				{Target: "largePersonGroupID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
    76  		return result, validation.NewError("face.LargePersonGroupClient", "Create", err.Error())
    77  	}
    78  
    79  	req, err := client.CreatePreparer(ctx, largePersonGroupID, body)
    80  	if err != nil {
    81  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Create", nil, "Failure preparing request")
    82  		return
    83  	}
    84  
    85  	resp, err := client.CreateSender(req)
    86  	if err != nil {
    87  		result.Response = resp
    88  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Create", resp, "Failure sending request")
    89  		return
    90  	}
    91  
    92  	result, err = client.CreateResponder(resp)
    93  	if err != nil {
    94  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Create", resp, "Failure responding to request")
    95  		return
    96  	}
    97  
    98  	return
    99  }
   100  
   101  // CreatePreparer prepares the Create request.
   102  func (client LargePersonGroupClient) CreatePreparer(ctx context.Context, largePersonGroupID string, body MetaDataContract) (*http.Request, error) {
   103  	urlParameters := map[string]interface{}{
   104  		"Endpoint": client.Endpoint,
   105  	}
   106  
   107  	pathParameters := map[string]interface{}{
   108  		"largePersonGroupId": autorest.Encode("path", largePersonGroupID),
   109  	}
   110  
   111  	preparer := autorest.CreatePreparer(
   112  		autorest.AsContentType("application/json; charset=utf-8"),
   113  		autorest.AsPut(),
   114  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   115  		autorest.WithPathParameters("/largepersongroups/{largePersonGroupId}", pathParameters),
   116  		autorest.WithJSON(body))
   117  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   118  }
   119  
   120  // CreateSender sends the Create request. The method will close the
   121  // http.Response Body if it receives an error.
   122  func (client LargePersonGroupClient) CreateSender(req *http.Request) (*http.Response, error) {
   123  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   124  }
   125  
   126  // CreateResponder handles the response to the Create request. The method always
   127  // closes the http.Response Body.
   128  func (client LargePersonGroupClient) CreateResponder(resp *http.Response) (result autorest.Response, err error) {
   129  	err = autorest.Respond(
   130  		resp,
   131  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   132  		autorest.ByClosing())
   133  	result.Response = resp
   134  	return
   135  }
   136  
   137  // Delete delete an existing large person group. Persisted face features of all people in the large person group will
   138  // also be deleted.
   139  // Parameters:
   140  // largePersonGroupID - id referencing a particular large person group.
   141  func (client LargePersonGroupClient) Delete(ctx context.Context, largePersonGroupID string) (result autorest.Response, err error) {
   142  	if tracing.IsEnabled() {
   143  		ctx = tracing.StartSpan(ctx, fqdn+"/LargePersonGroupClient.Delete")
   144  		defer func() {
   145  			sc := -1
   146  			if result.Response != nil {
   147  				sc = result.Response.StatusCode
   148  			}
   149  			tracing.EndSpan(ctx, sc, err)
   150  		}()
   151  	}
   152  	if err := validation.Validate([]validation.Validation{
   153  		{TargetValue: largePersonGroupID,
   154  			Constraints: []validation.Constraint{{Target: "largePersonGroupID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   155  				{Target: "largePersonGroupID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   156  		return result, validation.NewError("face.LargePersonGroupClient", "Delete", err.Error())
   157  	}
   158  
   159  	req, err := client.DeletePreparer(ctx, largePersonGroupID)
   160  	if err != nil {
   161  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Delete", nil, "Failure preparing request")
   162  		return
   163  	}
   164  
   165  	resp, err := client.DeleteSender(req)
   166  	if err != nil {
   167  		result.Response = resp
   168  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Delete", resp, "Failure sending request")
   169  		return
   170  	}
   171  
   172  	result, err = client.DeleteResponder(resp)
   173  	if err != nil {
   174  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Delete", resp, "Failure responding to request")
   175  		return
   176  	}
   177  
   178  	return
   179  }
   180  
   181  // DeletePreparer prepares the Delete request.
   182  func (client LargePersonGroupClient) DeletePreparer(ctx context.Context, largePersonGroupID string) (*http.Request, error) {
   183  	urlParameters := map[string]interface{}{
   184  		"Endpoint": client.Endpoint,
   185  	}
   186  
   187  	pathParameters := map[string]interface{}{
   188  		"largePersonGroupId": autorest.Encode("path", largePersonGroupID),
   189  	}
   190  
   191  	preparer := autorest.CreatePreparer(
   192  		autorest.AsDelete(),
   193  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   194  		autorest.WithPathParameters("/largepersongroups/{largePersonGroupId}", pathParameters))
   195  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   196  }
   197  
   198  // DeleteSender sends the Delete request. The method will close the
   199  // http.Response Body if it receives an error.
   200  func (client LargePersonGroupClient) DeleteSender(req *http.Request) (*http.Response, error) {
   201  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   202  }
   203  
   204  // DeleteResponder handles the response to the Delete request. The method always
   205  // closes the http.Response Body.
   206  func (client LargePersonGroupClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   207  	err = autorest.Respond(
   208  		resp,
   209  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   210  		autorest.ByClosing())
   211  	result.Response = resp
   212  	return
   213  }
   214  
   215  // Get retrieve the information of a large person group, including its name, userData and recognitionModel. This API
   216  // returns large person group information only, use [LargePersonGroup Person -
   217  // List](https://docs.microsoft.com/rest/api/cognitiveservices/face/largepersongroupperson/list) instead to retrieve
   218  // person information under the large person group.
   219  // Parameters:
   220  // largePersonGroupID - id referencing a particular large person group.
   221  // returnRecognitionModel - a value indicating whether the operation should return 'recognitionModel' in
   222  // response.
   223  func (client LargePersonGroupClient) Get(ctx context.Context, largePersonGroupID string, returnRecognitionModel *bool) (result LargePersonGroup, err error) {
   224  	if tracing.IsEnabled() {
   225  		ctx = tracing.StartSpan(ctx, fqdn+"/LargePersonGroupClient.Get")
   226  		defer func() {
   227  			sc := -1
   228  			if result.Response.Response != nil {
   229  				sc = result.Response.Response.StatusCode
   230  			}
   231  			tracing.EndSpan(ctx, sc, err)
   232  		}()
   233  	}
   234  	if err := validation.Validate([]validation.Validation{
   235  		{TargetValue: largePersonGroupID,
   236  			Constraints: []validation.Constraint{{Target: "largePersonGroupID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   237  				{Target: "largePersonGroupID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   238  		return result, validation.NewError("face.LargePersonGroupClient", "Get", err.Error())
   239  	}
   240  
   241  	req, err := client.GetPreparer(ctx, largePersonGroupID, returnRecognitionModel)
   242  	if err != nil {
   243  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Get", nil, "Failure preparing request")
   244  		return
   245  	}
   246  
   247  	resp, err := client.GetSender(req)
   248  	if err != nil {
   249  		result.Response = autorest.Response{Response: resp}
   250  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Get", resp, "Failure sending request")
   251  		return
   252  	}
   253  
   254  	result, err = client.GetResponder(resp)
   255  	if err != nil {
   256  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Get", resp, "Failure responding to request")
   257  		return
   258  	}
   259  
   260  	return
   261  }
   262  
   263  // GetPreparer prepares the Get request.
   264  func (client LargePersonGroupClient) GetPreparer(ctx context.Context, largePersonGroupID string, returnRecognitionModel *bool) (*http.Request, error) {
   265  	urlParameters := map[string]interface{}{
   266  		"Endpoint": client.Endpoint,
   267  	}
   268  
   269  	pathParameters := map[string]interface{}{
   270  		"largePersonGroupId": autorest.Encode("path", largePersonGroupID),
   271  	}
   272  
   273  	queryParameters := map[string]interface{}{}
   274  	if returnRecognitionModel != nil {
   275  		queryParameters["returnRecognitionModel"] = autorest.Encode("query", *returnRecognitionModel)
   276  	} else {
   277  		queryParameters["returnRecognitionModel"] = autorest.Encode("query", false)
   278  	}
   279  
   280  	preparer := autorest.CreatePreparer(
   281  		autorest.AsGet(),
   282  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   283  		autorest.WithPathParameters("/largepersongroups/{largePersonGroupId}", pathParameters),
   284  		autorest.WithQueryParameters(queryParameters))
   285  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   286  }
   287  
   288  // GetSender sends the Get request. The method will close the
   289  // http.Response Body if it receives an error.
   290  func (client LargePersonGroupClient) GetSender(req *http.Request) (*http.Response, error) {
   291  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   292  }
   293  
   294  // GetResponder handles the response to the Get request. The method always
   295  // closes the http.Response Body.
   296  func (client LargePersonGroupClient) GetResponder(resp *http.Response) (result LargePersonGroup, err error) {
   297  	err = autorest.Respond(
   298  		resp,
   299  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   300  		autorest.ByUnmarshallingJSON(&result),
   301  		autorest.ByClosing())
   302  	result.Response = autorest.Response{Response: resp}
   303  	return
   304  }
   305  
   306  // GetTrainingStatus retrieve the training status of a large person group (completed or ongoing).
   307  // Parameters:
   308  // largePersonGroupID - id referencing a particular large person group.
   309  func (client LargePersonGroupClient) GetTrainingStatus(ctx context.Context, largePersonGroupID string) (result TrainingStatus, err error) {
   310  	if tracing.IsEnabled() {
   311  		ctx = tracing.StartSpan(ctx, fqdn+"/LargePersonGroupClient.GetTrainingStatus")
   312  		defer func() {
   313  			sc := -1
   314  			if result.Response.Response != nil {
   315  				sc = result.Response.Response.StatusCode
   316  			}
   317  			tracing.EndSpan(ctx, sc, err)
   318  		}()
   319  	}
   320  	if err := validation.Validate([]validation.Validation{
   321  		{TargetValue: largePersonGroupID,
   322  			Constraints: []validation.Constraint{{Target: "largePersonGroupID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   323  				{Target: "largePersonGroupID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   324  		return result, validation.NewError("face.LargePersonGroupClient", "GetTrainingStatus", err.Error())
   325  	}
   326  
   327  	req, err := client.GetTrainingStatusPreparer(ctx, largePersonGroupID)
   328  	if err != nil {
   329  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "GetTrainingStatus", nil, "Failure preparing request")
   330  		return
   331  	}
   332  
   333  	resp, err := client.GetTrainingStatusSender(req)
   334  	if err != nil {
   335  		result.Response = autorest.Response{Response: resp}
   336  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "GetTrainingStatus", resp, "Failure sending request")
   337  		return
   338  	}
   339  
   340  	result, err = client.GetTrainingStatusResponder(resp)
   341  	if err != nil {
   342  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "GetTrainingStatus", resp, "Failure responding to request")
   343  		return
   344  	}
   345  
   346  	return
   347  }
   348  
   349  // GetTrainingStatusPreparer prepares the GetTrainingStatus request.
   350  func (client LargePersonGroupClient) GetTrainingStatusPreparer(ctx context.Context, largePersonGroupID string) (*http.Request, error) {
   351  	urlParameters := map[string]interface{}{
   352  		"Endpoint": client.Endpoint,
   353  	}
   354  
   355  	pathParameters := map[string]interface{}{
   356  		"largePersonGroupId": autorest.Encode("path", largePersonGroupID),
   357  	}
   358  
   359  	preparer := autorest.CreatePreparer(
   360  		autorest.AsGet(),
   361  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   362  		autorest.WithPathParameters("/largepersongroups/{largePersonGroupId}/training", pathParameters))
   363  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   364  }
   365  
   366  // GetTrainingStatusSender sends the GetTrainingStatus request. The method will close the
   367  // http.Response Body if it receives an error.
   368  func (client LargePersonGroupClient) GetTrainingStatusSender(req *http.Request) (*http.Response, error) {
   369  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   370  }
   371  
   372  // GetTrainingStatusResponder handles the response to the GetTrainingStatus request. The method always
   373  // closes the http.Response Body.
   374  func (client LargePersonGroupClient) GetTrainingStatusResponder(resp *http.Response) (result TrainingStatus, err error) {
   375  	err = autorest.Respond(
   376  		resp,
   377  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   378  		autorest.ByUnmarshallingJSON(&result),
   379  		autorest.ByClosing())
   380  	result.Response = autorest.Response{Response: resp}
   381  	return
   382  }
   383  
   384  // List list all existing large person groups’ largePersonGroupId, name, userData and recognitionModel.<br />
   385  // * Large person groups are stored in alphabetical order of largePersonGroupId.
   386  // * "start" parameter (string, optional) is a user-provided largePersonGroupId value that returned entries have larger
   387  // ids by string comparison. "start" set to empty to indicate return from the first item.
   388  // * "top" parameter (int, optional) specifies the number of entries to return. A maximal of 1000 entries can be
   389  // returned in one call. To fetch more, you can specify "start" with the last returned entry’s Id of the current call.
   390  // <br />
   391  // For example, total 5 large person groups: "group1", ..., "group5".
   392  // <br /> "start=&top=" will return all 5 groups.
   393  // <br /> "start=&top=2" will return "group1", "group2".
   394  // <br /> "start=group2&top=3" will return "group3", "group4", "group5".
   395  // Parameters:
   396  // start - list large person groups from the least largePersonGroupId greater than the "start".
   397  // top - the number of large person groups to list.
   398  // returnRecognitionModel - a value indicating whether the operation should return 'recognitionModel' in
   399  // response.
   400  func (client LargePersonGroupClient) List(ctx context.Context, start string, top *int32, returnRecognitionModel *bool) (result ListLargePersonGroup, err error) {
   401  	if tracing.IsEnabled() {
   402  		ctx = tracing.StartSpan(ctx, fqdn+"/LargePersonGroupClient.List")
   403  		defer func() {
   404  			sc := -1
   405  			if result.Response.Response != nil {
   406  				sc = result.Response.Response.StatusCode
   407  			}
   408  			tracing.EndSpan(ctx, sc, err)
   409  		}()
   410  	}
   411  	if err := validation.Validate([]validation.Validation{
   412  		{TargetValue: start,
   413  			Constraints: []validation.Constraint{{Target: "start", Name: validation.Empty, Rule: false,
   414  				Chain: []validation.Constraint{{Target: "start", Name: validation.MaxLength, Rule: 64, Chain: nil}}}}},
   415  		{TargetValue: top,
   416  			Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false,
   417  				Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMaximum, Rule: int64(1000), Chain: nil},
   418  					{Target: "top", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   419  				}}}}}); err != nil {
   420  		return result, validation.NewError("face.LargePersonGroupClient", "List", err.Error())
   421  	}
   422  
   423  	req, err := client.ListPreparer(ctx, start, top, returnRecognitionModel)
   424  	if err != nil {
   425  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "List", nil, "Failure preparing request")
   426  		return
   427  	}
   428  
   429  	resp, err := client.ListSender(req)
   430  	if err != nil {
   431  		result.Response = autorest.Response{Response: resp}
   432  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "List", resp, "Failure sending request")
   433  		return
   434  	}
   435  
   436  	result, err = client.ListResponder(resp)
   437  	if err != nil {
   438  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "List", resp, "Failure responding to request")
   439  		return
   440  	}
   441  
   442  	return
   443  }
   444  
   445  // ListPreparer prepares the List request.
   446  func (client LargePersonGroupClient) ListPreparer(ctx context.Context, start string, top *int32, returnRecognitionModel *bool) (*http.Request, error) {
   447  	urlParameters := map[string]interface{}{
   448  		"Endpoint": client.Endpoint,
   449  	}
   450  
   451  	queryParameters := map[string]interface{}{}
   452  	if len(start) > 0 {
   453  		queryParameters["start"] = autorest.Encode("query", start)
   454  	}
   455  	if top != nil {
   456  		queryParameters["top"] = autorest.Encode("query", *top)
   457  	} else {
   458  		queryParameters["top"] = autorest.Encode("query", 1000)
   459  	}
   460  	if returnRecognitionModel != nil {
   461  		queryParameters["returnRecognitionModel"] = autorest.Encode("query", *returnRecognitionModel)
   462  	} else {
   463  		queryParameters["returnRecognitionModel"] = autorest.Encode("query", false)
   464  	}
   465  
   466  	preparer := autorest.CreatePreparer(
   467  		autorest.AsGet(),
   468  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   469  		autorest.WithPath("/largepersongroups"),
   470  		autorest.WithQueryParameters(queryParameters))
   471  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   472  }
   473  
   474  // ListSender sends the List request. The method will close the
   475  // http.Response Body if it receives an error.
   476  func (client LargePersonGroupClient) ListSender(req *http.Request) (*http.Response, error) {
   477  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   478  }
   479  
   480  // ListResponder handles the response to the List request. The method always
   481  // closes the http.Response Body.
   482  func (client LargePersonGroupClient) ListResponder(resp *http.Response) (result ListLargePersonGroup, err error) {
   483  	err = autorest.Respond(
   484  		resp,
   485  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   486  		autorest.ByUnmarshallingJSON(&result.Value),
   487  		autorest.ByClosing())
   488  	result.Response = autorest.Response{Response: resp}
   489  	return
   490  }
   491  
   492  // Train queue a large person group training task, the training task may not be started immediately.
   493  // Parameters:
   494  // largePersonGroupID - id referencing a particular large person group.
   495  func (client LargePersonGroupClient) Train(ctx context.Context, largePersonGroupID string) (result autorest.Response, err error) {
   496  	if tracing.IsEnabled() {
   497  		ctx = tracing.StartSpan(ctx, fqdn+"/LargePersonGroupClient.Train")
   498  		defer func() {
   499  			sc := -1
   500  			if result.Response != nil {
   501  				sc = result.Response.StatusCode
   502  			}
   503  			tracing.EndSpan(ctx, sc, err)
   504  		}()
   505  	}
   506  	if err := validation.Validate([]validation.Validation{
   507  		{TargetValue: largePersonGroupID,
   508  			Constraints: []validation.Constraint{{Target: "largePersonGroupID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   509  				{Target: "largePersonGroupID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   510  		return result, validation.NewError("face.LargePersonGroupClient", "Train", err.Error())
   511  	}
   512  
   513  	req, err := client.TrainPreparer(ctx, largePersonGroupID)
   514  	if err != nil {
   515  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Train", nil, "Failure preparing request")
   516  		return
   517  	}
   518  
   519  	resp, err := client.TrainSender(req)
   520  	if err != nil {
   521  		result.Response = resp
   522  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Train", resp, "Failure sending request")
   523  		return
   524  	}
   525  
   526  	result, err = client.TrainResponder(resp)
   527  	if err != nil {
   528  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Train", resp, "Failure responding to request")
   529  		return
   530  	}
   531  
   532  	return
   533  }
   534  
   535  // TrainPreparer prepares the Train request.
   536  func (client LargePersonGroupClient) TrainPreparer(ctx context.Context, largePersonGroupID string) (*http.Request, error) {
   537  	urlParameters := map[string]interface{}{
   538  		"Endpoint": client.Endpoint,
   539  	}
   540  
   541  	pathParameters := map[string]interface{}{
   542  		"largePersonGroupId": autorest.Encode("path", largePersonGroupID),
   543  	}
   544  
   545  	preparer := autorest.CreatePreparer(
   546  		autorest.AsPost(),
   547  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   548  		autorest.WithPathParameters("/largepersongroups/{largePersonGroupId}/train", pathParameters))
   549  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   550  }
   551  
   552  // TrainSender sends the Train request. The method will close the
   553  // http.Response Body if it receives an error.
   554  func (client LargePersonGroupClient) TrainSender(req *http.Request) (*http.Response, error) {
   555  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   556  }
   557  
   558  // TrainResponder handles the response to the Train request. The method always
   559  // closes the http.Response Body.
   560  func (client LargePersonGroupClient) TrainResponder(resp *http.Response) (result autorest.Response, err error) {
   561  	err = autorest.Respond(
   562  		resp,
   563  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   564  		autorest.ByClosing())
   565  	result.Response = resp
   566  	return
   567  }
   568  
   569  // Update update an existing large person group's display name and userData. The properties which does not appear in
   570  // request body will not be updated.
   571  // Parameters:
   572  // largePersonGroupID - id referencing a particular large person group.
   573  // body - request body for updating large person group.
   574  func (client LargePersonGroupClient) Update(ctx context.Context, largePersonGroupID string, body NameAndUserDataContract) (result autorest.Response, err error) {
   575  	if tracing.IsEnabled() {
   576  		ctx = tracing.StartSpan(ctx, fqdn+"/LargePersonGroupClient.Update")
   577  		defer func() {
   578  			sc := -1
   579  			if result.Response != nil {
   580  				sc = result.Response.StatusCode
   581  			}
   582  			tracing.EndSpan(ctx, sc, err)
   583  		}()
   584  	}
   585  	if err := validation.Validate([]validation.Validation{
   586  		{TargetValue: largePersonGroupID,
   587  			Constraints: []validation.Constraint{{Target: "largePersonGroupID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   588  				{Target: "largePersonGroupID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   589  		return result, validation.NewError("face.LargePersonGroupClient", "Update", err.Error())
   590  	}
   591  
   592  	req, err := client.UpdatePreparer(ctx, largePersonGroupID, body)
   593  	if err != nil {
   594  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Update", nil, "Failure preparing request")
   595  		return
   596  	}
   597  
   598  	resp, err := client.UpdateSender(req)
   599  	if err != nil {
   600  		result.Response = resp
   601  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Update", resp, "Failure sending request")
   602  		return
   603  	}
   604  
   605  	result, err = client.UpdateResponder(resp)
   606  	if err != nil {
   607  		err = autorest.NewErrorWithError(err, "face.LargePersonGroupClient", "Update", resp, "Failure responding to request")
   608  		return
   609  	}
   610  
   611  	return
   612  }
   613  
   614  // UpdatePreparer prepares the Update request.
   615  func (client LargePersonGroupClient) UpdatePreparer(ctx context.Context, largePersonGroupID string, body NameAndUserDataContract) (*http.Request, error) {
   616  	urlParameters := map[string]interface{}{
   617  		"Endpoint": client.Endpoint,
   618  	}
   619  
   620  	pathParameters := map[string]interface{}{
   621  		"largePersonGroupId": autorest.Encode("path", largePersonGroupID),
   622  	}
   623  
   624  	preparer := autorest.CreatePreparer(
   625  		autorest.AsContentType("application/json; charset=utf-8"),
   626  		autorest.AsPatch(),
   627  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   628  		autorest.WithPathParameters("/largepersongroups/{largePersonGroupId}", pathParameters),
   629  		autorest.WithJSON(body))
   630  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   631  }
   632  
   633  // UpdateSender sends the Update request. The method will close the
   634  // http.Response Body if it receives an error.
   635  func (client LargePersonGroupClient) UpdateSender(req *http.Request) (*http.Response, error) {
   636  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   637  }
   638  
   639  // UpdateResponder handles the response to the Update request. The method always
   640  // closes the http.Response Body.
   641  func (client LargePersonGroupClient) UpdateResponder(resp *http.Response) (result autorest.Response, err error) {
   642  	err = autorest.Respond(
   643  		resp,
   644  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   645  		autorest.ByClosing())
   646  	result.Response = resp
   647  	return
   648  }
   649
View as plain text