public async Task <HttpResponseMessage> UpdateDevice(UpdateDeviceRequest updateDeviceRequest)
{
var content = IntegrationHttpRequest.CreateContentRequest(updateDeviceRequest);
HttpResponseMessage response = await client.PutAsync(UrlBase + "api/v1/update-device", content);
return(response);
}
public void Update_WithValidParameters_DeviceIsUpdated()
{
//Arrange
var dbContext = DbContextMocker.GetDbContext(nameof(Update_WithValidParameters_DeviceIsUpdated));
var devicesController = new DevicesController(dbContext);
var updateDeviceRequest = new UpdateDeviceRequest
{
Name = "updatedName",
Location = "updatedLocation"
};
var expectedDevice = new Device
{
Device_id = 1,
Name = "updatedName",
Location = "updatedLocation"
};
//Act
var response = devicesController.Update(1, updateDeviceRequest);
var result = (ObjectResult)response.Result;
var deviceReceived = result.Value.As <Device>();
dbContext.Dispose();
//Assert
result.StatusCode.Should().Be((int)HttpStatusCode.OK);
Assert.True(DevicesComparer.CompareDevices(deviceReceived, expectedDevice), "The device received is different " +
"than the expected.");
}
public async Task <ResponseDTO> Update(UpdateDeviceRequest device)
{
if (ModelState.IsValid)
{
return(await _deviceApplicationService.UpdateDeviceAsync(device));
}
return(ModelState.ToResponse());
}
public async Task <bool> UpdateDeviceAsync(UpdateDeviceRequest request)
{
var result = await UpdateAsync(_mapper.Map <DomainModel.Device>(request));
await SaveAsync();
return(result);
}
public static bool CompareDeviceWithDeviceRequest(Device device, UpdateDeviceRequest deviceRequest)
{
if ((!device.Name.Equals(deviceRequest.Name) ||
!device.Location.Equals(deviceRequest.Location)))
{
return(false);
}
return(true);
}
public async Task TestUpdateDevice(UpdateDeviceRequest obj, ObjectResult resultAction, bool elementCreated = false)
{
var createdcompanyId = DeviceComponentsValues.GetDeviceAviability();
obj.Id = elementCreated == true ? createdcompanyId : obj.Id;
HttpResponseMessage actionResult = await _deviceAPI.UpdateDevice(obj);
base.CheckAssert(actionResult, resultAction);
}
public async Task TestUpdateDevice(UpdateDeviceRequest obj, ObjectResult resultAction, bool elementCreated = false)
{
DeviceResponse defaultCompany = await this.CreatedDefaultDevice();
obj.Id = elementCreated == true ? defaultCompany.Id : obj.Id;
IActionResult actionResult = await this.UpdateDevice(obj);
base.CheckAssert(actionResult, resultAction);
}
/// <summary>
/// 修改设备
/// </summary>
public async Task <UpdateDeviceResponse> UpdateDeviceAsync(UpdateDeviceRequest updateDeviceRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
urlParam.Add("device_id", updateDeviceRequest.DeviceId.ToString());
string urlPath = HttpUtils.AddUrlPath("/v5/iot/{project_id}/devices/{device_id}", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json", updateDeviceRequest);
HttpResponseMessage response = await DoHttpRequestAsync("PUT", request);
return(JsonUtils.DeSerialize <UpdateDeviceResponse>(response));
}
protected override async Task <Entity> UpdateAsync(IDictionary <string, object> propertyUpdates, IDictionary <string, string> attributeUpdates, IEnumerable <string> addedTags, IEnumerable <string> removedTags, int specificRevision)
{
var request = new UpdateDeviceRequest()
{
SessionToken = AppacitiveContext.SessionToken,
Environment = AppacitiveContext.Environment,
UserToken = AppacitiveContext.UserToken,
Verbosity = AppacitiveContext.Verbosity,
Revision = specificRevision,
Id = this.Id
};
if (propertyUpdates != null && propertyUpdates.Count > 0)
{
propertyUpdates.For(x => request.PropertyUpdates[x.Key] = x.Value);
}
if (attributeUpdates != null && attributeUpdates.Count > 0)
{
attributeUpdates.For(x => request.AttributeUpdates[x.Key] = x.Value);
}
if (addedTags != null)
{
request.AddedTags.AddRange(addedTags);
}
if (removedTags != null)
{
request.RemovedTags.AddRange(removedTags);
}
// Check if an update is needed.
if (request.PropertyUpdates.Count == 0 &&
request.AttributeUpdates.Count == 0 &&
request.AddedTags.Count == 0 &&
request.RemovedTags.Count == 0)
{
return(null);
}
var response = await request.ExecuteAsync();
if (response.Status.IsSuccessful == false)
{
throw response.Status.ToFault();
}
// 3. Update the last known state based on the differences
Debug.Assert(response.Device != null, "If status is successful, then updated device should not be null.");
return(response.Device);
}
public async Task <IActionResult> Update([FromRoute] int id, [FromBody] UpdateDeviceRequest request)
{
if (id <= default(int))
{
return(BadRequest("Id should be more then 0"));
}
var device = _mapper.Map <Contracts.Entities.Device>(request);
device.Id = id;
await _deviceService.UpdateDevice(device);
return(Ok());
}
public async Task <IActionResult> Put(int id, [FromBody] UpdateDeviceRequest request)
{
try {
await _repository.UpdateAsync(id, request);
} catch (DbUpdateConcurrencyException) {
if (!await _repository.ExistsAsync(id))
{
return(NotFound());
}
throw;
}
return(NoContent());
}
public async Task <IActionResult> Update(int id, [FromBody] UpdateDeviceRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
await _devicesRepository.Update(id, request);
return(NoContent());
}
catch (InvalidDeviceException)
{
return(NotFound());
}
catch (InvalidOfficeException)
{
string errorText = String.Format("Office with ID: {0} doesn't exist", request.OfficeId);
return(StatusCode(StatusCodes.Status409Conflict, new { Message = errorText }));
}
catch (InvalidBrandException)
{
string errorText = String.Format("Brand with ID: {0} doesn't exist", request.BrandId);
return(StatusCode(StatusCodes.Status409Conflict, new { Message = errorText }));
}
catch (InvalidModelException)
{
string errorText = String.Format("Model with ID: {0} doesn't exist", request.ModelId);
return(StatusCode(StatusCodes.Status409Conflict, new { Message = errorText }));
}
catch (DuplicateDeviceSerialNumberException)
{
string errorText = String.Format("Device with Serial number: {0} already exist", request.SerialNum);
return(StatusCode(StatusCodes.Status409Conflict, new { Message = errorText }));
}
catch (DuplicateModelException)
{
string errorText = String.Format("Model with name: {0} already exist", request.ModelName);
return(StatusCode(StatusCodes.Status409Conflict, new { Message = errorText }));
}
catch (DuplicateDeviceIdentificationNumberException)
{
string errorText = String.Format("Device with identification number: {0} already exist", request.IdentificationNum);
return(StatusCode(StatusCodes.Status409Conflict, new { Message = errorText }));
}
}
public async Task <ResponseDTO> UpdateDeviceAsync(UpdateDeviceRequest device)
{
//Map to Command
var command = _mapper.Map <UpdateDeviceRequest, UpdateDeviceCommand>(device);
var response = await ValidateCellphoneAndUser(device.CellphoneNumber, device.AssignedAmigoTenantTUserId);
if (response.IsValid)
{
//Execute Command
var resp = await _bus.SendAsync(command);
ResponseBuilder.Correct(resp);
}
return(response);
}
public async Task UpdateDevice_Call()
{
//-------------- Arrange -------------
CommonArrangements();
var request = new UpdateDeviceRequest();
var command = new UpdateDeviceCommand();
A.CallTo(() => mapper.Map <UpdateDeviceRequest, UpdateDeviceCommand>(request)).Returns(command);
//-------------- Act -------------
var resp = deviceService.UpdateDeviceAsync(request);
//-------------- Assert -------------
A.CallTo(() => bus.SendAsync(command)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task Rename(UpdateDeviceRequest device)
{
using (IUnitOfWork uow = factory.Create())
{
IDeviceRepository devicesRepository = uow.GetDeviceRepository();
Device existDevice = await devicesRepository.GetById(device.Id);
if (existDevice == null)
{
throw new Exception("Запись с таким id не найдена");
}
existDevice.Name = device.Name;
await devicesRepository.Update(existDevice);
uow.Commit();
}
}
public async Task Update_WithoutAnExistingDevice_ReturnNotFound()
{
//Arrange
int nonExistingDeviceId = 99;
UpdateDeviceRequest deviceRequest = new UpdateDeviceRequest {
Name = "integrationTestNameUpdated1", Location = "integrationTestLocationUpdated1"
};
var updatePayload = JsonConvert.SerializeObject(deviceRequest);
HttpContent updateContent = new StringContent(updatePayload, Encoding.UTF8, "application/json");
string requestUri = $"Devices/{nonExistingDeviceId}";
// Act
var response = await HttpClient.PutAsync(requestUri, updateContent);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
private async Task <IActionResult> UpdateDevice(UpdateDeviceRequest updateDeviceRequest)
{
var options = new DbContextOptionsBuilder <Context>()
.UseInMemoryDatabase(databaseName: "Device")
.Options;
// Run the test against one instance of the context
using (var context = new Context(options))
{
var repository = new DeviceRepository(context, AutomapperSingleton.Mapper);
var service = new DeviceService(repository, AutomapperSingleton.Mapper);
var controller = new DeviceController(service);
Mock <HttpRequest> mockCreateRequest = MockHttpRequest.CreateMockRequest(updateDeviceRequest);
return(await controller.UpdateDeviceAsync(mockCreateRequest.Object, _logger)); //as GridController;
}
}
public void TestUpdateDevice()
{
var client = new DefaultOneNETClient(url, appkey, "");
var device = new DeviceBasicInfo
{
Title = "测试修改C# SDK的返回结果",
Desc = "一次通过一次通过一次通过了吗？（update）",
//Private = true,
OnLine = true,
//Tags = new[] { "测试", "sdk" },
//Location = new LocationInfo(370000, 27.609997, 178.03403)
};
var req = new UpdateDeviceRequest {
DeviceID = 776941, DeviceInfo = device
};
var resp = client.Execute(req);
Assert.IsFalse(resp.IsError);
}
public async Task <IActionResult> UpdateDevice([FromRoute] string deviceId, [FromBody] UpdateDeviceRequest request)
{
var user = await UserManager.GetUserAsync(User);
if (user == null)
{
return(NotFound());
}
var device = await DbContext.UserDevices.SingleOrDefaultAsync(x => x.UserId == user.Id && x.DeviceId == deviceId);
if (device is null)
{
return(NotFound());
}
var shouldEnablePushNotifications = !string.IsNullOrWhiteSpace(request.PnsHandle);
var shouldUnRegisterDevice = device.IsPushNotificationsEnabled && !shouldEnablePushNotifications;
var shouldRegisterDevice = !device.IsPushNotificationsEnabled && shouldEnablePushNotifications;
try {
if (shouldUnRegisterDevice)
{
await PushNotificationService.UnRegister(deviceId);
}
if (shouldRegisterDevice)
{
await PushNotificationService.Register(device.DeviceId, request.PnsHandle, device.Platform, user.Id, request.Tags?.ToArray());
}
} catch (Exception exception) {
Logger.LogError("An exception occurred when connection to Azure Notification Hubs. Exception is '{Exception}'. Inner Exception is '{InnerException}'.", exception.Message, exception.InnerException?.Message ?? "N/A");
throw;
}
device.IsPushNotificationsEnabled = shouldEnablePushNotifications;
device.Name = request.Name;
device.Model = request.Model;
device.OsVersion = request.OsVersion;
device.Data = request.Data;
await DbContext.SaveChangesAsync();
var @event = new DeviceUpdatedEvent(DeviceInfo.FromUserDevice(device), SingleUserInfo.FromUser(user));
await EventService.Publish(@event);
return(NoContent());
}
public async Task Update_WithValidParameters_DeviceWasUpdated()
{
//Arrange
CreateDeviceRequest deviceCreateRequest = new CreateDeviceRequest {
Name = "integrationTestName1", Location = "integrationTestLocation1"
};
var insertSqlString = $"Insert into Devices (Name, Location) values('{deviceCreateRequest.Name}', '{deviceCreateRequest.Location}')";
ExecuteNonQuery(insertSqlString);
var selectSqlString = $"Select * from Devices WHERE Name = '{deviceCreateRequest.Name}'";
var device = ExecuteDevicesQuery(selectSqlString);
Assert.NotNull(device);
UpdateDeviceRequest deviceUpdateRequest = new UpdateDeviceRequest {
Name = "integrationTestNameUpdated1", Location = "integrationTestLocationUpdated1"
};
var updatePayload = JsonConvert.SerializeObject(deviceUpdateRequest);
HttpContent updateContent = new StringContent(updatePayload, Encoding.UTF8, "application/json");
string requestUri = $"Devices/{device.Device_id}";
// Act
var response = await HttpClient.PutAsync(requestUri, updateContent);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
selectSqlString = $"Select * from Devices WHERE Name = '{deviceUpdateRequest.Name}'";
var receivedUpdatedDevice = ExecuteDevicesQuery(selectSqlString);
Assert.NotNull(receivedUpdatedDevice);
Assert.True(DevicesComparer.CompareDeviceWithDeviceRequest(receivedUpdatedDevice, deviceUpdateRequest), "The device was not updated.");
//Clean Up
var cleanUpSqlString = $"DELETE FROM Devices WHERE Name = '{deviceUpdateRequest.Name}'";
var cleanedUp = ExecuteNonQuery(cleanUpSqlString);
Assert.True(cleanedUp, "It was not possible to clean up the database.");
}
public async Task <Device> UpdateDevice(Guid deviceId, UpdateDeviceRequest updateDeviceRequest)
{
var existingDevice = await _dbContext.Devices.AsTracking().FirstOrDefaultAsync(d => d.Id == deviceId);
if (existingDevice == null)
{
throw new KeyNotFoundException();
}
existingDevice.DeviceIdentifier = updateDeviceRequest.DeviceIdentifier;
existingDevice.IpAddress = updateDeviceRequest.IpAddress;
existingDevice.Type = updateDeviceRequest.Type;
existingDevice.ClientId = updateDeviceRequest.ClientId;
existingDevice.BuildingId = updateDeviceRequest.BuildingId;
_dbContext.Devices.Update(existingDevice);
await _dbContext.SaveChangesAsync();
return(existingDevice);
}
public void Update_WithoutAnExistingDevice_ReturnNotFound()
{
//Arrange
var dbContext = DbContextMocker.GetDbContext(nameof(Update_WithoutAnExistingDevice_ReturnNotFound));
var devicesController = new DevicesController(dbContext);
var updateDeviceRequest = new UpdateDeviceRequest
{
Name = "updatedName",
Location = "updatedLocation"
};
//Act
var response = devicesController.Update(4, updateDeviceRequest);
var result = (ObjectResult)response.Result;
var deviceReceived = result.Value.As <Device>();
dbContext.Dispose();
//Assert
result.StatusCode.Should().Be((int)HttpStatusCode.NotFound);
}
public async Task <IActionResult> Update(int id, UpdateDeviceRequest updateDeviceRequest)
{
var currentDevice = _context.Devices.SingleOrDefault(device => device.Device_id == id);
if (currentDevice == null)
{
return(NotFound("No device was found with the inserted device_id: " + id));
}
currentDevice.Name = updateDeviceRequest.Name;
currentDevice.Location = updateDeviceRequest.Location;
_context.Devices.Update(currentDevice);
var numerOfUpdates = await _context.SaveChangesAsync();
if (numerOfUpdates > 0)
{
return(Ok(currentDevice));
}
return(NotFound("No device was found with the inserted device_id: " + id));
}
private static void updateDevice(IoTDAClient client)
{
UpdateDeviceRequest req = new UpdateDeviceRequest
{
DeviceId = "5e25d39a3b7c24fa3638804b_1211211",
Body = new UpdateDevice()
{
DeviceName = "test",
Description = "dfsdfgfgvfdfddfvdf",
AuthInfo = new AuthInfoWithoutSecret()
{
SecureAccess = true,
Timeout = 0
}
}
};
try
{
var resp = client.UpdateDevice(req);
Console.WriteLine(resp);
}
catch (RequestTimeoutException requestTimeoutException)
{
Console.WriteLine(requestTimeoutException.ErrorMessage);
}
catch (ServiceResponseException clientRequestException)
{
Console.WriteLine(clientRequestException.HttpStatusCode);
Console.WriteLine(clientRequestException.ErrorCode);
Console.WriteLine(clientRequestException.ErrorMsg);
}
catch (ConnectionException connectionException)
{
Console.WriteLine(connectionException.ErrorMessage);
}
}
public async Task <UpdateDeviceResponse> UpdateDeviceAsync(UpdateDeviceRequest request)
{
AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
return(await UpdateDeviceWithOptionsAsync(request, runtime));
}
private UpdateDeviceRequest CreateUpdateRequest(EntityChanges changes, int specificRevision, ApiOptions options)
{
var request = new UpdateDeviceRequest()
{
Revision = specificRevision,
Id = this.Id
};
ApiOptions.Apply(request, options);
if (changes.PropertyUpdates != null && changes.PropertyUpdates.Count > 0)
changes.PropertyUpdates.For(x => request.PropertyUpdates[x.Key] = x.Value);
if (changes.AttributeUpdates != null && changes.AttributeUpdates.Count > 0)
changes.AttributeUpdates.For(x => request.AttributeUpdates[x.Key] = x.Value);
if (changes.AddedTags != null)
request.AddedTags.AddRange(changes.AddedTags);
if (changes.RemovedTags != null)
request.RemovedTags.AddRange(changes.RemovedTags);
return request;
}
public async Task <UpdateDeviceResponse> UpdateDeviceAsync(UpdateDeviceRequest updateDeviceRequest)
{
return(await _onenetClient.ExecuteAsync <UpdateDeviceResponse>(updateDeviceRequest));
}
/// <summary>
/// 修改设备详情
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public async Task <UpdateDeviceResponse> UpdateDevice(UpdateDeviceRequest request)
{
return(await new UpdateDeviceExecutor().Client(this).Execute <UpdateDeviceResponse, UpdateDeviceResult, UpdateDeviceRequest>(request).ConfigureAwait(false));
}
/// <summary>
/// 修改设备详情
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public UpdateDeviceResponse UpdateDevice(UpdateDeviceRequest request)
{
return(new UpdateDeviceExecutor().Client(this).Execute <UpdateDeviceResponse, UpdateDeviceResult, UpdateDeviceRequest>(request));
}
public async Task <bool> UpdateDeviceAsync(UpdateDeviceRequest request)
{
var result = await _deviceRepository.UpdateDeviceAsync(request);
return(result);
}
public UpdateDeviceResponse UpdateDevice(UpdateDeviceRequest request)
{
AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
return(UpdateDeviceWithOptions(request, runtime));
}
protected override async Task<Entity> UpdateAsync(IDictionary<string, object> propertyUpdates, IDictionary<string, string> attributeUpdates, IEnumerable<string> addedTags, IEnumerable<string> removedTags, int specificRevision)
{
var request = new UpdateDeviceRequest()
{
SessionToken = AppacitiveContext.SessionToken,
Environment = AppacitiveContext.Environment,
UserToken = AppacitiveContext.UserToken,
Verbosity = AppacitiveContext.Verbosity,
Revision = specificRevision,
Id = this.Id
};
if (propertyUpdates != null && propertyUpdates.Count > 0)
propertyUpdates.For(x => request.PropertyUpdates[x.Key] = x.Value);
if (attributeUpdates != null && attributeUpdates.Count > 0)
attributeUpdates.For(x => request.AttributeUpdates[x.Key] = x.Value);
if (addedTags != null)
request.AddedTags.AddRange(addedTags);
if (removedTags != null)
request.RemovedTags.AddRange(removedTags);
// Check if an update is needed.
if (request.PropertyUpdates.Count == 0 &&
request.AttributeUpdates.Count == 0 &&
request.AddedTags.Count == 0 &&
request.RemovedTags.Count == 0)
return null;
var response = await request.ExecuteAsync();
if (response.Status.IsSuccessful == false)
throw response.Status.ToFault();
// 3. Update the last known state based on the differences
Debug.Assert(response.Device != null, "If status is successful, then updated device should not be null.");
return response.Device;
}
