public async Task <IActionResult> Post([FromBody] DeviceModel deviceModel)
{
m_logger.LogDebug(LogEventId.CreateDeviceStart, "Starting request to create device");
if (!ModelState.IsValid)
{
m_logger.LogDebug(LogEventId.CreateDeviceEnd, "Ending request to create device failed with invalid model");
return(BadRequest());
}
CreateDeviceRequest request = new CreateDeviceRequest(
deviceModel.MacAddress,
deviceModel.BluetoothName,
deviceModel.Manufacturer,
deviceModel.Model,
DateTime.Now);
var response = await m_processor.Run(request);
if (!response.Success)
{
m_logger.LogDebug(LogEventId.CreateDeviceEnd, "Ending request to create device failed with bad request");
return(BadRequest());
}
m_logger.LogDebug(LogEventId.CreateDeviceEnd, string.Format("Ending request to create device success with Id {0}", deviceModel.MacAddress));
return(Ok());
}
public async Task GetReadingsUsingDeviceId_Startingdate_Endingdate_StartingDateHigherThanEnding_ReturnsBadRequest()
{
//Arrange
CreateDeviceRequest deviceRequest = new CreateDeviceRequest {
Name = "testInvalidStartingEndName1", Location = "testInvalidStartingEndLocation1"
};
var insertDeviceSqlString = $"Insert into Devices (Name, Location) values('{deviceRequest.Name}', '{deviceRequest.Location}')";
ExecuteNonQuery(insertDeviceSqlString);
var selectSqlStringDevice1 = $"Select * from Devices WHERE Name = '{deviceRequest.Name}'";
var device = ExecuteDevicesQuery(selectSqlStringDevice1);
Assert.NotNull(device);
var startingDatetime = 1005;
var endingDatetime = 1000;
string requestUri = $"Readings/{device.Device_id}/{startingDatetime}/{endingDatetime}";
// Act
var response = await HttpClient.GetAsync(requestUri);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
//Clean Up
var cleanUpReadingsSqlString = $"DELETE From Devices WHERE Device_id = {device.Device_id}";
var cleanedUpReadings = ExecuteNonQuery(cleanUpReadingsSqlString);
Assert.True(cleanedUpReadings, "It was not possible to clean up the created readings database.");
}
private async Task <DeviceResponse> CreatedDefaultDevice()
{
CreateDeviceRequest device = DeviceComponentsValues.CreateDeviceRequestBasic();
var request = AutomapperSingleton.Mapper.Map <DeviceResponse>(device);
IActionResult actionResult = await CreateDevice(device);
ObjectResult objectResult = actionResult is ObjectResult ? actionResult as ObjectResult : null;
if (objectResult != null && objectResult.Value is Guid)
{
var identifier = objectResult.Value as Guid?;
if (identifier.HasValue)
{
request.Id = identifier.Value;
}
else
{
Assert.Fail("Return value isn't a identifier valid");
}
}
else
{
Assert.Fail("Imposible create default record");
}
return(request);
}
protected override async Task <int> ExecuteAsync(CommandContext context, CancellationToken cancellationToken)
{
//Get the application
var application = await context.FindApplicationAsync(Application, cancellationToken);
if (application == null)
{
return(1);
}
var deviceKey = DeviceKey.TryParseGuid();
var request = new CreateDeviceRequest
{
ApplicationId = application.Id,
Name = Name,
DeviceKey = deviceKey,
};
//Create the device
var device = await context.Client.Devices.CreateDeviceAsync(request, cancellationToken);
//Let the user know what happened.
Console.WriteLine($"Device {device.Id} created with name '{device.Name}'.");
return(0);
}
public void AgentCreateDeviceNoInit()
{
Agent agent = new Agent();
CreateDeviceRequest request = new CreateDeviceRequest();
Assert.Throws <SdkException>(() => agent.CreateDevice(request));
}
/// <inheritdoc />
public async Task <Guid> Create(CreateDeviceRequest request, string token)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (string.IsNullOrWhiteSpace(token))
{
throw new ArgumentNullException(nameof(token));
}
var devices = await _deviceRepository.GetAsync();
if (devices.Any(x => x.Udid == request.Udid))
{
throw new ApplicationException($"Device with udid: {request.Udid} already exist");
}
var scopeArray = new [] { Const.Permissions.Device.AdminCreate };
var correctCompanyId = await _validationHelper.GetCompanyIdByPermission(token, scopeArray, request.CompanyId);
if (!correctCompanyId.HasValue)
{
throw new ArgumentException("Invalid companyId", nameof(request.CompanyId));
}
request.CompanyId = correctCompanyId.Value;
await _validationHelper.ValidateCompanyAndBranch(request.CompanyId, request.BranchId, token);
var device = request.Adapt <Device>();
device.CreatedOn = DateTime.UtcNow;
return(await _deviceRepository.AddAsync(device));
}
public Device Create(CreateDeviceRequest request, User user)
{
var location = _dataContext.Offices.Find(request.LocationId);
var device = new Device
{
Name = request.Name,
SerialNumber = request.SerialNumber,
OperatingSystem = request.OS,
Description = request.Description,
Status = DeviceStatus.AVAILABLE,
Location = location
};
var createEvent = new Event()
{
Type = EventType.NEW_DEVICE,
Device = device,
Office = location,
User = user,
Date = DateTime.Now
};
_dataContext.Add(createEvent);
_dataContext.Devices.Add(device);
_dataContext.SaveChanges();
return(device);
}
public async Task Create_WithValidParameters_DeviceIsAdded()
{
//Arrange
var dbContext = DbContextMocker.GetDbContext(nameof(Create_WithValidParameters_DeviceIsAdded));
var devicesController = new DevicesController(dbContext);
var createDeviceRequest = new CreateDeviceRequest
{
Name = "testName1",
Location = "testLocation1"
};
var expectedDevice = new Device
{
Device_id = 4,
Name = "testName1",
Location = "testLocation1"
};
//Act
var response = await devicesController.Create(createDeviceRequest);
var result = (ObjectResult)response.Result;
var deviceReceived = result.Value.As <Device>();
dbContext.Dispose();
//Assert
result.StatusCode.Should().Be((int)HttpStatusCode.Created);
Assert.True(DevicesComparer.CompareDevices(deviceReceived, expectedDevice), "The device received is different " +
"than the expected.");
}
public async Task GetById_WithDeviceAvailable_ReturnsDevice()
{
CreateDeviceRequest deviceRequest = new CreateDeviceRequest {
Name = "integrationTestName1", Location = "integrationTestLocation1"
};
//Arrange
var insertSqlString = $"Insert into Devices (Name, Location) values('{deviceRequest.Name}', '{deviceRequest.Location}')";
ExecuteNonQuery(insertSqlString);
var selectSqlString = $"Select * from Devices WHERE Name = '{deviceRequest.Name}'";
var device = ExecuteDevicesQuery(selectSqlString);
Assert.NotNull(device);
string requestUri = $"Devices/{device.Device_id}";
// Act
var response = await HttpClient.GetAsync(requestUri);
var receivedDevice = await response.Content.ReadAsAsync <Device>();
//Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
Assert.True(DevicesComparer.CompareDeviceWithDeviceRequest(receivedDevice, deviceRequest), "The requested device was not found in the" +
" device retrieved by the GetById.");
//Clean Up
var cleanUpSqlString = $"DELETE From Devices WHERE Name = '{deviceRequest.Name}'";
var cleanedUp = ExecuteNonQuery(cleanUpSqlString);
Assert.True(cleanedUp, "It was not possible to clean up the database.");
}
/// <summary>
/// Attempts to create the device in the database, returning the new Id
/// </summary>
/// <param name="Request"></param>
/// <returns></returns>
public Task <CreateDeviceResponse> Run(CreateDeviceRequest Request)
{
using (var scope = m_serviceProvider.CreateScope())
{
var context = scope.ServiceProvider.GetService <DeviceContext>();
// Is device present?
var device = context.Devices
.Where(D => D.MacAddress == Request.MacAddress)
.FirstOrDefault();
if (device == default)
{
device = new Device()
{
MacAddress = Request.MacAddress,
BluetoothName = Request.BluetoothName,
Manufacturer = Request.Manufacturer,
Model = Request.DeviceModel
};
context.Devices.Add(device);
context.SaveChanges();
}
return(Task.FromResult(new CreateDeviceResponse(true, device.Id)));
}
}
public async Task <HttpResponseMessage> CreateDevice(CreateDeviceRequest createDeviceRequest)
{
var content = IntegrationHttpRequest.CreateContentRequest(createDeviceRequest);
HttpResponseMessage response = await client.PostAsync(UrlBase + "api/v1/create-device", content);
return(response);
}
public async Task <Guid> CreateDeviceAsync(CreateDeviceRequest request)
{
var id = await AddAsync(_mapper.Map <DomainModel.Device>(request));
await SaveAsync();
return(id);
}
public async Task GetReadingsUsingDeviceId_Startingdate_WithReadingsAvailable_ReturnsReadings()
{
//Arrange
CreateDeviceRequest deviceRequest = new CreateDeviceRequest {
Name = "testGetStartingDateName1", Location = "testGetStartingDateLocation1"
};
var insertDeviceSqlString = $"Insert into Devices (Name, Location) values('{deviceRequest.Name}', '{deviceRequest.Location}')";
ExecuteNonQuery(insertDeviceSqlString);
var selectSqlStringDevice1 = $"Select * from Devices WHERE Name = '{deviceRequest.Name}'";
var device = ExecuteDevicesQuery(selectSqlStringDevice1);
Assert.NotNull(device);
Reading reading1 = new Reading {
Device_id = device.Device_id, Timestamp = 1000, Reading_type = "typeTest1", Raw_value = 10
};
Reading reading2 = new Reading {
Device_id = device.Device_id, Timestamp = 1001, Reading_type = "typeTest2", Raw_value = 20
};
var insertReadingsSqlString = "Insert into Readings (Device_id, Timestamp, Reading_type, Raw_value)" +
$" values({device.Device_id}, {reading1.Timestamp}, '{reading1.Reading_type}', {reading1.Raw_value})," +
$" ({device.Device_id}, {reading2.Timestamp}, '{reading2.Reading_type}', {reading2.Raw_value})";
ExecuteNonQuery(insertReadingsSqlString);
var startingDatetime = 1000;
string requestUri = $"Readings/{device.Device_id}/{startingDatetime}";
// Act
var response = await HttpClient.GetAsync(requestUri);
var receivedReadingList = await response.Content.ReadAsAsync <List <Reading> >();
//Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
Assert.True(ReadingsComparer.DoesReadingsListContainSpecificReading(receivedReadingList, reading1), "The reading list received " +
"does not contain the expected reading");
Assert.True(ReadingsComparer.DoesReadingsListContainSpecificReading(receivedReadingList, reading2), "The reading list received " +
"does not contain the expected reading");
//Clean Up
var cleanUpReadingsSqlString = $"DELETE From Readings WHERE Device_id = {device.Device_id}";
var cleanedUpReadings = ExecuteNonQuery(cleanUpReadingsSqlString);
Assert.True(cleanedUpReadings, "It was not possible to clean up the created readings database.");
var cleanUpDevicesSqlString = $"DELETE From Devices WHERE Device_id = {device.Device_id}";
var cleanedUpDevices = ExecuteNonQuery(cleanUpDevicesSqlString);
Assert.True(cleanedUpDevices, "It was not possible to clean up the created devices database.");
}
public static bool CompareDeviceWithDeviceRequest(Device device, CreateDeviceRequest deviceRequest)
{
if ((!device.Name.Equals(deviceRequest.Name) ||
!device.Location.Equals(deviceRequest.Location)))
{
return(false);
}
return(true);
}
public IActionResult CreateDevice(CreateDeviceRequest device)
{
Device created_device = _deviceRepository.CreateDevice(device.name,
Guid.NewGuid().ToString(),
HttpContext.User.Identity.Name);
if (created_device == null)
{
return(BadRequest(new { statusCode = 400, message = "bad_request" }));
}
return(StatusCode(201, new { statusCode = 201, message = "created" }));
}
public void AgentCreateDeviceSetRsaKey()
{
// generate RSA key pair
RsaKeyGenerator generator = new RsaKeyGenerator();
RsaPrivateKey privateKey = generator.GeneratePrivateKey(2048);
RsaPublicKey publicKey = generator.GeneratePublicKey(privateKey);
// set RSA keys into a CreateDeviceRequest object
CreateDeviceRequest request = new CreateDeviceRequest();
request.ClientRsaPrivateKey = privateKey;
request.ClientRsaPublicKey = publicKey;
}
public async Task <ActionResult <Device> > Create(CreateDeviceRequest createDeviceRequest)
{
var device = new Device
{
Name = createDeviceRequest.Name,
Location = createDeviceRequest.Location
};
await _context.Devices.AddAsync(device);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetDevice", new { id = device.Device_id }, device));
}
public async Task TestCreateDeviceAsync(CreateDeviceRequest obj, ObjectResult resultAction)
{
var request = AutomapperSingleton.Mapper.Map <CreateDeviceRequest>(obj);
HttpResponseMessage actionResult = await _deviceAPI.CreateDevice(request);
if (actionResult.StatusCode == HttpStatusCode.OK)
{
dynamic id = JsonConvert.DeserializeObject(actionResult.Content.ReadAsStringAsync().Result, resultAction.Value.GetType());
DeviceComponentsValues.GuidAvailable = (Guid)id;
//RecordComponentsValues.NameAvailable = obj.Name;
}
base.CheckAssert(actionResult, resultAction);
}
public Device Post([FromBody] CreateDeviceRequest request)
{
using (var connection = _connectionFactory.CreateAndOpen())
using (var transaction = connection.BeginTransaction())
{
var device = connection.InsertDevice(transaction, request.Name, request.ApplicationId, request.DeviceKey);
//Create the event record
connection.InsertDeviceEvent(transaction, device.Id, DeviceEventType.Created, "Device created.");
transaction.Commit();
return(device);
}
}
/// <summary>
/// 创建设备
/// </summary>
/// <param name="req"><see cref="CreateDeviceRequest"/></param>
/// <returns><see cref="CreateDeviceResponse"/></returns>
public CreateDeviceResponse CreateDeviceSync(CreateDeviceRequest req)
{
JsonResponseModel <CreateDeviceResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "CreateDevice");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateDeviceResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public async Task <IActionResult> CreateDevice([FromBody] CreateDeviceRequest request)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
var item = _devicesService.Create(request, user);
var response = _mapper.Map <GetDevicesResponse>(item);
return(Ok(response));
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <Device> CreateDevice(CreateDeviceRequest createDeviceRequest)
{
var device = new Device
{
Id = Guid.NewGuid(),
DeviceIdentifier = createDeviceRequest.DeviceIdentifier,
IpAddress = createDeviceRequest.IpAddress,
Type = createDeviceRequest.Type,
ClientId = createDeviceRequest.ClientId,
BuildingId = createDeviceRequest.BuildingId
};
_dbContext.Devices.Add(device);
await _dbContext.SaveChangesAsync();
return(device);
}
public async Task <IActionResult> Post([FromBody] CreateDeviceRequest request)
{
try
{
var deviceId = await _deviceService.Create(request, Token);
return(Created(HttpContext.Request.GetEncodedUrl(), deviceId));
}
catch (ArgumentNullException ex)
{
return(BadRequest(ex.Message));
}
catch (ApplicationException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task TestCreateDevice(CreateDeviceRequest obj, IActionResult resultAction)
{
//var request = AutomapperSingleton.Mapper.Map<CreateCompanyRequest>(obj);
IActionResult actionResult = await CreateDevice(obj);
var objectResult = actionResult as ObjectResult;
if (objectResult.StatusCode == 200)
{
dynamic id = Guid.Parse(objectResult.Value.ToString());
DeviceComponentsValues.GuidAvailable = (Guid)id;
//RecordComponentsValues.NameAvailable = obj.Name;
}
base.CheckAssert(actionResult, resultAction);
}
public async Task Create_AlreadyExistingDatetimeForTheDevice_ReturnsBadRequest()
{
//Arrange
CreateDeviceRequest deviceRequest = new CreateDeviceRequest {
Name = "testBadRequestCreateName1", Location = "testBadRequestCreateLocation1"
};
var insertDeviceSqlString = $"Insert into Devices (Name, Location) values('{deviceRequest.Name}', '{deviceRequest.Location}')";
ExecuteNonQuery(insertDeviceSqlString);
var selectSqlStringDevice1 = $"Select * from Devices WHERE Name = '{deviceRequest.Name}'";
var device = ExecuteDevicesQuery(selectSqlStringDevice1);
Assert.NotNull(device);
Reading reading = new Reading {
Device_id = device.Device_id, Timestamp = 1000, Reading_type = "typeTest1", Raw_value = 10
};
var insertReadingSqlString = "Insert into Readings (Device_id, Timestamp, Reading_type, Raw_value)" +
$" values({device.Device_id}, {reading.Timestamp}, '{reading.Reading_type}', {reading.Raw_value})";
ExecuteNonQuery(insertReadingSqlString);
var postPayload = JsonConvert.SerializeObject(reading);
HttpContent postContent = new StringContent(postPayload, Encoding.UTF8, "application/json");
string requestUri = $"Readings/";
// Act
var response = await HttpClient.PostAsync(requestUri, postContent);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
//Clean Up
var cleanUpReadingsSqlString = $"DELETE From Readings WHERE Device_id = {device.Device_id}";
var cleanedUpReadings = ExecuteNonQuery(cleanUpReadingsSqlString);
var cleanUpDevicesSqlString = $"DELETE From Devices WHERE Device_id = {device.Device_id}";
var cleanedUpDevices = ExecuteNonQuery(cleanUpDevicesSqlString);
Assert.True(cleanedUpReadings, "It was not possible to clean up the created readings database.");
}
private async Task <IActionResult> CreateDevice(CreateDeviceRequest createDeviceRequest)
{
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(createDeviceRequest);
return(await controller.CreateDeviceAsync(mockCreateRequest.Object, _logger)); //as GridController;
}
}
public void Execute(object parameter)
{
CreateDeviceRequestHandler deviceHandler = new CreateDeviceRequestHandler(new DeviceRepository());
Random random = new Random();
int port = random.Next(16000, 16100);
CreateDeviceRequest request = new CreateDeviceRequest()
{
Device = new Device(port)
{
Id = Guid.NewGuid(),
Name = "Aspirator",
DeviceState = DeviceState.Active
}
};
deviceHandler.Handle(request).Wait();
}
public void AgentCreateDevice()
{
AgentConfig config = new AgentConfig();
Agent agent = AgentTestUtils.getTestAgent(config);
CreateDeviceRequest request = new CreateDeviceRequest();
//request.SetServer("https://api.ionic.engineering");
request.Server = "https://api.ionic.com";
request.ETag = "XyZ";
request.UidAuth = "username@domain";
request.Token = "abCDEfghiJkLmNOp123=";
request.EiRsaPublicKeyBase64 = "{A very long public key without newlines}";
CreateDeviceResponse response = agent.CreateDevice(request);
Assert.That(response.HttpResponseCode == 200, Is.True);
}
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 <IActionResult> Create([FromBody] CreateDeviceRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var itemId = await _devicesRepository.Create(request);
return(CreatedAtAction(nameof(GetById), new { id = itemId }, itemId));
}
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 }));
}
}
