jrojas
1006 lines
41 KiB
C#
1006 lines
41 KiB
C#
using System.Reflection;
|
|
using System.Text;
|
|
using adas_core.Application.Providers;
|
|
using adas_core.Application.Services.Interfaces;
|
|
using adas_core.Domain.Models;
|
|
using adas_core.Domain.Models.AppSettings;
|
|
using adas_core.Domain.Models.Providers;
|
|
using adas_core.Domain.Utils;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Extensions.Options;
|
|
using Quartz;
|
|
using Quartz.Impl;
|
|
using Serilog;
|
|
using ILogger = Serilog.ILogger;
|
|
using Options = Microsoft.Extensions.Options.Options;
|
|
|
|
namespace adas_core.Application.Services;
|
|
|
|
public class SchedulerService
|
|
{
|
|
private readonly bool _activateCheckExpiredAlerts;
|
|
private readonly bool _activateCheckExpiredObservations;
|
|
private readonly bool _activateCheckInactivePatients;
|
|
private readonly bool _activateSchedulerCheckActiveTreatmentsJob;
|
|
private readonly bool _activateSchedulerCheckActiveAppointmentsJob;
|
|
private readonly bool _activateSchedulerCheckHydricBalance;
|
|
private readonly bool _activateSchedulerCheckNewsJob;
|
|
private readonly bool _activateSchedulerCheckOpiateBoluses;
|
|
private readonly bool _activateSchedulerGetProvidersObservations;
|
|
|
|
private readonly ArchiveNurseData _archiveNurseData;
|
|
private readonly int _archivePatientsWithoutObservationsSinceHours;
|
|
private readonly Lazy<ICalculatedObservationsService> _calculatedObservationsService;
|
|
private readonly int _checkActiveTreatmentsSchedulerIntervalMinutes;
|
|
private readonly int _checkActiveAppointmentsSchedulerIntervalMinutes;
|
|
private readonly int _checkExpiredAlertsIntervalSeconds;
|
|
private readonly int _checkExpiredObservationsIntervalMinutes;
|
|
private readonly int _checkInactivePatientSchedulerIntervalHours;
|
|
|
|
private readonly int _checkNewsJobIntervalMinutes;
|
|
private readonly Lazy<IConfigObservationService> _configObservationService;
|
|
|
|
private readonly int _getProviderObservationsIntervalMinutes;
|
|
private readonly IHttpClientFactory _httpClientFactory;
|
|
private readonly ILogger<SchedulerService> _logger;
|
|
private readonly Lazy<IMedicineService> _medicineService;
|
|
private readonly Lazy<IObservationService> _observationService;
|
|
private readonly Lazy<IPatientCarePlanService> _patientProcedureService;
|
|
private readonly Lazy<IPatientService> _patientService;
|
|
private readonly IOptions<List<ProvidersSettings>> _providersSettings;
|
|
private readonly int _sinceDischargeTimeToArchive;
|
|
private readonly Lazy<ITreatmentService> _treatmentService;
|
|
private readonly Lazy<IAppointmentService> _appointmentService;
|
|
private readonly Lazy<IDiagnosisService> _diagnosisService;
|
|
|
|
|
|
public SchedulerService(IOptions<ApiSettings> apiSettings,
|
|
IOptions<List<ProvidersSettings>> providersSettings,
|
|
Lazy<IPatientService> patientService,
|
|
Lazy<ITreatmentService> treatmentService,
|
|
Lazy<IAppointmentService> appointmentService,
|
|
Lazy<IDiagnosisService> diagnosisService,
|
|
Lazy<IMedicineService> medicineService,
|
|
Lazy<IObservationService> observationService,
|
|
Lazy<IConfigObservationService> configObservationService,
|
|
ILogger<SchedulerService> logger,
|
|
IHttpClientFactory httpClientFactory,
|
|
Lazy<ICalculatedObservationsService> calculatedObservationsService,
|
|
Lazy<IPatientCarePlanService> patientProcedureService)
|
|
{
|
|
_patientService = patientService;
|
|
_treatmentService = treatmentService;
|
|
_appointmentService = appointmentService;
|
|
_diagnosisService = diagnosisService;
|
|
_medicineService = medicineService;
|
|
_observationService = observationService;
|
|
_configObservationService = configObservationService;
|
|
_providersSettings = providersSettings;
|
|
_httpClientFactory = httpClientFactory;
|
|
_calculatedObservationsService = calculatedObservationsService;
|
|
_patientProcedureService = patientProcedureService;
|
|
_logger = logger;
|
|
|
|
//LogExecutionContext.TrySetTraceIdentifier(Guid.NewGuid().ToString(), true);
|
|
|
|
_archivePatientsWithoutObservationsSinceHours =
|
|
apiSettings.Value.ArchivePatientsWithoutObservationsSinceHours ?? 24;
|
|
|
|
var checkInactivePatientSchedulerIntervalHours =
|
|
apiSettings.Value.CheckInactivePatientSchedulerIntervalHours;
|
|
_checkInactivePatientSchedulerIntervalHours = checkInactivePatientSchedulerIntervalHours ?? 12;
|
|
|
|
var checkActiveTreatmentsSchedulerIntervalMinutes =
|
|
apiSettings.Value.CheckActiveTreatmentsSchedulerIntervalMinutes;
|
|
_checkActiveTreatmentsSchedulerIntervalMinutes = checkActiveTreatmentsSchedulerIntervalMinutes ?? 5;
|
|
|
|
var checkActiveAppointmentsSchedulerIntervalMinutes =
|
|
apiSettings.Value.CheckActiveAppointmentsSchedulerIntervalMinutes;
|
|
_checkActiveAppointmentsSchedulerIntervalMinutes = checkActiveAppointmentsSchedulerIntervalMinutes ?? 60;
|
|
|
|
var getProvidersObservationsIntervalMinutes =
|
|
apiSettings.Value.GetProvidersObservationsSchedulerIntervalMinutes;
|
|
_getProviderObservationsIntervalMinutes = getProvidersObservationsIntervalMinutes ?? 5;
|
|
|
|
|
|
var sinceDischargeTimeToArchive = apiSettings.Value.SinceDischargeTimeToArchive;
|
|
_sinceDischargeTimeToArchive = sinceDischargeTimeToArchive ?? 48;
|
|
|
|
var activateSchedulerCheckExpiredObservations = apiSettings.Value.ActivateSchedulerCheckExpiredObservation;
|
|
_activateCheckExpiredObservations = activateSchedulerCheckExpiredObservations;
|
|
|
|
_activateCheckExpiredAlerts = apiSettings.Value.ActivateCheckExpiredAlerts;
|
|
|
|
_activateCheckInactivePatients = apiSettings.Value.ActivateCheckInactivePatients;
|
|
|
|
_activateSchedulerCheckActiveTreatmentsJob = apiSettings.Value.ActivateSchedulerCheckActiveTreatmentsJob;
|
|
|
|
_activateSchedulerCheckActiveAppointmentsJob = apiSettings.Value.ActivateSchedulerCheckActiveAppointmentsJob;
|
|
|
|
_activateSchedulerCheckOpiateBoluses = apiSettings.Value.ActivateSchedulerCheckOpiateBoluses;
|
|
|
|
_activateSchedulerCheckHydricBalance = apiSettings.Value.ActivateSchedulerCheckHydricBalance;
|
|
|
|
_activateSchedulerGetProvidersObservations = apiSettings.Value.ActivateSchedulerGetProvidersObservations;
|
|
|
|
_archiveNurseData = apiSettings.Value.ArchiveNurseData;
|
|
|
|
var schedulerCheckExpiredObservationsIntervalMinutes =
|
|
apiSettings.Value.SchedulerCheckExpiredObservationsIntervalMinutes;
|
|
_checkExpiredObservationsIntervalMinutes = schedulerCheckExpiredObservationsIntervalMinutes ?? 3;
|
|
|
|
var schedulerCheckExpiredAlertsIntervalSeconds =
|
|
apiSettings.Value.SchedulerCheckExpiredAlertsIntervalSeconds;
|
|
_checkExpiredAlertsIntervalSeconds = schedulerCheckExpiredAlertsIntervalSeconds ?? 6;
|
|
|
|
|
|
_activateSchedulerCheckNewsJob = apiSettings.Value.ActivateSchedulerCheckNewsJob;
|
|
|
|
|
|
_checkNewsJobIntervalMinutes =
|
|
apiSettings.Value.CheckNewsJobIntervalMinutes;
|
|
|
|
|
|
Task.Run(InitScheduler);
|
|
}
|
|
|
|
|
|
private async Task InitScheduler()
|
|
{
|
|
//TODO con el cambio a .net core y el repaso a la inyección de dependencias de estructure map
|
|
//probar a inyectar la dependencia así https://dev.to/bohdanstupak1/dependency-injection-for-quartz-net-in-net-core-3oh7
|
|
CheckInactivePatientsJob.PatientService = _patientService.Value;
|
|
CheckActiveTreatmentsJob.MedicineService = _medicineService.Value;
|
|
CheckActiveTreatmentsJob.PatientService = _patientService.Value;
|
|
CheckActiveTreatmentsJob.TreatmentService = _treatmentService.Value;
|
|
CheckActiveTreatmentsJob.CalculatedObservationsService = _calculatedObservationsService.Value;
|
|
|
|
CheckActiveAppointmentsJob.AppointmentService = _appointmentService.Value;
|
|
CheckActiveAppointmentsJob.DiagnosisService = _diagnosisService.Value;
|
|
CheckActiveAppointmentsJob.PatientService = _patientService.Value;
|
|
|
|
ArchiveNurseDataJob.PatientCarePlanService = _patientProcedureService.Value;
|
|
ArchiveNurseDataJob.PatientService = _patientService.Value;
|
|
ArchiveNurseDataJob.ArchiveNurseDataSettings = _archiveNurseData;
|
|
|
|
CheckOpiateBolusesJob.PatientService = _patientService.Value;
|
|
CheckOpiateBolusesJob.CalculatedObservationsService = _calculatedObservationsService.Value;
|
|
|
|
CheckHydricBalanceRyCJob.ObservationService = _observationService.Value;
|
|
CheckHydricBalanceRyCJob.PatientService = _patientService.Value;
|
|
CheckHydricBalanceRyCJob.CalculatedObservationsService = _calculatedObservationsService.Value;
|
|
|
|
CheckExpiredObservationsJob.ObservationService = _observationService.Value;
|
|
|
|
CheckExpiredAlertsJob.ObservationService = _observationService.Value;
|
|
|
|
GetProvidersObservationsJob.ObservationService = _observationService.Value;
|
|
GetProvidersObservationsJob.PatientService = _patientService.Value;
|
|
GetProvidersObservationsJob.Providers = _providersSettings.Value;
|
|
GetProvidersObservationsJob.HttpClientFactory = _httpClientFactory;
|
|
|
|
CalculateNewsJob.ObservationService = _observationService.Value;
|
|
CalculateNewsJob.ConfigObservationService = _configObservationService.Value;
|
|
CalculateNewsJob.PatientService = _patientService.Value;
|
|
CalculateNewsJob.ExpiresIn = _checkNewsJobIntervalMinutes;
|
|
|
|
var jobDataMap = new JobDataMap
|
|
{
|
|
{ "archivePatientsWithoutObservationsSinceHours", _archivePatientsWithoutObservationsSinceHours },
|
|
{ "sinceDischargeTime", _sinceDischargeTimeToArchive }
|
|
};
|
|
|
|
// Grab the Scheduler instance from the Factory
|
|
var factory = new StdSchedulerFactory();
|
|
var scheduler = await factory.GetScheduler();
|
|
// and start it off
|
|
await scheduler.Start();
|
|
|
|
var checkInactivePatientsJob = JobBuilder.Create<CheckInactivePatientsJob>()
|
|
.UsingJobData(jobDataMap)
|
|
.Build();
|
|
|
|
// Trigger the job to run now, and then repeat every 10 seconds
|
|
var checkInactivePatientsTrigger = TriggerBuilder.Create()
|
|
.StartNow()
|
|
.WithSimpleSchedule(x => x
|
|
.WithIntervalInHours(_checkInactivePatientSchedulerIntervalHours)
|
|
.RepeatForever())
|
|
.Build();
|
|
|
|
|
|
var treatmentsJob = JobBuilder.Create<CheckActiveTreatmentsJob>()
|
|
.Build();
|
|
|
|
// Trigger the job to run now, and then repeat every 10 seconds
|
|
var treatmentsTrigger = TriggerBuilder.Create()
|
|
.StartNow()
|
|
.WithSimpleSchedule(x => x
|
|
.WithIntervalInMinutes(_checkActiveTreatmentsSchedulerIntervalMinutes)
|
|
.RepeatForever())
|
|
.Build();
|
|
|
|
|
|
var appointmentsJob = JobBuilder.Create<CheckActiveAppointmentsJob>()
|
|
.Build();
|
|
var appointmentsTrigger = TriggerBuilder.Create()
|
|
.StartNow()
|
|
.WithSimpleSchedule(x => x
|
|
.WithIntervalInMinutes(_checkActiveAppointmentsSchedulerIntervalMinutes)
|
|
.RepeatForever())
|
|
.Build();
|
|
|
|
//Job only for RYC hydric balance.
|
|
//Check every hour if hydric balance of that hour exists and recalculate.
|
|
var hydricBalanceJob = JobBuilder.Create<CheckHydricBalanceRyCJob>()
|
|
.UsingJobData(jobDataMap)
|
|
.Build();
|
|
|
|
var datetimePlusOneHour = DateTime.UtcNow.AddHours(1);
|
|
|
|
var hydricBalanceTrigger = TriggerBuilder.Create()
|
|
.StartAt(new DateTime(datetimePlusOneHour.Year, datetimePlusOneHour.Month, datetimePlusOneHour.Day,
|
|
datetimePlusOneHour.Hour, 0, 0))
|
|
.WithSimpleSchedule(x => x
|
|
.WithIntervalInHours(1)
|
|
.RepeatForever())
|
|
.Build();
|
|
|
|
|
|
//Check_error_queues
|
|
var opiateBolusesJob = JobBuilder.Create<CheckOpiateBolusesJob>()
|
|
.Build();
|
|
|
|
|
|
var opiateBolusesTrigger = TriggerBuilder.Create()
|
|
.StartNow()
|
|
.WithSimpleSchedule(x => x
|
|
.WithIntervalInMinutes(5)
|
|
.RepeatForever())
|
|
.Build();
|
|
|
|
|
|
//Job to expire expired observations
|
|
//Check every minute if observations are expired and recalculate.
|
|
var checkExpiredObservationsJob = JobBuilder.Create<CheckExpiredObservationsJob>()
|
|
.Build();
|
|
|
|
|
|
var checkExpiredObservationsTrigger = TriggerBuilder.Create()
|
|
.StartNow()
|
|
.WithSimpleSchedule(x => x
|
|
.WithIntervalInMinutes(_checkExpiredObservationsIntervalMinutes)
|
|
.RepeatForever())
|
|
.Build();
|
|
|
|
|
|
//Job to expire Alert
|
|
//Check every minute if Alerts are expired and power off.
|
|
var checkExpiredAlertsJob = JobBuilder.Create<CheckExpiredAlertsJob>()
|
|
.Build();
|
|
|
|
|
|
var checkExpiredAlertsTrigger = TriggerBuilder.Create()
|
|
.StartAt(DateBuilder.FutureDate(30, IntervalUnit.Second)) // Comienza 30segundos después del inicio
|
|
.WithSimpleSchedule(x => x
|
|
//.WithIntervalInMinutes(_checkExpiredAlertsIntervalMinutes)
|
|
.WithIntervalInSeconds(_checkExpiredAlertsIntervalSeconds)
|
|
.RepeatForever())
|
|
.Build();
|
|
|
|
|
|
//Job to get Providers (ADAS) observations
|
|
//Check every minute if Alerts are expired and power off.
|
|
var getProvidersObservationsJob = JobBuilder.Create<GetProvidersObservationsJob>()
|
|
.Build();
|
|
|
|
|
|
var getProvidersObservationsTrigger = TriggerBuilder.Create()
|
|
.StartNow()
|
|
.WithSimpleSchedule(x => x
|
|
.WithIntervalInMinutes(_getProviderObservationsIntervalMinutes)
|
|
.RepeatForever())
|
|
.Build();
|
|
|
|
|
|
//Job to get Providers (ADAS) observations
|
|
//Check every minute if Alerts are expired and power off.
|
|
var calculateNewsJob = JobBuilder.Create<CalculateNewsJob>()
|
|
.Build();
|
|
|
|
|
|
var calculateNewsJobTrigger = TriggerBuilder.Create()
|
|
.StartNow()
|
|
.WithSimpleSchedule(x => x
|
|
.WithIntervalInMinutes(_checkNewsJobIntervalMinutes)
|
|
.RepeatForever())
|
|
.StartNow()
|
|
.Build();
|
|
|
|
//Job to ArchiveNurseDataConfig
|
|
//Check every 15 minute if Patients has data to archive.
|
|
var archiveNurseDataJob = JobBuilder.Create<ArchiveNurseDataJob>()
|
|
.Build();
|
|
|
|
|
|
var archiveNurseDataJobTrigger = TriggerBuilder.Create()
|
|
.StartNow()
|
|
.WithSimpleSchedule(x => x
|
|
.WithIntervalInMinutes(_archiveNurseData.IntervalMinutes)
|
|
.RepeatForever())
|
|
.StartNow()
|
|
.Build();
|
|
|
|
var jobsDictionary = new Dictionary<IJobDetail, IReadOnlyCollection<ITrigger>>();
|
|
|
|
|
|
if (_activateCheckExpiredObservations)
|
|
jobsDictionary.Add(checkExpiredObservationsJob, new List<ITrigger> { checkExpiredObservationsTrigger });
|
|
|
|
if (_activateCheckExpiredAlerts)
|
|
jobsDictionary.Add(checkExpiredAlertsJob, new List<ITrigger> { checkExpiredAlertsTrigger });
|
|
|
|
if (_activateCheckInactivePatients)
|
|
jobsDictionary.Add(checkInactivePatientsJob, new List<ITrigger> { checkInactivePatientsTrigger });
|
|
|
|
if (_activateSchedulerCheckActiveTreatmentsJob)
|
|
jobsDictionary.Add(treatmentsJob, new List<ITrigger> { treatmentsTrigger });
|
|
|
|
if (_activateSchedulerCheckOpiateBoluses)
|
|
jobsDictionary.Add(opiateBolusesJob, new List<ITrigger> { opiateBolusesTrigger });
|
|
|
|
if (_activateSchedulerCheckHydricBalance)
|
|
jobsDictionary.Add(hydricBalanceJob, new List<ITrigger> { hydricBalanceTrigger });
|
|
|
|
if (_activateSchedulerGetProvidersObservations && _providersSettings.Value.Any())
|
|
jobsDictionary.Add(getProvidersObservationsJob, new List<ITrigger> { getProvidersObservationsTrigger });
|
|
|
|
if (_activateSchedulerCheckNewsJob)
|
|
jobsDictionary.Add(calculateNewsJob, new List<ITrigger> { calculateNewsJobTrigger });
|
|
|
|
if (_archiveNurseData.Active)
|
|
jobsDictionary.Add(archiveNurseDataJob, new List<ITrigger> { archiveNurseDataJobTrigger });
|
|
|
|
_logger.LogDebug("Tell to schedule the job using our trigger. {jobsDictionary}", jobsDictionary);
|
|
// Tell to schedule the job using our trigger
|
|
await scheduler.ScheduleJobs(jobsDictionary, true);
|
|
|
|
// and last shut down the scheduler when you are ready to close your program
|
|
//await scheduler.Shutdown();
|
|
}
|
|
}
|
|
|
|
[DisallowConcurrentExecution]
|
|
public class CheckHydricBalanceRyCJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<CheckHydricBalanceRyCJob>();
|
|
public static IObservationService ObservationService { get; set; } = null!;
|
|
public static IPatientService PatientService { get; set; } = null!;
|
|
public static ICalculatedObservationsService CalculatedObservationsService { get; set; } = null!;
|
|
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
var start = DateTime.Now;
|
|
|
|
//LogExecutionContext.TrySetTraceIdentifier(Guid.NewGuid().ToString(), true);
|
|
_logger.Debug("Start check hydric balance job");
|
|
|
|
try
|
|
{
|
|
var patients = await PatientService.FindAll();
|
|
|
|
foreach (var patient in patients)
|
|
{
|
|
var lastHydricBalance = await ObservationService.FindLastBeforeDate(patient.Id,
|
|
DateTime.UtcNow.AddMinutes(50), "Hydric_Balance");
|
|
|
|
if (lastHydricBalance != null &&
|
|
DateTime.Compare(
|
|
new DateTime(DateTime.UtcNow.Year, DateTime.UtcNow.Month, DateTime.UtcNow.Day,
|
|
DateTime.UtcNow.Hour, 0, 0),
|
|
new DateTime(lastHydricBalance.Time.Year, lastHydricBalance.Time.Month,
|
|
lastHydricBalance.Time.Day, lastHydricBalance.Time.Hour, 0, 0))
|
|
== 0
|
|
)
|
|
await CalculatedObservationsService.Map(lastHydricBalance);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error("ERROR executing check hydric balance job {exMessage}", ex.Message);
|
|
}
|
|
|
|
var end = DateTime.Now;
|
|
_logger.Debug("Finished check hydric balance job in {TotalMilliseconds:F1} ms",
|
|
(end - start).TotalMilliseconds);
|
|
}
|
|
}
|
|
|
|
[DisallowConcurrentExecution]
|
|
public class CheckActiveTreatmentsJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<CheckActiveTreatmentsJob>();
|
|
public static ITreatmentService TreatmentService { get; set; } = null!;
|
|
|
|
public static IMedicineService MedicineService { get; set; } = null!;
|
|
|
|
public static IPatientService PatientService { get; set; } = null!;
|
|
|
|
public static ICalculatedObservationsService CalculatedObservationsService { get; set; } = null!;
|
|
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
var start = DateTime.Now;
|
|
|
|
//LogExecutionContext.TrySetTraceIdentifier(Guid.NewGuid().ToString(), true);
|
|
_logger.Debug("Executing check active treatments job");
|
|
|
|
|
|
try
|
|
{
|
|
var patients = await PatientService.FindAll();
|
|
|
|
foreach (var patient in patients)
|
|
{
|
|
var activeMedicines = new List<Medicine>();
|
|
//var treatments = treatmentService.GetActiveTreatmentsByPatient(patient.id);
|
|
|
|
var treatments =
|
|
await CalculatedObservationsService.GetActiveTreatmentsByPatient(patient.Id);
|
|
|
|
|
|
var medicines = await MedicineService.GetMedicinesOfTreatments(treatments);
|
|
|
|
var medicinesList = medicines.ToList();
|
|
var medicinesWithoutNutrition = medicinesList.Where(m => !m.Type.Contains("Nutrition"))
|
|
.ToList();
|
|
|
|
activeMedicines.AddRange(medicinesWithoutNutrition);
|
|
|
|
|
|
await CalculatedObservationsService.CalculateMedicineObservation(activeMedicines,
|
|
patient.Id);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error("ERROR executing check active treatments job {exMessage}", ex.Message);
|
|
}
|
|
|
|
var end = DateTime.Now;
|
|
_logger.Debug("Finished check active treatments job in {TotalMilliseconds:F1} ms",
|
|
(end - start).TotalMilliseconds);
|
|
}
|
|
}
|
|
|
|
[DisallowConcurrentExecution]
|
|
public class CheckActiveAppointmentsJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<CheckActiveAppointmentsJob>();
|
|
public static IAppointmentService AppointmentService { get; set; } = null!;
|
|
|
|
public static IDiagnosisService DiagnosisService { get; set; } = null!;
|
|
|
|
public static IPatientService PatientService { get; set; } = null!;
|
|
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
var start = DateTime.Now;
|
|
|
|
_logger.Debug("Executing check active appointments job");
|
|
|
|
|
|
try
|
|
{
|
|
//TODO falta definir
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error("ERROR executing check active treatments job {exMessage}", ex.Message);
|
|
}
|
|
|
|
var end = DateTime.Now;
|
|
_logger.Debug("Finished check active treatments job in {TotalMilliseconds:F1} ms",
|
|
(end - start).TotalMilliseconds);
|
|
}
|
|
}
|
|
[DisallowConcurrentExecution]
|
|
public class CheckInactivePatientsJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<CheckInactivePatientsJob>();
|
|
|
|
public static IPatientService PatientService { get; set; } = null!;
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
//LogExecutionContext.TrySetTraceIdentifier(Guid.NewGuid().ToString(), true);
|
|
|
|
var start = DateTime.Now;
|
|
|
|
var dataMap = context.JobDetail.JobDataMap;
|
|
var archivePatientsWithoutObservationsSinceHours =
|
|
dataMap.GetInt("archivePatientsWithoutObservationsSinceHours");
|
|
var sinceDischargeTime = dataMap.GetInt("sinceDischargeTime");
|
|
var sinceDate = DateTime.Now.AddHours(-archivePatientsWithoutObservationsSinceHours);
|
|
|
|
_logger.Debug(
|
|
"Executing Check inactive patients job archivePatientsWithoutObservationsSinceHours: {archivePatientsWithoutObservationsSinceHours} sinceDate: {sinceDate} sinceDischargeTime: {sinceDischargeTime}",
|
|
archivePatientsWithoutObservationsSinceHours, sinceDate, sinceDischargeTime);
|
|
try
|
|
{
|
|
var exists = GlobalData.Data.TryGetValue("isCheckingInactivePatients", out var isChecking);
|
|
if (!exists || isChecking is false)
|
|
await PatientService.DischargeInactivePatients(sinceDate, sinceDischargeTime);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error("ERROR executing check inactive patients job {ExMessage}", ex.Message);
|
|
}
|
|
|
|
var end = DateTime.Now;
|
|
_logger.Debug("Finished Check inactive patients job in {TotalMilliseconds:F1} ms",
|
|
(end - start).TotalMilliseconds);
|
|
}
|
|
}
|
|
|
|
[DisallowConcurrentExecution]
|
|
public class CheckOpiateBolusesJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<CheckOpiateBolusesJob>();
|
|
public static IPatientService PatientService { get; set; } = null!;
|
|
public static ICalculatedObservationsService CalculatedObservationsService { get; set; } = null!;
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
var start = DateTime.Now;
|
|
|
|
//LogExecutionContext.TrySetTraceIdentifier(Guid.NewGuid().ToString(), true);
|
|
_logger.Debug("Executing check opiate boluses job");
|
|
|
|
try
|
|
{
|
|
var patients = await PatientService.FindAll();
|
|
foreach (var patient in patients) await CalculatedObservationsService.CalculateBolusOpiates(patient.Id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error("ERROR executing check opiate boluses job {ExMessage} trace: {ExStackTrace}", ex.Message,
|
|
ex.StackTrace);
|
|
}
|
|
|
|
var end = DateTime.Now;
|
|
|
|
_logger.Debug("Finished Check opiate boluses job in {TotalSeconds:F1} seconds", (end - start).TotalSeconds);
|
|
}
|
|
}
|
|
|
|
[DisallowConcurrentExecution]
|
|
public class CheckExpiredObservationsJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<CheckExpiredObservationsJob>();
|
|
|
|
public static IObservationService ObservationService { get; set; } = null!;
|
|
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
var start = DateTime.Now;
|
|
|
|
//LogExecutionContext.TrySetTraceIdentifier(Guid.NewGuid().ToString(), true);
|
|
_logger.Debug("Executing check expired observations job");
|
|
|
|
try
|
|
{
|
|
var exists = GlobalData.Data.TryGetValue("isCheckingExpiration", out var isChecking);
|
|
if (!exists)
|
|
{
|
|
GlobalData.AddData("isCheckingExpiration", false);
|
|
isChecking = false;
|
|
}
|
|
|
|
if (!exists || isChecking is false) await ObservationService.ExpireObservationsAndRecalculateAsync();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error("ERROR executing check expired observations {ExMessage} trace: {ExStackTrace}",
|
|
ex.Message, ex.StackTrace);
|
|
}
|
|
|
|
var end = DateTime.Now;
|
|
_logger.Debug("Finished Check expired observations job in {TotalSeconds:F1} seconds",
|
|
(end - start).TotalSeconds);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Job for calculate NEWS based on FR, SPo2, Temperature, Tas and FC
|
|
/// </summary>
|
|
[DisallowConcurrentExecution]
|
|
public class CalculateNewsJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<CalculateNewsJob>();
|
|
|
|
public static IObservationService ObservationService { get; set; } = null!;
|
|
|
|
public static IConfigObservationService ConfigObservationService { get; set; } = null!;
|
|
|
|
public static IPatientService PatientService { get; set; } = null!;
|
|
|
|
public static int ExpiresIn { get; set; } = 15;
|
|
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
//Filter patients in real locations
|
|
//LogExecutionContext.TrySetTraceIdentifier(Guid.NewGuid().ToString(), true);
|
|
|
|
var patients = await PatientService.FindInActivePoC();
|
|
var observationList = new List<string> { "Resp_Rate_Calculated", "SpO2", "Temperature", "TAs", "FC" };
|
|
|
|
foreach (var patient in patients)
|
|
{
|
|
var observations =
|
|
await CheckExpiredAlertsJob.ObservationService.FindLastObservations(patient.Id, 1, observationList);
|
|
if (!observations.Any()) continue;
|
|
var newsScore = 0;
|
|
var msg = new StringBuilder();
|
|
_logger.Debug("CalculateNewsJob - patient ({patientPointOfCare} {patientBed})", patient.UnitString,
|
|
patient.Bed);
|
|
foreach (var obs in observations)
|
|
{
|
|
var conf = await ConfigObservationService.Get(obs);
|
|
var expires = conf?.Expires;
|
|
if (obs.Expired || (expires != null &&
|
|
obs.Time.AddSeconds(expires.Value).ToUniversalTime() < DateTime.UtcNow))
|
|
{
|
|
_logger.Verbose(
|
|
"CalculateNewsJob - patient ({patientPointOfCare} {patientBed}) obs ({obsName} value {obsValue} time {obsTime} expired {obsExpired}) confexpires: {expires} EXPIRED",
|
|
patient.UnitString, patient.Bed, obs.Name, obs.Value, obs.Time, obs.Expired, expires);
|
|
continue;
|
|
}
|
|
|
|
_logger.Verbose(
|
|
"CalculateNewsJob - patient ({patientPointOfCare} {patientBed}) obs ({obsName} value {obsValue} time {obsTime} expired {obsExpired}) confexpires: {expires} NOT EXPIRED",
|
|
patient.UnitString, patient.Bed, obs.Name, obs.Value, obs.Time, obs.Expired, expires);
|
|
var partialNewsScore = 0;
|
|
switch (obs.Name)
|
|
{
|
|
case "Resp_Rate_Calculated":
|
|
if (!double.TryParse(obs.Value.ToString(), out var frValue)) continue;
|
|
switch (Math.Round(frValue, 0))
|
|
{
|
|
case >= 12 and <= 20:
|
|
break;
|
|
case >= 25:
|
|
case <= 8:
|
|
partialNewsScore = 3;
|
|
break;
|
|
case >= 9 and <= 11:
|
|
partialNewsScore = 1;
|
|
break;
|
|
case >= 21 and <= 24:
|
|
partialNewsScore = 2;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case "SpO2":
|
|
if (!double.TryParse(obs.Value.ToString(), out var spo2Value)) continue;
|
|
switch (Math.Round(spo2Value, 0))
|
|
{
|
|
case <= 91:
|
|
partialNewsScore = 3;
|
|
break;
|
|
case >= 92 and <= 93:
|
|
partialNewsScore = 2;
|
|
break;
|
|
case >= 94 and <= 95:
|
|
partialNewsScore = 1;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case "Temperature":
|
|
if (!double.TryParse(obs.Value.ToString(), out var tempValue)) continue;
|
|
switch (Math.Round(tempValue, 1))
|
|
{
|
|
case <= 35:
|
|
partialNewsScore = 3;
|
|
break;
|
|
case >= 35.1 and <= 36.0:
|
|
case >= 38.1 and <= 39.0:
|
|
partialNewsScore = 1;
|
|
break;
|
|
case >= 39.1:
|
|
partialNewsScore = 2;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case "TAs":
|
|
if (!double.TryParse(obs.Value.ToString(), out var tasValue)) continue;
|
|
switch (Math.Round(tasValue, 0))
|
|
{
|
|
case <= 90:
|
|
case >= 220:
|
|
partialNewsScore = 3;
|
|
break;
|
|
case >= 91 and <= 100:
|
|
partialNewsScore = 2;
|
|
break;
|
|
case >= 101 and <= 110:
|
|
partialNewsScore = 1;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case "FC":
|
|
if (!double.TryParse(obs.Value.ToString(), out var fcValue)) continue;
|
|
switch (Math.Round(fcValue, 0))
|
|
{
|
|
case <= 40:
|
|
case >= 131:
|
|
partialNewsScore = 3;
|
|
break;
|
|
case >= 111 and <= 130:
|
|
partialNewsScore = 2;
|
|
break;
|
|
case >= 41 and <= 50:
|
|
case >= 91 and <= 110:
|
|
partialNewsScore = 1;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
msg.Append($"[{obs.Name} {obs.Value} {partialNewsScore}] ");
|
|
newsScore += partialNewsScore;
|
|
}
|
|
|
|
var lastObs =
|
|
await CheckExpiredAlertsJob.ObservationService.FindLastObservations(patient.Id, 1, observationList);
|
|
|
|
if (lastObs.FirstOrDefault()?.Expired != true)
|
|
{
|
|
var newObs = new PatientObservation
|
|
{
|
|
Name = "NEWS",
|
|
CodingSystem = "ADAS",
|
|
Expires = ExpiresIn,
|
|
Value = newsScore,
|
|
PatientId = patient.Id,
|
|
Time = DateTime.Now
|
|
};
|
|
await CheckExpiredAlertsJob.ObservationService.InsertObservation(newObs);
|
|
_logger.Debug(
|
|
$"CalculateNewsJob - patient ({patient.UnitString} {patient.Bed}) newsScore: {newsScore} from {msg}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[DisallowConcurrentExecution]
|
|
public class CheckExpiredAlertsJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<CheckExpiredAlertsJob>();
|
|
|
|
public static IObservationService ObservationService { get; set; } = null!;
|
|
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
var start = DateTime.Now;
|
|
|
|
//LogExecutionContext.TrySetTraceIdentifier(Guid.NewGuid().ToString(), true);
|
|
_logger.Debug("Executing check expired alerts and power off job");
|
|
|
|
try
|
|
{
|
|
var exists = GlobalData.Data.TryGetValue("isCheckingAlertsExpiration", out var isChecking);
|
|
if (!exists || isChecking is false) await ObservationService.ExpireAlertsAndPowerOffAsync();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error("ERROR executing check expired alerts and power off {ExMessage} trace: {ExStackTrace}",
|
|
ex.Message,
|
|
ex.StackTrace);
|
|
}
|
|
|
|
var end = DateTime.Now;
|
|
_logger.Debug("Finished Check check expired alerts and power off job in {TotalSeconds:F1} seconds",
|
|
(end - start).TotalSeconds);
|
|
}
|
|
}
|
|
|
|
[DisallowConcurrentExecution]
|
|
public class ArchiveNurseDataJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<CheckOpiateBolusesJob>();
|
|
|
|
//private readonly ArchiveNurseData _archiveNurseData;
|
|
public static ArchiveNurseData ArchiveNurseDataSettings { get; set; } = new();
|
|
|
|
public static IPatientService PatientService { get; set; } = null!;
|
|
|
|
public static IPatientCarePlanService PatientCarePlanService { get; set; } = null!;
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
var start = DateTime.Now;
|
|
_logger.Debug("Executing ArchiveNurseDataJob job");
|
|
|
|
try
|
|
{
|
|
if (ArchiveNurseDataSettings.ArchiveProcedure.Active)
|
|
{
|
|
var patientWithFinishedProcedures =
|
|
await PatientService.FindAllPatientWithFinishedProcedures(ArchiveNurseDataSettings.ArchiveProcedure
|
|
.EndDateAfterMinutes);
|
|
foreach (var patientWithFinishedProcedure in patientWithFinishedProcedures)
|
|
{
|
|
var itemsToArchive = patientWithFinishedProcedure.Procedures?
|
|
.Where(c =>
|
|
c is
|
|
{
|
|
//OptionType: "procedure",
|
|
EndDate: not null
|
|
} &&
|
|
c.EndDate.Value.AddMinutes(ArchiveNurseDataSettings.ArchiveProcedure.EndDateAfterMinutes) <
|
|
DateTime.UtcNow)
|
|
.ToList();
|
|
|
|
if (itemsToArchive != null)
|
|
{
|
|
_ = PatientCarePlanService.ArchiveCarePlanFromJob(patientWithFinishedProcedure,
|
|
itemsToArchive);
|
|
patientWithFinishedProcedure.Procedures = patientWithFinishedProcedure.Procedures?
|
|
.Where(c => !itemsToArchive.Contains(c)).ToList();
|
|
await PatientService.Update(patientWithFinishedProcedure);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ArchiveNurseDataSettings.ArchiveTest.Active)
|
|
{
|
|
var patientWithFinishedTests =
|
|
await PatientService.FindAllPatientWithFinishedTest(ArchiveNurseDataSettings.ArchiveTest
|
|
.EndDateAfterMinutes);
|
|
foreach (var patientWithFinishedTest in patientWithFinishedTests)
|
|
{
|
|
var itemsToArchive = patientWithFinishedTest.Tests?
|
|
.Where(c =>
|
|
c is
|
|
{
|
|
//OptionType: "test",
|
|
EndDate: not null
|
|
} &&
|
|
c.EndDate.Value.AddMinutes(ArchiveNurseDataSettings.ArchiveTest.EndDateAfterMinutes) <
|
|
DateTime.UtcNow)
|
|
.ToList();
|
|
|
|
if (itemsToArchive != null)
|
|
{
|
|
_ = PatientCarePlanService.ArchiveCarePlanFromJob(patientWithFinishedTest,
|
|
itemsToArchive);
|
|
patientWithFinishedTest.Tests = patientWithFinishedTest.Tests?
|
|
.Where(c => !itemsToArchive.Contains(c)).ToList();
|
|
await PatientService.Update(patientWithFinishedTest);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ArchiveNurseDataSettings.ArchiveTreatment.Active)
|
|
{
|
|
var patientWithFinishedTreatments =
|
|
await PatientService.FindAllPatientWithFinishedTreatment(ArchiveNurseDataSettings.ArchiveTreatment
|
|
.EndDateAfterMinutes);
|
|
foreach (var patientWithFinishedTreatment in patientWithFinishedTreatments)
|
|
{
|
|
var itemsToArchive = patientWithFinishedTreatment.Treatment?
|
|
.Where(c =>
|
|
c.EndDate.HasValue &&
|
|
c.EndDate.Value.AddMinutes(ArchiveNurseDataSettings.ArchiveTest.EndDateAfterMinutes) <
|
|
DateTime.UtcNow)
|
|
.ToList();
|
|
|
|
if (itemsToArchive != null)
|
|
{
|
|
_ = PatientCarePlanService.ArchiveCarePlanFromJob(patientWithFinishedTreatment,
|
|
itemsToArchive);
|
|
patientWithFinishedTreatment.Treatment = patientWithFinishedTreatment.Treatment?
|
|
.Where(c => !itemsToArchive.Contains(c))
|
|
.ToList();
|
|
await PatientService.Update(patientWithFinishedTreatment);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error("ERROR executing ArchiveNurseDataJob {ExMessage} trace: {ExStackTrace}",
|
|
ex.Message,
|
|
ex.StackTrace);
|
|
}
|
|
|
|
var end = DateTime.Now;
|
|
_logger.Debug("Finished ArchiveNurseDataJob {TotalSeconds:F1} seconds",
|
|
(end - start).TotalSeconds);
|
|
}
|
|
}
|
|
|
|
[DisallowConcurrentExecution]
|
|
public class GetProvidersObservationsJob : IJob
|
|
{
|
|
private readonly ILogger _logger = Log.ForContext<GetProvidersObservationsJob>();
|
|
|
|
public static IObservationService ObservationService { get; set; } = null!;
|
|
|
|
public static IPatientService PatientService { get; set; } = null!;
|
|
|
|
public static List<ProvidersSettings> Providers { get; set; } = null!;
|
|
|
|
|
|
public static IHttpClientFactory HttpClientFactory { get; set; } = null!;
|
|
|
|
public async Task Execute(IJobExecutionContext context)
|
|
{
|
|
var start = DateTime.Now;
|
|
_logger.Debug("Executing get providers job");
|
|
|
|
try
|
|
{
|
|
if (!Providers.Any()) return;
|
|
|
|
foreach (var provider in Providers)
|
|
{
|
|
//replace - to _ to fit name
|
|
var providerType =
|
|
Type.GetType(
|
|
$"{Assembly.GetExecutingAssembly().GetName().Name?.Replace("-", "_")}.Providers.{provider.Name}Provider");
|
|
if (providerType == null)
|
|
{
|
|
Log.Error("Provider {ProviderName} not able lo load by reflection", provider.Name);
|
|
continue;
|
|
}
|
|
|
|
|
|
var ctor = providerType.GetConstructor([
|
|
typeof(IOptions<ProvidersSettings>),
|
|
typeof(IHttpClientFactory)
|
|
]);
|
|
if (ctor == null)
|
|
{
|
|
Log.Error("not able to find constructor for provider: {ProviderName}", provider.Name);
|
|
continue;
|
|
}
|
|
|
|
var customProvider = (BaseProvider)ctor.Invoke([
|
|
Options.Create(provider),
|
|
HttpClientFactory
|
|
]);
|
|
|
|
var patients = await PatientService.FindAll();
|
|
|
|
foreach (var patient in patients)
|
|
{
|
|
var observations = await customProvider.GetObservations(patient);
|
|
if (observations.Any()) observations.ForEach(o => ObservationService.InsertObservation(o));
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Error(
|
|
"ERROR executing GetByCodeSysAndCode providers observations job error: {ExMessage} trace: {ExStackTrace}",
|
|
ex.Message, ex.StackTrace);
|
|
}
|
|
|
|
var end = DateTime.Now;
|
|
_logger.Debug("Finished GetByCodeSysAndCode providers observations job in {TotalMilliseconds:F1} ms",
|
|
(end - start).TotalMilliseconds);
|
|
}
|
|
} |