protected override void PrepareQueryRequest(ListExternalPractitionersRequest request)
        {
            var today = Platform.Time;

            request.VerifiedState          = VerifiedState.Verified;
            request.LastVerifiedRangeFrom  = today.Date;
            request.LastVerifiedRangeUntil = today.Date.AddDays(1);
            request.SortByLastVerifiedTime = true;
            request.SortAscending          = false;
        }
Beispiel #2
0
        private static void InitReferenceDataCacheOnce()
        {
            if (_refDataCachedInitialized)
            {
                return;
            }

            lock (_syncLock)
            {
                if (_refDataCachedInitialized)
                {
                    return;
                }

                Platform.GetService(
                    delegate(IPatientAdminService service)
                {
                    _patientEditorFormData = service.LoadPatientProfileEditorFormData(new LoadPatientProfileEditorFormDataRequest());
                });

                Platform.GetService(
                    delegate(IVisitAdminService service)
                {
                    _visitEditorFormData = service.LoadVisitEditorFormData(new LoadVisitEditorFormDataRequest());
                });

                Platform.GetService(
                    delegate(IOrderEntryService service)
                {
                    _orderEntryFormData = service.GetOrderEntryFormData(new GetOrderEntryFormDataRequest());
                });

                // cache up to 1000 diagnostic services
                Platform.GetService(
                    delegate(IDiagnosticServiceAdminService service)
                {
                    var request = new ListDiagnosticServicesRequest {
                        Page = { FirstRow = 0, MaxRows = 1000 }
                    };
                    _diagnosticServices = service.ListDiagnosticServices(request).DiagnosticServices;
                });

                // cache up to 500 practitioners
                Platform.GetService(
                    delegate(IExternalPractitionerAdminService service)
                {
                    var request = new ListExternalPractitionersRequest {
                        Page = { FirstRow = 0, MaxRows = 500 }, QueryItems = true
                    };
                    _practitioners = service.ListExternalPractitioners(request).Practitioners;
                });

                _refDataCachedInitialized = true;
            }
        }
        protected override int QueryCount()
        {
            var count = -1;

            Platform.GetService(
                delegate(IExternalPractitionerAdminService service)
            {
                var request = new ListExternalPractitionersRequest {
                    QueryItems = false, QueryCount = true
                };
                PrepareQueryRequest(request);
                var response = service.ListExternalPractitioners(request);
                count        = response.ItemCount;
            });

            return(count);
        }
        protected override QueryItemsResult QueryItems(int firstRow, int maxRows)
        {
            QueryItemsResult result = null;

            Platform.GetService(
                delegate(IExternalPractitionerAdminService service)
            {
                var request = new ListExternalPractitionersRequest {
                    QueryItems = true, QueryCount = true, Page = new SearchResultPage(firstRow, maxRows)
                };
                PrepareQueryRequest(request);
                var response = service.ListExternalPractitioners(request);
                result       = new QueryItemsResult(response.Practitioners, response.ItemCount);
            });

            return(result);
        }
Beispiel #5
0
        // note: this operation is not protected with ClearCanvas.Ris.Application.Common.AuthorityTokens.ExternalPractitionerAdmin
        // because it is used in non-admin situations - perhaps we need to create a separate operation???
        public ListExternalPractitionersResponse ListExternalPractitioners(ListExternalPractitionersRequest request)
        {
            var assembler = new ExternalPractitionerAssembler();

            var criteria = new ExternalPractitionerSearchCriteria();

            if (request.SortByLastVerifiedTime)
            {
                if (request.SortAscending)
                {
                    criteria.LastVerifiedTime.SortAsc(0);
                }
                else
                {
                    criteria.LastVerifiedTime.SortDesc(0);
                }
            }
            else if (request.SortByLastEditedTime)
            {
                if (request.SortAscending)
                {
                    criteria.LastEditedTime.SortAsc(0);
                }
                else
                {
                    criteria.LastEditedTime.SortDesc(0);
                }
            }
            else
            {
                criteria.Name.FamilyName.SortAsc(0);
            }

            if (!string.IsNullOrEmpty(request.FirstName))
            {
                criteria.Name.GivenName.StartsWith(request.FirstName);
            }
            if (!string.IsNullOrEmpty(request.LastName))
            {
                criteria.Name.FamilyName.StartsWith(request.LastName);
            }

            switch (request.VerifiedState)
            {
            case VerifiedState.Verified:
                criteria.IsVerified.EqualTo(true);
                break;

            case VerifiedState.NotVerified:
                criteria.IsVerified.EqualTo(false);
                break;
            }

            if (request.LastVerifiedRangeFrom != null && request.LastVerifiedRangeUntil != null)
            {
                criteria.LastVerifiedTime.Between(request.LastVerifiedRangeFrom, request.LastVerifiedRangeUntil);
            }
            else if (request.LastVerifiedRangeFrom != null)
            {
                criteria.LastVerifiedTime.MoreThanOrEqualTo(request.LastVerifiedRangeFrom);
            }
            else if (request.LastVerifiedRangeUntil != null)
            {
                criteria.LastVerifiedTime.LessThanOrEqualTo(request.LastVerifiedRangeUntil);
            }

            if (!request.IncludeMerged)
            {
                criteria.MergedInto.IsNull();
            }

            if (!request.IncludeDeactivated)
            {
                criteria.Deactivated.EqualTo(false);
            }

            var results = new List <ExternalPractitionerSummary>();

            if (request.QueryItems)
            {
                results = CollectionUtils.Map <ExternalPractitioner, ExternalPractitionerSummary, List <ExternalPractitionerSummary> >(
                    PersistenceContext.GetBroker <IExternalPractitionerBroker>().Find(criteria, request.Page),
                    s => assembler.CreateExternalPractitionerSummary(s, PersistenceContext));
            }

            var itemCount = -1;

            if (request.QueryCount)
            {
                itemCount = (int)PersistenceContext.GetBroker <IExternalPractitionerBroker>().Count(criteria);
            }

            return(new ListExternalPractitionersResponse(results, itemCount));
        }
 protected override void PrepareQueryRequest(ListExternalPractitionersRequest request)
 {
     request.VerifiedState        = VerifiedState.NotVerified;
     request.SortByLastEditedTime = true;
     request.SortAscending        = true;
 }
 protected abstract void PrepareQueryRequest(ListExternalPractitionersRequest request);