public LoadMergeExternalPractitionerFormDataResponse LoadMergeExternalPractitionerFormData(LoadMergeExternalPractitionerFormDataRequest request)
{
var response = new LoadMergeExternalPractitionerFormDataResponse();
if (request.PractitionerRef != null)
{
var broker = PersistenceContext.GetBroker <IExternalPractitionerBroker>();
var practitioner = PersistenceContext.Load <ExternalPractitioner>(request.PractitionerRef);
var duplicates = broker.GetMergeCandidates(practitioner);
var assembler = new ExternalPractitionerAssembler();
response.Duplicates = CollectionUtils.Map <ExternalPractitioner, ExternalPractitionerSummary>(duplicates,
item => assembler.CreateExternalPractitionerSummary(item, this.PersistenceContext));
}
return(response);
}
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));
}
public OrderRequisition CreateOrderRequisition(Order order, IPersistenceContext context)
{
var patientProfileAssembler = new PatientProfileAssembler();
var visitAssembler = new VisitAssembler();
var pracAssembler = new ExternalPractitionerAssembler();
var facilityAssembler = new FacilityAssembler();
var dsAssembler = new DiagnosticServiceAssembler();
var attachmentAssembler = new OrderAttachmentAssembler();
var noteAssembler = new OrderNoteAssembler();
var resultRecipientAssembler = new ResultRecipientAssembler();
var requisition = new OrderRequisition
{
OrderRef = order.GetRef(),
Patient =
patientProfileAssembler.CreatePatientProfileSummary(
CollectionUtils.FirstElement(order.Procedures).PatientProfile, context),
Visit = visitAssembler.CreateVisitSummary(order.Visit, context),
DiagnosticService = dsAssembler.CreateSummary(order.DiagnosticService),
SchedulingRequestTime = order.SchedulingRequestTime,
OrderingPractitioner =
pracAssembler.CreateExternalPractitionerSummary(order.OrderingPractitioner, context),
OrderingFacility = facilityAssembler.CreateFacilitySummary(order.OrderingFacility),
ReasonForStudy = order.ReasonForStudy,
Priority = EnumUtils.GetEnumValueInfo(order.Priority, context),
ResultRecipients = CollectionUtils.Map<ResultRecipient, ResultRecipientDetail>(
order.ResultRecipients,
r => resultRecipientAssembler.CreateResultRecipientDetail(r, context)),
Procedures = CollectionUtils.Map<Procedure, ProcedureRequisition>(
order.Procedures,
procedure => CreateProcedureRequisition(procedure, context)),
Attachments = CollectionUtils.Map<OrderAttachment, AttachmentSummary>(
order.Attachments,
attachment => attachmentAssembler.CreateOrderAttachmentSummary(attachment, context)),
Notes = CollectionUtils.Map<OrderNote, OrderNoteDetail>(
OrderNote.GetNotesForOrder(order),
note => noteAssembler.CreateOrderNoteDetail(note, context)),
ExtendedProperties = ExtendedPropertyUtils.Copy(order.ExtendedProperties),
CanModify = !order.IsTerminated
};
return requisition;
}
public OrderRequisition CreateOrderRequisition(Order order, IPersistenceContext context)
{
var patientProfileAssembler = new PatientProfileAssembler();
var visitAssembler = new VisitAssembler();
var pracAssembler = new ExternalPractitionerAssembler();
var facilityAssembler = new FacilityAssembler();
var dsAssembler = new DiagnosticServiceAssembler();
var attachmentAssembler = new OrderAttachmentAssembler();
var noteAssembler = new OrderNoteAssembler();
var resultRecipientAssembler = new ResultRecipientAssembler();
var requisition = new OrderRequisition
{
OrderRef = order.GetRef(),
Patient =
patientProfileAssembler.CreatePatientProfileSummary(
CollectionUtils.FirstElement(order.Procedures).PatientProfile, context),
Visit = visitAssembler.CreateVisitSummary(order.Visit, context),
DiagnosticService = dsAssembler.CreateSummary(order.DiagnosticService),
SchedulingRequestTime = order.SchedulingRequestTime,
OrderingPractitioner =
pracAssembler.CreateExternalPractitionerSummary(order.OrderingPractitioner, context),
OrderingFacility = facilityAssembler.CreateFacilitySummary(order.OrderingFacility),
ReasonForStudy = order.ReasonForStudy,
Priority = EnumUtils.GetEnumValueInfo(order.Priority, context),
ResultRecipients = CollectionUtils.Map <ResultRecipient, ResultRecipientDetail>(
order.ResultRecipients,
r => resultRecipientAssembler.CreateResultRecipientDetail(r, context)),
Procedures = CollectionUtils.Map <Procedure, ProcedureRequisition>(
order.Procedures,
procedure => CreateProcedureRequisition(procedure, context)),
Attachments = CollectionUtils.Map <OrderAttachment, AttachmentSummary>(
order.Attachments,
attachment => attachmentAssembler.CreateOrderAttachmentSummary(attachment, context)),
Notes = CollectionUtils.Map <OrderNote, OrderNoteDetail>(
OrderNote.GetNotesForOrder(order),
note => noteAssembler.CreateOrderNoteDetail(note, context)),
ExtendedProperties = ExtendedPropertyUtils.Copy(order.ExtendedProperties),
CanModify = !order.IsTerminated
};
return(requisition);
}
public UpdateExternalPractitionerResponse UpdateExternalPractitioner(UpdateExternalPractitionerRequest request)
{
var prac = PersistenceContext.Load <ExternalPractitioner>(request.PractitionerDetail.PractitionerRef, EntityLoadFlags.CheckVersion);
EnsureNoDeactivatedContactPointsWithActiveOrders(request.PractitionerDetail.ContactPoints);
var assembler = new ExternalPractitionerAssembler();
assembler.UpdateExternalPractitioner(request.PractitionerDetail, prac, PersistenceContext);
prac.MarkEdited();
var userCanVerify = Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Admin.Data.ExternalPractitionerVerification);
if (request.MarkVerified && userCanVerify)
{
prac.MarkVerified();
}
return(new UpdateExternalPractitionerResponse(assembler.CreateExternalPractitionerSummary(prac, PersistenceContext)));
}
private static void UpdateListItem(OrderListItem data, Order order, IPersistenceContext context)
{
var practitionerAssembler = new ExternalPractitionerAssembler();
var dsAssembler = new DiagnosticServiceAssembler();
var facilityAssembler = new FacilityAssembler();
data.OrderRef = order.GetRef();
data.PlacerNumber = order.PlacerNumber;
data.AccessionNumber = order.AccessionNumber;
data.DiagnosticService = dsAssembler.CreateSummary(order.DiagnosticService);
data.EnteredTime = order.EnteredTime;
data.SchedulingRequestTime = order.SchedulingRequestTime;
data.OrderingPractitioner = practitionerAssembler.CreateExternalPractitionerSummary(order.OrderingPractitioner, context);
data.OrderingFacility = facilityAssembler.CreateFacilitySummary(order.OrderingFacility);
data.ReasonForStudy = order.ReasonForStudy;
data.OrderPriority = EnumUtils.GetEnumValueInfo(order.Priority, context);
data.CancelReason = order.CancelInfo != null && order.CancelInfo.Reason != null ? EnumUtils.GetEnumValueInfo(order.CancelInfo.Reason) : null;
data.OrderStatus = EnumUtils.GetEnumValueInfo(order.Status, context);
data.OrderScheduledStartTime = order.ScheduledStartTime;
}
//[PrincipalPermission(SecurityAction.Demand, Role = ClearCanvas.Ris.Application.Common.AuthorityTokens.ExternalPractitionerAdmin)]
public LoadExternalPractitionerForEditResponse LoadExternalPractitionerForEdit(LoadExternalPractitionerForEditRequest request)
{
// note that the version of the ExternalPractitionerRef is intentionally ignored here (default behaviour of ReadOperation)
var practitioner = PersistenceContext.Load <ExternalPractitioner>(request.PractitionerRef);
var assembler = new ExternalPractitionerAssembler();
var response = new LoadExternalPractitionerForEditResponse {
PractitionerDetail = assembler.CreateExternalPractitionerDetail(practitioner, this.PersistenceContext)
};
if (request.IncludeAlerts)
{
var alerts = new List <AlertNotification>();
alerts.AddRange(AlertHelper.Instance.Test(practitioner, this.PersistenceContext));
var alertAssembler = new AlertAssembler();
response.Alerts = CollectionUtils.Map <AlertNotification, AlertNotificationDetail>(alerts, alertAssembler.CreateAlertNotification);
}
return(response);
}
private static void UpdateListItem(OrderListItem data, Order order, IPersistenceContext context)
{
var practitionerAssembler = new ExternalPractitionerAssembler();
var dsAssembler = new DiagnosticServiceAssembler();
var facilityAssembler = new FacilityAssembler();
data.OrderRef = order.GetRef();
data.PlacerNumber = order.PlacerNumber;
data.AccessionNumber = order.AccessionNumber;
data.DiagnosticService = dsAssembler.CreateSummary(order.DiagnosticService);
data.EnteredTime = order.EnteredTime;
data.SchedulingRequestTime = order.SchedulingRequestTime;
data.OrderingPractitioner = practitionerAssembler.CreateExternalPractitionerSummary(order.OrderingPractitioner, context);
data.OrderingFacility = facilityAssembler.CreateFacilitySummary(order.OrderingFacility);
data.ReasonForStudy = order.ReasonForStudy;
data.OrderPriority = EnumUtils.GetEnumValueInfo(order.Priority, context);
data.CancelReason = order.CancelInfo != null && order.CancelInfo.Reason != null?EnumUtils.GetEnumValueInfo(order.CancelInfo.Reason) : null;
data.OrderStatus = EnumUtils.GetEnumValueInfo(order.Status, context);
data.OrderScheduledStartTime = order.ScheduledStartTime;
}
public AddExternalPractitionerResponse AddExternalPractitioner(AddExternalPractitionerRequest request)
{
var prac = new ExternalPractitioner();
var assembler = new ExternalPractitionerAssembler();
assembler.UpdateExternalPractitioner(request.PractitionerDetail, prac, PersistenceContext);
prac.MarkEdited();
var userCanVerify = Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Admin.Data.ExternalPractitionerVerification);
if (request.MarkVerified && userCanVerify)
{
prac.MarkVerified();
}
PersistenceContext.Lock(prac, DirtyState.New);
// ensure the new prac is assigned an OID before using it in the return value
PersistenceContext.SynchState();
return(new AddExternalPractitionerResponse(assembler.CreateExternalPractitionerSummary(prac, PersistenceContext)));
}
public GetExternalPractitionerContactPointsResponse GetExternalPractitionerContactPoints(GetExternalPractitionerContactPointsRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.PractitionerRef, "PractitionerRef");
var practitioner = this.PersistenceContext.Load <ExternalPractitioner>(request.PractitionerRef);
var assembler = new ExternalPractitionerAssembler();
// sort contact points such that default is first (descending sort)
var sortedContactPoints = CollectionUtils.Sort(practitioner.ContactPoints,
(x, y) => - x.IsDefaultContactPoint.CompareTo(y.IsDefaultContactPoint));
var responseContactPoints = sortedContactPoints;
if (!request.IncludeDeactivated)
{
responseContactPoints = CollectionUtils.Select(sortedContactPoints, cp => !cp.Deactivated);
}
return(new GetExternalPractitionerContactPointsResponse(
CollectionUtils.Map(
responseContactPoints,
(ExternalPractitionerContactPoint cp) => assembler.CreateExternalPractitionerContactPointDetail(cp, this.PersistenceContext))));
}
// 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));
}
public MergeExternalPractitionerResponse MergeExternalPractitioner(MergeExternalPractitionerRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.LeftPractitionerRef, "LeftPractitionerRef");
Platform.CheckMemberIsSet(request.RightPractitionerRef, "RightPractitionerRef");
var left = PersistenceContext.Load <ExternalPractitioner>(request.LeftPractitionerRef, EntityLoadFlags.Proxy);
var right = PersistenceContext.Load <ExternalPractitioner>(request.RightPractitionerRef, EntityLoadFlags.Proxy);
// if we are only doing a cost estimate, exit here without modifying any data
if (request.EstimateCostOnly)
{
var cost = EstimateAffectedRecords(right, left);
return(new MergeExternalPractitionerResponse(cost));
}
// unpack the request, loading all required entities
var nameAssembler = new PersonNameAssembler();
var name = new PersonName();
nameAssembler.UpdatePersonName(request.Name, name);
var defaultContactPoint = request.DefaultContactPointRef != null?
PersistenceContext.Load <ExternalPractitionerContactPoint>(request.DefaultContactPointRef) : null;
var deactivatedContactPoints = request.DeactivatedContactPointRefs == null ? new List <ExternalPractitionerContactPoint>() :
CollectionUtils.Map(request.DeactivatedContactPointRefs,
(EntityRef cpRef) => PersistenceContext.Load <ExternalPractitionerContactPoint>(cpRef));
var cpReplacements = CollectionUtils.Map(request.ContactPointReplacements ?? (new Dictionary <EntityRef, EntityRef>()),
kvp => new KeyValuePair <ExternalPractitionerContactPoint, ExternalPractitionerContactPoint>(
PersistenceContext.Load <ExternalPractitionerContactPoint>(kvp.Key, EntityLoadFlags.Proxy),
PersistenceContext.Load <ExternalPractitionerContactPoint>(kvp.Value, EntityLoadFlags.Proxy)));
// merge the practitioners
var result = ExternalPractitioner.MergePractitioners(left, right,
name,
request.LicenseNumber,
request.BillingNumber,
request.ExtendedProperties,
defaultContactPoint,
deactivatedContactPoints,
cpReplacements
);
PersistenceContext.Lock(result, DirtyState.New);
// if user has verify permission, verify the result
if (Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Admin.Data.ExternalPractitionerVerification))
{
result.MarkVerified();
}
// queue work items to migrate orders and visits
foreach (var practitioner in new[] { right, left })
{
var queueItem = MergeWorkQueueItem.Create(practitioner.GetRef());
PersistenceContext.Lock(queueItem, DirtyState.New);
}
PersistenceContext.SynchState();
var assembler = new ExternalPractitionerAssembler();
return(new MergeExternalPractitionerResponse(assembler.CreateExternalPractitionerSummary(result, this.PersistenceContext)));
}
public MergeDuplicateContactPointResponse MergeDuplicateContactPoint(MergeDuplicateContactPointRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.RetainedContactPointRef, "RetainedContactPointRef");
Platform.CheckMemberIsSet(request.ReplacedContactPointRef, "ReplacedContactPointRef");
var dest = PersistenceContext.Load <ExternalPractitionerContactPoint>(request.RetainedContactPointRef, EntityLoadFlags.Proxy);
var src = PersistenceContext.Load <ExternalPractitionerContactPoint>(request.ReplacedContactPointRef, EntityLoadFlags.Proxy);
// if we are only doing a cost estimate, exit here without modifying any data
if (request.EstimateCostOnly)
{
// compute cost estimate. Need to include affected records of both src and dest, because both will be merged and deactivated.
var cost = EstimateAffectedRecords(dest, src);
return(new MergeDuplicateContactPointResponse(cost));
}
// combine all phone numbers and addresses, expiring those from the src object
var allPhoneNumbers = CollectionUtils.Concat(
CloneAndExpire(dest.TelephoneNumbers, tn => tn.ValidRange, false),
CloneAndExpire(src.TelephoneNumbers, tn => tn.ValidRange, true));
var allAddresses = CollectionUtils.Concat(
CloneAndExpire(dest.Addresses, tn => tn.ValidRange, false),
CloneAndExpire(src.Addresses, tn => tn.ValidRange, true));
var allEmailAddresses = CollectionUtils.Concat(
CloneAndExpire(dest.EmailAddresses, tn => tn.ValidRange, false),
CloneAndExpire(src.EmailAddresses, tn => tn.ValidRange, true));
// merge contact points
var result = ExternalPractitionerContactPoint.MergeContactPoints(
dest,
src,
dest.Name,
dest.Description,
dest.PreferredResultCommunicationMode,
dest.InformationAuthority,
allPhoneNumbers,
allAddresses,
allEmailAddresses);
PersistenceContext.Lock(result, DirtyState.New);
// if user has verify permission, verify the practitioner
if (Thread.CurrentPrincipal.IsInRole(AuthorityTokens.Admin.Data.ExternalPractitionerVerification))
{
result.Practitioner.MarkVerified();
}
// queue work items to migrate orders
foreach (var contactPoint in new[] { src, dest })
{
var queueItem = MergeWorkQueueItem.Create(contactPoint.GetRef());
PersistenceContext.Lock(queueItem, DirtyState.New);
}
PersistenceContext.SynchState();
var assembler = new ExternalPractitionerAssembler();
return(new MergeDuplicateContactPointResponse(assembler.CreateExternalPractitionerContactPointSummary(result)));
}
/// <summary>
/// Create worklist detail.
/// </summary>
/// <param name="worklist"></param>
/// <param name="context"></param>
/// <returns></returns>
public WorklistAdminDetail CreateWorklistDetail(Worklist worklist, IPersistenceContext context)
{
var detail = new WorklistAdminDetail(worklist.GetRef(), worklist.Name, worklist.Description,
CreateClassSummary(worklist.GetClass()));
var staffAssembler = new StaffAssembler();
var staffGroupAssembler = new StaffGroupAssembler();
detail.OwnerStaff = worklist.Owner.IsStaffOwner ?
staffAssembler.CreateStaffSummary(worklist.Owner.Staff, context) : null;
detail.OwnerGroup = worklist.Owner.IsGroupOwner ?
staffGroupAssembler.CreateSummary(worklist.Owner.Group) : null;
// proc types
var ptAssembler = new ProcedureTypeAssembler();
detail.ProcedureTypes = GetFilterSummary(worklist.ProcedureTypeFilter,
item => ptAssembler.CreateSummary(item));
// proc type groups
var ptgAssembler = new ProcedureTypeGroupAssembler();
detail.ProcedureTypeGroups = GetFilterSummary(worklist.ProcedureTypeGroupFilter,
item => ptgAssembler.GetProcedureTypeGroupSummary(item, context));
// facilities
var facilityAssembler = new FacilityAssembler();
detail.Facilities = GetFilterSummary(worklist.FacilityFilter,
item => facilityAssembler.CreateFacilitySummary(item));
detail.FilterByWorkingFacility = worklist.FacilityFilter.IsEnabled && worklist.FacilityFilter.IncludeWorkingFacility;
// departments
var departmentAssembler = new DepartmentAssembler();
detail.Departments = GetFilterSummary(worklist.DepartmentFilter,
item => departmentAssembler.CreateSummary(item, context));
// patient class
detail.PatientClasses = GetFilterSummary(worklist.PatientClassFilter,
item => EnumUtils.GetEnumValueInfo(item));
// location
var locationAssembler = new LocationAssembler();
detail.PatientLocations = GetFilterSummary(worklist.PatientLocationFilter,
item => locationAssembler.CreateLocationSummary(item));
// order priority
detail.OrderPriorities = GetFilterSummary(worklist.OrderPriorityFilter,
item => EnumUtils.GetEnumValueInfo(item));
// ordering prac
var practitionerAssembler = new ExternalPractitionerAssembler();
detail.OrderingPractitioners = GetFilterSummary(worklist.OrderingPractitionerFilter,
item => practitionerAssembler.CreateExternalPractitionerSummary(item, context));
// portable
if (worklist.PortableFilter.IsEnabled)
{
detail.Portabilities = new List <bool> {
worklist.PortableFilter.Value
};
}
// time window
if (worklist.TimeFilter.IsEnabled && worklist.TimeFilter.Value != null)
{
if (worklist.TimeFilter.Value.Start != null)
{
detail.StartTime = CreateTimePointContract(worklist.TimeFilter.Value.Start);
}
if (worklist.TimeFilter.Value.End != null)
{
detail.EndTime = CreateTimePointContract(worklist.TimeFilter.Value.End);
}
}
detail.StaffSubscribers = CollectionUtils.Map(worklist.StaffSubscribers,
(Staff staff) => staffAssembler.CreateStaffSummary(staff, context));
detail.GroupSubscribers = CollectionUtils.Map(worklist.GroupSubscribers,
(StaffGroup group) => staffGroupAssembler.CreateSummary(group));
// Some ReportingWorklists can support staff role filters, if that is true for this worklist,
// add those filters to the WorklistAdminDetail
if (Worklist.GetSupportsReportingStaffRoleFilter(worklist.GetClass()))
{
var reportingWorklist = worklist.As <ReportingWorklist>();
detail.InterpretedByStaff = GetFilterSummary(reportingWorklist.InterpretedByStaffFilter, context);
detail.TranscribedByStaff = GetFilterSummary(reportingWorklist.TranscribedByStaffFilter, context);
detail.VerifiedByStaff = GetFilterSummary(reportingWorklist.VerifiedByStaffFilter, context);
detail.SupervisedByStaff = GetFilterSummary(reportingWorklist.SupervisedByStaffFilter, context);
}
return(detail);
}
public GetExternalPractitionerContactPointsResponse GetExternalPractitionerContactPoints(GetExternalPractitionerContactPointsRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.PractitionerRef, "PractitionerRef");
var practitioner = this.PersistenceContext.Load<ExternalPractitioner>(request.PractitionerRef);
var assembler = new ExternalPractitionerAssembler();
// sort contact points such that default is first (descending sort)
var sortedContactPoints = CollectionUtils.Sort(practitioner.ContactPoints,
(x, y) => -x.IsDefaultContactPoint.CompareTo(y.IsDefaultContactPoint));
var responseContactPoints = sortedContactPoints;
if (!request.IncludeDeactivated)
{
responseContactPoints = CollectionUtils.Select(sortedContactPoints, cp => !cp.Deactivated);
}
return new GetExternalPractitionerContactPointsResponse(
CollectionUtils.Map(
responseContactPoints,
(ExternalPractitionerContactPoint cp) => assembler.CreateExternalPractitionerContactPointDetail(cp, this.PersistenceContext)));
}
