public GetProcedureTypeGroupSummaryFormDataResponse GetProcedureTypeGroupSummaryFormData(GetProcedureTypeGroupSummaryFormDataRequest request)
{
var ptgAssembler = new ProcedureTypeGroupAssembler();
var subClasses = ProcedureTypeGroup.ListSubClasses(PersistenceContext);
// Category choices
return(new GetProcedureTypeGroupSummaryFormDataResponse(
CollectionUtils.Map(subClasses, (Type t) => ptgAssembler.GetCategoryEnumValueInfo(t))));
}
public void UpdateProcedureTypeGroup(ProcedureTypeGroup group, ProcedureTypeGroupDetail detail, IPersistenceContext context)
{
group.Name = detail.Name;
group.Description = detail.Description;
group.ProcedureTypes.Clear();
detail.ProcedureTypes.ForEach(
delegate(ProcedureTypeSummary summary)
{
group.ProcedureTypes.Add(context.Load <ProcedureType>(summary.ProcedureTypeRef));
});
}
public ProcedureTypeGroupDetail GetProcedureTypeGroupDetail(ProcedureTypeGroup rptGroup, IPersistenceContext context)
{
ProcedureTypeGroupDetail detail = new ProcedureTypeGroupDetail();
detail.Name = rptGroup.Name;
detail.Description = rptGroup.Description;
detail.Category = GetCategoryEnumValueInfo(rptGroup.GetType());
ProcedureTypeAssembler assembler = new ProcedureTypeAssembler();
detail.ProcedureTypes = CollectionUtils.Map <ProcedureType, ProcedureTypeSummary, List <ProcedureTypeSummary> >(
rptGroup.ProcedureTypes,
delegate(ProcedureType rpt)
{
return(assembler.CreateSummary(rpt));
});
return(detail);
}
public GetProcedureTypeGroupEditFormDataResponse GetProcedureTypeGroupEditFormData(
GetProcedureTypeGroupEditFormDataRequest request)
{
var response = new GetProcedureTypeGroupEditFormDataResponse();
var ptgAssembler = new ProcedureTypeGroupAssembler();
var subClasses = ProcedureTypeGroup.ListSubClasses(PersistenceContext);
// Category choices
response.Categories = CollectionUtils.Map(subClasses, (Type t) => ptgAssembler.GetCategoryEnumValueInfo(t));
// ProcedureType choices
var assembler = new ProcedureTypeAssembler();
response.ProcedureTypes = CollectionUtils.Map(
PersistenceContext.GetBroker <IProcedureTypeBroker>().FindAll(request.IncludeDeactivated),
(ProcedureType rpt) => assembler.CreateSummary(rpt));
return(response);
}
public ListProcedureTypeGroupsResponse ListProcedureTypeGroups(ListProcedureTypeGroupsRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.ProcedureTypeGroupClass, "request.ProcedureTypeGroupClass");
var procedureTypeGroupClass = ProcedureTypeGroup.GetSubClass(request.ProcedureTypeGroupClass, PersistenceContext);
if (procedureTypeGroupClass == null)
{
throw new ArgumentException("Invalid ProcedureTypeGroupClass name");
}
var response = new ListProcedureTypeGroupsResponse();
var assembler = new ProcedureTypeGroupAssembler();
response.ProcedureTypeGroups =
CollectionUtils.Map <ProcedureTypeGroup, ProcedureTypeGroupSummary>(
PersistenceContext.GetBroker <IProcedureTypeGroupBroker>().Find(new ProcedureTypeGroupSearchCriteria(), procedureTypeGroupClass),
group => assembler.GetProcedureTypeGroupSummary(group, PersistenceContext));
return(response);
}
public ProcedureTypeGroupSummary GetProcedureTypeGroupSummary(ProcedureTypeGroup rptGroup, IPersistenceContext context)
{
EnumValueInfo category = GetCategoryEnumValueInfo(rptGroup.GetType());
return(new ProcedureTypeGroupSummary(rptGroup.GetRef(), rptGroup.Name, rptGroup.Description, category));
}
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);
}
}
