/// <summary>
        /// Called by the host to initialize the application component.
        /// </summary>
        public override void Start()
        {
            _recipientLookupHandler = new ExternalPractitionerLookupHandler(this.Host.DesktopWindow);

            Platform.GetService(
                delegate(IBrowsePatientDataService service)
            {
                var request = new GetDataRequest {
                    GetOrderDetailRequest = new GetOrderDetailRequest(_orderRef, false, false, false, false, false, true)
                };
                var order = service.GetData(request).GetOrderDetailResponse.Order;

                _selectedRecipient = order.OrderingPractitioner;

                var recipient = order.ResultRecipients.FirstOrDefault(
                    rr => rr.Practitioner.PractitionerRef.Equals(_selectedRecipient.PractitionerRef, true));

                _selectedContactPoint = recipient != null ? recipient.ContactPoint : null;
            });

            UpdateConsultantContactPointChoices();


            base.Start();
        }
        public override void Start()
        {
            if (_worklistDetail.FilterByWorkingFacility)
            {
                _selectedFacilities.Add(_workingFacilityItem);
            }
            _selectedFacilities.AddRange(_worklistDetail.Facilities);

            if (_worklistDetail.Portabilities.Contains(true))
            {
                _selectedPortabilities.Add(_portableItem);
            }
            if (_worklistDetail.Portabilities.Contains(false))
            {
                _selectedPortabilities.Add(_nonPortableItem);
            }

            _orderingPractitionerLookupHandler = new ExternalPractitionerLookupHandler(this.Host.DesktopWindow);
            if (_worklistDetail.OrderingPractitioners != null)
            {
                // GUI only allows 1 ordering practitioner - could change this in future if needed
                _selectedOrderingPractitioner = CollectionUtils.FirstElement(_worklistDetail.OrderingPractitioners);
            }

            base.Start();
        }
        private void DummyAddVisitPractitioner()
        {
            try
            {
                Platform.GetService <IExternalPractitionerAdminService>(
                    delegate(IExternalPractitionerAdminService service)
                {
                    ListExternalPractitionersResponse findResponse = service.ListExternalPractitioners(new ListExternalPractitionersRequest("Who", ""));
                    ExternalPractitionerSummary practitioner       = findResponse.Practitioners[0];

                    VisitPractitionerDetail vp = new VisitPractitionerDetail();

                    vp.Role = CollectionUtils.SelectFirst(_visitPractitionerRoleChoices,
                                                          delegate(EnumValueInfo e) { return(e.Code == "RF"); });
                    vp.Practitioner = practitioner;
                    vp.StartTime    = Platform.Time;

                    _visit.Practitioners.Add(vp);
                });
            }
            catch (Exception e)
            {
                ExceptionHandler.Report(e, SR.ExceptionCannotAddVisitPractitioner, this.Host.DesktopWindow,
                                        delegate
                {
                    this.ExitCode = ApplicationComponentExitCode.Error;
                    this.Host.Exit();
                });
            }
        }
Beispiel #4
0
        public override void Accept()
        {
            if (this.HasValidationErrors)
            {
                this.ShowValidation(true);
                return;
            }

            try
            {
                _practitionerDetail.ContactPoints.Clear();
                foreach (var detail in _contactPointSummaryComponent.Subject)
                {
                    _practitionerDetail.ContactPoints.Add(detail);
                }

                // Add the contact points back, otherwise server will think they are deleted.
                _practitionerDetail.ContactPoints.AddRange(_hiddenMergedContactPoints);

                // give extension pages a chance to save data prior to commit
                _extensionPages.ForEach(page => page.Save());

                Platform.GetService <IExternalPractitionerAdminService>(service =>
                {
                    if (_isNew)
                    {
                        var response = service.AddExternalPractitioner(
                            new AddExternalPractitionerRequest(_practitionerDetail, _detailsEditor.MarkVerified));

                        _practitionerRef     = response.Practitioner.PractitionerRef;
                        _practitionerSummary = response.Practitioner;
                    }
                    else
                    {
                        var response = service.UpdateExternalPractitioner(
                            new UpdateExternalPractitionerRequest(_practitionerDetail, _detailsEditor.MarkVerified));

                        _practitionerRef     = response.Practitioner.PractitionerRef;
                        _practitionerSummary = response.Practitioner;
                    }
                });

                this.Exit(ApplicationComponentExitCode.Accepted);
            }
            catch (Exception e)
            {
                ExceptionHandler.Report(e, SR.ExceptionSaveExternalPractitioner, this.Host.DesktopWindow,
                                        delegate
                {
                    this.ExitCode = ApplicationComponentExitCode.Error;
                    this.Host.Exit();
                });
            }
        }
		public ExternalPractitionerSummary CreateExternalPractitionerSummary(ExternalPractitioner prac, IPersistenceContext context)
		{
			var summary = new ExternalPractitionerSummary(
				prac.GetRef(),
				new PersonNameAssembler().CreatePersonNameDetail(prac.Name),
				prac.LicenseNumber,
				prac.BillingNumber,
				prac.IsVerified,
				prac.LastVerifiedTime,
				prac.LastEditedTime,
				prac.IsMerged,
				prac.Deactivated);

			return summary;
		}
        public ExternalPractitionerSummary CreateExternalPractitionerSummary(ExternalPractitioner prac, IPersistenceContext context)
        {
            var summary = new ExternalPractitionerSummary(
                prac.GetRef(),
                new PersonNameAssembler().CreatePersonNameDetail(prac.Name),
                prac.LicenseNumber,
                prac.BillingNumber,
                prac.IsVerified,
                prac.LastVerifiedTime,
                prac.LastEditedTime,
                prac.IsMerged,
                prac.Deactivated);

            return(summary);
        }
 public UpdateExternalPractitionerResponse(ExternalPractitionerSummary prac)
 {
     this.Practitioner = prac;
 }
 public UpdateExternalPractitionerResponse(ExternalPractitionerSummary prac)
 {
     this.Practitioner = prac;
 }
 public LoadMergeDuplicatePractitionerFormDataRequest(ExternalPractitionerSummary practitioner)
 {
     this.Practitioner = practitioner;
 }
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="updatedOriginal">The updated data for the original record.</param>
		public MergeDuplicatePractitionerResponse(ExternalPractitionerSummary updatedOriginal)
		{
			this.UpdatedOriginal = updatedOriginal;
		}
		public MergeExternalPractitionerResponse(ExternalPractitionerSummary mergedPractitioner)
		{
			MergedPractitioner = mergedPractitioner;
		}
		public ResultRecipientDetail(ExternalPractitionerSummary practitioner, ExternalPractitionerContactPointDetail contactPoint, EnumValueInfo preferredCommunicationMode)
		{
			this.Practitioner = practitioner;
			this.ContactPoint = contactPoint;
			this.PreferredCommunicationMode = preferredCommunicationMode;
		}
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="duplicate">The duplicate practitioners to remove.</param>
		/// <param name="original">The original record to keep.</param>
		public MergeDuplicatePractitionerRequest(ExternalPractitionerSummary duplicate, ExternalPractitionerSummary original)
		{
			this.Duplicate = duplicate;
			this.Original = original;
		}
		public LoadMergeDuplicatePractitionerFormDataRequest(ExternalPractitionerSummary practitioner)
		{
			this.Practitioner = practitioner;
		}
        private static List <ExternalPractitionerContactPointDetail> GetPractitionerContactPoints(ExternalPractitionerSummary prac)
        {
            var choices = new List <ExternalPractitionerContactPointDetail>();

            if (prac != null)
            {
                Platform.GetService(
                    delegate(IOrderEntryService service)
                {
                    var response = service.GetExternalPractitionerContactPoints(
                        new GetExternalPractitionerContactPointsRequest(prac.PractitionerRef));
                    choices = response.ContactPoints;
                });
            }

            return(choices);
        }
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="duplicate">The duplicate practitioners to remove.</param>
 /// <param name="original">The original record to keep.</param>
 public MergeDuplicatePractitionerRequest(ExternalPractitionerSummary duplicate, ExternalPractitionerSummary original)
 {
     this.Duplicate = duplicate;
     this.Original  = original;
 }
Beispiel #17
0
 public MergeExternalPractitionerResponse(ExternalPractitionerSummary mergedPractitioner)
 {
     MergedPractitioner = mergedPractitioner;
 }