private bool ShouldIncludeDegeneratePatientItems(WorklistItemTextQueryRequest request)
{
// include degenerate patient items iff
// 1) degen procedure items are being included, and
// 2) advanced search is not being used, or it is being used and all non-patient search criteria are empty
return(ShouldIncludeDegenerateProcedureItems(request) &&
(!request.UseAdvancedSearch || request.SearchFields.IsNonPatientFieldsEmpty()));
}
private bool ShouldIncludeDegenerateProcedureItems(WorklistItemTextQueryRequest request)
{
// generally, if the search query is being used on patients/orders, then it makes sense to include
// degenerate procedure items
// conversely, if this flag is not present, then including degenerate items could result in an open query
// on the entire database which would obviously not be desirable
return((_options & WorklistItemTextQueryOptions.PatientOrder) == WorklistItemTextQueryOptions.PatientOrder);
}
private List <WorklistItemSearchCriteria> BuildTextQueryStaffSearchCriteria(WorklistItemTextQueryRequest request)
{
var query = request.TextQuery;
// this will hold all criteria
var criteria = new List <WorklistItemSearchCriteria>();
// build criteria against names
var names = ParsePersonNames(query);
// scheduled performer
criteria.AddRange(CollectionUtils.Map(names,
delegate(PersonName n)
{
var sc = new WorklistItemSearchCriteria();
var scheduledPerformerNameCriteria = sc.ProcedureStep.Scheduling.Performer.Staff.Name;
ApplyStringCriteria(scheduledPerformerNameCriteria.FamilyName, n.FamilyName);
ApplyStringCriteria(scheduledPerformerNameCriteria.GivenName, n.GivenName);
return(sc);
}));
// actual performer
criteria.AddRange(CollectionUtils.Map(names,
delegate(PersonName n)
{
var sc = new WorklistItemSearchCriteria();
var performerNameCriteria = sc.ProcedureStep.Performer.Staff.Name;
ApplyStringCriteria(performerNameCriteria.FamilyName, n.FamilyName);
ApplyStringCriteria(performerNameCriteria.GivenName, n.GivenName);
return(sc);
}));
// build criteria against Staff ID identifiers
// bug #3952: use ParseTerms instead of ParseIdentifiers, because a Staff ID might only contain letters
var ids = ParseTerms(query);
// scheduled performer
criteria.AddRange(CollectionUtils.Map(ids,
delegate(string id)
{
var sc = new WorklistItemSearchCriteria();
ApplyStringCriteria(sc.ProcedureStep.Scheduling.Performer.Staff.Id, id, ShouldUseExactMatchingOnIdentifiers(request));
return(sc);
}));
// actual performer
criteria.AddRange(CollectionUtils.Map(ids,
delegate(string id)
{
var sc = new WorklistItemSearchCriteria();
ApplyStringCriteria(sc.ProcedureStep.Performer.Staff.Id, id, ShouldUseExactMatchingOnIdentifiers(request));
return(sc);
}));
return(criteria);
}
private IEnumerable <WorklistItemSearchCriteria> BuildStaffSearchCriteria(WorklistItemTextQueryRequest request)
{
if (request.UseAdvancedSearch)
{
// advanced search not supported here
throw new NotSupportedException();
}
return(BuildTextQueryStaffSearchCriteria(request));
}
public TextQueryResponse <ReportingWorklistItemSummary> SearchWorklists(WorklistItemTextQueryRequest request)
{
var assembler = new ReportingWorkflowAssembler();
var broker = this.PersistenceContext.GetBroker <IReportingWorklistItemBroker>();
return(SearchHelper <ReportingWorklistItem, ReportingWorklistItemSummary>(
request,
broker,
WorklistItemProjection.ReportingWorklistSearch,
item => assembler.CreateWorklistItemSummary(item, this.PersistenceContext)));
}
/// <summary>
/// Helper method that implements the logic for performing searches on worklists.
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <typeparam name="TSummary"></typeparam>
/// <param name="request"></param>
/// <param name="broker"></param>
/// <param name="projection"></param>
/// <param name="mapCallback"></param>
/// <returns></returns>
protected TextQueryResponse <TSummary> SearchHelper <TItem, TSummary>(
WorklistItemTextQueryRequest request,
IWorklistItemBroker broker,
WorklistItemProjection projection,
Converter <TItem, TSummary> mapCallback)
where TSummary : DataContractBase
where TItem : WorklistItem
{
var procedureStepClass = request.ProcedureStepClassName == null ? null
: ProcedureStep.GetSubClass(request.ProcedureStepClassName, PersistenceContext);
var helper = new WorklistItemTextQueryHelper <TItem, TSummary>(broker, mapCallback, procedureStepClass, projection, request.Options, PersistenceContext);
return(helper.Query(request));
}
protected static TextQueryResponse <TItem> DoQueryCore(WorklistSearchParams query, int specificityThreshold, WorklistItemTextQueryOptions options, string procedureStepClassName)
{
TextQueryResponse <TItem> response = null;
var request = new WorklistItemTextQueryRequest(
query.TextSearch, specificityThreshold, procedureStepClassName, options);
if (query.UseAdvancedSearch)
{
request.UseAdvancedSearch = query.UseAdvancedSearch;
request.SearchFields = query.SearchFields;
}
Platform.GetService <TWorklistService>(
service => response = service.SearchWorklists(request));
return(response);
}
public TextQueryResponse <ReportingWorklistItemSummary> SearchWorklists(WorklistItemTextQueryRequest request)
{
var procedureStepClass = request.ProcedureStepClassName == null ? null
: ProcedureStep.GetSubClass(request.ProcedureStepClassName, PersistenceContext);
// decide which broker/projection to use for searching
var isReporting = typeof(ReportingProcedureStep).IsAssignableFrom(procedureStepClass);
var broker = isReporting ?
(IWorklistItemBroker)PersistenceContext.GetBroker <IReportingWorklistItemBroker>()
: PersistenceContext.GetBroker <IProtocolWorklistItemBroker>();
var projection = isReporting ?
WorklistItemProjection.ReportingWorklistSearch :
WorklistItemProjection.ProtocolWorklistSearch;
var assembler = new ReportingWorkflowAssembler();
return(SearchHelper <ReportingWorklistItem, ReportingWorklistItemSummary>(
request,
broker,
projection,
item => assembler.CreateWorklistItemSummary(item, PersistenceContext)));
}
private bool ShouldUseExactMatchingOnIdentifiers(WorklistItemTextQueryRequest request)
{
// use exact matching if the option to enable partial matching is not specified
return(!((_options & WorklistItemTextQueryOptions.EnablePartialMatchingOnIdentifiers)
== WorklistItemTextQueryOptions.EnablePartialMatchingOnIdentifiers));
}
private List <WorklistItemSearchCriteria> BuildTextQueryProcedureSearchCriteria(WorklistItemTextQueryRequest request)
{
var query = request.TextQuery;
// this will hold all criteria
var criteria = new List <WorklistItemSearchCriteria>();
// build criteria against names
var names = ParsePersonNames(query);
criteria.AddRange(CollectionUtils.Map(names,
delegate(PersonName n)
{
var sc = new WorklistItemSearchCriteria();
ApplyStringCriteria(sc.PatientProfile.Name.FamilyName, n.FamilyName);
ApplyStringCriteria(sc.PatientProfile.Name.GivenName, n.GivenName);
return(sc);
}));
// build criteria against Mrn identifiers
var ids = ParseIdentifiers(query);
criteria.AddRange(CollectionUtils.Map(ids,
delegate(string word)
{
var c = new WorklistItemSearchCriteria();
ApplyStringCriteria(c.PatientProfile.Mrn.Id, word, ShouldUseExactMatchingOnIdentifiers(request));
return(c);
}));
// build criteria against Healthcard identifiers
criteria.AddRange(CollectionUtils.Map(ids,
delegate(string word)
{
var c = new WorklistItemSearchCriteria();
ApplyStringCriteria(c.PatientProfile.Healthcard.Id, word, ShouldUseExactMatchingOnIdentifiers(request));
return(c);
}));
// build criteria against Accession Number
criteria.AddRange(CollectionUtils.Map(ids,
delegate(string word)
{
var c = new WorklistItemSearchCriteria();
ApplyStringCriteria(c.Order.AccessionNumber, word, ShouldUseExactMatchingOnIdentifiers(request));
return(c);
}));
return(criteria);
}
private List <WorklistItemSearchCriteria> BuildAdvancedProcedureSearchCriteria(WorklistItemTextQueryRequest request)
{
Platform.CheckMemberIsSet(request.SearchFields, "SearchFields");
var searchParams = request.SearchFields;
var wheres = new List <WorklistItemSearchCriteria>();
// construct a base criteria object from the request values
var criteria = new WorklistItemSearchCriteria();
ApplyStringCriteria(criteria.PatientProfile.Mrn.Id, searchParams.Mrn, ShouldUseExactMatchingOnIdentifiers(request));
ApplyStringCriteria(criteria.PatientProfile.Name.FamilyName, searchParams.FamilyName);
ApplyStringCriteria(criteria.PatientProfile.Name.GivenName, searchParams.GivenName);
ApplyStringCriteria(criteria.PatientProfile.Healthcard.Id, searchParams.HealthcardNumber, ShouldUseExactMatchingOnIdentifiers(request));
ApplyStringCriteria(criteria.Order.AccessionNumber, searchParams.AccessionNumber, ShouldUseExactMatchingOnIdentifiers(request));
if (searchParams.OrderingPractitionerRef != null)
{
var orderedBy = _context.Load <ExternalPractitioner>(searchParams.OrderingPractitionerRef, EntityLoadFlags.Proxy);
criteria.Order.OrderingPractitioner.EqualTo(orderedBy);
}
if (searchParams.DiagnosticServiceRef != null)
{
var ds = _context.Load <DiagnosticService>(searchParams.DiagnosticServiceRef, EntityLoadFlags.Proxy);
criteria.Order.DiagnosticService.EqualTo(ds);
}
if (searchParams.ProcedureTypeRef != null)
{
var pt = _context.Load <ProcedureType>(searchParams.ProcedureTypeRef, EntityLoadFlags.Proxy);
criteria.Procedure.Type.EqualTo(pt);
}
if (searchParams.FromDate != null || searchParams.UntilDate != null)
{
// the goal here is to use the date-range in an approximate fashion, to search for procedures
// that were performed "around" that time-frame
// therefore, the date-range is applied to muliple dates, and these are OR'd
// use "day" resolution on the start and end times, because we don't care about time
var start = searchParams.FromDate == null ? null
: new WorklistTimePoint(searchParams.FromDate.Value, WorklistTimePoint.Resolutions.Day);
var end = searchParams.UntilDate == null ? null
: new WorklistTimePoint(searchParams.UntilDate.Value, WorklistTimePoint.Resolutions.Day);
var dateRange = new WorklistTimeRange(start, end);
var now = Platform.Time;
var procSchedDateCriteria = (WorklistItemSearchCriteria)criteria.Clone();
dateRange.Apply((ISearchCondition)procSchedDateCriteria.Procedure.ScheduledStartTime, now);
wheres.Add(procSchedDateCriteria);
var procStartDateCriteria = (WorklistItemSearchCriteria)criteria.Clone();
dateRange.Apply((ISearchCondition)procStartDateCriteria.Procedure.StartTime, now);
wheres.Add(procStartDateCriteria);
var procEndDateCriteria = (WorklistItemSearchCriteria)criteria.Clone();
dateRange.Apply((ISearchCondition)procEndDateCriteria.Procedure.EndTime, now);
wheres.Add(procEndDateCriteria);
}
else
{
// no date range, so just need a single criteria
wheres.Add(criteria);
}
return(wheres);
}
private List <WorklistItemSearchCriteria> BuildProcedureSearchCriteria(WorklistItemTextQueryRequest request)
{
return(request.UseAdvancedSearch ?
BuildAdvancedProcedureSearchCriteria(request) : BuildTextQueryProcedureSearchCriteria(request));
}
