public async Task <ActionResult> CopySearch(short SearchDefinitionID)
        {
            var accountId = this.Identity.ToAccountID();
            var roleId    = this.Identity.ToRoleID();
            var isSTAdmin = this.Identity.IsSTAdmin();
            GetSearchResponse response = await advancedSearchService.GetSavedSearchAsync(new GetSearchRequest()
            {
                SearchDefinitionID   = SearchDefinitionID,
                IncludeSearchResults = false,
                AccountId            = this.Identity.ToAccountID(),
                RoleId    = roleId,
                IsSTAdmin = isSTAdmin
            });

            response.SearchViewModel.CreatedOn            = response.SearchViewModel.CreatedOn.ToJSDate();
            response.SearchViewModel.SearchDefinitionName = "";
            response.SearchViewModel.SearchDefinitionID   = 0;
            IList <FilterViewModel> searchFilters = response.SearchViewModel.SearchFilters;

            foreach (FilterViewModel searchfilter in searchFilters)
            {
                searchfilter.SearchFilterID     = 0;
                searchfilter.SearchDefinitionID = 0;
            }
            short ItemsPerPage = default(short);

            short.TryParse(this.Identity.ToItemsPerPage(), out ItemsPerPage);
            AddCookie("savedsearchpagesize", ItemsPerPage.ToString(), 1);
            ViewBag.EmailPermission = cachingService.CheckSendMailPermissions(accountId, roleId);
            bool gridvisible = false;

            ViewBag.grid = gridvisible;
            response.SearchViewModel.SearchFilters = searchFilters;
            return(View("AddEditSearch", response.SearchViewModel));
        }
        public async Task <ActionResult> ViewSearch(short SearchDefinitionID)
        {
            bool gridvisible = false;

            ViewBag.grid = gridvisible;
            var   accountId    = this.Identity.ToAccountID();
            var   roleId       = this.Identity.ToRoleID();
            var   userId       = this.Identity.ToUserID();
            var   isSTAdmin    = this.Identity.IsSTAdmin();
            short ItemsPerPage = default(short);

            short.TryParse(this.Identity.ToItemsPerPage(), out ItemsPerPage);
            AddCookie("savedsearchpagesize", ItemsPerPage.ToString(), 1);
            ViewBag.EmailPermission = cachingService.CheckSendMailPermissions(accountId, roleId);
            GetSearchResponse response = await advancedSearchService.GetSavedSearchAsync(new GetSearchRequest()
            {
                SearchDefinitionID = SearchDefinitionID,
                AccountId          = accountId,
                RoleId             = roleId,
                IsSTAdmin          = isSTAdmin
            });

            response.SearchViewModel.CreatedOn = response.SearchViewModel.CreatedOn.ToJSDate();
            if (SearchDefinitionID != 0 && response.SearchViewModel != null)
            {
                advancedSearchService.InsertViewActivity(new InsertViewActivityRequest()
                {
                    AccountId          = accountId,
                    RequestedBy        = userId,
                    SearchDefinitionId = SearchDefinitionID,
                    SearchName         = response.SearchViewModel.SearchDefinitionName
                });
            }
            return(View("AddEditSearch", response.SearchViewModel));
        }
Exemple #3
0
        public GetSearchResponse Get(GetSearchRequest request)
        {
            var response = new GetSearchResponse {
                Version = request.Version
            };

            try
            {
                RequireUserId(request);

                var type = (SearchEnum)Enum.Parse(typeof(SearchEnum), request.Type);
                switch (type)
                {
                case SearchEnum.Medication:
                {
                    response.MedResults = Manager.GetTermSearchResults(request, type).Cast <TextValuePair>().ToList();
                    break;
                }

                case SearchEnum.Allergy:
                {
                    response.AllergyResults = Manager.GetTermSearchResults(request, type).Cast <IdNamePair>().ToList();
                    break;
                }
                }
            }
            catch (Exception ex)
            {
                FileLog.LogMessageToFile(ex.Message + " trace:" + ex.StackTrace);
                RaiseException(response, ex);
            }
            return(response);
        }
        public List <object> GetTermSearchResults(IAppDomainRequest e, SearchEnum type, string term)
        {
            string            urlTest            = null;
            GetSearchResponse dataDomainResponse = null;

            try
            {
                List <object> result = new List <object>();

                IRestClient client = new JsonServiceClient();
                //[Route("/{Context}/{Version}/{ContractNumber}/Search/{Type}/{Term}", "GET")]
                var url = Common.Helper.BuildURL(string.Format("{0}/{1}/{2}/{3}/Search/{4}/",
                                                               _ddSearchServiceUrl,
                                                               "NG",
                                                               e.Version,
                                                               e.ContractNumber,
                                                               type), e.UserId);

                url = url + "&Term=" + term;

                dataDomainResponse = client.Get <GetSearchResponse>(url);

                switch (type)
                {
                case SearchEnum.Medication:
                {
                    if (dataDomainResponse.MedResults != null)
                    {
                        result = dataDomainResponse.MedResults.ConvertAll(s =>
                                                                          new TextValuePair {
                                Text = s.Text, Value = s.Value
                            }).ToList <object>();
                    }
                    break;
                }

                case SearchEnum.Allergy:
                {
                    if (dataDomainResponse.AllergyResults != null)
                    {
                        try
                        {
                            result = dataDomainResponse.AllergyResults.ToList <object>();
                        }
                        catch (Exception ex)
                        {
                            throw new Exception("AllergyResults tolist() failed.", ex.InnerException);
                        }
                    }
                    break;
                }
                }
                return(result);
            }
            catch (WebServiceException ex)
            {
                throw new Exception("AD:SearchEndpointUtil:GetTermSearchResults():: url:" + urlTest + " message:" + dataDomainResponse.Status.Message + " trace:" + ex.StackTrace, ex.InnerException);
            }
        }
Exemple #5
0
        public static GetSearchResponse Unmarshall(UnmarshallerContext context)
        {
            GetSearchResponse getSearchResponse = new GetSearchResponse();

            getSearchResponse.HttpResponse = context.HttpResponse;

            return(getSearchResponse);
        }
        public async Task <ActionResult> RunSearch(short SearchDefinitionID, bool IsPreConfigSearch, bool IsFavoriteSearch)
        {
            var   identity     = Thread.CurrentPrincipal.Identity;
            short ItemsPerPage = default(short);

            short.TryParse(this.Identity.ToItemsPerPage(), out ItemsPerPage);
            AddCookie("savedsearchpagesize", ItemsPerPage.ToString(), 1);
            var accountId = identity.ToAccountID();
            var roleId    = identity.ToRoleID();
            var userId    = identity.ToUserID();
            var isSTAdmin = identity.IsSTAdmin();

            ViewBag.EmailPermission = cachingService.CheckSendMailPermissions(accountId, roleId);
            bool isAccountAdmin = cachingService.IsAccountAdmin(this.Identity.ToRoleID(), this.Identity.ToAccountID());

            ViewBag.IsAccountAdmin = isAccountAdmin;
            GetSearchResponse response = await advancedSearchService.GetSavedSearchAsync(new GetSearchRequest()
            {
                SearchDefinitionID   = SearchDefinitionID,
                IncludeSearchResults = false,
                Limit              = ItemsPerPage,
                AccountId          = accountId,
                RoleId             = roleId,
                RequestedBy        = userId,
                IsRunSearchRequest = true,
                IsSTAdmin          = isSTAdmin
            });

            response.SearchViewModel.CreatedOn             = response.SearchViewModel.CreatedOn.ToJSDate();
            response.SearchViewModel.IsFavoriteSearch      = IsFavoriteSearch;
            response.SearchViewModel.IsPreConfiguredSearch = IsPreConfigSearch;
            if (SearchDefinitionID != 0 && response.SearchViewModel != null)
            {
                advancedSearchService.InsertLastRun(new InsertLastRunActivityRequest()
                {
                    AccountId          = accountId,
                    RequestedBy        = userId,
                    SearchDefinitionId = SearchDefinitionID,
                    SearchName         = response.SearchViewModel.SearchDefinitionName
                });
            }
            bool gridvisible = true;

            ViewBag.grid         = gridvisible;
            ViewBag.ItemsPerPage = ItemsPerPage;
            ViewBag.IsRunSearch  = true;
            return(View("AddEditSearch", response.SearchViewModel));
        }
Exemple #7
0
        public GetSearchResponse Post(GetSearchRequest request)
        {
            var response = new GetSearchResponse {
                Version = request.Version
            };

            try
            {
                RequireUserId(request);
                //response.MedResults = Manager.GetSearchByID(request);
            }
            catch (Exception ex)
            {
                RaiseException(response, ex);
            }
            return(response);
        }
        public async Task <ActionResult> EditSearch(short SearchDefinitionID)
        {
            var   identity     = Thread.CurrentPrincipal.Identity;
            var   accountId    = identity.ToAccountID();
            var   roleId       = identity.ToRoleID();
            var   userId       = identity.ToUserID();
            var   isSTAdmin    = identity.IsSTAdmin();
            short ItemsPerPage = default(short);

            short.TryParse(this.Identity.ToItemsPerPage(), out ItemsPerPage);
            AddCookie("savedsearchpagesize", ItemsPerPage.ToString(), 1);
            GetSearchResponse response = await advancedSearchService.GetSavedSearchAsync(new GetSearchRequest()
            {
                SearchDefinitionID   = SearchDefinitionID,
                IncludeSearchResults = false,
                Limit       = ItemsPerPage,
                AccountId   = accountId,
                RoleId      = roleId,
                RequestedBy = userId,
                IsSTAdmin   = isSTAdmin
            });

            response.SearchViewModel.CreatedOn = response.SearchViewModel.CreatedOn.ToJSDate();
            foreach (var item in response.SearchViewModel.SearchFilters)
            {
                if (item.InputTypeId == 2)
                {
                    DateTime date = DateTime.Parse(item.SearchText.ToString());
                    item.SearchText = date.ToString();
                }
            }
            bool gridvisible = false;

            ViewBag.grid            = gridvisible;
            ViewBag.EmailPermission = cachingService.CheckSendMailPermissions(accountId, roleId);
            return(View("AddEditSearch", response.SearchViewModel));
        }