public async Task <ActionResult> Create(CreateSensorViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
SensorDto sensorDto = _mapper.Map <CreateSensorViewModel, SensorDto>(model);
SensorTypeDto sensorType = await _sensorTypeManager.GetSensorTypeByIdAsync(sensorDto.SensorTypeId);
if (model.IconFile != null)
{
sensorDto.IconId = await _iconManager.CreateAndGetIconId(model.IconFile);
}
else
{
sensorDto.IconId = sensorType.IconId;
}
var res = await _sensorManager.Create(sensorDto);
if (res != null)
{
res.SensorTypeName = sensorType.Name;
return(ViewComponent("SensorElement", _mapper.Map <SensorDto, SensorViewModel>(res)));
}
else
{
//ModelState.AddModelError(res.Property, res.Message);
return(View(model));
}
}
public async Task CreateAsync(SensorDto sensorDto)
{
var sensor = _mapper.Map <DAL.Entities.Sensor>(sensorDto);
sensor.Id = Guid.NewGuid();
await _repository.CreateAsync(sensor);
}
public async Task <ActionResult> Edit(EditSensorViewModel model)
{
SensorDto sensorDto = _mapper.Map <EditSensorViewModel, SensorDto>(model);
IconDto iconDto = null;
if (model.IconFile != null)
{
sensorDto.IconId = _iconManager.CreateAndGetIconId(model.IconFile).Result;
iconDto = await _iconManager.GetById(sensorDto.IconId.GetValueOrDefault());
sensorDto.IconPath = iconDto.Path;
}
var res = await _sensorManager.Update(sensorDto);
if (res != null)
{
res = await _sensorManager.GetSensorByIdAsync(sensorDto.Id);
iconDto = await _iconManager.GetById(sensorDto.IconId.GetValueOrDefault());
sensorDto.IconPath = iconDto.Path;
sensorDto.SensorTypeName = res.SensorTypeName;
return(ViewComponent("SensorElement", _mapper.Map <SensorDto, SensorViewModel>(sensorDto)));
}
else
{
//ModelState.AddModelError(res.Property, res.Message);
return(View(model));
}
}
public override bool Perform(SensorDto dto, string jsonMessage)
{
var email = JsonConvert.DeserializeObject <Email>(jsonMessage);
if (email == null)
{
return(false);
}
MailMessage mailMessage = new MailMessage();
mailMessage.From = new MailAddress(settings.From);
mailMessage.To.Add(email.To);
mailMessage.IsBodyHtml = true;
mailMessage.Body = GetBodyString(email.Body, dto);
mailMessage.Subject = email.Subject ?? "Sensor value changed!";
lock (_lock)
{
try
{
_client.Send(mailMessage);
}
catch (Exception ex)
{
manager.Log("logs", "exception", ex);
}
}
return(true);
}
private void ExecuteRule(string datatype, SensorDto dto, Rule rule)
{
switch (datatype.ToLower())
{
case "0": //numeric
if (CheckValue(int.Parse(dto.Value), rule.Operator, int.Parse(rule.Value)))
{
foreach (var action in rule.Actions)
{
ActionPerformerFactory.Create(action.Type, _manager, _emailSettings).Perform(dto, action.Content);
}
}
break;
case "1": //boolean
if (CheckValue(bool.Parse(dto.Value), rule.Operator, bool.Parse(rule.Value)))
{
foreach (var action in rule.Actions)
{
ActionPerformerFactory.Create(action.Type, _manager, _emailSettings).Perform(dto, action.Content);
}
}
break;
default:
break;
}
}
public IActionResult UpdateSensor([FromRoute] string name, [FromBody] SensorDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var sensor = _repository.GetSensor(name);
if (model.Name == null)
{
model.Name = name;
}
var result = (sensor != null) ? _repository.UpdateSensor(model) : _repository.AddSensor(model);
if (!result)
{
return(BadRequest());
}
var svm = SensorViewModelFactory.FromSensor(_repository.GetSensor(name));
return(CreatedAtAction("Sensor", svm));
}
public async Task Put_CreateNewSensorWithoutData(string sensor)
{
// Arrange
var auth = "testapi";
var url = $"/{sensor}";
string randomId = Utilities.RandomString(5);
string randomDescription = Utilities.RandomString(20);
var dto = new SensorDto {
InternalId = randomId, Description = randomDescription
};
var content = JsonConvert.SerializeObject(dto);
var response = await DoPut(url, content, auth);
// Assert
response.EnsureSuccessStatusCode(); // Status Code 200-299
var responseBody = await response.Content.ReadAsStringAsync();
var svm = JsonConvert.DeserializeObject <SensorDto>(responseBody);
Assert.Equal(randomId, svm.InternalId);
Assert.Equal(randomDescription, svm.Description);
Assert.Equal("application/json; charset=utf-8",
response.Content.Headers.ContentType.ToString());
}
public async Task Put_SensorInformationApiKeyInBody(string sensor)
{
var url = $"/{sensor}";
var response = await DoGet($"/{sensor}.json");
var responseBody = await response.Content.ReadAsStringAsync();
var svm = JsonConvert.DeserializeObject <SensorDto>(responseBody);
var oldData = svm.Data;
string randomId = Utilities.RandomString(5);
string randomDescription = Utilities.RandomString(20);
var dto = new SensorDto {
InternalId = randomId, Description = randomDescription, ApiKey = "testapi"
};
var content = JsonConvert.SerializeObject(dto);
response = await DoPut(url, content);
// Assert
response.EnsureSuccessStatusCode(); // Status Code 200-299
responseBody = await response.Content.ReadAsStringAsync();
svm = JsonConvert.DeserializeObject <SensorDto>(responseBody);
Assert.Equal(oldData, svm.Data);
Assert.Equal(randomId, svm.InternalId);
Assert.Equal(randomDescription, svm.Description);
Assert.Equal("application/json; charset=utf-8",
response.Content.Headers.ContentType.ToString());
}
public async Task <IActionResult> Index([FromBody] SensorDto dto, [FromServices] IRuleExecutor executor)
{
dto.CreationTime = DateTime.UtcNow;
var result = await executor.Execute(dto);
return(Ok(result));
}
public void Create_ValidDto_ReturnNotNull()
{
Guid guid = Guid.NewGuid();
SensorDto newSensorDto = new SensorDto()
{
Name = "Correct", Token = guid, IsActive = true, IsValid = true
};
Sensor newSensor = new Sensor()
{
Name = "Correct", Token = guid, IsActive = true, IsValid = true
};
mockMapper.Setup(m => m
.Map <SensorDto, Sensor>(newSensorDto))
.Returns(newSensor);
mockMapper.Setup(m => m
.Map <Sensor, SensorDto>(newSensor))
.Returns(newSensorDto);
mockUnitOfWork.Setup(uow => uow
.SensorRepo.GetByToken(guid));
mockUnitOfWork.Setup(uow => uow
.SensorRepo.Insert(newSensor));
var result = _manager.Create(newSensorDto);
Assert.IsNotNull(result.Result);
}
public async Task Put_SensorDataApiKeyInHeaders(string sensor)
{
// Arrange
var client = _factory.CreateClient();
var url = $"/{sensor}";
var auth = "testapi";
var dto = new SensorDto {
Data = 9
};
var content = JsonConvert.SerializeObject(dto);
var response = await DoPut(url, content, auth);
// Assert
response.EnsureSuccessStatusCode(); // Status Code 200-299
var responseBody = await response.Content.ReadAsStringAsync();
var svm = JsonConvert.DeserializeObject <SensorDto>(responseBody);
Assert.Equal(9.0f, svm.Data);
Assert.Equal("application/json; charset=utf-8",
response.Content.Headers.ContentType.ToString());
}
public bool UpdateSensor(SensorDto sensorDto)
{
var sensor = GetSensor(sensorDto.Name);
if (sensorDto.Description != null && sensorDto.Description != sensor.Description)
{
sensor.Description = sensorDto.Description;
}
if (sensorDto.InternalId != null && sensorDto.InternalId != sensor.InternalId)
{
sensor.InternalId = sensorDto.InternalId;
}
if (sensorDto.Type.HasValue && sensorDto.Type.Value != sensor.Type)
{
sensor.Type = sensorDto.Type.Value;
}
_context.SaveChanges();
if (sensorDto.Data.CompareTo(float.NaN) != 0 && !AddSensorReading(sensorDto))
{
return(false);
}
return(true);
}
private string GetBodyString(string content, SensorDto dto)
{
content = HttpUtility.UrlDecode(content);
content = content.Replace("[SensorName]", dto.Name);
content = content.Replace("[SensorValue]", dto.Value);
content = content.Replace("[ActionDate]", dto.CreationTime.ToString("F"));
return(content);
}
protected override async Task <AuthenticateResult> HandleAuthenticateAsync()
{
var claims = new[] { new Claim(ClaimTypes.Name, "API Key User") };
var identity = new ClaimsIdentity(claims, Scheme.Name);
var principal = new ClaimsPrincipal(identity);
var at = new AuthenticationTicket(principal, ApiKeyAuthenticationDefaults.AuthenticationScheme);
var apikey = Context.Request.Headers["X-APIKEY"].FirstOrDefault();
if (string.IsNullOrEmpty(apikey))
{
// workaround for https://github.com/aspnet/Security/issues/1638
var ms = new MemoryStream();
await Request.Body.CopyToAsync(ms);
ms.Seek(0, SeekOrigin.Begin);
var requestBody = await new StreamReader(ms).ReadToEndAsync();
ms.Seek(0, SeekOrigin.Begin);
Request.Body = ms;
SensorDto sensorData = null;
try
{
sensorData = JsonConvert.DeserializeObject <SensorDto>(requestBody);
}
catch (JsonReaderException)
{
sensorData = null;
}
if (sensorData == null)
{
return(AuthenticateResult.NoResult());
}
else
{
if (sensorData.ApiKey == Options.ApiKey)
{
Context.User.AddIdentity(new ClaimsIdentity(ApiKeyAuthenticationDefaults.AuthenticationScheme));
return(AuthenticateResult.Success(at));
}
else
{
return(AuthenticateResult.Fail("API key is invalid"));
}
}
}
else if (apikey == Options.ApiKey)
{
Context.User.AddIdentity(new ClaimsIdentity(ApiKeyAuthenticationDefaults.AuthenticationScheme));
return(AuthenticateResult.Success(at));
}
else
{
return(AuthenticateResult.NoResult());
}
}
public static VehicleSensorData Create(SensorDto sensorDto)
{
return(new VehicleSensorData
{
Timestamp = sensorDto.Timestamp,
Quality = sensorDto.Quality,
Value = sensorDto.Value
});
}
private static void ReplaceSensorData(SensorDto sensorDto, VehicleSnapshot vehicleSnapshot)
{
var sensor = vehicleSnapshot.Sensors[sensorDto.Name];
if (sensorDto.Timestamp >= sensor.Timestamp)
{
vehicleSnapshot.Sensors[sensorDto.Name] = VehicleSensorData.Create(sensorDto);
}
}
public static Sensor Convert(this SensorDto sensor)
{
return(new Sensor
{
firstName = sensor.FirstName,
lastName = sensor.LastName,
sensorId = sensor.SensorId,
sensorMac = sensor.SensorMac
});
}
public ActionResult <SensorDto> Post([FromServices] SensorService service, [FromBody] SensorInputDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
SensorDto dtoResultado = service.SaveSensorAsync(model);
return(Ok(dtoResultado));
}
public async Task <ActionResult <SensorDto> > Adicionar(SensorDto sensorDto)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _sensorService.Adicionar(_mapper.Map <Sensor>(sensorDto));
return(CustomResponse(sensorDto));
}
public async Task UpdateAsync(SensorDto sensorDto)
{
var sensor = await _repository.GetAsync(sensorDto.Id);
if (sensor == null)
{
throw new GreenFieldNotFoundException();
}
sensor = _mapper.Map <DAL.Entities.Sensor>(sensorDto);
await _repository.UpdateAsync(sensor);
}
public void Update_DtoIsNull_ReturnNull()
{
SensorDto nullSensorDto = null;
mockUnitOfWork.Setup(uow => uow
.SensorRepo.GetById(_existingSensor.Id))
.Returns(Task.FromResult(_existingSensor));
var result = _manager.Update(nullSensorDto);
Assert.IsNull(result.Result);
}
public void Create_DtoIsNull_ReturnNull()
{
SensorDto newSensorDto = null;
mockUnitOfWork.Setup(uow => uow
.SensorRepo.GetByToken(_existingSensor.Token))
.Returns(_existingSensor);
var result = _manager.Create(newSensorDto);
Assert.IsNull(result.Result);
}
public async Task <IActionResult> Create([FromForm] CreateDataViewModel measurement)
{
if (!ModelState.IsValid)
{
return(View(measurement));
}
if (ModelState.IsValid)
{
var modelForCreation = new SensorDto {
Id = measurement.LocationIdentifier,
Light = measurement.Light,
Temperature = measurement.Temperature,
TimeStamp = DateTime.Now.ToLongTimeString()
};
var serializedModel = JsonConvert.SerializeObject(modelForCreation);
var apiClient = await _sensorHttpClient.GetClient();
using (apiClient)
{
try
{
var response = await apiClient.PostAsync("api/SensorDatas",
new StringContent(serializedModel, System.Text.Encoding.Unicode, "application/json"));
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
var m = new ApiResponseViewModel();
m.Content = response.Content.ToString();
m.Message = response.Headers.ToString();
m.StatusCode = response.StatusCode.ToString();
return(RedirectToAction("ShowOtherStatusCodesFromApi", m));
}
}
catch (HttpRequestException e)
{
throw new HttpRequestException(e.Message);
}
catch (ArgumentNullException n)
{
throw new ArgumentNullException(n.Message);
}
}
}
return(View(measurement));
}
public void Update_SensorNotExist_ReturnNull()
{
SensorDto notExistingSensorDto = null;
Sensor notExistingSensor = null;
mockUnitOfWork.Setup(uow => uow
.SensorRepo.GetById(0))
.Returns(Task.FromResult(notExistingSensor));
var result = _manager.Update(notExistingSensorDto);
Assert.IsNull(result.Result);
}
public async Task Put_UpdateSensorWithData127_ShouldBe400(string sensor)
{
var url = $"/{sensor}";
var auth = "testapi";
var dto = new SensorDto {
Data = -127
};
var content = JsonConvert.SerializeObject(dto);
var response = await DoPut(url, content, auth);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public SensorDto SaveSensorAsync(SensorInputDto dto)
{
var model = SensorModel.Build(dto.Tag, dto.Timestamp, dto.Valor);
_sensorDao.Save(model);
SensorDto novoDto = new SensorDto();
novoDto.SensorNome = model.Nome;
novoDto.Pais = model.Pais;
novoDto.Regiao = model.Regiao;
novoDto.Valor = model.Valor;
return(novoDto);
}
public override bool Perform(SensorDto dto, string jsonMessage)
{
var webrequest = JsonConvert.DeserializeObject <WebRequest>(jsonMessage);
if (webrequest == null || string.IsNullOrEmpty(webrequest.Url))
{
return(false);
}
lock (_lock){
if (webrequest.Security != null && webrequest.Security.Type.ToLower() == "basic")
{
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("basic", Convert.ToBase64String(Encoding.UTF8.GetBytes(webrequest.Security.Username + ":" + webrequest.Security.Password)));
}
if (webrequest.Headers != null && webrequest.Headers.Any())
{
foreach (var header in webrequest.Headers)
{
_client.DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
try
{
var tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
if (webrequest.Method.ToLower() == "get")
{
_client.GetAsync(webrequest.Url, tokenSource.Token).Wait();
}
else
{
if (webrequest.Body != null)
{
_client.PostAsync(webrequest.Url, new StringContent(JsonConvert.SerializeObject(webrequest.Body), Encoding.UTF8, "application/json"), tokenSource.Token).Wait();
}
else
{
_client.PostAsync(webrequest.Url, null, tokenSource.Token).Wait();
}
}
}
catch (Exception ex)
{
manager.Log("logs", "exception", ex);
}
_client.DefaultRequestHeaders.Clear();
}
return(true);
}
protected override void Initialize()
{
base.Initialize();
Mock <IHubContext <GraphHub> > graphHub = new Mock <IHubContext <GraphHub> >();
_manager = new SensorManager(mockUnitOfWork.Object, mockMapper.Object, graphHub.Object);
Guid guid = new Guid();
_existingSensor = new Sensor {
Id = 1, Name = "Existing", Token = guid, IsActive = true, IsValid = true
};
_existingSensorDto = new SensorDto {
Id = 1, Name = "Existing", Token = guid, IsActive = true, IsValid = true
};
}
public async Task <ActionResult <SensorDto> > Atualizar(Guid id, SensorDto sensorDto)
{
if (id != sensorDto.Id)
{
NotificarErro("O id informado não é o mesmo que foi passado na query");
return(CustomResponse(sensorDto));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _sensorService.Atualizar(_mapper.Map <Sensor>(sensorDto));
return(CustomResponse(sensorDto));
}
public bool AddSensorReading(SensorDto sensorDto)
{
if (IsDataInvalid(sensorDto.Data))
{
return(false);
}
_context.SensorValues.Add(new SensorValue
{
Data = sensorDto.Data,
Sensor = GetSensor(sensorDto.Name),
Timestamp = DateTime.UtcNow
});
_context.SaveChanges();
return(true);
}
public PresenceDto GetSensorPresence(SensorDto client)
{
return presenceRepository.GetSensorPresence(client.SensorId);
}
public void RecordLocation(PresenceDto presence, SensorDto sensor)
{
presenceRepository.CreateSensorPresence(presence.Convert(), sensor.Convert());
}
