private void PopulateFieldMap(ParsedDataModel model, List <SensorModel> sensors)
{
var dataRow = model.Data.FirstOrDefault();
if (null != dataRow)
{
if (model.FieldMap.Count > dataRow.Count)
{
model.FieldMap = model.FieldMap.Take(dataRow.Count).ToList();
}
else
{
int sensorIndex = 0;
int sensorCount = null != sensors ? sensors.Count : 0;
for (int i = model.FieldMap.Count; i < dataRow.Count; i++)
{
if (sensorIndex < sensorCount)
{
model.FieldMap.Add(sensors[sensorIndex++].Tag);
}
else
{
model.FieldMap.Add("");
}
}
}
}
}
public async Task <ActionResult> Parse(RawDataModel data)
{
ParsedDataModel model = new ParsedDataModel();
if (null == data)
{
return(View(model));
}
model.Key = data.Key;
model.DataFieldType = DataField.Value;
List <SensorModel> sensors = null;
if (!string.IsNullOrEmpty(model.Key))
{
Repository r = new Repository();
sensors = await r.GetSensorsAsync(model.Key);
}
model.Data = this.ParseRawData(data);
this.PopulateFieldMap(model, sensors);
return(View(model));
}
public async Task <IActionResult> UpdateData([FromBody] ParsedDataModel data)
{
await _mediator.Send(new UpdateData(data));
return(new OkObjectResult(new { message = "all good" }));
}
public UpdateData(ParsedDataModel data)
{
NewData = data;
}
public async Task <ParsedDataModel> GetCurrentData() => _localData = JsonConvert.DeserializeObject <ParsedDataModel>(await _fileService.GetRawData());
public static InfectionsStatsModel MapToInfectionsStatsModel(LiveUpdateData liveData, ParsedDataModel parsedData)
{
if (liveData == null)
{
return(new InfectionsStatsModel());
}
var data = new InfectionsStatsModel()
{
Confirmed = liveData.NumberDiagnosed ?? 0,
Cured = liveData.NumberCured ?? 0,
Hospitalized = parsedData.PatientsInfo.Count(p => p.Condition == PatientCondition.Hospitalised),
InQuarantine = liveData.NumberQuarantined ?? 0,
Monitored = liveData.NumberMonitoredAtHome ?? 0,
Deaths = parsedData.PatientsInfo.Count(p => p.Condition == PatientCondition.Deceased),
InIcu = parsedData.PatientsInfo.Count(p => p.Condition == PatientCondition.ICU),
Date = new DateTimeOffset(liveData.Timestamp).ToUnixTimeSeconds(),
DateString = liveData.Timestamp.ToShortDateString()
};
return(data);
}
public async Task <ActionResult> SaveParsed(ParsedDataModel data)
{
if (null == data || string.IsNullOrEmpty(data.Key))
{
ModelState.AddModelError("Key", "Key cannot be empty!");
return(View("Parse", data));
}
data.Data = this.ParseRawData(data);
Repository r = new Repository();
List <MeasurementModel> measurements = new List <MeasurementModel>();
MeasurementModel mm;
int timeIndex = data.FieldMap.IndexOf(ParsedDataModel.MeasurementTimeField);
int objectIndex = data.FieldMap.IndexOf(ParsedDataModel.MeasurementObjectField);
int tagIndex = data.FieldMap.IndexOf(ParsedDataModel.MeasurementTagField);
foreach (var row in data.Data)
{
mm = new MeasurementModel()
{
Timestamp = timeIndex > -1 ? row[timeIndex].ToDateTimeOffset() : DateTimeOffset.Now,
Object = objectIndex > -1 ? row[objectIndex] : null,
Tag = tagIndex > -1 ? row[tagIndex] : null,
Data = new List <DataModel>()
};
DataModel d;
switch (data.DataFieldType)
{
case DataField.LongValue:
for (int i = 0; i < row.Count; i++)
{
if (i != timeIndex && i != objectIndex && i != tagIndex)
{
if (string.IsNullOrEmpty(data.FieldMap[i]))
{
continue;
}
d = new DataModel()
{
Tag = data.FieldMap[i],
LongValue = row[i].ToLong()
};
mm.Data.Add(d);
}
}
break;
case DataField.Value:
for (int i = 0; i < row.Count; i++)
{
if (i != timeIndex && i != objectIndex && i != tagIndex)
{
if (string.IsNullOrEmpty(data.FieldMap[i]))
{
continue;
}
d = new DataModel()
{
Tag = data.FieldMap[i],
Value = row[i].ToDouble()
};
mm.Data.Add(d);
}
}
break;
default:
for (int i = 0; i < row.Count; i++)
{
if (string.IsNullOrEmpty(data.FieldMap[i]))
{
continue;
}
if (i != timeIndex && i != objectIndex && i != tagIndex)
{
d = new DataModel()
{
Tag = data.FieldMap[i],
TextValue = row[i]
};
mm.Data.Add(d);
}
}
break;
}
measurements.Add(mm);
}
SaveResult result = null;
try
{
result = await r.SaveMeasurementsAsync(data.Key, measurements.ToArray());
}
catch (KeyNotFoundException kex)
{
return(HttpNotFound(kex.Message));
}
catch (UnauthorizedAccessException uex)
{
return(HttpNotFound(uex.Message));
}
return(View(result));
}
