public GetConversationResponse GetConversation(GetConversationRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.OrderRef, "request.OrderRef");
var order = PersistenceContext.Load <Order>(request.OrderRef);
// select only notes that are actually posted, and meet category filter
var notes = CollectionUtils.Select(OrderNote.GetNotesForOrder(order),
n => n.IsPosted && (request.CategoryFilters == null || request.CategoryFilters.Count == 0 ||
request.CategoryFilters.Contains(n.Category)));
// put most recent notes first
notes.Reverse();
var noteAssembler = new OrderNoteAssembler();
if (request.CountOnly)
{
return(new GetConversationResponse(order.GetRef(), null, notes.Count));
}
return(new GetConversationResponse(
order.GetRef(),
CollectionUtils.Map(notes, (OrderNote n) => noteAssembler.CreateOrderNoteDetail(n, CurrentUserStaff, PersistenceContext)),
notes.Count));
}
private void AddAdditionalCommentsNote(OrderNoteDetail detail, Order order)
{
if (detail != null)
{
var noteAssembler = new OrderNoteAssembler();
noteAssembler.CreateOrderNote(detail, order, this.CurrentUserStaff, true, this.PersistenceContext);
}
}
private List <OrderNoteDetail> GetNoteDetails(Order order, string category)
{
var noteAssembler = new OrderNoteAssembler();
return(CollectionUtils.Map <OrderNote, OrderNoteDetail>(
OrderNote.GetNotesForOrder(order, new[] { category }, false),
note => noteAssembler.CreateOrderNoteDetail(note, this.PersistenceContext)));
}
public AcknowledgeAndPostResponse AcknowledgeAndPost(AcknowledgeAndPostRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.OrderRef, "request.OrderRef");
var order = PersistenceContext.Load <Order>(request.OrderRef);
// process acknowledgements first
if (request.OrderNotesToAcknowledge != null)
{
var notes = CollectionUtils.Map(request.OrderNotesToAcknowledge,
(EntityRef noteRef) => PersistenceContext.Load <OrderNote>(noteRef));
foreach (var note in notes)
{
//validate that the note is actually associated with the correct order
if (!Equals(note.Order, order))
{
throw new ArgumentException("Attempt to acknowledge a note that is not associated with this order.");
}
note.Acknowledge(CurrentUserStaff);
}
}
try
{
// process reply note
OrderNote replyNote = null;
var noteAssembler = new OrderNoteAssembler();
if (request.OrderNote != null)
{
replyNote = noteAssembler.CreateOrderNote(
request.OrderNote, order, CurrentUserStaff, true, PersistenceContext);
}
PersistenceContext.SynchState();
return(replyNote != null ?
new AcknowledgeAndPostResponse(noteAssembler.CreateOrderNoteDetail(replyNote, CurrentUserStaff, PersistenceContext))
: new AcknowledgeAndPostResponse(null));
}
catch (NoteAcknowledgementException e)
{
// occurs when there are notes that this author must ack prior to posting a new note
throw new RequestValidationException(e.Message);
}
}
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);
}
}
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 SaveOrderDocumentationDataResponse SaveOrderDocumentationData(SaveOrderDocumentationDataRequest request)
{
var order = this.PersistenceContext.Load <Order>(request.OrderRef);
ExtendedPropertyUtils.Update(order.ExtendedProperties, request.OrderExtendedProperties);
var dicomSeriesAssembler = new DicomSeriesAssembler();
foreach (var detail in request.ModalityPerformedProcedureSteps)
{
var mpps = this.PersistenceContext.Load <ModalityPerformedProcedureStep>(detail.ModalityPerformendProcedureStepRef);
ExtendedPropertyUtils.Update(mpps.ExtendedProperties, detail.ExtendedProperties);
dicomSeriesAssembler.SynchronizeDicomSeries(mpps, detail.DicomSeries, this.PersistenceContext);
}
// add new order notes
var noteAssembler = new OrderNoteAssembler();
noteAssembler.SynchronizeOrderNotes(order, request.OrderNotes, CurrentUserStaff, this.PersistenceContext);
// assign all procedures for this order to the specified interpreter (or unassign them, if null)
var interpreter = request.AssignedInterpreter == null
? null
: this.PersistenceContext.Load <Staff>(request.AssignedInterpreter.StaffRef, EntityLoadFlags.Proxy);
foreach (var procedure in order.Procedures)
{
if (procedure.IsPerformed)
{
var interpretationStep = GetPendingInterpretationStep(procedure);
if (interpretationStep != null)
{
interpretationStep.Assign(interpreter);
}
}
}
this.PersistenceContext.SynchState();
var planAssembler = new ProcedurePlanAssembler();
return(new SaveOrderDocumentationDataResponse(planAssembler.CreateProcedurePlanSummary(order, this.PersistenceContext)));
}
public LoadOrderDocumentationDataResponse LoadOrderDocumentationData(LoadOrderDocumentationDataRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.OrderRef, "OrderRef");
var order = this.PersistenceContext.Load <Order>(request.OrderRef);
var noteAssembler = new OrderNoteAssembler();
return(new LoadOrderDocumentationDataResponse
{
OrderRef = order.GetRef(),
OrderExtendedProperties = ExtendedPropertyUtils.Copy(order.ExtendedProperties),
OrderNotes = CollectionUtils.Map <OrderNote, OrderNoteDetail>(
OrderNote.GetNotesForOrder(order),
note => noteAssembler.CreateOrderNoteDetail(note, PersistenceContext)),
AssignedInterpreter = GetUniqueAssignedInterpreter(order)
});
}
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);
}
private Order PlaceOrderHelper(OrderRequisition requisition)
{
// get appropriate A# for this order
var accNum = GetAccessionNumberForOrder(requisition);
var patient = this.PersistenceContext.Load <Patient>(requisition.Patient.PatientRef, EntityLoadFlags.Proxy);
var orderingFacility = this.PersistenceContext.Load <Facility>(requisition.OrderingFacility.FacilityRef, EntityLoadFlags.Proxy);
var visit = FindOrCreateVisit(requisition, patient, orderingFacility, accNum);
var orderingPhysician = this.PersistenceContext.Load <ExternalPractitioner>(requisition.OrderingPractitioner.PractitionerRef, EntityLoadFlags.Proxy);
var diagnosticService = this.PersistenceContext.Load <DiagnosticService>(requisition.DiagnosticService.DiagnosticServiceRef);
var priority = EnumUtils.GetEnumValue <OrderPriority>(requisition.Priority);
var resultRecipients = CollectionUtils.Map(
requisition.ResultRecipients ?? new List <ResultRecipientDetail>(),
(ResultRecipientDetail s) => new ResultRecipient(
this.PersistenceContext.Load <ExternalPractitionerContactPoint>(s.ContactPoint.ContactPointRef, EntityLoadFlags.Proxy),
EnumUtils.GetEnumValue <ResultCommunicationMode>(s.PreferredCommunicationMode)));
// generate set of procedures
// create a temp map from procedure back to its requisition, this will be needed later
var orderAssembler = new OrderEntryAssembler();
var mapProcToReq = new Dictionary <Procedure, ProcedureRequisition>();
var procedureNumberBroker = PersistenceContext.GetBroker <IProcedureNumberBroker>();
var dicomUidBroker = PersistenceContext.GetBroker <IDicomUidBroker>();
var procedures = CollectionUtils.Map(
requisition.Procedures ?? new List <ProcedureRequisition>(),
delegate(ProcedureRequisition req)
{
var rpt = this.PersistenceContext.Load <ProcedureType>(req.ProcedureType.ProcedureTypeRef);
var rp = new Procedure(rpt, procedureNumberBroker.GetNext(), dicomUidBroker.GetNewUid());
mapProcToReq.Add(rp, req);
// important to set this flag prior to creating the procedure steps, because it may affect
// which procedure steps are created
rp.DowntimeRecoveryMode = requisition.IsDowntimeOrder;
return(rp);
});
// generate a new order with the default set of procedures
var order = Order.NewOrder(
new OrderCreationArgs(
Platform.Time,
this.CurrentUserStaff,
null,
accNum,
patient,
visit,
diagnosticService,
requisition.ReasonForStudy,
priority,
orderingFacility,
requisition.SchedulingRequestTime,
orderingPhysician,
resultRecipients,
procedures),
procedureNumberBroker,
dicomUidBroker);
// note: need to lock the new order now, prior to creating the procedure steps
// otherwise may get exceptions saying the Procedure is a transient object
this.PersistenceContext.Lock(order, DirtyState.New);
// create procedure steps and update from requisition
foreach (var procedure in order.Procedures)
{
procedure.CreateProcedureSteps();
if (mapProcToReq.ContainsKey(procedure))
{
orderAssembler.UpdateProcedureFromRequisition(procedure, mapProcToReq[procedure], this.CurrentUserStaff, this.PersistenceContext);
}
}
// add order notes
if (requisition.Notes != null)
{
var noteAssembler = new OrderNoteAssembler();
noteAssembler.SynchronizeOrderNotes(order, requisition.Notes, this.CurrentUserStaff, this.PersistenceContext);
}
// add attachments
if (requisition.Attachments != null)
{
var attachmentAssembler = new OrderAttachmentAssembler();
attachmentAssembler.Synchronize(order.Attachments, requisition.Attachments, this.CurrentUserStaff, this.PersistenceContext);
}
if (requisition.ExtendedProperties != null)
{
ExtendedPropertyUtils.Update(order.ExtendedProperties, requisition.ExtendedProperties);
}
return(order);
}
private void AddAdditionalCommentsNote(OrderNoteDetail detail, Order order)
{
if (detail == null) return;
var noteAssembler = new OrderNoteAssembler();
noteAssembler.CreateOrderNote(detail, order, this.CurrentUserStaff, true, this.PersistenceContext);
}
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);
}
}
public SaveOrderDocumentationDataResponse SaveOrderDocumentationData(SaveOrderDocumentationDataRequest request)
{
var order = this.PersistenceContext.Load<Order>(request.OrderRef);
ExtendedPropertyUtils.Update(order.ExtendedProperties, request.OrderExtendedProperties);
var dicomSeriesAssembler = new DicomSeriesAssembler();
foreach (var detail in request.ModalityPerformedProcedureSteps)
{
var mpps = this.PersistenceContext.Load<ModalityPerformedProcedureStep>(detail.ModalityPerformendProcedureStepRef);
ExtendedPropertyUtils.Update(mpps.ExtendedProperties, detail.ExtendedProperties);
dicomSeriesAssembler.SynchronizeDicomSeries(mpps, detail.DicomSeries, this.PersistenceContext);
}
// add new order notes
var noteAssembler = new OrderNoteAssembler();
noteAssembler.SynchronizeOrderNotes(order, request.OrderNotes, CurrentUserStaff, this.PersistenceContext);
// assign all procedures for this order to the specified interpreter (or unassign them, if null)
var interpreter = request.AssignedInterpreter == null
? null
: this.PersistenceContext.Load<Staff>(request.AssignedInterpreter.StaffRef, EntityLoadFlags.Proxy);
foreach (var procedure in order.Procedures)
{
if (procedure.IsPerformed)
{
var interpretationStep = GetPendingInterpretationStep(procedure);
if (interpretationStep != null)
{
interpretationStep.Assign(interpreter);
}
}
}
this.PersistenceContext.SynchState();
var planAssembler = new ProcedurePlanAssembler();
return new SaveOrderDocumentationDataResponse(planAssembler.CreateProcedurePlanSummary(order, this.PersistenceContext));
}
private Order PlaceOrderHelper(OrderRequisition requisition)
{
// get appropriate A# for this order
var accNum = GetAccessionNumberForOrder(requisition);
var patient = this.PersistenceContext.Load<Patient>(requisition.Patient.PatientRef, EntityLoadFlags.Proxy);
var orderingFacility = this.PersistenceContext.Load<Facility>(requisition.OrderingFacility.FacilityRef, EntityLoadFlags.Proxy);
var visit = FindOrCreateVisit(requisition, patient, orderingFacility, accNum);
var orderingPhysician = this.PersistenceContext.Load<ExternalPractitioner>(requisition.OrderingPractitioner.PractitionerRef, EntityLoadFlags.Proxy);
var diagnosticService = this.PersistenceContext.Load<DiagnosticService>(requisition.DiagnosticService.DiagnosticServiceRef);
var priority = EnumUtils.GetEnumValue<OrderPriority>(requisition.Priority);
var resultRecipients = CollectionUtils.Map(
requisition.ResultRecipients ?? new List<ResultRecipientDetail>(),
(ResultRecipientDetail s) => new ResultRecipient(
this.PersistenceContext.Load<ExternalPractitionerContactPoint>(s.ContactPoint.ContactPointRef, EntityLoadFlags.Proxy),
EnumUtils.GetEnumValue<ResultCommunicationMode>(s.PreferredCommunicationMode)));
// generate set of procedures
// create a temp map from procedure back to its requisition, this will be needed later
var orderAssembler = new OrderEntryAssembler();
var mapProcToReq = new Dictionary<Procedure, ProcedureRequisition>();
var procedureNumberBroker = PersistenceContext.GetBroker<IProcedureNumberBroker>();
var dicomUidBroker = PersistenceContext.GetBroker<IDicomUidBroker>();
var procedures = CollectionUtils.Map(
requisition.Procedures ?? new List<ProcedureRequisition>(),
delegate(ProcedureRequisition req)
{
var rpt = this.PersistenceContext.Load<ProcedureType>(req.ProcedureType.ProcedureTypeRef);
var rp = new Procedure(rpt, procedureNumberBroker.GetNext(), dicomUidBroker.GetNewUid());
mapProcToReq.Add(rp, req);
// important to set this flag prior to creating the procedure steps, because it may affect
// which procedure steps are created
rp.DowntimeRecoveryMode = requisition.IsDowntimeOrder;
return rp;
});
// generate a new order with the default set of procedures
var order = Order.NewOrder(
new OrderCreationArgs(
Platform.Time,
this.CurrentUserStaff,
null,
accNum,
patient,
visit,
diagnosticService,
requisition.ReasonForStudy,
priority,
orderingFacility,
requisition.SchedulingRequestTime,
orderingPhysician,
resultRecipients,
procedures),
procedureNumberBroker,
dicomUidBroker);
// note: need to lock the new order now, prior to creating the procedure steps
// otherwise may get exceptions saying the Procedure is a transient object
this.PersistenceContext.Lock(order, DirtyState.New);
// create procedure steps and update from requisition
foreach (var procedure in order.Procedures)
{
procedure.CreateProcedureSteps();
if(mapProcToReq.ContainsKey(procedure))
{
orderAssembler.UpdateProcedureFromRequisition(procedure, mapProcToReq[procedure], this.CurrentUserStaff, this.PersistenceContext);
}
}
// add order notes
if (requisition.Notes != null)
{
var noteAssembler = new OrderNoteAssembler();
noteAssembler.SynchronizeOrderNotes(order, requisition.Notes, this.CurrentUserStaff, this.PersistenceContext);
}
// add attachments
if(requisition.Attachments != null)
{
var attachmentAssembler = new OrderAttachmentAssembler();
attachmentAssembler.Synchronize(order.Attachments, requisition.Attachments, this.CurrentUserStaff, this.PersistenceContext);
}
if (requisition.ExtendedProperties != null)
{
ExtendedPropertyUtils.Update(order.ExtendedProperties, requisition.ExtendedProperties);
}
return order;
}
/// <summary>
/// Creates order detail document including only specified parts.
/// </summary>
public OrderDetail CreateOrderDetail(Order order, CreateOrderDetailOptions options, IPersistenceContext context)
{
var orderDetail = new OrderDetail();
var practitionerAssembler = new ExternalPractitionerAssembler();
var facilityAssembler = new FacilityAssembler();
var dsAssembler = new DiagnosticServiceAssembler();
var procedureAssembler = new ProcedureAssembler();
var staffAssembler = new StaffAssembler();
orderDetail.OrderRef = order.GetRef();
orderDetail.PatientRef = order.Patient.GetRef();
if (options.IncludeVisit)
{
var visitAssembler = new VisitAssembler();
orderDetail.Visit = visitAssembler.CreateVisitDetail(order.Visit, context);
}
orderDetail.PlacerNumber = order.PlacerNumber;
orderDetail.AccessionNumber = order.AccessionNumber;
orderDetail.DiagnosticService = dsAssembler.CreateSummary(order.DiagnosticService);
orderDetail.EnteredTime = order.EnteredTime;
orderDetail.EnteredBy = order.EnteredBy == null ? null :
staffAssembler.CreateStaffSummary(order.EnteredBy, context);
orderDetail.EnteredComment = order.EnteredComment;
orderDetail.SchedulingRequestTime = order.SchedulingRequestTime;
orderDetail.OrderingPractitioner = practitionerAssembler.CreateExternalPractitionerSummary(order.OrderingPractitioner, context);
orderDetail.OrderingFacility = facilityAssembler.CreateFacilitySummary(order.OrderingFacility);
orderDetail.ReasonForStudy = order.ReasonForStudy;
orderDetail.OrderPriority = EnumUtils.GetEnumValueInfo(order.Priority, context);
if (order.CancelInfo != null)
{
orderDetail.CancelReason = order.CancelInfo.Reason == null ? null : EnumUtils.GetEnumValueInfo(order.CancelInfo.Reason);
orderDetail.CancelledBy = order.CancelInfo.CancelledBy == null ? null :
staffAssembler.CreateStaffSummary(order.CancelInfo.CancelledBy, context);
orderDetail.CancelComment = order.CancelInfo.Comment;
}
if (options.IncludeProcedures)
{
orderDetail.Procedures = CollectionUtils.Map(order.Procedures,
(Procedure p) => procedureAssembler.CreateProcedureDetail(p, context));
}
if (options.IncludeNotes)
{
var orderNoteAssembler = new OrderNoteAssembler();
var orderNotes = new List<OrderNote>(OrderNote.GetNotesForOrder(order, options.NoteCategoriesFilter, options.IncludeVirtualNotes));
// sort notes by post-time (guaranteed non-null because only "posted" notes are in this collection)
orderNotes.Sort((x, y) => x.PostTime.Value.CompareTo(y.PostTime.Value));
// Put most recent notes first
orderNotes.Reverse();
orderDetail.Notes = CollectionUtils.Map<OrderNote, OrderNoteSummary>(
orderNotes,
note => orderNoteAssembler.CreateOrderNoteSummary(note, context));
}
if (options.IncludeAttachments)
{
var orderAttachmentAssembler = new OrderAttachmentAssembler();
var attachments = new List<OrderAttachment>(order.Attachments);
orderDetail.Attachments = CollectionUtils.Map<OrderAttachment, AttachmentSummary>(
attachments,
a => orderAttachmentAssembler.CreateOrderAttachmentSummary(a, context));
}
if (options.IncludeResultRecipients)
{
var resultRecipientAssembler = new ResultRecipientAssembler();
var resultRecipients = new List<ResultRecipient>(order.ResultRecipients);
orderDetail.ResultRecipients = CollectionUtils.Map<ResultRecipient, ResultRecipientDetail>(
resultRecipients,
r => resultRecipientAssembler.CreateResultRecipientDetail(r, context));
}
if (options.IncludeExtendedProperties)
{
orderDetail.ExtendedProperties = ExtendedPropertyUtils.Copy(order.ExtendedProperties);
}
return orderDetail;
}
private void UpdateOrderNotes(Order order, IList <OrderNoteDetail> notes)
{
var noteAssembler = new OrderNoteAssembler();
noteAssembler.SynchronizeOrderNotes(order, notes, this.CurrentUserStaff, this.PersistenceContext);
}
public LoadOrderDocumentationDataResponse LoadOrderDocumentationData(LoadOrderDocumentationDataRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.OrderRef, "OrderRef");
var order = this.PersistenceContext.Load<Order>(request.OrderRef);
var noteAssembler = new OrderNoteAssembler();
return new LoadOrderDocumentationDataResponse
{
OrderRef = order.GetRef(),
OrderExtendedProperties = ExtendedPropertyUtils.Copy(order.ExtendedProperties),
OrderNotes = CollectionUtils.Map<OrderNote, OrderNoteDetail>(
OrderNote.GetNotesForOrder(order),
note => noteAssembler.CreateOrderNoteDetail(note, PersistenceContext)),
AssignedInterpreter = GetUniqueAssignedInterpreter(order)
};
}
