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() : ""; }