private static ExternalPractitionerSearchCriteria[] GetMergeCandidatesCriteria(ExternalPractitioner practitioner)
{
var criteria = new List<ExternalPractitionerSearchCriteria>();
var baseCriteria = new ExternalPractitionerSearchCriteria();
baseCriteria.NotEqualTo(practitioner);
baseCriteria.Deactivated.EqualTo(false);
var nameCriteria = (ExternalPractitionerSearchCriteria)baseCriteria.Clone();
nameCriteria.Name.FamilyName.EqualTo(practitioner.Name.FamilyName);
nameCriteria.Name.GivenName.EqualTo(practitioner.Name.GivenName);
criteria.Add(nameCriteria);
if (!string.IsNullOrEmpty(practitioner.LicenseNumber))
{
var licenseNumberCriteria = (ExternalPractitionerSearchCriteria)baseCriteria.Clone();
licenseNumberCriteria.LicenseNumber.EqualTo(practitioner.LicenseNumber);
criteria.Add(licenseNumberCriteria);
}
if (!string.IsNullOrEmpty(practitioner.BillingNumber))
{
var billingNumberCriteria = (ExternalPractitionerSearchCriteria)baseCriteria.Clone();
billingNumberCriteria.BillingNumber.EqualTo(practitioner.BillingNumber);
criteria.Add(billingNumberCriteria);
}
return criteria.ToArray();
}
private static ExternalPractitionerSearchCriteria[] GetMergeCandidatesCriteria(ExternalPractitioner practitioner)
{
var criteria = new List <ExternalPractitionerSearchCriteria>();
var baseCriteria = new ExternalPractitionerSearchCriteria();
baseCriteria.NotEqualTo(practitioner);
baseCriteria.Deactivated.EqualTo(false);
var nameCriteria = (ExternalPractitionerSearchCriteria)baseCriteria.Clone();
nameCriteria.Name.FamilyName.EqualTo(practitioner.Name.FamilyName);
nameCriteria.Name.GivenName.EqualTo(practitioner.Name.GivenName);
criteria.Add(nameCriteria);
if (!string.IsNullOrEmpty(practitioner.LicenseNumber))
{
var licenseNumberCriteria = (ExternalPractitionerSearchCriteria)baseCriteria.Clone();
licenseNumberCriteria.LicenseNumber.EqualTo(practitioner.LicenseNumber);
criteria.Add(licenseNumberCriteria);
}
if (!string.IsNullOrEmpty(practitioner.BillingNumber))
{
var billingNumberCriteria = (ExternalPractitionerSearchCriteria)baseCriteria.Clone();
billingNumberCriteria.BillingNumber.EqualTo(practitioner.BillingNumber);
criteria.Add(billingNumberCriteria);
}
return(criteria.ToArray());
}
/// <summary>
/// Applies this filter to the specified criteria object.
/// </summary>
/// <param name="criteria"></param>
/// <param name="wqc"></param>
public void Apply(ExternalPractitionerSearchCriteria criteria, IWorklistQueryContext wqc)
{
if (!this.IsEnabled)
{
return;
}
criteria.In(this.Values);
}
protected override IList <ExternalPractitioner> GetItemsForExport(IReadContext context, int firstRow, int maxRows)
{
var where = new ExternalPractitionerSearchCriteria();
where.Name.FamilyName.SortAsc(0);
where.Name.GivenName.SortAsc(1);
where.Name.MiddleName.SortAsc(2);
where.LicenseNumber.SortAsc(3);
where.BillingNumber.SortAsc(4);
return(context.GetBroker <IExternalPractitionerBroker>().Find(where, new SearchResultPage(firstRow, maxRows)));
}
public TextQueryResponse <ExternalPractitionerSummary> TextQuery(TextQueryRequest request)
{
var broker = PersistenceContext.GetBroker <IExternalPractitionerBroker>();
var assembler = new ExternalPractitionerAssembler();
var helper = new TextQueryHelper <ExternalPractitioner, ExternalPractitionerSearchCriteria, ExternalPractitionerSummary>(
delegate
{
var rawQuery = request.TextQuery;
var criteria = new List <ExternalPractitionerSearchCriteria>();
// build criteria against names
var names = TextQueryHelper.ParsePersonNames(rawQuery);
criteria.AddRange(CollectionUtils.Map(names,
delegate(PersonName n)
{
var sc = new ExternalPractitionerSearchCriteria();
sc.Name.FamilyName.StartsWith(n.FamilyName);
if (n.GivenName != null)
{
sc.Name.GivenName.StartsWith(n.GivenName);
}
return(sc);
}));
// build criteria against identifiers
var ids = TextQueryHelper.ParseIdentifiers(rawQuery);
criteria.AddRange(CollectionUtils.Map(ids,
delegate(string word)
{
var c = new ExternalPractitionerSearchCriteria();
c.LicenseNumber.StartsWith(word);
return(c);
}));
return(criteria.ToArray());
},
prac => assembler.CreateExternalPractitionerSummary(prac, PersistenceContext),
(criteria, threshold) => broker.Count(criteria) <= threshold,
broker.Find);
return(helper.Query(request));
}
protected ExternalPractitioner GetPractitioner(string practitionerId)
{
if (practitionerId == null)
{
return(null);
}
ExternalPractitioner externalPractitioner = null;
var searchCriteria = new ExternalPractitionerSearchCriteria();
searchCriteria.LicenseNumber.EqualTo(practitionerId);
searchCriteria.Deactivated.EqualTo(false);
try
{
externalPractitioner = PersistenceContext.GetBroker <IExternalPractitionerBroker>().FindOne(searchCriteria);
}
catch (EntityNotFoundException)
{
}
return(externalPractitioner);
}
private ExternalPractitioner GetExternalPracitioner(string license, IEnumerable <ExternalPractitioner> importedEPs)
{
// if licenseId is not supplied, then assume the record does not exist
if (string.IsNullOrEmpty(license))
{
return(null);
}
var externalPractitioner = CollectionUtils.SelectFirst(importedEPs, ep => Equals(ep.LicenseNumber, license));
if (externalPractitioner == null)
{
var criteria = new ExternalPractitionerSearchCriteria();
criteria.LicenseNumber.EqualTo(license);
var broker = _context.GetBroker <IExternalPractitionerBroker>();
externalPractitioner = CollectionUtils.FirstElement(broker.Find(criteria));
}
return(externalPractitioner);
}
private static ExternalPractitioner LoadExternalPractitioner(string licenseNumber, string billingNumber, IPersistenceContext context)
{
ExternalPractitioner prac = null;
// if either license or billing number are supplied, check for an existing practitioner
if (!string.IsNullOrEmpty(licenseNumber) || !string.IsNullOrEmpty(billingNumber))
{
var criteria = new ExternalPractitionerSearchCriteria();
if (!string.IsNullOrEmpty(licenseNumber))
{
criteria.LicenseNumber.EqualTo(licenseNumber);
}
if (!string.IsNullOrEmpty(billingNumber))
{
criteria.BillingNumber.EqualTo(billingNumber);
}
var broker = context.GetBroker <IExternalPractitionerBroker>();
prac = CollectionUtils.FirstElement(broker.Find(criteria));
}
return(prac);
}
// note: this operation is not protected with ClearCanvas.Ris.Application.Common.AuthorityTokens.ExternalPractitionerAdmin
// because it is used in non-admin situations - perhaps we need to create a separate operation???
public ListExternalPractitionersResponse ListExternalPractitioners(ListExternalPractitionersRequest request)
{
var assembler = new ExternalPractitionerAssembler();
var criteria = new ExternalPractitionerSearchCriteria();
if (request.SortByLastVerifiedTime)
{
if (request.SortAscending)
{
criteria.LastVerifiedTime.SortAsc(0);
}
else
{
criteria.LastVerifiedTime.SortDesc(0);
}
}
else if (request.SortByLastEditedTime)
{
if (request.SortAscending)
{
criteria.LastEditedTime.SortAsc(0);
}
else
{
criteria.LastEditedTime.SortDesc(0);
}
}
else
{
criteria.Name.FamilyName.SortAsc(0);
}
if (!string.IsNullOrEmpty(request.FirstName))
{
criteria.Name.GivenName.StartsWith(request.FirstName);
}
if (!string.IsNullOrEmpty(request.LastName))
{
criteria.Name.FamilyName.StartsWith(request.LastName);
}
switch (request.VerifiedState)
{
case VerifiedState.Verified:
criteria.IsVerified.EqualTo(true);
break;
case VerifiedState.NotVerified:
criteria.IsVerified.EqualTo(false);
break;
}
if (request.LastVerifiedRangeFrom != null && request.LastVerifiedRangeUntil != null)
{
criteria.LastVerifiedTime.Between(request.LastVerifiedRangeFrom, request.LastVerifiedRangeUntil);
}
else if (request.LastVerifiedRangeFrom != null)
{
criteria.LastVerifiedTime.MoreThanOrEqualTo(request.LastVerifiedRangeFrom);
}
else if (request.LastVerifiedRangeUntil != null)
{
criteria.LastVerifiedTime.LessThanOrEqualTo(request.LastVerifiedRangeUntil);
}
if (!request.IncludeMerged)
{
criteria.MergedInto.IsNull();
}
if (!request.IncludeDeactivated)
{
criteria.Deactivated.EqualTo(false);
}
var results = new List <ExternalPractitionerSummary>();
if (request.QueryItems)
{
results = CollectionUtils.Map <ExternalPractitioner, ExternalPractitionerSummary, List <ExternalPractitionerSummary> >(
PersistenceContext.GetBroker <IExternalPractitionerBroker>().Find(criteria, request.Page),
s => assembler.CreateExternalPractitionerSummary(s, PersistenceContext));
}
var itemCount = -1;
if (request.QueryCount)
{
itemCount = (int)PersistenceContext.GetBroker <IExternalPractitionerBroker>().Count(criteria);
}
return(new ListExternalPractitionersResponse(results, itemCount));
}
private ExternalPractitioner GetExternalPracitioner(string license, IEnumerable<ExternalPractitioner> importedEPs)
{
// if licenseId is not supplied, then assume the record does not exist
if (string.IsNullOrEmpty(license))
return null;
var externalPractitioner = CollectionUtils.SelectFirst(importedEPs, ep => Equals(ep.LicenseNumber, license));
if (externalPractitioner == null)
{
var criteria = new ExternalPractitionerSearchCriteria();
criteria.LicenseNumber.EqualTo(license);
var broker = _context.GetBroker<IExternalPractitionerBroker>();
externalPractitioner = CollectionUtils.FirstElement(broker.Find(criteria));
}
return externalPractitioner;
}
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);
}
}
