public async Task <MeasurementItem> GetMeasurementItem()
{
MeasurementItem Item = null;
try
{
DB.BeginTransaction();
var Entity = DB.Table <MeasurementsEntity>().FirstOrDefault();
Item = GetMeasurementItem(Entity);
DB.Commit();
}
catch (SQLiteException e)
{
Trace.WriteLine(e);
DB.Rollback();
return(null);
}
catch (JsonReaderException e)
{
Console.WriteLine(e);
DB.Rollback();
return(null);
}
return(Item);
}
private MeasurementItem GetMeasurementItem(MeasurementsEntity Entity)
{
MeasurementItem mi = null;
try
{
Console.WriteLine("-----GETTING ENTITY:{0}----", Entity.Id);
var mie = DB.Query <MeasurementItemEntity>
("SELECT * FROM MeasurementItemEntity WHERE Id = ?", Entity.Current)?.FirstOrDefault();
Console.WriteLine("-----GOT ENTITY:{0}----", Entity.Id);
var mieVs = JsonConvert.DeserializeObject <List <MeasurementValue> >(mie.Values);
var mieIs = JsonConvert.DeserializeObject <List <AirQualityIndex> >(mie.Indexes);
var mieSs = JsonConvert.DeserializeObject <List <AirQualityStandard> >(mie.Standards);
Console.WriteLine("-----GOT DATA:{0}----", Entity.Id);
mi = new MeasurementItem();
mi.Indexes = mieIs.ToArray();
mi.Standards = mieSs.ToArray();
mi.Values = mieVs.ToArray();
mi.FromDateTime = mie.FromDateTime;
mi.FromDateTime = mie.TillDateTime;
Console.WriteLine("-----CREATED ITEM:{0}----", Entity.Id);
}
catch (SQLiteException e)
{
Console.WriteLine(e);
}
catch (JsonReaderException e)
{
Console.WriteLine(e);
}
return(mi);
}
internal static MeasurementItem FromApi(ApiMeasurementItem item, MeasurementItemType type)
=> MeasurementItem.Create(type,
item.FromDateTime,
item.TillDateTime,
item.Values.Select(AirlyApiMeasurementValueAdapter.FromApi).ToList(),
item.Indexes.Select(AirlyApiQualityIndexApiAdapter.FromApi).ToList(),
item.Standards.Select(AirlyApiQualityStandardApiAdapter.FromApi).ToList());
public List <Measurement> SelectMeasurements()
{
List <MeasurementEntity> measurementEntities = DatabaseConnection.Table <MeasurementEntity>().ToList();
List <Measurement> measurements = new List <Measurement>();
foreach (MeasurementEntity measurementEntity in measurementEntities)
{
InstallationEntity installationEntity = DatabaseConnection.Get <InstallationEntity>(measurementEntity.InstallationID);
Installation installation = new Installation(installationEntity);
MeasurementItemEntity measurementItemEntity = DatabaseConnection.Get <MeasurementItemEntity>(measurementEntity.CurrentID);
var valuesArray = JArray.Parse(measurementItemEntity.Values);
var indexesArray = JArray.Parse(measurementItemEntity.Indexes);
var standardsArray = JArray.Parse(measurementItemEntity.Standards);
var valueIDs = ParseJSONToIntArray(valuesArray, "Id");
var indexIDs = ParseJSONToIntArray(indexesArray, "Id");
var standardIDs = ParseJSONToIntArray(standardsArray, "Id");
var measurementValues = DatabaseConnection.Table <ParameterValue>().Where(x => valueIDs.Contains(x.Id)).ToList();
var measurementIndexes = DatabaseConnection.Table <Index>().Where(x => indexIDs.Contains(x.Id)).ToList();
var measurementStandards = DatabaseConnection.Table <Standard>().Where(x => standardIDs.Contains(x.Id)).ToList();
MeasurementItem measurementItem = new MeasurementItem(measurementItemEntity, measurementValues, measurementIndexes, measurementStandards);
Measurement measurement = new Measurement(measurementEntity, installation, measurementItem);
measurements.Add(measurement);
}
return(measurements);
}
public void SetUpUI(MeasurementItem mI, Transform list)
{
measurementItem = mI;
measurementItem.guiInstance = Instantiate(RocketPartPopulator.populator.measurementPrefab);
measurementItem.guiInstance.transform.SetParent(list, false);
measurementItem.infoLabel = measurementItem.guiInstance.transform.Find("HorizPart/NumValue").GetComponent <TextMeshProUGUI>();
measurementItem.colorIndicator = measurementItem.guiInstance.transform.Find("HorizPart/ColorIndicator").GetComponent <Image>();
measurementItem.button = measurementItem.guiInstance.transform.Find("HorizPart/InteractButton").GetComponent <Button>();
if (!measurementItem.buttonEnabled)
{
measurementItem.button.gameObject.SetActive(false);
}
measurementItem.button.transform.Find("ButtonText").GetComponent <TextMeshProUGUI>().text = measurementItem.buttonText;
measurementItem.graphUI = measurementItem.guiInstance.transform.Find("GraphContainer/Graph").GetComponent <Graph>();
measurementItem.graphUI.XAxisLabel = measurementItem.graphXAxisLabel;
measurementItem.graphUI.YAxisLabel = measurementItem.graphYAxisLabel;
//measurementItem.graphUI.addTestPoints = true;
GraphDisplayer disp = measurementItem.guiInstance.transform.Find("GraphContainer").GetComponent <GraphDisplayer>();
disp.parentRectTransform = GetComponent <RectTransform>();
//mat =
}
public MeasurementItemEntity(MeasurementItem mi)
{
FromDateTime = mi.FromDateTime;
TillDateTime = mi.TillDateTime;
Values = JsonConvert.SerializeObject(mi.Values);
Indexes = JsonConvert.SerializeObject(mi.Indexes);
Standards = JsonConvert.SerializeObject(mi.Standards);
}
public async Task <List <Measurement> > GetMeasurements()
{
var measurementEntitiesQuery = dbAsyncConnection.Table <MeasurementEntity>();
var measurementEntities = await measurementEntitiesQuery.ToListAsync();
var measurements = new List <Measurement>(measurementEntities.Count);
foreach (var measurementEntity in measurementEntities)
{
var entityInstallationEntityQuery = dbAsyncConnection.Table <InstallationEntity>()
.Where(x => x.Id == measurementEntity.InstallationId);
var installationEntity = await entityInstallationEntityQuery.FirstAsync();
var installation = new Installation(installationEntity);
var measurementItemEntityQuery = dbAsyncConnection.Table <MeasurementItemEntity>()
.Where(x => x.Id == measurementEntity.CurrentId);
var measurementItemEntity = await measurementItemEntityQuery.FirstAsync();
var valuesIndexes = JsonConvert.DeserializeObject <List <int> >(measurementItemEntity.Values);
var indexesIndexes = JsonConvert.DeserializeObject <List <int> >(measurementItemEntity.Indexes);
var standardsIndexes = JsonConvert.DeserializeObject <List <int> >(measurementItemEntity.Standards);
var valuesQuery = dbAsyncConnection.Table <MeasurementValue>().Where(x => valuesIndexes.Contains(x.Id));
var values = await valuesQuery.ToListAsync();
var indexesQuery = dbAsyncConnection.Table <AirQualityIndex>().Where(x => indexesIndexes.Contains(x.Id));
var indexes = await indexesQuery.ToListAsync();
var standardsQuery = dbAsyncConnection.Table <AirQualityStandard>().Where(x => standardsIndexes.Contains(x.Id));
var standards = await standardsQuery.ToListAsync();
var current = new MeasurementItem
{
FromDateTime = measurementItemEntity.FromDateTime,
TillDateTime = measurementItemEntity.TillDateTime,
Values = values,
Indexes = indexes,
Standards = standards
};
var measurement = new Measurement
{
Installation = installation,
Current = current
};
measurements.Add(measurement);
}
return(measurements);
}
public Measurement(long?id,
int currentDisplayValue,
MeasurementItem current,
List <MeasurementItem> history,
List <MeasurementItem> forecast,
InstallationDomain installation)
{
Id = id;
CurrentDisplayValue = currentDisplayValue;
Current = current;
History = history;
Forecast = forecast;
Installation = installation;
}
public MeasurementItemEntity(MeasurementItem measurementItem)
{
if (measurementItem == null)
{
return;
}
FromDateTime = measurementItem.FromDateTime;
TillDateTime = measurementItem.TillDateTime;
MeasurementValueIds = JsonConvert.SerializeObject(measurementItem.Values?.Select(s => s.Id));
AirQualityIndexIds = JsonConvert.SerializeObject(measurementItem.Indexes?.Select(s => s.Id));
AirQualityStandardIds = JsonConvert.SerializeObject(measurementItem.Standards?.Select(s => s.Id));
}
public IActionResult Item(int id)
{
MeasurementItem item = null;
try
{
item = _measurementService.GetMeasurement(id);
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
return(Ok(item));
}
public async Task <IEnumerable <Measurement> > GetMeasurements()
{
var List = new List <Measurement>();
try
{
Console.WriteLine("-----GETTING MEASUREMENT DATA-----");
var MeasurementItemList = new List <MeasurementItem>();
DB.BeginTransaction();
var Table = DB.Table <MeasurementsEntity>();
foreach (var Entity in Table)
{
var ie = DB.Query <InstallationEntity>
("SELECT * FROM InstallationEntity WHERE Id = ?", Entity.Installation)?.FirstOrDefault();
var i = new Installation(ie);
MeasurementItem mi = GetMeasurementItem(Entity);
MeasurementItemList.Add(mi);
var m = new Measurement();
m.Current = mi;
m.Installation = i;
List.Add(m);
}
DB.Commit();
Console.WriteLine("-----GOT MEASUREMENT DATA-----");
}
catch (SQLiteException e)
{
Trace.WriteLine(e);
DB.Rollback();
return(null);
}
catch (JsonReaderException e)
{
Console.WriteLine(e);
DB.Rollback();
return(null);
}
return(List);
}
public Measurement WithCurrent(MeasurementItem current)
{
Current = current;
return(this);
}
public MeasurementItemEntity(MeasurementItem item)
{
Values = JsonConvert.SerializeObject(item.Values);
Standards = JsonConvert.SerializeObject(item.Standards);
Indexes = JsonConvert.SerializeObject(item.Indexes);
}
public List <MeasurementValue> SaveAllFromMeasurementItem(MeasurementItem item)
=> item.Values.Select(value => Save(value, item.Id ?? throw new ArgumentException("MeasurementItem id is null")))
public List <AirQualityStandard> SaveAllFromMeasurementItem(MeasurementItem item)
=> item.Standards.Select(standard => Save(standard, item.Id ?? throw new ArgumentException("MeasurementItem id is null")))
public Measurement(MeasurementItem measurementItem, Installation installation)
{
Current = measurementItem;
Installation = installation;
}
public GetMeasurementByInstallationIdResponse(MeasurementItem current)
{
Current = current;
}
public MeasurementDomain ToDomain(MeasurementItem current,
List <MeasurementItem> history,
List <MeasurementItem> forecast,
InstallationDomain installation)
=> new MeasurementDomain(Id, CurrentDisplayValue, current, history, forecast, installation);
public static Measurement Create(int currentDisplayValue,
MeasurementItem current,
List <MeasurementItem> history,
List <MeasurementItem> forecast,
Installation.Installation installation)
=> new Measurement(null, currentDisplayValue, current, history, forecast, installation);
public List <AirQualityIndex> SaveAllFromMeasurementItem(MeasurementItem item)
=> item.Indexes.Select(index => Save(index, item.Id ?? throw new ArgumentException("MeasurementItem id is null")))
public static MeasurementItemEntity FromDomain(MeasurementItem item, long measurementRef)
=> new MeasurementItemEntity(item.Id,
(int)item.Type,
item.FromDateTime,
item.TillDateTime,
measurementRef);
