internal static TestResult VisitAndPerformingFacilitiesHaveSameInformationAuthority(Order order) { // all non-defunct procedures for the order must have the same performing information authority as the visit var hasSameInformationAuthority = CollectionUtils.TrueForAll(NonDefunctProcedures(order), p => Equals(p.PerformingFacility.InformationAuthority, p.Order.Visit.VisitNumber.AssigningAuthority)); return new TestResult(hasSameInformationAuthority, SR.MessageValidateInformationAuthorityForVisitAndPerformingFacilities); }
internal static TestResult AllNonDefunctProceduresHaveSamePerformingDepartment(Order order) { // all non-defunct procedures for the order must have the same performing department var procedures = NonDefunctProcedures(order); var department = CollectionUtils.FirstElement(CollectionUtils.Map(procedures, (Procedure p) => p.PerformingDepartment)); var hasSameDepartment = CollectionUtils.TrueForAll(procedures, p => Equals(p.PerformingDepartment, department)); return new TestResult(hasSameDepartment, SR.MessageValidateOrderPerformingDepartments); }
public void EnqueueEvents(Order order) { var queueItem = new WorkQueueItem(WorkQueueItemType); queueItem.ExtendedProperties.Add("EventType", this.EventType); queueItem.ExtendedProperties.Add("OrderOID", order.OID.ToString()); queueItem.ExtendedProperties.Add("AccessionNumber", order.AccessionNumber); EnqueueWorkItem(queueItem); }
public OrderListItem CreateOrderListItem(Order order, IPersistenceContext context) { var data = new OrderListItem(); UpdateListItem(data, order, context); UpdateListItem(data, order.Visit, context); return data; }
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 void UpdateOrderFromRequisition(Order order, OrderRequisition requisition, Staff currentStaff, IPersistenceContext context) { // only certain properties of an order may be updated from a requisition // Patient cannot not be updated // DiagnosticService cannot be updated // OrderingFacility cannot be updated // do not update the individual procedures, as this is done separately - see UpdateProcedureFromRequisition // Some properties cannot be updated if the procedure is terminated if (!order.IsTerminated) { order.Visit = context.Load<Visit>(requisition.Visit.VisitRef, EntityLoadFlags.Proxy); order.SchedulingRequestTime = requisition.SchedulingRequestTime; order.OrderingPractitioner = context.Load<ExternalPractitioner>( requisition.OrderingPractitioner.PractitionerRef, EntityLoadFlags.Proxy); order.ReasonForStudy = requisition.ReasonForStudy; order.Priority = EnumUtils.GetEnumValue<OrderPriority>(requisition.Priority); // wipe out and reset the result recipients order.ResultRecipients.Clear(); CollectionUtils.Map<ResultRecipientDetail, ResultRecipient>( requisition.ResultRecipients, s => new ResultRecipient( context.Load<ExternalPractitionerContactPoint>(s.ContactPoint.ContactPointRef, EntityLoadFlags.Proxy), EnumUtils.GetEnumValue<ResultCommunicationMode>(s.PreferredCommunicationMode))).ForEach(r => order.ResultRecipients.Add(r)); } // synchronize Order.Attachments from order requisition var attachmentAssembler = new OrderAttachmentAssembler(); attachmentAssembler.Synchronize(order.Attachments, requisition.Attachments, currentStaff, context); // synchronize Order.Notes from order requisition var noteAssembler = new OrderNoteAssembler(); noteAssembler.SynchronizeOrderNotes(order, requisition.Notes, currentStaff, context); if (requisition.ExtendedProperties != null) { ExtendedPropertyUtils.Update(order.ExtendedProperties, requisition.ExtendedProperties); } }
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; }
/// <summary> /// Constructor. /// </summary> /// <param name="note"></param> /// <param name="order"></param> /// <param name="patient"></param> /// <param name="patientProfile"></param> /// <param name="noteAuthor"></param> /// <param name="recipients"></param> /// <param name="diagnosticServiceName"></param> /// <param name="isAcknowledged"></param> public OrderNoteboxItem(Note note, Order order, Patient patient, PatientProfile patientProfile, Staff noteAuthor, IList recipients, string diagnosticServiceName, bool isAcknowledged) { _noteRef = note.GetRef(); _orderRef = order.GetRef(); _patientRef = patient.GetRef(); _patientProfileRef = patientProfile.GetRef(); _mrn = patientProfile.Mrn; _patientName = patientProfile.Name; _dateOfBirth = patientProfile.DateOfBirth; _accessionNumber = order.AccessionNumber; _diagnosticServiceName = diagnosticServiceName; _category = note.Category; _urgent = note.Urgent; _postTime = note.PostTime; _author = noteAuthor; _onBehalfOfGroup = note.OnBehalfOfGroup; _isAcknowledged = isAcknowledged; _recipients = recipients; }
public ProcedurePlanDetail CreateProcedurePlanSummary(Order order, IPersistenceContext context) { ProcedurePlanDetail detail = new ProcedurePlanDetail(); ProcedureAssembler assembler = new ProcedureAssembler(); StaffAssembler staffAssembler = new StaffAssembler(); detail.OrderRef = order.GetRef(); detail.Procedures = CollectionUtils.Map<Procedure, ProcedureDetail>( order.Procedures, delegate(Procedure rp) { return assembler.CreateProcedureDetail( rp, delegate(ProcedureStep ps) { return ps.Is<ModalityProcedureStep>(); }, // only MPS are relevant here false, context); }); detail.DiagnosticServiceSummary = new DiagnosticServiceSummary(order.DiagnosticService.GetRef(), order.DiagnosticService.Id, order.DiagnosticService.Name, order.DiagnosticService.Deactivated); return detail; }
private StaffSummary GetUniqueAssignedInterpreter(Order order) { StaffSummary uniqueAssignedInterpreter = null; var staffAssembler = new StaffAssembler(); // establish whether there is a unique assigned interpreter for all procedures var interpreters = new HashedSet<Staff>(); foreach (var procedure in order.Procedures) { var pendingInterpretationStep = procedure.GetProcedureStep( ps => ps.Is<InterpretationStep>() && ps.State == ActivityStatus.SC); if (pendingInterpretationStep != null && pendingInterpretationStep.AssignedStaff != null) interpreters.Add(pendingInterpretationStep.AssignedStaff); } if (interpreters.Count == 1) { uniqueAssignedInterpreter = staffAssembler.CreateStaffSummary( CollectionUtils.FirstElement(interpreters), this.PersistenceContext); } return uniqueAssignedInterpreter; }
private void ValidateVisitsExist(Order order) { try { var visitSearchCriteria = new VisitSearchCriteria(); visitSearchCriteria.Patient.EqualTo(order.Patient); visitSearchCriteria.VisitNumber.AssigningAuthority.EqualTo(order.OrderingFacility.InformationAuthority); this.PersistenceContext.GetBroker<IVisitBroker>().FindOne(visitSearchCriteria); } catch (EntityNotFoundException) { throw new RequestValidationException( string.Format(SR.InvalidRequest_CannotEnterOrderWithoutVisits, order.OrderingFacility.InformationAuthority.Value)); } }
public MergeOrderOperationData(string operation, PatientProfile patientProfile, Order destOrder, IEnumerable<Order> mergedOrders) : base(operation, patientProfile) { this.MergedIntoOrder = new OrderData(destOrder); this.MergedOrders = mergedOrders.Select(x => new OrderData(x)).ToList(); }
public ReplaceOrderOperationData(string operation, PatientProfile patientProfile, Order cancelledOrder, Order newOrder) : base(operation, patientProfile) { this.CancelledOrder = new OrderData(cancelledOrder); this.NewOrder = new OrderData(newOrder); }
/// <summary> /// Un-merges this order from its merge destination, returning a new order with the specified accession #, /// and marking this order as Replaced by the new order. /// </summary> /// <param name="cancelInfo"></param> /// <param name="newAccessionNumber"></param> /// <returns></returns> public virtual UnmergeResult Unmerge(OrderCancelInfo cancelInfo, string newAccessionNumber) { string failureReason; if (!CanUnmerge(cancelInfo, out failureReason)) throw new WorkflowException(failureReason); var destOrder = _mergeInfo.MergeDestinationOrder; // create replacement order var newOrder = new Order( _patient, _visit, null, // do not copy placer-number newAccessionNumber, // assign new acc # _diagnosticService, _enteredTime, _enteredBy, _enteredComment, _schedulingRequestTime, null, // will be set by call to UpdateScheduling() null, null, _orderingPractitioner, _orderingFacility, new HashedSet<Procedure>(), // will be added later new HashedSet<Procedure>(), // ghosts CollectionUtils.Map(_resultRecipients, (ResultRecipient rr) => (ResultRecipient)rr.Clone()), new List<OrderAttachment>(), _reasonForStudy, _priority, (int)_priority, OrderStatus.SC, null, null, new HashedSet<Order>(), ExtendedPropertyUtils.Copy(_extendedProperties) ); // reclaim order notes var notes = OrderNote.GetNotesForOrder(this); var reclaimNotes = CollectionUtils.Map( CollectionUtils.Select(notes, n => n.GhostOf != null), (OrderNote n) => n.GhostOf.Downcast<OrderNote>()); foreach (var note in reclaimNotes) { note.Order = newOrder; } // reclaim attachments var reclaimAttachments = CollectionUtils.Map(_attachments, (OrderAttachment a) => CollectionUtils.SelectFirst(destOrder.Attachments, b => Equals(a.Document.GhostOf, b.Document))); foreach (var attachment in reclaimAttachments) { destOrder.Attachments.Remove(attachment); newOrder.Attachments.Add(attachment); } // reclaim procedures // need to create new ghost copies on the dest order, so that HL7 can cancel them var reclaimProcedures = CollectionUtils.Map(_ghostProcedures, (Procedure p) => p.GhostOf); var ghostProcedures = CollectionUtils.Map(reclaimProcedures, (Procedure p) => p.CreateGhostCopy()); foreach (var procedure in reclaimProcedures) { newOrder.AddProcedure(procedure); } destOrder.Procedures.AddAll(ghostProcedures); // note: procedure Indexes are already set correctly // update scheduling/status information newOrder.UpdateScheduling(); newOrder.UpdateStatus(); // any orders that were merged into this order must be redirected to the new order, // in order to support recursive unmerge foreach (var sourceOrder in _mergeSourceOrders) { sourceOrder.MergeInfo.MergeDestinationOrder = newOrder; newOrder.MergeSourceOrders.Add(sourceOrder); } _mergeSourceOrders.Clear(); // change status of this order to RP, and set cancel info _cancelInfo = (OrderCancelInfo)cancelInfo.Clone(); _cancelInfo.ReplacementOrder = newOrder; // clear merge info on this order, since it is no longer considered merged _mergeInfo = null; // set status of this order to RP, and set end time manually SetStatus(OrderStatus.RP); _endTime = Platform.Time; return new UnmergeResult {ReplacementOrder = newOrder, GhostProcedures = ghostProcedures}; }
public CancelOrderOperationData(string operation, PatientProfile patientProfile, Order order) : base(operation, patientProfile, order) { this.CancelReason = EnumUtils.GetEnumValueInfo(order.CancelInfo.Reason); }
private void UpdateProceduresHelper(Order order, IEnumerable<ProcedureRequisition> procedureReqs, ModifyOrderRequest request) { // do not update the procedures if the order is completed if (order.IsTerminated) return; var assembler = new OrderEntryAssembler(); // if any procedure is in downtime recovery mode, assume the entire order is a "downtime order" var isDowntime = CollectionUtils.Contains(order.Procedures, p => p.DowntimeRecoveryMode); // separate the list into additions and updates var existingReqs = new List<ProcedureRequisition>(); var addedReqs = new List<ProcedureRequisition>(); foreach (var req in procedureReqs) { if (CollectionUtils.Contains(order.Procedures, x => req.ProcedureNumber == x.Number)) { existingReqs.Add(req); } else { addedReqs.Add(req); } } // process the additions first, so that we don't accidentally cancel an order (if all its procedures are cancelled momentarily) var procedureNumberBroker = PersistenceContext.GetBroker<IProcedureNumberBroker>(); var dicomUidBroker = PersistenceContext.GetBroker<IDicomUidBroker>(); foreach (var req in addedReqs) { var requestedType = this.PersistenceContext.Load<ProcedureType>(req.ProcedureType.ProcedureTypeRef); // create a new procedure for this requisition var procedure = new Procedure(requestedType, procedureNumberBroker.GetNext(), dicomUidBroker.GetNewUid()) { DowntimeRecoveryMode = isDowntime }; order.AddProcedure(procedure); // note: need to lock the new procedure now, prior to creating the procedure steps // otherwise may get exceptions saying the Procedure is a transient object this.PersistenceContext.Lock(procedure, DirtyState.New); // create the procedure steps procedure.CreateProcedureSteps(); // apply the requisition information to the actual procedure assembler.UpdateProcedureFromRequisition(procedure, req, this.CurrentUserStaff, this.PersistenceContext); LogicalHL7Event.ProcedureCreated.EnqueueEvents(procedure); } // process updates foreach (var req in existingReqs) { var requestedType = this.PersistenceContext.Load<ProcedureType>(req.ProcedureType.ProcedureTypeRef); var procedure = CollectionUtils.SelectFirst(order.Procedures, x => req.ProcedureNumber == x.Number); // validate that the type has not changed if (!procedure.Type.Equals(requestedType)) throw new RequestValidationException("Order modification must not modify the type of a requested procedure."); // If the procedure is already terminated, just move on to the next one since procedures cannot be "un-terminated". if (procedure.IsTerminated) continue; // apply the requisition information to the actual procedure assembler.UpdateProcedureFromRequisition(procedure, req, this.CurrentUserStaff, this.PersistenceContext); (req.Cancelled ? LogicalHL7Event.ProcedureCancelled : LogicalHL7Event.ProcedureModified).EnqueueEvents(procedure); } }
private static int QueryDicomServer(Order order, string shredAETitle, string dicomServerAETitle, string dicomServerHost, int dicomServerPort, out bool studiesNotFound) { DicomAttributeCollection requestCollection = new DicomAttributeCollection(); requestCollection[DicomTags.QueryRetrieveLevel].SetStringValue("STUDY"); requestCollection[DicomTags.StudyInstanceUid].SetStringValue(""); requestCollection[DicomTags.AccessionNumber].SetStringValue(order.AccessionNumber); requestCollection[DicomTags.NumberOfStudyRelatedInstances].SetStringValue(""); int numberOfInstancesFromDicomServer = 0; using (StudyRootFindScu scu = new StudyRootFindScu()) { IList<DicomAttributeCollection> results = scu.Find( shredAETitle, dicomServerAETitle, dicomServerHost, dicomServerPort, requestCollection); // Wait for a response scu.Join(new TimeSpan(0, 0, 0, 0, 1000)); if (scu.Status == ScuOperationStatus.Canceled) { String message = String.Format(SR.MessageFormatDicomRemoteServerCancelledFind, scu.FailureDescription ?? "no failure description provided"); throw new DicomException(message); } if (scu.Status == ScuOperationStatus.ConnectFailed) { String message = String.Format(SR.MessageFormatDicomConnectionFailed, scu.FailureDescription ?? "no failure description provided"); throw new DicomException(message); } if (scu.Status == ScuOperationStatus.Failed) { String message = String.Format(SR.MessageFormatDicomQueryOperationFailed, scu.FailureDescription ?? "no failure description provided"); throw new DicomException(message); } if (scu.Status == ScuOperationStatus.TimeoutExpired) { String message = String.Format(SR.MessageFormatDicomConnectTimeoutExpired, scu.FailureDescription ?? "no failure description provided"); throw new DicomException(message); } foreach (DicomAttributeCollection result in results) { numberOfInstancesFromDicomServer += (int) result[DicomTags.NumberOfStudyRelatedInstances].GetUInt32(0, 0); } studiesNotFound = results.Count == 0; } return numberOfInstancesFromDicomServer; }
private void CheckStatus(OrderStatus status, Order o) { Assert.AreEqual(status, o.Status, string.Format("Exptected {0} status {1}", o.GetClass().Name, status.ToString())); }
public OrderData(Order order) { AccessionNumber = order.AccessionNumber; }
/// <summary> /// Factory method to create a new order. /// </summary> public static Order NewOrder(OrderCreationArgs args, IProcedureNumberBroker procedureNumberBroker, IDicomUidBroker dicomUidBroker) { // validate required members are set Platform.CheckMemberIsSet(args.Patient, "Patient"); Platform.CheckMemberIsSet(args.Visit, "Visit"); Platform.CheckMemberIsSet(args.AccessionNumber, "AccessionNumber"); Platform.CheckMemberIsSet(args.DiagnosticService, "DiagnosticService"); Platform.CheckMemberIsSet(args.ReasonForStudy, "ReasonForStudy"); Platform.CheckMemberIsSet(args.OrderingFacility, "OrderingFacility"); Platform.CheckMemberIsSet(args.OrderingPractitioner, "OrderingPractitioner"); // create the order var order = new Order { Patient = args.Patient, Visit = args.Visit, AccessionNumber = args.AccessionNumber, DiagnosticService = args.DiagnosticService, ReasonForStudy = args.ReasonForStudy, OrderingFacility = args.OrderingFacility, OrderingPractitioner = args.OrderingPractitioner, Priority = args.Priority, SchedulingRequestTime = args.SchedulingRequestTime, EnteredTime = args.EnteredTime, EnteredBy = args.EnteredBy, EnteredComment = args.EnteredComment }; if (args.Procedures == null || args.Procedures.Count == 0) { // create procedures according to the diagnostic service plan args.Procedures = CollectionUtils.Map<ProcedureType, Procedure>( args.DiagnosticService.ProcedureTypes, type => new Procedure(type, procedureNumberBroker.GetNext(), dicomUidBroker.GetNewUid()) { PerformingFacility = args.PerformingFacility ?? args.OrderingFacility }); } // associate all procedures with the order foreach (var procedure in args.Procedures) { order.AddProcedure(procedure); } // add recipients if (args.ResultRecipients != null) { foreach (var recipient in args.ResultRecipients) { order.ResultRecipients.Add(recipient); } } var recipientsContainsOrderingPractitioner = CollectionUtils.Contains( order.ResultRecipients, r => r.PractitionerContactPoint.Practitioner.Equals(args.OrderingPractitioner)); // if the result recipients collection does not contain the ordering practitioner, add it by force if (!recipientsContainsOrderingPractitioner) { var orderingPractitionerContactPoint = // use the contact point associated to the ordering facility's information authority CollectionUtils.SelectFirst(args.OrderingPractitioner.ContactPoints, cp => args.OrderingFacility.InformationAuthority.Equals(cp.InformationAuthority) && cp.Deactivated == false) // or, use the default contact point ?? CollectionUtils.SelectFirst(args.OrderingPractitioner.ContactPoints, cp => cp.IsDefaultContactPoint) // or, if no default, use first available active CP (should never happen) ?? CollectionUtils.SelectFirst(args.OrderingPractitioner.ContactPoints, cp => !cp.Deactivated) // or, if no active CPs, use first in the collection (should never happen) ?? CollectionUtils.FirstElement(args.OrderingPractitioner.ContactPoints); if (orderingPractitionerContactPoint != null) { order.ResultRecipients.Add(new ResultRecipient(orderingPractitionerContactPoint, ResultCommunicationMode.ANY)); } } return order; }
private void ValidateOrderReplacable(Order order) { if (order.IsTerminated) throw new RequestValidationException(string.Format("Orders with a status of '{0}' cannot be replaced.", EnumUtils.GetEnumValueInfo(order.Status, this.PersistenceContext))); if (CollectionUtils.Contains(order.Procedures, p => p.DowntimeRecoveryMode)) throw new RequestValidationException("Downtime orders cannot be replaced. You must cancel the order and create a new one."); }
private static int QueryDocumentation(Order order, out bool hasIncompleteDicomSeries) { List<DicomSeries> dicomSeries = new List<DicomSeries>(); bool isMissingDicomSeries = false; // Find all the DicomSeries for this order CollectionUtils.ForEach(order.Procedures, delegate(Procedure procedure) { CollectionUtils.ForEach(procedure.ModalityProcedureSteps, delegate(ModalityProcedureStep mps) { List<PerformedStep> mppsList = CollectionUtils.Select(mps.PerformedSteps, delegate(PerformedStep ps) { return ps.Is<ModalityPerformedProcedureStep>(); }); if (mppsList.Count == 0) { isMissingDicomSeries = true; } else { CollectionUtils.ForEach(mps.PerformedSteps, delegate(PerformedStep ps) { if (ps.Is<ModalityPerformedProcedureStep>()) { ModalityPerformedProcedureStep mpps = ps.As<ModalityPerformedProcedureStep>(); if (mpps.DicomSeries == null || mpps.DicomSeries.Count == 0) isMissingDicomSeries = true; else dicomSeries.AddRange(mpps.DicomSeries); } }); } }); }); // Sum the number of instances for all DicomSeries hasIncompleteDicomSeries = isMissingDicomSeries; int numberOfInstancesFromDocumentation = CollectionUtils.Reduce<DicomSeries, int>( dicomSeries, 0, delegate(DicomSeries series, int totalInstances) { return totalInstances + series.NumberOfSeriesRelatedInstances; }); return numberOfInstancesFromDocumentation; }
private void ValidateOrderReplacable(Order order) { if (order.IsTerminated) throw new RequestValidationException(string.Format(SR.InvalidRequest_OrderInStatusCannotBeReplaced, EnumUtils.GetEnumValueInfo(order.Status, this.PersistenceContext))); if (CollectionUtils.Contains(order.Procedures, p => p.DowntimeRecoveryMode)) throw new RequestValidationException(SR.InvalidRequest_DowntimeOrdersCannotBeReplaced); }
/// <summary> /// Creates duplicates of any attached documents in the order that also appear in the /// requisition, and then replaces the references in the requisition to refer to the /// duplicates. /// </summary> /// <param name="order"></param> /// <param name="requisition"></param> private void DuplicateAttachmentsForOrderReplace(Order order, OrderRequisition requisition) { foreach (var attachment in order.Attachments) { var summary = CollectionUtils.SelectFirst(requisition.Attachments, s => s.Document.DocumentRef.Equals(attachment.Document.GetRef(), true)); if (summary != null) { var dup = attachment.Document.Duplicate(true); PersistenceContext.Lock(dup, DirtyState.New); summary.Document.DocumentRef = dup.GetRef(); } } }
private void ValidateVisitsExist(Order order) { try { var visitSearchCriteria = new VisitSearchCriteria(); visitSearchCriteria.Patient.EqualTo(order.Patient); visitSearchCriteria.VisitNumber.AssigningAuthority.EqualTo(order.OrderingFacility.InformationAuthority); this.PersistenceContext.GetBroker<IVisitBroker>().FindOne(visitSearchCriteria); } catch (EntityNotFoundException) { throw new RequestValidationException( string.Format("The order cannot be entered because the patient does not have any visits at {0}.", order.OrderingFacility.InformationAuthority.Value)); } }
private static List<Procedure> NonDefunctProcedures(Order order) { return order.GetProcedures(p => !p.IsDefunct); }
private void AddAdditionalCommentsNote(OrderNoteDetail detail, Order order) { if (detail == null) return; var noteAssembler = new OrderNoteAssembler(); noteAssembler.CreateOrderNote(detail, order, this.CurrentUserStaff, true, this.PersistenceContext); }
private static void CancelOrderHelper(Order order, OrderCancelInfo info) { var operation = new CancelOrDiscontinueOrderOperation(); operation.Execute(order, info); }
private void MergeOrderHelper(Order destinationOrder, IEnumerable<Order> sourceOrders, OrderMergeInfo mergeInfo, bool validateOnly) { var sourceOrderAccessionNumbers = new List<string>(); foreach (var sourceOrder in sourceOrders) { sourceOrderAccessionNumbers.Add(sourceOrder.AccessionNumber); string failureReason; if (!sourceOrder.CanMerge(mergeInfo, out failureReason)) throw new RequestValidationException(failureReason); if (validateOnly) continue; // Merge the source order into the destination order. var result = sourceOrder.Merge(mergeInfo); // sync state so that ghost procedures get OIDs, prior to queuing ghost HL7 events PersistenceContext.SynchState(); // create all necessary HL7 events foreach (var ghostProcedure in result.GhostProcedures) { LogicalHL7Event.ProcedureCancelled.EnqueueEvents(ghostProcedure); LogicalHL7Event.ProcedureCreated.EnqueueEvents(ghostProcedure.GhostOf); } LogicalHL7Event.OrderModified.EnqueueEvents(destinationOrder); } }
public OperationData(string operation, PatientProfile patientProfile, Order order, IEnumerable<Procedure> procedures) { Operation = operation; Patient = new PatientData(patientProfile); Order = new OrderData(order); Procedures = procedures.Select(rp => new ProcedureData(rp)).ToList(); }