listmanagementimage.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/tracing"
    14  	"io"
    15  	"net/http"
    16  )
    17  
    18  // ListManagementImageClient is the you use the API to scan your content as it is generated. Content Moderator then
    19  // processes your content and sends the results along with relevant information either back to your systems or to the
    20  // built-in review tool. You can use this information to take decisions e.g. take it down, send to human judge, etc.
    21  //
    22  // When using the API, images need to have a minimum of 128 pixels and a maximum file size of 4MB.
    23  // Text can be at most 1024 characters long.
    24  // If the content passed to the text API or the image API exceeds the size limits, the API will return an error code
    25  // that informs about the issue.
    26  type ListManagementImageClient struct {
    27  	BaseClient
    28  }
    29  
    30  // NewListManagementImageClient creates an instance of the ListManagementImageClient client.
    31  func NewListManagementImageClient(endpoint string) ListManagementImageClient {
    32  	return ListManagementImageClient{New(endpoint)}
    33  }
    34  
    35  // AddImage add an image to the list with list Id equal to list Id passed.
    36  // Parameters:
    37  // listID - list Id of the image list.
    38  // tag - tag for the image.
    39  // label - the image label.
    40  func (client ListManagementImageClient) AddImage(ctx context.Context, listID string, tag *int32, label string) (result Image, err error) {
    41  	if tracing.IsEnabled() {
    42  		ctx = tracing.StartSpan(ctx, fqdn+"/ListManagementImageClient.AddImage")
    43  		defer func() {
    44  			sc := -1
    45  			if result.Response.Response != nil {
    46  				sc = result.Response.Response.StatusCode
    47  			}
    48  			tracing.EndSpan(ctx, sc, err)
    49  		}()
    50  	}
    51  	req, err := client.AddImagePreparer(ctx, listID, tag, label)
    52  	if err != nil {
    53  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "AddImage", nil, "Failure preparing request")
    54  		return
    55  	}
    56  
    57  	resp, err := client.AddImageSender(req)
    58  	if err != nil {
    59  		result.Response = autorest.Response{Response: resp}
    60  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "AddImage", resp, "Failure sending request")
    61  		return
    62  	}
    63  
    64  	result, err = client.AddImageResponder(resp)
    65  	if err != nil {
    66  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "AddImage", resp, "Failure responding to request")
    67  		return
    68  	}
    69  
    70  	return
    71  }
    72  
    73  // AddImagePreparer prepares the AddImage request.
    74  func (client ListManagementImageClient) AddImagePreparer(ctx context.Context, listID string, tag *int32, label string) (*http.Request, error) {
    75  	urlParameters := map[string]interface{}{
    76  		"Endpoint": client.Endpoint,
    77  	}
    78  
    79  	pathParameters := map[string]interface{}{
    80  		"listId": autorest.Encode("path", listID),
    81  	}
    82  
    83  	queryParameters := map[string]interface{}{}
    84  	if tag != nil {
    85  		queryParameters["tag"] = autorest.Encode("query", *tag)
    86  	}
    87  	if len(label) > 0 {
    88  		queryParameters["label"] = autorest.Encode("query", label)
    89  	}
    90  
    91  	preparer := autorest.CreatePreparer(
    92  		autorest.AsPost(),
    93  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
    94  		autorest.WithPathParameters("/contentmoderator/lists/v1.0/imagelists/{listId}/images", pathParameters),
    95  		autorest.WithQueryParameters(queryParameters))
    96  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    97  }
    98  
    99  // AddImageSender sends the AddImage request. The method will close the
   100  // http.Response Body if it receives an error.
   101  func (client ListManagementImageClient) AddImageSender(req *http.Request) (*http.Response, error) {
   102  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   103  }
   104  
   105  // AddImageResponder handles the response to the AddImage request. The method always
   106  // closes the http.Response Body.
   107  func (client ListManagementImageClient) AddImageResponder(resp *http.Response) (result Image, err error) {
   108  	err = autorest.Respond(
   109  		resp,
   110  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   111  		autorest.ByUnmarshallingJSON(&result),
   112  		autorest.ByClosing())
   113  	result.Response = autorest.Response{Response: resp}
   114  	return
   115  }
   116  
   117  // AddImageFileInput add an image to the list with list Id equal to list Id passed.
   118  // Parameters:
   119  // listID - list Id of the image list.
   120  // imageStream - the image file.
   121  // tag - tag for the image.
   122  // label - the image label.
   123  func (client ListManagementImageClient) AddImageFileInput(ctx context.Context, listID string, imageStream io.ReadCloser, tag *int32, label string) (result Image, err error) {
   124  	if tracing.IsEnabled() {
   125  		ctx = tracing.StartSpan(ctx, fqdn+"/ListManagementImageClient.AddImageFileInput")
   126  		defer func() {
   127  			sc := -1
   128  			if result.Response.Response != nil {
   129  				sc = result.Response.Response.StatusCode
   130  			}
   131  			tracing.EndSpan(ctx, sc, err)
   132  		}()
   133  	}
   134  	req, err := client.AddImageFileInputPreparer(ctx, listID, imageStream, tag, label)
   135  	if err != nil {
   136  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "AddImageFileInput", nil, "Failure preparing request")
   137  		return
   138  	}
   139  
   140  	resp, err := client.AddImageFileInputSender(req)
   141  	if err != nil {
   142  		result.Response = autorest.Response{Response: resp}
   143  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "AddImageFileInput", resp, "Failure sending request")
   144  		return
   145  	}
   146  
   147  	result, err = client.AddImageFileInputResponder(resp)
   148  	if err != nil {
   149  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "AddImageFileInput", resp, "Failure responding to request")
   150  		return
   151  	}
   152  
   153  	return
   154  }
   155  
   156  // AddImageFileInputPreparer prepares the AddImageFileInput request.
   157  func (client ListManagementImageClient) AddImageFileInputPreparer(ctx context.Context, listID string, imageStream io.ReadCloser, tag *int32, label string) (*http.Request, error) {
   158  	urlParameters := map[string]interface{}{
   159  		"Endpoint": client.Endpoint,
   160  	}
   161  
   162  	pathParameters := map[string]interface{}{
   163  		"listId": autorest.Encode("path", listID),
   164  	}
   165  
   166  	queryParameters := map[string]interface{}{}
   167  	if tag != nil {
   168  		queryParameters["tag"] = autorest.Encode("query", *tag)
   169  	}
   170  	if len(label) > 0 {
   171  		queryParameters["label"] = autorest.Encode("query", label)
   172  	}
   173  
   174  	preparer := autorest.CreatePreparer(
   175  		autorest.AsContentType("image/gif"),
   176  		autorest.AsPost(),
   177  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   178  		autorest.WithPathParameters("/contentmoderator/lists/v1.0/imagelists/{listId}/images", pathParameters),
   179  		autorest.WithFile(imageStream),
   180  		autorest.WithQueryParameters(queryParameters))
   181  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   182  }
   183  
   184  // AddImageFileInputSender sends the AddImageFileInput request. The method will close the
   185  // http.Response Body if it receives an error.
   186  func (client ListManagementImageClient) AddImageFileInputSender(req *http.Request) (*http.Response, error) {
   187  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   188  }
   189  
   190  // AddImageFileInputResponder handles the response to the AddImageFileInput request. The method always
   191  // closes the http.Response Body.
   192  func (client ListManagementImageClient) AddImageFileInputResponder(resp *http.Response) (result Image, err error) {
   193  	err = autorest.Respond(
   194  		resp,
   195  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   196  		autorest.ByUnmarshallingJSON(&result),
   197  		autorest.ByClosing())
   198  	result.Response = autorest.Response{Response: resp}
   199  	return
   200  }
   201  
   202  // AddImageURLInput add an image to the list with list Id equal to list Id passed.
   203  // Parameters:
   204  // listID - list Id of the image list.
   205  // contentType - the content type.
   206  // imageURL - the image url.
   207  // tag - tag for the image.
   208  // label - the image label.
   209  func (client ListManagementImageClient) AddImageURLInput(ctx context.Context, listID string, contentType string, imageURL ImageURL, tag *int32, label string) (result Image, err error) {
   210  	if tracing.IsEnabled() {
   211  		ctx = tracing.StartSpan(ctx, fqdn+"/ListManagementImageClient.AddImageURLInput")
   212  		defer func() {
   213  			sc := -1
   214  			if result.Response.Response != nil {
   215  				sc = result.Response.Response.StatusCode
   216  			}
   217  			tracing.EndSpan(ctx, sc, err)
   218  		}()
   219  	}
   220  	req, err := client.AddImageURLInputPreparer(ctx, listID, contentType, imageURL, tag, label)
   221  	if err != nil {
   222  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "AddImageURLInput", nil, "Failure preparing request")
   223  		return
   224  	}
   225  
   226  	resp, err := client.AddImageURLInputSender(req)
   227  	if err != nil {
   228  		result.Response = autorest.Response{Response: resp}
   229  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "AddImageURLInput", resp, "Failure sending request")
   230  		return
   231  	}
   232  
   233  	result, err = client.AddImageURLInputResponder(resp)
   234  	if err != nil {
   235  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "AddImageURLInput", resp, "Failure responding to request")
   236  		return
   237  	}
   238  
   239  	return
   240  }
   241  
   242  // AddImageURLInputPreparer prepares the AddImageURLInput request.
   243  func (client ListManagementImageClient) AddImageURLInputPreparer(ctx context.Context, listID string, contentType string, imageURL ImageURL, tag *int32, label string) (*http.Request, error) {
   244  	urlParameters := map[string]interface{}{
   245  		"Endpoint": client.Endpoint,
   246  	}
   247  
   248  	pathParameters := map[string]interface{}{
   249  		"listId": autorest.Encode("path", listID),
   250  	}
   251  
   252  	queryParameters := map[string]interface{}{}
   253  	if tag != nil {
   254  		queryParameters["tag"] = autorest.Encode("query", *tag)
   255  	}
   256  	if len(label) > 0 {
   257  		queryParameters["label"] = autorest.Encode("query", label)
   258  	}
   259  
   260  	preparer := autorest.CreatePreparer(
   261  		autorest.AsContentType("application/json; charset=utf-8"),
   262  		autorest.AsPost(),
   263  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   264  		autorest.WithPathParameters("/contentmoderator/lists/v1.0/imagelists/{listId}/images", pathParameters),
   265  		autorest.WithJSON(imageURL),
   266  		autorest.WithQueryParameters(queryParameters),
   267  		autorest.WithHeader("Content-Type", autorest.String(contentType)))
   268  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   269  }
   270  
   271  // AddImageURLInputSender sends the AddImageURLInput request. The method will close the
   272  // http.Response Body if it receives an error.
   273  func (client ListManagementImageClient) AddImageURLInputSender(req *http.Request) (*http.Response, error) {
   274  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   275  }
   276  
   277  // AddImageURLInputResponder handles the response to the AddImageURLInput request. The method always
   278  // closes the http.Response Body.
   279  func (client ListManagementImageClient) AddImageURLInputResponder(resp *http.Response) (result Image, err error) {
   280  	err = autorest.Respond(
   281  		resp,
   282  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   283  		autorest.ByUnmarshallingJSON(&result),
   284  		autorest.ByClosing())
   285  	result.Response = autorest.Response{Response: resp}
   286  	return
   287  }
   288  
   289  // DeleteAllImages deletes all images from the list with list Id equal to list Id passed.
   290  // Parameters:
   291  // listID - list Id of the image list.
   292  func (client ListManagementImageClient) DeleteAllImages(ctx context.Context, listID string) (result String, err error) {
   293  	if tracing.IsEnabled() {
   294  		ctx = tracing.StartSpan(ctx, fqdn+"/ListManagementImageClient.DeleteAllImages")
   295  		defer func() {
   296  			sc := -1
   297  			if result.Response.Response != nil {
   298  				sc = result.Response.Response.StatusCode
   299  			}
   300  			tracing.EndSpan(ctx, sc, err)
   301  		}()
   302  	}
   303  	req, err := client.DeleteAllImagesPreparer(ctx, listID)
   304  	if err != nil {
   305  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "DeleteAllImages", nil, "Failure preparing request")
   306  		return
   307  	}
   308  
   309  	resp, err := client.DeleteAllImagesSender(req)
   310  	if err != nil {
   311  		result.Response = autorest.Response{Response: resp}
   312  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "DeleteAllImages", resp, "Failure sending request")
   313  		return
   314  	}
   315  
   316  	result, err = client.DeleteAllImagesResponder(resp)
   317  	if err != nil {
   318  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "DeleteAllImages", resp, "Failure responding to request")
   319  		return
   320  	}
   321  
   322  	return
   323  }
   324  
   325  // DeleteAllImagesPreparer prepares the DeleteAllImages request.
   326  func (client ListManagementImageClient) DeleteAllImagesPreparer(ctx context.Context, listID string) (*http.Request, error) {
   327  	urlParameters := map[string]interface{}{
   328  		"Endpoint": client.Endpoint,
   329  	}
   330  
   331  	pathParameters := map[string]interface{}{
   332  		"listId": autorest.Encode("path", listID),
   333  	}
   334  
   335  	preparer := autorest.CreatePreparer(
   336  		autorest.AsDelete(),
   337  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   338  		autorest.WithPathParameters("/contentmoderator/lists/v1.0/imagelists/{listId}/images", pathParameters))
   339  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   340  }
   341  
   342  // DeleteAllImagesSender sends the DeleteAllImages request. The method will close the
   343  // http.Response Body if it receives an error.
   344  func (client ListManagementImageClient) DeleteAllImagesSender(req *http.Request) (*http.Response, error) {
   345  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   346  }
   347  
   348  // DeleteAllImagesResponder handles the response to the DeleteAllImages request. The method always
   349  // closes the http.Response Body.
   350  func (client ListManagementImageClient) DeleteAllImagesResponder(resp *http.Response) (result String, err error) {
   351  	err = autorest.Respond(
   352  		resp,
   353  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   354  		autorest.ByUnmarshallingJSON(&result.Value),
   355  		autorest.ByClosing())
   356  	result.Response = autorest.Response{Response: resp}
   357  	return
   358  }
   359  
   360  // DeleteImage deletes an image from the list with list Id and image Id passed.
   361  // Parameters:
   362  // listID - list Id of the image list.
   363  // imageID - id of the image.
   364  func (client ListManagementImageClient) DeleteImage(ctx context.Context, listID string, imageID string) (result String, err error) {
   365  	if tracing.IsEnabled() {
   366  		ctx = tracing.StartSpan(ctx, fqdn+"/ListManagementImageClient.DeleteImage")
   367  		defer func() {
   368  			sc := -1
   369  			if result.Response.Response != nil {
   370  				sc = result.Response.Response.StatusCode
   371  			}
   372  			tracing.EndSpan(ctx, sc, err)
   373  		}()
   374  	}
   375  	req, err := client.DeleteImagePreparer(ctx, listID, imageID)
   376  	if err != nil {
   377  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "DeleteImage", nil, "Failure preparing request")
   378  		return
   379  	}
   380  
   381  	resp, err := client.DeleteImageSender(req)
   382  	if err != nil {
   383  		result.Response = autorest.Response{Response: resp}
   384  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "DeleteImage", resp, "Failure sending request")
   385  		return
   386  	}
   387  
   388  	result, err = client.DeleteImageResponder(resp)
   389  	if err != nil {
   390  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "DeleteImage", resp, "Failure responding to request")
   391  		return
   392  	}
   393  
   394  	return
   395  }
   396  
   397  // DeleteImagePreparer prepares the DeleteImage request.
   398  func (client ListManagementImageClient) DeleteImagePreparer(ctx context.Context, listID string, imageID string) (*http.Request, error) {
   399  	urlParameters := map[string]interface{}{
   400  		"Endpoint": client.Endpoint,
   401  	}
   402  
   403  	pathParameters := map[string]interface{}{
   404  		"ImageId": autorest.Encode("path", imageID),
   405  		"listId":  autorest.Encode("path", listID),
   406  	}
   407  
   408  	preparer := autorest.CreatePreparer(
   409  		autorest.AsDelete(),
   410  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   411  		autorest.WithPathParameters("/contentmoderator/lists/v1.0/imagelists/{listId}/images/{ImageId}", pathParameters))
   412  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   413  }
   414  
   415  // DeleteImageSender sends the DeleteImage request. The method will close the
   416  // http.Response Body if it receives an error.
   417  func (client ListManagementImageClient) DeleteImageSender(req *http.Request) (*http.Response, error) {
   418  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   419  }
   420  
   421  // DeleteImageResponder handles the response to the DeleteImage request. The method always
   422  // closes the http.Response Body.
   423  func (client ListManagementImageClient) DeleteImageResponder(resp *http.Response) (result String, err error) {
   424  	err = autorest.Respond(
   425  		resp,
   426  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   427  		autorest.ByUnmarshallingJSON(&result.Value),
   428  		autorest.ByClosing())
   429  	result.Response = autorest.Response{Response: resp}
   430  	return
   431  }
   432  
   433  // GetAllImageIds gets all image Ids from the list with list Id equal to list Id passed.
   434  // Parameters:
   435  // listID - list Id of the image list.
   436  func (client ListManagementImageClient) GetAllImageIds(ctx context.Context, listID string) (result ImageIds, err error) {
   437  	if tracing.IsEnabled() {
   438  		ctx = tracing.StartSpan(ctx, fqdn+"/ListManagementImageClient.GetAllImageIds")
   439  		defer func() {
   440  			sc := -1
   441  			if result.Response.Response != nil {
   442  				sc = result.Response.Response.StatusCode
   443  			}
   444  			tracing.EndSpan(ctx, sc, err)
   445  		}()
   446  	}
   447  	req, err := client.GetAllImageIdsPreparer(ctx, listID)
   448  	if err != nil {
   449  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "GetAllImageIds", nil, "Failure preparing request")
   450  		return
   451  	}
   452  
   453  	resp, err := client.GetAllImageIdsSender(req)
   454  	if err != nil {
   455  		result.Response = autorest.Response{Response: resp}
   456  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "GetAllImageIds", resp, "Failure sending request")
   457  		return
   458  	}
   459  
   460  	result, err = client.GetAllImageIdsResponder(resp)
   461  	if err != nil {
   462  		err = autorest.NewErrorWithError(err, "contentmoderator.ListManagementImageClient", "GetAllImageIds", resp, "Failure responding to request")
   463  		return
   464  	}
   465  
   466  	return
   467  }
   468  
   469  // GetAllImageIdsPreparer prepares the GetAllImageIds request.
   470  func (client ListManagementImageClient) GetAllImageIdsPreparer(ctx context.Context, listID string) (*http.Request, error) {
   471  	urlParameters := map[string]interface{}{
   472  		"Endpoint": client.Endpoint,
   473  	}
   474  
   475  	pathParameters := map[string]interface{}{
   476  		"listId": autorest.Encode("path", listID),
   477  	}
   478  
   479  	preparer := autorest.CreatePreparer(
   480  		autorest.AsGet(),
   481  		autorest.WithCustomBaseURL("{Endpoint}", urlParameters),
   482  		autorest.WithPathParameters("/contentmoderator/lists/v1.0/imagelists/{listId}/images", pathParameters))
   483  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   484  }
   485  
   486  // GetAllImageIdsSender sends the GetAllImageIds request. The method will close the
   487  // http.Response Body if it receives an error.
   488  func (client ListManagementImageClient) GetAllImageIdsSender(req *http.Request) (*http.Response, error) {
   489  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   490  }
   491  
   492  // GetAllImageIdsResponder handles the response to the GetAllImageIds request. The method always
   493  // closes the http.Response Body.
   494  func (client ListManagementImageClient) GetAllImageIdsResponder(resp *http.Response) (result ImageIds, err error) {
   495  	err = autorest.Respond(
   496  		resp,
   497  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   498  		autorest.ByUnmarshallingJSON(&result),
   499  		autorest.ByClosing())
   500  	result.Response = autorest.Response{Response: resp}
   501  	return
   502  }
   503
View as plain text