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