Exemple #1
0
        /// <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
            });
        }
Exemple #2
0
        /// <summary>
        /// Merge the current order into the destination order specified in the mergeInfo.
        /// </summary>
        /// <param name="mergeInfo"></param>
        public virtual MergeResult Merge(OrderMergeInfo mergeInfo)
        {
            var destOrder = mergeInfo.MergeDestinationOrder;

            string failureReason;

            if (!CanMerge(mergeInfo, out failureReason))
            {
                throw new WorkflowException(failureReason);
            }

            _mergeInfo = mergeInfo;

            // copy all the result recipients to destination
            foreach (var rr in _resultRecipients)
            {
                var recipientAlreadyExist = CollectionUtils.Contains(
                    destOrder.ResultRecipients, recipients => recipients.PractitionerContactPoint.Equals(rr.PractitionerContactPoint));
                if (!recipientAlreadyExist)
                {
                    destOrder.ResultRecipients.Add((ResultRecipient)rr.Clone());
                }
            }

            // move all the attachments to destination, and replace with ghosts
            var ghostAttachments = CollectionUtils.Map(_attachments, (OrderAttachment a) => a.CreateGhostCopy());

            foreach (var a in _attachments)
            {
                destOrder.Attachments.Add(a);
            }
            _attachments.Clear();
            foreach (var ghost in ghostAttachments)
            {
                if (PersistenceScope.Current != null)
                {
                    PersistenceScope.CurrentContext.Lock(ghost.Document, DirtyState.New);
                }
                _attachments.Add(ghost);
            }

            // Move all the order notes to destination, and create ghosts of notes for this order
            var notes      = OrderNote.GetNotesForOrder(this);
            var ghostNotes = CollectionUtils.Map(notes, (OrderNote n) => n.CreateGhostCopy());

            foreach (var n in notes)
            {
                n.Order = destOrder;
            }
            foreach (var n in ghostNotes)
            {
                PersistenceScope.CurrentContext.Lock(n, DirtyState.New);
            }

            // Create ghost copies of the original procedures before it is added to the destinations
            // Theese ghost procedures are required for HL7 messages.
            var ghostProcedures = CollectionUtils.Map(_procedures, (Procedure p) => p.CreateGhostCopy());

            // Move all the procedures to the destination order.
            foreach (var p in _procedures)
            {
                destOrder.AddProcedure(p);
            }

            // update destination scheduling information
            destOrder.UpdateScheduling();

            // Add ghost procedures back to the source order.
            _procedures.AddAll(ghostProcedures);

            // Set source order to merged status
            SetStatus(OrderStatus.MG);

            return(new MergeResult {
                GhostProcedures = ghostProcedures
            });
        }