Beispiel #1
0
        public static IWebElement FindElement(SearchBy by, string locator)
        {
            loggerInfo.Instance.LogInfo("Find By [ " + by + " ]" + " Locator [ " + locator + " ]");
            IWebElement parentElement = null;

            return(FindElement(by, locator, 2, parentElement));//TODO: Ideally we should be using 0 but for now its 2 sec
        }
Beispiel #2
0
        public static bool ClickElement(SearchBy by, string locator, bool teardownTestIfFail, string logMessage)
        {
            IWebElement element = FindElement(by, locator, string.Empty);

            if (element != null)
            {
                try
                {
                    loggerInfo.Instance.Message(logMessage);
                    loggerInfo.Instance.Message("Click on " + locator);
                    return(ClickElement(element, teardownTestIfFail));
                }
                catch (Exception e)
                {
                    loggerInfo.Instance.LogAppErro(e, "Unable to Click on Element : [ " + locator + " ]", LogLevel.Error);
                    return(false);
                }
            }
            else
            {
                Exception e = new Exception("Click Element with By [ " + by + " ]" + " Locator [ " + locator + " ]");
                loggerInfo.Instance.LogAppErro(e, "", LogLevel.Error);
                return(false);
            }
        }
Beispiel #3
0
 public SearchEmployeeQuery(SearchBy searchBy, string searchTerm, int page, int pageSize)
 {
     _searchBy   = searchBy;
     _searchTerm = searchTerm;
     _page       = page;
     _pageSize   = pageSize;
 }
Beispiel #4
0
        public static UnityEngine.Object[] FindAll(SearchBy search, string query)
        {
            switch (search)
            {
            case SearchBy.Nothing:
                return(ArrayUtil.Empty <UnityEngine.Object>());

            case SearchBy.Tag:
                return(GameObjectUtil.FindGameObjectsWithMultiTag(query));

            case SearchBy.Name:
            {
                using (var tmp = com.spacepuppy.Collections.TempCollection.GetList <UnityEngine.GameObject>())
                {
                    GameObjectUtil.FindAllByName(query, tmp);
                    return(tmp.ToArray());
                }
            }

            case SearchBy.Type:
                return(ObjUtil.FindObjectsOfType(TypeUtil.FindType(query)));

            default:
                return(null);
            }
        }
Beispiel #5
0
        // Ищем продукт по Коду в прайс-листах
        public static DataTable Search(string fieldSearch, SearchBy searchBy)
        {
            ResultSearchXLSX.Clear();

            if (Settings.listXLSX == null || Settings.listXLSX.Count == 0 || fieldSearch == string.Empty)
            {
                return(ResultSearchXLSX);
            }

            foreach (string file in Settings.listXLSX)
            {
                if (File.Exists(file))
                {
                    try
                    {
                        switch (searchBy)
                        {
                        case SearchBy.Code:
                            SearchByCode(fieldSearch, file);
                            break;

                        case SearchBy.Name:
                            SearchByName(fieldSearch, file);
                            break;
                        }
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
            return(ResultSearchXLSX);
        }
Beispiel #6
0
        public static void TypeElement(SearchBy by, string locator, string textToType, string logMessage, bool hitEnterAfterType)
        {
            string postString = string.Empty;

            if (logMessage != "")
            {
                loggerInfo.Instance.Message(logMessage);
            }
            if (hitEnterAfterType)
            {
                postString = System.Environment.NewLine;
            }

            IWebElement element = FindElement(by, locator, string.Empty);

            try
            {
                ClickElement(element, false);
                loggerInfo.Instance.Message("Type '" + textToType + "' in locator: { " + locator + " }");
                element.SendKeys(textToType + postString);
            }
            catch (Exception e)
            {
                e = new Exception(e.Message);
                loggerInfo.Instance.LogAppErro(e, "Unable to Type '" + textToType + "' in " + locator, NLog.LogLevel.Error);
                return;
            }
        }
 public void SearchVisuallyByImageUrlWithCropShouldThrowWhenConstructed()
 {
     Assert.Throws <ClarifaiException>(() =>
     {
         SearchBy.ImageVisually(CELEB1, new Crop(0.1M, 0.2M, 0.3M, 0.4M));
     });
 }
Beispiel #8
0
        public static IWebElement FindElement(SearchBy by, string locator, int timeOut, IWebElement parentElement = null)
        {
            ReadOnlyCollection <IWebElement> SearchElements = FindElements(by, locator, timeOut, parentElement);

            if (SearchElements != null)
            {
                if (SearchElements.Count > 0)
                {
                    loggerInfo.Instance.LogInfo("Found Element By [ " + by + " ]" + " Locator [ " + locator + " ]");
                    return(SearchElements.First <IWebElement>());
                }
                else
                {
                    PromptAlertMessage("Unable to find Element By [ " + by + " ]" + " Locator [ " + locator + " ]");
                    loggerInfo.Instance.LogAppErro(new Exception("Unable to find Element By [ " + by + " ]" + " Locator [ " + locator + " ]"), "", NLog.LogLevel.Error);
                    TakeScreenShot(testEInfo);
                    return(null);
                }
            }
            else
            {
                PromptAlertMessage("Unable to Error Message is Element By [ " + by + " ]" + " Locator [ " + locator + " ]");
                loggerInfo.Instance.LogAppErro(new Exception("Unable to Error Message is Element By [ " + by + " ]" + " Locator [ " + locator + " ]"), "", NLog.LogLevel.Error);
                TakeScreenShot(testEInfo);
                return(null);
            }
        }
Beispiel #9
0
 public IActionResult SearchResults(string Name, int Id)
 {
     if (!string.IsNullOrWhiteSpace(Name))
     {
         try
         {
             string   search       = Name;
             SearchBy typeOfSearch = SearchBy.name;
             Pokemon  p            = DAL.ConvertToPokemonModels(search, typeOfSearch);
             return(View(p));
         }
         catch
         {
             return(View("Search"));
         }
     }
     else if (Id != 0)
     {
         string   search       = Id.ToString();
         SearchBy typeOfSearch = SearchBy.id;
         Pokemon  p            = DAL.ConvertToPokemonModels(search, typeOfSearch);
         return(View(p));
     }
     return(View(""));
 }
 private void cboNCT_TheLoai_SelectionChangeCommitted(object sender, EventArgs e)
 {
     _CurrentPage  = "1";
     _SearchBy     = SearchBy.TheLoai;
     _IsSearchMenu = true;
     Search("http://v6.nhaccuatui.com", _SearchBy.ToString(), _IsSearchMenu);
 }
Beispiel #11
0
        public async Task <IEnumerable <Job_DiscriptionView> > GetBy(SearchBy searchBy)
        {
            try
            {
                var vList = (from jd in adbContext.job_description.Where(String.Format("{0}=={1}", searchBy.FieldName, searchBy.FieldValue))
                             join comp in adbContext.company on jd.Company_Id equals comp.Company_Id
                             join dep in adbContext.department on jd.Dept_Id equals dep.Dept_Id
                             join desig in adbContext.designation on jd.Desig_Id equals desig.Desig_Id
                             where jd.isActive == 1 && comp.isActive == 1
                             select new Job_DiscriptionView
                {
                    JD_Id = jd.JD_Id,

                    Company_Id = jd.Company_Id,
                    Company_Name = comp.Company_Name,

                    Dept_Id = jd.Dept_Id,
                    Dept_Name = dep.Dept_Name,

                    Desig_Id = jd.Desig_Id,
                    Desig_Name = desig.Desig_Name,

                    JD_Code = jd.JD_Code,
                    JD_Name = jd.JD_Name,
                    JD_Description = jd.JD_Description,
                    Notes = jd.Notes
                }
                             ).Take(searchBy.RecordLimit).ToList();
                return(await Task.FromResult(vList));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #12
0
 public async Task <IEnumerable <ShiftView> > GetBy(SearchBy searchBy)
 {
     try
     {
         var vList = (from s in adbContext.shift.Where(String.Format("{0}=={1}", searchBy.FieldName, searchBy.FieldValue))
                      join comp in adbContext.company on s.Company_Id equals comp.Company_Id
                      where s.isActive == 1 && comp.isActive == 1
                      select new ShiftView
         {
             Shift_Id = s.Shift_Id,
             Company_Id = s.Company_Id,
             Company_Name = comp.Company_Name,
             Shift_Code = s.Shift_Code,
             Shift_Name = s.Shift_Name,
             Shift_Start = s.Shift_Start,
             Shift_End = s.Shift_End,
             NightShift = s.NightShift,
             Shift_Variable = s.Shift_Variable
         }
                      ).Take(searchBy.RecordLimit).ToList();
         return(await Task.FromResult(vList));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
        public async Task <IEnumerable <Module_PermissionView> > GetBy(SearchBy searchBy)
        {
            try
            {
                var vList = (from mp in adbContext.module_permission.Where(String.Format("{0}=={1}", searchBy.FieldName, searchBy.FieldValue))
                             join m in adbContext.module on mp.Module_Id equals m.Id
                             select new Module_PermissionView
                {
                    Id = mp.Id,
                    Module_Id = mp.Module_Id,
                    Module_Name = m.Name,
                    Name = mp.Name,
                    isActive = mp.isActive
                }
                             ).Take(searchBy.RecordLimit).ToList();
                if (vList == null || vList.Count() == 0)
                {
                    throw new RecoredNotFoundException("Get Data Empty");
                }

                return(await Task.FromResult(vList));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public async Task <IEnumerable <User_RoleView> > GetBy(SearchBy searchBy)
        {
            try
            {
                var vList = (from ur in adbContext.user_role.Where(String.Format("{0}=={1}", searchBy.FieldName, searchBy.FieldValue))
                             join u in adbContext.users on ur.User_Id equals u.User_Id
                             join r in adbContext.roles on ur.Role_Id equals r.Id
                             where ur.isActive == 1 && u.isActive == 1
                             select new User_RoleView
                {
                    Id = ur.Id,
                    User_Id = ur.User_Id,
                    Login_Id = u.Login_Id,

                    Role_Id = ur.Role_Id,
                    Name = r.Name
                }
                             ).Take(searchBy.RecordLimit).ToList();
                return(await Task.FromResult(vList));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #15
0
        public static Element InitializeElement(string locator, SearchBy locatorValue = SearchBy.Xpath)
        {
            Element element = new Element();

            element.Search = new Search(locator);
            return(element);
        }
Beispiel #16
0
        public static ElementsList InitializeElements(string locator, SearchBy locatorValue = SearchBy.Xpath)
        {
            ElementsList elements = new ElementsList();

            elements.Search = new Search(locator);
            return(elements);
        }
 public ActionResult ClassAdvanced(string searchString, int page, SearchBy searchBy, OrderBy orderBy, string universityId)
 {
     UserInformationModel<User> myUserInformation = GetUserInformatonModel();
     searchString = MassageSearchString(searchString);
     SearchResultsModel mySearchResults = theSearchService.GetClassSearchResults(myUserInformation, searchString, page, searchBy, orderBy, universityId);
     return View("Results", mySearchResults);
 }
 private void cboZing_CaSi_SelectionChangeCommitted(object sender, EventArgs e)
 {
     _CurrentPage  = "1";
     _SearchBy     = SearchBy.CaSi;
     _IsSearchMenu = true;
     Search("http://mp3.zing.vn", _SearchBy.ToString(), _IsSearchMenu);
 }
Beispiel #19
0
 public async Task <IEnumerable <ProbationView> > GetBy(SearchBy searchBy)
 {
     try
     {
         var vList = (from prob in adbContext.probation.Where(String.Format("{0}=={1}", searchBy.FieldName, searchBy.FieldValue))
                      join comp in adbContext.company on prob.Company_Id equals comp.Company_Id
                      where prob.isActive == 1 && comp.isActive == 1
                      select new ProbationView
         {
             Prob_Id = prob.Prob_Id,
             Company_Id = prob.Company_Id,
             Company_Name = comp.Company_Name,
             Prob_Code = prob.Prob_Code,
             Prob_Name = prob.Prob_Name,
             Prob_Description = prob.Prob_Description,
             Prob_DurationUnit = prob.Prob_DurationUnit,
             Prob_Duration = prob.Prob_Duration,
             Notes = prob.Notes,
         }
                      ).Take(searchBy.RecordLimit).ToList();
         return(await Task.FromResult(vList));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Beispiel #20
0
 public async Task <IEnumerable <SiteView> > GetBy(SearchBy searchBy)
 {
     try
     {
         var vList = (from s in adbContext.site.Where(String.Format("{0}=={1}", searchBy.FieldName, searchBy.FieldValue))
                      join comp in adbContext.company on s.Company_Id equals comp.Company_Id
                      where s.isActive == 1 && comp.isActive == 1
                      select new SiteView
         {
             Site_Id = s.Site_Id,
             Company_Id = s.Company_Id,
             Company_Name = comp.Company_Name,
             Site_Code = s.Site_Code,
             Site_Name = s.Site_Name,
             Address1 = s.Address1,
             Address2 = s.Address2,
             Address3 = s.Address3,
             Address4 = s.Address4,
             PostCode = s.PostCode,
             City = s.City,
             State = s.State,
             Country = s.Country
         }
                      ).Take(searchBy.RecordLimit).ToList();
         return(await Task.FromResult(vList));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Beispiel #21
0
        /// <summary>
        /// Finds all books that contain the given value in their properties.
        /// </summary>
        /// <param name="tag">The searching criteria.</param>
        /// <param name="keyword">The keyword to be used in the search.</param>
        /// <returns>A collection of the found books.</returns>
        public IEnumerable <Book> FindBookByTag(SearchBy tag, string keyword)
        {
            if (string.IsNullOrWhiteSpace(keyword))
            {
                throw new ArgumentException("No data to search with.");
            }

            string subset = keyword.ToUpperInvariant();

            switch (tag)
            {
            case SearchBy.Isbn:
                return(this.bookSet.Where(b => string.Equals(b.Isbn, keyword, StringComparison.OrdinalIgnoreCase)));

            case SearchBy.Author:
                return(this.bookSet.Where(b => b.Author.ToUpperInvariant().Contains(subset)));

            case SearchBy.Title:
                return(this.bookSet.Where(b => b.Title.ToUpperInvariant().Contains(subset)));

            case SearchBy.Publisher:
                return(this.bookSet.Where(b => b.Publisher.ToUpperInvariant().Contains(subset)));

            default:
                throw new ArgumentException("Wrong searching tag.");
            }
        }
Beispiel #22
0
        public Result Execute(
            ExternalCommandData cmdData,
            ref string msg,
            ElementSet elems)
        {
            Result result;

            try
            {
                Snoop.CollectorExts.CollectorExt.m_app = cmdData.Application;
                UIDocument revitDoc = cmdData.Application.ActiveUIDocument;
                Document   dbdoc    = revitDoc.Document;
                Snoop.CollectorExts.CollectorExt.m_activeDoc = dbdoc; // TBD: see note in CollectorExt.cs

                SearchBy searchByWin = new SearchBy(dbdoc);
                ActiveDoc.UIApp = cmdData.Application;
                searchByWin.ShowDialog();
                result = Result.Succeeded;
            }
            catch (System.Exception e)
            {
                msg    = e.Message;
                result = Result.Failed;
            }

            return(result);
        }
Beispiel #23
0
        public async Task <IActionResult> GetBy(SearchBy searchBy)
        {
            ResponseHelper objHelper = new ResponseHelper();

            try
            {
                var vList = await commonQueryRepo.GetBy(searchBy);

                if (vList == null)
                {
                    objHelper.Status  = StatusCodes.Status200OK;
                    objHelper.Message = "Get Empty Data";
                }
                else
                {
                    objHelper.Status  = StatusCodes.Status200OK;
                    objHelper.Message = "Get Successfully";
                    objHelper.Data    = vList;
                }
                return(Ok(objHelper));
            }
            catch
            {
                objHelper.Status  = StatusCodes.Status500InternalServerError;
                objHelper.Message = "Get Unsuccessful";
                return(StatusCode(StatusCodes.Status500InternalServerError, objHelper));
            }
        }
Beispiel #24
0
        public void Add(SearchScope scope, SearchBy searchBy, Operator op, string searchText)
        {
            var searchPredicate = HookExtensions.FormatSearchClause <T>(searchBy, op, searchText);

            switch (scope)
            {
            case SearchScope.ExecutingAssembly:
                _hook.AddRange(Assembly.GetExecutingAssembly().GetHooks <T>(searchPredicate));
                break;

            case SearchScope.EntryAssembly:
                _hook.AddRange(Assembly.GetEntryAssembly().GetHooks <T>(searchPredicate));
                break;

            case SearchScope.CallingAssembly:
                _hook.AddRange(Assembly.GetCallingAssembly().GetHooks <T>(searchPredicate));
                break;

            case SearchScope.CurrentDirectory:
                List <Assembly> assemblies = DirectoryExtensions.GetAssemblies(Environment.CurrentDirectory, "*.dll");
                assemblies.AddRange(DirectoryExtensions.GetAssemblies(Environment.CurrentDirectory, "*.exe"));
                foreach (var item in assemblies)
                {
                    _hook.AddRange(item.GetHooks(searchPredicate));
                }
                break;

            default:
                throw new InvalidOperationException("Invalid SearchScope: " + scope);
            }
        }
Beispiel #25
0
        public static ReadOnlyCollection <IWebElement> FindElements(SearchBy by, string locator)
        {
            loggerInfo.Instance.LogInfo("Find Elements By [ " + by + " ]" + " Locator [ " + locator + " ]");
            IWebElement parentElement = null;

            return(FindElements(by, locator, testTimeout, parentElement));
        }
Beispiel #26
0
        public async Task <IEnumerable <DesignationView> > GetBy(SearchBy searchBy)
        {
            try
            {
                var vList = (from desig in adbContext.designation.Where(String.Format("{0}=={1}", searchBy.FieldName, searchBy.FieldValue))
                             join dept in adbContext.department on desig.Dept_Id equals dept.Dept_Id
                             join comp in adbContext.company on desig.Company_Id equals comp.Company_Id
                             join zone in adbContext.zone on desig.Zone_Id equals zone.Zone_Id
                             select new DesignationView
                {
                    Desig_Id = desig.Desig_Id,
                    Desig_Code = desig.Desig_Code,
                    Desig_Name = desig.Desig_Name,
                    Report_To = desig.Report_To,
                    AdditionalReport_To = desig.AdditionalReport_To,
                    Company_Name = comp.Company_Name,
                    Dept_Name = dept.Dept_Name,
                    Zone_Name = zone.Zone_Name
                }).Take(searchBy.RecordLimit).ToList();

                return(await Task.FromResult(vList));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #27
0
        public Pokemon ConvertToPokemonModels(string search, SearchBy typeOfSearch)
        {
            string  pokemonData = GetPokemon(search, typeOfSearch);
            Pokemon p           = JsonConvert.DeserializeObject <Pokemon>(pokemonData);

            return(p);
        }
        public async Task SearchIssuesTest()
        {
            //Arrange
            var issues = new List <Issue>()
            {
                new Issue {
                    Id = 1
                },
                new Issue {
                    Id = 2
                }
            };

            int totalIssues = 2;

            var service = new SearchBy(issueRepository.Object);

            issueRepository.Setup(x => x.GetIssues(It.IsAny <Func <Issue, bool> >(), It.IsAny <int>(), It.IsAny <int>()))
            .Returns(Task.FromResult(issues));

            issueRepository.Setup(x => x.CountIssues(It.IsAny <Func <Issue, bool> >())).Returns(Task.FromResult(totalIssues));

            //Act
            var action = await service.SearchIssues(x => x.Id != 0, x => x.Status != Status.Close, searchSpecification);


            //Assert
            Assert.Equal(totalIssues, action.Issues.Count);
            Assert.Equal(totalIssues, action.Count.FilteredIssue);
        }
 public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
 {
     if (SearchBy.Equals("name", System.StringComparison.InvariantCultureIgnoreCase))
     {
         if (string.IsNullOrEmpty(Name))
         {
             yield return(new ValidationResult("Please specify a search Name.", new[] { nameof(Name) }));
         }
     }
     else if (SearchBy.Equals("coordinates", System.StringComparison.InvariantCultureIgnoreCase))
     {
         string InvalidVertexMessage = "Please specify vertext coordinates.";
         if (!IsVertexValid(Vertex1))
         {
             yield return(new ValidationResult(InvalidVertexMessage, new[] { nameof(Vertex1) }));
         }
         if (!IsVertexValid(Vertex2))
         {
             yield return(new ValidationResult(InvalidVertexMessage, new[] { nameof(Vertex2) }));
         }
         if (!IsVertexValid(Vertex3))
         {
             yield return(new ValidationResult(InvalidVertexMessage, new[] { nameof(Vertex3) }));
         }
     }
     else
     {
         yield return(new ValidationResult("Please specify a valid search type.", new[] { nameof(SearchBy) }));
     }
 }
Beispiel #30
0
        public async Task <IEnumerable <Email_ConfigView> > GetBy(SearchBy searchBy)
        {
            try
            {
                var vList = (from con in adbContext.email_config.Where(String.Format("{0}=={1}", searchBy.FieldName, searchBy.FieldValue))
                             join c in adbContext.company on con.Company_Id equals c.Company_Id
                             select new Email_ConfigView
                {
                    Email_Config_Id = con.Email_Config_Id,

                    Company_Id = con.Company_Id,
                    Company_Name = c.Company_Name,

                    Email_Host = con.Email_Host,
                    Email_Port = con.Email_Port,
                    Email_UserName = con.Email_UserName,
                    Email_Password = con.Email_Password,
                    EnableSSL = con.EnableSSL,
                    TLSEnable = con.TLSEnable
                }
                             ).Take(searchBy.RecordLimit).ToList();
                if (vList == null || vList.Count() == 0)
                {
                    throw new RecoredNotFoundException("Get Data Empty");
                }

                return(await Task.FromResult(vList));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #31
0
        public async Task <IEnumerable <ContractView> > GetBy(SearchBy searchBy)
        {
            try
            {
                var vList = (from con in adbContext.contract.Where(String.Format("{0}=={1}", searchBy.FieldName, searchBy.FieldValue))
                             join c in adbContext.company on con.Company_Id equals c.Company_Id
                             where con.isActive == 1 && c.isActive == 1
                             select new ContractView
                {
                    Contract_Id = con.Contract_Id,

                    Company_Id = con.Company_Id,
                    Company_Name = c.Company_Name,

                    Contract_Code = con.Contract_Code,
                    Contract_Name = con.Contract_Name,
                    Contract_HoursDaily = con.Contract_HoursDaily,
                    Contract_HoursWeekly = con.Contract_HoursWeekly,
                    Contract_Days = con.Contract_Days,
                    Contract_Type = con.Contract_Type,
                    Notes = con.Notes
                }
                             ).Take(searchBy.RecordLimit).ToList();
                return(await Task.FromResult(vList));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public SearchIndexViewModel(string query, SearchBy searchBy = SearchBy.FullText | SearchBy.Tag, SearchWhat searchWhat = SearchWhat.Groups | SearchWhat.Content)
        {
            if (!string.IsNullOrWhiteSpace(query))
            {
                Query = query;

                if (searchBy.HasFlag(SearchBy.FullText))
                {
                    if (searchWhat.HasFlag(SearchWhat.Content))
                    {
                        var comments = DataService.PerThread.GetCommentsByFullText(query, 100).Select(x => new SearchIndex_ResultViewModel(x));
                        var posts = DataService.PerThread.GetPostsByFullText(query, 100).Select(x => new SearchIndex_ResultViewModel(x));
                        var petitions = DataService.PerThread.GetPetitionsByFullText(query, 100).Select(x => new SearchIndex_ResultViewModel(x));
                        var polls = DataService.PerThread.GetPollsByFullText(query, 100).Select(x => new SearchIndex_ResultViewModel(x));
                        var surveys = DataService.PerThread.GetSurveysByFullText(query, 100).Select(x => new SearchIndex_ResultViewModel(x));

                        Content = comments.Union(posts.Union(petitions.Union(polls.Union(surveys)))).ToList();
                    }

                    if (searchWhat.HasFlag(SearchWhat.Groups))
                        Groups = DataService.PerThread.GetGroupsByFullText(query, 100).Select(x => new SearchIndex_ResultViewModel(x)).ToList();
                }
                if (searchBy.HasFlag(SearchBy.Tag))
                {
                    var tags = DataService.PerThread.TagSet.Where(x => x.Title.Contains(query) || query.Contains(x.Title)).ToList();

                    if (searchWhat.HasFlag(SearchWhat.Content))
                    {
                        IEnumerable<SearchIndex_ResultViewModel> tagedContent = new List<SearchIndex_ResultViewModel>();
                        foreach (var c in tags.Where(x => x.Contents.Count != 0).Select(x => x.Contents))
                            tagedContent = tagedContent.Union(c.Select(x => new SearchIndex_ResultViewModel(x)).ToList());

                        Content = Content.Union(tagedContent).ToList();
                    }

                    if (searchWhat.HasFlag(SearchWhat.Groups))
                    {
                        var tagedGroups = tags.Where(x => x.GroupId.HasValue).Select(x => new SearchIndex_ResultViewModel(x.Group)).ToList();
                        Groups = Groups.Union(tagedGroups).ToList();
                    }
                }
            }
        }
Beispiel #33
0
        /// <summary>
        /// Provide searching of a key and tells how many keys were found. You have to be on "Pages" page
        /// </summary>
        /// <param name="key"></param>
        /// <param name="howToSearch"></param>
        /// <returns>Number of keys found</returns>
        public int SearchKey(string key, SearchBy howToSearch)
        {
            if (howToSearch == SearchBy.Content)
            {
                ChooseElementInSelect("Content", _searchBySelect, SelectBy.Text);
            }

            _searchInput.SendKeys(key);
            _searchKeyButton.Click();
            WaitAjax();

            return Driver.FindElements(By.CssSelector("div > .table.table-hover.table-bordered:nth-child(2) > tbody > tr")).Count;
        }
 public ActionResult DoAdvancedSearch(SearchFilter searchType, string searchString, int page, SearchBy searchBy, OrderBy orderBy, string universityId)
 {
     return JavaScript("window.top.location.href ='" + Url.Action(searchType.ToString() + "Advanced") + "?searchString=" + searchString + "&page=" + page + "&searchBy=" + searchBy.ToString() + "&orderBy=" + orderBy.ToString() + "&universityId=" + universityId + "';");
 }
		public DdeCustomTypeSchemaFactory(SearchBy searchBy, VisibleScopes scope)
			: base(searchBy, scope)
		{
		}
Beispiel #36
0
 public Rollouts(Client client, DateTime date, SearchBy searchBy)
 {
     MySqlCommand cmd;
     Rollout roll;
     string dateField = (searchBy == SearchBy.RollDate) ? "rolledDate" : "scheduledDate";
     date = date.Date; // Store date part, time part not needed.
     using(MySqlConnection conn = (MySqlConnection)this.Conn){
         conn.Open();
         cmd = conn.CreateCommand();
         cmd.CommandText = "SELECT * FROM " + _table + " WHERE clientId = @clientId AND " + dateField + " = @" + dateField;
         cmd.Parameters.Add("@clientId", client.Id);
         cmd.Parameters.Add("@" + dateField, date);
         using(MySqlDataReader dr = cmd.ExecuteReader()){
             if(!dr.HasRows && dateField == "scheduledDate"){
                 roll = new Rollout();
                 roll.Client = client;
                 roll.ScheduledDate = date;
                 roll.BusinessCollection = this;
                 List.Add(roll);
             }else{
                 while (dr.Read()){
                     roll = new Rollout(dr);
                     roll.BusinessCollection = this;
                     List.Add(roll);
                 }
             }
         }
     }
 }
        private SearchResultsModel BuildSearchResultsModel(string aUniversityId, List<ISearchResult> aResults, Helpers.Search.SearchFilter aSearchType,
                        int aPage, string aSearchString, int aTotalResults, IDictionary<string, string> aSearchByOptions,
                        SearchBy aSearchBySelected, IDictionary<string, string> anOrderByOptions, 
                        OrderBy anOrderBySelected)
        {
            int myToGet = (aPage - 1) * SiteConfiguration.ResultsPerPage() + SiteConfiguration.ResultsPerPage() > aResults.Count
                                ? aTotalResults % SiteConfiguration.ResultsPerPage()
                                : SiteConfiguration.ResultsPerPage();
                            IEnumerable<ISearchResult> myFinalResultSet = aResults.GetRange((aPage - 1) * SiteConfiguration.ResultsPerPage(), myToGet);
            return new SearchResultsModel() {
                SearchType = aSearchType,
                SearchResults = myFinalResultSet,
                CurrentPage = aPage,
                TotalPages = (int)Math.Ceiling((double)aTotalResults / (double)SiteConfiguration.ResultsPerPage()),
                TotalResults = aTotalResults,
                SearchString = aSearchString,
                SearchByOptions = new SelectList(aSearchByOptions, "Value", "Key", aSearchBySelected),
                OrderByOptions = new SelectList(anOrderByOptions, "Value", "Key", anOrderBySelected),
                UniversityOptions = new SelectList(UniversityOptions(), "Value", "Key", aUniversityId)

            };
        }
    /// <summary>
    /// Search on Allmusic for the requested string
    /// </summary>
    /// <param name="searchBy"></param>
    /// <param name="searchStr"></param>
    /// <returns></returns>
    public bool FindInfo(SearchBy searchBy, string searchStr)
    {
      _searchby = searchBy;
      HTMLUtil util = new HTMLUtil();
      string strPostData = "";
      if (SearchBy.Albums == searchBy)
      {
        strPostData = string.Format(ALBUMSEARCH, HttpUtility.UrlEncode(searchStr));
      }
      else
      {
        searchStr = SwitchArtist(searchStr);
        strPostData = string.Format(ARTISTSEARCH, HttpUtility.UrlEncode(searchStr));
      }

      string strHTML = PostHTTP(MAINURL + URLPROGRAM, strPostData);
      if (strHTML.Length == 0)
      {
        return false;
      }

      _htmlCode = strHTML; // save the html content...

      Regex multiples = new Regex(
        @"\sSearch\sResults\sfor:",
        RegexOptions.IgnoreCase
        | RegexOptions.Multiline
        | RegexOptions.IgnorePatternWhitespace
        | RegexOptions.Compiled
        );

      if (multiples.IsMatch(strHTML))
      {
        string pattern = "";
        if (searchBy.ToString().Equals("Artists"))
        {
          pattern = @"<tr.*?>\s*?.*?<td\s*?class=""relevance\stext-center"">\s*?.*\s*?.*</td>" +
                    @"\s*?.*<td.*\s*?.*</td>\s*?.*<td>.*<a.*href=""(?<code>.*?)"">(?<name>.*)</a>.*</td>" +
                    @"\s*?.*<td>(?<detail>.*)</td>\s*?.*<td>(?<detail2>.*)</td>";
        }
        else if (searchBy.ToString().Equals("Albums"))
        {
          pattern = @"<tr.*?>\s*?.*?<td\s*?class=""relevance\stext-center"">\s*?.*\s*?.*</td>" +
                    @"\s*?.*<td.*\s*?.*</td>\s*?.*<td>.*<a.*href=""(?<code>.*?)"">(?<name>.*)</a>.*</td>" +
                    @"\s*?.*<td>(?<detail>.*)</td>\s*?.*<td>.*</td>\s*?.*<td>(?<detail2>.*)</td>";
        }


        Match m;
        Regex itemsFoundFromSite = new Regex(
          pattern,
          RegexOptions.IgnoreCase
          | RegexOptions.Multiline
          | RegexOptions.IgnorePatternWhitespace
          | RegexOptions.Compiled
          );


        for (m = itemsFoundFromSite.Match(strHTML); m.Success; m = m.NextMatch())
        {
          string code = m.Groups["code"].ToString();
          string name = m.Groups["name"].ToString();
          string detail = m.Groups["detail"].ToString();
          string detail2 = m.Groups["detail2"].ToString();

          util.RemoveTags(ref name);
          util.ConvertHTMLToAnsi(name, out name);

          util.RemoveTags(ref detail);
          util.ConvertHTMLToAnsi(detail, out detail);

          util.RemoveTags(ref detail2);
          util.ConvertHTMLToAnsi(detail2, out detail2);

          if (SearchBy.Artists == searchBy)
          {
            detail += " - " + detail2;
            if (detail.Length > 0)
            {
              _codes.Add(code);
              _values.Add(name + " - " + detail);
            }
            else
            {
              _codes.Add(code);
              _values.Add(name);
            }
          }
          else
          {
            MusicAlbumInfo albumInfo = new MusicAlbumInfo();
            albumInfo.AlbumURL = code;
            albumInfo.Artist = detail;
            albumInfo.Title = name;
            albumInfo.DateOfRelease = detail2;
            _albumList.Add(albumInfo);
          }
        }
        _multiple = true;
      }
      else // found the right one
      {}
      return true;
    }
        public SearchResultsModel MarketplaceSearchResults(UserInformationModel<User> aUserInformation, string aSearchString, int aPage, SearchBy aSearchBy, OrderBy anOrderBy, string anItemType, string aUniversityId)
        {
            IEnumerable<MarketplaceItem> myItems = new List<MarketplaceItem>();
            string myUniversityId = "All";

            if (!aUniversityId.Equals("All")) {
                myUniversityId = aUniversityId;
                if (aSearchBy == SearchBy.Title) {
                    myItems = theMarketplaceSerivce.GetLatestItemsSellingInUniversityByItemAndTitle(myUniversityId, anItemType, aSearchString);
                }
            } else {
                if (aSearchBy == SearchBy.Title) {
                    myItems = theMarketplaceSerivce.GetLatestItemsSellingByTypeAndTitleForAnyUniversity(anItemType, aSearchString);
                }
            }

            if (anOrderBy == OrderBy.Title) {
                myItems = myItems.OrderBy(r => r.Title);
            } else if (anOrderBy == OrderBy.LowestPrice) {
                myItems = myItems.OrderBy(r => r.Price);
            } else if (anOrderBy == OrderBy.HighestPrice) {
                myItems = myItems.OrderByDescending(r => r.Price);
            } else if (anOrderBy == OrderBy.Newest) {
                myItems = myItems.OrderBy(r => r.DateTimeStamp);
            }

            List<ISearchResult> mySearchResult = new List<ISearchResult>();

            mySearchResult.AddRange(myItems.Select(r => new ItemSearchResult(r) {
                UserInformationModel = aUserInformation
            }));

            int myTotalResults = myItems.Count();

            SearchResultsModel myModel =
                BuildSearchResultsModel(myUniversityId, mySearchResult, (SearchFilter)Enum.Parse(typeof(SearchFilter), anItemType), aPage,
                                        aSearchString, myTotalResults, SearchByForItems(),
                                        aSearchBy, OrderByForItems(), anOrderBy);
            return myModel;
        }
        public SearchResultsModel GetUserSearchResults(UserInformationModel<User> aUserInformation, string aSearchString,
                                                 int aPage, SearchBy aSearchBy, OrderBy anOrderBy, string aUniversityId)
        {
            IEnumerable<User> myUsers = new List<User>();

            if (aSearchBy == SearchBy.Name) {
                if (aUserInformation == null) {
                    myUsers = theSearchRepository.GetUserByName(aSearchString);
                } else {
                    myUsers = theSearchRepository.GetUserByName(aUserInformation.UserId, aSearchString);
                }
            }

            if (anOrderBy == OrderBy.Name) {
                myUsers = myUsers.OrderBy(r => r.FirstName + " " + r.LastName);
            }

            List<ISearchResult> mySearchResult = new List<ISearchResult>();

            mySearchResult.AddRange(myUsers.Select(r => new UserSearchResult(r) {
                UserInformationModel = aUserInformation
            }));

            int myTotalResults = myUsers.Count<User>();

            SearchResultsModel myModel =
                BuildSearchResultsModel("All", mySearchResult, SearchFilter.USER, aPage,
                                        aSearchString, myTotalResults, SearchByForPeople(),
                                        aSearchBy, OrderByForPeople(), anOrderBy);
            return myModel;
        }
        public SearchResultsModel GetTextBookSearchResults(UserInformationModel<User> aUserInformation, string aSearchString,
                                                   int aPage, SearchBy aSearchBy, OrderBy anOrderBy, string aUniversityId)
        {
            IEnumerable<TextBook> myTextBooks = new List<TextBook>();
            string myUniversityId = "All";

            if (!aUniversityId.Equals("All")) {
                myUniversityId = aUniversityId;
                if (aSearchBy == SearchBy.Title) {
                    myTextBooks = theSearchRepository.GetTextBookByTitle(myUniversityId, aSearchString);
                } else if (aSearchBy == SearchBy.ClassCode) {
                    myTextBooks = theSearchRepository.GetTextBookByClassCode(myUniversityId, aSearchString);
                }
            } else {
                if (aSearchBy == SearchBy.Title) {
                    myTextBooks = theSearchRepository.GetTextBookByTitle(aSearchString);
                } else if (aSearchBy == SearchBy.ClassCode) {
                    myTextBooks = theSearchRepository.GetTextBookByClassCode(aSearchString);
                }
            }

            if (anOrderBy == OrderBy.Title) {
                myTextBooks = myTextBooks.OrderBy(r => r.BookTitle);
            } else if (anOrderBy == OrderBy.ClassCode) {
                myTextBooks = myTextBooks.OrderBy(r => r.ClassSubject + r.ClassCourse);
            } else if (anOrderBy == OrderBy.LowestPrice) {
                myTextBooks = myTextBooks.OrderBy(r => r.Price);
            } else if (anOrderBy == OrderBy.HighestPrice) {
                myTextBooks = myTextBooks.OrderByDescending(r => r.Price);
            }

            List<ISearchResult> mySearchResult = new List<ISearchResult>();

            mySearchResult.AddRange(myTextBooks.Select(r => new TextBookSearchResult(r) {
                UserInformationModel = aUserInformation
            }));

            int myTotalResults = myTextBooks.Count<TextBook>();

            SearchResultsModel myModel =
                BuildSearchResultsModel(myUniversityId, mySearchResult, SearchFilter.TEXTBOOK, aPage,
                                        aSearchString, myTotalResults, SearchByForTextbook(),
                                        aSearchBy, OrderByForTextbook(), anOrderBy);
            return myModel;
        }
        public SearchResultsModel GetClassSearchResults(UserInformationModel<User> aUserInformation, string aSearchString,
                                                        int aPage, SearchBy aSearchBy, OrderBy anOrderBy, string aUniversityId)
        {
            IEnumerable<Class> myClasses = new List<Class>();
            string myUniversityId = "All";

            if (!aUniversityId.Equals("All")) {
                myUniversityId = aUniversityId;
                if (aSearchBy == SearchBy.Title) {
                    myClasses = theSearchRepository.GetClassByTitle(myUniversityId, aSearchString);
                } else if (aSearchBy == SearchBy.ClassCode) {
                    myClasses = theSearchRepository.GetClassByClassCode(myUniversityId, aSearchString);
                }
            } else {
                if (aSearchBy == SearchBy.Title) {
                    myClasses = theSearchRepository.GetClassByTitle(aSearchString);
                } else if (aSearchBy == SearchBy.ClassCode) {
                    myClasses = theSearchRepository.GetClassByClassCode(aSearchString);
                }
            }

            if (anOrderBy == OrderBy.Title) {
                myClasses = myClasses.OrderBy(r => r.Title);
            } else if (anOrderBy == OrderBy.ClassCode) {
                myClasses = myClasses.OrderBy(r => r.Subject + r.Course);
            }

            List<ISearchResult> mySearchResult = new List<ISearchResult>();

            mySearchResult.AddRange(myClasses.Select(r => new ClassSearchResult(r)));

            int myTotalResults = myClasses.Count<Class>();

            SearchResultsModel myModel =
                BuildSearchResultsModel(myUniversityId, mySearchResult, SearchFilter.CLASS, aPage, aSearchString,
                                        myTotalResults, SearchByForClass(), aSearchBy,
                                        OrderByForClass(), anOrderBy);
            return myModel;
        }
        public IEnumerable<Group> GetGroups(UserInformationModel<User> aUser, string aSearchTerm, SearchBy aSearchBy, OrderBy orderBy, bool aMyGroups)
        {
            IEnumerable<Group> myGroups = new List<Group>();

            if (aMyGroups) {
                if (aSearchBy == SearchBy.All) {
                    myGroups = theGroupRepository.GetMyGroupsByAll(aUser.Details);
                } else if (aSearchBy == SearchBy.City) {
                    myGroups = theGroupRepository.GetMyGroupsByCity(aUser.Details, aSearchTerm);
                } else if (aSearchBy == SearchBy.Name) {
                    myGroups = theGroupRepository.GetMyGroupsByName(aUser.Details, aSearchTerm);
                } else if (aSearchBy == SearchBy.Tags) {
                    myGroups = theGroupRepository.GetMyGroupsByKeywordTags(aUser.Details, aSearchTerm);
                } else if (aSearchBy == SearchBy.ZipCode) {
                    if (!ZipCodeValidation.IsValid(aSearchTerm)) {
                        throw new CustomException("The zip code must be 5 digits long.");
                    }
                    myGroups = theGroupRepository.GetMyGroupsByZipCode(aUser.Details, int.Parse(aSearchTerm));
                }
            } else {
                User myUser = aUser != null ? aUser.Details : null;
                bool myIncludeAdmin = aUser != null;

                if (aSearchBy == SearchBy.All) {
                    myGroups = theGroupRepository.GetGroupsByAll(myUser, myIncludeAdmin);
                } else if (aSearchBy == SearchBy.City) {
                    myGroups = theGroupRepository.GetGroupsByCity(myUser, aSearchTerm, myIncludeAdmin);
                } else if (aSearchBy == SearchBy.Name) {
                    myGroups = theGroupRepository.GetGroupsByName(myUser, aSearchTerm, myIncludeAdmin);
                } else if (aSearchBy == SearchBy.Tags) {
                    myGroups = theGroupRepository.GetGroupsByKeywordTags(myUser, aSearchTerm, myIncludeAdmin);
                } else if (aSearchBy == SearchBy.ZipCode) {
                    if (!ZipCodeValidation.IsValid(aSearchTerm)) {
                        throw new CustomException("The zip code must be 5 digits long.");
                    }
                    myGroups = theGroupRepository.GetGroupsByZipCode(myUser, int.Parse(aSearchTerm), myIncludeAdmin);
                }
            }

            if (orderBy == OrderBy.City) {
                myGroups = myGroups.OrderBy(g => g.GroupCityStateTags.OrderBy(gc => gc.City));
            } else if (orderBy == OrderBy.Name) {
                myGroups = myGroups.OrderBy(g => g.Name);
            } else if (orderBy == OrderBy.State) {
                myGroups = myGroups.OrderBy(g => g.GroupCityStateTags.OrderBy(gc => gc.State));
            } else if (orderBy == OrderBy.ZipCode) {
                myGroups = myGroups.OrderBy(g =>
                    g.GroupZipCodeTags.Count > 0 ?
                    g.GroupZipCodeTags.Min(gz => gz.ZipCode) :
                    0);
            }

            return myGroups;
        }
        public HttpResponseMessage SearchForBook(string query, SearchBy searchBy=SearchBy.All)
        {
            try
            {
                var context = new LibrarySystemContext();

                if (query == null || query == "")
                {
                    throw new ArgumentException("Невалидно търсене!");
                }

                IQueryable<Book> booksEntity;
                if (searchBy == SearchBy.Key)
                {
                    booksEntity = context.Books.Where(b => b.Key.Contains(query));
                }
                else if (searchBy == SearchBy.Author)
                {
                    booksEntity = context.Books.Where(b => b.Author.Name.Contains(query));
                }
                else if (searchBy == SearchBy.Title)
                {
                    booksEntity = context.Books.Where(b => b.Title.Contains(query));
                }
                else
                {
                    booksEntity = context.Books.Where(b => b.Key.Contains(query) || b.Author.Name.Contains(query)
                                                           || b.Title.Contains(query));
                }

                var books = from book in booksEntity
                            select new BookModel()
                                       {
                                           Title = book.Title,
                                           AuthorName = book.Author.Name,
                                           Description = book.Description,
                                           Key = book.Key,
                                           Year = book.Year
                                       };

                var response = this.Request.CreateResponse(HttpStatusCode.OK, books);
                return response;

            }
            catch (Exception ex)
            {
                var response = this.Request.CreateResponse(HttpStatusCode.BadRequest,
                                           ex.Message);
                return response;
            }
        }
 public bool FindAlbumInfo(string strAlbum, string artistName, int releaseYear)
 {
   _searchby = SearchBy.Albums;
   _albumList.Clear();
   if (FindInfo(SearchBy.Albums, strAlbum))
   {
     // Sort the Album
     artistName = SwitchArtist(artistName);
     _albumList.Sort(new AlbumSort(strAlbum, artistName, releaseYear));
     return true;
   }
   return false;
 }
 public ActionResult Search(SearchBy searchBy, OrderBy orderBy, string searchTerm)
 {
     return SearchIssues(searchBy, orderBy, searchTerm);
 }
        public IEnumerable<IssueWithDispositionModel> GetIssues(User aUser, SearchBy aSearchBy, OrderBy anOrderBy, string aSearchTerm)
        {
            IEnumerable<IssueWithDispositionModel> mySearchResults = new List<IssueWithDispositionModel>();

            if (aSearchBy == SearchBy.All) {
                mySearchResults = theIssueRepository.GetIssues(aUser);
            } else if (aSearchBy == SearchBy.Title) {
                mySearchResults = theIssueRepository.GetIssuesByTitle(aUser, aSearchTerm);
            } else if (aSearchBy == SearchBy.Description) {
                mySearchResults = theIssueRepository.GetIssuesByDescription(aUser, aSearchTerm);
            }

            if (anOrderBy == OrderBy.LastReplyDate) {
                mySearchResults = mySearchResults.OrderByDescending(
                    r => r.Issue.IssueReplys
                        .Where(r2 => !r2.Deleted)
                        .OrderByDescending(r2 => r2.DateTimeStamp)
                        .FirstOrDefault<IssueReply>() != null ?
                        r.Issue.IssueReplys
                        .Where(r2 => !r2.Deleted)
                        .OrderByDescending(r2 => r2.DateTimeStamp)
                        .FirstOrDefault<IssueReply>().DateTimeStamp :
                        OLD_DATE
                );
            } else if (anOrderBy == OrderBy.LatestCreationDate) {
                mySearchResults = mySearchResults.OrderByDescending(i => i.Issue.DateTimeStamp);
            } else if (anOrderBy == OrderBy.Title) {
                mySearchResults = mySearchResults.OrderBy(i => i.Issue.Title);
            }

            return mySearchResults;
        }
        private ActionResult SearchIssues(SearchBy aSearchBy, OrderBy anOrderBy, string aSearchTerm)
        {
            IEnumerable<IssueWithDispositionModel> myIssues = new List<IssueWithDispositionModel>(); ;
            try {
                myIssues = theIssueService.GetIssues(GetUserInformaton(), aSearchBy, anOrderBy, aSearchTerm);
            } catch (Exception e) {
                LogError(e, GET_LATEST_ISSUES_ERROR);
                return SendToErrorPage(GET_LATEST_ISSUES_ERROR);
            }

            if (myIssues.Count() == 0) {
                ViewData["Message"] = MessageHelper.NormalMessage(NO_ISSUES);
            }

            SearchModel<IssueWithDispositionModel> mySearchModel = new SearchModel<IssueWithDispositionModel>() {
                SearchResults = myIssues,
                SearchByOptions = new SelectList(theIssueService.SearchByOptions(), "Value", "Key", aSearchBy),
                OrderByOptions = new SelectList(theIssueService.OrderByOptions(), "Value", "Key", anOrderBy)
            };

            return View("List", mySearchModel);
        }
        public ActionResult Search(string searchTerm, SearchBy searchBy, OrderBy orderBy, bool showMyGroupsOnly)
        {
            if (!IsLoggedIn()) {
                return RedirectToLogin();
            }

            IEnumerable<Group> myGroups = new List<Group>();

            GroupSearchModel myGroupSearchModel = new GroupSearchModel() {
                SearchResults = myGroups,
                SearchByOptions = new SelectList(theGroupService.SearchByOptions(), "Value", "Key", searchBy.ToString()),
                OrderByOptions = new SelectList(theGroupService.OrderByOptions(), "Value", "Key", orderBy.ToString())
            };

            try {
                UserInformationModel<User> myUser = GetUserInformatonModel();

                myGroups = theGroupService.GetGroups(myUser, searchTerm, searchBy, orderBy, showMyGroupsOnly);

                if (myGroups.Count<Group>() == 0) {
                    ViewData["Message"] = MessageHelper.NormalMessage(NO_GROUPS);
                }

                myGroupSearchModel.SearchResults = myGroups;
            } catch(CustomException anException) {
                ViewData["Message"] = MessageHelper.ErrorMessage(anException.Message);
            } catch (Exception myException) {
                LogError(myException, GROUP_LIST_ERROR);
                ViewData["Message"] = GROUP_LIST_ERROR;
            }

            return View("List", myGroupSearchModel);
        }