reviews.go

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

     1  package contentmoderator
     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  	"io"
    16  	"net/http"
    17  )
    18  
    19  // ReviewsClient is the you use the API to scan your content as it is generated. Content Moderator then processes your
    20  // content and sends the results along with relevant information either back to your systems or to the built-in review
    21  // tool. You can use this information to take decisions e.g. take it down, send to human judge, etc.
    22  //
    23  // When using the API, images need to have a minimum of 128 pixels and a maximum file size of 4MB.
    24  // Text can be at most 1024 characters long.
    25  // If the content passed to the text API or the image API exceeds the size limits, the API will return an error code
    26  // that informs about the issue.
    27  type ReviewsClient struct {
    28  	BaseClient
    29  }
    30  
    31  // NewReviewsClient creates an instance of the ReviewsClient client.
    32  func NewReviewsClient(endpoint string) ReviewsClient {
    33  	return ReviewsClient{New(endpoint)}
    34  }
    35  
    36  // AddVideoFrame the reviews created would show up for Reviewers on your team. As Reviewers complete reviewing, results
    37  // of the Review would be POSTED (i.e. HTTP POST) on the specified CallBackEndpoint.
    38  //
    39  // <h3>CallBack Schemas </h3>
    40  // <h4>Review Completion CallBack Sample</h4>
    41  // <p>
    42  // {<br/>
    43  // "ReviewId": "<Review Id>",<br/>
    44  // "ModifiedOn": "2016-10-11T22:36:32.9934851Z",<br/>
    45  // "ModifiedBy": "<Name of the Reviewer>",<br/>
    46  // "CallBackType": "Review",<br/>
    47  // "ContentId": "<The ContentId that was specified input>",<br/>
    48  // "Metadata": {<br/>
    49  // "adultscore": "0.xxx",<br/>
    50  // "a": "False",<br/>
    51  // "racyscore": "0.xxx",<br/>
    52  // "r": "True"<br/>
    53  // },<br/>
    54  // "ReviewerResultTags": {<br/>
    55  // "a": "False",<br/>
    56  // "r": "True"<br/>
    57  // }<br/>
    58  // }<br/>
    59  //
    60  // </p>.
    61  // Parameters:
    62  // teamName - your team name.
    63  // reviewID - id of the review.
    64  // timescale - timescale of the video you are adding frames to.
    65  func (client ReviewsClient) AddVideoFrame(ctx context.Context, teamName string, reviewID string, timescale *int32) (result autorest.Response, err error) {
    66  	if tracing.IsEnabled() {
    67  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.AddVideoFrame")
    68  		defer func() {
    69  			sc := -1
    70  			if result.Response != nil {
    71  				sc = result.Response.StatusCode
    72  			}
    73  			tracing.EndSpan(ctx, sc, err)
    74  		}()
    75  	}
    76  	req, err := client.AddVideoFramePreparer(ctx, teamName, reviewID, timescale)
    77  	if err != nil {
    78  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoFrame", nil, "Failure preparing request")
    79  		return
    80  	}
    81  
    82  	resp, err := client.AddVideoFrameSender(req)
    83  	if err != nil {
    84  		result.Response = resp
    85  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoFrame", resp, "Failure sending request")
    86  		return
    87  	}
    88  
    89  	result, err = client.AddVideoFrameResponder(resp)
    90  	if err != nil {
    91  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoFrame", resp, "Failure responding to request")
    92  		return
    93  	}
    94  
    95  	return
    96  }
    97  
    98  // AddVideoFramePreparer prepares the AddVideoFrame request.
    99  func (client ReviewsClient) AddVideoFramePreparer(ctx context.Context, teamName string, reviewID string, timescale *int32) (*http.Request, error) {
   100  	urlParameters := map[string]interface{}{
   101  		"Endpoint": client.Endpoint,
   102  	}
   103  
   104  	pathParameters := map[string]interface{}{
   105  		"reviewId": autorest.Encode("path", reviewID),
   106  		"teamName": autorest.Encode("path", teamName),
   107  	}
   108  
   109  	queryParameters := map[string]interface{}{}
   110  	if timescale != nil {
   111  		queryParameters["timescale"] = autorest.Encode("query", *timescale)
   112  	}
   113  
   114  	preparer := autorest.CreatePreparer(
   115  		autorest.AsPost(),
   116  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   117  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews/{reviewId}/frames", pathParameters),
   118  		autorest.WithQueryParameters(queryParameters))
   119  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   120  }
   121  
   122  // AddVideoFrameSender sends the AddVideoFrame request. The method will close the
   123  // http.Response Body if it receives an error.
   124  func (client ReviewsClient) AddVideoFrameSender(req *http.Request) (*http.Response, error) {
   125  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   126  }
   127  
   128  // AddVideoFrameResponder handles the response to the AddVideoFrame request. The method always
   129  // closes the http.Response Body.
   130  func (client ReviewsClient) AddVideoFrameResponder(resp *http.Response) (result autorest.Response, err error) {
   131  	err = autorest.Respond(
   132  		resp,
   133  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   134  		autorest.ByClosing())
   135  	result.Response = resp
   136  	return
   137  }
   138  
   139  // AddVideoFrameStream use this method to add frames for a video review.Timescale: This parameter is a factor which is
   140  // used to convert the timestamp on a frame into milliseconds. Timescale is provided in the output of the Content
   141  // Moderator video media processor on the Azure Media Services platform.Timescale in the Video Moderation output is
   142  // Ticks/Second.
   143  // Parameters:
   144  // contentType - the content type.
   145  // teamName - your team name.
   146  // reviewID - id of the review.
   147  // frameImageZip - zip file containing frame images.
   148  // frameMetadata - metadata of the frame.
   149  // timescale - timescale of the video .
   150  func (client ReviewsClient) AddVideoFrameStream(ctx context.Context, contentType string, teamName string, reviewID string, frameImageZip io.ReadCloser, frameMetadata string, timescale *int32) (result autorest.Response, err error) {
   151  	if tracing.IsEnabled() {
   152  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.AddVideoFrameStream")
   153  		defer func() {
   154  			sc := -1
   155  			if result.Response != nil {
   156  				sc = result.Response.StatusCode
   157  			}
   158  			tracing.EndSpan(ctx, sc, err)
   159  		}()
   160  	}
   161  	req, err := client.AddVideoFrameStreamPreparer(ctx, contentType, teamName, reviewID, frameImageZip, frameMetadata, timescale)
   162  	if err != nil {
   163  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoFrameStream", nil, "Failure preparing request")
   164  		return
   165  	}
   166  
   167  	resp, err := client.AddVideoFrameStreamSender(req)
   168  	if err != nil {
   169  		result.Response = resp
   170  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoFrameStream", resp, "Failure sending request")
   171  		return
   172  	}
   173  
   174  	result, err = client.AddVideoFrameStreamResponder(resp)
   175  	if err != nil {
   176  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoFrameStream", resp, "Failure responding to request")
   177  		return
   178  	}
   179  
   180  	return
   181  }
   182  
   183  // AddVideoFrameStreamPreparer prepares the AddVideoFrameStream request.
   184  func (client ReviewsClient) AddVideoFrameStreamPreparer(ctx context.Context, contentType string, teamName string, reviewID string, frameImageZip io.ReadCloser, frameMetadata string, timescale *int32) (*http.Request, error) {
   185  	urlParameters := map[string]interface{}{
   186  		"Endpoint": client.Endpoint,
   187  	}
   188  
   189  	pathParameters := map[string]interface{}{
   190  		"reviewId": autorest.Encode("path", reviewID),
   191  		"teamName": autorest.Encode("path", teamName),
   192  	}
   193  
   194  	queryParameters := map[string]interface{}{}
   195  	if timescale != nil {
   196  		queryParameters["timescale"] = autorest.Encode("query", *timescale)
   197  	}
   198  
   199  	formDataParameters := map[string]interface{}{
   200  		"frameImageZip": frameImageZip,
   201  		"frameMetadata": frameMetadata,
   202  	}
   203  
   204  	preparer := autorest.CreatePreparer(
   205  		autorest.AsPost(),
   206  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   207  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews/{reviewId}/frames", pathParameters),
   208  		autorest.WithQueryParameters(queryParameters),
   209  		autorest.WithMultiPartFormData(formDataParameters),
   210  		autorest.WithHeader("Content-Type", autorest.String(contentType)))
   211  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   212  }
   213  
   214  // AddVideoFrameStreamSender sends the AddVideoFrameStream request. The method will close the
   215  // http.Response Body if it receives an error.
   216  func (client ReviewsClient) AddVideoFrameStreamSender(req *http.Request) (*http.Response, error) {
   217  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   218  }
   219  
   220  // AddVideoFrameStreamResponder handles the response to the AddVideoFrameStream request. The method always
   221  // closes the http.Response Body.
   222  func (client ReviewsClient) AddVideoFrameStreamResponder(resp *http.Response) (result autorest.Response, err error) {
   223  	err = autorest.Respond(
   224  		resp,
   225  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   226  		autorest.ByClosing())
   227  	result.Response = resp
   228  	return
   229  }
   230  
   231  // AddVideoFrameURL use this method to add frames for a video review.Timescale: This parameter is a factor which is
   232  // used to convert the timestamp on a frame into milliseconds. Timescale is provided in the output of the Content
   233  // Moderator video media processor on the Azure Media Services platform.Timescale in the Video Moderation output is
   234  // Ticks/Second.
   235  // Parameters:
   236  // contentType - the content type.
   237  // teamName - your team name.
   238  // reviewID - id of the review.
   239  // videoFrameBody - body for add video frames API
   240  // timescale - timescale of the video.
   241  func (client ReviewsClient) AddVideoFrameURL(ctx context.Context, contentType string, teamName string, reviewID string, videoFrameBody []VideoFrameBodyItem, timescale *int32) (result autorest.Response, err error) {
   242  	if tracing.IsEnabled() {
   243  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.AddVideoFrameURL")
   244  		defer func() {
   245  			sc := -1
   246  			if result.Response != nil {
   247  				sc = result.Response.StatusCode
   248  			}
   249  			tracing.EndSpan(ctx, sc, err)
   250  		}()
   251  	}
   252  	if err := validation.Validate([]validation.Validation{
   253  		{TargetValue: videoFrameBody,
   254  			Constraints: []validation.Constraint{{Target: "videoFrameBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   255  		return result, validation.NewError("contentmoderator.ReviewsClient", "AddVideoFrameURL", err.Error())
   256  	}
   257  
   258  	req, err := client.AddVideoFrameURLPreparer(ctx, contentType, teamName, reviewID, videoFrameBody, timescale)
   259  	if err != nil {
   260  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoFrameURL", nil, "Failure preparing request")
   261  		return
   262  	}
   263  
   264  	resp, err := client.AddVideoFrameURLSender(req)
   265  	if err != nil {
   266  		result.Response = resp
   267  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoFrameURL", resp, "Failure sending request")
   268  		return
   269  	}
   270  
   271  	result, err = client.AddVideoFrameURLResponder(resp)
   272  	if err != nil {
   273  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoFrameURL", resp, "Failure responding to request")
   274  		return
   275  	}
   276  
   277  	return
   278  }
   279  
   280  // AddVideoFrameURLPreparer prepares the AddVideoFrameURL request.
   281  func (client ReviewsClient) AddVideoFrameURLPreparer(ctx context.Context, contentType string, teamName string, reviewID string, videoFrameBody []VideoFrameBodyItem, timescale *int32) (*http.Request, error) {
   282  	urlParameters := map[string]interface{}{
   283  		"Endpoint": client.Endpoint,
   284  	}
   285  
   286  	pathParameters := map[string]interface{}{
   287  		"reviewId": autorest.Encode("path", reviewID),
   288  		"teamName": autorest.Encode("path", teamName),
   289  	}
   290  
   291  	queryParameters := map[string]interface{}{}
   292  	if timescale != nil {
   293  		queryParameters["timescale"] = autorest.Encode("query", *timescale)
   294  	}
   295  
   296  	preparer := autorest.CreatePreparer(
   297  		autorest.AsContentType("application/json; charset=utf-8"),
   298  		autorest.AsPost(),
   299  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   300  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews/{reviewId}/frames", pathParameters),
   301  		autorest.WithJSON(videoFrameBody),
   302  		autorest.WithQueryParameters(queryParameters),
   303  		autorest.WithHeader("Content-Type", autorest.String(contentType)))
   304  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   305  }
   306  
   307  // AddVideoFrameURLSender sends the AddVideoFrameURL request. The method will close the
   308  // http.Response Body if it receives an error.
   309  func (client ReviewsClient) AddVideoFrameURLSender(req *http.Request) (*http.Response, error) {
   310  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   311  }
   312  
   313  // AddVideoFrameURLResponder handles the response to the AddVideoFrameURL request. The method always
   314  // closes the http.Response Body.
   315  func (client ReviewsClient) AddVideoFrameURLResponder(resp *http.Response) (result autorest.Response, err error) {
   316  	err = autorest.Respond(
   317  		resp,
   318  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   319  		autorest.ByClosing())
   320  	result.Response = resp
   321  	return
   322  }
   323  
   324  // AddVideoTranscript this API adds a transcript file (text version of all the words spoken in a video) to a video
   325  // review. The file should be a valid WebVTT format.
   326  // Parameters:
   327  // teamName - your team name.
   328  // reviewID - id of the review.
   329  // vttfile - transcript file of the video.
   330  func (client ReviewsClient) AddVideoTranscript(ctx context.Context, teamName string, reviewID string, vttfile io.ReadCloser) (result autorest.Response, err error) {
   331  	if tracing.IsEnabled() {
   332  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.AddVideoTranscript")
   333  		defer func() {
   334  			sc := -1
   335  			if result.Response != nil {
   336  				sc = result.Response.StatusCode
   337  			}
   338  			tracing.EndSpan(ctx, sc, err)
   339  		}()
   340  	}
   341  	req, err := client.AddVideoTranscriptPreparer(ctx, teamName, reviewID, vttfile)
   342  	if err != nil {
   343  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoTranscript", nil, "Failure preparing request")
   344  		return
   345  	}
   346  
   347  	resp, err := client.AddVideoTranscriptSender(req)
   348  	if err != nil {
   349  		result.Response = resp
   350  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoTranscript", resp, "Failure sending request")
   351  		return
   352  	}
   353  
   354  	result, err = client.AddVideoTranscriptResponder(resp)
   355  	if err != nil {
   356  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoTranscript", resp, "Failure responding to request")
   357  		return
   358  	}
   359  
   360  	return
   361  }
   362  
   363  // AddVideoTranscriptPreparer prepares the AddVideoTranscript request.
   364  func (client ReviewsClient) AddVideoTranscriptPreparer(ctx context.Context, teamName string, reviewID string, vttfile io.ReadCloser) (*http.Request, error) {
   365  	urlParameters := map[string]interface{}{
   366  		"Endpoint": client.Endpoint,
   367  	}
   368  
   369  	pathParameters := map[string]interface{}{
   370  		"reviewId": autorest.Encode("path", reviewID),
   371  		"teamName": autorest.Encode("path", teamName),
   372  	}
   373  
   374  	preparer := autorest.CreatePreparer(
   375  		autorest.AsContentType("text/plain"),
   376  		autorest.AsPut(),
   377  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   378  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews/{reviewId}/transcript", pathParameters),
   379  		autorest.WithFile(vttfile),
   380  		autorest.WithHeader("Content-Type", "text/plain"))
   381  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   382  }
   383  
   384  // AddVideoTranscriptSender sends the AddVideoTranscript request. The method will close the
   385  // http.Response Body if it receives an error.
   386  func (client ReviewsClient) AddVideoTranscriptSender(req *http.Request) (*http.Response, error) {
   387  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   388  }
   389  
   390  // AddVideoTranscriptResponder handles the response to the AddVideoTranscript request. The method always
   391  // closes the http.Response Body.
   392  func (client ReviewsClient) AddVideoTranscriptResponder(resp *http.Response) (result autorest.Response, err error) {
   393  	err = autorest.Respond(
   394  		resp,
   395  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   396  		autorest.ByClosing())
   397  	result.Response = resp
   398  	return
   399  }
   400  
   401  // AddVideoTranscriptModerationResult this API adds a transcript screen text result file for a video review. Transcript
   402  // screen text result file is a result of Screen Text API . In order to generate transcript screen text result file , a
   403  // transcript file has to be screened for profanity using Screen Text API.
   404  // Parameters:
   405  // contentType - the content type.
   406  // teamName - your team name.
   407  // reviewID - id of the review.
   408  // transcriptModerationBody - body for add video transcript moderation result API
   409  func (client ReviewsClient) AddVideoTranscriptModerationResult(ctx context.Context, contentType string, teamName string, reviewID string, transcriptModerationBody []TranscriptModerationBodyItem) (result autorest.Response, err error) {
   410  	if tracing.IsEnabled() {
   411  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.AddVideoTranscriptModerationResult")
   412  		defer func() {
   413  			sc := -1
   414  			if result.Response != nil {
   415  				sc = result.Response.StatusCode
   416  			}
   417  			tracing.EndSpan(ctx, sc, err)
   418  		}()
   419  	}
   420  	if err := validation.Validate([]validation.Validation{
   421  		{TargetValue: transcriptModerationBody,
   422  			Constraints: []validation.Constraint{{Target: "transcriptModerationBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   423  		return result, validation.NewError("contentmoderator.ReviewsClient", "AddVideoTranscriptModerationResult", err.Error())
   424  	}
   425  
   426  	req, err := client.AddVideoTranscriptModerationResultPreparer(ctx, contentType, teamName, reviewID, transcriptModerationBody)
   427  	if err != nil {
   428  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoTranscriptModerationResult", nil, "Failure preparing request")
   429  		return
   430  	}
   431  
   432  	resp, err := client.AddVideoTranscriptModerationResultSender(req)
   433  	if err != nil {
   434  		result.Response = resp
   435  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoTranscriptModerationResult", resp, "Failure sending request")
   436  		return
   437  	}
   438  
   439  	result, err = client.AddVideoTranscriptModerationResultResponder(resp)
   440  	if err != nil {
   441  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "AddVideoTranscriptModerationResult", resp, "Failure responding to request")
   442  		return
   443  	}
   444  
   445  	return
   446  }
   447  
   448  // AddVideoTranscriptModerationResultPreparer prepares the AddVideoTranscriptModerationResult request.
   449  func (client ReviewsClient) AddVideoTranscriptModerationResultPreparer(ctx context.Context, contentType string, teamName string, reviewID string, transcriptModerationBody []TranscriptModerationBodyItem) (*http.Request, error) {
   450  	urlParameters := map[string]interface{}{
   451  		"Endpoint": client.Endpoint,
   452  	}
   453  
   454  	pathParameters := map[string]interface{}{
   455  		"reviewId": autorest.Encode("path", reviewID),
   456  		"teamName": autorest.Encode("path", teamName),
   457  	}
   458  
   459  	preparer := autorest.CreatePreparer(
   460  		autorest.AsContentType("application/json; charset=utf-8"),
   461  		autorest.AsPut(),
   462  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   463  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews/{reviewId}/transcriptmoderationresult", pathParameters),
   464  		autorest.WithJSON(transcriptModerationBody),
   465  		autorest.WithHeader("Content-Type", autorest.String(contentType)))
   466  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   467  }
   468  
   469  // AddVideoTranscriptModerationResultSender sends the AddVideoTranscriptModerationResult request. The method will close the
   470  // http.Response Body if it receives an error.
   471  func (client ReviewsClient) AddVideoTranscriptModerationResultSender(req *http.Request) (*http.Response, error) {
   472  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   473  }
   474  
   475  // AddVideoTranscriptModerationResultResponder handles the response to the AddVideoTranscriptModerationResult request. The method always
   476  // closes the http.Response Body.
   477  func (client ReviewsClient) AddVideoTranscriptModerationResultResponder(resp *http.Response) (result autorest.Response, err error) {
   478  	err = autorest.Respond(
   479  		resp,
   480  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   481  		autorest.ByClosing())
   482  	result.Response = resp
   483  	return
   484  }
   485  
   486  // CreateJob a job Id will be returned for the content posted on this endpoint.
   487  //
   488  // Once the content is evaluated against the Workflow provided the review will be created or ignored based on the
   489  // workflow expression.
   490  //
   491  // <h3>CallBack Schemas </h3>
   492  //
   493  // <p>
   494  // <h4>Job Completion CallBack Sample</h4><br/>
   495  //
   496  // {<br/>
   497  // "JobId": "<Job Id>,<br/>
   498  // "ReviewId": "<Review Id, if the Job resulted in a Review to be created>",<br/>
   499  // "WorkFlowId": "default",<br/>
   500  // "Status": "<This will be one of Complete, InProgress, Error>",<br/>
   501  // "ContentType": "Image",<br/>
   502  // "ContentId": "<This is the ContentId that was specified on input>",<br/>
   503  // "CallBackType": "Job",<br/>
   504  // "Metadata": {<br/>
   505  // "adultscore": "0.xxx",<br/>
   506  // "a": "False",<br/>
   507  // "racyscore": "0.xxx",<br/>
   508  // "r": "True"<br/>
   509  // }<br/>
   510  // }<br/>
   511  //
   512  // </p>
   513  // <p>
   514  // <h4>Review Completion CallBack Sample</h4><br/>
   515  //
   516  // {
   517  // "ReviewId": "<Review Id>",<br/>
   518  // "ModifiedOn": "2016-10-11T22:36:32.9934851Z",<br/>
   519  // "ModifiedBy": "<Name of the Reviewer>",<br/>
   520  // "CallBackType": "Review",<br/>
   521  // "ContentId": "<The ContentId that was specified input>",<br/>
   522  // "Metadata": {<br/>
   523  // "adultscore": "0.xxx",
   524  // "a": "False",<br/>
   525  // "racyscore": "0.xxx",<br/>
   526  // "r": "True"<br/>
   527  // },<br/>
   528  // "ReviewerResultTags": {<br/>
   529  // "a": "False",<br/>
   530  // "r": "True"<br/>
   531  // }<br/>
   532  // }<br/>
   533  //
   534  // </p>.
   535  // Parameters:
   536  // teamName - your team name.
   537  // contentType - image, Text or Video.
   538  // contentID - id/Name to identify the content submitted.
   539  // workflowName - workflow Name that you want to invoke.
   540  // jobContentType - the content type.
   541  // content - content to evaluate.
   542  // callBackEndpoint - callback endpoint for posting the create job result.
   543  func (client ReviewsClient) CreateJob(ctx context.Context, teamName string, contentType string, contentID string, workflowName string, jobContentType string, content Content, callBackEndpoint string) (result JobID, err error) {
   544  	if tracing.IsEnabled() {
   545  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.CreateJob")
   546  		defer func() {
   547  			sc := -1
   548  			if result.Response.Response != nil {
   549  				sc = result.Response.Response.StatusCode
   550  			}
   551  			tracing.EndSpan(ctx, sc, err)
   552  		}()
   553  	}
   554  	if err := validation.Validate([]validation.Validation{
   555  		{TargetValue: content,
   556  			Constraints: []validation.Constraint{{Target: "content.ContentValue", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   557  		return result, validation.NewError("contentmoderator.ReviewsClient", "CreateJob", err.Error())
   558  	}
   559  
   560  	req, err := client.CreateJobPreparer(ctx, teamName, contentType, contentID, workflowName, jobContentType, content, callBackEndpoint)
   561  	if err != nil {
   562  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "CreateJob", nil, "Failure preparing request")
   563  		return
   564  	}
   565  
   566  	resp, err := client.CreateJobSender(req)
   567  	if err != nil {
   568  		result.Response = autorest.Response{Response: resp}
   569  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "CreateJob", resp, "Failure sending request")
   570  		return
   571  	}
   572  
   573  	result, err = client.CreateJobResponder(resp)
   574  	if err != nil {
   575  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "CreateJob", resp, "Failure responding to request")
   576  		return
   577  	}
   578  
   579  	return
   580  }
   581  
   582  // CreateJobPreparer prepares the CreateJob request.
   583  func (client ReviewsClient) CreateJobPreparer(ctx context.Context, teamName string, contentType string, contentID string, workflowName string, jobContentType string, content Content, callBackEndpoint string) (*http.Request, error) {
   584  	urlParameters := map[string]interface{}{
   585  		"Endpoint": client.Endpoint,
   586  	}
   587  
   588  	pathParameters := map[string]interface{}{
   589  		"teamName": autorest.Encode("path", teamName),
   590  	}
   591  
   592  	queryParameters := map[string]interface{}{
   593  		"ContentId":    autorest.Encode("query", contentID),
   594  		"ContentType":  autorest.Encode("query", contentType),
   595  		"WorkflowName": autorest.Encode("query", workflowName),
   596  	}
   597  	if len(callBackEndpoint) > 0 {
   598  		queryParameters["CallBackEndpoint"] = autorest.Encode("query", callBackEndpoint)
   599  	}
   600  
   601  	preparer := autorest.CreatePreparer(
   602  		autorest.AsContentType("application/json; charset=utf-8"),
   603  		autorest.AsPost(),
   604  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   605  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/jobs", pathParameters),
   606  		autorest.WithJSON(content),
   607  		autorest.WithQueryParameters(queryParameters),
   608  		autorest.WithHeader("Content-Type", autorest.String(jobContentType)))
   609  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   610  }
   611  
   612  // CreateJobSender sends the CreateJob request. The method will close the
   613  // http.Response Body if it receives an error.
   614  func (client ReviewsClient) CreateJobSender(req *http.Request) (*http.Response, error) {
   615  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   616  }
   617  
   618  // CreateJobResponder handles the response to the CreateJob request. The method always
   619  // closes the http.Response Body.
   620  func (client ReviewsClient) CreateJobResponder(resp *http.Response) (result JobID, err error) {
   621  	err = autorest.Respond(
   622  		resp,
   623  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   624  		autorest.ByUnmarshallingJSON(&result),
   625  		autorest.ByClosing())
   626  	result.Response = autorest.Response{Response: resp}
   627  	return
   628  }
   629  
   630  // CreateReviews the reviews created would show up for Reviewers on your team. As Reviewers complete reviewing, results
   631  // of the Review would be POSTED (i.e. HTTP POST) on the specified CallBackEndpoint.
   632  //
   633  // <h3>CallBack Schemas </h3>
   634  // <h4>Review Completion CallBack Sample</h4>
   635  // <p>
   636  // {<br/>
   637  // "ReviewId": "<Review Id>",<br/>
   638  // "ModifiedOn": "2016-10-11T22:36:32.9934851Z",<br/>
   639  // "ModifiedBy": "<Name of the Reviewer>",<br/>
   640  // "CallBackType": "Review",<br/>
   641  // "ContentId": "<The ContentId that was specified input>",<br/>
   642  // "Metadata": {<br/>
   643  // "adultscore": "0.xxx",<br/>
   644  // "a": "False",<br/>
   645  // "racyscore": "0.xxx",<br/>
   646  // "r": "True"<br/>
   647  // },<br/>
   648  // "ReviewerResultTags": {<br/>
   649  // "a": "False",<br/>
   650  // "r": "True"<br/>
   651  // }<br/>
   652  // }<br/>
   653  //
   654  // </p>.
   655  // Parameters:
   656  // URLContentType - the content type.
   657  // teamName - your team name.
   658  // createReviewBody - body for create reviews API
   659  // subTeam - subTeam of your team, you want to assign the created review to.
   660  func (client ReviewsClient) CreateReviews(ctx context.Context, URLContentType string, teamName string, createReviewBody []CreateReviewBodyItem, subTeam string) (result ListString, err error) {
   661  	if tracing.IsEnabled() {
   662  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.CreateReviews")
   663  		defer func() {
   664  			sc := -1
   665  			if result.Response.Response != nil {
   666  				sc = result.Response.Response.StatusCode
   667  			}
   668  			tracing.EndSpan(ctx, sc, err)
   669  		}()
   670  	}
   671  	if err := validation.Validate([]validation.Validation{
   672  		{TargetValue: createReviewBody,
   673  			Constraints: []validation.Constraint{{Target: "createReviewBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   674  		return result, validation.NewError("contentmoderator.ReviewsClient", "CreateReviews", err.Error())
   675  	}
   676  
   677  	req, err := client.CreateReviewsPreparer(ctx, URLContentType, teamName, createReviewBody, subTeam)
   678  	if err != nil {
   679  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "CreateReviews", nil, "Failure preparing request")
   680  		return
   681  	}
   682  
   683  	resp, err := client.CreateReviewsSender(req)
   684  	if err != nil {
   685  		result.Response = autorest.Response{Response: resp}
   686  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "CreateReviews", resp, "Failure sending request")
   687  		return
   688  	}
   689  
   690  	result, err = client.CreateReviewsResponder(resp)
   691  	if err != nil {
   692  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "CreateReviews", resp, "Failure responding to request")
   693  		return
   694  	}
   695  
   696  	return
   697  }
   698  
   699  // CreateReviewsPreparer prepares the CreateReviews request.
   700  func (client ReviewsClient) CreateReviewsPreparer(ctx context.Context, URLContentType string, teamName string, createReviewBody []CreateReviewBodyItem, subTeam string) (*http.Request, error) {
   701  	urlParameters := map[string]interface{}{
   702  		"Endpoint": client.Endpoint,
   703  	}
   704  
   705  	pathParameters := map[string]interface{}{
   706  		"teamName": autorest.Encode("path", teamName),
   707  	}
   708  
   709  	queryParameters := map[string]interface{}{}
   710  	if len(subTeam) > 0 {
   711  		queryParameters["subTeam"] = autorest.Encode("query", subTeam)
   712  	}
   713  
   714  	preparer := autorest.CreatePreparer(
   715  		autorest.AsContentType("application/json; charset=utf-8"),
   716  		autorest.AsPost(),
   717  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   718  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews", pathParameters),
   719  		autorest.WithJSON(createReviewBody),
   720  		autorest.WithQueryParameters(queryParameters),
   721  		autorest.WithHeader("UrlContentType", autorest.String(URLContentType)))
   722  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   723  }
   724  
   725  // CreateReviewsSender sends the CreateReviews request. The method will close the
   726  // http.Response Body if it receives an error.
   727  func (client ReviewsClient) CreateReviewsSender(req *http.Request) (*http.Response, error) {
   728  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   729  }
   730  
   731  // CreateReviewsResponder handles the response to the CreateReviews request. The method always
   732  // closes the http.Response Body.
   733  func (client ReviewsClient) CreateReviewsResponder(resp *http.Response) (result ListString, err error) {
   734  	err = autorest.Respond(
   735  		resp,
   736  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   737  		autorest.ByUnmarshallingJSON(&result.Value),
   738  		autorest.ByClosing())
   739  	result.Response = autorest.Response{Response: resp}
   740  	return
   741  }
   742  
   743  // CreateVideoReviews the reviews created would show up for Reviewers on your team. As Reviewers complete reviewing,
   744  // results of the Review would be POSTED (i.e. HTTP POST) on the specified CallBackEndpoint.
   745  //
   746  // <h3>CallBack Schemas </h3>
   747  // <h4>Review Completion CallBack Sample</h4>
   748  // <p>
   749  // {<br/>
   750  // "ReviewId": "<Review Id>",<br/>
   751  // "ModifiedOn": "2016-10-11T22:36:32.9934851Z",<br/>
   752  // "ModifiedBy": "<Name of the Reviewer>",<br/>
   753  // "CallBackType": "Review",<br/>
   754  // "ContentId": "<The ContentId that was specified input>",<br/>
   755  // "Metadata": {<br/>
   756  // "adultscore": "0.xxx",<br/>
   757  // "a": "False",<br/>
   758  // "racyscore": "0.xxx",<br/>
   759  // "r": "True"<br/>
   760  // },<br/>
   761  // "ReviewerResultTags": {<br/>
   762  // "a": "False",<br/>
   763  // "r": "True"<br/>
   764  // }<br/>
   765  // }<br/>
   766  //
   767  // </p>.
   768  // Parameters:
   769  // contentType - the content type.
   770  // teamName - your team name.
   771  // createVideoReviewsBody - body for create reviews API
   772  // subTeam - subTeam of your team, you want to assign the created review to.
   773  func (client ReviewsClient) CreateVideoReviews(ctx context.Context, contentType string, teamName string, createVideoReviewsBody []CreateVideoReviewsBodyItem, subTeam string) (result ListString, err error) {
   774  	if tracing.IsEnabled() {
   775  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.CreateVideoReviews")
   776  		defer func() {
   777  			sc := -1
   778  			if result.Response.Response != nil {
   779  				sc = result.Response.Response.StatusCode
   780  			}
   781  			tracing.EndSpan(ctx, sc, err)
   782  		}()
   783  	}
   784  	if err := validation.Validate([]validation.Validation{
   785  		{TargetValue: createVideoReviewsBody,
   786  			Constraints: []validation.Constraint{{Target: "createVideoReviewsBody", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   787  		return result, validation.NewError("contentmoderator.ReviewsClient", "CreateVideoReviews", err.Error())
   788  	}
   789  
   790  	req, err := client.CreateVideoReviewsPreparer(ctx, contentType, teamName, createVideoReviewsBody, subTeam)
   791  	if err != nil {
   792  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "CreateVideoReviews", nil, "Failure preparing request")
   793  		return
   794  	}
   795  
   796  	resp, err := client.CreateVideoReviewsSender(req)
   797  	if err != nil {
   798  		result.Response = autorest.Response{Response: resp}
   799  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "CreateVideoReviews", resp, "Failure sending request")
   800  		return
   801  	}
   802  
   803  	result, err = client.CreateVideoReviewsResponder(resp)
   804  	if err != nil {
   805  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "CreateVideoReviews", resp, "Failure responding to request")
   806  		return
   807  	}
   808  
   809  	return
   810  }
   811  
   812  // CreateVideoReviewsPreparer prepares the CreateVideoReviews request.
   813  func (client ReviewsClient) CreateVideoReviewsPreparer(ctx context.Context, contentType string, teamName string, createVideoReviewsBody []CreateVideoReviewsBodyItem, subTeam string) (*http.Request, error) {
   814  	urlParameters := map[string]interface{}{
   815  		"Endpoint": client.Endpoint,
   816  	}
   817  
   818  	pathParameters := map[string]interface{}{
   819  		"teamName": autorest.Encode("path", teamName),
   820  	}
   821  
   822  	queryParameters := map[string]interface{}{}
   823  	if len(subTeam) > 0 {
   824  		queryParameters["subTeam"] = autorest.Encode("query", subTeam)
   825  	}
   826  
   827  	preparer := autorest.CreatePreparer(
   828  		autorest.AsContentType("application/json; charset=utf-8"),
   829  		autorest.AsPost(),
   830  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   831  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews", pathParameters),
   832  		autorest.WithJSON(createVideoReviewsBody),
   833  		autorest.WithQueryParameters(queryParameters),
   834  		autorest.WithHeader("Content-Type", autorest.String(contentType)))
   835  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   836  }
   837  
   838  // CreateVideoReviewsSender sends the CreateVideoReviews request. The method will close the
   839  // http.Response Body if it receives an error.
   840  func (client ReviewsClient) CreateVideoReviewsSender(req *http.Request) (*http.Response, error) {
   841  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   842  }
   843  
   844  // CreateVideoReviewsResponder handles the response to the CreateVideoReviews request. The method always
   845  // closes the http.Response Body.
   846  func (client ReviewsClient) CreateVideoReviewsResponder(resp *http.Response) (result ListString, err error) {
   847  	err = autorest.Respond(
   848  		resp,
   849  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   850  		autorest.ByUnmarshallingJSON(&result.Value),
   851  		autorest.ByClosing())
   852  	result.Response = autorest.Response{Response: resp}
   853  	return
   854  }
   855  
   856  // GetJobDetails get the Job Details for a Job Id.
   857  // Parameters:
   858  // teamName - your Team Name.
   859  // jobID - id of the job.
   860  func (client ReviewsClient) GetJobDetails(ctx context.Context, teamName string, jobID string) (result Job, err error) {
   861  	if tracing.IsEnabled() {
   862  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.GetJobDetails")
   863  		defer func() {
   864  			sc := -1
   865  			if result.Response.Response != nil {
   866  				sc = result.Response.Response.StatusCode
   867  			}
   868  			tracing.EndSpan(ctx, sc, err)
   869  		}()
   870  	}
   871  	req, err := client.GetJobDetailsPreparer(ctx, teamName, jobID)
   872  	if err != nil {
   873  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "GetJobDetails", nil, "Failure preparing request")
   874  		return
   875  	}
   876  
   877  	resp, err := client.GetJobDetailsSender(req)
   878  	if err != nil {
   879  		result.Response = autorest.Response{Response: resp}
   880  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "GetJobDetails", resp, "Failure sending request")
   881  		return
   882  	}
   883  
   884  	result, err = client.GetJobDetailsResponder(resp)
   885  	if err != nil {
   886  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "GetJobDetails", resp, "Failure responding to request")
   887  		return
   888  	}
   889  
   890  	return
   891  }
   892  
   893  // GetJobDetailsPreparer prepares the GetJobDetails request.
   894  func (client ReviewsClient) GetJobDetailsPreparer(ctx context.Context, teamName string, jobID string) (*http.Request, error) {
   895  	urlParameters := map[string]interface{}{
   896  		"Endpoint": client.Endpoint,
   897  	}
   898  
   899  	pathParameters := map[string]interface{}{
   900  		"JobId":    autorest.Encode("path", jobID),
   901  		"teamName": autorest.Encode("path", teamName),
   902  	}
   903  
   904  	preparer := autorest.CreatePreparer(
   905  		autorest.AsGet(),
   906  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   907  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/jobs/{JobId}", pathParameters))
   908  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   909  }
   910  
   911  // GetJobDetailsSender sends the GetJobDetails request. The method will close the
   912  // http.Response Body if it receives an error.
   913  func (client ReviewsClient) GetJobDetailsSender(req *http.Request) (*http.Response, error) {
   914  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   915  }
   916  
   917  // GetJobDetailsResponder handles the response to the GetJobDetails request. The method always
   918  // closes the http.Response Body.
   919  func (client ReviewsClient) GetJobDetailsResponder(resp *http.Response) (result Job, err error) {
   920  	err = autorest.Respond(
   921  		resp,
   922  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   923  		autorest.ByUnmarshallingJSON(&result),
   924  		autorest.ByClosing())
   925  	result.Response = autorest.Response{Response: resp}
   926  	return
   927  }
   928  
   929  // GetReview returns review details for the review Id passed.
   930  // Parameters:
   931  // teamName - your Team Name.
   932  // reviewID - id of the review.
   933  func (client ReviewsClient) GetReview(ctx context.Context, teamName string, reviewID string) (result Review, err error) {
   934  	if tracing.IsEnabled() {
   935  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.GetReview")
   936  		defer func() {
   937  			sc := -1
   938  			if result.Response.Response != nil {
   939  				sc = result.Response.Response.StatusCode
   940  			}
   941  			tracing.EndSpan(ctx, sc, err)
   942  		}()
   943  	}
   944  	req, err := client.GetReviewPreparer(ctx, teamName, reviewID)
   945  	if err != nil {
   946  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "GetReview", nil, "Failure preparing request")
   947  		return
   948  	}
   949  
   950  	resp, err := client.GetReviewSender(req)
   951  	if err != nil {
   952  		result.Response = autorest.Response{Response: resp}
   953  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "GetReview", resp, "Failure sending request")
   954  		return
   955  	}
   956  
   957  	result, err = client.GetReviewResponder(resp)
   958  	if err != nil {
   959  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "GetReview", resp, "Failure responding to request")
   960  		return
   961  	}
   962  
   963  	return
   964  }
   965  
   966  // GetReviewPreparer prepares the GetReview request.
   967  func (client ReviewsClient) GetReviewPreparer(ctx context.Context, teamName string, reviewID string) (*http.Request, error) {
   968  	urlParameters := map[string]interface{}{
   969  		"Endpoint": client.Endpoint,
   970  	}
   971  
   972  	pathParameters := map[string]interface{}{
   973  		"reviewId": autorest.Encode("path", reviewID),
   974  		"teamName": autorest.Encode("path", teamName),
   975  	}
   976  
   977  	preparer := autorest.CreatePreparer(
   978  		autorest.AsGet(),
   979  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   980  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews/{reviewId}", pathParameters))
   981  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   982  }
   983  
   984  // GetReviewSender sends the GetReview request. The method will close the
   985  // http.Response Body if it receives an error.
   986  func (client ReviewsClient) GetReviewSender(req *http.Request) (*http.Response, error) {
   987  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   988  }
   989  
   990  // GetReviewResponder handles the response to the GetReview request. The method always
   991  // closes the http.Response Body.
   992  func (client ReviewsClient) GetReviewResponder(resp *http.Response) (result Review, err error) {
   993  	err = autorest.Respond(
   994  		resp,
   995  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   996  		autorest.ByUnmarshallingJSON(&result),
   997  		autorest.ByClosing())
   998  	result.Response = autorest.Response{Response: resp}
   999  	return
  1000  }
  1001  
  1002  // GetVideoFrames the reviews created would show up for Reviewers on your team. As Reviewers complete reviewing,
  1003  // results of the Review would be POSTED (i.e. HTTP POST) on the specified CallBackEndpoint.
  1004  //
  1005  // <h3>CallBack Schemas </h3>
  1006  // <h4>Review Completion CallBack Sample</h4>
  1007  // <p>
  1008  // {<br/>
  1009  // "ReviewId": "<Review Id>",<br/>
  1010  // "ModifiedOn": "2016-10-11T22:36:32.9934851Z",<br/>
  1011  // "ModifiedBy": "<Name of the Reviewer>",<br/>
  1012  // "CallBackType": "Review",<br/>
  1013  // "ContentId": "<The ContentId that was specified input>",<br/>
  1014  // "Metadata": {<br/>
  1015  // "adultscore": "0.xxx",<br/>
  1016  // "a": "False",<br/>
  1017  // "racyscore": "0.xxx",<br/>
  1018  // "r": "True"<br/>
  1019  // },<br/>
  1020  // "ReviewerResultTags": {<br/>
  1021  // "a": "False",<br/>
  1022  // "r": "True"<br/>
  1023  // }<br/>
  1024  // }<br/>
  1025  //
  1026  // </p>.
  1027  // Parameters:
  1028  // teamName - your team name.
  1029  // reviewID - id of the review.
  1030  // startSeed - time stamp of the frame from where you want to start fetching the frames.
  1031  // noOfRecords - number of frames to fetch.
  1032  // filter - get frames filtered by tags.
  1033  func (client ReviewsClient) GetVideoFrames(ctx context.Context, teamName string, reviewID string, startSeed *int32, noOfRecords *int32, filter string) (result Frames, err error) {
  1034  	if tracing.IsEnabled() {
  1035  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.GetVideoFrames")
  1036  		defer func() {
  1037  			sc := -1
  1038  			if result.Response.Response != nil {
  1039  				sc = result.Response.Response.StatusCode
  1040  			}
  1041  			tracing.EndSpan(ctx, sc, err)
  1042  		}()
  1043  	}
  1044  	req, err := client.GetVideoFramesPreparer(ctx, teamName, reviewID, startSeed, noOfRecords, filter)
  1045  	if err != nil {
  1046  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "GetVideoFrames", nil, "Failure preparing request")
  1047  		return
  1048  	}
  1049  
  1050  	resp, err := client.GetVideoFramesSender(req)
  1051  	if err != nil {
  1052  		result.Response = autorest.Response{Response: resp}
  1053  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "GetVideoFrames", resp, "Failure sending request")
  1054  		return
  1055  	}
  1056  
  1057  	result, err = client.GetVideoFramesResponder(resp)
  1058  	if err != nil {
  1059  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "GetVideoFrames", resp, "Failure responding to request")
  1060  		return
  1061  	}
  1062  
  1063  	return
  1064  }
  1065  
  1066  // GetVideoFramesPreparer prepares the GetVideoFrames request.
  1067  func (client ReviewsClient) GetVideoFramesPreparer(ctx context.Context, teamName string, reviewID string, startSeed *int32, noOfRecords *int32, filter string) (*http.Request, error) {
  1068  	urlParameters := map[string]interface{}{
  1069  		"Endpoint": client.Endpoint,
  1070  	}
  1071  
  1072  	pathParameters := map[string]interface{}{
  1073  		"reviewId": autorest.Encode("path", reviewID),
  1074  		"teamName": autorest.Encode("path", teamName),
  1075  	}
  1076  
  1077  	queryParameters := map[string]interface{}{}
  1078  	if startSeed != nil {
  1079  		queryParameters["startSeed"] = autorest.Encode("query", *startSeed)
  1080  	}
  1081  	if noOfRecords != nil {
  1082  		queryParameters["noOfRecords"] = autorest.Encode("query", *noOfRecords)
  1083  	}
  1084  	if len(filter) > 0 {
  1085  		queryParameters["filter"] = autorest.Encode("query", filter)
  1086  	}
  1087  
  1088  	preparer := autorest.CreatePreparer(
  1089  		autorest.AsGet(),
  1090  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
  1091  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews/{reviewId}/frames", pathParameters),
  1092  		autorest.WithQueryParameters(queryParameters))
  1093  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1094  }
  1095  
  1096  // GetVideoFramesSender sends the GetVideoFrames request. The method will close the
  1097  // http.Response Body if it receives an error.
  1098  func (client ReviewsClient) GetVideoFramesSender(req *http.Request) (*http.Response, error) {
  1099  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1100  }
  1101  
  1102  // GetVideoFramesResponder handles the response to the GetVideoFrames request. The method always
  1103  // closes the http.Response Body.
  1104  func (client ReviewsClient) GetVideoFramesResponder(resp *http.Response) (result Frames, err error) {
  1105  	err = autorest.Respond(
  1106  		resp,
  1107  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1108  		autorest.ByUnmarshallingJSON(&result),
  1109  		autorest.ByClosing())
  1110  	result.Response = autorest.Response{Response: resp}
  1111  	return
  1112  }
  1113  
  1114  // PublishVideoReview publish video review to make it available for review.
  1115  // Parameters:
  1116  // teamName - your team name.
  1117  // reviewID - id of the review.
  1118  func (client ReviewsClient) PublishVideoReview(ctx context.Context, teamName string, reviewID string) (result autorest.Response, err error) {
  1119  	if tracing.IsEnabled() {
  1120  		ctx = tracing.StartSpan(ctx, fqdn+"/ReviewsClient.PublishVideoReview")
  1121  		defer func() {
  1122  			sc := -1
  1123  			if result.Response != nil {
  1124  				sc = result.Response.StatusCode
  1125  			}
  1126  			tracing.EndSpan(ctx, sc, err)
  1127  		}()
  1128  	}
  1129  	req, err := client.PublishVideoReviewPreparer(ctx, teamName, reviewID)
  1130  	if err != nil {
  1131  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "PublishVideoReview", nil, "Failure preparing request")
  1132  		return
  1133  	}
  1134  
  1135  	resp, err := client.PublishVideoReviewSender(req)
  1136  	if err != nil {
  1137  		result.Response = resp
  1138  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "PublishVideoReview", resp, "Failure sending request")
  1139  		return
  1140  	}
  1141  
  1142  	result, err = client.PublishVideoReviewResponder(resp)
  1143  	if err != nil {
  1144  		err = autorest.NewErrorWithError(err, "contentmoderator.ReviewsClient", "PublishVideoReview", resp, "Failure responding to request")
  1145  		return
  1146  	}
  1147  
  1148  	return
  1149  }
  1150  
  1151  // PublishVideoReviewPreparer prepares the PublishVideoReview request.
  1152  func (client ReviewsClient) PublishVideoReviewPreparer(ctx context.Context, teamName string, reviewID string) (*http.Request, error) {
  1153  	urlParameters := map[string]interface{}{
  1154  		"Endpoint": client.Endpoint,
  1155  	}
  1156  
  1157  	pathParameters := map[string]interface{}{
  1158  		"reviewId": autorest.Encode("path", reviewID),
  1159  		"teamName": autorest.Encode("path", teamName),
  1160  	}
  1161  
  1162  	preparer := autorest.CreatePreparer(
  1163  		autorest.AsPost(),
  1164  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
  1165  		autorest.WithPathParameters("/contentmoderator/review/v1.0/teams/{teamName}/reviews/{reviewId}/publish", pathParameters))
  1166  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1167  }
  1168  
  1169  // PublishVideoReviewSender sends the PublishVideoReview request. The method will close the
  1170  // http.Response Body if it receives an error.
  1171  func (client ReviewsClient) PublishVideoReviewSender(req *http.Request) (*http.Response, error) {
  1172  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1173  }
  1174  
  1175  // PublishVideoReviewResponder handles the response to the PublishVideoReview request. The method always
  1176  // closes the http.Response Body.
  1177  func (client ReviewsClient) PublishVideoReviewResponder(resp *http.Response) (result autorest.Response, err error) {
  1178  	err = autorest.Respond(
  1179  		resp,
  1180  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1181  		autorest.ByClosing())
  1182  	result.Response = resp
  1183  	return
  1184  }
  1185
View as plain text