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))); }