Source file src/github.com/Azure/azure-sdk-for-go/services/storsimple8000series/mgmt/2017-06-01/storsimple/devicesettings.go

Documentation: github.com/Azure/azure-sdk-for-go/services/storsimple8000series/mgmt/2017-06-01/storsimple

     1  package storsimple
     2  
     3  // Copyright (c) Microsoft Corporation. All rights reserved.
     4  // Licensed under the MIT License. See License.txt in the project root for license information.
     5  //
     6  // Code generated by Microsoft (R) AutoRest Code Generator.
     7  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
     8  
     9  import (
    10  	"context"
    11  	"github.com/Azure/go-autorest/autorest"
    12  	"github.com/Azure/go-autorest/autorest/azure"
    13  	"github.com/Azure/go-autorest/autorest/validation"
    14  	"github.com/Azure/go-autorest/tracing"
    15  	"net/http"
    16  )
    17  
    18  // DeviceSettingsClient is the client for the DeviceSettings methods of the Storsimple service.
    19  type DeviceSettingsClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewDeviceSettingsClient creates an instance of the DeviceSettingsClient client.
    24  func NewDeviceSettingsClient(subscriptionID string) DeviceSettingsClient {
    25  	return NewDeviceSettingsClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewDeviceSettingsClientWithBaseURI creates an instance of the DeviceSettingsClient client using a custom endpoint.
    29  // Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    30  func NewDeviceSettingsClientWithBaseURI(baseURI string, subscriptionID string) DeviceSettingsClient {
    31  	return DeviceSettingsClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CreateOrUpdateAlertSettings creates or updates the alert settings of the specified device.
    35  // Parameters:
    36  // deviceName - the device name
    37  // parameters - the alert settings to be added or updated.
    38  // resourceGroupName - the resource group name
    39  // managerName - the manager name
    40  func (client DeviceSettingsClient) CreateOrUpdateAlertSettings(ctx context.Context, deviceName string, parameters AlertSettings, resourceGroupName string, managerName string) (result DeviceSettingsCreateOrUpdateAlertSettingsFuture, err error) {
    41  	if tracing.IsEnabled() {
    42  		ctx = tracing.StartSpan(ctx, fqdn+"/DeviceSettingsClient.CreateOrUpdateAlertSettings")
    43  		defer func() {
    44  			sc := -1
    45  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    46  				sc = result.FutureAPI.Response().StatusCode
    47  			}
    48  			tracing.EndSpan(ctx, sc, err)
    49  		}()
    50  	}
    51  	if err := validation.Validate([]validation.Validation{
    52  		{TargetValue: parameters,
    53  			Constraints: []validation.Constraint{{Target: "parameters.AlertNotificationProperties", Name: validation.Null, Rule: true, Chain: nil}}},
    54  		{TargetValue: managerName,
    55  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
    56  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
    57  		return result, validation.NewError("storsimple.DeviceSettingsClient", "CreateOrUpdateAlertSettings", err.Error())
    58  	}
    59  
    60  	req, err := client.CreateOrUpdateAlertSettingsPreparer(ctx, deviceName, parameters, resourceGroupName, managerName)
    61  	if err != nil {
    62  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "CreateOrUpdateAlertSettings", nil, "Failure preparing request")
    63  		return
    64  	}
    65  
    66  	result, err = client.CreateOrUpdateAlertSettingsSender(req)
    67  	if err != nil {
    68  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "CreateOrUpdateAlertSettings", result.Response(), "Failure sending request")
    69  		return
    70  	}
    71  
    72  	return
    73  }
    74  
    75  // CreateOrUpdateAlertSettingsPreparer prepares the CreateOrUpdateAlertSettings request.
    76  func (client DeviceSettingsClient) CreateOrUpdateAlertSettingsPreparer(ctx context.Context, deviceName string, parameters AlertSettings, resourceGroupName string, managerName string) (*http.Request, error) {
    77  	pathParameters := map[string]interface{}{
    78  		"deviceName":        deviceName,
    79  		"managerName":       managerName,
    80  		"resourceGroupName": resourceGroupName,
    81  		"subscriptionId":    client.SubscriptionID,
    82  	}
    83  
    84  	const APIVersion = "2017-06-01"
    85  	queryParameters := map[string]interface{}{
    86  		"api-version": APIVersion,
    87  	}
    88  
    89  	preparer := autorest.CreatePreparer(
    90  		autorest.AsContentType("application/json; charset=utf-8"),
    91  		autorest.AsPut(),
    92  		autorest.WithBaseURL(client.BaseURI),
    93  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/alertSettings/default", pathParameters),
    94  		autorest.WithJSON(parameters),
    95  		autorest.WithQueryParameters(queryParameters))
    96  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    97  }
    98  
    99  // CreateOrUpdateAlertSettingsSender sends the CreateOrUpdateAlertSettings request. The method will close the
   100  // http.Response Body if it receives an error.
   101  func (client DeviceSettingsClient) CreateOrUpdateAlertSettingsSender(req *http.Request) (future DeviceSettingsCreateOrUpdateAlertSettingsFuture, err error) {
   102  	var resp *http.Response
   103  	future.FutureAPI = &azure.Future{}
   104  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   105  	if err != nil {
   106  		return
   107  	}
   108  	var azf azure.Future
   109  	azf, err = azure.NewFutureFromResponse(resp)
   110  	future.FutureAPI = &azf
   111  	future.Result = future.result
   112  	return
   113  }
   114  
   115  // CreateOrUpdateAlertSettingsResponder handles the response to the CreateOrUpdateAlertSettings request. The method always
   116  // closes the http.Response Body.
   117  func (client DeviceSettingsClient) CreateOrUpdateAlertSettingsResponder(resp *http.Response) (result AlertSettings, err error) {
   118  	err = autorest.Respond(
   119  		resp,
   120  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   121  		autorest.ByUnmarshallingJSON(&result),
   122  		autorest.ByClosing())
   123  	result.Response = autorest.Response{Response: resp}
   124  	return
   125  }
   126  
   127  // CreateOrUpdateTimeSettings creates or updates the time settings of the specified device.
   128  // Parameters:
   129  // deviceName - the device name
   130  // parameters - the time settings to be added or updated.
   131  // resourceGroupName - the resource group name
   132  // managerName - the manager name
   133  func (client DeviceSettingsClient) CreateOrUpdateTimeSettings(ctx context.Context, deviceName string, parameters TimeSettings, resourceGroupName string, managerName string) (result DeviceSettingsCreateOrUpdateTimeSettingsFuture, err error) {
   134  	if tracing.IsEnabled() {
   135  		ctx = tracing.StartSpan(ctx, fqdn+"/DeviceSettingsClient.CreateOrUpdateTimeSettings")
   136  		defer func() {
   137  			sc := -1
   138  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   139  				sc = result.FutureAPI.Response().StatusCode
   140  			}
   141  			tracing.EndSpan(ctx, sc, err)
   142  		}()
   143  	}
   144  	if err := validation.Validate([]validation.Validation{
   145  		{TargetValue: parameters,
   146  			Constraints: []validation.Constraint{{Target: "parameters.TimeSettingsProperties", Name: validation.Null, Rule: true,
   147  				Chain: []validation.Constraint{{Target: "parameters.TimeSettingsProperties.TimeZone", Name: validation.Null, Rule: true, Chain: nil}}}}},
   148  		{TargetValue: managerName,
   149  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   150  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   151  		return result, validation.NewError("storsimple.DeviceSettingsClient", "CreateOrUpdateTimeSettings", err.Error())
   152  	}
   153  
   154  	req, err := client.CreateOrUpdateTimeSettingsPreparer(ctx, deviceName, parameters, resourceGroupName, managerName)
   155  	if err != nil {
   156  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "CreateOrUpdateTimeSettings", nil, "Failure preparing request")
   157  		return
   158  	}
   159  
   160  	result, err = client.CreateOrUpdateTimeSettingsSender(req)
   161  	if err != nil {
   162  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "CreateOrUpdateTimeSettings", result.Response(), "Failure sending request")
   163  		return
   164  	}
   165  
   166  	return
   167  }
   168  
   169  // CreateOrUpdateTimeSettingsPreparer prepares the CreateOrUpdateTimeSettings request.
   170  func (client DeviceSettingsClient) CreateOrUpdateTimeSettingsPreparer(ctx context.Context, deviceName string, parameters TimeSettings, resourceGroupName string, managerName string) (*http.Request, error) {
   171  	pathParameters := map[string]interface{}{
   172  		"deviceName":        deviceName,
   173  		"managerName":       managerName,
   174  		"resourceGroupName": resourceGroupName,
   175  		"subscriptionId":    client.SubscriptionID,
   176  	}
   177  
   178  	const APIVersion = "2017-06-01"
   179  	queryParameters := map[string]interface{}{
   180  		"api-version": APIVersion,
   181  	}
   182  
   183  	preparer := autorest.CreatePreparer(
   184  		autorest.AsContentType("application/json; charset=utf-8"),
   185  		autorest.AsPut(),
   186  		autorest.WithBaseURL(client.BaseURI),
   187  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/timeSettings/default", pathParameters),
   188  		autorest.WithJSON(parameters),
   189  		autorest.WithQueryParameters(queryParameters))
   190  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   191  }
   192  
   193  // CreateOrUpdateTimeSettingsSender sends the CreateOrUpdateTimeSettings request. The method will close the
   194  // http.Response Body if it receives an error.
   195  func (client DeviceSettingsClient) CreateOrUpdateTimeSettingsSender(req *http.Request) (future DeviceSettingsCreateOrUpdateTimeSettingsFuture, err error) {
   196  	var resp *http.Response
   197  	future.FutureAPI = &azure.Future{}
   198  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   199  	if err != nil {
   200  		return
   201  	}
   202  	var azf azure.Future
   203  	azf, err = azure.NewFutureFromResponse(resp)
   204  	future.FutureAPI = &azf
   205  	future.Result = future.result
   206  	return
   207  }
   208  
   209  // CreateOrUpdateTimeSettingsResponder handles the response to the CreateOrUpdateTimeSettings request. The method always
   210  // closes the http.Response Body.
   211  func (client DeviceSettingsClient) CreateOrUpdateTimeSettingsResponder(resp *http.Response) (result TimeSettings, err error) {
   212  	err = autorest.Respond(
   213  		resp,
   214  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   215  		autorest.ByUnmarshallingJSON(&result),
   216  		autorest.ByClosing())
   217  	result.Response = autorest.Response{Response: resp}
   218  	return
   219  }
   220  
   221  // GetAlertSettings gets the alert settings of the specified device.
   222  // Parameters:
   223  // deviceName - the device name
   224  // resourceGroupName - the resource group name
   225  // managerName - the manager name
   226  func (client DeviceSettingsClient) GetAlertSettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (result AlertSettings, err error) {
   227  	if tracing.IsEnabled() {
   228  		ctx = tracing.StartSpan(ctx, fqdn+"/DeviceSettingsClient.GetAlertSettings")
   229  		defer func() {
   230  			sc := -1
   231  			if result.Response.Response != nil {
   232  				sc = result.Response.Response.StatusCode
   233  			}
   234  			tracing.EndSpan(ctx, sc, err)
   235  		}()
   236  	}
   237  	if err := validation.Validate([]validation.Validation{
   238  		{TargetValue: managerName,
   239  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   240  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   241  		return result, validation.NewError("storsimple.DeviceSettingsClient", "GetAlertSettings", err.Error())
   242  	}
   243  
   244  	req, err := client.GetAlertSettingsPreparer(ctx, deviceName, resourceGroupName, managerName)
   245  	if err != nil {
   246  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetAlertSettings", nil, "Failure preparing request")
   247  		return
   248  	}
   249  
   250  	resp, err := client.GetAlertSettingsSender(req)
   251  	if err != nil {
   252  		result.Response = autorest.Response{Response: resp}
   253  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetAlertSettings", resp, "Failure sending request")
   254  		return
   255  	}
   256  
   257  	result, err = client.GetAlertSettingsResponder(resp)
   258  	if err != nil {
   259  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetAlertSettings", resp, "Failure responding to request")
   260  		return
   261  	}
   262  
   263  	return
   264  }
   265  
   266  // GetAlertSettingsPreparer prepares the GetAlertSettings request.
   267  func (client DeviceSettingsClient) GetAlertSettingsPreparer(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (*http.Request, error) {
   268  	pathParameters := map[string]interface{}{
   269  		"deviceName":        deviceName,
   270  		"managerName":       managerName,
   271  		"resourceGroupName": resourceGroupName,
   272  		"subscriptionId":    client.SubscriptionID,
   273  	}
   274  
   275  	const APIVersion = "2017-06-01"
   276  	queryParameters := map[string]interface{}{
   277  		"api-version": APIVersion,
   278  	}
   279  
   280  	preparer := autorest.CreatePreparer(
   281  		autorest.AsGet(),
   282  		autorest.WithBaseURL(client.BaseURI),
   283  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/alertSettings/default", pathParameters),
   284  		autorest.WithQueryParameters(queryParameters))
   285  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   286  }
   287  
   288  // GetAlertSettingsSender sends the GetAlertSettings request. The method will close the
   289  // http.Response Body if it receives an error.
   290  func (client DeviceSettingsClient) GetAlertSettingsSender(req *http.Request) (*http.Response, error) {
   291  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   292  }
   293  
   294  // GetAlertSettingsResponder handles the response to the GetAlertSettings request. The method always
   295  // closes the http.Response Body.
   296  func (client DeviceSettingsClient) GetAlertSettingsResponder(resp *http.Response) (result AlertSettings, err error) {
   297  	err = autorest.Respond(
   298  		resp,
   299  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   300  		autorest.ByUnmarshallingJSON(&result),
   301  		autorest.ByClosing())
   302  	result.Response = autorest.Response{Response: resp}
   303  	return
   304  }
   305  
   306  // GetNetworkSettings gets the network settings of the specified device.
   307  // Parameters:
   308  // deviceName - the device name
   309  // resourceGroupName - the resource group name
   310  // managerName - the manager name
   311  func (client DeviceSettingsClient) GetNetworkSettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (result NetworkSettings, err error) {
   312  	if tracing.IsEnabled() {
   313  		ctx = tracing.StartSpan(ctx, fqdn+"/DeviceSettingsClient.GetNetworkSettings")
   314  		defer func() {
   315  			sc := -1
   316  			if result.Response.Response != nil {
   317  				sc = result.Response.Response.StatusCode
   318  			}
   319  			tracing.EndSpan(ctx, sc, err)
   320  		}()
   321  	}
   322  	if err := validation.Validate([]validation.Validation{
   323  		{TargetValue: managerName,
   324  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   325  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   326  		return result, validation.NewError("storsimple.DeviceSettingsClient", "GetNetworkSettings", err.Error())
   327  	}
   328  
   329  	req, err := client.GetNetworkSettingsPreparer(ctx, deviceName, resourceGroupName, managerName)
   330  	if err != nil {
   331  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetNetworkSettings", nil, "Failure preparing request")
   332  		return
   333  	}
   334  
   335  	resp, err := client.GetNetworkSettingsSender(req)
   336  	if err != nil {
   337  		result.Response = autorest.Response{Response: resp}
   338  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetNetworkSettings", resp, "Failure sending request")
   339  		return
   340  	}
   341  
   342  	result, err = client.GetNetworkSettingsResponder(resp)
   343  	if err != nil {
   344  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetNetworkSettings", resp, "Failure responding to request")
   345  		return
   346  	}
   347  
   348  	return
   349  }
   350  
   351  // GetNetworkSettingsPreparer prepares the GetNetworkSettings request.
   352  func (client DeviceSettingsClient) GetNetworkSettingsPreparer(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (*http.Request, error) {
   353  	pathParameters := map[string]interface{}{
   354  		"deviceName":        deviceName,
   355  		"managerName":       managerName,
   356  		"resourceGroupName": resourceGroupName,
   357  		"subscriptionId":    client.SubscriptionID,
   358  	}
   359  
   360  	const APIVersion = "2017-06-01"
   361  	queryParameters := map[string]interface{}{
   362  		"api-version": APIVersion,
   363  	}
   364  
   365  	preparer := autorest.CreatePreparer(
   366  		autorest.AsGet(),
   367  		autorest.WithBaseURL(client.BaseURI),
   368  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/networkSettings/default", pathParameters),
   369  		autorest.WithQueryParameters(queryParameters))
   370  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   371  }
   372  
   373  // GetNetworkSettingsSender sends the GetNetworkSettings request. The method will close the
   374  // http.Response Body if it receives an error.
   375  func (client DeviceSettingsClient) GetNetworkSettingsSender(req *http.Request) (*http.Response, error) {
   376  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   377  }
   378  
   379  // GetNetworkSettingsResponder handles the response to the GetNetworkSettings request. The method always
   380  // closes the http.Response Body.
   381  func (client DeviceSettingsClient) GetNetworkSettingsResponder(resp *http.Response) (result NetworkSettings, err error) {
   382  	err = autorest.Respond(
   383  		resp,
   384  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   385  		autorest.ByUnmarshallingJSON(&result),
   386  		autorest.ByClosing())
   387  	result.Response = autorest.Response{Response: resp}
   388  	return
   389  }
   390  
   391  // GetSecuritySettings returns the Security properties of the specified device name.
   392  // Parameters:
   393  // deviceName - the device name
   394  // resourceGroupName - the resource group name
   395  // managerName - the manager name
   396  func (client DeviceSettingsClient) GetSecuritySettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (result SecuritySettings, err error) {
   397  	if tracing.IsEnabled() {
   398  		ctx = tracing.StartSpan(ctx, fqdn+"/DeviceSettingsClient.GetSecuritySettings")
   399  		defer func() {
   400  			sc := -1
   401  			if result.Response.Response != nil {
   402  				sc = result.Response.Response.StatusCode
   403  			}
   404  			tracing.EndSpan(ctx, sc, err)
   405  		}()
   406  	}
   407  	if err := validation.Validate([]validation.Validation{
   408  		{TargetValue: managerName,
   409  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   410  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   411  		return result, validation.NewError("storsimple.DeviceSettingsClient", "GetSecuritySettings", err.Error())
   412  	}
   413  
   414  	req, err := client.GetSecuritySettingsPreparer(ctx, deviceName, resourceGroupName, managerName)
   415  	if err != nil {
   416  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetSecuritySettings", nil, "Failure preparing request")
   417  		return
   418  	}
   419  
   420  	resp, err := client.GetSecuritySettingsSender(req)
   421  	if err != nil {
   422  		result.Response = autorest.Response{Response: resp}
   423  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetSecuritySettings", resp, "Failure sending request")
   424  		return
   425  	}
   426  
   427  	result, err = client.GetSecuritySettingsResponder(resp)
   428  	if err != nil {
   429  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetSecuritySettings", resp, "Failure responding to request")
   430  		return
   431  	}
   432  
   433  	return
   434  }
   435  
   436  // GetSecuritySettingsPreparer prepares the GetSecuritySettings request.
   437  func (client DeviceSettingsClient) GetSecuritySettingsPreparer(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (*http.Request, error) {
   438  	pathParameters := map[string]interface{}{
   439  		"deviceName":        deviceName,
   440  		"managerName":       managerName,
   441  		"resourceGroupName": resourceGroupName,
   442  		"subscriptionId":    client.SubscriptionID,
   443  	}
   444  
   445  	const APIVersion = "2017-06-01"
   446  	queryParameters := map[string]interface{}{
   447  		"api-version": APIVersion,
   448  	}
   449  
   450  	preparer := autorest.CreatePreparer(
   451  		autorest.AsGet(),
   452  		autorest.WithBaseURL(client.BaseURI),
   453  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/securitySettings/default", pathParameters),
   454  		autorest.WithQueryParameters(queryParameters))
   455  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   456  }
   457  
   458  // GetSecuritySettingsSender sends the GetSecuritySettings request. The method will close the
   459  // http.Response Body if it receives an error.
   460  func (client DeviceSettingsClient) GetSecuritySettingsSender(req *http.Request) (*http.Response, error) {
   461  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   462  }
   463  
   464  // GetSecuritySettingsResponder handles the response to the GetSecuritySettings request. The method always
   465  // closes the http.Response Body.
   466  func (client DeviceSettingsClient) GetSecuritySettingsResponder(resp *http.Response) (result SecuritySettings, err error) {
   467  	err = autorest.Respond(
   468  		resp,
   469  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   470  		autorest.ByUnmarshallingJSON(&result),
   471  		autorest.ByClosing())
   472  	result.Response = autorest.Response{Response: resp}
   473  	return
   474  }
   475  
   476  // GetTimeSettings gets the time settings of the specified device.
   477  // Parameters:
   478  // deviceName - the device name
   479  // resourceGroupName - the resource group name
   480  // managerName - the manager name
   481  func (client DeviceSettingsClient) GetTimeSettings(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (result TimeSettings, err error) {
   482  	if tracing.IsEnabled() {
   483  		ctx = tracing.StartSpan(ctx, fqdn+"/DeviceSettingsClient.GetTimeSettings")
   484  		defer func() {
   485  			sc := -1
   486  			if result.Response.Response != nil {
   487  				sc = result.Response.Response.StatusCode
   488  			}
   489  			tracing.EndSpan(ctx, sc, err)
   490  		}()
   491  	}
   492  	if err := validation.Validate([]validation.Validation{
   493  		{TargetValue: managerName,
   494  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   495  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   496  		return result, validation.NewError("storsimple.DeviceSettingsClient", "GetTimeSettings", err.Error())
   497  	}
   498  
   499  	req, err := client.GetTimeSettingsPreparer(ctx, deviceName, resourceGroupName, managerName)
   500  	if err != nil {
   501  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetTimeSettings", nil, "Failure preparing request")
   502  		return
   503  	}
   504  
   505  	resp, err := client.GetTimeSettingsSender(req)
   506  	if err != nil {
   507  		result.Response = autorest.Response{Response: resp}
   508  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetTimeSettings", resp, "Failure sending request")
   509  		return
   510  	}
   511  
   512  	result, err = client.GetTimeSettingsResponder(resp)
   513  	if err != nil {
   514  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "GetTimeSettings", resp, "Failure responding to request")
   515  		return
   516  	}
   517  
   518  	return
   519  }
   520  
   521  // GetTimeSettingsPreparer prepares the GetTimeSettings request.
   522  func (client DeviceSettingsClient) GetTimeSettingsPreparer(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (*http.Request, error) {
   523  	pathParameters := map[string]interface{}{
   524  		"deviceName":        deviceName,
   525  		"managerName":       managerName,
   526  		"resourceGroupName": resourceGroupName,
   527  		"subscriptionId":    client.SubscriptionID,
   528  	}
   529  
   530  	const APIVersion = "2017-06-01"
   531  	queryParameters := map[string]interface{}{
   532  		"api-version": APIVersion,
   533  	}
   534  
   535  	preparer := autorest.CreatePreparer(
   536  		autorest.AsGet(),
   537  		autorest.WithBaseURL(client.BaseURI),
   538  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/timeSettings/default", pathParameters),
   539  		autorest.WithQueryParameters(queryParameters))
   540  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   541  }
   542  
   543  // GetTimeSettingsSender sends the GetTimeSettings request. The method will close the
   544  // http.Response Body if it receives an error.
   545  func (client DeviceSettingsClient) GetTimeSettingsSender(req *http.Request) (*http.Response, error) {
   546  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   547  }
   548  
   549  // GetTimeSettingsResponder handles the response to the GetTimeSettings request. The method always
   550  // closes the http.Response Body.
   551  func (client DeviceSettingsClient) GetTimeSettingsResponder(resp *http.Response) (result TimeSettings, err error) {
   552  	err = autorest.Respond(
   553  		resp,
   554  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   555  		autorest.ByUnmarshallingJSON(&result),
   556  		autorest.ByClosing())
   557  	result.Response = autorest.Response{Response: resp}
   558  	return
   559  }
   560  
   561  // SyncRemotemanagementCertificate sync Remote management Certificate between appliance and Service
   562  // Parameters:
   563  // deviceName - the device name
   564  // resourceGroupName - the resource group name
   565  // managerName - the manager name
   566  func (client DeviceSettingsClient) SyncRemotemanagementCertificate(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (result DeviceSettingsSyncRemotemanagementCertificateFuture, err error) {
   567  	if tracing.IsEnabled() {
   568  		ctx = tracing.StartSpan(ctx, fqdn+"/DeviceSettingsClient.SyncRemotemanagementCertificate")
   569  		defer func() {
   570  			sc := -1
   571  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   572  				sc = result.FutureAPI.Response().StatusCode
   573  			}
   574  			tracing.EndSpan(ctx, sc, err)
   575  		}()
   576  	}
   577  	if err := validation.Validate([]validation.Validation{
   578  		{TargetValue: managerName,
   579  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   580  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   581  		return result, validation.NewError("storsimple.DeviceSettingsClient", "SyncRemotemanagementCertificate", err.Error())
   582  	}
   583  
   584  	req, err := client.SyncRemotemanagementCertificatePreparer(ctx, deviceName, resourceGroupName, managerName)
   585  	if err != nil {
   586  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "SyncRemotemanagementCertificate", nil, "Failure preparing request")
   587  		return
   588  	}
   589  
   590  	result, err = client.SyncRemotemanagementCertificateSender(req)
   591  	if err != nil {
   592  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "SyncRemotemanagementCertificate", result.Response(), "Failure sending request")
   593  		return
   594  	}
   595  
   596  	return
   597  }
   598  
   599  // SyncRemotemanagementCertificatePreparer prepares the SyncRemotemanagementCertificate request.
   600  func (client DeviceSettingsClient) SyncRemotemanagementCertificatePreparer(ctx context.Context, deviceName string, resourceGroupName string, managerName string) (*http.Request, error) {
   601  	pathParameters := map[string]interface{}{
   602  		"deviceName":        deviceName,
   603  		"managerName":       managerName,
   604  		"resourceGroupName": resourceGroupName,
   605  		"subscriptionId":    client.SubscriptionID,
   606  	}
   607  
   608  	const APIVersion = "2017-06-01"
   609  	queryParameters := map[string]interface{}{
   610  		"api-version": APIVersion,
   611  	}
   612  
   613  	preparer := autorest.CreatePreparer(
   614  		autorest.AsPost(),
   615  		autorest.WithBaseURL(client.BaseURI),
   616  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/securitySettings/default/syncRemoteManagementCertificate", pathParameters),
   617  		autorest.WithQueryParameters(queryParameters))
   618  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   619  }
   620  
   621  // SyncRemotemanagementCertificateSender sends the SyncRemotemanagementCertificate request. The method will close the
   622  // http.Response Body if it receives an error.
   623  func (client DeviceSettingsClient) SyncRemotemanagementCertificateSender(req *http.Request) (future DeviceSettingsSyncRemotemanagementCertificateFuture, err error) {
   624  	var resp *http.Response
   625  	future.FutureAPI = &azure.Future{}
   626  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   627  	if err != nil {
   628  		return
   629  	}
   630  	var azf azure.Future
   631  	azf, err = azure.NewFutureFromResponse(resp)
   632  	future.FutureAPI = &azf
   633  	future.Result = future.result
   634  	return
   635  }
   636  
   637  // SyncRemotemanagementCertificateResponder handles the response to the SyncRemotemanagementCertificate request. The method always
   638  // closes the http.Response Body.
   639  func (client DeviceSettingsClient) SyncRemotemanagementCertificateResponder(resp *http.Response) (result autorest.Response, err error) {
   640  	err = autorest.Respond(
   641  		resp,
   642  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   643  		autorest.ByClosing())
   644  	result.Response = resp
   645  	return
   646  }
   647  
   648  // UpdateNetworkSettings updates the network settings on the specified device.
   649  // Parameters:
   650  // deviceName - the device name
   651  // parameters - the network settings to be updated.
   652  // resourceGroupName - the resource group name
   653  // managerName - the manager name
   654  func (client DeviceSettingsClient) UpdateNetworkSettings(ctx context.Context, deviceName string, parameters NetworkSettingsPatch, resourceGroupName string, managerName string) (result DeviceSettingsUpdateNetworkSettingsFuture, err error) {
   655  	if tracing.IsEnabled() {
   656  		ctx = tracing.StartSpan(ctx, fqdn+"/DeviceSettingsClient.UpdateNetworkSettings")
   657  		defer func() {
   658  			sc := -1
   659  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   660  				sc = result.FutureAPI.Response().StatusCode
   661  			}
   662  			tracing.EndSpan(ctx, sc, err)
   663  		}()
   664  	}
   665  	if err := validation.Validate([]validation.Validation{
   666  		{TargetValue: managerName,
   667  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   668  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   669  		return result, validation.NewError("storsimple.DeviceSettingsClient", "UpdateNetworkSettings", err.Error())
   670  	}
   671  
   672  	req, err := client.UpdateNetworkSettingsPreparer(ctx, deviceName, parameters, resourceGroupName, managerName)
   673  	if err != nil {
   674  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "UpdateNetworkSettings", nil, "Failure preparing request")
   675  		return
   676  	}
   677  
   678  	result, err = client.UpdateNetworkSettingsSender(req)
   679  	if err != nil {
   680  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "UpdateNetworkSettings", result.Response(), "Failure sending request")
   681  		return
   682  	}
   683  
   684  	return
   685  }
   686  
   687  // UpdateNetworkSettingsPreparer prepares the UpdateNetworkSettings request.
   688  func (client DeviceSettingsClient) UpdateNetworkSettingsPreparer(ctx context.Context, deviceName string, parameters NetworkSettingsPatch, resourceGroupName string, managerName string) (*http.Request, error) {
   689  	pathParameters := map[string]interface{}{
   690  		"deviceName":        deviceName,
   691  		"managerName":       managerName,
   692  		"resourceGroupName": resourceGroupName,
   693  		"subscriptionId":    client.SubscriptionID,
   694  	}
   695  
   696  	const APIVersion = "2017-06-01"
   697  	queryParameters := map[string]interface{}{
   698  		"api-version": APIVersion,
   699  	}
   700  
   701  	preparer := autorest.CreatePreparer(
   702  		autorest.AsContentType("application/json; charset=utf-8"),
   703  		autorest.AsPatch(),
   704  		autorest.WithBaseURL(client.BaseURI),
   705  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/networkSettings/default", pathParameters),
   706  		autorest.WithJSON(parameters),
   707  		autorest.WithQueryParameters(queryParameters))
   708  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   709  }
   710  
   711  // UpdateNetworkSettingsSender sends the UpdateNetworkSettings request. The method will close the
   712  // http.Response Body if it receives an error.
   713  func (client DeviceSettingsClient) UpdateNetworkSettingsSender(req *http.Request) (future DeviceSettingsUpdateNetworkSettingsFuture, err error) {
   714  	var resp *http.Response
   715  	future.FutureAPI = &azure.Future{}
   716  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   717  	if err != nil {
   718  		return
   719  	}
   720  	var azf azure.Future
   721  	azf, err = azure.NewFutureFromResponse(resp)
   722  	future.FutureAPI = &azf
   723  	future.Result = future.result
   724  	return
   725  }
   726  
   727  // UpdateNetworkSettingsResponder handles the response to the UpdateNetworkSettings request. The method always
   728  // closes the http.Response Body.
   729  func (client DeviceSettingsClient) UpdateNetworkSettingsResponder(resp *http.Response) (result NetworkSettings, err error) {
   730  	err = autorest.Respond(
   731  		resp,
   732  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   733  		autorest.ByUnmarshallingJSON(&result),
   734  		autorest.ByClosing())
   735  	result.Response = autorest.Response{Response: resp}
   736  	return
   737  }
   738  
   739  // UpdateSecuritySettings patch Security properties of the specified device name.
   740  // Parameters:
   741  // deviceName - the device name
   742  // parameters - the security settings properties to be patched.
   743  // resourceGroupName - the resource group name
   744  // managerName - the manager name
   745  func (client DeviceSettingsClient) UpdateSecuritySettings(ctx context.Context, deviceName string, parameters SecuritySettingsPatch, resourceGroupName string, managerName string) (result DeviceSettingsUpdateSecuritySettingsFuture, err error) {
   746  	if tracing.IsEnabled() {
   747  		ctx = tracing.StartSpan(ctx, fqdn+"/DeviceSettingsClient.UpdateSecuritySettings")
   748  		defer func() {
   749  			sc := -1
   750  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   751  				sc = result.FutureAPI.Response().StatusCode
   752  			}
   753  			tracing.EndSpan(ctx, sc, err)
   754  		}()
   755  	}
   756  	if err := validation.Validate([]validation.Validation{
   757  		{TargetValue: managerName,
   758  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   759  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   760  		return result, validation.NewError("storsimple.DeviceSettingsClient", "UpdateSecuritySettings", err.Error())
   761  	}
   762  
   763  	req, err := client.UpdateSecuritySettingsPreparer(ctx, deviceName, parameters, resourceGroupName, managerName)
   764  	if err != nil {
   765  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "UpdateSecuritySettings", nil, "Failure preparing request")
   766  		return
   767  	}
   768  
   769  	result, err = client.UpdateSecuritySettingsSender(req)
   770  	if err != nil {
   771  		err = autorest.NewErrorWithError(err, "storsimple.DeviceSettingsClient", "UpdateSecuritySettings", result.Response(), "Failure sending request")
   772  		return
   773  	}
   774  
   775  	return
   776  }
   777  
   778  // UpdateSecuritySettingsPreparer prepares the UpdateSecuritySettings request.
   779  func (client DeviceSettingsClient) UpdateSecuritySettingsPreparer(ctx context.Context, deviceName string, parameters SecuritySettingsPatch, resourceGroupName string, managerName string) (*http.Request, error) {
   780  	pathParameters := map[string]interface{}{
   781  		"deviceName":        deviceName,
   782  		"managerName":       managerName,
   783  		"resourceGroupName": resourceGroupName,
   784  		"subscriptionId":    client.SubscriptionID,
   785  	}
   786  
   787  	const APIVersion = "2017-06-01"
   788  	queryParameters := map[string]interface{}{
   789  		"api-version": APIVersion,
   790  	}
   791  
   792  	preparer := autorest.CreatePreparer(
   793  		autorest.AsContentType("application/json; charset=utf-8"),
   794  		autorest.AsPatch(),
   795  		autorest.WithBaseURL(client.BaseURI),
   796  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/securitySettings/default", pathParameters),
   797  		autorest.WithJSON(parameters),
   798  		autorest.WithQueryParameters(queryParameters))
   799  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   800  }
   801  
   802  // UpdateSecuritySettingsSender sends the UpdateSecuritySettings request. The method will close the
   803  // http.Response Body if it receives an error.
   804  func (client DeviceSettingsClient) UpdateSecuritySettingsSender(req *http.Request) (future DeviceSettingsUpdateSecuritySettingsFuture, err error) {
   805  	var resp *http.Response
   806  	future.FutureAPI = &azure.Future{}
   807  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   808  	if err != nil {
   809  		return
   810  	}
   811  	var azf azure.Future
   812  	azf, err = azure.NewFutureFromResponse(resp)
   813  	future.FutureAPI = &azf
   814  	future.Result = future.result
   815  	return
   816  }
   817  
   818  // UpdateSecuritySettingsResponder handles the response to the UpdateSecuritySettings request. The method always
   819  // closes the http.Response Body.
   820  func (client DeviceSettingsClient) UpdateSecuritySettingsResponder(resp *http.Response) (result SecuritySettings, err error) {
   821  	err = autorest.Respond(
   822  		resp,
   823  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   824  		autorest.ByUnmarshallingJSON(&result),
   825  		autorest.ByClosing())
   826  	result.Response = autorest.Response{Response: resp}
   827  	return
   828  }
   829  

View as plain text