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 })); } }