/// <summary>
/// Adds criteria to the query (the 'where' clause).
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public virtual void AddCriteria(HqlProjectionQuery query, QueryBuilderArgs args)
{
QueryBuilderHelpers.AddCriteriaToQuery(HqlConstants.WorklistItemQualifier, args.Criteria, query, RemapHqlExpression);
// modify the query to workaround some NHibernate bugs
QueryBuilderHelpers.NHibernateBugWorkaround(query.Froms[0], query.Conditions, a => a);
}
public override void AddRootQuery(HqlProjectionQuery query, QueryBuilderArgs args)
{
base.AddRootQuery(query, args);
var from = query.Froms[0]; // this would be added by the base.AddWorklistRootQuery call
// join protocol object, because may have criteria on this object
from.Joins.Add(HqlConstants.JoinProtocol);
// check if we need to apply the "most recent step" condition
// this is essentially a workaround to avoid showing duplicates in some worklist results
// we can only apply this workaround when there is exactly one ps class specified
// fortunately, there are no use cases yet where more than one ps class is specified
// that require the workaround
if (args.ProcedureStepClasses.Length == 1)
{
var psClass = CollectionUtils.FirstElement(args.ProcedureStepClasses);
// the proc step class may be set to the more general "ProtocolProcedureStep" so
// we need to check for both
if (psClass == typeof(ProtocolAssignmentStep) || psClass == typeof(ProtocolProcedureStep))
{
// when querying for Rejected protocols, only show the most recent ProtocolAssignmentStep
// There may be many ProtocolAssignmentStep if a protocol is rejected, resubmitted and rejected again.
// For rejected protocols, the condition "pr.Status not in ('RJ')" is always false. So the max(EndTime) condition is used
// For non-rejected protocols, the first condition is always true, and the max(EndTime) condition is never used.
query.Conditions.Add(ConditionMostRecentProtocolAssignmentStepIfRejected);
}
}
}
private static HqlProjectionQuery GetBaseVisitPractitionerQuery(VisitSearchCriteria visitSearchCriteria, VisitPractitionerSearchCriteria practitionerSearchCriteria)
{
var hqlFrom = new HqlFrom(typeof(Visit).Name, "v");
hqlFrom.Joins.Add(new HqlJoin("v.Practitioners", "vp"));
var query = new HqlProjectionQuery(hqlFrom);
query.Conditions.AddRange(HqlCondition.FromSearchCriteria("vp", practitionerSearchCriteria));
query.Conditions.AddRange(HqlCondition.FromSearchCriteria("v", visitSearchCriteria));
return query;
}
private static HqlProjectionQuery GetBaseResultRecipientQuery(OrderSearchCriteria orderSearchCriteria, ResultRecipientSearchCriteria recipientSearchCriteria)
{
var hqlFrom = new HqlFrom(typeof(Order).Name, "o");
hqlFrom.Joins.Add(new HqlJoin("o.ResultRecipients", "rr"));
var query = new HqlProjectionQuery(hqlFrom);
query.Conditions.AddRange(HqlCondition.FromSearchCriteria("rr", recipientSearchCriteria));
query.Conditions.AddRange(HqlCondition.FromSearchCriteria("o", orderSearchCriteria));
return query;
}
/// <summary>
/// Adds the specified ordering to the specified query, pre-pending the specified qualifier.
/// </summary>
/// <param name="qualifier"></param>
/// <param name="query"></param>
/// <param name="criteria"></param>
/// <param name="remapHqlExprFunction"></param>
/// <remarks>
/// All HQL dot expressions are passed through the <paramref name="remapHqlExprFunction"/>, allowing the expression
/// to be modified prior to be added to the query.
/// </remarks>
public static void AddOrderingToQuery(string qualifier, HqlProjectionQuery query, WorklistItemSearchCriteria[] criteria,
Converter<string, string> remapHqlExprFunction)
{
// use the sorting information from the first WorklistItemSearchCriteria object only
// (the assumption is that they are all identical)
var c = CollectionUtils.FirstElement(criteria);
if (c == null)
return;
var sorts = HqlSort.FromSearchCriteria(qualifier, c, remapHqlExprFunction);
query.Sorts.AddRange(sorts);
}
public IList<ConfigurationDocument> Find(ConfigurationDocumentSearchCriteria documentCriteria, ConfigurationDocumentBodySearchCriteria bodyCriteria, SearchResultPage page)
{
var hqlFrom = new HqlFrom(typeof(ConfigurationDocument).Name, "doc");
hqlFrom.Joins.Add(new HqlJoin("doc.Body", "body"));
var query = new HqlProjectionQuery(hqlFrom);
query.Selects.Add(new HqlSelect("doc"));
query.Conditions.AddRange(HqlCondition.FromSearchCriteria("doc", documentCriteria));
query.Conditions.AddRange(HqlCondition.FromSearchCriteria("body", bodyCriteria));
query.Page = page;
return ExecuteHql<ConfigurationDocument>(query);
}
/// <summary>
/// Adds the specified criteria to the specified query, pre-pending the specified qualifier.
/// </summary>
/// <param name="qualifier"></param>
/// <param name="criteria"></param>
/// <param name="query"></param>
/// <param name="remapHqlExprFunction"></param>
/// <remarks>
/// All HQL dot expressions are passed through the <paramref name="remapHqlExprFunction"/>, allowing the expression
/// to be modified prior to be added to the query.
/// </remarks>
public static void AddCriteriaToQuery(string qualifier, WorklistItemSearchCriteria[] criteria, HqlProjectionQuery query,
Converter<string, string> remapHqlExprFunction)
{
var or = new HqlOr();
foreach (var c in criteria)
{
if(c.IsEmpty)
continue;
var conditions = HqlCondition.FromSearchCriteria(qualifier, c, remapHqlExprFunction);
var and = new HqlAnd(conditions);
if (and.Conditions.Count > 0)
or.Conditions.Add(and);
}
if (or.Conditions.Count > 0)
query.Conditions.Add(or);
}
/// <summary>
/// Establishes the root query (the 'from' clause and any 'join' clauses).
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public override void AddRootQuery(HqlProjectionQuery query, QueryBuilderArgs args)
{
var procedureStepClasses = args.ProcedureStepClasses;
// if we have 1 procedure step class, we can say "from x"
// otherwise we need to say "from ProcedureStep where ps.class = ..."
if (procedureStepClasses.Length == 1)
{
var procStepClass = CollectionUtils.FirstElement(procedureStepClasses);
query.Froms.Add(new HqlFrom(procStepClass.Name, "ps", WorklistJoins));
}
else
{
// either 0 or > 1 classes were specified
query.Froms.Add(new HqlFrom(typeof(ProcedureStep).Name, "ps", WorklistJoins));
if(procedureStepClasses.Length > 1)
{
query.Conditions.Add(HqlCondition.IsOfClass("ps", procedureStepClasses));
}
}
}
public override void AddRootQuery(HqlProjectionQuery query, QueryBuilderArgs args)
{
base.AddRootQuery(query, args);
var from = query.Froms[0]; // added by base.AddRootQuery
// join report/report part object, because may have criteria or projections on this object
from.Joins.Add(HqlConstants.JoinReportPart);
from.Joins.Add(HqlConstants.JoinReport);
// check if we need to apply the "most recent step" condition
// this is essentially a workaround to avoid showing duplicates in some worklist results
// we can only apply this workaround when there is exactly one ps class specified
// fortunately, there are no use cases yet where more than one ps class is specified
// that require the workaround
if (args.ProcedureStepClasses.Length == 1)
{
var psClass = CollectionUtils.FirstElement(args.ProcedureStepClasses);
if (psClass == typeof(PublicationStep))
query.Conditions.Add(ConditionMostRecentPublicationStep);
if (psClass == typeof(TranscriptionStep))
query.Conditions.Add(ConditionMostRecentTranscriptionStep);
}
}
/// <summary>
/// Constrains the patient profile to match the performing facility.
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public override void AddConstrainPatientProfile(HqlProjectionQuery query, QueryBuilderArgs args)
{
// constrain patient profile to performing facility
query.Conditions.Add(HqlConstants.ConditionConstrainPatientProfile);
}
/// <summary>
/// Adds worklist filters to the query (affects the 'from' clause).
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public virtual void AddFilters(HqlProjectionQuery query, WorklistQueryArgs args)
{
QueryBuilderHelpers.AddCriteriaToQuery(HqlConstants.WorklistItemQualifier, args.FilterCriteria, query, RemapHqlExpression);
}
/// <summary>
/// Adds the "active procedure step" constraint (affects the 'from' clause).
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public void AddActiveProcedureStepConstraint(HqlProjectionQuery query, QueryBuilderArgs args)
{
query.Conditions.Add(HqlConstants.ConditionActiveProcedureStep);
}
/// <summary>
/// Establishes the root query (the 'from' clause and any 'join' clauses).
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public override void AddRootQuery(HqlProjectionQuery query, QueryBuilderArgs args)
{
query.Froms.Add(DefaultFrom);
// do not constrain patient profile
}
private List<OrderNoteboxItem> BuildOrderNoteboxItems(List<NoteboxItem> inboxItems)
{
if (inboxItems.Count == 0)
return new List<OrderNoteboxItem>();
// Get all the patients for all the items
var patients = CollectionUtils.Unique(CollectionUtils.Map<NoteboxItem, Patient>(inboxItems, item => item.Patient));
var patientQuery = new HqlProjectionQuery(new HqlFrom(typeof(PatientProfile).Name, "pp"));
var patientCriteria = new PatientProfileSearchCriteria();
patientCriteria.Patient.In(patients);
patientQuery.Conditions.AddRange(HqlCondition.FromSearchCriteria("pp", patientCriteria));
var profiles = ExecuteHql<PatientProfile>(patientQuery);
// Have to manually get the postings (and later their recipients) to work around a Hibernate fetch="subselect" issue.
// The subselect somehow removed the "top(100)" and "order by" clause. Making the query slow.
// Load all the postings for all the notes. There may be more than one postings per orderNote.
// Therefore it is inappropriate to just use the postings in the base query.
var notes = CollectionUtils.Unique(CollectionUtils.Map<NoteboxItem, Note>(inboxItems, item => item.Note));
var postingQuery = new HqlProjectionQuery(new HqlFrom(typeof(NotePosting).Name, "np"));
var postingCriteria = new NotePostingSearchCriteria();
postingCriteria.Note.In(notes);
postingQuery.Conditions.AddRange(HqlCondition.FromSearchCriteria("np", postingCriteria));
postingQuery.Froms[0].Joins.Add(new HqlJoin("np.Recipient", null, HqlJoinMode.Left, true));
var postings = ExecuteHql<NotePosting>(postingQuery);
// Build order notebox items
var orderNoteboxItems = CollectionUtils.Map(inboxItems,
delegate(NoteboxItem item)
{
// Find the appropriate patient profile based on OrderingFacility
var profile = CollectionUtils.SelectFirst(profiles,
pp => pp.Patient.Equals(item.Patient)
&& pp.Mrn.AssigningAuthority.Code.Equals(item.OrderingFacilityInformationAuthority.Code));
// Find all the recipients
var postingsForThisNote = CollectionUtils.Select(postings, np => np.Note.Equals(item.Note));
var recipients = CollectionUtils.Map<NotePosting, object>(postingsForThisNote,
posting => posting is StaffNotePosting
? (object)((StaffNotePosting)posting).Recipient
: (object)((GroupNotePosting)posting).Recipient);
return new OrderNoteboxItem(item.Note, item.Order, item.Patient, profile, item.Author, recipients,
item.DiagnosticServiceName, item.NotePostingAcknowledged);
});
return orderNoteboxItems;
}
/// <summary>
/// Constrains the patient profile to match the performing facility.
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public override void AddConstrainPatientProfile(HqlProjectionQuery query, QueryBuilderArgs args)
{
// calling this method on this class would not make any sense
throw new InvalidOperationException();
}
private static HqlProjectionQuery GetBaseQuery(INoteboxQueryContext nqc, bool countQuery,
string entityAlias, Type fromEntityType, HqlSelect[] itemProjection, HqlJoin[] itemJoins)
{
var joins = countQuery ? new HqlJoin[] { } : itemJoins;
var query = new HqlProjectionQuery(new HqlFrom(fromEntityType.Name, entityAlias, joins));
if (countQuery)
{
query.Selects.AddRange(CountProjection);
}
else
{
query.Selects.AddRange(itemProjection);
// need this in case orderNote was sent to staff and staffgroup containing same staff
//query.SelectDistinct = true;
// add paging if not a count query
query.Page = nqc.Page;
}
return query;
}
protected List<OrderNoteboxItem> DoQuery(HqlProjectionQuery query)
{
var list = ExecuteHql<object[]>(query);
var results = new List<NoteboxItem>();
foreach (var tuple in list)
{
var item = (NoteboxItem)Activator.CreateInstance(typeof(NoteboxItem), tuple);
results.Add(item);
}
return BuildOrderNoteboxItems(results);
}
/// <summary>
/// Establishes the root query (the 'from' clause and any 'join' clauses).
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public override void AddRootQuery(HqlProjectionQuery query, QueryBuilderArgs args)
{
query.Froms.Add(DefaultFrom);
}
/// <summary> /// Establishes the root query (the 'from' clause and any 'join' clauses). /// </summary> /// <param name="query"></param> /// <param name="args"></param> public abstract void AddRootQuery(HqlProjectionQuery query, QueryBuilderArgs args);
/// <summary> /// Constrains the patient profile to match the performing facility. /// </summary> /// <param name="query"></param> /// <param name="args"></param> public abstract void AddConstrainPatientProfile(HqlProjectionQuery query, QueryBuilderArgs args);
/// <summary>
/// Adds ordering to the query (the 'rder by' clause).
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public virtual void AddOrdering(HqlProjectionQuery query, QueryBuilderArgs args)
{
QueryBuilderHelpers.AddOrderingToQuery(HqlConstants.WorklistItemQualifier, query, args.Criteria, RemapHqlExpression);
}
/// <summary>
/// Adds a paging restriction to the query (the 'top' or 'limit' clause).
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public virtual void AddPagingRestriction(HqlProjectionQuery query, QueryBuilderArgs args)
{
query.Page = args.Page;
}
/// <summary>
/// Adds an item projection to the query (the 'select' clause).
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public virtual void AddItemProjection(HqlProjectionQuery query, QueryBuilderArgs args)
{
query.Selects.AddRange(GetWorklistItemSelects(args.Projection));
}
/// <summary>
/// Adds a count projection to the query (e.g. 'select count(*)').
/// </summary>
/// <param name="query"></param>
/// <param name="args"></param>
public virtual void AddCountProjection(HqlProjectionQuery query, QueryBuilderArgs args)
{
query.Selects.AddRange(HqlConstants.DefaultCountProjection);
}