public MergeOrderResponse MergeOrder(MergeOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.SourceOrderRefs, "SourceOrderRefs");
Platform.CheckTrue(request.SourceOrderRefs.Count > 0, "SourceOrderRefs.Count > 0");
Platform.CheckMemberIsSet(request.DestinationOrderRef, "DestinationOrderRef");
var response = new MergeOrderResponse();
DryRunHelper(request.DryRun,
delegate
{
var destinationOrder = this.PersistenceContext.Load <Order>(request.DestinationOrderRef);
var sourceOrders = CollectionUtils.Map(request.SourceOrderRefs, (EntityRef r) => PersistenceContext.Load <Order>(r));
var mergeInfo = new OrderMergeInfo(this.CurrentUserStaff, Platform.Time, destinationOrder);
MergeOrderHelper(destinationOrder, sourceOrders, mergeInfo, request.ValidationOnly);
if (request.DryRun)
{
var orderAssembler = new OrderAssembler();
var orderDetail = orderAssembler.CreateOrderDetail(destinationOrder,
OrderAssembler.CreateOrderDetailOptions.GetVerboseOptions(), PersistenceContext);
response.DryRunMergedOrder = orderDetail;
}
});
return(response);
}
private GetOrderDetailResponse GetOrderDetail(GetOrderDetailRequest request)
{
var order = this.PersistenceContext.GetBroker <IOrderBroker>().Load(request.OrderRef);
var createOrderDetailOptions = new OrderAssembler.CreateOrderDetailOptions
{
IncludeVisit = request.IncludeVisit && (new WorkflowConfigurationReader()).EnableVisitWorkflow,
IncludeProcedures = request.IncludeProcedures,
IncludeNotes = request.IncludeNotes,
IncludeVirtualNotes = request.IncludeNotes, // include virtual notes, if including notes at all
NoteCategoriesFilter = request.NoteCategoriesFilter,
IncludeAttachments = request.IncludeAttachments,
IncludeResultRecipients = request.IncludeResultRecipients,
IncludeExtendedProperties = request.IncludeExtendedProperties
};
var response = new GetOrderDetailResponse();
var orderAssembler = new OrderAssembler();
response.Order = orderAssembler.CreateOrderDetail(order, createOrderDetailOptions, this.PersistenceContext);
if (request.IncludeAlerts)
{
var alertAssembler = new AlertAssembler();
response.OrderAlerts =
CollectionUtils.Map <AlertNotification, AlertNotificationDetail>(
AlertHelper.Instance.Test(order, this.PersistenceContext),
alertAssembler.CreateAlertNotification);
}
return(response);
}
public LoadTranscriptionForEditResponse LoadTranscriptionForEdit(LoadTranscriptionForEditRequest request)
{
var step = this.PersistenceContext.Load<ReportingProcedureStep>(request.ReportingStepRef, EntityLoadFlags.CheckVersion);
var reportAssembler = new ReportAssembler();
var orderAssembler = new OrderAssembler();
var orderDetailOptions = new OrderAssembler.CreateOrderDetailOptions {IncludeExtendedProperties = true};
return new LoadTranscriptionForEditResponse(
reportAssembler.CreateReportDetail(step.ReportPart.Report, false, this.PersistenceContext),
step.ReportPart.Index,
orderAssembler.CreateOrderDetail(step.Procedure.Order, orderDetailOptions, this.PersistenceContext));
}
public ListOrdersForPatientResponse ListActiveOrdersForPatient(ListOrdersForPatientRequest request)
{
var criteria = new OrderSearchCriteria();
var profile = this.PersistenceContext.Load<PatientProfile>(request.PatientProfileRef);
criteria.Patient.EqualTo(profile.Patient);
criteria.Status.In(new[] { OrderStatus.SC, OrderStatus.IP });
var assembler = new OrderAssembler();
return new ListOrdersForPatientResponse(
CollectionUtils.Map<Order, OrderSummary, List<OrderSummary>>(
this.PersistenceContext.GetBroker<IOrderBroker>().Find(criteria),
order => assembler.CreateOrderSummary(order, this.PersistenceContext)));
}
public LoadTranscriptionForEditResponse LoadTranscriptionForEdit(LoadTranscriptionForEditRequest request)
{
var step = this.PersistenceContext.Load <ReportingProcedureStep>(request.ReportingStepRef, EntityLoadFlags.CheckVersion);
var reportAssembler = new ReportAssembler();
var orderAssembler = new OrderAssembler();
var orderDetailOptions = new OrderAssembler.CreateOrderDetailOptions {
IncludeExtendedProperties = true
};
return(new LoadTranscriptionForEditResponse(
reportAssembler.CreateReportDetail(step.ReportPart.Report, false, this.PersistenceContext),
step.ReportPart.Index,
orderAssembler.CreateOrderDetail(step.Procedure.Order, orderDetailOptions, this.PersistenceContext)));
}
public ListOrdersForPatientResponse ListActiveOrdersForPatient(ListOrdersForPatientRequest request)
{
var criteria = new OrderSearchCriteria();
var profile = this.PersistenceContext.Load <PatientProfile>(request.PatientProfileRef);
criteria.Patient.EqualTo(profile.Patient);
criteria.Status.In(new[] { OrderStatus.SC, OrderStatus.IP });
var assembler = new OrderAssembler();
return(new ListOrdersForPatientResponse(
CollectionUtils.Map <Order, OrderSummary, List <OrderSummary> >(
this.PersistenceContext.GetBroker <IOrderBroker>().Find(criteria),
order => assembler.CreateOrderSummary(order, this.PersistenceContext))));
}
public StartProtocolResponse StartProtocol(StartProtocolRequest request)
{
var assignmentStep = this.PersistenceContext.Load <ProtocolAssignmentStep>(request.ProtocolAssignmentStepRef);
var protocolClaimed = false;
var canPerformerAcceptProtocols = Thread.CurrentPrincipal.IsInRole(Extended.Common.AuthorityTokens.Workflow.Protocol.Accept);
Staff assignedStaff = null;
var linkedSteps = new List <ProtocolAssignmentStep>();
if (request.LinkedProtocolAssignmentStepRefs != null && request.LinkedProtocolAssignmentStepRefs.Count > 0)
{
linkedSteps = CollectionUtils.Map <EntityRef, ProtocolAssignmentStep>(
request.LinkedProtocolAssignmentStepRefs,
stepRef => this.PersistenceContext.Load <ProtocolAssignmentStep>(stepRef));
}
if (request.ShouldClaim)
{
try
{
var op = new ProtocollingOperations.StartProtocolOperation();
op.Execute(assignmentStep, linkedSteps, this.CurrentUserStaff, canPerformerAcceptProtocols, out protocolClaimed, out assignedStaff);
}
catch (Exception e)
{
throw new RequestValidationException(e.Message);
}
}
var noteDetails = GetNoteDetails(assignmentStep.Procedure.Order, request.NoteCategory);
var orderAssembler = new OrderAssembler();
var orderDetailOptions = new OrderAssembler.CreateOrderDetailOptions {
IncludeExtendedProperties = true
};
var orderDetail = orderAssembler.CreateOrderDetail(assignmentStep.Procedure.Order, orderDetailOptions, this.PersistenceContext);
this.PersistenceContext.SynchState();
return(new StartProtocolResponse(
assignmentStep.GetRef(),
assignedStaff == null ? null : assignedStaff.GetRef(),
protocolClaimed,
noteDetails,
orderDetail));
}
public PlaceOrderResponse PlaceOrder(PlaceOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.Requisition, "Requisition");
var order = PlaceOrderHelper(request.Requisition);
ValidateVisitsExist(order);
// ensure the new order is assigned an OID before using it in the return value
this.PersistenceContext.SynchState();
LogicalHL7Event.OrderCreated.EnqueueEvents(order);
var orderAssembler = new OrderAssembler();
return(new PlaceOrderResponse(orderAssembler.CreateOrderSummary(order, this.PersistenceContext)));
}
public ModifyOrderResponse ModifyOrder(ModifyOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.Requisition, "Requisition");
Platform.CheckMemberIsSet(request.Requisition.OrderRef, "OrderRef");
var order = this.PersistenceContext.Load <Order>(request.Requisition.OrderRef);
var assembler = new OrderEntryAssembler();
assembler.UpdateOrderFromRequisition(order, request.Requisition, this.CurrentUserStaff, this.PersistenceContext);
UpdateProceduresHelper(order, request.Requisition.Procedures, request);
ValidateVisitsExist(order);
this.PersistenceContext.SynchState();
var orderAssembler = new OrderAssembler();
return(new ModifyOrderResponse(orderAssembler.CreateOrderSummary(order, this.PersistenceContext)));
}
public TimeShiftOrderResponse TimeShiftOrder(TimeShiftOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.OrderRef, "OrderRef");
// load the order, explicitly ignoring the version (since this is only used for testing/demo data creation, we don't care)
var order = this.PersistenceContext.Load <Order>(request.OrderRef, EntityLoadFlags.None);
// shift the order, which will also shift all procedures, etc.
order.TimeShift(request.NumberOfMinutes);
// shift the visit
order.Visit.TimeShift(request.NumberOfMinutes);
this.PersistenceContext.SynchState();
LogicalHL7Event.OrderModified.EnqueueEvents(order);
var orderAssembler = new OrderAssembler();
return(new TimeShiftOrderResponse(orderAssembler.CreateOrderSummary(order, this.PersistenceContext)));
}
public void Should_be_able_to_assemble_item()
{
var now = DateTime.Now;
var mappedData = new MappedData();
var orderTable = new DataTable();
orderTable.Columns.Add("OrderNumber", typeof(string));
orderTable.Columns.Add("OrderDate", typeof(DateTime));
const string orderNumber = "ON-10";
mappedData.Add(new MappedRow<Order>(orderTable.Rows.Add(orderNumber, now), new Order(orderNumber, now)));
var orderLineTable = new DataTable();
orderLineTable.Columns.Add("OrderNumber", typeof(string));
orderLineTable.Columns.Add("ProductId", typeof(string));
orderLineTable.Columns.Add("Quantity", typeof(int));
orderLineTable.Columns.Add("UnitCost", typeof(double));
mappedData.Add(new List<MappedRow<OrderLine>>
{
new MappedRow<OrderLine>(orderLineTable.Rows.Add(orderNumber, "SKU-1", 5, 10), new OrderLine("SKU-1", 5, 10)),
new MappedRow<OrderLine>(orderLineTable.Rows.Add(orderNumber, "SKU-2", 1, 65), new OrderLine("SKU-2", 1, 65)),
new MappedRow<OrderLine>(orderLineTable.Rows.Add(orderNumber, "SKU-3", 10, 10.5), new OrderLine("SKU-3", 10, 10.5))
});
var order = new OrderAssembler().AssembleItem(mappedData);
Assert.AreEqual(orderNumber, order.OrderNumber);
Assert.AreEqual(now, order.OrderDate);
Assert.AreEqual(3, order.Lines.Count());
Assert.AreEqual(50, order.Lines.ElementAt(0).TotalCost());
Assert.AreEqual(65, order.Lines.ElementAt(1).TotalCost());
Assert.AreEqual(105, order.Lines.ElementAt(2).TotalCost());
Assert.AreEqual(220, order.Total());
}
public void Should_be_able_to_assemble_item()
{
var now = DateTime.Now;
var mappedData = new MappedData();
var orderTable = new DataTable();
orderTable.Columns.Add("OrderNumber", typeof(string));
orderTable.Columns.Add("OrderDate", typeof(DateTime));
const string orderNumber = "ON-10";
mappedData.Add(new MappedRow <Order>(orderTable.Rows.Add(orderNumber, now), new Order(orderNumber, now)));
var orderLineTable = new DataTable();
orderLineTable.Columns.Add("OrderNumber", typeof(string));
orderLineTable.Columns.Add("ProductId", typeof(string));
orderLineTable.Columns.Add("Quantity", typeof(int));
orderLineTable.Columns.Add("UnitCost", typeof(double));
mappedData.Add(new List <MappedRow <OrderLine> >
{
new MappedRow <OrderLine>(orderLineTable.Rows.Add(orderNumber, "SKU-1", 5, 10), new OrderLine("SKU-1", 5, 10)),
new MappedRow <OrderLine>(orderLineTable.Rows.Add(orderNumber, "SKU-2", 1, 65), new OrderLine("SKU-2", 1, 65)),
new MappedRow <OrderLine>(orderLineTable.Rows.Add(orderNumber, "SKU-3", 10, 10.5), new OrderLine("SKU-3", 10, 10.5))
});
var order = new OrderAssembler().AssembleItem(mappedData);
Assert.AreEqual(orderNumber, order.OrderNumber);
Assert.AreEqual(now, order.OrderDate);
Assert.AreEqual(3, order.Lines.Count());
Assert.AreEqual(50, order.Lines.ElementAt(0).TotalCost());
Assert.AreEqual(65, order.Lines.ElementAt(1).TotalCost());
Assert.AreEqual(105, order.Lines.ElementAt(2).TotalCost());
Assert.AreEqual(220, order.Total());
}
public ReplaceOrderResponse ReplaceOrder(ReplaceOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.OrderRef, "OrderRef");
Platform.CheckMemberIsSet(request.Requisition, "Requisition");
var orderToReplace = this.PersistenceContext.Load <Order>(request.OrderRef);
ValidateOrderReplacable(orderToReplace);
// reason is optional
var reason = (request.CancelReason != null) ?
EnumUtils.GetEnumValue <OrderCancelReasonEnum>(request.CancelReason, this.PersistenceContext) : null;
// duplicate any attachments in the requisition,
// so that the replacement order gets a copy while the replaced order
// retains the association to the originals
DuplicateAttachmentsForOrderReplace(orderToReplace, request.Requisition);
// place new order
var newOrder = PlaceOrderHelper(request.Requisition);
ValidateVisitsExist(newOrder);
// cancel existing order
CancelOrderHelper(orderToReplace, new OrderCancelInfo(reason, this.CurrentUserStaff, null, newOrder));
this.PersistenceContext.SynchState();
LogicalHL7Event.OrderCreated.EnqueueEvents(newOrder);
LogicalHL7Event.OrderCancelled.EnqueueEvents(orderToReplace);
var orderAssembler = new OrderAssembler();
return(new ReplaceOrderResponse(orderAssembler.CreateOrderSummary(newOrder, this.PersistenceContext)));
}
private GetOrderDetailResponse GetOrderDetail(GetOrderDetailRequest request)
{
var order = this.PersistenceContext.GetBroker<IOrderBroker>().Load(request.OrderRef);
var createOrderDetailOptions = new OrderAssembler.CreateOrderDetailOptions
{
IncludeVisit = request.IncludeVisit && (new WorkflowConfigurationReader()).EnableVisitWorkflow,
IncludeProcedures = request.IncludeProcedures,
IncludeNotes = request.IncludeNotes,
IncludeVirtualNotes = request.IncludeNotes, // include virtual notes, if including notes at all
NoteCategoriesFilter = request.NoteCategoriesFilter,
IncludeAttachments = request.IncludeAttachments,
IncludeResultRecipients = request.IncludeResultRecipients,
IncludeExtendedProperties = request.IncludeExtendedProperties
};
var response = new GetOrderDetailResponse();
var orderAssembler = new OrderAssembler();
response.Order = orderAssembler.CreateOrderDetail(order, createOrderDetailOptions, this.PersistenceContext);
if (request.IncludeAlerts)
{
var alertAssembler = new AlertAssembler();
response.OrderAlerts =
CollectionUtils.Map<AlertNotification, AlertNotificationDetail>(
AlertHelper.Instance.Test(order, this.PersistenceContext),
alertAssembler.CreateAlertNotification);
}
return response;
}
public TimeShiftOrderResponse TimeShiftOrder(TimeShiftOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.OrderRef, "OrderRef");
// load the order, explicitly ignoring the version (since this is only used for testing/demo data creation, we don't care)
var order = this.PersistenceContext.Load<Order>(request.OrderRef, EntityLoadFlags.None);
// shift the order, which will also shift all procedures, etc.
order.TimeShift(request.NumberOfMinutes);
// shift the visit
order.Visit.TimeShift(request.NumberOfMinutes);
this.PersistenceContext.SynchState();
LogicalHL7Event.OrderModified.EnqueueEvents(order);
var orderAssembler = new OrderAssembler();
return new TimeShiftOrderResponse(orderAssembler.CreateOrderSummary(order, this.PersistenceContext));
}
public MergeOrderResponse MergeOrder(MergeOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.SourceOrderRefs, "SourceOrderRefs");
Platform.CheckTrue(request.SourceOrderRefs.Count > 0, "SourceOrderRefs.Count > 0");
Platform.CheckMemberIsSet(request.DestinationOrderRef, "DestinationOrderRef");
var response = new MergeOrderResponse();
DryRunHelper(request.DryRun,
delegate
{
var destinationOrder = this.PersistenceContext.Load<Order>(request.DestinationOrderRef);
var sourceOrders = CollectionUtils.Map(request.SourceOrderRefs, (EntityRef r) => PersistenceContext.Load<Order>(r));
var mergeInfo = new OrderMergeInfo(this.CurrentUserStaff, Platform.Time, destinationOrder);
MergeOrderHelper(destinationOrder, sourceOrders, mergeInfo, request.ValidationOnly);
if (request.DryRun)
{
var orderAssembler = new OrderAssembler();
var orderDetail = orderAssembler.CreateOrderDetail(destinationOrder,
OrderAssembler.CreateOrderDetailOptions.GetVerboseOptions(), PersistenceContext);
response.DryRunMergedOrder = orderDetail;
}
});
return response;
}
public ReplaceOrderResponse ReplaceOrder(ReplaceOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.OrderRef, "OrderRef");
Platform.CheckMemberIsSet(request.Requisition, "Requisition");
var orderToReplace = this.PersistenceContext.Load<Order>(request.OrderRef);
ValidateOrderReplacable(orderToReplace);
// reason is optional
var reason = (request.CancelReason != null) ?
EnumUtils.GetEnumValue<OrderCancelReasonEnum>(request.CancelReason, this.PersistenceContext) : null;
// duplicate any attachments in the requisition,
// so that the replacement order gets a copy while the replaced order
// retains the association to the originals
DuplicateAttachmentsForOrderReplace(orderToReplace, request.Requisition);
// place new order
var newOrder = PlaceOrderHelper(request.Requisition);
ValidateVisitsExist(newOrder);
// cancel existing order
CancelOrderHelper(orderToReplace, new OrderCancelInfo(reason, this.CurrentUserStaff, null, newOrder));
this.PersistenceContext.SynchState();
LogicalHL7Event.OrderCreated.EnqueueEvents(newOrder);
LogicalHL7Event.OrderCancelled.EnqueueEvents(orderToReplace);
var orderAssembler = new OrderAssembler();
return new ReplaceOrderResponse(orderAssembler.CreateOrderSummary(newOrder, this.PersistenceContext));
}
public ModifyOrderResponse ModifyOrder(ModifyOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.Requisition, "Requisition");
Platform.CheckMemberIsSet(request.Requisition.OrderRef, "OrderRef");
var order = this.PersistenceContext.Load<Order>(request.Requisition.OrderRef);
var assembler = new OrderEntryAssembler();
assembler.UpdateOrderFromRequisition(order, request.Requisition, this.CurrentUserStaff, this.PersistenceContext);
UpdateProceduresHelper(order, request.Requisition.Procedures, request);
ValidateVisitsExist(order);
this.PersistenceContext.SynchState();
var orderAssembler = new OrderAssembler();
return new ModifyOrderResponse(orderAssembler.CreateOrderSummary(order, this.PersistenceContext));
}
public PlaceOrderResponse PlaceOrder(PlaceOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.Requisition, "Requisition");
var order = PlaceOrderHelper(request.Requisition);
ValidateVisitsExist(order);
// ensure the new order is assigned an OID before using it in the return value
this.PersistenceContext.SynchState();
LogicalHL7Event.OrderCreated.EnqueueEvents(order);
var orderAssembler = new OrderAssembler();
return new PlaceOrderResponse(orderAssembler.CreateOrderSummary(order, this.PersistenceContext));
}
