public virtual ActionResult Index(StatisticsFilterModel filter = null)
{
filter = filter ?? new StatisticsFilterModel();
ViewBag.UserName = filter.UserName;
ViewBag.Filter = filter;
ViewBag.CountryDepartmentList = SearchModel.GetCountryDeparmentList();
ViewBag.SectorDepartmentList = SearchModel.GetSectorDeparmentList();
ViewBag.DivisionList = SearchModel.GetDivisionBySectorDeparment(null);
ViewBag.CountryList = SearchModel.GetCountryByCountryDeparment(null);
ViewBag.OperationTypeList = MasterDataModel.GetMasterDataModels("OPERATION TYPE");
((List <ConvergenceMasterDataModel>)ViewBag.OperationTypeList).Insert(0, this.CreateSelectDataModel("Operation Type"));
ViewBag.OverallStageList = MasterDataModel.GetMasterDataModels("OVERALL_STAGE");
((List <ConvergenceMasterDataModel>)ViewBag.OverallStageList).Insert(0, this.CreateSelectDataModel("Overall Stage"));
var FundList = MasterDataModel.GetMasterDataModels("FUND");
ViewBag.FundList = MasterDataModel.GetMasterDataModels("FUND");
((List <ConvergenceMasterDataModel>)ViewBag.FundList).Insert(0, this.CreateSelectDataModel("Fund"));
ViewBag.SelectedFilter = SelectedFilter.none;
var model = new SearchQueryModel();
model.UserName = filter.UserName;
model.ClauseStatus = filter.ClauseStatus;
return(View(model));
}
public SearchQueryModel Search(string searchText)
{
var articles = _articleRepository.Search(searchText);
var authors = _authorRepository.Search(searchText);
var categories = _categoryRepository.Search(searchText);
var articleSearchContent = new SearchContent()
{
Module = nameof(Article),
Data = articles
};
var authorSearchContent = new SearchContent()
{
Module = nameof(Author),
Data = authors
};
var categorySearchContent = new SearchContent()
{
Module = nameof(Category),
Data = categories
};
var searchQueryModel = new SearchQueryModel()
{
SearchText = searchText
};
searchQueryModel.Contents.Add(articleSearchContent);
searchQueryModel.Contents.Add(authorSearchContent);
searchQueryModel.Contents.Add(categorySearchContent);
return(searchQueryModel);
}
public async Task <AnalysisQueueListModel> GetAsync(SearchQueryModel filter)
{
IQueryable <AnalysisQueue> query = _context.AnalysisQueues.Include(x => x.User);
if (filter.DateFrom.HasValue)
{
query = query.Where(x => x.UserStartPeriod >= filter.DateFrom.Value);
}
if (filter.DateTo.HasValue)
{
query = query.Where(x => x.UserEndPeriod <= filter.DateTo.Value);
}
var total = query.Count();
var result = await query
.OrderByDescending(x => x.UserEndPeriod)
.Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize)
.ToListAsync();
return(new AnalysisQueueListModel
{
TotalCount = total,
CurrentPage = filter.Page,
Items = Mapper.Map <IList <AnalysisQueueModel> >(result ?? new List <AnalysisQueue>()),
PageSize = filter.PageSize,
TotalPages = (int)Math.Ceiling((double)total / filter.PageSize)
});
}
public async Task <IEnumerable <PublicVehicleViewModel> > GetByQuery(SearchQueryModel _queryModel, string _query = "")
{
List <PublicVehicleViewModel> carList = new List <PublicVehicleViewModel>();
List <PublicVehicleViewModel> carDateList = new List <PublicVehicleViewModel>();
await Task.Run(() =>
{
foreach (Vehicle car in dBase.Vehicles)
{
if (PublicSearchParameters(_query, car, _queryModel._queryVehicle))
{
carList.Add(ConvertDBModelToViewModel(car));
}
}
});
if (_queryModel._dates != null)
{
await Task.Run(() =>
{
foreach (PublicVehicleViewModel item in carList)
{
if (checkRentals(item, _queryModel._dates))
{
carDateList.Add(item);
}
}
});
return(carDateList);
}
return(carList);
}
public async Task <ActionResult <SearchResponseModel> > Search([FromQuery] SearchQueryModel search, CancellationToken cancellationToken)
{
var semver2 = search.SemVerLevel == "2.0.0";
var prerelease = search.Prerelease;
var query = search.Query;
IQueryable <Package> dbpackages = this.Database.Packages
.Include(x => x.Versions)
.Include(x => x.Tags)
.Include(x => x.Authors);
if (!string.IsNullOrWhiteSpace(search.Query))
{
dbpackages = dbpackages.Where(x => (EF.Functions.TrigramsSimilarity(x.Id, query) >= 0.35 ||
EF.Functions.TrigramsSimilarity(x.Description, query) >= 0.2 ||
EF.Functions.TrigramsSimilarity(x.Title, query) >= 0.2 ||
x.Tags.Any(y => EF.Functions.TrigramsSimilarity(y.Tag, query) >= 0.35)) &&
(x.SemVerLevel == SemVerLevel.Unknown || semver2) &&
x.Versions.Any(y => (!y.IsPrerelase || prerelease) && y.IsListed));
}
else
{
dbpackages = dbpackages.Where(x => (x.SemVerLevel == SemVerLevel.Unknown || semver2) &&
x.Versions.Any(y => (!y.IsPrerelase || prerelease) && y.IsListed));
}
var count = await dbpackages.CountAsync(cancellationToken).ConfigureAwait(false);
return(this.PrepareResponse(dbpackages, count, prerelease, search.Skip, search.Take));
}
public new IQueryable <ContentPage> GetQuery(SearchQueryModel searchQueryModel, out string indexName)
{
//todo: determine if this override is still necessary in SXA 1.8
searchQueryModel.Languages = new List <string> {
Sitecore.Context.Language.Name
};
return(base.GetQuery(searchQueryModel, out indexName));
}
public ActionResult Index()
{
SearchQueryModel searchQuery = new SearchQueryModel()
{
TypeService = "Catégorisation"
};
return(View(searchQuery));
}
public IActionResult SearchQuery([Bind("QueryId")] SearchQueryModel sqm)
{
if (ModelState.IsValid)
{
return(RedirectToAction("viewQuery", "query", new { queryId = sqm.QueryId }));
}
return(View(sqm));
}
public IActionResult Index(SearchQueryModel query)
{
if (!ModelState.IsValid)
{
return(View(query));
}
query.Result = _searchQuery.GetSearchPosition(query);
return(View(query));
}
public async Task <IHttpActionResult> GetByQuery(SearchQueryModel viewModel, string _query = "")
{
if ((_query == null && store.EmptyViewModelCheck(viewModel._queryVehicle)) && (viewModel._dates == null))
{
return(Ok(store.GetAllVehicles()));
}
else
{
IEnumerable <PublicVehicleViewModel> model = await store.GetByQuery(viewModel, _query);
return(Ok(model));
}
}
public SearchQueryDto(SearchQueryModel query) : this()
{
if (query is null)
{
return;
}
OrderBy = query.OrderBy ?? OrderBy.Title;
OrderDirection = query.OrderDirection ?? OrderDirection.Asc;
Skip = query.Skip ?? defaultSkipValue;
Title = query.Title;
Top = query.Top ?? defaultTopValue;
}
public ActionResult Search(SearchQueryModel model)
{
if (ModelState.IsValid)
{
LastSearchResult = planService.SearchDestinations(model.PlaceId, model.CategoryId, model.Keywords);
return(PartialView(
"SearchResult",
LastSearchResult != null && LastSearchResult.Count > 0 ? LastSearchResult : null));
}
return(new EmptyResult());
}
public Stream GetSearch(string request)
{
// Don't know why this doesn't come with the wildcard parameter in the template, but here's another
// way to get the query string
SearchQueryModel search = new SearchQueryModel(WebOperationContext.Current.IncomingRequest.UriTemplateMatch.RequestUri.Query, request);
string searchString = "";
int memberId = _memberAdapter.GetMemberIdFromContext();
bool isAuthorized = memberId != 0;
Dictionary <string, MemberToDoModel> todos = new Dictionary <string, MemberToDoModel>();
if (isAuthorized)
{
todos = _memberAdapter.GetToDoDictionary(memberId);
}
/*if the request is not from sort control bar, we don't execute updateFilterParamter function.*/
if (search.query.Contains("Dims=") || search.query.Contains("Type=") || search.query.Contains("Ns="))
{
searchString = endecaUtility.updateFilterParameter(search.query, memberId, true);
}
if (searchString.Length > Config.SearchApiLimit)
{
_log.Error("Search request " + searchString + " exceeded max allowed length of " + Config.SearchApiLimit);
throw new WebException("Search error: Search string exceeded maximum allowed length");
}
WebRequest reqEndeca = WebRequest.Create("http://" + Config.ITLHost + ":" + Config.ITLPort.ToString() + "/" + request + searchString);
//COV-10458 - RESOURCE_LEAK
using (HttpWebResponse resEndeca = (HttpWebResponse)reqEndeca.GetResponse())
{
if (isAuthorized && todos.Count > 0)
{
return(decorateTodoRecordProperties(resEndeca, todos));
}
else
{
WebOperationContext.Current.OutgoingResponse.ContentType = "application/json";
// Get the stream containing content returned by the server.
using (StreamReader streamReader = new StreamReader(resEndeca.GetResponseStream(), true))
{
return(new MemoryStream(Encoding.UTF8.GetBytes(streamReader.ReadToEnd() ?? "")));
}
}
}
}
public async Task <SearchResultModel <GroupModel> > GetRootGroups(SearchQueryModel pageSearchEntry)
{
var restClient = await GetRestClient();
var request = new RestRequest("/api/groups/root", Method.POST)
{
RequestFormat = DataFormat.Json
};
request.AddBody(pageSearchEntry);
IRestResponse <SearchResultModel <GroupModel> > response = await restClient.ExecuteTaskAsync <SearchResultModel <GroupModel> >(request);
return(response.IsSuccessful ? response.Data : null);
}
public async Task <IEnumerable <GroupModel> > GetSubgroups(SearchQueryModel searchEntry, string parentId)
{
var restClient = await GetRestClient();
var request = new RestRequest("/api/groups/" + parentId + "/subgroups", Method.POST)
{
RequestFormat = DataFormat.Json
};
request.AddBody(searchEntry);
IRestResponse <IEnumerable <GroupModel> > response = await restClient.ExecuteTaskAsync <IEnumerable <GroupModel> >(request);
return(response.IsSuccessful ? response.Data : null);
}
private async Task GetCompanies(SqlConnection connection1, SearchQueryModel model, List <CompaniesQueryModel> lst)
{
SqlCommand cmd = new SqlCommand();
string cmdString = "SELECT top " + rowsQuery.ToString() + " id, name, status FROM companies ";
SqlParameter parameter = null;
if (model.status != 2)
{
cmdString += "where status = @status ";
parameter = new SqlParameter("@status", SqlDbType.Int);
parameter.Value = model.status;
cmd.Parameters.Add(parameter);
}
if (model.filter != "")
{
if (model.status == 2)
{
cmdString += "where name like @search ";
}
else
{
cmdString += "and name like @search ";
}
parameter = new SqlParameter("@search", SqlDbType.VarChar);
parameter.Value = "%" + model.filter + "%";
cmd.Parameters.Add(parameter);
}
cmdString += "order by name";
cmd.CommandText = cmdString;
cmd.Connection = connection1;
SqlDataReader reader = await cmd.ExecuteReaderAsync();
while (await reader.ReadAsync())
{
CompaniesQueryModel menuModel = new CompaniesQueryModel();
menuModel.id = reader.GetString(0);
menuModel.name = reader.GetString(1);
menuModel.status = reader.GetInt32(2);
lst.Add(menuModel);
}
reader.Close();
}
public string GetSearchPosition(SearchQueryModel query)
{
string search = string.Format(_configuration["SearchEnglineUrl"], HttpUtility.UrlEncode(query.KeyWord), query.ResultSetCount);
var request = (HttpWebRequest)WebRequest.Create(search);
using (var response = (HttpWebResponse)request.GetResponse())
{
using (var reader = new StreamReader(response.GetResponseStream(), Encoding.ASCII))
{
string html = reader.ReadToEnd();
return(FindPosition(html, new Uri(query.Website)));
}
}
}
public async Task <ActionResult> Recommendation(SearchQueryModel searchModel)
{
if (ModelState.IsValid)
{
try
{
return(View(await _spotifyService.SearchAsync(searchModel.Query, searchModel.SeedType).ToViewModel()));
}
catch (Exception e)
{
TempData["ErrorMessage"] = e.Message;
return(View("Error"));
}
}
return(View("Search", searchModel));
}
public IHttpActionResult SearchLibraryItems([FromUri] SearchQueryModel query)
{
var searchQuery = new SearchQueryDto(query);
var passesWithMinimalData = _passRepository.MinimalDataSearch(
searchQuery,
true
);
if (passesWithMinimalData.TotalCount > 0)
{
return(Ok(passesWithMinimalData));
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> Autocomplete([FromQuery] SearchQueryModel search, CancellationToken cancellationToken)
{
var semver2 = search.SemVerLevel == "2.0.0";
var prerelease = search.Prerelease;
if (string.IsNullOrWhiteSpace(search.Id))
{
var query = search.Query;
var dbids = this.Database.Packages
.Include(x => x.Versions)
.Include(x => x.Tags)
.Include(x => x.Authors)
.Where(x => (EF.Functions.TrigramsSimilarity(x.Id, query) >= 0.35 ||
EF.Functions.TrigramsSimilarity(x.Description, query) >= 0.2 ||
EF.Functions.TrigramsSimilarity(x.Title, query) >= 0.2 ||
x.Tags.Any(y => EF.Functions.TrigramsSimilarity(y.Tag, query) >= 0.35)) &&
(x.SemVerLevel == SemVerLevel.Unknown || semver2) &&
x.Versions.Any(y => (!y.IsPrerelase || prerelease) && y.IsListed))
.Select(x => x.Id);
var count = await dbids.CountAsync(cancellationToken).ConfigureAwait(false);
return(this.Ok(new SearchAutocompleteResponseModel
{
TotalResultCount = count,
Results = dbids
}));
}
else
{
var id = search.Id;
var dbversions = this.Database.PackageVersions
.Include(x => x.Package)
.Where(x => x.PackageId == id &&
(!x.IsPrerelase || prerelease) &&
(x.Package.SemVerLevel == SemVerLevel.Unknown || semver2))
.Select(x => x.Version);
return(this.Ok(new SearchEnumerateResponseModel {
Versions = dbversions
}));
}
}
[Route("api/GetAutoCompleteData")] //pending
public IActionResult GetAutoCompleteData(string sportid, string stype, string term = "")
{
string result = string.Empty;
try
{
List <SearchQueryModel> _objLstSearchQuery = new List <SearchQueryModel>();
SearchQueryModel _objSqModel = new SearchQueryModel();
//List<FTData> _objFTData = LuceneService.GetFTData(term);
ResultFTData _objResultFTData = new ResultFTData();
List <string> _objLstSkill = new List <string>();
List <FTData> _objFTData = new List <FTData>();
List <KTData> _objKTdata = new List <KTData>();
}
catch (Exception ex)
{
}
return(Ok(new { Response = result }));
}
public override async Task <ActionResult <PaginationModel <ReadViewModel> > > Get()
{
var searchQuery = new SearchQueryModel(Request);
Expression <Func <MixTheme, bool> > predicate = null;
predicate = predicate.AndAlsoIf(searchQuery.Status.HasValue, model => model.Status == searchQuery.Status.Value);
predicate = predicate.AndAlsoIf(searchQuery.FromDate.HasValue, model => model.CreatedDateTime >= searchQuery.FromDate.Value);
predicate = predicate.AndAlsoIf(searchQuery.ToDate.HasValue, model => model.CreatedDateTime <= searchQuery.ToDate.Value);
predicate = predicate.AndAlsoIf(!string.IsNullOrEmpty(searchQuery.Keyword),
model => EF.Functions.Like(model.Name, $"%{searchQuery.Keyword}%"));
var getData = await GetListAsync <ReadViewModel>(predicate, searchQuery);
if (getData.IsSucceed)
{
return(getData.Data);
}
else
{
return(BadRequest(getData.Errors));
}
}
public async Task <List <ProductViewModel> > Get(SearchQueryModel query)
{
var ret = await Context.Products.Include(x => x.Properties)
.Include(x => x.Category)
.Where(x =>
(x.Name.Contains(query.SearchText) || string.IsNullOrWhiteSpace(query.SearchText)) &&
(query.Properties == null || query.Properties.Count(p => !string.IsNullOrWhiteSpace(p.Value)) == 0 || (x.Properties.Any(z => query.Properties.Where(p => !string.IsNullOrWhiteSpace(p.Value)).Any(p => p.Key == z.CategoryPropertyId && (z.Value == p.Value))))) &&
(x.CategoryId == query.CategoryId || query.CategoryId == null)
).Select(x => new ProductViewModel()
{
Id = x.Id,
Name = x.Name,
Price = x.Price,
Description = x.Description,
Category = new CategoryViewModel()
{
Name = x.Category.Name
},
}).ToListAsync();
return(ret);
}
public IHttpActionResult SearchLibraryItems([FromUri] SearchQueryModel query)
{
var searchQuery = new SearchQueryDto(query);
IEnumerable <PassDigestListItem> passesContainingTitleFromQuery = new List <PassDigestListItem>();
if (!string.IsNullOrEmpty(searchQuery.Title))
{
var passesSearchQuery = new SearchQueryDto(new SearchQueryModel()
{
OrderBy = query.OrderBy,
OrderDirection = query.OrderDirection,
Title = query.Title,
Top = int.MaxValue,
Skip = 0
});
passesContainingTitleFromQuery = _passRepository.MinimalDataSearch(passesSearchQuery, false)
.Items
.Where(p =>
p.Name.IndexOf(searchQuery.Title, StringComparison.CurrentCultureIgnoreCase) >= 0
);
}
var scenariosWithMinimalData = _scenarioRepository.MinimalDataSearch(
searchQuery,
true,
passesContainingTitleFromQuery
.Select(p => p.Id)
);
if (scenariosWithMinimalData.TotalCount > 0)
{
var defaultScenarioId = _tenantSettingsRepository.GetDefaultScenarioId();
var defaultScenario = scenariosWithMinimalData.Items.FirstOrDefault(c => c.Id == defaultScenarioId);
if (defaultScenario != null)
{
defaultScenario.IsDefault = true;
}
var extractedPasses = ExtractMinimalPassesFromScenarios(scenariosWithMinimalData)
.ToList();
var passesFromDb = _passRepository.FindByIds(extractedPasses.Select(pass => pass.Id))
.Select(p => (p.Id, p.Name, p.DateModified))
.ToDictionary(p => p.Id);
List <int> passIdsToRemove = new List <int>();
UpdatePassesWithMinimalData(extractedPasses, passesFromDb, passIdsToRemove);
RemoveDeletedPasses(scenariosWithMinimalData, passIdsToRemove);
var minimalDataSearchResult = _mapper.Map <SearchResultModel <ScenarioDigestListItemModel> >(scenariosWithMinimalData);
return(Ok(minimalDataSearchResult));
}
else
{
return(NotFound());
}
void UpdatePassesWithMinimalData(
List <PassDigestListItem> passesWithMinimalData,
Dictionary <int, (int Id, string Name, DateTime?DateModified)> passesFromDb,
List <int> passIdsToRemove)
{
passesWithMinimalData.ForEach(minimalDataPass =>
{
var pass = passesFromDb.FirstOrDefault(pass => pass.Key == minimalDataPass.Id).Value;
if (pass.Id == minimalDataPass.Id)
{
minimalDataPass.DateModified = pass.DateModified.Value;
minimalDataPass.Name = pass.Name;
}
else
{
passIdsToRemove.Add(minimalDataPass.Id);
}
});
}
void RemoveDeletedPasses(SearchResultModel <ScenarioDigestListItem> scenariosWithMinimalData, List <int> passIdsToRemove)
{
passIdsToRemove.ForEach(id =>
{
scenariosWithMinimalData.Items.ForEach(scenario =>
{
var passToRemove = scenario.Passes.Find(p => p.Id == id);
if (passToRemove != null)
{
scenario.Passes.Remove(passToRemove);
}
});
});
}
IEnumerable <PassDigestListItem> ExtractMinimalPassesFromScenarios(SearchResultModel <ScenarioDigestListItem> searchScenarios)
{
var passes = new List <PassDigestListItem>();
foreach (var scenario in searchScenarios.Items)
{
passes.AddRange(scenario.Passes);
}
return(passes);
}
}
internal async Task SearchQuery(SearchQueryModel model, List <MenuQueryModel> resultSeachModel, SqlConnection connection1)
{
await GetMenus(connection1, model, resultSeachModel);
}
public async Task <List <ProductViewModel> > Get(SearchQueryModel query)
{
return(await _productRepository.Get(query));
}
internal async Task SearchQuery(SearchQueryModel model, List <CompaniesQueryModel> resultSeachModel, SqlConnection connection1)
{
await GetCompanies(connection1, model, resultSeachModel);
}
public async Task <IActionResult> Search([FromBody] SearchQueryModel model)
{
var articles = await _articleService.SearchAsync(model.QueryText);
return(Ok(articles));
}
/// <summary>
/// Search for companies according to search criteria
/// </summary>
/// <param name="queries">The criteria to search for.</param>
/// <returns>The collection of companies that match the criteria.</returns>
public virtual Data.Companies[] SearchForCompanies(string[] queries)
{
// Create the expression helper.
DataTypeConversion dataTypeConversion = new DataTypeConversion(_connectionDataType);
SqlStatementConstructor statement = new SqlStatementConstructor(dataTypeConversion);
// Create the query list.
Data.Companies[] companies = null;
List <QueryModel> queryModels = new List <QueryModel>();
// For each query.
foreach (string query in queries)
{
// Add the serach model.
SearchQueryModel[] searchModel = new SearchQueryModel[]
{
new SearchQueryModel()
{
ColumnName = "CompanyID",
Operand = Linq.ExpressionOperandType.Like,
Value = query,
ValueType = typeof(string)
},
new SearchQueryModel()
{
ColumnName = "CompanyName",
Operand = Linq.ExpressionOperandType.Like,
Value = query,
ValueType = typeof(string)
},
new SearchQueryModel()
{
ColumnName = "Address",
Operand = Linq.ExpressionOperandType.Like,
Value = query,
ValueType = typeof(string)
},
new SearchQueryModel()
{
ColumnName = "ABN",
Operand = Linq.ExpressionOperandType.Like,
Value = query,
ValueType = typeof(string)
},
};
// Add the query model item.
QueryModel model = new QueryModel()
{
Queries = searchModel, Operand = Linq.ExpressionOperandType.OrElse
};
queryModels.Add(model);
}
// Create the company expression.
Expression <Nequeo.Threading.FunctionHandler <bool, Data.Companies> > predicate =
statement.CreateLambdaExpressionEx <Data.Companies>(queryModels.ToArray(), Linq.ExpressionOperandType.OrElse);
// Execute the query.
companies = Select.SelectIQueryableItems(predicate).ToArray();
// Return the list found.
return(companies);
}
protected async Task <RepositoryResponse <PaginationModel <T> > > GetListAsync <T>(Expression <Func <TModel, bool> > predicate = null, SearchQueryModel searchQuery = null)
where T : ViewModelBase <TDbContext, TModel, T>
{
searchQuery ??= new SearchQueryModel(Request);
RequestPaging request = new RequestPaging()
{
PageIndex = searchQuery.PagingData.PageIndex,
PageSize = searchQuery.PagingData.PageSize,
OrderBy = searchQuery.PagingData.OrderBy,
Direction = searchQuery.PagingData.Direction
};
RepositoryResponse <PaginationModel <T> > data = null;
if (data == null)
{
if (predicate != null)
{
data = await DefaultRepository <TDbContext, TModel, T> .Instance.GetModelListByAsync(
predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex, null, null);
}
else
{
data = await DefaultRepository <TDbContext, TModel, T> .Instance.GetModelListAsync(request.OrderBy, request.Direction, request.PageSize, request.PageIndex, null, null).ConfigureAwait(false);
}
}
return(data);
}
