public void UpdateSensor_WithUnknownSensorType_Returns_ConflictResult()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
sensorServiceMock.Setup(service => service
.GetSensorByIdAsync(It.IsAny <int>()))
.Returns(Task.FromResult(GetSensor()));
sensorServiceMock.Setup(service => service
.UpdateSensorAsync(It.IsAny <SensorDTO>()))
.Returns(Task.FromResult(false));
var loggerMock = new Mock <ILogger <SensorsController> >();
var controller = new SensorsController(sensorServiceMock.Object, loggerMock.Object);
var sensorDTO = new SensorDTO {
Id = 1
};
// Act
var result = controller.UpdateSensor(sensorDTO).GetAwaiter().GetResult();
// Assert
var conflictResult = Assert.IsType <ConflictResult>(result);
}
public JsonResult SensorIsNotEmpty(int?id)
{
if (id == null)
{
return(Json("Need id Sensor"));
}
try
{
SensorDTO sensorDTO = sensorService.GetSensorById(id.Value);
if (sensorDTO.IsProduct)
{
return(Json("Sensor has worked"));
}
sensorDTO.IsProduct = true;
try
{
return(Json(sensorService.EditSensor(sensorDTO).Result));
}
catch
{
return(Json("Bad with Edit Sensor"));
}
}
catch
{
return(Json("Bad with get Sensor"));
}
}
public async Task <IActionResult> UpdateSensor([FromBody] SensorDTO sensor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (sensor.Id <= 0)
{
return(BadRequest(sensor.Id));
}
var sensorFound = await _sensorService.GetSensorByIdAsync(sensor.Id);
if (sensorFound == null)
{
_logger.LogWarning($"{sensor.Id} {SensorsConstants.SENSOR_NOT_FOUND}");
return(NotFound(sensor.Id));
}
var success = await _sensorService.UpdateSensorAsync(sensor);
if (!success)
{
_logger.LogWarning($"{sensor.Id} {SensorsConstants.UPDATE_SENSOR_CONFLICT}");
return(Conflict());
}
_logger.LogInformation($"{sensor.Id} {SensorsConstants.UPDATE_SENSOR_SUCCESS}");
return(Ok(sensor));
}
public void UpdateSensor_WithValidModel_Returns_OkResult()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
sensorServiceMock.Setup(service => service
.GetSensorByIdAsync(It.IsAny <int>()))
.Returns(Task.FromResult(GetSensor()));
sensorServiceMock.Setup(service => service
.UpdateSensorAsync(It.IsAny <SensorDTO>()))
.Returns(Task.FromResult(true));
var loggerMock = new Mock <ILogger <SensorsController> >();
var controller = new SensorsController(sensorServiceMock.Object, loggerMock.Object);
var sensorDTO = new SensorDTO {
Id = 1
};
// Act
var result = controller.UpdateSensor(sensorDTO).GetAwaiter().GetResult();
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.IsAssignableFrom <SensorDTO>(okResult.Value);
}
/// <inheritdoc/>
public async Task <bool> UpdateSensorAsync(SensorDTO sensorDTO)
{
var sensor = await _sensorContext.Sensors.FirstOrDefaultAsync(s => s.Id == sensorDTO.Id);
if (sensor == null)
{
return(false);
}
sensor.Serial = sensorDTO.Serial;
if (sensor.SensorType.Type != sensorDTO.SensorType)
{
var newType = await _sensorContext.Types.FirstOrDefaultAsync(t => t.Type == sensorDTO.SensorType);
if (newType == null)
{
_logger.LogError(SensorsConstants.UNKNOWN_SENSOR_TYPE);
return(false);
}
else
{
sensor.SensorTypeId = newType.Id;
sensor.SensorType = newType;
}
}
_sensorContext.Update(sensor);
await _sensorContext.SaveChangesAsync(new CancellationToken());
return(true);
}
private Sensor AddNewSensoreToDatabase(SensorDTO sensorToAdd)
{
string sensorId = sensorToAdd.SensorId;
string description = sensorToAdd.Description;
var extractedValues = GetMinMaxValues(description);
string tag = sensorToAdd.Tag;
string measureType = sensorToAdd.MeasureType;
int minPollInterval = int.TryParse
(sensorToAdd.MinPollingIntervalInSeconds.ToString(), out int number)
? number : 10;
var newSensor = new Sensor()
{
ApiId = sensorId,
Description = description,
PoolInterval = minPollInterval,
MeasurmentType = measureType,
ValueRangeMax = Math.Max(extractedValues[0], extractedValues[1]),
ValueRangeMin = Math.Min(extractedValues[0], extractedValues[1]),
TimeStamp = DateTime.Now.ToString()
};
this.context.Add(newSensor);
this.context.SaveChanges();
return(newSensor);
}
/// <inheritdoc/>
public async Task <(int id, bool success)> RegisterNewSensorAsync(SensorDTO sensorDTO)
{
var sensor = _mapper.Map <SensorDTO, SensorDevice>(sensorDTO);
var sensorFound = await _sensorContext.Sensors.FirstOrDefaultAsync(s => s.Serial == sensorDTO.Serial);
if (sensorFound != null)
{
_logger.LogError(SensorsConstants.SENSOR_ALREADY_EXIST);
return(0, false);
}
var typeFound = await _sensorContext.Types.FirstOrDefaultAsync(t => t.Type == sensorDTO.SensorType);
if (typeFound == null)
{
_logger.LogError($"{sensorDTO.SensorType} {SensorsConstants.UNKNOWN_SENSOR_TYPE}");
return(0, false);
}
sensor.SensorTypeId = typeFound.Id;
sensor.SensorType = typeFound;
await _sensorContext.Sensors.AddAsync(sensor);
await _sensorContext.SaveChangesAsync(new CancellationToken());
var id = sensor.Id;
return(id, true);
}
public OperationResult EditSensor(SensorDTO sensorDTO)
{
if (sensorDTO == null)
{
throw new ArgumentNullException(nameof(sensorDTO), "Sensor is null");
}
Sensor sensor = Database.Sensors.Get(sensorDTO.Id);
if (sensor == null)
{
throw new Exception("Sensor is not found");
}
sensor.IsProduct = sensorDTO.IsProduct;
sensor.IsWorking = sensorDTO.IsWorking;
sensor.ProductId = sensorDTO.ProductId;
sensor.ApplicationUserId = sensorDTO.ApplicationUserId;
sensor.CountProduct = sensorDTO.CountProduct;
sensor.DeliveryAddress = sensorDTO.DeliveryAddress;
sensor.Name = sensorDTO.Name;
sensor.AutoDelivery = sensorDTO.AutoDelivery;
Database.Sensors.Update(sensor);
Database.Save();
return(new OperationResult("Sensor was edited"));
}
public List <SensorDTO> GetAllSensorsInfo()
{
var sensors = db.Sensors;
if (sensors == null)
{
return(null);
}
List <SensorDTO> sensorsDTO = new List <SensorDTO>();
foreach (Sensor sensor in sensors)
{
var location = db.Locations.FirstOrDefault((i) => i.Id == sensor.Fk_Location);
var sensorType = db.SensorTypes.FirstOrDefault((i) => i.Id == sensor.Fk_SensorType);
var values = db.Values.Where((i) => i.FK_Sensor == sensor.Id);
var broadcaster = db.Broadcasters.First((i) => i.Id == sensor.Fk_Broadcaster).Name;
var sensorDTO = new SensorDTO();
sensorDTO.Id = sensor.Id;
sensorDTO.LocationName = location.Name;
sensorDTO.SensorType = sensorType.Type;
sensorDTO.Values = values;
sensorDTO.Broadcaster = broadcaster;
sensorsDTO.Add(sensorDTO);
}
return(sensorsDTO);
}
private void CheckHeaders(XlWorksheet worksheet)
{
if (worksheet != null)
{
Schema s;
List <string> h;
if (worksheet.Name == "DET_Deployments")
{
s = DeploymentDTO.GetSchema();
}
else if (worksheet.Name == "DET_Measurements")
{
s = MeasurementDTO.GetSchema();
}
else if (worksheet.Name == "LIST_Sites")
{
s = SiteDTO.GetSchema();
}
else if (worksheet.Name == "LIST_Sensors")
{
s = SensorDTO.GetSchema();
}
else
{
return;
}
h = new List <string>();
List <string> hdrs = ExcelBaseDet.Headers(worksheet);
bool bad = false;
for (int i = 0; i < hdrs.Count - 1; i++)
{
string t = hdrs[i];
for (int j = i + 1; j < hdrs.Count; j++)
{
if (t == hdrs[j])
{
bad = true;
break; //inner
}
}
if (bad)
{
break; //outer
}
}
if (bad)
{
generalDet.ValidationIssues.Add(ValidationIssue.Code.DuplicateHeader, "Duplicate column header in " + worksheet.Name);
}
foreach (SchemaEntry c in s)
{
h.Add(c.LowerColumnName);
}
if (!ExcelBaseDet.HasHeaders(hdrs, h))
{
generalDet.ValidationIssues.Add(ValidationIssue.Code.MissingFieldHeader, "Missing column header in " + worksheet.Name);
}
}
}
private async Task <bool> Authenticate(SensorDTO sensorDTO)
{
Sensor sensor = mapper.Map <Sensor>(sensorDTO);
return((await unitOfWork.Sensors
.GetAsync(sensorDTO.Id))?
.PasswordHash == (int.Parse(sensorDTO.Password) % 13).ToString());
}
public JsonResult SensorIsEmpty(int?id)
{
if (id == null)
{
return(Json("Need id Sensor"));
}
try
{
SensorDTO sensorDTO = sensorService.GetSensorById(id.Value);
if (!sensorDTO.IsProduct)
{
return(Json("Sensor has not worked"));
}
sensorDTO.IsProduct = false;
if (sensorDTO.AutoDelivery)
{
ProductDTO productDTO;
try
{
productDTO = productService.GetProductById(sensorDTO.ProductId);
}
catch
{
return(Json("Bad with get product"));
}
OrderDTO orderDto = new OrderDTO
{
Delivered = false,
DeliveryAddress = sensorDTO.DeliveryAddress,
Price = productDTO.Price * sensorDTO.CountProduct,
SensorId = sensorDTO.Id,
DeliveryDate = DateTime.Now
};
try
{
orderService.CreateOrder(orderDto);
}
catch
{
return(Json("Bad with Create order"));
}
}
try
{
return(Json(sensorService.EditSensor(sensorDTO).Result));
}
catch
{
return(Json("Bad with Edit Sensor"));
}
}
catch
{
return(Json("Bad with get Sensor"));
}
}
public async Task <IActionResult> Post([FromBody] SensorDTO dto)
{
try
{
await sensorService.PingAsync(dto);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void CreateSensor(SensorDTO sensorDTO, string email)
{
var user = Database.Users.Find(i => i.Email == email).FirstOrDefault();
sensorDTO.Id = user.Id;
sensorDTO.IsProduct = false;
sensorDTO.IsWorking = false;
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <SensorDTO, Sensor>()).CreateMapper();
Sensor sensor = mapper.Map <SensorDTO, Sensor>(sensorDTO);
Database.Sensors.Create(sensor);
Database.Save();
}
public void UpdateSensor(SensorDTO sensorDTO)
{
var oldSensor = Database.Sensors.Get(sensorDTO.Id);
oldSensor.CountProduct = sensorDTO.CountProduct;
oldSensor.CurrentCountProduct = sensorDTO.CurrentCountProduct;
oldSensor.DelivaryAddress = sensorDTO.DelivaryAddress;
oldSensor.IsProduct = sensorDTO.IsProduct;
oldSensor.IsWorking = sensorDTO.IsWorking;
oldSensor.MonitoringId = sensorDTO.MonitoringId;
oldSensor.ProductId = sensorDTO.ProductId;
oldSensor.Weight = sensorDTO.Weight;
oldSensor.UseAutomaticDelivery = sensorDTO.UseAutomaticDelivery;
Database.Sensors.Update(oldSensor);
Database.Save();
}
public async Task <ActionResult <SensorDTO> > Adicionar(SensorDTO sensorDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var sensor = _mapper.Map <Sensor>(sensorDTO);
await _sensorService.Adicionar(sensor);
await _hubContext.Clients.All.SendAsync("ReceiveMessage", sensor);
return(Ok(sensor));
}
public JsonResult GetSensors(string projectId)
{
List <Sensor> s = new List <Sensor>();
if (ctx.Sensors.Where(s => s.ProjectId == int.Parse(projectId)).Count() > 0)
{
s = ctx.Sensors.Where(s => s.ProjectId == int.Parse(projectId)).Include(s => s.Product).ToList();
}
var sensors = new SensorDTO[] { };
if (s.Count() > 0)
{
sensors = mapper.Map <SensorDTO[]>(s);
}
return(new JsonResult(new { sensors }));
}
public async Task PingAsync(SensorDTO sensorDTO)
{
if (await Authenticate(sensorDTO))
{
Sensor sensor = await unitOfWork.Sensors.GetAsync(sensorDTO.Id);
sensor.IsBroken = sensorDTO.DamageInPercents > 0.5;
sensor.DamageInPercents = sensorDTO.DamageInPercents;
await unitOfWork.CompleteAsync();
}
else
{
throw new Exception("Creds are not valid");
}
}
public SensorDTO ToDTO()
{
SensorDTO sensorDTO = new SensorDTO();
sensorDTO.sensorID = this.sensorID;
sensorDTO.servosetting = this.servoSetting;
var tempData = data;
if (tempData != null)
{
foreach (Data data in tempData)
{
sensorDTO.data.Add(data.DataToDTO());
}
}
return(sensorDTO);
}
public async Task <SensorDTO> AddSensorAsync(SensorDTO region)
{
var user = Authorization.GetUser();
var userRole = user.GetType();
if (userRole != typeof(Administrator))
{
throw new MethodAccessException();
}
var entity = _mapper.Map <SensorDTO, Sensor>(region);
var result = await _unitOfWork.InsertAsync(entity);
await _unitOfWork.CommitAsync();
return(_mapper.Map <Sensor, SensorDTO>(result));
}
public void UpdateSensor_WithInvalidModel_Returns_BadRequestResult()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
var loggerMock = new Mock <ILogger <SensorsController> >();
var controller = new SensorsController(sensorServiceMock.Object, loggerMock.Object);
controller.ModelState.AddModelError("Error", "Model Error");
var sensorDTO = new SensorDTO();
// Act
var result = controller.UpdateSensor(sensorDTO).GetAwaiter().GetResult();
// Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task <ActionResult <SensorDTO> > Atualizar(Guid id, SensorDTO sensorDTO)
{
if (id != sensorDTO.Id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var sensor = _mapper.Map <Sensor>(sensorDTO);
await _sensorService.Atualizar(sensor);
return(Ok(sensor));
}
public SensorDTO FilterSensorByDates(int sensorId, DateTime?fromDate = null, DateTime?toDate = null)
{
var sensor = db.Sensors.First((i) => i.Id == sensorId);
if (sensor == null)
{
return(null);
}
var broadcaster = db.Broadcasters.First((i) => i.Id == sensor.Fk_Broadcaster).Name;
var location = db.Locations.First((i) => i.Id == sensor.Fk_Location).Name;
var sensorType = db.SensorTypes.First((i) => i.Id == sensor.Fk_SensorType).Type;
var sensorDTO = new SensorDTO();
sensorDTO.Id = sensor.Id;
sensorDTO.Broadcaster = broadcaster;
sensorDTO.LocationName = location;
sensorDTO.SensorType = sensorType;
var tempValues = db.Values.Where((i) => i.FK_Sensor == sensor.Id);
List <Value> values = new List <Value>();
if (toDate == null)
{
toDate = DateTime.MaxValue;
}
if (fromDate == null)
{
fromDate = DateTime.MinValue;
}
foreach (Value val in tempValues)
{
DateTime parsedTime = new DateTime();
DateTime.TryParse(val.ValueInput, out parsedTime);
if (parsedTime >= fromDate && parsedTime <= toDate)
{
values.Add(val);
}
}
sensorDTO.Values = values.AsQueryable();
return(sensorDTO);
}
public void UpdateSensor_WithInvalidModelId_Returns_BadRequestResult()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
var loggerMock = new Mock <ILogger <SensorsController> >();
var controller = new SensorsController(sensorServiceMock.Object, loggerMock.Object);
var sensorDTO = new SensorDTO {
Id = -1
};
// Act
var result = controller.UpdateSensor(sensorDTO).GetAwaiter().GetResult();
// Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.IsAssignableFrom <int>(badRequestObjectResult.Value);
}
public async Task <IActionResult> RegisterNewSensor([FromBody] SensorDTO sensor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var(id, success) = await _sensorService.RegisterNewSensorAsync(sensor);
if (!success)
{
_logger.LogWarning($"{id} {SensorsConstants.ADD_SENSOR_CONFLICT}");
return(Conflict(id));
}
sensor.Id = id;
_logger.LogInformation($"{sensor.Id} {SensorsConstants.ADD_SENSOR_SUCCESS}");
return(CreatedAtAction(nameof(RegisterNewSensor), sensor));
}
public void RegisterNewSensorPost_WithValidModel_Returns_CreatedAtActionResult()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
sensorServiceMock.Setup(service => service
.RegisterNewSensorAsync(It.IsAny <SensorDTO>()))
.Returns(Task.FromResult((1, true)));
var loggerMock = new Mock <ILogger <SensorsController> >();
var controller = new SensorsController(sensorServiceMock.Object, loggerMock.Object);
var sensorDTO = new SensorDTO();
// Act
var result = controller.RegisterNewSensor(sensorDTO).GetAwaiter().GetResult();
// Assert
var createdAtActionResult = Assert.IsType <CreatedAtActionResult>(result);
Assert.IsAssignableFrom <SensorDTO>(createdAtActionResult.Value);
}
public OperationResult CreateSensor(SensorDTO sensorDto)
{
if (sensorDto == null)
{
throw new ArgumentNullException(nameof(sensorDto), "Sensor is null");
}
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <SensorDTO, Sensor>()).CreateMapper();
Sensor sensor = mapper.Map <SensorDTO, Sensor>(sensorDto);
sensor.Orders = new List <Order>();
Database.Sensors.Create(sensor);
Database.Save();
Sensor mySensor = Database.Sensors.GetAll().Last();
Monitoring monitoring = new Monitoring {
SensorId = mySensor.Id,
ApplicationUserId = mySensor.ApplicationUserId
};
Database.Monitorings.Create(monitoring);
Database.Save();
return(new OperationResult("Sensor was created"));
}
public void UpdateSensor_WithNonexistingId_Returns_NotFoundResult()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
sensorServiceMock.Setup(service => service
.GetSensorByIdAsync(It.IsAny <int>()))
.Returns(Task.FromResult(GetNullSensor()));
var loggerMock = new Mock <ILogger <SensorsController> >();
var controller = new SensorsController(sensorServiceMock.Object, loggerMock.Object);
var sensorDTO = new SensorDTO {
Id = 2
};
// Act
var result = controller.UpdateSensor(sensorDTO).GetAwaiter().GetResult();
// Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.IsAssignableFrom <int>(notFoundObjectResult.Value);
}
public void DeleteSensor_WithInvalidModelId_Returns_NotFoundResult()
{
// Arrange
var sensorServiceMock = new Mock <ISensorService>();
sensorServiceMock.Setup(service => service
.DeleteSensorByIdAsync(It.IsAny <int>()))
.Returns(Task.FromResult(false));
var loggerMock = new Mock <ILogger <SensorsController> >();
var controller = new SensorsController(sensorServiceMock.Object, loggerMock.Object);
var sensorDTO = new SensorDTO();
var id = 1;
// Act
var result = controller.DeleteSensor(id).GetAwaiter().GetResult();
// Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.IsAssignableFrom <int>(notFoundObjectResult.Value);
}
public SensorDTO GetAllSensorInfo(int sensorId)
{
var sensor = db.Sensors.FirstOrDefault((i) => i.Id == sensorId);
if (sensor == null)
{
return(null);
}
var location = db.Locations.FirstOrDefault((i) => i.Id == sensor.Fk_Location);
var sensorType = db.SensorTypes.FirstOrDefault((i) => i.Id == sensor.Fk_SensorType);
var values = db.Values.Where((i) => i.FK_Sensor == sensor.Id);
var broadcaster = db.Broadcasters.First((i) => i.Id == sensor.Fk_Broadcaster).Name;
var sensorDTO = new SensorDTO();
sensorDTO.Id = sensor.Id;
sensorDTO.LocationName = location.Name;
sensorDTO.SensorType = sensorType.Type;
sensorDTO.Values = values;
sensorDTO.Broadcaster = broadcaster;
return(sensorDTO);
}
