Source file src/github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v1.0/face/largefacelist.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  	"github.com/gofrs/uuid"
    16  	"io"
    17  	"net/http"
    18  )
    19  
    20  // LargeFaceListClient is the an API for face detection, verification, and identification.
    21  type LargeFaceListClient struct {
    22  	BaseClient
    23  }
    24  
    25  // NewLargeFaceListClient creates an instance of the LargeFaceListClient client.
    26  func NewLargeFaceListClient(endpoint string) LargeFaceListClient {
    27  	return LargeFaceListClient{New(endpoint)}
    28  }
    29  
    30  // AddFaceFromStream add a face to a specified large face list, up to 1,000,000 faces.
    31  // <br /> To deal with an image contains multiple faces, input face can be specified as an image with a targetFace
    32  // rectangle. It returns a persistedFaceId representing the added face. No image will be stored. Only the extracted
    33  // face feature will be stored on server until [LargeFaceList Face -
    34  // Delete](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/deleteface) or [LargeFaceList -
    35  // Delete](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/delete) is called.
    36  // <br /> Note persistedFaceId is different from faceId generated by [Face -
    37  // Detect](https://docs.microsoft.com/rest/api/cognitiveservices/face/face/detectwithurl).
    38  // * Higher face image quality means better recognition precision. Please consider high-quality faces: frontal, clear,
    39  // and face size is 200x200 pixels (100 pixels between eyes) or bigger.
    40  // * JPEG, PNG, GIF (the first frame), and BMP format are supported. The allowed image file size is from 1KB to 6MB.
    41  // * "targetFace" rectangle should contain one face. Zero or multiple faces will be regarded as an error. If the
    42  // provided "targetFace" rectangle is not returned from [Face -
    43  // Detect](https://docs.microsoft.com/rest/api/cognitiveservices/face/face/detectwithurl), there’s no guarantee to
    44  // detect and add the face successfully.
    45  // * Out of detectable face size (36x36 - 4096x4096 pixels), large head-pose, or large occlusions will cause failures.
    46  // * Adding/deleting faces to/from a same face list are processed sequentially and to/from different face lists are in
    47  // parallel.
    48  // * The minimum detectable face size is 36x36 pixels in an image no larger than 1920x1080 pixels. Images with
    49  // dimensions higher than 1920x1080 pixels will need a proportionally larger minimum face size.
    50  // * Different 'detectionModel' values can be provided. To use and compare different detection models, please refer to
    51  // [How to specify a detection
    52  // model](https://docs.microsoft.com/azure/cognitive-services/face/face-api-how-to-topics/specify-detection-model)
    53  // | Model | Recommended use-case(s) |
    54  // | ---------- | -------- |
    55  // | 'detection_01': | The default detection model for [LargeFaceList - Add
    56  // Face](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/addfacefromurl). Recommend for near
    57  // frontal face detection. For scenarios with exceptionally large angle (head-pose) faces, occluded faces or wrong
    58  // image orientation, the faces in such cases may not be detected. |
    59  // | 'detection_02': | Detection model released in 2019 May with improved accuracy especially on small, side and blurry
    60  // faces. |
    61  //
    62  // Quota:
    63  // * Free-tier subscription quota: 1,000 faces per large face list.
    64  // * S0-tier subscription quota: 1,000,000 faces per large face list.
    65  // Parameters:
    66  // largeFaceListID - id referencing a particular large face list.
    67  // imageParameter - an image stream.
    68  // userData - user-specified data about the face for any purpose. The maximum length is 1KB.
    69  // targetFace - a face rectangle to specify the target face to be added to a person in the format of
    70  // "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the
    71  // image, targetFace is required to specify which face to add. No targetFace means there is only one face
    72  // detected in the entire image.
    73  // detectionModel - name of detection model. Detection model is used to detect faces in the submitted image. A
    74  // detection model name can be provided when performing Face - Detect or (Large)FaceList - Add Face or
    75  // (Large)PersonGroup - Add Face. The default value is 'detection_01', if another model is needed, please
    76  // explicitly specify it.
    77  func (client LargeFaceListClient) AddFaceFromStream(ctx context.Context, largeFaceListID string, imageParameter io.ReadCloser, userData string, targetFace []int32, detectionModel DetectionModel) (result PersistedFace, err error) {
    78  	if tracing.IsEnabled() {
    79  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.AddFaceFromStream")
    80  		defer func() {
    81  			sc := -1
    82  			if result.Response.Response != nil {
    83  				sc = result.Response.Response.StatusCode
    84  			}
    85  			tracing.EndSpan(ctx, sc, err)
    86  		}()
    87  	}
    88  	if err := validation.Validate([]validation.Validation{
    89  		{TargetValue: largeFaceListID,
    90  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
    91  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}},
    92  		{TargetValue: userData,
    93  			Constraints: []validation.Constraint{{Target: "userData", Name: validation.Empty, Rule: false,
    94  				Chain: []validation.Constraint{{Target: "userData", Name: validation.MaxLength, Rule: 1024, Chain: nil}}}}}}); err != nil {
    95  		return result, validation.NewError("face.LargeFaceListClient", "AddFaceFromStream", err.Error())
    96  	}
    97  
    98  	req, err := client.AddFaceFromStreamPreparer(ctx, largeFaceListID, imageParameter, userData, targetFace, detectionModel)
    99  	if err != nil {
   100  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "AddFaceFromStream", nil, "Failure preparing request")
   101  		return
   102  	}
   103  
   104  	resp, err := client.AddFaceFromStreamSender(req)
   105  	if err != nil {
   106  		result.Response = autorest.Response{Response: resp}
   107  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "AddFaceFromStream", resp, "Failure sending request")
   108  		return
   109  	}
   110  
   111  	result, err = client.AddFaceFromStreamResponder(resp)
   112  	if err != nil {
   113  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "AddFaceFromStream", resp, "Failure responding to request")
   114  		return
   115  	}
   116  
   117  	return
   118  }
   119  
   120  // AddFaceFromStreamPreparer prepares the AddFaceFromStream request.
   121  func (client LargeFaceListClient) AddFaceFromStreamPreparer(ctx context.Context, largeFaceListID string, imageParameter io.ReadCloser, userData string, targetFace []int32, detectionModel DetectionModel) (*http.Request, error) {
   122  	urlParameters := map[string]interface{}{
   123  		"Endpoint": client.Endpoint,
   124  	}
   125  
   126  	pathParameters := map[string]interface{}{
   127  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
   128  	}
   129  
   130  	queryParameters := map[string]interface{}{}
   131  	if len(userData) > 0 {
   132  		queryParameters["userData"] = autorest.Encode("query", userData)
   133  	}
   134  	if targetFace != nil && len(targetFace) > 0 {
   135  		queryParameters["targetFace"] = autorest.Encode("query", targetFace, ",")
   136  	}
   137  	if len(string(detectionModel)) > 0 {
   138  		queryParameters["detectionModel"] = autorest.Encode("query", detectionModel)
   139  	} else {
   140  		queryParameters["detectionModel"] = autorest.Encode("query", "detection_01")
   141  	}
   142  
   143  	preparer := autorest.CreatePreparer(
   144  		autorest.AsContentType("application/octet-stream"),
   145  		autorest.AsPost(),
   146  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   147  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}/persistedfaces", pathParameters),
   148  		autorest.WithFile(imageParameter),
   149  		autorest.WithQueryParameters(queryParameters))
   150  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   151  }
   152  
   153  // AddFaceFromStreamSender sends the AddFaceFromStream request. The method will close the
   154  // http.Response Body if it receives an error.
   155  func (client LargeFaceListClient) AddFaceFromStreamSender(req *http.Request) (*http.Response, error) {
   156  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   157  }
   158  
   159  // AddFaceFromStreamResponder handles the response to the AddFaceFromStream request. The method always
   160  // closes the http.Response Body.
   161  func (client LargeFaceListClient) AddFaceFromStreamResponder(resp *http.Response) (result PersistedFace, err error) {
   162  	err = autorest.Respond(
   163  		resp,
   164  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   165  		autorest.ByUnmarshallingJSON(&result),
   166  		autorest.ByClosing())
   167  	result.Response = autorest.Response{Response: resp}
   168  	return
   169  }
   170  
   171  // AddFaceFromURL add a face to a specified large face list, up to 1,000,000 faces.
   172  // <br /> To deal with an image contains multiple faces, input face can be specified as an image with a targetFace
   173  // rectangle. It returns a persistedFaceId representing the added face. No image will be stored. Only the extracted
   174  // face feature will be stored on server until [LargeFaceList Face -
   175  // Delete](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/deleteface) or [LargeFaceList -
   176  // Delete](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/delete) is called.
   177  // <br /> Note persistedFaceId is different from faceId generated by [Face -
   178  // Detect](https://docs.microsoft.com/rest/api/cognitiveservices/face/face/detectwithurl).
   179  // * Higher face image quality means better recognition precision. Please consider high-quality faces: frontal, clear,
   180  // and face size is 200x200 pixels (100 pixels between eyes) or bigger.
   181  // * JPEG, PNG, GIF (the first frame), and BMP format are supported. The allowed image file size is from 1KB to 6MB.
   182  // * "targetFace" rectangle should contain one face. Zero or multiple faces will be regarded as an error. If the
   183  // provided "targetFace" rectangle is not returned from [Face -
   184  // Detect](https://docs.microsoft.com/rest/api/cognitiveservices/face/face/detectwithurl), there’s no guarantee to
   185  // detect and add the face successfully.
   186  // * Out of detectable face size (36x36 - 4096x4096 pixels), large head-pose, or large occlusions will cause failures.
   187  // * Adding/deleting faces to/from a same face list are processed sequentially and to/from different face lists are in
   188  // parallel.
   189  // * The minimum detectable face size is 36x36 pixels in an image no larger than 1920x1080 pixels. Images with
   190  // dimensions higher than 1920x1080 pixels will need a proportionally larger minimum face size.
   191  // * Different 'detectionModel' values can be provided. To use and compare different detection models, please refer to
   192  // [How to specify a detection
   193  // model](https://docs.microsoft.com/azure/cognitive-services/face/face-api-how-to-topics/specify-detection-model)
   194  // | Model | Recommended use-case(s) |
   195  // | ---------- | -------- |
   196  // | 'detection_01': | The default detection model for [LargeFaceList - Add
   197  // Face](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/addfacefromurl). Recommend for near
   198  // frontal face detection. For scenarios with exceptionally large angle (head-pose) faces, occluded faces or wrong
   199  // image orientation, the faces in such cases may not be detected. |
   200  // | 'detection_02': | Detection model released in 2019 May with improved accuracy especially on small, side and blurry
   201  // faces. |
   202  //
   203  // Quota:
   204  // * Free-tier subscription quota: 1,000 faces per large face list.
   205  // * S0-tier subscription quota: 1,000,000 faces per large face list.
   206  // Parameters:
   207  // largeFaceListID - id referencing a particular large face list.
   208  // imageURL - a JSON document with a URL pointing to the image that is to be analyzed.
   209  // userData - user-specified data about the face for any purpose. The maximum length is 1KB.
   210  // targetFace - a face rectangle to specify the target face to be added to a person in the format of
   211  // "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the
   212  // image, targetFace is required to specify which face to add. No targetFace means there is only one face
   213  // detected in the entire image.
   214  // detectionModel - name of detection model. Detection model is used to detect faces in the submitted image. A
   215  // detection model name can be provided when performing Face - Detect or (Large)FaceList - Add Face or
   216  // (Large)PersonGroup - Add Face. The default value is 'detection_01', if another model is needed, please
   217  // explicitly specify it.
   218  func (client LargeFaceListClient) AddFaceFromURL(ctx context.Context, largeFaceListID string, imageURL ImageURL, userData string, targetFace []int32, detectionModel DetectionModel) (result PersistedFace, err error) {
   219  	if tracing.IsEnabled() {
   220  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.AddFaceFromURL")
   221  		defer func() {
   222  			sc := -1
   223  			if result.Response.Response != nil {
   224  				sc = result.Response.Response.StatusCode
   225  			}
   226  			tracing.EndSpan(ctx, sc, err)
   227  		}()
   228  	}
   229  	if err := validation.Validate([]validation.Validation{
   230  		{TargetValue: largeFaceListID,
   231  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   232  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}},
   233  		{TargetValue: userData,
   234  			Constraints: []validation.Constraint{{Target: "userData", Name: validation.Empty, Rule: false,
   235  				Chain: []validation.Constraint{{Target: "userData", Name: validation.MaxLength, Rule: 1024, Chain: nil}}}}},
   236  		{TargetValue: imageURL,
   237  			Constraints: []validation.Constraint{{Target: "imageURL.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   238  		return result, validation.NewError("face.LargeFaceListClient", "AddFaceFromURL", err.Error())
   239  	}
   240  
   241  	req, err := client.AddFaceFromURLPreparer(ctx, largeFaceListID, imageURL, userData, targetFace, detectionModel)
   242  	if err != nil {
   243  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "AddFaceFromURL", nil, "Failure preparing request")
   244  		return
   245  	}
   246  
   247  	resp, err := client.AddFaceFromURLSender(req)
   248  	if err != nil {
   249  		result.Response = autorest.Response{Response: resp}
   250  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "AddFaceFromURL", resp, "Failure sending request")
   251  		return
   252  	}
   253  
   254  	result, err = client.AddFaceFromURLResponder(resp)
   255  	if err != nil {
   256  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "AddFaceFromURL", resp, "Failure responding to request")
   257  		return
   258  	}
   259  
   260  	return
   261  }
   262  
   263  // AddFaceFromURLPreparer prepares the AddFaceFromURL request.
   264  func (client LargeFaceListClient) AddFaceFromURLPreparer(ctx context.Context, largeFaceListID string, imageURL ImageURL, userData string, targetFace []int32, detectionModel DetectionModel) (*http.Request, error) {
   265  	urlParameters := map[string]interface{}{
   266  		"Endpoint": client.Endpoint,
   267  	}
   268  
   269  	pathParameters := map[string]interface{}{
   270  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
   271  	}
   272  
   273  	queryParameters := map[string]interface{}{}
   274  	if len(userData) > 0 {
   275  		queryParameters["userData"] = autorest.Encode("query", userData)
   276  	}
   277  	if targetFace != nil && len(targetFace) > 0 {
   278  		queryParameters["targetFace"] = autorest.Encode("query", targetFace, ",")
   279  	}
   280  	if len(string(detectionModel)) > 0 {
   281  		queryParameters["detectionModel"] = autorest.Encode("query", detectionModel)
   282  	} else {
   283  		queryParameters["detectionModel"] = autorest.Encode("query", "detection_01")
   284  	}
   285  
   286  	preparer := autorest.CreatePreparer(
   287  		autorest.AsContentType("application/json; charset=utf-8"),
   288  		autorest.AsPost(),
   289  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   290  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}/persistedfaces", pathParameters),
   291  		autorest.WithJSON(imageURL),
   292  		autorest.WithQueryParameters(queryParameters))
   293  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   294  }
   295  
   296  // AddFaceFromURLSender sends the AddFaceFromURL request. The method will close the
   297  // http.Response Body if it receives an error.
   298  func (client LargeFaceListClient) AddFaceFromURLSender(req *http.Request) (*http.Response, error) {
   299  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   300  }
   301  
   302  // AddFaceFromURLResponder handles the response to the AddFaceFromURL request. The method always
   303  // closes the http.Response Body.
   304  func (client LargeFaceListClient) AddFaceFromURLResponder(resp *http.Response) (result PersistedFace, err error) {
   305  	err = autorest.Respond(
   306  		resp,
   307  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   308  		autorest.ByUnmarshallingJSON(&result),
   309  		autorest.ByClosing())
   310  	result.Response = autorest.Response{Response: resp}
   311  	return
   312  }
   313  
   314  // Create create an empty large face list with user-specified largeFaceListId, name, an optional userData and
   315  // recognitionModel.
   316  // <br /> Large face list is a list of faces, up to 1,000,000 faces, and used by [Face - Find
   317  // Similar](https://docs.microsoft.com/rest/api/cognitiveservices/face/face/findsimilar).
   318  // <br /> After creation, user should use [LargeFaceList Face -
   319  // Add](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/addfacefromurl) to import the faces
   320  // and [LargeFaceList - Train](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/train) to make
   321  // it ready for [Face - Find Similar](https://docs.microsoft.com/rest/api/cognitiveservices/face/face/findsimilar). No
   322  // image will be stored. Only the extracted face features are stored on server until [LargeFaceList -
   323  // Delete](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/delete) is called.
   324  // <br /> Find Similar is used for scenario like finding celebrity-like faces, similar face filtering, or as a light
   325  // way face identification. But if the actual use is to identify person, please use
   326  // [PersonGroup](https://docs.microsoft.com/rest/api/cognitiveservices/face/persongroup) /
   327  // [LargePersonGroup](https://docs.microsoft.com/rest/api/cognitiveservices/face/largepersongroup) and [Face -
   328  // Identify](https://docs.microsoft.com/rest/api/cognitiveservices/face/face/identify).
   329  // <br/>'recognitionModel' should be specified to associate with this large face list. The default value for
   330  // 'recognitionModel' is 'recognition_01', if the latest model needed, please explicitly specify the model you need in
   331  // this parameter. New faces that are added to an existing large face list will use the recognition model that's
   332  // already associated with the collection. Existing face features in a large face list can't be updated to features
   333  // extracted by another version of recognition model.
   334  // * 'recognition_01': The default recognition model for [LargeFaceList-
   335  // Create](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/create). All those large face lists
   336  // created before 2019 March are bonded with this recognition model.
   337  // * 'recognition_02': Recognition model released in 2019 March.
   338  // * 'recognition_03': Recognition model released in 2020 May. 'recognition_03' is recommended since its overall
   339  // accuracy is improved compared with 'recognition_01' and 'recognition_02'.
   340  //
   341  // Large face list quota:
   342  // * Free-tier subscription quota: 64 large face lists.
   343  // * S0-tier subscription quota: 1,000,000 large face lists.
   344  // Parameters:
   345  // largeFaceListID - id referencing a particular large face list.
   346  // body - request body for creating a large face list.
   347  func (client LargeFaceListClient) Create(ctx context.Context, largeFaceListID string, body MetaDataContract) (result autorest.Response, err error) {
   348  	if tracing.IsEnabled() {
   349  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.Create")
   350  		defer func() {
   351  			sc := -1
   352  			if result.Response != nil {
   353  				sc = result.Response.StatusCode
   354  			}
   355  			tracing.EndSpan(ctx, sc, err)
   356  		}()
   357  	}
   358  	if err := validation.Validate([]validation.Validation{
   359  		{TargetValue: largeFaceListID,
   360  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   361  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   362  		return result, validation.NewError("face.LargeFaceListClient", "Create", err.Error())
   363  	}
   364  
   365  	req, err := client.CreatePreparer(ctx, largeFaceListID, body)
   366  	if err != nil {
   367  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Create", nil, "Failure preparing request")
   368  		return
   369  	}
   370  
   371  	resp, err := client.CreateSender(req)
   372  	if err != nil {
   373  		result.Response = resp
   374  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Create", resp, "Failure sending request")
   375  		return
   376  	}
   377  
   378  	result, err = client.CreateResponder(resp)
   379  	if err != nil {
   380  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Create", resp, "Failure responding to request")
   381  		return
   382  	}
   383  
   384  	return
   385  }
   386  
   387  // CreatePreparer prepares the Create request.
   388  func (client LargeFaceListClient) CreatePreparer(ctx context.Context, largeFaceListID string, body MetaDataContract) (*http.Request, error) {
   389  	urlParameters := map[string]interface{}{
   390  		"Endpoint": client.Endpoint,
   391  	}
   392  
   393  	pathParameters := map[string]interface{}{
   394  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
   395  	}
   396  
   397  	preparer := autorest.CreatePreparer(
   398  		autorest.AsContentType("application/json; charset=utf-8"),
   399  		autorest.AsPut(),
   400  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   401  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}", pathParameters),
   402  		autorest.WithJSON(body))
   403  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   404  }
   405  
   406  // CreateSender sends the Create request. The method will close the
   407  // http.Response Body if it receives an error.
   408  func (client LargeFaceListClient) CreateSender(req *http.Request) (*http.Response, error) {
   409  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   410  }
   411  
   412  // CreateResponder handles the response to the Create request. The method always
   413  // closes the http.Response Body.
   414  func (client LargeFaceListClient) CreateResponder(resp *http.Response) (result autorest.Response, err error) {
   415  	err = autorest.Respond(
   416  		resp,
   417  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   418  		autorest.ByClosing())
   419  	result.Response = resp
   420  	return
   421  }
   422  
   423  // Delete delete a specified large face list.
   424  // Parameters:
   425  // largeFaceListID - id referencing a particular large face list.
   426  func (client LargeFaceListClient) Delete(ctx context.Context, largeFaceListID string) (result autorest.Response, err error) {
   427  	if tracing.IsEnabled() {
   428  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.Delete")
   429  		defer func() {
   430  			sc := -1
   431  			if result.Response != nil {
   432  				sc = result.Response.StatusCode
   433  			}
   434  			tracing.EndSpan(ctx, sc, err)
   435  		}()
   436  	}
   437  	if err := validation.Validate([]validation.Validation{
   438  		{TargetValue: largeFaceListID,
   439  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   440  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   441  		return result, validation.NewError("face.LargeFaceListClient", "Delete", err.Error())
   442  	}
   443  
   444  	req, err := client.DeletePreparer(ctx, largeFaceListID)
   445  	if err != nil {
   446  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Delete", nil, "Failure preparing request")
   447  		return
   448  	}
   449  
   450  	resp, err := client.DeleteSender(req)
   451  	if err != nil {
   452  		result.Response = resp
   453  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Delete", resp, "Failure sending request")
   454  		return
   455  	}
   456  
   457  	result, err = client.DeleteResponder(resp)
   458  	if err != nil {
   459  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Delete", resp, "Failure responding to request")
   460  		return
   461  	}
   462  
   463  	return
   464  }
   465  
   466  // DeletePreparer prepares the Delete request.
   467  func (client LargeFaceListClient) DeletePreparer(ctx context.Context, largeFaceListID string) (*http.Request, error) {
   468  	urlParameters := map[string]interface{}{
   469  		"Endpoint": client.Endpoint,
   470  	}
   471  
   472  	pathParameters := map[string]interface{}{
   473  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
   474  	}
   475  
   476  	preparer := autorest.CreatePreparer(
   477  		autorest.AsDelete(),
   478  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   479  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}", pathParameters))
   480  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   481  }
   482  
   483  // DeleteSender sends the Delete request. The method will close the
   484  // http.Response Body if it receives an error.
   485  func (client LargeFaceListClient) DeleteSender(req *http.Request) (*http.Response, error) {
   486  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   487  }
   488  
   489  // DeleteResponder handles the response to the Delete request. The method always
   490  // closes the http.Response Body.
   491  func (client LargeFaceListClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   492  	err = autorest.Respond(
   493  		resp,
   494  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   495  		autorest.ByClosing())
   496  	result.Response = resp
   497  	return
   498  }
   499  
   500  // DeleteFace delete a face from a large face list by specified largeFaceListId and persistedFaceId.
   501  // <br /> Adding/deleting faces to/from a same large face list are processed sequentially and to/from different large
   502  // face lists are in parallel.
   503  // Parameters:
   504  // largeFaceListID - id referencing a particular large face list.
   505  // persistedFaceID - id referencing a particular persistedFaceId of an existing face.
   506  func (client LargeFaceListClient) DeleteFace(ctx context.Context, largeFaceListID string, persistedFaceID uuid.UUID) (result autorest.Response, err error) {
   507  	if tracing.IsEnabled() {
   508  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.DeleteFace")
   509  		defer func() {
   510  			sc := -1
   511  			if result.Response != nil {
   512  				sc = result.Response.StatusCode
   513  			}
   514  			tracing.EndSpan(ctx, sc, err)
   515  		}()
   516  	}
   517  	if err := validation.Validate([]validation.Validation{
   518  		{TargetValue: largeFaceListID,
   519  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   520  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   521  		return result, validation.NewError("face.LargeFaceListClient", "DeleteFace", err.Error())
   522  	}
   523  
   524  	req, err := client.DeleteFacePreparer(ctx, largeFaceListID, persistedFaceID)
   525  	if err != nil {
   526  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "DeleteFace", nil, "Failure preparing request")
   527  		return
   528  	}
   529  
   530  	resp, err := client.DeleteFaceSender(req)
   531  	if err != nil {
   532  		result.Response = resp
   533  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "DeleteFace", resp, "Failure sending request")
   534  		return
   535  	}
   536  
   537  	result, err = client.DeleteFaceResponder(resp)
   538  	if err != nil {
   539  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "DeleteFace", resp, "Failure responding to request")
   540  		return
   541  	}
   542  
   543  	return
   544  }
   545  
   546  // DeleteFacePreparer prepares the DeleteFace request.
   547  func (client LargeFaceListClient) DeleteFacePreparer(ctx context.Context, largeFaceListID string, persistedFaceID uuid.UUID) (*http.Request, error) {
   548  	urlParameters := map[string]interface{}{
   549  		"Endpoint": client.Endpoint,
   550  	}
   551  
   552  	pathParameters := map[string]interface{}{
   553  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
   554  		"persistedFaceId": autorest.Encode("path", persistedFaceID),
   555  	}
   556  
   557  	preparer := autorest.CreatePreparer(
   558  		autorest.AsDelete(),
   559  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   560  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}/persistedfaces/{persistedFaceId}", pathParameters))
   561  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   562  }
   563  
   564  // DeleteFaceSender sends the DeleteFace request. The method will close the
   565  // http.Response Body if it receives an error.
   566  func (client LargeFaceListClient) DeleteFaceSender(req *http.Request) (*http.Response, error) {
   567  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   568  }
   569  
   570  // DeleteFaceResponder handles the response to the DeleteFace request. The method always
   571  // closes the http.Response Body.
   572  func (client LargeFaceListClient) DeleteFaceResponder(resp *http.Response) (result autorest.Response, err error) {
   573  	err = autorest.Respond(
   574  		resp,
   575  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   576  		autorest.ByClosing())
   577  	result.Response = resp
   578  	return
   579  }
   580  
   581  // Get retrieve a large face list’s largeFaceListId, name, userData and recognitionModel.
   582  // Parameters:
   583  // largeFaceListID - id referencing a particular large face list.
   584  // returnRecognitionModel - a value indicating whether the operation should return 'recognitionModel' in
   585  // response.
   586  func (client LargeFaceListClient) Get(ctx context.Context, largeFaceListID string, returnRecognitionModel *bool) (result LargeFaceList, err error) {
   587  	if tracing.IsEnabled() {
   588  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.Get")
   589  		defer func() {
   590  			sc := -1
   591  			if result.Response.Response != nil {
   592  				sc = result.Response.Response.StatusCode
   593  			}
   594  			tracing.EndSpan(ctx, sc, err)
   595  		}()
   596  	}
   597  	if err := validation.Validate([]validation.Validation{
   598  		{TargetValue: largeFaceListID,
   599  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   600  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   601  		return result, validation.NewError("face.LargeFaceListClient", "Get", err.Error())
   602  	}
   603  
   604  	req, err := client.GetPreparer(ctx, largeFaceListID, returnRecognitionModel)
   605  	if err != nil {
   606  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Get", nil, "Failure preparing request")
   607  		return
   608  	}
   609  
   610  	resp, err := client.GetSender(req)
   611  	if err != nil {
   612  		result.Response = autorest.Response{Response: resp}
   613  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Get", resp, "Failure sending request")
   614  		return
   615  	}
   616  
   617  	result, err = client.GetResponder(resp)
   618  	if err != nil {
   619  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Get", resp, "Failure responding to request")
   620  		return
   621  	}
   622  
   623  	return
   624  }
   625  
   626  // GetPreparer prepares the Get request.
   627  func (client LargeFaceListClient) GetPreparer(ctx context.Context, largeFaceListID string, returnRecognitionModel *bool) (*http.Request, error) {
   628  	urlParameters := map[string]interface{}{
   629  		"Endpoint": client.Endpoint,
   630  	}
   631  
   632  	pathParameters := map[string]interface{}{
   633  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
   634  	}
   635  
   636  	queryParameters := map[string]interface{}{}
   637  	if returnRecognitionModel != nil {
   638  		queryParameters["returnRecognitionModel"] = autorest.Encode("query", *returnRecognitionModel)
   639  	} else {
   640  		queryParameters["returnRecognitionModel"] = autorest.Encode("query", false)
   641  	}
   642  
   643  	preparer := autorest.CreatePreparer(
   644  		autorest.AsGet(),
   645  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   646  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}", pathParameters),
   647  		autorest.WithQueryParameters(queryParameters))
   648  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   649  }
   650  
   651  // GetSender sends the Get request. The method will close the
   652  // http.Response Body if it receives an error.
   653  func (client LargeFaceListClient) GetSender(req *http.Request) (*http.Response, error) {
   654  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   655  }
   656  
   657  // GetResponder handles the response to the Get request. The method always
   658  // closes the http.Response Body.
   659  func (client LargeFaceListClient) GetResponder(resp *http.Response) (result LargeFaceList, err error) {
   660  	err = autorest.Respond(
   661  		resp,
   662  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   663  		autorest.ByUnmarshallingJSON(&result),
   664  		autorest.ByClosing())
   665  	result.Response = autorest.Response{Response: resp}
   666  	return
   667  }
   668  
   669  // GetFace retrieve information about a persisted face (specified by persistedFaceId and its belonging
   670  // largeFaceListId).
   671  // Parameters:
   672  // largeFaceListID - id referencing a particular large face list.
   673  // persistedFaceID - id referencing a particular persistedFaceId of an existing face.
   674  func (client LargeFaceListClient) GetFace(ctx context.Context, largeFaceListID string, persistedFaceID uuid.UUID) (result PersistedFace, err error) {
   675  	if tracing.IsEnabled() {
   676  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.GetFace")
   677  		defer func() {
   678  			sc := -1
   679  			if result.Response.Response != nil {
   680  				sc = result.Response.Response.StatusCode
   681  			}
   682  			tracing.EndSpan(ctx, sc, err)
   683  		}()
   684  	}
   685  	if err := validation.Validate([]validation.Validation{
   686  		{TargetValue: largeFaceListID,
   687  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   688  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   689  		return result, validation.NewError("face.LargeFaceListClient", "GetFace", err.Error())
   690  	}
   691  
   692  	req, err := client.GetFacePreparer(ctx, largeFaceListID, persistedFaceID)
   693  	if err != nil {
   694  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "GetFace", nil, "Failure preparing request")
   695  		return
   696  	}
   697  
   698  	resp, err := client.GetFaceSender(req)
   699  	if err != nil {
   700  		result.Response = autorest.Response{Response: resp}
   701  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "GetFace", resp, "Failure sending request")
   702  		return
   703  	}
   704  
   705  	result, err = client.GetFaceResponder(resp)
   706  	if err != nil {
   707  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "GetFace", resp, "Failure responding to request")
   708  		return
   709  	}
   710  
   711  	return
   712  }
   713  
   714  // GetFacePreparer prepares the GetFace request.
   715  func (client LargeFaceListClient) GetFacePreparer(ctx context.Context, largeFaceListID string, persistedFaceID uuid.UUID) (*http.Request, error) {
   716  	urlParameters := map[string]interface{}{
   717  		"Endpoint": client.Endpoint,
   718  	}
   719  
   720  	pathParameters := map[string]interface{}{
   721  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
   722  		"persistedFaceId": autorest.Encode("path", persistedFaceID),
   723  	}
   724  
   725  	preparer := autorest.CreatePreparer(
   726  		autorest.AsGet(),
   727  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   728  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}/persistedfaces/{persistedFaceId}", pathParameters))
   729  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   730  }
   731  
   732  // GetFaceSender sends the GetFace request. The method will close the
   733  // http.Response Body if it receives an error.
   734  func (client LargeFaceListClient) GetFaceSender(req *http.Request) (*http.Response, error) {
   735  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   736  }
   737  
   738  // GetFaceResponder handles the response to the GetFace request. The method always
   739  // closes the http.Response Body.
   740  func (client LargeFaceListClient) GetFaceResponder(resp *http.Response) (result PersistedFace, err error) {
   741  	err = autorest.Respond(
   742  		resp,
   743  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   744  		autorest.ByUnmarshallingJSON(&result),
   745  		autorest.ByClosing())
   746  	result.Response = autorest.Response{Response: resp}
   747  	return
   748  }
   749  
   750  // GetTrainingStatus retrieve the training status of a large face list (completed or ongoing).
   751  // Parameters:
   752  // largeFaceListID - id referencing a particular large face list.
   753  func (client LargeFaceListClient) GetTrainingStatus(ctx context.Context, largeFaceListID string) (result TrainingStatus, err error) {
   754  	if tracing.IsEnabled() {
   755  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.GetTrainingStatus")
   756  		defer func() {
   757  			sc := -1
   758  			if result.Response.Response != nil {
   759  				sc = result.Response.Response.StatusCode
   760  			}
   761  			tracing.EndSpan(ctx, sc, err)
   762  		}()
   763  	}
   764  	if err := validation.Validate([]validation.Validation{
   765  		{TargetValue: largeFaceListID,
   766  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   767  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
   768  		return result, validation.NewError("face.LargeFaceListClient", "GetTrainingStatus", err.Error())
   769  	}
   770  
   771  	req, err := client.GetTrainingStatusPreparer(ctx, largeFaceListID)
   772  	if err != nil {
   773  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "GetTrainingStatus", nil, "Failure preparing request")
   774  		return
   775  	}
   776  
   777  	resp, err := client.GetTrainingStatusSender(req)
   778  	if err != nil {
   779  		result.Response = autorest.Response{Response: resp}
   780  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "GetTrainingStatus", resp, "Failure sending request")
   781  		return
   782  	}
   783  
   784  	result, err = client.GetTrainingStatusResponder(resp)
   785  	if err != nil {
   786  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "GetTrainingStatus", resp, "Failure responding to request")
   787  		return
   788  	}
   789  
   790  	return
   791  }
   792  
   793  // GetTrainingStatusPreparer prepares the GetTrainingStatus request.
   794  func (client LargeFaceListClient) GetTrainingStatusPreparer(ctx context.Context, largeFaceListID string) (*http.Request, error) {
   795  	urlParameters := map[string]interface{}{
   796  		"Endpoint": client.Endpoint,
   797  	}
   798  
   799  	pathParameters := map[string]interface{}{
   800  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
   801  	}
   802  
   803  	preparer := autorest.CreatePreparer(
   804  		autorest.AsGet(),
   805  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   806  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}/training", pathParameters))
   807  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   808  }
   809  
   810  // GetTrainingStatusSender sends the GetTrainingStatus request. The method will close the
   811  // http.Response Body if it receives an error.
   812  func (client LargeFaceListClient) GetTrainingStatusSender(req *http.Request) (*http.Response, error) {
   813  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   814  }
   815  
   816  // GetTrainingStatusResponder handles the response to the GetTrainingStatus request. The method always
   817  // closes the http.Response Body.
   818  func (client LargeFaceListClient) GetTrainingStatusResponder(resp *http.Response) (result TrainingStatus, err error) {
   819  	err = autorest.Respond(
   820  		resp,
   821  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   822  		autorest.ByUnmarshallingJSON(&result),
   823  		autorest.ByClosing())
   824  	result.Response = autorest.Response{Response: resp}
   825  	return
   826  }
   827  
   828  // List list large face lists’ information of largeFaceListId, name, userData and recognitionModel. <br />
   829  // To get face information inside largeFaceList use [LargeFaceList Face -
   830  // Get](https://docs.microsoft.com/rest/api/cognitiveservices/face/largefacelist/getface)<br />
   831  // * Large face lists are stored in alphabetical order of largeFaceListId.
   832  // * "start" parameter (string, optional) is a user-provided largeFaceListId value that returned entries have larger
   833  // ids by string comparison. "start" set to empty to indicate return from the first item.
   834  // * "top" parameter (int, optional) specifies the number of entries to return. A maximal of 1000 entries can be
   835  // returned in one call. To fetch more, you can specify "start" with the last returned entry’s Id of the current call.
   836  // <br />
   837  // For example, total 5 large person lists: "list1", ..., "list5".
   838  // <br /> "start=&top=" will return all 5 lists.
   839  // <br /> "start=&top=2" will return "list1", "list2".
   840  // <br /> "start=list2&top=3" will return "list3", "list4", "list5".
   841  // Parameters:
   842  // returnRecognitionModel - a value indicating whether the operation should return 'recognitionModel' in
   843  // response.
   844  func (client LargeFaceListClient) List(ctx context.Context, returnRecognitionModel *bool) (result ListLargeFaceList, err error) {
   845  	if tracing.IsEnabled() {
   846  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.List")
   847  		defer func() {
   848  			sc := -1
   849  			if result.Response.Response != nil {
   850  				sc = result.Response.Response.StatusCode
   851  			}
   852  			tracing.EndSpan(ctx, sc, err)
   853  		}()
   854  	}
   855  	req, err := client.ListPreparer(ctx, returnRecognitionModel)
   856  	if err != nil {
   857  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "List", nil, "Failure preparing request")
   858  		return
   859  	}
   860  
   861  	resp, err := client.ListSender(req)
   862  	if err != nil {
   863  		result.Response = autorest.Response{Response: resp}
   864  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "List", resp, "Failure sending request")
   865  		return
   866  	}
   867  
   868  	result, err = client.ListResponder(resp)
   869  	if err != nil {
   870  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "List", resp, "Failure responding to request")
   871  		return
   872  	}
   873  
   874  	return
   875  }
   876  
   877  // ListPreparer prepares the List request.
   878  func (client LargeFaceListClient) ListPreparer(ctx context.Context, returnRecognitionModel *bool) (*http.Request, error) {
   879  	urlParameters := map[string]interface{}{
   880  		"Endpoint": client.Endpoint,
   881  	}
   882  
   883  	queryParameters := map[string]interface{}{}
   884  	if returnRecognitionModel != nil {
   885  		queryParameters["returnRecognitionModel"] = autorest.Encode("query", *returnRecognitionModel)
   886  	} else {
   887  		queryParameters["returnRecognitionModel"] = autorest.Encode("query", false)
   888  	}
   889  
   890  	preparer := autorest.CreatePreparer(
   891  		autorest.AsGet(),
   892  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   893  		autorest.WithPath("/largefacelists"),
   894  		autorest.WithQueryParameters(queryParameters))
   895  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   896  }
   897  
   898  // ListSender sends the List request. The method will close the
   899  // http.Response Body if it receives an error.
   900  func (client LargeFaceListClient) ListSender(req *http.Request) (*http.Response, error) {
   901  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   902  }
   903  
   904  // ListResponder handles the response to the List request. The method always
   905  // closes the http.Response Body.
   906  func (client LargeFaceListClient) ListResponder(resp *http.Response) (result ListLargeFaceList, err error) {
   907  	err = autorest.Respond(
   908  		resp,
   909  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   910  		autorest.ByUnmarshallingJSON(&result.Value),
   911  		autorest.ByClosing())
   912  	result.Response = autorest.Response{Response: resp}
   913  	return
   914  }
   915  
   916  // ListFaces list all faces in a large face list, and retrieve face information (including userData and
   917  // persistedFaceIds of registered faces of the face).
   918  // Parameters:
   919  // largeFaceListID - id referencing a particular large face list.
   920  // start - starting face id to return (used to list a range of faces).
   921  // top - number of faces to return starting with the face id indicated by the 'start' parameter.
   922  func (client LargeFaceListClient) ListFaces(ctx context.Context, largeFaceListID string, start string, top *int32) (result ListPersistedFace, err error) {
   923  	if tracing.IsEnabled() {
   924  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.ListFaces")
   925  		defer func() {
   926  			sc := -1
   927  			if result.Response.Response != nil {
   928  				sc = result.Response.Response.StatusCode
   929  			}
   930  			tracing.EndSpan(ctx, sc, err)
   931  		}()
   932  	}
   933  	if err := validation.Validate([]validation.Validation{
   934  		{TargetValue: largeFaceListID,
   935  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
   936  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}},
   937  		{TargetValue: top,
   938  			Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false,
   939  				Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMaximum, Rule: int64(1000), Chain: nil},
   940  					{Target: "top", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   941  				}}}}}); err != nil {
   942  		return result, validation.NewError("face.LargeFaceListClient", "ListFaces", err.Error())
   943  	}
   944  
   945  	req, err := client.ListFacesPreparer(ctx, largeFaceListID, start, top)
   946  	if err != nil {
   947  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "ListFaces", nil, "Failure preparing request")
   948  		return
   949  	}
   950  
   951  	resp, err := client.ListFacesSender(req)
   952  	if err != nil {
   953  		result.Response = autorest.Response{Response: resp}
   954  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "ListFaces", resp, "Failure sending request")
   955  		return
   956  	}
   957  
   958  	result, err = client.ListFacesResponder(resp)
   959  	if err != nil {
   960  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "ListFaces", resp, "Failure responding to request")
   961  		return
   962  	}
   963  
   964  	return
   965  }
   966  
   967  // ListFacesPreparer prepares the ListFaces request.
   968  func (client LargeFaceListClient) ListFacesPreparer(ctx context.Context, largeFaceListID string, start string, top *int32) (*http.Request, error) {
   969  	urlParameters := map[string]interface{}{
   970  		"Endpoint": client.Endpoint,
   971  	}
   972  
   973  	pathParameters := map[string]interface{}{
   974  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
   975  	}
   976  
   977  	queryParameters := map[string]interface{}{}
   978  	if len(start) > 0 {
   979  		queryParameters["start"] = autorest.Encode("query", start)
   980  	}
   981  	if top != nil {
   982  		queryParameters["top"] = autorest.Encode("query", *top)
   983  	}
   984  
   985  	preparer := autorest.CreatePreparer(
   986  		autorest.AsGet(),
   987  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
   988  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}/persistedfaces", pathParameters),
   989  		autorest.WithQueryParameters(queryParameters))
   990  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   991  }
   992  
   993  // ListFacesSender sends the ListFaces request. The method will close the
   994  // http.Response Body if it receives an error.
   995  func (client LargeFaceListClient) ListFacesSender(req *http.Request) (*http.Response, error) {
   996  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   997  }
   998  
   999  // ListFacesResponder handles the response to the ListFaces request. The method always
  1000  // closes the http.Response Body.
  1001  func (client LargeFaceListClient) ListFacesResponder(resp *http.Response) (result ListPersistedFace, err error) {
  1002  	err = autorest.Respond(
  1003  		resp,
  1004  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1005  		autorest.ByUnmarshallingJSON(&result.Value),
  1006  		autorest.ByClosing())
  1007  	result.Response = autorest.Response{Response: resp}
  1008  	return
  1009  }
  1010  
  1011  // Train queue a large face list training task, the training task may not be started immediately.
  1012  // Parameters:
  1013  // largeFaceListID - id referencing a particular large face list.
  1014  func (client LargeFaceListClient) Train(ctx context.Context, largeFaceListID string) (result autorest.Response, err error) {
  1015  	if tracing.IsEnabled() {
  1016  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.Train")
  1017  		defer func() {
  1018  			sc := -1
  1019  			if result.Response != nil {
  1020  				sc = result.Response.StatusCode
  1021  			}
  1022  			tracing.EndSpan(ctx, sc, err)
  1023  		}()
  1024  	}
  1025  	if err := validation.Validate([]validation.Validation{
  1026  		{TargetValue: largeFaceListID,
  1027  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
  1028  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
  1029  		return result, validation.NewError("face.LargeFaceListClient", "Train", err.Error())
  1030  	}
  1031  
  1032  	req, err := client.TrainPreparer(ctx, largeFaceListID)
  1033  	if err != nil {
  1034  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Train", nil, "Failure preparing request")
  1035  		return
  1036  	}
  1037  
  1038  	resp, err := client.TrainSender(req)
  1039  	if err != nil {
  1040  		result.Response = resp
  1041  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Train", resp, "Failure sending request")
  1042  		return
  1043  	}
  1044  
  1045  	result, err = client.TrainResponder(resp)
  1046  	if err != nil {
  1047  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Train", resp, "Failure responding to request")
  1048  		return
  1049  	}
  1050  
  1051  	return
  1052  }
  1053  
  1054  // TrainPreparer prepares the Train request.
  1055  func (client LargeFaceListClient) TrainPreparer(ctx context.Context, largeFaceListID string) (*http.Request, error) {
  1056  	urlParameters := map[string]interface{}{
  1057  		"Endpoint": client.Endpoint,
  1058  	}
  1059  
  1060  	pathParameters := map[string]interface{}{
  1061  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
  1062  	}
  1063  
  1064  	preparer := autorest.CreatePreparer(
  1065  		autorest.AsPost(),
  1066  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
  1067  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}/train", pathParameters))
  1068  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1069  }
  1070  
  1071  // TrainSender sends the Train request. The method will close the
  1072  // http.Response Body if it receives an error.
  1073  func (client LargeFaceListClient) TrainSender(req *http.Request) (*http.Response, error) {
  1074  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1075  }
  1076  
  1077  // TrainResponder handles the response to the Train request. The method always
  1078  // closes the http.Response Body.
  1079  func (client LargeFaceListClient) TrainResponder(resp *http.Response) (result autorest.Response, err error) {
  1080  	err = autorest.Respond(
  1081  		resp,
  1082  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1083  		autorest.ByClosing())
  1084  	result.Response = resp
  1085  	return
  1086  }
  1087  
  1088  // Update update information of a large face list.
  1089  // Parameters:
  1090  // largeFaceListID - id referencing a particular large face list.
  1091  // body - request body for updating a large face list.
  1092  func (client LargeFaceListClient) Update(ctx context.Context, largeFaceListID string, body NameAndUserDataContract) (result autorest.Response, err error) {
  1093  	if tracing.IsEnabled() {
  1094  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.Update")
  1095  		defer func() {
  1096  			sc := -1
  1097  			if result.Response != nil {
  1098  				sc = result.Response.StatusCode
  1099  			}
  1100  			tracing.EndSpan(ctx, sc, err)
  1101  		}()
  1102  	}
  1103  	if err := validation.Validate([]validation.Validation{
  1104  		{TargetValue: largeFaceListID,
  1105  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
  1106  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
  1107  		return result, validation.NewError("face.LargeFaceListClient", "Update", err.Error())
  1108  	}
  1109  
  1110  	req, err := client.UpdatePreparer(ctx, largeFaceListID, body)
  1111  	if err != nil {
  1112  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Update", nil, "Failure preparing request")
  1113  		return
  1114  	}
  1115  
  1116  	resp, err := client.UpdateSender(req)
  1117  	if err != nil {
  1118  		result.Response = resp
  1119  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Update", resp, "Failure sending request")
  1120  		return
  1121  	}
  1122  
  1123  	result, err = client.UpdateResponder(resp)
  1124  	if err != nil {
  1125  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "Update", resp, "Failure responding to request")
  1126  		return
  1127  	}
  1128  
  1129  	return
  1130  }
  1131  
  1132  // UpdatePreparer prepares the Update request.
  1133  func (client LargeFaceListClient) UpdatePreparer(ctx context.Context, largeFaceListID string, body NameAndUserDataContract) (*http.Request, error) {
  1134  	urlParameters := map[string]interface{}{
  1135  		"Endpoint": client.Endpoint,
  1136  	}
  1137  
  1138  	pathParameters := map[string]interface{}{
  1139  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
  1140  	}
  1141  
  1142  	preparer := autorest.CreatePreparer(
  1143  		autorest.AsContentType("application/json; charset=utf-8"),
  1144  		autorest.AsPatch(),
  1145  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
  1146  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}", pathParameters),
  1147  		autorest.WithJSON(body))
  1148  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1149  }
  1150  
  1151  // UpdateSender sends the Update request. The method will close the
  1152  // http.Response Body if it receives an error.
  1153  func (client LargeFaceListClient) UpdateSender(req *http.Request) (*http.Response, error) {
  1154  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1155  }
  1156  
  1157  // UpdateResponder handles the response to the Update request. The method always
  1158  // closes the http.Response Body.
  1159  func (client LargeFaceListClient) UpdateResponder(resp *http.Response) (result autorest.Response, err error) {
  1160  	err = autorest.Respond(
  1161  		resp,
  1162  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1163  		autorest.ByClosing())
  1164  	result.Response = resp
  1165  	return
  1166  }
  1167  
  1168  // UpdateFace update a persisted face's userData field.
  1169  // Parameters:
  1170  // largeFaceListID - id referencing a particular large face list.
  1171  // persistedFaceID - id referencing a particular persistedFaceId of an existing face.
  1172  // body - request body for updating persisted face.
  1173  func (client LargeFaceListClient) UpdateFace(ctx context.Context, largeFaceListID string, persistedFaceID uuid.UUID, body UpdateFaceRequest) (result autorest.Response, err error) {
  1174  	if tracing.IsEnabled() {
  1175  		ctx = tracing.StartSpan(ctx, fqdn+"/LargeFaceListClient.UpdateFace")
  1176  		defer func() {
  1177  			sc := -1
  1178  			if result.Response != nil {
  1179  				sc = result.Response.StatusCode
  1180  			}
  1181  			tracing.EndSpan(ctx, sc, err)
  1182  		}()
  1183  	}
  1184  	if err := validation.Validate([]validation.Validation{
  1185  		{TargetValue: largeFaceListID,
  1186  			Constraints: []validation.Constraint{{Target: "largeFaceListID", Name: validation.MaxLength, Rule: 64, Chain: nil},
  1187  				{Target: "largeFaceListID", Name: validation.Pattern, Rule: `^[a-z0-9-_]+$`, Chain: nil}}}}); err != nil {
  1188  		return result, validation.NewError("face.LargeFaceListClient", "UpdateFace", err.Error())
  1189  	}
  1190  
  1191  	req, err := client.UpdateFacePreparer(ctx, largeFaceListID, persistedFaceID, body)
  1192  	if err != nil {
  1193  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "UpdateFace", nil, "Failure preparing request")
  1194  		return
  1195  	}
  1196  
  1197  	resp, err := client.UpdateFaceSender(req)
  1198  	if err != nil {
  1199  		result.Response = resp
  1200  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "UpdateFace", resp, "Failure sending request")
  1201  		return
  1202  	}
  1203  
  1204  	result, err = client.UpdateFaceResponder(resp)
  1205  	if err != nil {
  1206  		err = autorest.NewErrorWithError(err, "face.LargeFaceListClient", "UpdateFace", resp, "Failure responding to request")
  1207  		return
  1208  	}
  1209  
  1210  	return
  1211  }
  1212  
  1213  // UpdateFacePreparer prepares the UpdateFace request.
  1214  func (client LargeFaceListClient) UpdateFacePreparer(ctx context.Context, largeFaceListID string, persistedFaceID uuid.UUID, body UpdateFaceRequest) (*http.Request, error) {
  1215  	urlParameters := map[string]interface{}{
  1216  		"Endpoint": client.Endpoint,
  1217  	}
  1218  
  1219  	pathParameters := map[string]interface{}{
  1220  		"largeFaceListId": autorest.Encode("path", largeFaceListID),
  1221  		"persistedFaceId": autorest.Encode("path", persistedFaceID),
  1222  	}
  1223  
  1224  	preparer := autorest.CreatePreparer(
  1225  		autorest.AsContentType("application/json; charset=utf-8"),
  1226  		autorest.AsPatch(),
  1227  		autorest.WithCustomBaseURL("{Endpoint}/face/v1.0", urlParameters),
  1228  		autorest.WithPathParameters("/largefacelists/{largeFaceListId}/persistedfaces/{persistedFaceId}", pathParameters),
  1229  		autorest.WithJSON(body))
  1230  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1231  }
  1232  
  1233  // UpdateFaceSender sends the UpdateFace request. The method will close the
  1234  // http.Response Body if it receives an error.
  1235  func (client LargeFaceListClient) UpdateFaceSender(req *http.Request) (*http.Response, error) {
  1236  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1237  }
  1238  
  1239  // UpdateFaceResponder handles the response to the UpdateFace request. The method always
  1240  // closes the http.Response Body.
  1241  func (client LargeFaceListClient) UpdateFaceResponder(resp *http.Response) (result autorest.Response, err error) {
  1242  	err = autorest.Respond(
  1243  		resp,
  1244  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1245  		autorest.ByClosing())
  1246  	result.Response = resp
  1247  	return
  1248  }
  1249  

View as plain text