jrojas
1262 lines
53 KiB
C#
1262 lines
53 KiB
C#
using System.Globalization;
|
|
using adas_core.Application.Repositories.Interfaces;
|
|
using adas_core.Application.Services.Interfaces;
|
|
using adas_core.Application.Subscriptions;
|
|
using adas_core.Domain.Enums;
|
|
using adas_core.Domain.Models;
|
|
using adas_core.Domain.Models.AppSettings;
|
|
using adas_core.Domain.Models.GroupedObservations;
|
|
using adas_core.Domain.Utils;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Extensions.Options;
|
|
using MongoDB.Bson;
|
|
using static adas_core.Domain.Models.GroupedObservation;
|
|
|
|
namespace adas_core.Application.Services;
|
|
|
|
public class GroupedObservationService : IGroupedObservationService
|
|
{
|
|
private readonly CacheSettings? _cacheSettings;
|
|
private readonly ICacheService _cacheService;
|
|
private readonly IConfigObservationService _configObservationService;
|
|
private readonly ILogger<GroupedObservationService> _logger;
|
|
private readonly IObservationRepository _observationRepository;
|
|
|
|
public GroupedObservationService(
|
|
IObservationRepository observationRepository,
|
|
IConfigObservationService configObservationService,
|
|
ILogger<GroupedObservationService> logger,
|
|
ICacheService cacheService,
|
|
IOptions<ApiSettings> apiSettings,
|
|
IOptions<CacheSettings> cacheSettings)
|
|
{
|
|
_observationRepository = observationRepository;
|
|
_configObservationService = configObservationService;
|
|
_logger = logger;
|
|
_cacheService = cacheService;
|
|
_cacheSettings = cacheSettings.Value;
|
|
}
|
|
|
|
|
|
// PUBLIC API (Use cases)
|
|
public async Task<GroupedObservation> GenerateGroupedObservation(
|
|
ObjectId patientId,
|
|
GroupedField groupedField,
|
|
string timeZoneId = "Romance Standard Time",
|
|
bool cacheIsChecked = false,
|
|
CancellationToken ct = default)
|
|
{
|
|
// Loader que calcula TODA la lista de observaciones agrupadas
|
|
async Task<List<GroupedObservationObs>> ComputeObservationsAsync()
|
|
{
|
|
var result = await _observationRepository.AggregatedPatientGroupedObservations(patientId, groupedField);
|
|
|
|
var tz = TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
|
|
|
|
result = FillHours(result, groupedField);
|
|
|
|
if (groupedField.StartTimeShift.Count > 0 &&
|
|
groupedField.Regularity == GroupedObservationEnum.Regularity.Shift)
|
|
{
|
|
var shiftGroupObservations = GenerateShiftObservations(result, groupedField);
|
|
result = CalculateShiftObservations(shiftGroupObservations, groupedField);
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.HalfHour))
|
|
{
|
|
result = CalculateHalfHourObservations(result);
|
|
result = FillHours(result, groupedField);
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.LastFilled))
|
|
result = await CalculateLastFilledObservations(result, groupedField, patientId);
|
|
|
|
var list = new List<GroupedObservationObs>();
|
|
|
|
foreach (var it in result.ToList())
|
|
{
|
|
var id = it.TryGetElement("_id", out var _) ? it.GetElement("_id").Value.AsBsonDocument : null;
|
|
var name = id?.Get("name")?.AsString;
|
|
if (name is null or "_id")
|
|
{
|
|
var idValue = id?.Get("value") as BsonDocument;
|
|
name = idValue?.Get("name")?.AsString;
|
|
}
|
|
|
|
var uTime = it.Get("time")?.ToUniversalTime();
|
|
if (!uTime.HasValue)
|
|
{
|
|
_logger.LogError("Error getting time to universal time. Bson document: {it}", it);
|
|
continue;
|
|
}
|
|
|
|
var obsTime = TimeZoneInfo.ConvertTimeFromUtc(uTime.Value, tz);
|
|
obsTime = DateTime.SpecifyKind(obsTime, DateTimeKind.Local);
|
|
|
|
var obs = new GroupedObservationObs
|
|
{
|
|
Time = obsTime,
|
|
Name = name ?? string.Empty
|
|
};
|
|
|
|
if (it.TryGetValue("shift", out var shiftValue) && it.TryGetValue("day", out _))
|
|
{
|
|
obs.Shift = shiftValue.ToInt32();
|
|
obs.ShiftDate = obs.Time;
|
|
}
|
|
|
|
if (id != null && id.Contains("min")) obs.MinAlert = id.Get("min")?.ToDouble();
|
|
if (id != null && id.Contains("max")) obs.MaxAlert = id.Get("max")?.ToDouble();
|
|
if (id != null && it.Contains("isFilled")) obs.IsFilled = (bool)it.Get("isFilled");
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.First))
|
|
{
|
|
var g = !it.Contains("first") ? null : it.Get("first")?.AsBsonDocument;
|
|
if (g != null)
|
|
{
|
|
var value = g.Get("value")?.ToObject();
|
|
var min = g.Get("min")?.ToDouble();
|
|
var max = g.Get("max")?.ToDouble();
|
|
var uTim = g.Get("time")?.ToUniversalTime();
|
|
if (!uTim.HasValue) { _logger.LogError("Error getting utc time in 'first': {it}", it); goto addObs; }
|
|
|
|
var time = TimeZoneInfo.ConvertTimeFromUtc(uTim.Value, tz);
|
|
time = DateTime.SpecifyKind(time, DateTimeKind.Local);
|
|
if (string.IsNullOrEmpty(name) || value == null)
|
|
{ _logger.LogError("Invalid 'first' grouped obs (name/value) patient:{patientId}", patientId); goto addObs; }
|
|
|
|
obs.First = new GroupedObservationObsValue(
|
|
value, time,
|
|
await GroupedObservationStatus(groupedField, GroupedObservationEnum.Result.First, name, value, min, max)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.Last))
|
|
{
|
|
var g = !it.Contains("last") ? null : it.Get("last")?.AsBsonDocument;
|
|
if (g != null)
|
|
{
|
|
var value = g.Get("value")?.ToObject();
|
|
var min = g.Get("min")?.ToDouble();
|
|
var max = g.Get("max")?.ToDouble();
|
|
var uTim = g.Get("time")?.ToUniversalTime();
|
|
if (!uTim.HasValue) { _logger.LogError("Error getting utc time in 'last': {it}", it); goto addObs; }
|
|
|
|
var time = TimeZoneInfo.ConvertTimeFromUtc(uTim.Value, tz);
|
|
time = DateTime.SpecifyKind(time, DateTimeKind.Local);
|
|
if (string.IsNullOrEmpty(name) || value == null)
|
|
{ _logger.LogError("Invalid 'last' grouped obs (name/value) patient:{patientId}", patientId); goto addObs; }
|
|
|
|
obs.Last = new GroupedObservationObsValue(
|
|
value, time,
|
|
await GroupedObservationStatus(groupedField, GroupedObservationEnum.Result.Last, name, value, min, max)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.Min))
|
|
{
|
|
var g = !it.Contains("min") ? null : it.Get("min")?.AsBsonDocument;
|
|
if (g != null)
|
|
{
|
|
var value = g.Get("value")?.ToObject();
|
|
var min = g.Get("min")?.ToDouble();
|
|
var max = g.Get("max")?.ToDouble();
|
|
var uTim = g.Get("time")?.ToUniversalTime();
|
|
if (!uTim.HasValue) { _logger.LogError("Error getting utc time in 'min': {it}", it); goto addObs; }
|
|
|
|
var time = TimeZoneInfo.ConvertTimeFromUtc(uTim.Value, tz);
|
|
time = DateTime.SpecifyKind(time, DateTimeKind.Local);
|
|
if (string.IsNullOrEmpty(name) || value == null)
|
|
{ _logger.LogError("Invalid 'min' grouped obs (name/value) patient:{patientId}", patientId); goto addObs; }
|
|
|
|
obs.Min = new GroupedObservationObsValue(
|
|
value, time,
|
|
await GroupedObservationStatus(groupedField, GroupedObservationEnum.Result.Min, name, value, min, max)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.Max))
|
|
{
|
|
var g = !it.Contains("max") ? null : it.Get("max")?.AsBsonDocument;
|
|
if (g != null)
|
|
{
|
|
var value = g.Get("value")?.ToObject();
|
|
var min = g.Get("min")?.ToDouble();
|
|
var max = g.Get("max")?.ToDouble();
|
|
var uTim = g.Get("time")?.ToUniversalTime();
|
|
if (!uTim.HasValue) { _logger.LogError("Error getting utc time in 'max': {it}", it); goto addObs; }
|
|
|
|
var time = TimeZoneInfo.ConvertTimeFromUtc(uTim.Value, tz);
|
|
time = DateTime.SpecifyKind(time, DateTimeKind.Local);
|
|
if (string.IsNullOrEmpty(name) || value == null)
|
|
{ _logger.LogError("Invalid 'max' grouped obs (name/value) patient:{patientId}", patientId); goto addObs; }
|
|
|
|
obs.Max = new GroupedObservationObsValue(
|
|
value, time,
|
|
await GroupedObservationStatus(groupedField, GroupedObservationEnum.Result.Max, name, value, min, max)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.Sum))
|
|
{
|
|
var value = !it.Contains("sum") ? null : it.Get("sum")?.ToObject();
|
|
if (value != null && !string.IsNullOrEmpty(name))
|
|
{
|
|
obs.Sum = new GroupedObservationObsValue(
|
|
value, null,
|
|
await GroupedObservationStatus(groupedField, GroupedObservationEnum.Result.Sum, name, value, null, null)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.Average))
|
|
{
|
|
var value = !it.Contains("average") ? null : it.Get("average")?.ToObject();
|
|
if (value != null && !string.IsNullOrEmpty(name))
|
|
{
|
|
obs.Average = new GroupedObservationObsValue(
|
|
value, null,
|
|
await GroupedObservationStatus(groupedField, GroupedObservationEnum.Result.Average, name, value, null, null)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.Count))
|
|
{
|
|
var value = !it.Contains("count") ? null : it.Get("count")?.AsNullableInt32;
|
|
if (value != null && !string.IsNullOrEmpty(name))
|
|
{
|
|
obs.Count = new GroupedObservationObsValue(
|
|
value, null,
|
|
await GroupedObservationStatus(groupedField, GroupedObservationEnum.Result.Count, name, value, null, null)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.LastFilled))
|
|
{
|
|
var g = !it.Contains("lastfilled") ? null : it.Get("lastfilled")?.AsBsonDocument;
|
|
if (g != null)
|
|
{
|
|
var value = g.Get("value")?.ToObject();
|
|
var min = g.Get("min")?.ToDouble();
|
|
var max = g.Get("max")?.ToDouble();
|
|
var uTim = g.Get("time")?.ToUniversalTime();
|
|
if (!uTim.HasValue) { _logger.LogError("Error getting utc time in 'lastfilled': {it}", it); goto addObs; }
|
|
|
|
var time = TimeZoneInfo.ConvertTimeFromUtc(uTim.Value, tz);
|
|
time = DateTime.SpecifyKind(time, DateTimeKind.Local);
|
|
|
|
if (value != null && !string.IsNullOrEmpty(name))
|
|
{
|
|
obs.LastFilled = new GroupedObservationObsValue(
|
|
value, time,
|
|
await GroupedObservationStatus(groupedField, GroupedObservationEnum.Result.LastFilled, name, value, min, max)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.HalfHour))
|
|
{
|
|
var g = !it.Contains("halfhour") ? null : it.Get("halfhour")?.AsBsonDocument;
|
|
if (g != null)
|
|
{
|
|
var value = g.Get("value")?.ToObject();
|
|
var min = g.Get("min")?.ToDouble();
|
|
var max = g.Get("max")?.ToDouble();
|
|
var uTim = g.Get("time")?.ToUniversalTime();
|
|
if (!uTim.HasValue) { _logger.LogError("Error getting utc time in 'halfhour': {it}", it); goto addObs; }
|
|
|
|
var time = TimeZoneInfo.ConvertTimeFromUtc(uTim.Value, tz);
|
|
time = DateTime.SpecifyKind(time, DateTimeKind.Local);
|
|
|
|
if (value != null && !string.IsNullOrEmpty(name))
|
|
{
|
|
obs.HalfHour = new GroupedObservationObsValue(
|
|
value, time,
|
|
await GroupedObservationStatus(groupedField, GroupedObservationEnum.Result.Last, name, value, min, max)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
addObs:
|
|
_logger.LogTrace("PatientId: {patientId}. Add to grouped observation: {obs}", patientId, obs);
|
|
list.Add(obs);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
// caché explícita por clave + TTL ---
|
|
if (!cacheIsChecked)
|
|
{
|
|
var (key, ttl) = CacheKeys.GroupedObsKeyWithTtl(_cacheSettings, patientId, groupedField.Name ?? string.Empty);
|
|
|
|
var observations = await _cacheService.GetOrSetObjectAsync(
|
|
key,
|
|
ComputeObservationsAsync,
|
|
ttl,
|
|
ct);
|
|
|
|
return new GroupedObservation
|
|
{
|
|
PatientId = patientId,
|
|
Group = groupedField.Group,
|
|
Name = groupedField.Name,
|
|
Observations = observations
|
|
};
|
|
}
|
|
|
|
// Re-cálculo forzado (sin tocar caché)
|
|
var computed = await ComputeObservationsAsync();
|
|
|
|
return new GroupedObservation
|
|
{
|
|
PatientId = patientId,
|
|
Group = groupedField.Group,
|
|
Name = groupedField.Name,
|
|
Observations = computed
|
|
};
|
|
}
|
|
|
|
public async Task<GroupedObservation> GenerateGroupedObservation(
|
|
ObjectId patientId,
|
|
GroupedField groupedField,
|
|
List<GroupedObservationObs> wsgLastGroupedObservationObs,
|
|
PatientObservation obs,
|
|
string timeZoneId = "Romance Standard Time")
|
|
{
|
|
|
|
// Estos resultados requieren recálculo completo (no incremental)
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.Average) ||
|
|
groupedField.Result.Contains(GroupedObservationEnum.Result.HalfHour) ||
|
|
groupedField.Result.Contains(GroupedObservationEnum.Result.Sum))
|
|
{
|
|
return await GenerateGroupedObservation(patientId, groupedField, timeZoneId, true);
|
|
}
|
|
|
|
// Clave consistente con CacheDispatcher / backends
|
|
var cacheKey = $"GroupedObs:{patientId}:{groupedField.Name}";
|
|
|
|
// Intentar leer caché actual
|
|
var cached = await _cacheService.GetObjectAsync<List<GroupedObservationObs>>(cacheKey, true);
|
|
if (cached != null)
|
|
{
|
|
_logger.LogInformation("Return cached grouped obs (incremental)");
|
|
|
|
// Actualizar lista en memoria
|
|
var updated = LocateCurrentObsInGroup(cached, obs, groupedField);
|
|
|
|
// Persistir nueva lista (SET incremental)
|
|
await _cacheService.SetObjectAsync(cacheKey, updated, true);
|
|
|
|
return new GroupedObservation
|
|
{
|
|
PatientId = patientId,
|
|
Group = groupedField.Group,
|
|
Name = groupedField.Name,
|
|
Observations = updated
|
|
};
|
|
}
|
|
// Si MISS, recálculo completo y salida
|
|
return await GenerateGroupedObservation(patientId, groupedField, timeZoneId, true);
|
|
}
|
|
|
|
public async Task<List<PatientObservation>> FindLastObservations(ObjectId patientId, int num = 2,
|
|
List<string>? filterObservations = null)
|
|
{
|
|
var result = await _observationRepository.AggregatedPatientLastObservations(patientId, num, filterObservations);
|
|
return result;
|
|
}
|
|
|
|
public async Task<GroupedObservation> CreateNextEmptyObs(WsSubscriberGrouped ws)
|
|
{
|
|
var gf = new GroupedField
|
|
{
|
|
Max = ws.Max,
|
|
Since = ws.Since,
|
|
StartTimeShift = ws.StartTimeShift,
|
|
Regularity = ws.Regularity,
|
|
Result = ws.Result,
|
|
Names = ws.Names,
|
|
Name = ws.Names.First(),
|
|
Group = ws.Group.FirstOrDefault().Value
|
|
};
|
|
|
|
// Mantenemos el uso del HashCode
|
|
var currentObsList = await _cacheService.GetObjectAsync<List<GroupedObservationObs>>(ws.HashCode, false);
|
|
|
|
if (currentObsList is { Count: > 0 })
|
|
{
|
|
var orderCurrentObsList = currentObsList.OrderBy(c => c.Time).ToList();
|
|
|
|
foreach (var name in gf.Names)
|
|
{
|
|
var obs = orderCurrentObsList.LastOrDefault(c => c.Name == name)
|
|
?? orderCurrentObsList.LastOrDefault();
|
|
if (obs != null)
|
|
{
|
|
var (timesLeft, multiplierFactor) = TimesLeftToCreateEmptyObs(obs, gf);
|
|
for (var i = 1; i <= timesLeft; i++)
|
|
orderCurrentObsList.Add(CreateNextObs(obs, gf, i * multiplierFactor));
|
|
}
|
|
}
|
|
|
|
// Ajuste de ventana temporal a mostrar según Regularity
|
|
DateTime dateLimit;
|
|
var requireMinutes = false;
|
|
var requireSeconds = false;
|
|
|
|
switch (gf.Regularity)
|
|
{
|
|
case GroupedObservationEnum.Regularity.Minute:
|
|
dateLimit = new DateTime(
|
|
DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day,
|
|
DateTime.Now.Hour, DateTime.Now.Minute, 0
|
|
).AddMinutes(gf.Max * -1);
|
|
requireMinutes = true;
|
|
break;
|
|
|
|
case GroupedObservationEnum.Regularity.Second:
|
|
dateLimit = new DateTime(
|
|
DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day,
|
|
DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second
|
|
).AddSeconds(gf.Max * -1);
|
|
requireMinutes = true;
|
|
requireSeconds = true;
|
|
break;
|
|
|
|
default:
|
|
dateLimit = new DateTime(
|
|
DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day,
|
|
DateTime.Now.Hour, 0, 0
|
|
).AddHours(gf.Max * -1);
|
|
break;
|
|
}
|
|
|
|
var cacheResult = orderCurrentObsList
|
|
.Where(c =>
|
|
new DateTime(
|
|
c.Time.Year, c.Time.Month, c.Time.Day, c.Time.Hour,
|
|
requireMinutes ? c.Time.Minute : 0,
|
|
requireSeconds ? c.Time.Second : 0
|
|
) >= dateLimit)
|
|
.ToList();
|
|
|
|
// Persistimos la lista incrementada en la misma clave para no romper el flujo actual.
|
|
await _cacheService.SetObjectAsync(ws.HashCode, cacheResult, false);
|
|
|
|
return new GroupedObservation
|
|
{
|
|
PatientId = ws.PatientId,
|
|
Group = gf.Group,
|
|
Name = gf.Name,
|
|
Observations = cacheResult
|
|
};
|
|
}
|
|
|
|
|
|
// Si no hay caché o hay MISS → recálculo completo (sin usar caché en esta ruta).
|
|
return await GenerateGroupedObservation(ws.PatientId, gf, ws.TimeZoneId, true);
|
|
}
|
|
|
|
|
|
// PRIVATE: High-level composition steps
|
|
public List<BsonDocument> FillHours(List<BsonDocument> result, GroupedField groupedField)
|
|
{
|
|
var now = DateTime.UtcNow;
|
|
//var resultNumber = groupedField.Max;
|
|
var names = groupedField.Names.Count > 1 ? groupedField.Names : [groupedField.Name ?? string.Empty];
|
|
|
|
if (result.Count >= groupedField.Max * names.Count)
|
|
return result; //We have data from each hour/day/minute, dont need to calc.
|
|
List<BsonDocument> fillResult = [];
|
|
//var first = result.FirstOrDefault();
|
|
foreach (var name in names)
|
|
{
|
|
var filteredDocuments = result.Where(doc => doc["_id"]["name"] == name).ToList();
|
|
if (filteredDocuments.Count >= groupedField.Max)
|
|
{
|
|
filteredDocuments = filteredDocuments.OrderBy(e => e.Get("time")?.ToLocalTime()).ToList();
|
|
fillResult.AddRange(filteredDocuments);
|
|
continue;
|
|
}
|
|
|
|
var expectedDate = DateTime.MinValue;
|
|
var inverseCounter = 0;
|
|
for (var i = groupedField.Max; i != 0; i--)
|
|
{
|
|
var expectedMatch = true;
|
|
|
|
var value = filteredDocuments.ElementAtOrDefault(inverseCounter);
|
|
|
|
DateTime? time = null;
|
|
|
|
if (value == null)
|
|
expectedMatch = false;
|
|
else
|
|
//Estamos recogiendo la hora en UTC
|
|
time = value.Get("time")?.ToUniversalTime();
|
|
|
|
|
|
switch (groupedField.Regularity)
|
|
{
|
|
case GroupedObservationEnum.Regularity.Day:
|
|
expectedDate = now.AddDays(-i);
|
|
if (!time.HasValue || expectedDate.Day != time.Value.Day) expectedMatch = false;
|
|
break;
|
|
case GroupedObservationEnum.Regularity.Hour:
|
|
case GroupedObservationEnum.Regularity.Shift:
|
|
expectedDate = now.AddHours(-i);
|
|
if (!time.HasValue || expectedDate.Hour != time.Value.Hour) expectedMatch = false;
|
|
break;
|
|
case GroupedObservationEnum.Regularity.Minute:
|
|
expectedDate = now.AddMinutes(-i);
|
|
if (!time.HasValue || expectedDate.Minute != time.Value.Minute) expectedMatch = false;
|
|
break;
|
|
case GroupedObservationEnum.Regularity.Second:
|
|
expectedDate = now.AddSeconds(-i);
|
|
if (!time.HasValue || expectedDate.Second != time.Value.Second) expectedMatch = false;
|
|
break;
|
|
}
|
|
|
|
|
|
if (!expectedMatch)
|
|
{
|
|
var newEntry = new BsonDocument
|
|
{
|
|
{
|
|
"_id", new BsonDocument
|
|
{
|
|
{ "year", expectedDate.Year },
|
|
{ "month", expectedDate.Month },
|
|
{ "day", expectedDate.Day },
|
|
{ "hour", expectedDate.Hour },
|
|
{ "minute", expectedDate.Minute },
|
|
{ "name", groupedField.Name }
|
|
}
|
|
},
|
|
{ "time", new BsonDateTime(expectedDate) }, //TODO loop del result entero
|
|
//{ Result.HalfHour.ToString().ToLower(), new BsonDocument { { "value", 0 }, { "min",0 }, { "max",0 }, { "time", new BsonDateTime(expectedDate) } } }
|
|
// { groupedField.regularity.ToString().ToLower(), new BsonDocument { { "value", 0 }, { "min",0 }, { "max",0 }, { "time", new BsonDateTime(expectedDate) } } }
|
|
{ "isFilled", true } //Marcamos como hora añadida
|
|
};
|
|
|
|
foreach (var r in groupedField.Result)
|
|
switch (r)
|
|
{
|
|
case GroupedObservationEnum.Result.LastFilled:
|
|
case GroupedObservationEnum.Result.LastAll:
|
|
continue;
|
|
case GroupedObservationEnum.Result.Sum:
|
|
case GroupedObservationEnum.Result.Average:
|
|
case GroupedObservationEnum.Result.Count:
|
|
newEntry.Add(new BsonElement(r.ToString().ToLower(), 0));
|
|
continue;
|
|
case GroupedObservationEnum.Result.HalfHour:
|
|
newEntry.Add("all",
|
|
new BsonArray
|
|
{
|
|
new BsonDocument
|
|
{
|
|
{ "value", 0 }, { "min", 0 }, { "max", 0 },
|
|
{ "time", new BsonDateTime(expectedDate) }
|
|
}
|
|
});
|
|
continue;
|
|
default:
|
|
newEntry.Add(r.ToString().ToLower(),
|
|
new BsonDocument
|
|
{
|
|
{ "value", 0 }, { "min", 0 }, { "max", 0 },
|
|
{ "time", new BsonDateTime(expectedDate) }
|
|
});
|
|
continue;
|
|
}
|
|
|
|
if (groupedField.Result.Count != 1 ||
|
|
!groupedField.Result.Contains(GroupedObservationEnum.Result.LastFilled))
|
|
filteredDocuments.Add(newEntry);
|
|
|
|
filteredDocuments = filteredDocuments.OrderBy(e => e.Get("time")?.ToLocalTime()).ToList();
|
|
}
|
|
|
|
inverseCounter++;
|
|
}
|
|
|
|
if (groupedField.Max <= filteredDocuments.Count)
|
|
{
|
|
var value = filteredDocuments.ElementAtOrDefault(inverseCounter);
|
|
|
|
if (value == null)
|
|
{
|
|
var newEntry = new BsonDocument
|
|
{
|
|
{
|
|
"_id", new BsonDocument
|
|
{
|
|
{ "year", DateTime.UtcNow.Year },
|
|
{ "month", DateTime.UtcNow.Month },
|
|
{ "day", DateTime.UtcNow.Day },
|
|
{ "hour", DateTime.UtcNow.Hour },
|
|
{ "minute", DateTime.UtcNow.Minute },
|
|
{ "name", groupedField.Name }
|
|
}
|
|
},
|
|
{ "time", new BsonDateTime(DateTime.UtcNow) }, //TODO loop del result entero
|
|
{ "isFilled", true } //Marcamos como hora añadida
|
|
};
|
|
|
|
foreach (var r in groupedField.Result)
|
|
switch (r)
|
|
{
|
|
case GroupedObservationEnum.Result.LastFilled:
|
|
case GroupedObservationEnum.Result.LastAll:
|
|
continue;
|
|
case GroupedObservationEnum.Result.Sum:
|
|
case GroupedObservationEnum.Result.Average:
|
|
case GroupedObservationEnum.Result.Count:
|
|
newEntry.Add(new BsonElement(r.ToString().ToLower(), 0));
|
|
continue;
|
|
case GroupedObservationEnum.Result.HalfHour:
|
|
newEntry.Add("all",
|
|
new BsonArray
|
|
{
|
|
new BsonDocument
|
|
{
|
|
{ "value", 0 }, { "min", 0 }, { "max", 0 },
|
|
{ "time", new BsonDateTime(expectedDate) }
|
|
}
|
|
});
|
|
continue;
|
|
default:
|
|
newEntry.Add(r.ToString().ToLower(),
|
|
new BsonDocument
|
|
{
|
|
{ "value", 0 }, { "min", 0 }, { "max", 0 },
|
|
{ "time", new BsonDateTime(expectedDate) }
|
|
});
|
|
continue;
|
|
}
|
|
|
|
if (groupedField.Result.Count != 1 ||
|
|
!groupedField.Result.Contains(GroupedObservationEnum.Result.LastFilled))
|
|
filteredDocuments.Add(newEntry);
|
|
|
|
filteredDocuments = filteredDocuments.OrderBy(e => e.Get("time")?.ToLocalTime()).ToList();
|
|
}
|
|
|
|
fillResult.AddRange(filteredDocuments);
|
|
}
|
|
}
|
|
|
|
fillResult = fillResult.OrderBy(e => e.Get("time")?.ToLocalTime()).ToList();
|
|
|
|
return fillResult;
|
|
}
|
|
|
|
public async Task<List<BsonDocument>> CalculateLastFilledObservations(List<BsonDocument> result,
|
|
GroupedField groupedField, ObjectId patientId)
|
|
{
|
|
List<BsonDocument> resultToReturn = [];
|
|
if (groupedField.Names.Any())
|
|
foreach (var name in groupedField.Names)
|
|
{
|
|
var resultFiltedByName = result.FindAll(b => b.Get("_id")?.AsBsonDocument.Get("name") == name);
|
|
var resultCalculated = await LastFilledCalc(resultFiltedByName, groupedField, patientId, name);
|
|
resultToReturn.AddRange(resultCalculated);
|
|
}
|
|
else
|
|
return await LastFilledCalc(result, groupedField, patientId, groupedField.Name);
|
|
|
|
|
|
return resultToReturn;
|
|
}
|
|
|
|
private async Task<List<BsonDocument>> LastFilledCalc(List<BsonDocument> result, GroupedField groupedField,
|
|
ObjectId patientId, string? name)
|
|
{
|
|
var now = DateTime.UtcNow;
|
|
|
|
if (result.Count == groupedField.Max)
|
|
return result; //We have data from each hour/day/minute, dont need to calc.
|
|
|
|
var first = result.FirstOrDefault();
|
|
|
|
|
|
object? lastObservationValue = null;
|
|
|
|
var expectedFirstDate = groupedField.Regularity switch
|
|
{
|
|
GroupedObservationEnum.Regularity.Day => now.AddDays(-groupedField.Max),
|
|
GroupedObservationEnum.Regularity.Hour => now.AddHours(-groupedField.Max),
|
|
GroupedObservationEnum.Regularity.Minute => now.AddMinutes(-groupedField.Max),
|
|
GroupedObservationEnum.Regularity.Second => now.AddSeconds(-groupedField.Max),
|
|
_ => DateTime.MinValue
|
|
};
|
|
|
|
//first > fecha minima tenemos que buscar el ultimo valor
|
|
if (first == null || first.Get("time")?.ToUniversalTime().CompareTo(expectedFirstDate) > 0)
|
|
{
|
|
var lastObservation =
|
|
await _observationRepository.FindLastObservationBeforeDate(patientId, groupedField.Name,
|
|
expectedFirstDate);
|
|
|
|
if (lastObservation != null) lastObservationValue = lastObservation.Value;
|
|
}
|
|
|
|
var expectedDate = DateTime.MinValue;
|
|
var inverseCounter = 0;
|
|
for (var i = groupedField.Max; i != 0; i--)
|
|
{
|
|
var expectedMatch = true;
|
|
|
|
var value = result.ElementAtOrDefault(inverseCounter);
|
|
|
|
DateTime? time = null;
|
|
|
|
if (value == null)
|
|
expectedMatch = false;
|
|
else
|
|
time = value.Get("time")?.ToUniversalTime();
|
|
|
|
|
|
switch (groupedField.Regularity)
|
|
{
|
|
case GroupedObservationEnum.Regularity.Day:
|
|
expectedDate = now.AddDays(-i);
|
|
if (!time.HasValue || expectedDate.Day != time.Value.Day) expectedMatch = false;
|
|
break;
|
|
case GroupedObservationEnum.Regularity.Hour:
|
|
expectedDate = now.AddHours(-i);
|
|
if (!time.HasValue || expectedDate.Hour != time.Value.Hour) expectedMatch = false;
|
|
break;
|
|
case GroupedObservationEnum.Regularity.Minute:
|
|
expectedDate = now.AddMinutes(-i);
|
|
if (!time.HasValue || expectedDate.Minute != time.Value.Minute) expectedMatch = false;
|
|
break;
|
|
case GroupedObservationEnum.Regularity.Second:
|
|
expectedDate = now.AddSeconds(-i);
|
|
if (!time.HasValue || expectedDate.Second != time.Value.Second) expectedMatch = false;
|
|
break;
|
|
}
|
|
|
|
|
|
if (!expectedMatch)
|
|
{
|
|
var lastResult = result.ElementAtOrDefault(inverseCounter - 1);
|
|
object? lastFilledValue;
|
|
if (lastResult == null)
|
|
{
|
|
lastFilledValue = lastObservationValue;
|
|
}
|
|
else
|
|
{
|
|
var lastfilled = GroupedObservationEnum.Result.LastFilled.ToString().ToLower();
|
|
lastFilledValue = lastResult.Get(lastfilled)?.AsBsonDocument.Get("value");
|
|
}
|
|
|
|
lastFilledValue ??= 0;
|
|
|
|
var newEntry = new BsonDocument
|
|
{
|
|
{
|
|
"_id", new BsonDocument
|
|
{
|
|
{ "year", expectedDate.Year },
|
|
{ "month", expectedDate.Month },
|
|
{ "day", expectedDate.Day },
|
|
{ "hour", expectedDate.Hour },
|
|
{ "minute", expectedDate.Minute },
|
|
{ "name", name }
|
|
}
|
|
},
|
|
{ "time", new BsonDateTime(expectedDate) },
|
|
{
|
|
GroupedObservationEnum.Result.LastFilled.ToString().ToLower(),
|
|
new BsonDocument
|
|
{
|
|
{ "value", lastFilledValue.ToString() }, { "min", 0 }, { "max", 0 },
|
|
{ "time", new BsonDateTime(expectedDate) }
|
|
}
|
|
}
|
|
};
|
|
result.Add(newEntry);
|
|
result = result.OrderBy(e => e.Get("time")?.ToLocalTime()).ToList();
|
|
}
|
|
|
|
inverseCounter++;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<BsonDocument> CalculateShiftObservations(List<BsonDocument> shiftGroupObservations,
|
|
GroupedField groupedField)
|
|
{
|
|
var shiftGrouped = new List<BsonDocument>();
|
|
|
|
if (groupedField.Result.Contains(GroupedObservationEnum.Result.Sum))
|
|
{
|
|
var shiftGroups =
|
|
shiftGroupObservations.GroupBy(shift => new
|
|
{ V1 = shift.GetElement("shift").ToString(), V = shift.GetElement("day").ToString() })
|
|
.Select(s => s.ToList())
|
|
.ToList();
|
|
|
|
|
|
shiftGroups.ForEach(shiftGroup =>
|
|
{
|
|
var shiftSum = shiftGroup.Select(shift => shift.Get("sum")?.ToInt32()).Sum();
|
|
var shiftToAdd = shiftGroup.FirstOrDefault();
|
|
|
|
shiftToAdd?.SetElement(new BsonElement("sum", shiftSum));
|
|
if (shiftGroup.Select(shift => shift.Get("isFilled")).Any(s => s == false))
|
|
shiftToAdd?.SetElement(new BsonElement("isFilled", false));
|
|
|
|
if (shiftToAdd != null)
|
|
shiftGrouped.Add(shiftToAdd);
|
|
});
|
|
|
|
|
|
return shiftGrouped;
|
|
}
|
|
|
|
return shiftGroupObservations;
|
|
}
|
|
|
|
//MIGUEL: EJEMPLO SI LAS 12 TIENEN 4 VALORES 12:15 => 5, 12:20 => 10, 12:45 => 20 Y LAS 13 NO TIENE VALOR. 12 DEBERÍA 5 Y 13 DEBERÍA SER
|
|
// ACTUALMENTE A LAS 12 MOSTRARIA EL ULTIMO DE LA MEDIA HORA Y A LAS 13?
|
|
public List<BsonDocument> CalculateHalfHourObservations(List<BsonDocument> result)
|
|
{
|
|
//HalfHour añadir que se rellenen las horas que no existen
|
|
for (var i = 0; i < result.Count; i++)
|
|
{
|
|
var document = result[i];
|
|
BsonDocument? nextDocument = null;
|
|
|
|
if (i + 1 < result.Count)
|
|
nextDocument = result[i + 1];
|
|
|
|
document.TryGetValue("all", out var docvalues);
|
|
|
|
|
|
List<BsonValue?> groups = [];
|
|
|
|
if (docvalues != null)
|
|
groups = docvalues.AsBsonArray.ToList().GroupBy(x =>
|
|
{
|
|
var stamp = x.AsBsonDocument.Get("time")?.ToLocalTime();
|
|
if (!stamp.HasValue) return null;
|
|
stamp = stamp.Value.AddMinutes(-(stamp.Value.Minute % 30));
|
|
stamp = stamp.Value.AddMilliseconds(-stamp.Value.Millisecond - 1000 * stamp.Value.Second);
|
|
return stamp;
|
|
}).Select(g =>
|
|
g.OrderByDescending(c => c.AsBsonDocument.Get("time")?.ToLocalTime()).FirstOrDefault())
|
|
.ToList();
|
|
|
|
|
|
if (groups.Count > 0)
|
|
{
|
|
if (nextDocument == null)
|
|
{
|
|
document.Set("halfhour", groups.Last());
|
|
break;
|
|
}
|
|
|
|
if (groups.Count > 1)
|
|
{
|
|
var nextDocumentValues = nextDocument.Get("all")?.AsBsonArray.ToList();
|
|
|
|
if (nextDocumentValues == null || nextDocumentValues.Count == 0
|
|
|| (nextDocumentValues.Count == 1 &&
|
|
nextDocument.Get("all")?.AsBsonArray.ToList()[0].AsBsonDocument
|
|
.Get("value")?.ToString() ==
|
|
"0")) //El siguiente registro no tiene tomas
|
|
{
|
|
nextDocument.Set("halfhour", groups.LastOrDefault());
|
|
document.Set("halfhour", groups.FirstOrDefault());
|
|
}
|
|
else
|
|
{
|
|
document.Set("halfhour", groups.LastOrDefault());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (document.Get("halfhour")?.AsBsonDocument == null)
|
|
document.Set("halfhour", groups.LastOrDefault());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!document.TryGetValue("halfhour", out _)) document.Set("halfhour", new BsonDocument());
|
|
}
|
|
}
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<BsonDocument> GenerateShiftObservations(List<BsonDocument> result, GroupedField groupedField)
|
|
{
|
|
result.ForEach(item =>
|
|
{
|
|
DateTime? obsDateTime = null;
|
|
var id = item.Get("_id")?.AsBsonDocument;
|
|
if (id == null)
|
|
return;
|
|
|
|
|
|
var timeStr = id.Get("hour")?.ToString()?.PadLeft(2, '0') ?? "00";
|
|
if (id.TryGetValue("minute", out _))
|
|
{
|
|
timeStr += ":" + id.Get("minute")?.ToString()?.PadLeft(2, '0');
|
|
if (DateTime.TryParseExact(timeStr, "HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None,
|
|
out var r1))
|
|
obsDateTime = r1;
|
|
}
|
|
else
|
|
{
|
|
if (DateTime.TryParseExact(timeStr, "HH", CultureInfo.InvariantCulture, DateTimeStyles.None,
|
|
out var r2))
|
|
obsDateTime = r2;
|
|
}
|
|
|
|
|
|
obsDateTime = obsDateTime?.ToLocalTime();
|
|
int shift;
|
|
int day;
|
|
//Return all dates in shift array before obsDateTime, and take last, that will be the closest shift date.
|
|
var expectedHour = obsDateTime?.Hour.ToString().Length < 2
|
|
? $"0{obsDateTime.Value.Hour}"
|
|
: obsDateTime?.Hour.ToString();
|
|
|
|
var expectedMinutes = obsDateTime?.Minute.ToString().Length < 2
|
|
? $"0{obsDateTime.Value.Minute}"
|
|
: obsDateTime?.Minute.ToString();
|
|
|
|
|
|
var shiftSelected = groupedField.StartTimeShift.LastOrDefault
|
|
(i => DateTime.ParseExact(i, "HH:mm", CultureInfo.InvariantCulture).Ticks <= DateTime
|
|
.ParseExact($"{expectedHour}:{expectedMinutes}", "HH:mm", CultureInfo.InvariantCulture)
|
|
.Ticks);
|
|
|
|
var havemin = id.TryGetValue("minute", out var minuteV);
|
|
var year = id.Get("year")?.ToInt32();
|
|
var month = id.Get("month")?.ToInt32();
|
|
var dayy = id.Get("day")?.ToInt32();
|
|
var hour = id.Get("hour")?.ToInt32();
|
|
|
|
if (!year.HasValue || !month.HasValue || !dayy.HasValue || !hour.HasValue)
|
|
{
|
|
_logger.LogError("Error getting dateTime from Bson: {id}", id);
|
|
return;
|
|
}
|
|
|
|
var dateUtc = new DateTime(year.Value, month.Value, dayy.Value, hour.Value, havemin ? minuteV.ToInt32() : 0,
|
|
0);
|
|
|
|
if (!groupedField.StartTimeShift.Any())
|
|
{
|
|
_logger.LogError(
|
|
"Error generating shift observations. StartTimeShift List in null or empty. {groupedField}",
|
|
groupedField);
|
|
return;
|
|
}
|
|
|
|
if (shiftSelected == null)
|
|
{
|
|
day = dateUtc.ToLocalTime().AddDays(-1).Day;
|
|
shift = groupedField.StartTimeShift.Count - 1;
|
|
}
|
|
else
|
|
{
|
|
day = dateUtc.ToLocalTime().Day;
|
|
shift = groupedField.StartTimeShift.IndexOf(shiftSelected);
|
|
}
|
|
|
|
item.Add(new BsonElement("day", day));
|
|
item.Add(new BsonElement("shift", shift));
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
// PRIVATE: Incremental item adjustment
|
|
private List<GroupedObservationObs> LocateCurrentObsInGroup(List<GroupedObservationObs> group,
|
|
PatientObservation obs, GroupedField groupedField)
|
|
{
|
|
// Check if we need to modify the current value or add new one
|
|
var specifyMinutes =
|
|
groupedField.Regularity is GroupedObservationEnum.Regularity.Minute
|
|
or GroupedObservationEnum.Regularity.Second;
|
|
var specifySeconds = groupedField.Regularity == GroupedObservationEnum.Regularity.Second;
|
|
var obsTime = new DateTime(obs.Time.Year, obs.Time.Month, obs.Time.Day, obs.Time.Hour,
|
|
specifyMinutes ? obs.Time.Minute : 0,
|
|
specifySeconds ? obs.Time.Second : 0);
|
|
var obsIndexInThisHour = group.FindIndex(c =>
|
|
new DateTime(c.Time.Year, c.Time.Month, c.Time.Day, c.Time.Hour,
|
|
specifyMinutes ? c.Time.Minute : 0,
|
|
specifySeconds ? c.Time.Second : 0) == obsTime && c.Name == obs.Name);
|
|
if (obsIndexInThisHour >= 0)
|
|
{
|
|
// Obs to modify found
|
|
var valueIsParsed = double.TryParse(obs.Value.ToString(), out var valueParsed);
|
|
if (!valueIsParsed)
|
|
return group;
|
|
group[obsIndexInThisHour].IsFilled = false;
|
|
group[obsIndexInThisHour].Time = obsTime;
|
|
foreach (var result in groupedField.Result)
|
|
switch (result)
|
|
{
|
|
case GroupedObservationEnum.Result.Max:
|
|
var valueMaxIsParsed = double.TryParse(group[obsIndexInThisHour].Max?.Value.ToString(),
|
|
out var valueMaxParsed);
|
|
if (!valueMaxIsParsed) continue;
|
|
//actual value is higher, is relevant
|
|
if (group[obsIndexInThisHour].Max?.Value != null && valueParsed > valueMaxParsed)
|
|
{
|
|
group[obsIndexInThisHour].Max!.Value = obs.Value;
|
|
group[obsIndexInThisHour].Max!.Time = obs.Time;
|
|
group[obsIndexInThisHour].Max!.Type = obs.Status;
|
|
group[obsIndexInThisHour].Max!.Type = obs.Status;
|
|
}
|
|
|
|
break;
|
|
case GroupedObservationEnum.Result.Min:
|
|
var valueMinIsParsed = double.TryParse(group[obsIndexInThisHour].Max?.Value.ToString(),
|
|
out var valueMinParsed);
|
|
if (!valueMinIsParsed) continue;
|
|
if (group[obsIndexInThisHour].Max?.Value != null && valueParsed < valueMinParsed)
|
|
{
|
|
group[obsIndexInThisHour].Min!.Value = obs.Value;
|
|
group[obsIndexInThisHour].Min!.Time = obs.Time;
|
|
group[obsIndexInThisHour].Min!.Type = obs.Status;
|
|
}
|
|
|
|
break;
|
|
case GroupedObservationEnum.Result.Last:
|
|
if (group[obsIndexInThisHour].Last?.Time < obs.Time)
|
|
{
|
|
group[obsIndexInThisHour].Last!.Value = obs.Value;
|
|
group[obsIndexInThisHour].Last!.Time = obs.Time;
|
|
group[obsIndexInThisHour].Last!.Type = obs.Status;
|
|
}
|
|
|
|
break;
|
|
case GroupedObservationEnum.Result.LastFilled:
|
|
if (group[obsIndexInThisHour].LastFilled?.Time < obs.Time)
|
|
{
|
|
group[obsIndexInThisHour].LastFilled!.Value = obs.Value;
|
|
group[obsIndexInThisHour].LastFilled!.Time = obs.Time;
|
|
group[obsIndexInThisHour].LastFilled!.Type = obs.Status;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Delete obs autofilled and in time of the new obs
|
|
var obsIndexInThisHourToRemove = group.FindIndex(c =>
|
|
new DateTime(c.Time.Year, c.Time.Month, c.Time.Day, c.Time.Hour,
|
|
specifyMinutes ? c.Time.Minute : 0,
|
|
specifySeconds ? c.Time.Second : 0) == obsTime && c.IsFilled);
|
|
if (obsIndexInThisHourToRemove >= 0)
|
|
group.RemoveAt(obsIndexInThisHourToRemove);
|
|
// Obs to modify not found add it
|
|
var ngo = new GroupedObservationObs
|
|
{
|
|
Name = obs.Name ?? string.Empty,
|
|
MinAlert = obs.Min,
|
|
MaxAlert = obs.Max,
|
|
Time = obsTime,
|
|
IsFilled = false,
|
|
ShiftDate = obs.Time,
|
|
Shift = GetShift(obs.Time, groupedField.StartTimeShift)
|
|
};
|
|
|
|
foreach (var result in groupedField.Result)
|
|
switch (result)
|
|
{
|
|
case GroupedObservationEnum.Result.Max:
|
|
ngo.Max = new GroupedObservationObsValue(obs.Value, obs.Time, obs.Status);
|
|
break;
|
|
case GroupedObservationEnum.Result.Min:
|
|
ngo.Min = new GroupedObservationObsValue(obs.Value, obs.Time, obs.Status);
|
|
break;
|
|
case GroupedObservationEnum.Result.Last:
|
|
ngo.Last = new GroupedObservationObsValue(obs.Value, obs.Time, obs.Status);
|
|
break;
|
|
case GroupedObservationEnum.Result.LastFilled:
|
|
ngo.LastFilled = new GroupedObservationObsValue(obs.Value, obs.Time, obs.Status);
|
|
break;
|
|
}
|
|
|
|
group.Add(ngo);
|
|
}
|
|
|
|
// Check if we have more obs than we require to show
|
|
DateTime dateLimit;
|
|
switch (groupedField.Regularity)
|
|
{
|
|
case GroupedObservationEnum.Regularity.Minute:
|
|
dateLimit = new DateTime(obs.Time.Year, obs.Time.Month, obs.Time.Day, obs.Time.Hour, obs.Time.Minute, 0)
|
|
.AddMinutes(groupedField.Max * -1);
|
|
break;
|
|
case GroupedObservationEnum.Regularity.Second:
|
|
dateLimit = new DateTime(obs.Time.Year, obs.Time.Month, obs.Time.Day, obs.Time.Hour, obs.Time.Minute,
|
|
obs.Time.Second).AddSeconds(groupedField.Max * -1);
|
|
break;
|
|
default:
|
|
dateLimit =
|
|
new DateTime(obs.Time.Year, obs.Time.Month, obs.Time.Day, obs.Time.Hour, 0, 0).AddHours(
|
|
groupedField.Max * -1);
|
|
break;
|
|
}
|
|
|
|
return group.Where(c =>
|
|
new DateTime(c.Time.Year, c.Time.Month, c.Time.Day, c.Time.Hour, specifyMinutes ? c.Time.Minute : 0,
|
|
specifySeconds ? c.Time.Second : 0) >= dateLimit).ToList();
|
|
}
|
|
|
|
|
|
|
|
// PRIVATE: Low-level utilities
|
|
private int? GetShift(DateTime currentObsDate, List<string> groupedFieldStartTimeShift)
|
|
{
|
|
if (groupedFieldStartTimeShift.Count == 0) return null;
|
|
var listTime = GetTimeSpan(groupedFieldStartTimeShift);
|
|
var dateTimeSpan = currentObsDate.TimeOfDay;
|
|
|
|
for (var i = 0; i < listTime.Count; i++)
|
|
{
|
|
var nextIndex = (i + 1) % listTime.Count;
|
|
var nextTimeSpan = listTime[nextIndex];
|
|
var currentTimeSpan = listTime[i];
|
|
|
|
if (dateTimeSpan >= currentTimeSpan && dateTimeSpan < nextTimeSpan) return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private List<TimeSpan> GetTimeSpan(List<string> groupedFieldStartTimeShift)
|
|
{
|
|
List<TimeSpan> timeSpans = [];
|
|
timeSpans.AddRange(groupedFieldStartTimeShift.Select(TimeSpan.Parse));
|
|
|
|
List<TimeSpan> newTimeSpans = [];
|
|
|
|
for (var i = 0; i < timeSpans.Count; i++)
|
|
{
|
|
var nextIndex = (i + 1) % timeSpans.Count;
|
|
var nextTimeSpan = timeSpans[nextIndex];
|
|
var currentTimeSpan = timeSpans[i];
|
|
var addedTimeSpan = currentTimeSpan.Add(TimeSpan.FromMinutes(1));
|
|
|
|
newTimeSpans.Add(addedTimeSpan < nextTimeSpan ? addedTimeSpan : nextTimeSpan);
|
|
}
|
|
|
|
return newTimeSpans;
|
|
}
|
|
|
|
private async Task<StatusEnum.Type> GroupedObservationStatus(GroupedField groupedField,
|
|
GroupedObservationEnum.Result result, string name, object value, double? min, double? max)
|
|
{
|
|
return await _configObservationService.GroupedObservationStatus(groupedField, result, name, value, min, max);
|
|
}
|
|
|
|
private (int timesLeft, int multiplierFactor) TimesLeftToCreateEmptyObs(GroupedObservationObs obs, GroupedField gf)
|
|
{
|
|
var currentDateTime = DateTime.Now;
|
|
var timeElapsed = currentDateTime - obs.Time;
|
|
double timeToCurrent;
|
|
var multipliesFactor = 1;
|
|
// Calcula el tiempo transcurrido en la unidad deseada
|
|
switch (gf.Regularity)
|
|
{
|
|
case GroupedObservationEnum.Regularity.Second:
|
|
timeToCurrent = timeElapsed.TotalSeconds;
|
|
break;
|
|
|
|
case GroupedObservationEnum.Regularity.Minute:
|
|
timeToCurrent = timeElapsed.TotalMinutes;
|
|
multipliesFactor = 60;
|
|
break;
|
|
|
|
case GroupedObservationEnum.Regularity.Day:
|
|
timeToCurrent = timeElapsed.TotalDays;
|
|
multipliesFactor = 86400;
|
|
break;
|
|
|
|
default:
|
|
timeToCurrent = timeElapsed.TotalHours;
|
|
multipliesFactor = 3600;
|
|
break;
|
|
}
|
|
|
|
var timesLeft = (int)Math.Ceiling(timeToCurrent);
|
|
return (timesLeft, multipliesFactor);
|
|
}
|
|
|
|
private GroupedObservationObs CreateNextObs(GroupedObservationObs sourceObs, GroupedField gf, int seconsToAdd)
|
|
{
|
|
var lastObs = new GroupedObservationObs
|
|
{
|
|
Time = sourceObs.Time.AddSeconds(seconsToAdd),
|
|
Name = sourceObs.Name,
|
|
IsFilled = true
|
|
};
|
|
//Log.Debug("Result list:", string.Join(',', Result));
|
|
//Se rellena el tiempo con la hora de la obs anterior por que no hay dato de la actual
|
|
GroupedObservationObsValue defaultValue = new(0, sourceObs.Time);
|
|
foreach (var r in gf.Result)
|
|
{
|
|
//Log.Debug("Processing {r}", r.ToString());
|
|
//var props = typeof(GroupedObservationObs).GetProperties();
|
|
//Log.Debug("GroupedObservationObs Poperties list: {list}", string.Join(',', props.ToList()));
|
|
|
|
var propInfo = typeof(GroupedObservationObs).GetProperty(r.ToString());
|
|
if (propInfo == null)
|
|
{
|
|
_logger.LogError("Error Creating Next Obs. Getting property: {R} not found. SourceObs:{Obs}",
|
|
r.ToString(), sourceObs);
|
|
continue;
|
|
}
|
|
|
|
propInfo.SetValue(lastObs, defaultValue);
|
|
|
|
var gObsValue = propInfo.GetValue(sourceObs);
|
|
if (gObsValue == null)
|
|
{
|
|
_logger.LogWarning("Error Creating Next Obs.Getting property value: {R} not found. SourceObs:{Obs}",
|
|
r.ToString(), sourceObs);
|
|
continue;
|
|
}
|
|
|
|
var prevValue = (GroupedObservationObsValue)gObsValue;
|
|
|
|
prevValue.Time = sourceObs.Time;
|
|
|
|
propInfo.SetValue(sourceObs, prevValue);
|
|
}
|
|
|
|
if (gf.Regularity == GroupedObservationEnum.Regularity.Shift)
|
|
{
|
|
lastObs.ShiftDate = lastObs.Time;
|
|
lastObs.Shift = GetShift(lastObs.ShiftDate, gf.StartTimeShift);
|
|
}
|
|
|
|
return lastObs;
|
|
}
|
|
} |