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 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)));
}
/// <summary>
/// Synchronizes an order's Notes collection, adding any notes that don't already exist in the collection,
/// using the specified author. The notes are posted immediately.
/// </summary>
/// <param name="order"></param>
/// <param name="sourceList"></param>
/// <param name="newNoteAuthor"></param>
/// <param name="context"></param>
public void SynchronizeOrderNotes(Order order, IList <OrderNoteDetail> sourceList, Staff newNoteAuthor, IPersistenceContext context)
{
List <OrderNote> existingNotes = new List <OrderNote>(OrderNote.GetNotesForOrder(order));
foreach (OrderNoteDetail detail in sourceList)
{
if (!CollectionUtils.Contains(existingNotes,
delegate(OrderNote n) { return(n.GetRef().Equals(detail.OrderNoteRef)); }))
{
CreateOrderNote(detail, order, newNoteAuthor, true, context);
}
}
}
public void SetOrderNotes(ORU_R01 oru, Order order)
{
var i = 0;
foreach (var orderNote in OrderNote.GetNotesForOrder(order, "General", false))
{
var nte = oru.GetPATIENT_RESULT().GetORDER_OBSERVATION().GetNTE(i);
nte.SetIDNTE.Value = (i + 1).ToString(CultureInfo.InvariantCulture);
nte.SourceOfComment.Value = "????";
nte.GetComment(0).Value = orderNote.Body;
i++;
}
}
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);
}
/// <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);
}
