protected OrderEditorArgs(DesktopWindow desktopWindow, PatientProfileSummary patientProfile, OrderRequisition requisition, OrderSubmitType submitType)
: base(desktopWindow)
{
PatientProfile = patientProfile;
Requisition = requisition;
SubmitType = submitType;
}
/// <summary>
/// Finds the visit specified in the requisition, or if no visit is specified, auto-generates a visit.
/// </summary>
/// <param name="requisition"></param>
/// <param name="patient"></param>
/// <param name="orderingFacility"></param>
/// <returns></returns>
private Visit FindOrCreateVisit(OrderRequisition requisition, Patient patient, Facility orderingFacility, string accessionNumber)
{
if (requisition.Visit != null && requisition.Visit.VisitRef != null)
{
return(this.PersistenceContext.Load <Visit>(requisition.Visit.VisitRef, EntityLoadFlags.Proxy));
}
// if Visit Workflow is disabled, then we must auto-generate a "dummy" visit in order to keep the system happy
// the user will never see this dummy visit
if (!new WorkflowConfigurationReader().EnableVisitWorkflow)
{
var patientClasses = PersistenceContext.GetBroker <IEnumBroker>().Load <PatientClassEnum>(false);
// create a visit using the minimum possible amount of information
var visit = new Visit
{
Patient = patient,
VisitNumber = new VisitNumber(accessionNumber, orderingFacility.InformationAuthority),
Status = VisitStatus.AA,
AdmitTime = Platform.Time,
Facility = orderingFacility,
PatientClass = CollectionUtils.FirstElement(patientClasses)
};
this.PersistenceContext.Lock(visit, DirtyState.New);
return(visit);
}
throw new RequestValidationException("A visit is required.");
}
internal override EntityRef Submit(OrderRequisition requisition, OrderEditorComponent component)
{
ReplaceOrderResponse response = null;
Platform.GetService <IOrderEntryService>(
service => response = service.ReplaceOrder(new ReplaceOrderRequest(this.OrderRef, component.SelectedCancelReason, requisition))
);
return(response.Order.OrderRef);
}
internal override EntityRef Submit(OrderRequisition requisition, OrderEditorComponent component)
{
PlaceOrderResponse response = null;
Platform.GetService <IOrderEntryService>(
service => response = service.PlaceOrder(new PlaceOrderRequest(requisition))
);
return(response.Order.OrderRef);
}
internal override EntityRef Submit(OrderRequisition requisition, OrderEditorComponent component)
{
ModifyOrderResponse response = null;
requisition.OrderRef = component.OrderRef;
Platform.GetService <IOrderEntryService>(service =>
{
response = service.ModifyOrder(new ModifyOrderRequest(requisition));
});
return(response.Order.OrderRef);
}
/// <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();
}
}
}
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);
}
private string GetAccessionNumberForOrder(OrderRequisition requisition)
{
// if this is a downtime requisition, validate the downtime A#, otherwise obtain a new A#
var accessionBroker = this.PersistenceContext.GetBroker <IAccessionNumberBroker>();
if (requisition.IsDowntimeOrder)
{
// validate that the downtime A# is less than then current sequence position
var currentMaxAccession = accessionBroker.PeekNext();
if (requisition.DowntimeAccessionNumber.CompareTo(currentMaxAccession) > -1)
{
throw new RequestValidationException("Invalid downtime accession number.");
}
return(requisition.DowntimeAccessionNumber);
}
// get new A#
return(this.PersistenceContext.GetBroker <IAccessionNumberBroker>().GetNext());
}
/// <summary> /// Submit the specified order requisition to the server. /// </summary> /// <param name="requisition"></param> /// <param name="component"></param> /// <returns></returns> internal abstract EntityRef Submit(OrderRequisition requisition, OrderEditorComponent component);
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);
}
public OrderSubmittedArgs(DesktopWindow desktopWindow, PatientProfileSummary patientProfile, OrderRequisition requisition, OrderSubmitType submitType)
: base(desktopWindow, patientProfile, requisition, submitType)
{
}
public void AddToOrderRequisitions(OrderRequisition orderRequisition)
{
base.AddObject("OrderRequisitions", orderRequisition);
}
public static OrderRequisition CreateOrderRequisition(int ID, string orderRequisitionNo, global::System.DateTime orderRequisitionDate, int requisition_Customer, bool status, byte[] rowVersion)
{
OrderRequisition orderRequisition = new OrderRequisition();
orderRequisition.Id = ID;
orderRequisition.OrderRequisitionNo = orderRequisitionNo;
orderRequisition.OrderRequisitionDate = orderRequisitionDate;
orderRequisition.Requisition_Customer = requisition_Customer;
orderRequisition.Status = status;
orderRequisition.RowVersion = rowVersion;
return orderRequisition;
}
/// <summary>
/// Create a random order on the specified visit.
/// </summary>
/// <param name="visit">Visit/patient for which the order is created.</param>
/// <param name="informationAuthority">Performing facility will be selected to match this information authority.</param>
/// <param name="diagnosticServiceName">Name of the diagnostic service to order.</param>
/// <param name="schedulingOffsetDays">A positive or negative number of days from today.</param>
/// <param name="modalityName">The name of the modality.</param>
/// <param name="facilityCode">The code of the ordering and performing facility.</param>
/// <param name="laterality">The procedure laterality.</param>
/// <returns></returns>
public static OrderSummary RandomOrder(VisitSummary visit, EnumValueInfo informationAuthority, string diagnosticServiceName, int schedulingOffsetDays, string modalityName, string facilityCode, EnumValueInfo laterality)
{
InitReferenceDataCacheOnce();
var scheduledTime = Platform.Time + TimeSpan.FromDays(schedulingOffsetDays);
LoadDiagnosticServicePlanResponse dsResponse = null;
OrderSummary orderSummary = null;
Platform.GetService(
delegate(IOrderEntryService service)
{
DiagnosticServiceSummary diagnosticService;
if (String.IsNullOrEmpty(diagnosticServiceName) && String.IsNullOrEmpty(modalityName))
{
diagnosticService = ChooseRandom(_diagnosticServices);
dsResponse = service.LoadDiagnosticServicePlan(new LoadDiagnosticServicePlanRequest(diagnosticService.DiagnosticServiceRef));
}
else
{
diagnosticService = CollectionUtils.SelectFirst(_diagnosticServices,
delegate(DiagnosticServiceSummary ds)
{
dsResponse = service.LoadDiagnosticServicePlan(new LoadDiagnosticServicePlanRequest(ds.DiagnosticServiceRef));
return((ds.Name == diagnosticServiceName) ||
(!String.IsNullOrEmpty(modalityName) && (CollectionUtils.SelectFirst(dsResponse.DiagnosticServicePlan.ProcedureTypes,
ptd => ptd.Name.IndexOf(modalityName) == 0) != null)));
});
if (diagnosticService == null)
{
throw new Exception(String.Format("Cannot find diagnostic service with name {0}", diagnosticServiceName));
}
}
var performingFacility = CollectionUtils.SelectFirst(_orderEntryFormData.FacilityChoices,
delegate(FacilitySummary facility)
{
if (facilityCode == null)
{
return(facility.InformationAuthority.Code == informationAuthority.Code);
}
return(facility.Code == facilityCode);
});
var randomPhysician = ChooseRandom(_practitioners);
var randomPriority = ChooseRandom(_orderEntryFormData.OrderPriorityChoices);
var requisition = new OrderRequisition
{
Patient = visit.Patient,
Visit = visit,
DiagnosticService = diagnosticService,
OrderingPractitioner = randomPhysician,
OrderingFacility = performingFacility,
Priority = randomPriority,
ReasonForStudy = "Randomly generated test order",
SchedulingRequestTime = scheduledTime,
Procedures = new List <ProcedureRequisition>(),
ResultRecipients = new List <ResultRecipientDetail>(),
Attachments = new List <AttachmentSummary>(),
Notes = new List <OrderNoteDetail>()
};
requisition.Procedures.AddRange(
CollectionUtils.Map(dsResponse.DiagnosticServicePlan.ProcedureTypes,
(ProcedureTypeSummary rpt) => new ProcedureRequisition(rpt, performingFacility)
{
ScheduledTime = scheduledTime,
Laterality = laterality,
ScheduledDuration = 30 // default to a non-zero scheduled duration
}));
var response = service.PlaceOrder(new PlaceOrderRequest(requisition));
orderSummary = response.Order;
});
return(orderSummary);
}
