public async Task <IActionResult> Index(string type)
{
type = string.IsNullOrEmpty(type) ? Constants.Patient : type;
ExplorerViewModel model = new ExplorerViewModel();
model.DataType = type;
model.Fields = GetFields(type);
//Get total patients
ExplorerService service = new ExplorerService();
model.TotalPatients = await service.TotalPatients(configuration);
model.TotalTransactions = await service.TotalTransactions(configuration);
model.TotalIssues = await service.TotalIssues(configuration);
model.TotalFacilities = await service.TotalFacilityInConsultation(configuration);
return(View(model));
}
public WorkingAreaViewModel(string containerName,
ExplorerService explorerService)
{
if (containerName == null)
{
throw new ArgumentNullException(nameof(containerName));
}
_viewSource = new CollectionViewSource
{
Source = explorerService.ExplorerViewModels,
IsLiveFilteringRequested = true,
LiveFilteringProperties = { nameof(ExplorerViewModel.Container) }
};
_viewSource.Filter += (sender, args) =>
{
args.Accepted = args.Item is ExplorerViewModel explorerViewModel &&
explorerViewModel.Container.AreEqual(containerName);
};
ExplorerViewModels = _viewSource.View;
}
public FilesController(ILogger <FilesController> logger, ExplorerService service)
{
_logger = logger;
_service = service;
}
public WorkingAreaView(ExplorerService explorerService)
{
_explorerService = explorerService ?? throw new ArgumentNullException(nameof(explorerService));
InitializeComponent();
}
public async Task <IActionResult> Index(string patientId)
{
try
{
PatientViewModel model = new PatientViewModel();
if (!string.IsNullOrEmpty(patientId))
{
ExplorerRequestModel request = new ExplorerRequestModel();
request.PatientId = patientId;
model.PatientId = patientId;
ExplorerService service = new ExplorerService();
var data = await service.GetAllPatientTrxns(configuration, request);
foreach (var d in data)
{
switch (d.TransactionType)
{
case Constants.TransactionType.CreatePatient:
model.Patient.TransactionId = d.TransactionId;
model.Patient.TransactionTimestamp = d.TransactionTimestamp;
model.Patient.TransactionType = d.TransactionType;
model.Patient.Events = new List <PatientModel>();
foreach (var e in d.Events)
{
var p = JsonConvert.DeserializeObject <ApiResponse>(e.ToString());
model.Patient.Events.Add(p.Patient);
}
model.PatientTrxns.Add(model.Patient);
break;
case Constants.TransactionType.ChangePatient:
TransactionDetailModel <PatientModel> patient = new TransactionDetailModel <PatientModel>();
patient.TransactionId = d.TransactionId;
patient.TransactionTimestamp = d.TransactionTimestamp;
patient.TransactionType = d.TransactionType;
patient.Events = new List <PatientModel>();
foreach (var e in d.Events)
{
var p = JsonConvert.DeserializeObject <ApiResponse>(e.ToString());
patient.Events.Add(p.Patient);
}
model.PatientTrxns.Add(patient);
break;
case Constants.TransactionType.Consult:
TransactionDetailModel <ConsultationModel> consult = new TransactionDetailModel <ConsultationModel>();
consult.TransactionId = d.TransactionId;
consult.TransactionTimestamp = d.TransactionTimestamp;
consult.TransactionType = d.TransactionType;
consult.Events = new List <ConsultationModel>();
foreach (var e in d.Events)
{
var p = JsonConvert.DeserializeObject <ApiResponse>(e.ToString());
consult.Events.Add(p.Consultation);
}
model.ConsultTrxns.Add(consult);
break;
case Constants.TransactionType.Prescription:
TransactionDetailModel <PrescriptionModel> prescript = new TransactionDetailModel <PrescriptionModel>();
prescript.TransactionId = d.TransactionId;
prescript.TransactionTimestamp = d.TransactionTimestamp;
prescript.TransactionType = d.TransactionType;
prescript.Events = new List <PrescriptionModel>();
foreach (var e in d.Events)
{
var p = JsonConvert.DeserializeObject <ApiResponse>(e.ToString());
prescript.Events.Add(p.Prescription);
}
model.PrescriptTrxns.Add(prescript);
break;
case Constants.TransactionType.CreateIssue:
TransactionDetailModel <IssueModel> issue = new TransactionDetailModel <IssueModel>();
issue.TransactionId = d.TransactionId;
issue.TransactionTimestamp = d.TransactionTimestamp;
issue.TransactionType = d.TransactionType;
issue.Events = new List <IssueModel>();
foreach (var e in d.Events)
{
var p = JsonConvert.DeserializeObject <ApiResponse>(e.ToString());
issue.Events.Add(p.Issue);
}
model.IssueTrxns.Add(issue);
break;
case Constants.TransactionType.CreateTest:
break;
case Constants.TransactionType.CreateTriage:
TransactionDetailModel <TriageModel> triage = new TransactionDetailModel <TriageModel>();
triage.TransactionId = d.TransactionId;
triage.TransactionTimestamp = d.TransactionTimestamp;
triage.TransactionType = d.TransactionType;
triage.Events = new List <TriageModel>();
foreach (var e in d.Events)
{
var p = JsonConvert.DeserializeObject <ApiResponse>(e.ToString());
triage.Events.Add(p.Triage);
}
model.TriageTrxns.Add(triage);
break;
case Constants.TransactionType.CreateProcedure:
break;
}
}
}
return(View(model));
}
catch (Exception ex)
{
ViewData["Message"] = "Could not get patient data. Please try again later.";
}
return(View());
}
private void FilesServiceActivation(ILifetimeScope scope, ExplorerService service)
{
Application.Current.Dispatcher.Postpone(DispatcherPriority.Background, service.Load);
}
public async Task <IActionResult> Search(ExplorerViewModel model, IFormCollection form)
{
string[] fields = form["Field"].ToString().Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
string[] values = form["Value"].ToString().Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
ExplorerService service = new ExplorerService();
try
{
if (model.DataType.Equals(Constants.Patient))
{
var patients = await service.FilterPatientsByDataType(configuration, fields, values);
return(Json(new { type = model.DataType, data = patients }));
}
if (model.DataType.Equals(Constants.Consultation))
{
var consults = await service.FilterConsultationsByDataType(configuration, fields, values);
return(Json(new { type = model.DataType, data = consults }));
}
if (model.DataType.Equals(Constants.Prescription))
{
List <PrescriptionViewModel> result = new List <PrescriptionViewModel>();
var prescriptions = await service.FilterPrescriptionsByDataType(configuration, fields, values);
foreach (var p in prescriptions)
{
foreach (var m in p.Medicines)
{
PrescriptionViewModel prescription = new PrescriptionViewModel
{
PatientId = p.PatientId,
Description = p.Description,
Dose = m.Dose,
DrugName = m.DrugName,
DrugType = m.DrugType,
Facility = p.Facility,
Frequency = m.Frequency,
Quantity = m.Quantity,
Route = m.Route,
VisitCode = p.VisitCode
};
result.Add(prescription);
}
}
return(Json(new { type = model.DataType, data = result }));
}
if (model.DataType.Equals(Constants.Issue))
{
var issues = await service.FilterIssuesByDataType(configuration, fields, values);
return(Json(new { type = model.DataType, data = issues }));
}
}
catch (Exception ex)
{
return(View(new ErrorViewModel {
RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier
}));
}
model.Fields = GetFields(model.DataType);
return(View("Index", model));
}
