public ListProcedureTypesResponse ListProcedureTypes(ListProcedureTypesRequest request)
{
Platform.CheckForNullReference(request, "request");
var where = new ProcedureTypeSearchCriteria();
where.Id.SortAsc(0);
if (!string.IsNullOrEmpty(request.Id))
{
where.Id.StartsWith(request.Id);
}
if (!string.IsNullOrEmpty(request.Name))
{
where.Name.Like(string.Format("%{0}%", request.Name));
}
if (!request.IncludeDeactivated)
{
where.Deactivated.EqualTo(false);
}
var broker = PersistenceContext.GetBroker <IProcedureTypeBroker>();
var items = broker.Find(where, request.Page);
var assembler = new ProcedureTypeAssembler();
return(new ListProcedureTypesResponse(CollectionUtils.Map(items, (ProcedureType item) => assembler.CreateSummary(item))));
}
public TextQueryResponse<ProcedureTypeSummary> TextQuery(TextQueryRequest request)
{
var broker = PersistenceContext.GetBroker<IProcedureTypeBroker>();
var assembler = new ProcedureTypeAssembler();
var helper = new TextQueryHelper<ProcedureType, ProcedureTypeSearchCriteria, ProcedureTypeSummary>(
delegate
{
var rawQuery = request.TextQuery;
IList<string> terms = TextQueryHelper.ParseTerms(rawQuery);
var criteria = new List<ProcedureTypeSearchCriteria>();
// allow matching on name (assume entire query is a name which may contain spaces)
var nameCriteria = new ProcedureTypeSearchCriteria();
nameCriteria.Name.StartsWith(rawQuery);
criteria.Add(nameCriteria);
// allow matching of any term against ID
criteria.AddRange(CollectionUtils.Map(terms,
delegate(string term)
{
var c = new ProcedureTypeSearchCriteria();
c.Id.StartsWith(term);
return c;
}));
return criteria.ToArray();
},
assembler.CreateSummary,
(criteria, threshold) => broker.Count(criteria) <= threshold,
broker.Find);
return helper.Query(request);
}
protected override IList <ProcedureType> GetItemsForExport(IReadContext context, int firstRow, int maxRows)
{
var where = new ProcedureTypeSearchCriteria();
where.Id.SortAsc(0);
return(context.GetBroker <IProcedureTypeBroker>().Find(where, new SearchResultPage(firstRow, maxRows)));
}
public TextQueryResponse <ProcedureTypeSummary> TextQuery(TextQueryRequest request)
{
var broker = PersistenceContext.GetBroker <IProcedureTypeBroker>();
var assembler = new ProcedureTypeAssembler();
var helper = new TextQueryHelper <ProcedureType, ProcedureTypeSearchCriteria, ProcedureTypeSummary>(
delegate
{
var rawQuery = request.TextQuery;
IList <string> terms = TextQueryHelper.ParseTerms(rawQuery);
var criteria = new List <ProcedureTypeSearchCriteria>();
// allow matching on name (assume entire query is a name which may contain spaces)
var nameCriteria = new ProcedureTypeSearchCriteria();
nameCriteria.Name.StartsWith(rawQuery);
criteria.Add(nameCriteria);
// allow matching of any term against ID
criteria.AddRange(CollectionUtils.Map(terms,
delegate(string term)
{
var c = new ProcedureTypeSearchCriteria();
c.Id.StartsWith(term);
return(c);
}));
return(criteria.ToArray());
},
assembler.CreateSummary,
(criteria, threshold) => broker.Count(criteria) <= threshold,
broker.Find);
return(helper.Query(request));
}
/// <summary>
/// Applies this filter to the specified criteria object.
/// </summary>
/// <param name="criteria"></param>
/// <param name="wqc"></param>
public void Apply(ProcedureTypeSearchCriteria criteria, IWorklistQueryContext wqc)
{
if (!this.IsEnabled)
{
return;
}
criteria.In(this.Values);
}
public LoadDiagnosticServiceEditorFormDataResponse LoadDiagnosticServiceEditorFormData(LoadDiagnosticServiceEditorFormDataRequest request)
{
ProcedureTypeSearchCriteria where = new ProcedureTypeSearchCriteria();
where.Id.SortAsc(0);
where.Deactivated.EqualTo(false);
IList <ProcedureType> procTypes = PersistenceContext.GetBroker <IProcedureTypeBroker>().Find(where);
ProcedureTypeAssembler assembler = new ProcedureTypeAssembler();
return(new LoadDiagnosticServiceEditorFormDataResponse(
CollectionUtils.Map <ProcedureType, ProcedureTypeSummary>(procTypes,
delegate(ProcedureType pt) { return assembler.CreateSummary(pt); })));
}
/// <summary>
/// Applies this filter to the specified criteria object.
/// </summary>
/// <param name="criteria"></param>
/// <param name="wqc"></param>
public void Apply(ProcedureTypeSearchCriteria criteria, IWorklistQueryContext wqc)
{
if (!this.IsEnabled)
{
return;
}
// TODO: this is pretty brute force and probably needs to be optimized with a custom broker
var procedureTypes = new List <ProcedureType>();
foreach (var procedureTypeGroup in this.Values)
{
procedureTypes.AddRange(procedureTypeGroup.ProcedureTypes);
}
criteria.In(CollectionUtils.Unique(procedureTypes));
}
public ListProcedureTypesResponse ListProcedureTypes(ListProcedureTypesRequest request)
{
Platform.CheckForNullReference(request, "request");
var where = new ProcedureTypeSearchCriteria();
where.Id.SortAsc(0);
if (!string.IsNullOrEmpty(request.Id))
where.Id.StartsWith(request.Id);
if (!string.IsNullOrEmpty(request.Name))
where.Name.Like(string.Format("%{0}%", request.Name));
if (!request.IncludeDeactivated)
where.Deactivated.EqualTo(false);
var broker = PersistenceContext.GetBroker<IProcedureTypeBroker>();
var items = broker.Find(where, request.Page);
var assembler = new ProcedureTypeAssembler();
return new ListProcedureTypesResponse(CollectionUtils.Map(items, (ProcedureType item) => assembler.CreateSummary(item)));
}
protected override void Import(ProcedureTypeGroupData data, IUpdateContext context)
{
ProcedureTypeGroup group = LoadOrCreateProcedureTypeGroup(data.Name, data.Class, context);
group.Description = data.Description;
if (data.ProcedureTypes != null)
{
foreach (ProcedureTypeData s in data.ProcedureTypes)
{
ProcedureTypeSearchCriteria where = new ProcedureTypeSearchCriteria();
where.Id.EqualTo(s.Id);
ProcedureType pt = CollectionUtils.FirstElement(context.GetBroker <IProcedureTypeBroker>().Find(where));
if (pt != null)
{
group.ProcedureTypes.Add(pt);
}
}
}
}
private static ProcedureType LoadOrCreateProcedureType(string id, string name, IPersistenceContext context)
{
ProcedureType pt;
try
{
// see if already exists in db
var where = new ProcedureTypeSearchCriteria();
where.Id.EqualTo(id);
pt = context.GetBroker <IProcedureTypeBroker>().FindOne(where);
}
catch (EntityNotFoundException)
{
// create it
pt = new ProcedureType(id, name);
context.Lock(pt, DirtyState.New);
}
return(pt);
}
protected override void Import(DiagnosticServiceData data, IUpdateContext context)
{
var ds = GetDiagnosticService(data.Id, data.Name, context);
ds.Deactivated = data.Deactivated;
ds.Name = data.Name;
if (data.ProcedureTypes != null)
{
foreach (var s in data.ProcedureTypes)
{
var where = new ProcedureTypeSearchCriteria();
where.Id.EqualTo(s.Id);
var pt = CollectionUtils.FirstElement(context.GetBroker <IProcedureTypeBroker>().Find(where));
if (pt != null)
{
ds.ProcedureTypes.Add(pt);
}
}
}
}
protected override void Import(WorklistData data, IUpdateContext context)
{
var worklist = LoadOrCreateWorklist(data.Name, data.Class, context);
worklist.Description = data.Description;
if (data.StaffSubscribers != null)
{
foreach (var s in data.StaffSubscribers)
{
var criteria = new StaffSearchCriteria();
criteria.Id.EqualTo(s.StaffId);
var staff = context.GetBroker <IStaffBroker>().Find(criteria);
if (staff.Count == 1)
{
worklist.StaffSubscribers.Add(CollectionUtils.FirstElement(staff));
}
}
}
if (data.GroupSubscribers != null)
{
foreach (var s in data.GroupSubscribers)
{
var criteria = new StaffGroupSearchCriteria();
criteria.Name.EqualTo(s.StaffGroupName);
var groups = context.GetBroker <IStaffGroupBroker>().Find(criteria);
if (groups.Count == 1)
{
worklist.GroupSubscribers.Add(CollectionUtils.FirstElement(groups));
}
}
}
// proc type filter
ImportFilter(
worklist.ProcedureTypeFilter,
data.Filters.ProcedureTypes,
delegate(WorklistData.ProcedureTypeData s)
{
var criteria = new ProcedureTypeSearchCriteria();
criteria.Id.EqualTo(s.Id);
var broker = context.GetBroker <IProcedureTypeBroker>();
return(CollectionUtils.FirstElement(broker.Find(criteria)));
});
// proc type group filter
ImportFilter(
worklist.ProcedureTypeGroupFilter,
data.Filters.ProcedureTypeGroups,
delegate(WorklistData.ProcedureTypeGroupData s)
{
var criteria = new ProcedureTypeGroupSearchCriteria();
criteria.Name.EqualTo(s.Name);
var broker = context.GetBroker <IProcedureTypeGroupBroker>();
return(CollectionUtils.FirstElement(broker.Find(criteria, ProcedureTypeGroup.GetSubClass(s.Class, context))));
});
//Bug #2284: don't forget to set the IncludeWorkingFacility property
// facility filter
worklist.FacilityFilter.IncludeWorkingFacility = data.Filters.Facilities.IncludeWorkingFacility;
ImportFilter(
worklist.FacilityFilter,
data.Filters.Facilities,
delegate(WorklistData.EnumValueData s)
{
var criteria = new FacilitySearchCriteria();
criteria.Code.EqualTo(s.Code);
var broker = context.GetBroker <IFacilityBroker>();
return(CollectionUtils.FirstElement(broker.Find(criteria)));
});
// department filter
ImportFilter(
worklist.DepartmentFilter,
data.Filters.Departments,
delegate(WorklistData.DepartmentData s)
{
var criteria = new DepartmentSearchCriteria();
criteria.Id.EqualTo(s.Id);
var broker = context.GetBroker <IDepartmentBroker>();
return(CollectionUtils.FirstElement(broker.Find(criteria)));
});
// priority filter
ImportFilter(
worklist.OrderPriorityFilter,
data.Filters.OrderPriorities,
delegate(WorklistData.EnumValueData s)
{
var broker = context.GetBroker <IEnumBroker>();
return(broker.Find <OrderPriorityEnum>(s.Code));
});
// ordering prac filter
ImportFilter(
worklist.OrderingPractitionerFilter,
data.Filters.OrderingPractitioners,
delegate(WorklistData.PractitionerData s)
{
var criteria = new ExternalPractitionerSearchCriteria();
criteria.Name.FamilyName.EqualTo(s.FamilyName);
criteria.Name.GivenName.EqualTo(s.GivenName);
// these criteria may not be provided (the data may not existed when exported),
// but if available, they help to ensure the correct practitioner is being mapped
if (!string.IsNullOrEmpty(s.BillingNumber))
{
criteria.BillingNumber.EqualTo(s.BillingNumber);
}
if (!string.IsNullOrEmpty(s.LicenseNumber))
{
criteria.LicenseNumber.EqualTo(s.LicenseNumber);
}
var broker = context.GetBroker <IExternalPractitionerBroker>();
return(CollectionUtils.FirstElement(broker.Find(criteria)));
});
// patient class filter
ImportFilter(
worklist.PatientClassFilter,
data.Filters.PatientClasses,
delegate(WorklistData.EnumValueData s)
{
var broker = context.GetBroker <IEnumBroker>();
return(broker.Find <PatientClassEnum>(s.Code));
});
// patient location filter
ImportFilter(
worklist.PatientLocationFilter,
data.Filters.PatientLocations,
delegate(WorklistData.LocationData s)
{
var criteria = new LocationSearchCriteria();
criteria.Id.EqualTo(s.Id);
var broker = context.GetBroker <ILocationBroker>();
return(CollectionUtils.FirstElement(broker.Find(criteria)));
});
// portable filter
worklist.PortableFilter.IsEnabled = data.Filters.Portable.Enabled;
worklist.PortableFilter.Value = data.Filters.Portable.Value;
//Bug #2429: don't forget to include the time filter
// time filter
worklist.TimeFilter.IsEnabled = data.Filters.TimeWindow.Enabled;
worklist.TimeFilter.Value = data.Filters.TimeWindow == null || data.Filters.TimeWindow.Value == null
? null
: data.Filters.TimeWindow.Value.CreateTimeRange();
// reporting filters
if (Worklist.GetSupportsReportingStaffRoleFilter(worklist.GetClass()))
{
ImportReportingWorklistFilters(data, worklist.As <ReportingWorklist>(), context);
}
}
public LoadDiagnosticServiceEditorFormDataResponse LoadDiagnosticServiceEditorFormData(LoadDiagnosticServiceEditorFormDataRequest request)
{
ProcedureTypeSearchCriteria where = new ProcedureTypeSearchCriteria();
where.Id.SortAsc(0);
where.Deactivated.EqualTo(false);
IList<ProcedureType> procTypes = PersistenceContext.GetBroker<IProcedureTypeBroker>().Find(where);
ProcedureTypeAssembler assembler = new ProcedureTypeAssembler();
return new LoadDiagnosticServiceEditorFormDataResponse(
CollectionUtils.Map<ProcedureType, ProcedureTypeSummary>(procTypes,
delegate(ProcedureType pt) { return assembler.CreateSummary(pt); }));
}
