public async Task <IActionResult> GetFilteredAddresses(AddressesCriteria addressesCriteria) { if (addressesCriteria == null) { addressesCriteria = new AddressesCriteria(); } if (!addressesCriteria.StartAt.HasValue) { addressesCriteria.StartAt = 0; } if (!addressesCriteria.Count.HasValue) { addressesCriteria.Count = MaxPageSize; } var criteria = _mapper.Map <AddressFilterCriteria>(addressesCriteria); var addressResult = await _addressQuery.GetAddressLitesFilteredAsync(criteria, addressesCriteria.StartAt.Value, addressesCriteria.Count.Value, true, MaxAddressesReults); var response = new FilterResponse <FilteredAddress, AddressesCriteria> { Criteria = addressesCriteria, FilterResultCount = addressResult.ResultCount, Data = addressResult.Results.Select(x => _mapper.Map <FilteredAddress>(x)).ToList() }; return(Ok(response)); }
public static FilterResponse <List <T> > CreatePagedReponse <T>(List <T> pagedData, int totalRecords) { var respose = new FilterResponse <List <T> >(pagedData); respose.TotalRecords = totalRecords; return(respose); }
public virtual CommonResponse GetSingleWhere(params Expression <Func <Entity, bool> >[] wheres) { CommonResponse response = new CommonResponse(); FilterResponse filterResponse = new FilterResponse(); Entity entity; try { //repository.ByUserId = LoggedUser.UserID; entity = repository.GetSingle(null, wheres); if (entity != null) { OnGetSingle(entity); AdapterOut(entity); } return(response.Success(entity)); } catch (Exception e) { var originalException = GetOriginalException(e); return(response.Error("Error " + originalException.Message)); } }
private FilterResponse <TEntity> GetAllByFiltersChangeLimit(FilterRequest request) { int lastElementPos = request.Limit * request.CurrentPage.Value; int loops = (int)Math.Floor((decimal)(lastElementPos / request.NewLimit.Value)); loops = loops == 0 ? 1 : loops; FilterResponse <TEntity> resultList = new FilterResponse <TEntity>(); List <string> paginationTokens = new List <string> { "{}" }; for (int i = 0; i < loops; i++) { resultList = GetAllByFilters(request); if (!resultList.PaginationToken.Equals("{}")) { paginationTokens.Add(resultList.PaginationToken); } else if (resultList.PaginationToken.Equals("{}")) { break; } } return(new FilterResponse <TEntity> { Elements = resultList.Elements, Total = resultList.Total, PaginationToken = resultList.PaginationToken, PaginationTokens = paginationTokens }); }
public void Setup() { request = new FilterRequest(); response = new FilterResponse(); filter = new Filter(); testData = new LinkedList <string[]>(); testData.AddLast(new string[] { "d[\\s\\.-]*[u* ][\\s\\.-]*[c* ][\\s\\.-]*k", "yuck", "yuck", "yuck", "yuck" }); testData.AddLast(new string[] { "s[\\s\\.-]*[n* ][\\s\\.-]*[i* ][\\s\\.-]*[t* ][\\s\\.-]*[c* ][\\s\\.-]*h", "lich", "lich", "lich", "lich" }); }
public string SaveString(FilterResponse inputString) { if (inputString == null) { throw new System.ArgumentNullException(nameof(inputString)); } // Simulate saving a cleaned string and returning the ID since this is a simiple fake repository. // return inputString.inputString; return("str"); }
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next) { if ((await OnActionExecutionPermission(context)).Status) { await next(); return; } FilterResponse.SetActionResult(context, ResponseContent); }
public void ProcessRequestNoMatchFound() { //arrange request.stringToModify = "This is a safe string."; //act response = filter.ProcessRequest(request, testData); //assert Assert.AreEqual("this is a safe string.", response.modifiedString); }
public void ProcessRequestMultipleMatchFound() { //arrange request.stringToModify = "What, the duck? You snitch."; //act response = filter.ProcessRequest(request, testData); //assert Assert.AreEqual("what, the yuck? you lich.", response.modifiedString); }
public FilterResponse ProcessRequest(FilterRequest request) { string newString = StringParser.generateNewString(request.stringToModify, "FILTER"); FilterResponse response = new FilterResponse { originalString = request.stringToModify, modifiedString = newString }; return(response); }
public FilterResponse ProcessRequest(FilterRequest request, LinkedList <string[]> filterList) { string newString = StringParser.generateNewString(request.stringToModify, filterList); FilterResponse response = new FilterResponse { originalString = request.stringToModify, modifiedString = newString }; return(response); }
public void ProcessRequestMatchFound() { //arrange request.stringToModify = "That's a duck."; //act response = filter.ProcessRequest(request, testData); //assert Console.WriteLine(response.modifiedString); Assert.AreEqual("that's a yuck.", response.modifiedString); }
///start:slot:logic<<< public CommonResponse GetInventory() { var response = new CommonResponse(); FilterResponse filterResponse = new FilterResponse(); var ctx = context as MROContext; var inventory = ctx.InventoryInputs.GroupBy(e => new { e.CatMaterial //, e.CatUnitOfMeasure }).Select(e => new { e.Key, e.Key.CatMaterial.Value, e.Key.CatMaterial.MaterialDescription, e.Key.CatMaterial.Min, BalanceSum = e.Sum(b => b.Balance), id = e.Key.CatMaterial.CatMaterialKey }); var filter = HttpContext.Current.Request["filterGeneral"]; if (!string.IsNullOrWhiteSpace(filter) && filter != null && filter != "undefined") { inventory = inventory.Where(e => e.Key.CatMaterial.Value.Contains(filter)); } var page = HttpContext.Current.Request["page"]; if (!string.IsNullOrWhiteSpace(page) && page != null && page != "undefined") { var perPage = HttpContext.Current.Request["perPage"]; if (!string.IsNullOrWhiteSpace(perPage) && perPage != null && perPage != "undefined") { int iPage = int.Parse(page); int iPerPage = int.Parse(perPage); filterResponse.total_items = inventory.Count(); //TODO FILTER filterResponse.total_filtered_items = inventory.Count(); inventory = inventory.OrderBy(e => e.Value).Skip((iPage - 1) * iPerPage).Take(iPerPage); } } return(response.Success(inventory.ToList(), filterResponse)); }
private static void GetStatesByCountryPaginatedControl(IStateRepository stateRepository) { string paginationToken; int option; string message = "Ingrese el Tamaño de Página"; int? limit = GetOption(message); List <string> pagTokens = new List <string> { "{}" }; int currentPage = 1; do { paginationToken = pagTokens[currentPage - 1]; FilterResponse <State> response = stateRepository.GetStateByCountry("CO", limit, paginationToken); ListStates(response.Elements); Console.WriteLine($"Pagina: {currentPage} - {response.PaginationToken}"); if (currentPage == 1) { message = "1.Avanzar\n3.Salir"; } else if (currentPage > 1 && response.PaginationToken.Equals("{}")) { message = "2. Atras\n3. Salir"; } else { message = "1. Avanzar\n2. Atras\n3. Salir"; } option = GetOption(message); if (option == 2 && currentPage > 1) { currentPage -= 1; pagTokens.RemoveAt(pagTokens.Count - 1); } else if (option == 1 && !response.PaginationToken.Equals("{}")) { pagTokens.Add(response.PaginationToken); currentPage++; } } while (option != 3); }
public static FilterResponse GetFilter() { var filterResponse = new FilterResponse(); filterResponse.Version = 1; filterResponse.Filters.Add(new TextBoxFilter() { key = "NumberInvoice", label = "Numer faktury", order = 1, visible = true }); filterResponse.Filters.Add(new TextBoxFilter() { key = "CompanyName", label = "Firma", order = 2, visible = true }); var dropdownMenu = new List <FiltersBase <string> >(); dropdownMenu.Add(new TextBoxFilter() { key = "", value = "Wybierz", order = 1 }); dropdownMenu.Add(new TextBoxFilter() { key = "Invoice", value = "Faktury", order = 2 }); dropdownMenu.Add(new TextBoxFilter() { key = "Correction", value = "Korekty", order = 3 }); filterResponse.Filters.Add(new DropdownFilter() { key = "DocumentType", label = "Typ dokumentu", order = 25, visible = true, options = dropdownMenu, }); return(filterResponse); }
protected override void OnActionExecuting(ActionExecutingContext filterContext) { List <PipelineDTO> list = new List <PipelineDTO>(); list = GetPipelines(); var FilterResponse = list.Where(x => x.IsNoms || x.IsUPRD); if (FilterResponse == null) { FilterResponse = new List <PipelineDTO>(); } if (FilterResponse != null) { var PipelineDuns = Request["pipelineDuns"] == null?Convert.ToString(FilterResponse.Select(a => a.DUNSNo).FirstOrDefault()) : Request["pipelineDuns"]; string Absoluteurl = HttpContext.Request.Url.AbsoluteUri; var parpipelineDuns = HttpUtility.ParseQueryString(Absoluteurl.Substring( new[] { 0, Absoluteurl.IndexOf('?') }.Max() )).Get("pipelineDuns"); PipelineDTO objPipeline = FilterResponse.Where(y => y.DUNSNo == parpipelineDuns).FirstOrDefault(); if (objPipeline == null) { objPipeline = FilterResponse.FirstOrDefault(); } if (Absoluteurl.Contains("MOperationalCapacity") || Absoluteurl.Contains("MUnsubscribedCapacity") || Absoluteurl.Contains("Notices")) { isPermission = (objPipeline.IsUPRD == true ? objPipeline.IsUPRD : false); } else if (Absoluteurl.Contains("PathedNomination") || Absoluteurl.Contains("NonPathed") || Absoluteurl.Contains("PNTNominations") || Absoluteurl.Contains("SQTSSummary") || Absoluteurl.Contains("Batch")) { isPermission = (objPipeline.IsNoms == true ? objPipeline.IsNoms : false); } ViewBag.IsPermission = isPermission; ViewBag.objPipeline = objPipeline; base.OnActionExecuting(filterContext); } }
public FilterResponse GetFilteredGraphData(FilterCriteriaRequest filterCriteria) { var vaccinationToQuery = string.Empty; var districtToQuery = string.Empty; if (filterCriteria.VaccineIdList.Count > 0) { vaccinationToQuery = "SchId in (" + string.Join(",", filterCriteria.VaccineIdList) + ")"; } if (filterCriteria.DistrictIdList.Count > 0) { districtToQuery = "DistrictId in (" + string.Join(",", filterCriteria.DistrictIdList) + ")"; } FilterResponse filterres = new FilterResponse(); if (filterCriteria.StatusList.Count > 0) { foreach (int status in filterCriteria.StatusList) { if (status == 0)//Done { var query = string.Format(@"SELECT Count(*) FROM ListOfSuccessfullVacc WHERE VaccinatedDate>='{0}' AND VaccinatedDate<='{1}' AND {2} AND {3}", filterCriteria.FromYear, filterCriteria.ToYear, districtToQuery, vaccinationToQuery); filterres.DoneCount = Convert.ToInt32(dbService.ExecuteScalar(query)); } else if (status == 1)//Due { var query = string.Format(@"SELECT Count(*) FROM ListOfVaccinationDue WHERE VAccStartOn>='{0}' AND VAccStartOn<='{1}'AND {2} AND {3} ", filterCriteria.FromYear, filterCriteria.ToYear, districtToQuery, vaccinationToQuery); filterres.DueCount = Convert.ToInt32(dbService.ExecuteScalar(query)); } else if (status == 2)//OverDue/Missed { var query = string.Format(@"SELECT Count(*) FROM ListOfVaccinationOverDue WHERE VAccStartOn>='{0}' AND VAccStartOn<='{1}' AND {2} AND {3}", filterCriteria.FromYear, filterCriteria.ToYear, districtToQuery, vaccinationToQuery); filterres.MissedCount = Convert.ToInt32(dbService.ExecuteScalar(query)); } } } //int Totalstatuscount = filterres.DueCount + filterres.DoneCount + filterres.MissedCount; //filterres.DoneCount = (filterres.DoneCount / Totalstatuscount) * 100; //filterres.DueCount = (filterres.DueCount / Totalstatuscount) * 100; //filterres.MissedCount = (filterres.MissedCount / Totalstatuscount) * 100; return(filterres); }
public FilterResponse GetFiltersData() { var filterResponse = new FilterResponse(); var miniVipTypes = GetVipTypes(); if (miniVipTypes.Count > 0) { VipLine.AddRange(filterResponse.vipLines, miniVipTypes); } var miniSpecials = GetSpecials(); if (miniSpecials.Count > 0) { SpecialLine.AddRange(filterResponse.specialLines, miniSpecials); } return(filterResponse); }
public void Write(FilterResponse response, Stream sw, List <Field> fields) { sw.StartObject(); sw.PropertyNameWithColon("accounts"); sw.StartArray(); var accounts = response.Ids; var limit = Math.Min(accounts.Count, response.Limit); for (int i = 0; i < limit; i++) { Write(accounts[i], sw, fields); if (i < limit - 1) { sw.Comma(); } } sw.EndArray(); sw.EndObject(); }
private static FilterResponse <MobilePhone> RunTemplate(List <CrunchItem <MobilePhone> > phoneItems) { CrunchRequest <MobilePhone> request = new CrunchRequest <MobilePhone>(); request.One = phoneItems.ToArray(); // In case you want to run a template with multiple rules set the TemplateId property to the Id of the template. // Otherwise if you run a single rule set the RuleId property. You can either have the TemplateId or the RuleId set at any given time not both. request.TemplateId = 1; // request.RuleId = 4; FilterResponse <MobilePhone> response = Task.Run(async() => { ApiClient api = new ApiClient(); return(await api.SendAsync <CrunchRequest <MobilePhone>, FilterResponse <MobilePhone> >(request, "/api/1.0/crunch/run")); }).GetAwaiter().GetResult(); return(response); }
private static FilterResponse <MobilePhone> FindBestHardwareAndCameraPhones(List <CrunchItem <MobilePhone> > phoneItems) { CrunchRequest <MobilePhone> request = new CrunchRequest <MobilePhone>(); request.One = phoneItems.ToArray(); request.Filter = new Filter() { Expression = "$1.status != \"Discontinued\" AND ISBLANK($1.internal_memory_mb) == FALSE AND ISBLANK($1.primary_camera_mp) == FALSE AND TONUMBER($1.internal_memory_mb) >= 8192 AND TONUMBER($1.primary_camera_mp) >= 8" }; request.FieldTypes = typeof(MobilePhone).GetProperties() .SelectMany(p => p.GetCustomAttributes(typeof(JsonPropertyAttribute), false).Cast <JsonPropertyAttribute>()) .ToDictionary(p => p.PropertyName, p => "String"); FilterResponse <MobilePhone> response = Task.Run(async() => { ApiClient api = new ApiClient(); return(await api.SendAsync <CrunchRequest <MobilePhone>, FilterResponse <MobilePhone> >(request, "/api/1.0/crunch/run")); }).GetAwaiter().GetResult(); return(response); }
private static FilterResponse <MobilePhone> FindDualSimPhones(List <CrunchItem <MobilePhone> > phoneItems) { CrunchRequest <MobilePhone> request = new CrunchRequest <MobilePhone>(); request.One = phoneItems.ToArray(); request.Filter = new Filter() { Expression = "$1.status != \"Discontinued\" AND FIND(\"Dual SIM\", $1.sim) >= 1 AND $1.card_slot != \"No\"" }; request.FieldTypes = typeof(MobilePhone).GetProperties() .SelectMany(p => p.GetCustomAttributes(typeof(JsonPropertyAttribute), false).Cast <JsonPropertyAttribute>()) .ToDictionary(p => p.PropertyName, p => "String"); FilterResponse <MobilePhone> response = Task.Run(async() => { ApiClient api = new ApiClient(); return(await api.SendAsync <CrunchRequest <MobilePhone>, FilterResponse <MobilePhone> >(request, "/api/1.0/crunch/run")); }).GetAwaiter().GetResult(); return(response); }
private static FilterResponse <MobilePhone> FindMostDurableBatteryPhones(List <CrunchItem <MobilePhone> > phoneItems) { CrunchRequest <MobilePhone> request = new CrunchRequest <MobilePhone>(); request.One = phoneItems.ToArray(); request.Filter = new Filter() { Expression = "$1.status != \"Discontinued\" AND ISBLANK($1.stand_by_hours) == FALSE AND ISBLANK($1.talk_time_hours) == FALSE " + "AND TONUMBER($1.stand_by_hours) >= 400 AND TONUMBER($1.talk_time_hours) >= 10" }; request.FieldTypes = typeof(MobilePhone).GetProperties() .SelectMany(p => p.GetCustomAttributes(typeof(JsonPropertyAttribute), false).Cast <JsonPropertyAttribute>()) .ToDictionary(p => p.PropertyName, p => "String"); FilterResponse <MobilePhone> response = Task.Run(async() => { ApiClient api = new ApiClient(); return(await api.SendAsync <CrunchRequest <MobilePhone>, FilterResponse <MobilePhone> >(request, "/api/1.0/crunch/run")); }).GetAwaiter().GetResult(); return(response); }
public virtual CommonResponse GetSingleWhere(params Expression <Func <Entity, bool> >[] wheres) { CommonResponse response = new CommonResponse(); FilterResponse filterResponse = new FilterResponse(); Entity entity; try { repository.byUserId = loggedUser.UserID; entity = repository.GetSingle(wheres); if (entity != null) { loadNavigationProperties(entity); } return(response.Success(entity)); } catch (Exception e) { return(response.Error("ERROR: " + e.ToString())); } }
public static List <FilterResponse> GetFilterResultForDocument(Document document, RestScoringResult scoringResult) { var searchResult = new List <FilterResponse>(); if (document != null) { foreach (var file in document.Files) { foreach (var paragraphUnit in file.ParagraphUnits) { if (paragraphUnit.IsStructure) { continue; } foreach (var pair in paragraphUnit.SegmentPairs) { var sourceText = FilterExpression.ConvertSegmentPair(pair.Source); var targetText = FilterExpression.ConvertSegmentPair(pair.Target); var matchScore = string.Empty; if (scoringResult != null) { matchScore = scoringResult.Match.ToString(); } var result = new FilterResponse { Source = sourceText, Target = targetText, MatchScore = matchScore }; searchResult.Add(result); } } } } return(searchResult); }
public virtual CommonResponse GetPage(int perPage, int page, string filterGeneral, Expression <Func <Entity, bool> >[] wheres, Expression <Func <Entity, object> > orderby, params Expression <Func <Entity, bool> >[] database_wheres) { CommonResponse response = new CommonResponse(); FilterResponse filterResponse = new FilterResponse(); IEnumerable <Entity> entities; //Entities comming from DB IQueryable <Entity> resultset; //To filter properties not in DB try { //repository.ByUserId = LoggedUser.UserID; //Apply Database Filtering and Fetch entities = StaticDbQueryForList(repository.GetList(orderby, null, database_wheres).AsQueryable()).AsNoTracking().ToList(); //Apply Roles Filtering //Applying Non-Database Wheres resultset = entities.AsQueryable(); if (wheres != null) { foreach (var where in wheres) { resultset = resultset.Where(where); } } filterResponse.total_items = resultset.Count(); #region Apply General Search Filter bool PopulateForSearchEqualsAdapterOut = false; PopulateForSearchEqualsAdapterOut = PopulateForSearch(resultset.ToArray()); HashSet <Entity> filteredResultSet = new HashSet <Entity>(); if (!string.IsNullOrWhiteSpace(filterGeneral)) { string[] arrFilterGeneral = filterGeneral.ToLower().Split(' '); var searchableProps = typeof(Entity).GetProperties().Where(prop => new[] { "String" }.Contains(prop.PropertyType.Name)); foreach (var e in resultset) { bool bAllKeywordsFound = true; foreach (var keyword in arrFilterGeneral) { bool bAtLeastOnePropertyContainsIt = false; foreach (var prop in searchableProps) { string a = (string)prop.GetValue(e, null); if (a != null && a.ToLower().Contains(keyword.Trim())) { bAtLeastOnePropertyContainsIt = true; break; } } if (!bAtLeastOnePropertyContainsIt) { bAllKeywordsFound = false; break; } } if (bAllKeywordsFound) { filteredResultSet.Add(e); } } //DID NOT WORK ALL THE TIMES: //resultset = resultset.Where(e => searchableProps.Any(prop => // arrFilterGeneral.All(keyword => // ((string)prop.GetValue(e, null) ?? "").ToString().ToLower() // .Contains(keyword)))); } else { filteredResultSet = new HashSet <Entity>(resultset); } #endregion filterResponse.total_filtered_items = filteredResultSet.Count(); #region Pagination IEnumerable <Entity> afterPaginate; if (perPage != 0) { afterPaginate = filteredResultSet.Skip((page - 1) * perPage).Take(perPage); } else { afterPaginate = filteredResultSet; } #endregion if (!PopulateForSearchEqualsAdapterOut) { AdapterOut(afterPaginate.ToArray()); } return(response.Success(afterPaginate, filterResponse)); } catch (Exception e) { var originalException = GetOriginalException(e); return(response.Error("Error " + originalException.Message)); } }
public virtual CommonResponse GetPage(int perPage, int page, string filterGeneral, Expression <Func <Entity, bool> >[] wheres, Expression <Func <Entity, object> > orderby, params Expression <Func <Entity, bool> >[] database_wheres) { CommonResponse response = new CommonResponse(); FilterResponse filterResponse = new FilterResponse(); IEnumerable <Entity> entities; //Entities comming from DB IQueryable <Entity> resultset; //To filter properties not in DB try { repository.byUserId = loggedUser.UserID; var database_wheresList = database_wheres.ToList(); addDbWheresWhenPaging(database_wheresList); #region Apply Database Filtering entities = repository.GetList(orderby, database_wheresList.ToArray()); loadNavigationProperties(entities.ToArray()); #endregion #region Apply Roles Filtering #endregion #region Applying Non-Database Properties Filtering resultset = entities.AsQueryable(); foreach (var where in wheres) { resultset = resultset.Where(where); } #endregion resultset = applyOrderByWhenPaging(resultset); filterResponse.total_items = resultset.Count(); #region Apply General Search Filter HashSet <Entity> filteredResultSet = new HashSet <Entity>(); if (!string.IsNullOrWhiteSpace(filterGeneral)) { string[] arrFilterGeneral = filterGeneral.ToLower().Split(' '); var searchableProps = typeof(Entity).GetProperties().Where(prop => new[] { "String" }.Contains(prop.PropertyType.Name)); foreach (var e in resultset) { bool bAllKeywordsFound = true; foreach (var keyword in arrFilterGeneral) { bool bAtLeastOnePropertyContainsIt = false; foreach (var prop in searchableProps) { string a = (string)prop.GetValue(e, null); if (a != null && a.ToLower().Contains(keyword.Trim())) { bAtLeastOnePropertyContainsIt = true; break; } } if (!bAtLeastOnePropertyContainsIt) { bAllKeywordsFound = false; break; } } if (bAllKeywordsFound) { filteredResultSet.Add(e); } } //DID NOT WORK ALL THE TIMES: //resultset = resultset.Where(e => searchableProps.Any(prop => // arrFilterGeneral.All(keyword => // ((string)prop.GetValue(e, null) ?? "").ToString().ToLower() // .Contains(keyword)))); } else { filteredResultSet = new HashSet <Entity>(resultset); } #endregion filterResponse.total_filtered_items = filteredResultSet.Count(); #region Pagination List <Entity> afterPaginate = filteredResultSet.ToList(); if (perPage != 0) { afterPaginate = filteredResultSet.Skip((page - 1) * perPage).Take(perPage).ToList(); } #endregion return(response.Success(afterPaginate, filterResponse)); } catch (Exception e) { return(response.Error("ERROR: " + e.ToString())); } }
virtual public async Task <CommonResponse> GetPagedAsync(int perPage = 0, int page = 1, string generalFilter = "", SqlExpression <Entity> query = null, string cachePrefix = null, bool requiresKeysInJsons = false) { if (string.IsNullOrWhiteSpace(cachePrefix)) { cachePrefix = CACHE_GET_PAGED; } cachePrefix += $"_{perPage}_{page}_{generalFilter}"; if (requiresKeysInJsons) { cachePrefix += "_requiresKeysInJsons"; } var cacheContainer = Cache.Get <Dictionary <string, CommonResponse> >(CACHE_CONTAINER_GET_PAGED); if (cacheContainer == null) { cacheContainer = new Dictionary <string, CommonResponse>(); } var paramsNotFoundAsProps = new Dictionary <string, string>(); //var cacheFromContainer = false; if (query == null) { query = Db.From <Entity>(); } // query = Db.From<Entity>(); //else // cacheFromContainer = true; #region Apply Database Filtering foreach (var queryParam in Request.QueryString.AllKeys) { string queryParamValue = Request.QueryString[queryParam]; if (IsValidParam(queryParam) && IsValidJSValue(queryParamValue)) { cachePrefix += $"_{queryParam}_{queryParamValue}"; string sPropertyName = queryParam; PropertyInfo oProp = typeof(Entity).GetProperty(sPropertyName); if (oProp == null) { paramsNotFoundAsProps.Add(queryParam, queryParamValue); continue; //Ignore non-existing properties, they could be just different query parameters. } Type tProp = oProp.PropertyType; //Nullable properties have to be treated differently, since we // use their underlying property to set the value in the object if (tProp.IsGenericType && tProp.GetGenericTypeDefinition().Equals(typeof(Nullable <>))) { //Get the underlying type property instead of the nullable generic tProp = new NullableConverter(oProp.PropertyType).UnderlyingType; } ParameterExpression entityParameter = Expression.Parameter(typeof(Entity), "entityParameter"); Expression childProperty = Expression.PropertyOrField(entityParameter, sPropertyName); var value = Expression.Constant(Convert.ChangeType(queryParamValue, tProp)); //if (cacheFromContainer) //{ if (tProp == typeof(string)) { query.Where($"{query.SqlColumn(sPropertyName)} like '%{value.Value}%'"); } else { query.Where($"{query.SqlColumn(sPropertyName)} = {value.Value}"); } //} //else //Cache From Memory //{ // // let's perform the conversion only if we really need it // var converted = value.Type != childProperty.Type // ? Expression.Convert(value, childProperty.Type) // : (Expression)value; // Expression<Func<Entity, bool>> lambda; // if (tProp == typeof(String)) // { // MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) }); // lambda = Expression.Lambda<Func<Entity, bool>>(Expression.Call(converted, method, childProperty), entityParameter); // } // else // { // Expression comparison = Expression.Equal(childProperty, converted); // lambda = Expression.Lambda<Func<Entity, bool>>(comparison, entityParameter); // } // allEntities = allEntities.Where(lambda); //} } } #endregion #region From Container Cache //if (cacheFromContainer) //{ cacheContainer.TryGetValue(cachePrefix, out CommonResponse cache); if (cache != null) { var cacheList = cache.Result as IEnumerable <Entity>; AdapterOut(cacheList.ToArray()); return(cache); } //} #endregion query = OnGetList(query); var entities = await Db.LoadSelectAsync(query); //var entities = await GetAllAsync(); var filterResponse = new FilterResponse { total_items = entities.Count() }; #region Apply General Search Filter var usingBeforeSearch = BeforeSearch(entities); var filtered = new HashSet <Entity>(); if (!string.IsNullOrEmpty(generalFilter) || (paramsNotFoundAsProps.Count > 0)) { var searchableProps = typeof(Entity).GetProperties().Where(prop => !prop.HasAttribute <IsJson>() && new[] { "String" }.Contains(prop.PropertyType.Name)).ToList(); var jsonProps = typeof(Entity).GetPublicProperties().Where(p => p.HasAttribute <IsJson>()).ToList(); foreach (var entity in entities) { if (SearchInStringProps(entity, generalFilter) && SearchInJsonProps(entity, paramsNotFoundAsProps, requiresKeysInJsons, jsonProps)) { filtered.Add(entity); } } } else { filtered = new HashSet <Entity>(entities); } filterResponse.total_filtered_items = filtered.Count(); #endregion #region Pagination IEnumerable <Entity> afterPaginate; if (perPage != 0) { var totalPagesCount = (filterResponse.total_filtered_items + perPage - 1) / perPage; if (page > totalPagesCount) { page = totalPagesCount; } afterPaginate = BeforePaginate(filtered.ToList()).Skip((page - 1) * perPage).Take(perPage); filterResponse.page = page; } else { afterPaginate = BeforePaginate(filtered.ToList()); } #endregion #region AdapterOut Hook if (!usingBeforeSearch) { AdapterOut(afterPaginate.ToArray()); } #endregion var response = new CommonResponse { Result = afterPaginate, AdditionalData = filterResponse }; //if (cacheFromContainer) //{ cacheContainer[cachePrefix] = response; Cache.Replace(CACHE_CONTAINER_GET_PAGED, cacheContainer); //} return(response); }
static void Main(string[] args) { Console.WriteLine("Please enter a bunch of digits separated by a coma: "); Console.WriteLine("Input should in format 9,3,6,4,12 ..........and so on...: "); var str = Console.ReadLine(); Console.WriteLine("================================ "); Console.WriteLine($"original String == { str}"); IFilterService stringService = new FilterService(); AppSettings appSettings = new AppSettings(); FilterResponse strResponse = new FilterResponse(str); // Filter Prime Numbers if (appSettings.ProcessFilterPrimeNumbers) { try { strResponse = stringService.ProcessFilter(strResponse); if (strResponse.Error.HasValue) { Console.WriteLine($"After filtering the prime numbers == { strResponse.Error.ToString()}"); } if (!string.IsNullOrEmpty(strResponse.InputString)) { Console.WriteLine($"After filtering the prime numbers == { strResponse.InputString}"); } } catch (Exception ex) { Console.WriteLine($"Exceoption Occurred == { ex.InnerException.Message}"); Console.ReadLine(); } } //Apply sort if (appSettings.ProcessSortDescending) { try { strResponse = stringService.ProcessSort(strResponse); if (strResponse.Error.HasValue) { Console.WriteLine($"After sorting in Descending order == { strResponse.Error.ToString()}"); } if (!string.IsNullOrEmpty(strResponse.InputString)) { Console.WriteLine($"After sorting in Descending order == { strResponse.InputString}"); } } catch (Exception ex) { Console.WriteLine($"Exceoption Occurred == { ex.InnerException.Message}"); Console.ReadLine(); } } Console.ReadLine(); }
virtual public async Task <CommonResponse> GetPagedAsync(int perPage, int page, string filterGeneral, SqlExpression <Entity> query = null, string cacheKey = null) { var cacheContainer = Cache.Get <Dictionary <string, CommonResponse> >(CACHE_CONTAINER_GET_PAGED); if (cacheContainer == null) { cacheContainer = new Dictionary <string, CommonResponse>(); } if (string.IsNullOrWhiteSpace(cacheKey)) { cacheKey = CACHE_GET_PAGED; } cacheKey += $"_{ perPage}_{page}_{filterGeneral}"; if (query == null) { query = Db.From <Entity>(); } var filterResponse = new FilterResponse(); #region Filter by User //if (request.FilterUser.HasValue && typeof(Entity).IsSubclassOf(typeof(BaseDocument))) //{ // query.LeftJoin<Track>() // .LeftJoin<Track, User>((t, u) => t.User_AssignedToKey == u.Id) // .Where<User>(u => u.Id == request.FilterUser); //} #endregion #region Apply Database Filtering foreach (var queryParam in Request.QueryString.AllKeys) { string queryParamValue = Request.QueryString[queryParam]; if (IsValidParam(queryParam) && IsValidJSValue(queryParamValue)) { cacheKey += $"_{queryParam}_{queryParamValue}"; string sPropertyName = queryParam; PropertyInfo oProp = typeof(Entity).GetProperty(sPropertyName); if (oProp == null) { continue; //Ignore non-existing properties, they could be just different query parameters. } Type tProp = oProp.PropertyType; //Nullable properties have to be treated differently, since we // use their underlying property to set the value in the object if (tProp.IsGenericType && tProp.GetGenericTypeDefinition().Equals(typeof(Nullable <>))) { //Get the underlying type property instead of the nullable generic tProp = new NullableConverter(oProp.PropertyType).UnderlyingType; } ParameterExpression entityParameter = Expression.Parameter(typeof(Entity), "entityParameter"); Expression childProperty = Expression.PropertyOrField(entityParameter, sPropertyName); var value = Expression.Constant(Convert.ChangeType(queryParamValue, tProp)); if (tProp == typeof(string)) { query.Where($"{query.SqlColumn(sPropertyName)} like '%{value.Value}%'"); } else { query.Where($"{query.SqlColumn(sPropertyName)} = {value.Value}"); } } } #endregion #region From Cache cacheContainer.TryGetValue(cacheKey, out CommonResponse cache); if (cache != null) { var cacheList = cache.Result as IEnumerable <Entity>; AdapterOut(cacheList.ToArray()); return(cache); } #endregion #region OnGetList Hook query = OnGetList(query); #endregion #region Non-Database Parameters Filters #endregion var entities = (await Db.LoadSelectAsync(query)).ToArray(); filterResponse.total_items = entities.Count(); #region Apply General Search Filter bool PopulateForSearchEqualsAdapterOut = false; PopulateForSearchEqualsAdapterOut = PopulateForSearch(entities); HashSet <Entity> filteredResultSet = new HashSet <Entity>(); if (!string.IsNullOrWhiteSpace(filterGeneral)) { string[] arrFilterGeneral = filterGeneral.ToLower().Split(' '); var searchableProps = typeof(Entity).GetProperties().Where(prop => new[] { "String" }.Contains(prop.PropertyType.Name)); foreach (var e in entities) { bool bAllKeywordsFound = true; foreach (var keyword in arrFilterGeneral) { bool bAtLeastOnePropertyContainsIt = false; foreach (var prop in searchableProps) { string a = (string)prop.GetValue(e, null); if (a != null && a.ToLower().Contains(keyword.Trim())) { bAtLeastOnePropertyContainsIt = true; break; } } if (!bAtLeastOnePropertyContainsIt) { bAllKeywordsFound = false; break; } } if (bAllKeywordsFound) { filteredResultSet.Add(e); } } //DID NOT WORK SOMETIMES: //resultset = resultset.Where(e => searchableProps.Any(prop => // arrFilterGeneral.All(keyword => // ((string)prop.GetValue(e, null) ?? "").ToString().ToLower() // .Contains(keyword)))); } else { filteredResultSet = new HashSet <Entity>(entities); } filterResponse.total_filtered_items = filteredResultSet.Count(); #endregion #region Pagination IEnumerable <Entity> afterPaginate; if (perPage != 0) { afterPaginate = BeforePaginate(filteredResultSet.ToList()).Skip((page - 1) * perPage).Take(perPage); } else { afterPaginate = BeforePaginate(filteredResultSet.ToList()); } #endregion #region AdapterOut Hook if (!PopulateForSearchEqualsAdapterOut) { AdapterOut(afterPaginate.ToArray()); } #endregion var response = new CommonResponse { Result = afterPaginate.ToList(), AdditionalData = filterResponse }; cacheContainer[cacheKey] = response; Cache.Replace(CACHE_CONTAINER_GET_PAGED, cacheContainer); return(response); }