Пример #1
0
        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);
        }
Пример #2
0
        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);
        }
Пример #3
0
		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 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)));
        }
Пример #5
0
        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));
        }
Пример #6
0
		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;
		}