public RemoveDialog()
{
InitializeComponent();
Controller = new RemoveDialogController(this);
SearchProps = new SearchFormModel();
DataContext = SearchProps;
}
public async Task <ActionResult> Submit(string type, string query)
{
if (!string.IsNullOrWhiteSpace(query) && type == "1")
{
var model = new SearchFormModel
{
SearchResult = await _movieRepository.SearchByTitle(query).ConfigureAwait(false)
};
return(PartialView("_MovieSearchResult", model));
}
var hitSpec = new HitSpecification
{
ExcerptLength = 255
};
var findModel = new FindResultViewModel
{
Result = SearchClient.Instance.UnifiedSearchFor(query)
.UsingSynonyms()
.ApplyBestBets()
.Take(100)
.GetResult(hitSpec)
};
return(PartialView("_FindSearchResult", findModel));
}
public async Task <IActionResult> Search(SearchFormModel model)
{
var viewModel = new SearchViewModel
{
SearchText = model.SearchText,
};
switch (model.SearchDrugBy)
{
case SearchDrugByType.SearchDrugByName:
viewModel.Drugs = await this.drugService.FindByNameAsync(model.SearchText);
break;
case SearchDrugByType.SearchDrugByBrand:
viewModel.Drugs = await this.drugService.FindByBrandAsync(model.SearchText);
break;
case SearchDrugByType.SearchDrugByDrugGroup:
viewModel.Drugs = await this.drugService.FindByDrugGroupAsync(model.SearchText);
break;
case SearchDrugByType.SearchDrugByRepresentative:
viewModel.Drugs = await this.drugService.FindByRepresentativeAsync(model.SearchText);
break;
default: break;
}
return(View(viewModel));
}
public async Task <IActionResult> Searched(SearchFormModel model, int page = 1)
{
var searchedHome = await this.soldService
.SearchedAllAsync(model.CityId,
model.LocationId,
model.RoomType,
model.FromSpaceId,
model.ToSpaceId,
model.FromPriceId,
model.ToPriceId,
page);
if (searchedHome == null)
{
return(BadRequest());
}
return(View(new SearchListingModel
{
Properties = searchedHome,
CurrentPage = page,
SearchModel = model,
TotalProperties = await this.soldService
.TotalSearchAsync(model.CityId,
model.LocationId,
model.RoomType,
model.FromSpaceId,
model.ToSpaceId,
model.FromPriceId,
model.ToPriceId)
}));
}
public IActionResult Search(SearchFormModel model)
{
var viewModel = new SearchListingViewModel
{
SearchTerm = model.SearchTerm
};
if (model.SearchInAccessories)
{
viewModel.Accessories = this.accessories.Search(model.SearchTerm);
}
if (model.SearchInBeers)
{
viewModel.Beers = this.beers.Search(model.SearchTerm);
}
if (model.SearchInGiftSets)
{
viewModel.GiftSets = this.giftSets.Search(model.SearchTerm);
}
if (model.SearchInGlasses)
{
viewModel.Glasses = this.glasses.Search(model.SearchTerm);
}
return(View(viewModel));
}
public async Task <IActionResult> GetAll(SearchFormModel searchForm, int page = WebConstants.FirstPage)
{
if (page < WebConstants.FirstPage)
{
page = WebConstants.FirstPage;
}
var allRequests = await this.requests.GetAll(searchForm.Status, page);
var pagination = new PaginationViewModel()
{
PageSize = WebConstants.ItemsPerPage,
TotalElements = allRequests.TotalItems,
CurrentPage = page
};
if (page > pagination.TotalPages)
{
pagination.CurrentPage = pagination.TotalPages;
}
var result = new RequestListingViewModel()
{
Requests = allRequests.Requests,
Pagination = pagination,
Search = searchForm
};
return(this.View(result));
}
public IActionResult Post([FromBody] SearchFormModel searchFormModel)
{
var searchTag = searchFormModel.SearchTag;
var links = db.Links;
var newListLinks = new List <Link>();
List <string> tags = new List <string>();
foreach (Link link in links)
{
tags = link.Tag.Split(", ").ToList();
foreach (string tag in tags)
{
if (tag == searchTag)
{
//links.Add(link);
newListLinks.Add(link);
}
}
}
if (newListLinks.Count() != 0)
{
return(Ok(newListLinks));
}
else
{
return(NotFound());
};
}
public async Task <IActionResult> Search(SearchFormModel model)
{
SearchViewModel viewModel = new SearchViewModel();
if (model.SearchInCourses)
{
if (string.IsNullOrEmpty(model.SearchText))
{
// take All Courses maybe?
}
else
{
viewModel.Courses = await this.courses.FindAsync(model.SearchText);
}
}
if (model.SearchInUsers)
{
if (string.IsNullOrEmpty(model.SearchText))
{
// take All Users maybe?
}
else
{
viewModel.Users = await this.users.FindAsync(model.SearchText);
}
}
viewModel.SearchText = model.SearchText;
return(this.View(viewModel));
}
public async Task <IActionResult> Search(SearchFormModel model)
{
var viewModel = new SearchViewModel
{
SearchText = model.SearchText
};
if (string.IsNullOrWhiteSpace(model.SearchText))
{
return(RedirectToAction(nameof(All)));
}
// TODO: Fix Search logic
if (model.SearchInMovies)
{
viewModel.Projections = await this.cinema.FindAsyncMovie(model.SearchText);
}
if (model.SearchInThemes)
{
viewModel.Projections = await this.cinema.FindAsyncTheme(model.SearchText);
}
return(View(viewModel));
}
public IActionResult Index()
{
var assetItems = _assets.GetAll();
var searchResults = assetItems.Select(result => new ItemListingModel
{
Id = result.Id,
ImageUrl = result.ImageUrl,
Title = result.Title,
Category = result.Category.Name,
Sku = result.Sku,
Location = result.Location,
Available = result.Available,
Notes = result.Notes
});
var assetModel = createItemIndexModel(searchResults);
var searchForm = new SearchFormModel()
{
SearchQuery = "Enter search query"
};
ViewModel myModel = new ViewModel();
myModel.Item1 = assetModel;
myModel.Item2 = searchForm;
return(View(myModel));
}
public async Task <IActionResult> Search(SearchFormModel model)
=> View(new SearchViewModel
{
SearchText = model.SearchText,
Subtitles = await this.subtitlesService.FindeAsync(model.SearchText, model.Language),
Language = model.Language
});
public async Task <IActionResult> Search(SearchFormModel model)
{
var viewModel = new SearchViewModel
{
SearchText = model.SearchText
};
if (model.SearchByBrands)
{
viewModel.Products = await this.products.FindByBrandAsync(model.SearchText);
viewModel.FilterName = WebConstants.BrandFilterName;
}
else if (model.SearchByCategories)
{
viewModel.Products = await this.products.FindByCategoryAsync(model.SearchText);
viewModel.FilterName = WebConstants.CategoryFilterName;
}
else
{
viewModel.Products = await this.products.FindAllBySearchTerm(model.SearchText);
}
return(View(viewModel));
}
private static void SearchButtonClick(object o, EventArgs e)
{
var view = new SearchFormView();
var model = new SearchFormModel();
var controller = new SearchFormController(model, view);
view.ShowDialog();
}
public SearchDialog()
{
InitializeComponent();
Controller = new SearchDialogController(this);
SearchFormModel model = new SearchFormModel();
SearchingProps = model;
DataContext = model;
}
private Task <DocumentSearchResult> SearchIndex(string indexName, SearchFormModel model)
{
SearchIndexClient indexClient = AzureSearchHelper.CreateSearchIndexClient(indexName: indexName);
SearchParameters searchParameter = CreateSearchParameters();
return(indexClient.Documents.SearchAsync(
searchText: model.SearchText,
searchParameters: searchParameter,
searchRequestOptions: null));
}
public ActionResult Index([Bind(Prefix = "SearchForm")] SearchFormModel search)
{
var searchResults = _jobService
.SearchJobs(search.Title, search.Cash);
var viewModel = new HomePageViewModel {
Jobs = searchResults, SearchForm = search
};
return(View(viewModel));
}
public async Task <ActionResult> Search(SearchFormModel model)
{
if (model == null)
{
model = new SearchFormModel();
}
model.SearchResultLucene = await SearchIndex(indexName : ConfigurationManager.AppSettings["SearchServiceIndex"], model : model);
return(View(model));
}
public IActionResult ExecuteSeach(SearchFormModel search)
{
int desiredResultCount = 100;
var googleResultsHtml = _googleHelper.GetHtmlResults(desiredResultCount, search.SearchTerms);
// Leave Bing out for now, client not evaluating javascript or something?
//var bingResultsHtml = _bingHelper.GetHtmlResults(desiredResultCount, search.SearchTerms);
ViewBag.SearchResult = ParseResult(search.TargetURL, googleResultsHtml);
return(View("Index"));
}
public ActionResult Index()
{
var directories = cacheService.Get(
LogsParserConstants.DirectoriesCacheKey,
() => directoryService.GetLogDirectories(), 60);
var formViewModel = new SearchFormModel()
{
Directories = directories
};
return(View(formViewModel));
}
public async Task <IActionResult> Search(SearchFormModel model)
{
var viewModel = new SearchViewModel
{
SearchText = model.SearchText
};
if (model.SearchInBags)
{
viewModel.Bags = await this.bagService.FindAsync(model.SearchText);
}
return(View(viewModel));
}
public ActionResult SearchResults(SearchFormModel search, int?id)
{
if (id != null && id != 0)
{
var jrn = _context.Journals.SingleOrDefault(j => j.Id == id);
search.JournalId = (int)id;
search.JournalTitle = jrn.Title;
}
search.Results = new List <JournalEntry>();
var myJournals = (from j in _context.Journals
where j.UserName == User.Identity.Name
select j).ToList();
foreach (var jrn in myJournals)
{
var myEntries = (from e in _context.JournalEntries
where e.JournalId == jrn.Id
select e).ToList();
foreach (var ent in myEntries)
{
search.Results.Add(ent);
}
}
if (search.ShowDeleted == false)
{
search.Results = FilterOutDeleted(search.Results);
}
if (search.ShowHidden == false)
{
search.Results = FilterOutHidden(search.Results);
}
if (search.SearchString != null)
{
search.Results = FilterByString(search.Results, search.SearchString);
}
if (search.StartDate.Date != new DateTime().Date)
{
search.Results = search.EndDate.Date != new DateTime().Date ? FilterByDateRange(search.Results, search.StartDate, search.EndDate) : FilterByDate(search.Results, search.StartDate);
}
if (search.JournalId != 0)
{
search.Results = FilterByJournal(search.Results, search.JournalId);
}
return(View(search));
}
public ActionResult AjaxSearch(SearchFormModel model)
{
DishService ds = new DishService();
IEnumerable <Dish> AllDishes = ds.GetAll();
IEnumerable <DishDetailsModel> result = AllDishes
.Where(d => d.Name.ToLower().Contains(model.NameSushi?.ToLower() ?? string.Empty))
.Select(d => d.Map <DishDetailsModel>());
if (model.PickedCategories != null)
{
result = result.Where(d => model.PickedCategories.Contains(d.CategoryId));
}
return(PartialView(result));
}
public ActionResult Search(SearchFormModel model)
{
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
NameValueCollection queryString = new NameValueCollection
{
["s"] = model.SearchTerm
};
return(new RedirectToUmbracoPageResult(7076, queryString));
}
public async Task <IActionResult> Search(SearchFormModel model, int page = 1)
{
var viewModel = new SearchViewModel
{
SearchText = model.SearchText,
Cars = await this.cars.AllAsync(page),
TotalCars = await this.cars.TotalAsync(),
CurrentPage = page
};
if (model.SearchInCity)
{
viewModel.Cars = await this.cars.FindCarByCityAsync(model.SearchText);
}
return(View(viewModel));
}
public ActionResult Index(SearchFormModel searchModel)
{
if (!string.IsNullOrWhiteSpace(searchModel.Query.QueryString))
{
var queryFrequencies = documentIndexator.ExtractWordFrequency(searchModel.Query.QueryString);
var user = User as User;
var documents = documentRepository.GetAllForUser(user);
IEnumerable <Dictionary <string, double> > allFrequencies = documents.Select(doc => doc.WordFrequency);
searchModel.Results = documents.Select(doc => new SearchResultItem()
{
Document = doc,
Relevancy = relevancyCounter.GetDocumentRelevancy(queryFrequencies, doc.WordFrequency, allFrequencies)
}).Where(result => result.Relevancy > 0).OrderByDescending(result => result.Relevancy).ToList();
}
return(View(searchModel));
}
public async Task <IActionResult> Search(SearchFormModel model)
{
if (model.SearchText == string.Empty)
{
return(View(model));
}
var products = await this.categories.Find(model.SearchText);
var viewModel = new SearchViewModel
{
SearchText = model.SearchText,
Products = products
};
return(View(viewModel));
}
public async Task <IActionResult> Search(SearchFormModel model)
{
var viewModel = new SearchViewModel
{
SearchText = model.SearchText
};
if (model.SearchInCourses)
{
viewModel.Courses = await this.courses.FindAsync(viewModel.SearchText);
}
if (model.SearchInUsers)
{
viewModel.Users = await this.users.FindAsync(model.SearchText);
}
return(View(viewModel));
}
public async Task <IActionResult> Search(SearchFormModel model)
{
var viewModel = new SearchViewModel
{
SearchText = model.SearchText,
};
var result = await this.listingService.FindAsync(model.SearchText);
if (result == null)
{
return(this.RedirectToAction(nameof(HomeController.Index), "Home", new { area = string.Empty }).WithWarning(string.Empty, CouldNotFind));
}
viewModel.Properties = result;
return(this.View(viewModel));
}
public async Task <IActionResult> Search(SearchFormModel model)
{
var viewModel = new SearchViewModel
{
Search = model.Search ?? string.Empty
};
if (model.SearchInCourses)
{
viewModel.Courses = await this.courses.CoursesBySearchAsync(viewModel.Search);
}
if (model.SearchInUsers)
{
viewModel.Users = await this.users.UserBySearchAsync(viewModel.Search);
}
return(View(viewModel));
}
public IActionResult Search(SearchFormModel model)
{
var viewModel = new SearchListingModel
{
SeachText = model.SearchText
};
if (model.SearchInCourses)
{
viewModel.Courses = this.courses.Find(model.SearchText);
}
if (model.SearchInStudents)
{
viewModel.Users = this.users.Find(model.SearchText);
}
return(View(viewModel));
}
public IEnumerable<IContent> SearchAll(SearchFormModel searchModel)
{
var contentTypeService = ApplicationContext.Current.Services.ContentTypeService;
var contentService = ApplicationContext.Current.Services.ContentService;
var contentType = contentTypeService.GetContentType("Forms");
if (contentType == null)
{
return new List<IContent>();
}
var contentNode = contentService.GetContentOfContentType(contentType.Id).FirstOrDefault();
if (contentNode == null)
{
return new List<IContent>();
}
var parentId = contentNode.Id;
var resultItems = contentService.GetChildren(parentId);
var filteredResult = resultItems
.Where(x =>
{
var formName = x.GetValue<string>("formName");
var isPublic = x.GetValue<bool>("isPublic");
var groups = x.GetValue<string>("associatedGroups");
var tags = x.GetValue<string>("formTags");
return (string.IsNullOrEmpty(searchModel.TextSearch) || (!string.IsNullOrEmpty(formName) && formName.InvariantContains(searchModel.TextSearch))) &&
(searchModel.IsPublic == null || searchModel.IsPublic.Equals(isPublic)) &&
(!searchModel.Groups.Any() || !string.IsNullOrEmpty(groups) && groups.ToDelimitedList().ContainsAll(searchModel.Groups)) &&
(!searchModel.Tags.Any() || !string.IsNullOrEmpty(tags) && tags.ToDelimitedList().ContainsAll(searchModel.Tags));
})
.Sort(x => x.GetValue<string>(searchModel.SortColumn), searchModel.SortDirection);
return filteredResult;
}
public QueryResultDisplay SearchForms(QueryDisplay query)
{
var textSearch = query.Parameters.FirstOrDefault(x => x.FieldName == "textSearch").IfNotNull(x => x.Value);
var isPublic = query.Parameters.FirstOrDefault(x => x.FieldName == "isPublic").IfNotNull(x => x.Value);
var groups = query.Parameters.FirstOrDefault(x => x.FieldName == "groups").IfNotNull(x => x.Value);
var tags = query.Parameters.FirstOrDefault(x => x.FieldName == "tags").IfNotNull(x => x.Value);
if (query.ItemsPerPage < 1)
{
query.ItemsPerPage = _itemsPerPage;
}
bool isPublicParsed;
var searchModel = new SearchFormModel
{
SortColumn = query.SortBy,
SortDirection = query.SortDirection,
TextSearch = textSearch,
IsPublic = !string.IsNullOrEmpty(isPublic) && Boolean.TryParse(isPublic, out isPublicParsed) ? (bool?)isPublicParsed : null,
Groups = !string.IsNullOrEmpty(groups) ? groups.ToDelimitedList() : new List<string>(),
Tags = !string.IsNullOrEmpty(tags) ? tags.ToDelimitedList() : new List<string>()
};
var forms = _formService.SearchAll(searchModel);
var totalItems = forms.Count();
var pagedForms = forms
.Skip(query.CurrentPage * query.ItemsPerPage)
.Take(query.ItemsPerPage)
.Select(Mapper.Map<IContent, ContentItemBasic<ContentPropertyBasic, IContent>>)
.Select(Mapper.Map<ContentItemBasic<ContentPropertyBasic, IContent>, FormListItemDisplay>).ToList();
var result = QueryResultDisplay.Build(pagedForms, totalItems, query.CurrentPage, query.ItemsPerPage);
return result;
}
