public virtual void RegisterNewSensor(string username, RegisterNewSensor sensorModel)
{
Sensor sensor = new Sensor
{
UserDefinedSensorName = sensorModel.UserDefinedSensorName,
UserDefinedDescription = sensorModel.UserDefinedDescription,
UserDefinedMeasureType = sensorModel.UserDefinedMeasureType,
UserDefinedMaxValue = sensorModel.UserDefinedMaxValue,
UserDefinedMinValue = sensorModel.UserDefinedMinValue,
IsPublic = sensorModel.IsPublic,
AddedOn = DateTime.Now,
SensorType = this.dbContext.SensorTypes.First(x => x.SensorIdICB == sensorModel.SensorIdICB),
LastValue = new LastValue
{
SensorIdICB = sensorModel.SensorIdICB,
PollingInterval = sensorModel.PollingInterval,
Value = "initial value",
From = DateTime.Now
}
};
this.dbContext.Users.First(x => x.UserName == username).OwnedSensors.Add(sensor);
this.dbContext.SaveChanges();
}
public async Task <ActionResult> RegisterNewSensor()
{
//IDictionary<{SensorIdICB}, SensorType>
IDictionary <string, APISensorType> availableSensorsFromAPI = await this.APIService.ListSensorsFromAPI();
this.DBService.UpdateSensorTypes(availableSensorsFromAPI);
IEnumerable <APISensorType> availableSensors = availableSensorsFromAPI.Values;
RegisterNewSensor sensorsFromApi = new RegisterNewSensor();
sensorsFromApi.AvailableSensors = availableSensors;
//to do later: check if sensors are no longer supported
return(this.View(sensorsFromApi));
}
private async Task SeedSensors(int sensorsNumber = 5)
{
IDictionary <string, APISensorType> availableSensors = await this.APIService.ListSensorsFromAPI();
//i v rega v sensor controlera
this.DBService.UpdateSensorTypes(availableSensors);
IList <string> supportedSensorTypes = availableSensors.Keys.ToList();
IEnumerable <string> registeredUsers = this.DBService.ListAllUsers();
bool inverse = true;
foreach (string user in registeredUsers)
{
CustomSensorController customSensorController =
new CustomSensorController(user, this.DBService, this.APIService);
for (int i = 0; i < sensorsNumber; i++)
{
inverse = !inverse;
APISensorType mainSensorInfo = availableSensors[supportedSensorTypes[this.random.Next(0, supportedSensorTypes.Count - 1)]];
string descriptionByICB = mainSensorInfo.Description;
string[] subDescription = descriptionByICB.Split(); //"This sensor will return values between 6 and 18" or "This sensor will return true or false value"
double minValue = 0;
double maxValue = 0;
if (subDescription.Contains("between"))
{
try //try with int
{
int mainMinValueI = int.Parse(subDescription[subDescription.Length - 3]);
int mainMaxValueI = int.Parse(subDescription[subDescription.Length - 1]);
int randomMinValue = this.random.Next(mainMinValueI, mainMaxValueI);
minValue = randomMinValue;
int randomMaxValue = this.random.Next(randomMinValue, mainMaxValueI);
maxValue = randomMaxValue;
}
catch
{
try //try with double. Trunkate because of Random() does not work with noninteger numbers
{
double mainMinValueD = Math.Truncate(double.Parse(subDescription[subDescription.Length - 3]));
double mainMaxValueD = Math.Truncate(double.Parse(subDescription[subDescription.Length - 1]));
int randomMinValue = this.random.Next((int)mainMinValueD, (int)mainMaxValueD);
minValue = randomMinValue;
int randomMaxValue = this.random.Next(randomMinValue, (int)mainMaxValueD);
maxValue = randomMaxValue;
}
catch //ebago
{
}
}
}
int pollingInterval = this.random.Next(mainSensorInfo.MinPollingIntervalInSeconds, mainSensorInfo.MinPollingIntervalInSeconds * 3);
RegisterNewSensor sensorModel = new RegisterNewSensor
{
AvailableSensors = null,
IsPublic = inverse,
PollingInterval = pollingInterval,
SensorIdICB = mainSensorInfo.SensorId,
Tag = mainSensorInfo.Tag,
UserDefinedSensorName = string.Format("{0}`s {1} sensor.", user, mainSensorInfo.Tag),
UserDefinedDescription = mainSensorInfo.Description,
UserDefinedMeasureType = mainSensorInfo.MeasureType, //to improove later
UserDefinedMinValue = minValue,
UserDefinedMaxValue = maxValue
};
customSensorController.RegisterNewSensor(sensorModel);
}
}
}
public ActionResult RegisterNewSensor(RegisterNewSensor sensorModel)
{
sensorModel.AvailableSensors = null; //just in case
//validation
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid model state." }));
}
if (sensorModel.SensorIdICB == null)
{
return(this.RedirectToAction("InvalidInput", new { message = "Sensor ID cannot be empty." }));
}
if (sensorModel.UserDefinedSensorName == null)
{
return(this.RedirectToAction("InvalidInput", new { message = "Name cannot be empty." }));
}
try
{
SensorType serverSensorType = this.DBService.GetSpecificSensorType(sensorModel.SensorIdICB);
if (sensorModel.PollingInterval < serverSensorType.MinPollingIntervalInSeconds)
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid minimal polling interval." }));
}
string operatingRange = serverSensorType.Description;
string[] substring = operatingRange.Split();
//"This sensor will return values between 6 and 18" or "This sensor will return true or false value"
if (serverSensorType.IsNumericValue)
{
//case sensor is integer type
double serverMinVal = double.Parse(substring[substring.Length - 3]);
double serverMaxVal = double.Parse(substring[substring.Length - 1]);
if (sensorModel.UserDefinedMinValue >= serverMinVal && sensorModel.UserDefinedMinValue <= serverMaxVal)
{
}
else
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid sensor minimal value." }));
}
if (sensorModel.UserDefinedMaxValue <= serverMaxVal && sensorModel.UserDefinedMaxValue >= serverMinVal)
{
}
else
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid sensor maximum value." }));
}
}
else
{
//case sensor is boolean type
if (sensorModel.UserDefinedMinValue != 0 || sensorModel.UserDefinedMaxValue != 0)
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid sensor min / maximum value when the sensor is boolean type." }));
}
}
//fix later with option the measurment type to be possible to be choosen and different
sensorModel.UserDefinedMeasureType = serverSensorType.MeasureType;
}
catch
{
//this is if the user tries even entering invalid sensorIdICB just to brake the application
return(this.RedirectToAction("InvalidInput", new { message = "Invalid sensor ID." }));
}
this.DBService
.RegisterNewSensor(GetLoggedUsername(), sensorModel);
return(this.View("Success"));
}
