public IList <CustomAttributeConfigListItem> ListCustomAttributes(string entityName)
{
var customAttributes = _customAttributeConfigRepository.List();
IList <CustomAttributeConfigListItem> attributesOfEntity =
(from c in customAttributes
where c.ExtendableTypeName == entityName
select new CustomAttributeConfigListItem
{
CustomAttributeConfigId = c.Id,
EntityName = entityName,
Category = c.Category,
AttributeName = c.AttributeKey,
AttributeTypeName = c.CustomAttributeType == CustomAttributeType.Numeric ? "Numeric" : c.CustomAttributeType == CustomAttributeType.String ? "Text" : c.CustomAttributeType == CustomAttributeType.DateTime ? "Date" : c.CustomAttributeType == CustomAttributeType.Selection ? "Selection" : "",
Required = c.IsRequired,
StringMaxLength = c.CustomAttributeType == CustomAttributeType.String ? c.StringMaxLength : null,
NumericMinValue = c.CustomAttributeType == CustomAttributeType.Numeric ? c.NumericMinValue : null,
NumericMaxValue = c.CustomAttributeType == CustomAttributeType.Numeric ? c.NumericMaxValue : null,
FutureDateOnly = c.CustomAttributeType == CustomAttributeType.DateTime ? (bool?)c.FutureDateOnly : null,
PastDateOnly = c.CustomAttributeType == CustomAttributeType.DateTime ? (bool?)c.PastDateOnly : null,
Searchable = c.IsSearchable,
}).ToList();
return(attributesOfEntity);
}
private async Task CustomConditionMapAsync(Patient patientFromRepo, PatientExpandedDto mappedPatient)
{
int[] terms = _patientConditionRepository.List(pc => pc.Patient.Id == mappedPatient.Id && pc.TerminologyMedDra != null && !pc.Archived && !pc.Patient.Archived, null, new string[] { "Condition" })
.Select(p => p.TerminologyMedDra.Id)
.ToArray();
var conditionMeddras = await _conditionMeddraRepository.ListAsync(cm => terms.Contains(cm.TerminologyMedDra.Id), null, new string[] { "Condition", "TerminologyMedDra" });
List <PatientConditionGroupDto> groupArray = new List <PatientConditionGroupDto>();
foreach (var conditionMeddra in conditionMeddras)
{
var tempCondition = conditionMeddra.GetConditionForPatient(patientFromRepo);
if (tempCondition != null)
{
var group = new PatientConditionGroupDto()
{
ConditionGroup = conditionMeddra.Condition.Description,
Status = tempCondition.OutcomeDate != null ? "Case Closed" : "Case Open",
PatientConditionId = tempCondition.Id,
StartDate = tempCondition.OnsetDate.ToString("yyyy-MM-dd"),
Detail = String.Format("{0} started on {1}", tempCondition.TerminologyMedDra.DisplayName, tempCondition.OnsetDate.ToString("yyyy-MM-dd"))
};
groupArray.Add(group);
}
}
mappedPatient.ConditionGroups = groupArray;
}
private async Task MapCaseNumberAsync(PatientDetailDto mappedPatient)
{
int[] terms = _patientConditionRepository.List(pc => pc.Patient.Id == mappedPatient.Id && pc.TerminologyMedDra != null && !pc.Archived && !pc.Patient.Archived, null, new string[] { "Condition", "TerminologyMedDra" })
.Select(p => p.TerminologyMedDra.Id)
.ToArray();
var conditionMeddras = await _conditionMeddraRepository.ListAsync(cm => terms.Contains(cm.TerminologyMedDra.Id), null, new string[] { "Condition", "TerminologyMedDra" });
var patientFromRepo = await _patientRepository.GetAsync(p => p.Archived == false &&
p.Id == mappedPatient.Id,
new string[] { "PatientConditions.TerminologyMedDra", "PatientConditions.Outcome", "PatientConditions.TreatmentOutcome" });
List <PatientConditionGroupDto> groupArray = new List <PatientConditionGroupDto>();
foreach (var conditionMeddra in conditionMeddras)
{
var currentConditionGroup = conditionMeddra.GetConditionForPatient(patientFromRepo);
if (currentConditionGroup != null)
{
if (!String.IsNullOrWhiteSpace(currentConditionGroup.CaseNumber))
{
mappedPatient.CaseNumber.Add(currentConditionGroup.CaseNumber);
}
}
}
}
public SeriesValueList[] GetElementValues(long patientId, string elementName, int records)
{
var patientFromRepo = _patientRepository.Get(p => p.Id == patientId);
if (patientFromRepo == null)
{
throw new ArgumentException(nameof(patientId));
}
if (string.IsNullOrWhiteSpace(elementName))
{
throw new ArgumentException(nameof(elementName));
}
var encounters = _encounterRepository.List(e => e.Patient.Id == patientId)
.OrderBy(e => e.EncounterDate);
var seriesValueArray = new List <SeriesValueList>();
var seriesValueList = new SeriesValueList()
{
Name = elementName
};
var values = new List <SeriesValueListItem>();
foreach (Encounter encounter in encounters)
{
var datasetInstance = _datasetInstanceRepository.Get(di => di.ContextId == encounter.Id && di.Dataset.ContextType.Id == (int)ContextTypes.Encounter);
if (datasetInstance != null)
{
var value = datasetInstance.GetInstanceValue(elementName);
var decimalValue = 0M;
Decimal.TryParse(value, out decimalValue);
if (!String.IsNullOrWhiteSpace(value))
{
var modelItem = new SeriesValueListItem()
{
Value = decimalValue,
//Min = intValue - ((intValue * 20) / 100),
//Max = intValue + ((intValue * 20) / 100),
Name = encounter.EncounterDate.ToString("yyyy-MM-dd")
};
values.Add(modelItem);
if (values.Count >= records)
{
break;
}
}
}
}
seriesValueList.Series = values;
seriesValueArray.Add(seriesValueList);
return(seriesValueArray.ToArray());
}
/// <summary>
/// Get lab results from repository and auto map to Dto
/// </summary>
/// <typeparam name="T">Identifier or detail Dto</typeparam>
/// <param name="labResultResourceParameters">Standard parameters for representing resource</param>
/// <returns></returns>
private PagedCollection <T> GetLabResults <T>(LabResultResourceParameters labResultResourceParameters) where T : class
{
var pagingInfo = new PagingInfo()
{
PageNumber = labResultResourceParameters.PageNumber,
PageSize = labResultResourceParameters.PageSize
};
var orderby = Extensions.GetOrderBy <LabResult>(labResultResourceParameters.OrderBy, "asc");
var predicate = PredicateBuilder.New <LabResult>(true);
if (!String.IsNullOrWhiteSpace(labResultResourceParameters.SearchTerm))
{
predicate = predicate.And(f => f.Description.Contains(labResultResourceParameters.SearchTerm.Trim()));
}
if (labResultResourceParameters.Active != Models.ValueTypes.YesNoBothValueType.Both)
{
predicate = predicate.And(f => f.Active == (labResultResourceParameters.Active == Models.ValueTypes.YesNoBothValueType.Yes));
}
var pagedLabResultsFromRepo = _labResultRepository.List(pagingInfo, predicate, orderby, "");
if (pagedLabResultsFromRepo != null)
{
// Map EF entity to Dto
var mappedLabResults = PagedCollection <T> .Create(_mapper.Map <PagedCollection <T> >(pagedLabResultsFromRepo),
pagingInfo.PageNumber,
pagingInfo.PageSize,
pagedLabResultsFromRepo.TotalCount);
// Prepare pagination data for response
var paginationMetadata = new
{
totalCount = mappedLabResults.TotalCount,
pageSize = mappedLabResults.PageSize,
currentPage = mappedLabResults.CurrentPage,
totalPages = mappedLabResults.TotalPages,
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
// Add HATEOAS links to each individual resource
mappedLabResults.ForEach(dto => CreateLinksForLabResult(dto));
return(mappedLabResults);
}
return(null);
}
// GET: api/CustomAttributeConfigApi
public IEnumerable <CustomAttributeConfigListItem> Get()
{
var customAttributes = customAttributeConfigRepository.List();
IList <CustomAttributeConfigListItem> attributesOfEntity =
(from c in customAttributes
select new CustomAttributeConfigListItem
{
CustomAttributeConfigId = c.Id,
EntityName = c.ExtendableTypeName,
Category = c.Category,
AttributeName = c.AttributeKey,
Required = c.IsRequired,
NumericMaxValue = c.NumericMaxValue,
NumericMinValue = c.NumericMinValue,
StringMaxLength = c.StringMaxLength,
FutureDateOnly = c.FutureDateOnly,
PastDateOnly = c.PastDateOnly,
AttributeTypeName = c.CustomAttributeType == CustomAttributeType.Numeric ? "Numeric" : c.CustomAttributeType == CustomAttributeType.String ? "Text" : c.CustomAttributeType == CustomAttributeType.DateTime ? "Date" : c.CustomAttributeType == CustomAttributeType.Selection ? "Selection" : ""
}).ToList();
return(attributesOfEntity);
}
/// <summary>
/// Get dataset elements from repository and auto map to Dto
/// </summary>
/// <typeparam name="T">Identifier or detail Dto</typeparam>
/// <param name="datasetElementResourceParameters">Standard parameters for representing resource</param>
/// <returns></returns>
private PagedCollection <T> GetDatasetElements <T>(DatasetElementResourceParameters datasetElementResourceParameters) where T : class
{
var pagingInfo = new PagingInfo()
{
PageNumber = datasetElementResourceParameters.PageNumber,
PageSize = datasetElementResourceParameters.PageSize
};
var orderby = Extensions.GetOrderBy <DatasetElement>(datasetElementResourceParameters.OrderBy, "asc");
var predicate = PredicateBuilder.New <DatasetElement>(true);
if (!String.IsNullOrWhiteSpace(datasetElementResourceParameters.ElementName))
{
predicate = predicate.And(f => f.ElementName.Contains(datasetElementResourceParameters.ElementName));
}
var pagedDatasetElementsFromRepo = _datasetElementRepository.List(pagingInfo, predicate, orderby, new string[] {
"Field.FieldType"
});
if (pagedDatasetElementsFromRepo != null)
{
// Map EF entity to Dto
var mappedDatasetElements = PagedCollection <T> .Create(_mapper.Map <PagedCollection <T> >(pagedDatasetElementsFromRepo),
pagingInfo.PageNumber,
pagingInfo.PageSize,
pagedDatasetElementsFromRepo.TotalCount);
// Prepare pagination data for response
var paginationMetadata = new
{
totalCount = mappedDatasetElements.TotalCount,
pageSize = mappedDatasetElements.PageSize,
currentPage = mappedDatasetElements.CurrentPage,
totalPages = mappedDatasetElements.TotalPages,
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
// Add HATEOAS links to each individual resource
mappedDatasetElements.ForEach(dto => CreateLinksForDatasetElement(dto));
return(mappedDatasetElements);
}
return(null);
}
private void CreateSelectionValues(CustomAttributeDetailDto dto)
{
if (dto.CustomAttributeType != "Selection")
{
return;
}
;
dto.SelectionDataItems = _selectionDataItemRepository.List(s => s.AttributeKey == dto.AttributeKey, null, "")
.Select(ss => new SelectionDataItemDto()
{
SelectionKey = ss.SelectionKey,
Value = ss.Value
})
.ToList();
}
public IEnumerable <SelectionDataItemDetail> ListSelectionDataItems()
{
var referenceData = selectionDataRepository.List();
IList <SelectionDataItemDetail> selectionDataItems =
(from item in referenceData
select new SelectionDataItemDetail
{
SelectionDataItemId = item.Id,
AttributeKey = item.AttributeKey,
SelectionKey = item.SelectionKey,
DataItemValue = item.Value
}).ToList();
return(selectionDataItems);
}
/// <summary>
/// Get patients from auditLogs
/// </summary>
/// <param name="auditLogResourceParameters">Standard parameters for representing resource</param>
/// <returns></returns>
private List <long> GetPatientsFromAuditLogs(AuditLogResourceParameters auditLogResourceParameters)
{
var orderby = Extensions.GetOrderBy <AuditLog>(auditLogResourceParameters.OrderBy, "asc");
// FIlter audit logs
var predicate = PredicateBuilder.New <AuditLog>(true);
predicate = predicate.And(au => au.ActionDate >= auditLogResourceParameters.SearchFrom && au.ActionDate <= auditLogResourceParameters.SearchTo);
predicate = predicate.And(au => au.AuditType == AuditType.SynchronisationForm);
if (auditLogResourceParameters.FacilityId > 0)
{
predicate = predicate.And(au => au.User.Facilities.Any(uf => uf.Facility.Id == auditLogResourceParameters.FacilityId));
}
var auditLogsFromRepo = _auditLogRepository.List(predicate, orderby, "");
if (auditLogsFromRepo != null)
{
var returnIds = new List <long>();
foreach (var auditLog in auditLogsFromRepo)
{
// Extract form identifier
var formIdentifier = auditLog.Details.Replace("Form submission successful ", "");
// Locate patient
if (!string.IsNullOrWhiteSpace(formIdentifier))
{
var attachments = _attachmentRepository.List(a => a.Patient != null && a.Description == formIdentifier);
if (attachments.Count > 0)
{
var patient = attachments.First()?.Patient;
if (patient != null)
{
returnIds.Add(patient.Id);
}
}
}
}
return(returnIds);
}
return(null);
}
/// <summary>
/// Get risk factors from repository and auto map to Dto
/// </summary>
/// <typeparam name="T">Identifier or detail Dto</typeparam>
/// <param name="riskFactorResourceParameters">Standard parameters for representing resource</param>
/// <returns></returns>
private PagedCollection <T> GetRiskFactors <T>(IdResourceParameters riskFactorResourceParameters) where T : class
{
var pagingInfo = new PagingInfo()
{
PageNumber = riskFactorResourceParameters.PageNumber,
PageSize = riskFactorResourceParameters.PageSize
};
var orderby = Extensions.GetOrderBy <RiskFactor>(riskFactorResourceParameters.OrderBy, "asc");
var predicate = PredicateBuilder.New <RiskFactor>(true);
predicate = predicate.And(f => f.Active);
var pagedRiskFactorsFromRepo = _riskFactorRepository.List(pagingInfo, predicate, orderby, "");
if (pagedRiskFactorsFromRepo != null)
{
// Map EF entity to Dto
var mappedRiskFactors = PagedCollection <T> .Create(_mapper.Map <PagedCollection <T> >(pagedRiskFactorsFromRepo),
pagingInfo.PageNumber,
pagingInfo.PageSize,
pagedRiskFactorsFromRepo.TotalCount);
// Prepare pagination data for response
var paginationMetadata = new
{
totalCount = mappedRiskFactors.TotalCount,
pageSize = mappedRiskFactors.PageSize,
currentPage = mappedRiskFactors.CurrentPage,
totalPages = mappedRiskFactors.TotalPages,
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
// Add HATEOAS links to each individual resource
mappedRiskFactors.ForEach(dto => CreateLinksForRiskFactor(dto));
return(mappedRiskFactors);
}
return(null);
}
private async Task <LinkedCollectionResourceWrapperDto <ReportInstanceDetailDto> > GetReportInstancesAsync(
Guid workFlowGuid,
int pageNumber,
int pageSize,
string qualifiedName)
{
var pagingInfo = new PagingInfo()
{
PageNumber = pageNumber,
PageSize = pageSize
};
var orderby = Extensions.GetOrderBy <ReportInstance>("Created", "desc");
var predicate = await PreparePredicateForFilter(workFlowGuid, qualifiedName);
var pagedReportsFromRepo = _reportInstanceRepository.List(pagingInfo, predicate, orderby, new string[] { "WorkFlow", "Medications", "TerminologyMedDra", "Activities.CurrentStatus", "Activities.ExecutionEvents.ExecutionStatus", "Tasks" });
if (pagedReportsFromRepo != null)
{
// Map EF entity to Dto
var mappedReportsWithLinks = new List <ReportInstanceDetailDto>();
foreach (var pagedReport in pagedReportsFromRepo)
{
var mappedReport = _mapper.Map <ReportInstanceDetailDto>(pagedReport);
await CustomMapAsync(pagedReport, mappedReport);
await CreateLinksAsync(pagedReport, mappedReport);
mappedReportsWithLinks.Add(mappedReport);
}
var wrapper = new LinkedCollectionResourceWrapperDto <ReportInstanceDetailDto>(pagedReportsFromRepo.TotalCount, mappedReportsWithLinks, pagedReportsFromRepo.TotalPages);
CreateLinksForReportInstances(workFlowGuid, wrapper, "Created", "", DateTime.MinValue, DateTime.MaxValue, pageNumber, pageSize,
pagedReportsFromRepo.HasNext, pagedReportsFromRepo.HasPrevious);
return(wrapper);
}
return(null);
}
/// <summary>
/// Get lab results from repository and auto map to Dto
/// </summary>
/// <typeparam name="T">Identifier or detail Dto</typeparam>
/// <param name="configResourceParameters">Standard parameters for representing resource</param>
/// <returns></returns>
private PagedCollection <T> GetConfigs <T>(ConfigResourceParameters configResourceParameters) where T : class
{
var pagingInfo = new PagingInfo()
{
PageNumber = configResourceParameters.PageNumber,
PageSize = configResourceParameters.PageSize
};
var orderby = Extensions.GetOrderBy <Config>(configResourceParameters.OrderBy, "asc");
var pagedConfigsFromRepo = _configRepository.List(pagingInfo, null, orderby, "");
if (pagedConfigsFromRepo != null)
{
// Map EF entity to Dto
var mappedConfigs = PagedCollection <T> .Create(_mapper.Map <PagedCollection <T> >(pagedConfigsFromRepo),
pagingInfo.PageNumber,
pagingInfo.PageSize,
pagedConfigsFromRepo.TotalCount);
// Prepare pagination data for response
var paginationMetadata = new
{
totalCount = mappedConfigs.TotalCount,
pageSize = mappedConfigs.PageSize,
currentPage = mappedConfigs.CurrentPage,
totalPages = mappedConfigs.TotalPages,
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
// Add HATEOAS links to each individual resource
mappedConfigs.ForEach(dto => CreateLinksForConfig(dto));
return(mappedConfigs);
}
return(null);
}
/// <summary>
/// Get meta tables from repository and auto map to Dto
/// </summary>
/// <typeparam name="T">Identifier or detail Dto</typeparam>
/// <param name="metaResourceParameters">Standard parameters for representing resource</param>
/// <returns></returns>
PagedCollection <T> GetMetaReports <T>(IdResourceParameters metaResourceParameters) where T : class
{
var pagingInfo = new PagingInfo()
{
PageNumber = metaResourceParameters.PageNumber,
PageSize = metaResourceParameters.PageSize
};
var orderby = Extensions.GetOrderBy <MetaReport>(metaResourceParameters.OrderBy, "asc");
var reportdMetaReportsFromRepo = _metaReportRepository.List(pagingInfo, null, orderby, "");
if (reportdMetaReportsFromRepo != null)
{
// Map EF entity to Dto
var mappedMetaReports = PagedCollection <T> .Create(_mapper.Map <PagedCollection <T> >(reportdMetaReportsFromRepo),
pagingInfo.PageNumber,
pagingInfo.PageSize,
reportdMetaReportsFromRepo.TotalCount);
// Prepare pagination data for response
var paginationMetadata = new
{
totalCount = mappedMetaReports.TotalCount,
reportSize = mappedMetaReports.PageSize,
currentReport = mappedMetaReports.CurrentPage,
totalReports = mappedMetaReports.TotalPages,
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
// Add HATEOAS links to each individual resource
//mappedMetaTables.ForEach(dto => CreateLinksForMetaTable(dto));
return(mappedMetaReports);
}
return(null);
}
private async Task <LinkedCollectionResourceWrapperDto <ReportInstanceDetailDto> > GetReportInstancesAsync(
Guid workFlowGuid,
int pageNumber,
int pageSize,
string qualifiedName)
{
var pagingInfo = new PagingInfo()
{
PageNumber = pageNumber,
PageSize = pageSize
};
var orderby = Extensions.GetOrderBy <ReportInstance>("Created", "desc");
// Filter list
var predicate = PredicateBuilder.New <ReportInstance>(true);
predicate = predicate.And(r => r.WorkFlow.WorkFlowGuid == workFlowGuid);
if (!String.IsNullOrWhiteSpace(qualifiedName))
{
switch (qualifiedName)
{
case "Confirm Report Data":
predicate = predicate.And(f => f.Activities.Any(a => a.QualifiedName == qualifiedName && a.Current == true && a.CurrentStatus.Description != "DELETED"));
break;
case "Extract E2B":
predicate = predicate.And(f => f.Activities.Any(a => a.QualifiedName == qualifiedName && a.Current == true && a.CurrentStatus.Description != "E2BSUBMITTED"));
break;
default:
predicate = predicate.And(f => f.Activities.Any(a => a.QualifiedName == qualifiedName && a.Current == true));
break;
}
}
else
{
(DateTime searchFrom, DateTime searchTo) = await PrepareComparisonDateRangeAsync();
predicate = predicate.And(f => f.Created >= searchFrom && f.Created <= searchTo);
}
var pagedReportsFromRepo = _reportInstanceRepository.List(pagingInfo, predicate, orderby, new string[] { "WorkFlow", "Medications", "TerminologyMedDra", "Activities.CurrentStatus", "Activities.ExecutionEvents.ExecutionStatus", "Activities.ExecutionEvents.Attachments", "Tasks" });
if (pagedReportsFromRepo != null)
{
// Map EF entity to Dto
var mappedReportsWithLinks = new List <ReportInstanceDetailDto>();
foreach (var pagedReport in pagedReportsFromRepo)
{
var mappedReport = _mapper.Map <ReportInstanceDetailDto>(pagedReport);
await CustomMapAsync(pagedReport, mappedReport);
await CreateLinksAsync(pagedReport, mappedReport);
mappedReportsWithLinks.Add(mappedReport);
}
var wrapper = new LinkedCollectionResourceWrapperDto <ReportInstanceDetailDto>(pagedReportsFromRepo.TotalCount, mappedReportsWithLinks, pagedReportsFromRepo.TotalPages);
CreateLinksForReportInstances(workFlowGuid, wrapper, "Created", "", DateTime.MinValue, DateTime.MaxValue, pageNumber, pageSize,
pagedReportsFromRepo.HasNext, pagedReportsFromRepo.HasPrevious);
return(wrapper);
}
return(null);
}
/// <summary>
/// Get auditLogs from repository and auto map to Dto
/// </summary>
/// <typeparam name="T">Identifier or detail Dto</typeparam>
/// <param name="auditLogResourceParameters">Standard parameters for representing resource</param>
/// <returns></returns>
private PagedCollection <T> GetAuditLogs <T>(AuditLogResourceParameters auditLogResourceParameters) where T : class
{
var pagingInfo = new PagingInfo()
{
PageNumber = auditLogResourceParameters.PageNumber,
PageSize = auditLogResourceParameters.PageSize
};
var orderby = Extensions.GetOrderBy <AuditLog>(auditLogResourceParameters.OrderBy, "asc");
// FIlter audit logs
var predicate = PredicateBuilder.New <AuditLog>(true);
predicate = predicate.And(au => au.ActionDate >= auditLogResourceParameters.SearchFrom && au.ActionDate <= auditLogResourceParameters.SearchTo);
switch (auditLogResourceParameters.AuditType)
{
case AuditTypeFilter.SubscriberAccess:
predicate = predicate.And(au => au.AuditType == AuditType.InvalidSubscriberAccess || au.AuditType == AuditType.ValidSubscriberAccess);
break;
case AuditTypeFilter.SubscriberPost:
predicate = predicate.And(au => au.AuditType == AuditType.InValidSubscriberPost || au.AuditType == AuditType.ValidSubscriberPost);
break;
case AuditTypeFilter.MeddraImport:
predicate = predicate.And(au => au.AuditType == AuditType.InValidMedDRAImport || au.AuditType == AuditType.ValidMedDRAImport);
break;
case AuditTypeFilter.UserLogin:
predicate = predicate.And(au => au.AuditType == AuditType.UserLogin);
break;
case AuditTypeFilter.SynchronisationSuccessful:
predicate = predicate.And(au => au.AuditType == AuditType.SynchronisationForm);
break;
case AuditTypeFilter.SynchronisationError:
predicate = predicate.And(au => au.AuditType == AuditType.SynchronisationError);
break;
case AuditTypeFilter.DataValidation:
predicate = predicate.And(au => au.AuditType == AuditType.DataValidation);
break;
}
if (auditLogResourceParameters.FacilityId > 0)
{
predicate = predicate.And(au => au.User.Facilities.Any(uf => uf.Facility.Id == auditLogResourceParameters.FacilityId));
}
var pagedAuditLogsFromRepo = _auditLogRepository.List(pagingInfo, predicate, orderby, new string[] { "User" });
if (pagedAuditLogsFromRepo != null)
{
// Map EF entity to Dto
var mappedAuditLogs = PagedCollection <T> .Create(_mapper.Map <PagedCollection <T> >(pagedAuditLogsFromRepo),
pagingInfo.PageNumber,
pagingInfo.PageSize,
pagedAuditLogsFromRepo.TotalCount);
// Prepare pagination data for response
var paginationMetadata = new
{
totalCount = mappedAuditLogs.TotalCount,
pageSize = mappedAuditLogs.PageSize,
currentPage = mappedAuditLogs.CurrentPage,
totalPages = mappedAuditLogs.TotalPages,
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
// Add HATEOAS links to each individual resource
mappedAuditLogs.ForEach(dto => CreateLinksForAuditLog(dto));
return(mappedAuditLogs);
}
return(null);
}
/// <summary>
/// Retrieves all selection data.
/// </summary>
/// <returns></returns>
public ICollection <SelectionDataItem> RetrieveAllSelectionData()
{
return(_selectionDataItemRepository.List());
}
/// <summary>
/// Get meddra terms from repository and auto map to Dto
/// </summary>
/// <typeparam name="T">Identifier or detail Dto</typeparam>
/// <param name="meddraTermResourceParameters">Standard parameters for representing resource</param>
/// <returns></returns>
private PagedCollection <T> GetMeddraTerms <T>(MeddraTermResourceParameters meddraTermResourceParameters) where T : class
{
var pagingInfo = new PagingInfo()
{
PageNumber = meddraTermResourceParameters.PageNumber,
PageSize = meddraTermResourceParameters.PageSize
};
var orderby = Extensions.GetOrderBy <TerminologyMedDra>(meddraTermResourceParameters.OrderBy, "asc");
var predicate = PredicateBuilder.New <TerminologyMedDra>(true);
if (!String.IsNullOrWhiteSpace(meddraTermResourceParameters.TermType))
{
predicate = predicate.And(mt => mt.MedDraTermType == meddraTermResourceParameters.TermType);
}
if (!String.IsNullOrWhiteSpace(meddraTermResourceParameters.ParentSearchTerm))
{
predicate = predicate.And(mt => mt.Parent.MedDraTerm.Contains(meddraTermResourceParameters.ParentSearchTerm));
}
if (!String.IsNullOrWhiteSpace(meddraTermResourceParameters.SearchTerm))
{
predicate = predicate.And(mt => mt.MedDraTerm.Contains(meddraTermResourceParameters.SearchTerm));
}
if (!String.IsNullOrWhiteSpace(meddraTermResourceParameters.SearchCode))
{
predicate = predicate.And(mt => mt.MedDraCode.Contains(meddraTermResourceParameters.SearchCode));
}
var pagedTermsFromRepo = _termsRepository.List(pagingInfo, predicate, orderby, new string[] {
"Children",
"Parent"
});
if (pagedTermsFromRepo != null)
{
// Map EF entity to Dto
var mappedTerms = PagedCollection <T> .Create(_mapper.Map <PagedCollection <T> >(pagedTermsFromRepo),
pagingInfo.PageNumber,
pagingInfo.PageSize,
pagedTermsFromRepo.TotalCount);
// Prepare pagination data for response
var paginationMetadata = new
{
totalCount = mappedTerms.TotalCount,
pageSize = mappedTerms.PageSize,
currentPage = mappedTerms.CurrentPage,
totalPages = mappedTerms.TotalPages,
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
// Add HATEOAS links to each individual resource
//mappedLabTests.ForEach(dto => CreateLinksForFacility(dto));
return(mappedTerms);
}
return(null);
}
private async Task CustomMapAsync(Encounter encounterFromRepo, EncounterExpandedDto mappedEncounter)
{
if (encounterFromRepo == null)
{
throw new ArgumentNullException(nameof(encounterFromRepo));
}
mappedEncounter.Patient = _mapper.Map <PatientDetailDto>(encounterFromRepo.Patient);
var datasetInstanceFromRepo = await _datasetInstanceRepository.GetAsync(di => di.Dataset.ContextType.Id == (int)ContextTypes.Encounter &&
di.ContextId == mappedEncounter.Id &&
di.EncounterTypeWorkPlan.EncounterType.Id == encounterFromRepo.EncounterType.Id
, new string[] { "Dataset.ContextType"
, "EncounterTypeWorkPlan.EncounterType"
, "Dataset.DatasetCategories.DatasetCategoryElements.DatasetCategory"
, "Dataset.DatasetCategories.DatasetCategoryElements.DatasetCategory"
, "Dataset.DatasetCategories.DatasetCategoryElements.DatasetElement.Field.FieldType"
, "Dataset.DatasetCategories.DatasetCategoryElements.DatasetElement.Field.FieldValues"
, "Dataset.DatasetCategories.DatasetCategoryElements.DatasetElement.DatasetElementSubs"
, "Dataset.DatasetCategories.DatasetCategoryElements.DatasetCategoryElementConditions"
, "DatasetInstanceValues" });
if (datasetInstanceFromRepo != null)
{
var groupedDatasetCategories = datasetInstanceFromRepo.Dataset.DatasetCategories
.SelectMany(dc => dc.DatasetCategoryElements).OrderBy(dc => dc.FieldOrder)
.GroupBy(dce => dce.DatasetCategory)
.ToList();
mappedEncounter.DatasetCategories = groupedDatasetCategories
.Select(dsc => new DatasetCategoryViewDto
{
DatasetCategoryId = dsc.Key.Id,
DatasetCategoryName = dsc.Key.DatasetCategoryName,
DatasetCategoryDisplayed = ShouldCategoryBeDisplayed(encounterFromRepo, dsc.Key),
DatasetElements = dsc.Select(element => new DatasetElementViewDto
{
DatasetElementId = element.DatasetElement.Id,
DatasetElementName = element.DatasetElement.ElementName,
DatasetElementDisplayName = element.FriendlyName ?? element.DatasetElement.ElementName,
DatasetElementHelp = element.Help,
DatasetElementDisplayed = ShouldElementBeDisplayed(encounterFromRepo, element),
DatasetElementChronic = IsElementChronic(encounterFromRepo, element),
DatasetElementSystem = element.DatasetElement.System,
DatasetElementType = element.DatasetElement.Field.FieldType.Description,
DatasetElementValue = datasetInstanceFromRepo.GetInstanceValue(element.DatasetElement.ElementName),
StringMaxLength = element.DatasetElement.Field.MaxLength,
NumericMinValue = element.DatasetElement.Field.MinSize,
NumericMaxValue = element.DatasetElement.Field.MaxSize,
Required = element.DatasetElement.Field.Mandatory,
SelectionDataItems = element.DatasetElement.Field.FieldValues.Select(fv => new SelectionDataItemDto()
{
SelectionKey = fv.Value, Value = fv.Value
}).ToList(),
DatasetElementSubs = element.DatasetElement.DatasetElementSubs.Select(elementSub => new DatasetElementSubViewDto
{
DatasetElementSubId = elementSub.Id,
DatasetElementSubName = elementSub.ElementName,
DatasetElementSubType = elementSub.Field.FieldType.Description
}).ToArray()
})
.ToArray()
})
.ToArray();
}
// Condition groups
int[] terms = _patientConditionRepository.List(pc => pc.Patient.Id == encounterFromRepo.Patient.Id && !pc.Archived && !pc.Patient.Archived, null, new string[] { "TerminologyMedDra" })
.Select(p => p.TerminologyMedDra.Id)
.ToArray();
List <PatientConditionGroupDto> groupArray = new List <PatientConditionGroupDto>();
foreach (var conditionMeddra in _conditionMeddraRepository.List(cm => terms.Contains(cm.TerminologyMedDra.Id), null, new string[] { "Condition" })
.ToList())
{
var tempCondition = conditionMeddra.GetConditionForPatient(encounterFromRepo.Patient);
if (tempCondition != null)
{
var group = new PatientConditionGroupDto()
{
ConditionGroup = conditionMeddra.Condition.Description,
Status = tempCondition.OutcomeDate != null ? "Case Closed" : "Case Open",
PatientConditionId = tempCondition.Id,
StartDate = tempCondition.OnsetDate.ToString("yyyy-MM-dd"),
Detail = $"{tempCondition.TerminologyMedDra.DisplayName} started on {tempCondition.OnsetDate.ToString("yyyy-MM-dd")}"
};
groupArray.Add(group);
}
}
mappedEncounter.ConditionGroups = groupArray;
// Weight history
mappedEncounter.WeightSeries = _patientService.GetElementValues(encounterFromRepo.Patient.Id, "Weight (kg)", 5);
// patient custom mapping
IExtendable patientExtended = encounterFromRepo.Patient;
var attribute = patientExtended.GetAttributeValue("Medical Record Number");
mappedEncounter.Patient.MedicalRecordNumber = attribute != null?attribute.ToString() : "";
}