/// <summary> /// Gets a list of ranking illusts. /// </summary> /// <param name="mode">The ranking mode to use.</param> /// <param name="date">The date to get ranking illusts for.</param> /// <param name="filter">The filter to use.</param> /// <returns><seealso cref="IllustSearchResult"/> for ranking illusts.</returns> public async Task <IllustSearchResult> RankingIllustsAsync(RankingMode mode = RankingMode.Day, DateTime?date = null, FilterType?filter = null) { // Converts time to the correct timezone and produces a date string in correct format Stream response; DateTime dateValue = date ?? DateTime.Now.AddDays(-1); string dateString = dateValue.Year.ToString("0000") + "-" + dateValue.Month.ToString("00") + "-" + dateValue.Day.ToString("00"); Dictionary <string, string> parameters = new Dictionary <string, string>() { { "mode", mode.JsonValue() }, { "date", dateString } }; // Adds filter if required if ((filter ?? Filter) != FilterType.None) { parameters.Add("filter", filter.JsonValue() ?? Filter.JsonValue()); } FormUrlEncodedContent encodedParams = new FormUrlEncodedContent(parameters); response = await RequestClient.RequestAsync(PixivUrls.RankingIllusts, encodedParams) .ConfigureAwait(false); return(Json.DeserializeJson <IllustSearchResult>(response)); }
private static IEnumerable <QueryToken> AggregateTokens(QueryToken token, QueryDescription qd) { if (token == null) { yield return(new AggregateToken(AggregateFunction.Count, qd.QueryName)); } else if (!(token is AggregateToken)) { FilterType?ft = QueryUtils.TryGetFilterType(token.Type); if (ft == FilterType.Integer || ft == FilterType.Decimal || ft == FilterType.Boolean) { yield return(new AggregateToken(AggregateFunction.Average, token)); yield return(new AggregateToken(AggregateFunction.Sum, token)); yield return(new AggregateToken(AggregateFunction.Min, token)); yield return(new AggregateToken(AggregateFunction.Max, token)); } else if (ft == FilterType.DateTime) /*ft == FilterType.String || */ { yield return(new AggregateToken(AggregateFunction.Min, token)); yield return(new AggregateToken(AggregateFunction.Max, token)); } } }
internal ServiceBusRuleData(ResourceIdentifier id, string name, ResourceType resourceType, SystemData systemData, FilterAction action, FilterType?filterType, SqlFilter sqlFilter, CorrelationFilter correlationFilter) : base(id, name, resourceType, systemData) { Action = action; FilterType = filterType; SqlFilter = sqlFilter; CorrelationFilter = correlationFilter; }
protected override string PropertyValidation(PropertyInfo pi) { if (token != null && token.ParseException == null) { if (pi.Name == nameof(Token)) { return(QueryUtils.CanFilter(token.Token)); } if (pi.Name == nameof(Operation)) { FilterType?filterType = QueryUtils.TryGetFilterType(Token.Token.Type); if (filterType == null) { return(UserQueryMessage._0IsNotFilterable.NiceToString().FormatWith(token)); } if (!QueryUtils.GetFilterOperations(filterType.Value).Contains(Operation)) { return(UserQueryMessage.TheFilterOperation0isNotCompatibleWith1.NiceToString().FormatWith(Operation, filterType)); } } if (pi.Name == nameof(ValueString)) { return(FilterValueConverter.TryParse(ValueString, Token.Token.Type, out object val, Operation.IsList())); } } return(null); }
private string FilterTypeToString(FilterType?filterType) { if (filterType.HasValue && FilterTypeNameMapper.TryGetValue(filterType.Value, out var res)) { return(res); } throw new InvalidOperationException(); }
/// <summary> /// Initializes a new instance of the Rule class. /// </summary> /// <param name="id">Resource Id</param> /// <param name="name">Resource name</param> /// <param name="type">Resource type</param> /// <param name="action">Represents the filter actions which are /// allowed for the transformation of a message that have been matched /// by a filter expression.</param> /// <param name="filterType">Filter type that is evaluated against a /// BrokeredMessage. Possible values include: 'SqlFilter', /// 'CorrelationFilter'</param> /// <param name="sqlFilter">Properties of sqlFilter</param> /// <param name="correlationFilter">Properties of /// correlationFilter</param> public Rule(string id = default(string), string name = default(string), string type = default(string), Action action = default(Action), FilterType?filterType = default(FilterType?), SqlFilter sqlFilter = default(SqlFilter), CorrelationFilter correlationFilter = default(CorrelationFilter)) : base(id, name, type) { Action = action; FilterType = filterType; SqlFilter = sqlFilter; CorrelationFilter = correlationFilter; CustomInit(); }
/// <summary> /// Set filter type. /// </summary> /// <param name="filterType">Filter type.</param> public void FilterType(FilterType filterType) { if (_complexFilter != null) { throw new InvalidOperationException("Cannot specify filter type when complex filter expression is used."); } _filterType = filterType; }
private static IEnumerable <QueryToken> AggregateTokens(QueryToken token, QueryDescription qd) { if (token == null) { yield return(new AggregateToken(AggregateFunction.Count, qd.QueryName)); } else if (!(token is AggregateToken)) { FilterType?ft = QueryUtils.TryGetFilterType(token.Type); if (ft == FilterType.Integer || ft == FilterType.Decimal || ft == FilterType.Boolean) { yield return(new AggregateToken(AggregateFunction.Average, token)); yield return(new AggregateToken(AggregateFunction.Sum, token)); yield return(new AggregateToken(AggregateFunction.Min, token)); yield return(new AggregateToken(AggregateFunction.Max, token)); } else if (ft == FilterType.DateTime) /*ft == FilterType.String || */ { yield return(new AggregateToken(AggregateFunction.Min, token)); yield return(new AggregateToken(AggregateFunction.Max, token)); } if (ft != null) { yield return(new AggregateToken(AggregateFunction.Count, token, FilterOperation.DistinctTo, null)); yield return(new AggregateToken(AggregateFunction.Count, token, FilterOperation.EqualTo, null)); } if (token.IsGroupable) { yield return(new AggregateToken(AggregateFunction.Count, token, distinct: true)); } if (ft == FilterType.Enum) { foreach (var v in Enum.GetValues(token.Type.UnNullify())) { yield return(new AggregateToken(AggregateFunction.Count, token, FilterOperation.EqualTo, v)); yield return(new AggregateToken(AggregateFunction.Count, token, FilterOperation.DistinctTo, v)); } } if (ft == FilterType.Boolean) { yield return(new AggregateToken(AggregateFunction.Count, token, FilterOperation.EqualTo, true)); yield return(new AggregateToken(AggregateFunction.Count, token, FilterOperation.EqualTo, false)); } } }
public static FilterType GetFilterType(Type type) { FilterType?filterType = TryGetFilterType(type); if (filterType == null) { throw new NotSupportedException("Type {0} not supported".FormatWith(type)); } return(filterType.Value); }
private void ComboBoxType_SelectedIndexChanged(object sender, EventArgs e) { FilterType?type = (FilterType?)comboBoxType.SelectedItem; if (type == FilterType.Highlight) { UpdateColor(); } labelColor.Enabled = type == FilterType.Highlight; buttonColor.Enabled = type == FilterType.Highlight; }
public async Task <IActionResult> List([FromQuery] string keyword = null, [FromQuery] FilterType?filterType = FilterType.Student, [FromQuery] int pageNo = 1, [FromQuery] int pageSize = 10) { try { if (pageNo <= 0) { pageNo = 1; } if (pageSize > 50) { pageSize = 50; } else if (pageSize <= 0) { pageSize = 10; } keyword = keyword?.ToLower(); var skip = (pageNo - 1) * pageSize; var take = pageSize; var query = _DbContext.tbl_Marks.Where(x => (filterType == FilterType.Student && (string.IsNullOrWhiteSpace(keyword) || x.StudentID.ToString() == keyword || x.tbl_Student.FirstName.Contains(keyword) || x.tbl_Student.LastName.Contains(keyword))) || (filterType == FilterType.Class && x.tbl_Student.Class.ToString() == keyword) || (filterType == FilterType.Subject && x.tbl_Subject.Name.ToString() == keyword)); var newquery = query.Select(x => new { x.ID, x.StudentID, x.StudentMark, x.tbl_Student.Class, x.tbl_Student.FirstName, x.tbl_Student.LastName, x.tbl_Subject.Name }); var totalFilteredResultCount = await newquery.CountAsync(); if (skip > totalFilteredResultCount) { return(StatusCode(StatusCodes.Status400BadRequest, new ApiResponse { message = "invalid request", data = "no more file found." })); } var totalFilteredResult = await newquery.Skip(skip).Take(take).ToListAsync(); return(StatusCode(StatusCodes.Status200OK, new ApiResponse { success = true, message = "success", data = new { total = totalFilteredResultCount, pageNo = pageNo, pageSize = pageSize, records = totalFilteredResult } })); } catch (Exception ex) { return(StatusCode(StatusCodes.Status500InternalServerError, new ApiResponse { message = "unexpected error", data = ex.Message })); } }
public ColumnDescriptionTS(ColumnDescription a, object queryName) { var token = new ColumnToken(a, queryName); this.name = a.Name; this.type = new TypeReferenceTS(a.Type, a.Implementations); this.filterType = QueryUtils.TryGetFilterType(a.Type); this.typeColor = token.TypeColor; this.niceTypeName = token.NiceTypeName; this.isGroupable = token.IsGroupable; this.unit = a.Unit; this.format = a.Format; this.displayName = a.DisplayName; this.propertyRoute = token.GetPropertyRoute()?.ToString(); }
public ColumnDescriptionTS(ColumnDescription a, object queryName) { var token = new ColumnToken(a, queryName); this.name = a.Name; this.type = new TypeReferenceTS(a.Type, a.Implementations); this.filterType = QueryUtils.TryGetFilterType(a.Type); this.typeColor = token.TypeColor; this.niceTypeName = token.NiceTypeName; this.isGroupable = token.IsGroupable; this.hasOrderAdapter = QueryUtils.OrderAdapters.ContainsKey(token.Type); this.preferEquals = token.Type == typeof(string) && token.GetPropertyRoute() is PropertyRoute pr && typeof(Entity).IsAssignableFrom(pr.RootType) && Schema.Current.HasSomeIndex(pr); this.unit = a.Unit; this.format = a.Format; this.displayName = a.DisplayName; this.propertyRoute = token.GetPropertyRoute()?.ToString(); }
public static string GetUrl(string ext = null, bool fromEditor = false, FolderType?root = null, bool?thirdParty = null, FilterType?filterType = null, bool multiple = false, string successButton = null) { var args = new Dictionary <string, string>(); if (!string.IsNullOrEmpty(ext = (ext ?? "").Trim().ToLower())) { args.Add(FilterExtParam, ext); } if (fromEditor) { args.Add(FromEditorParam, "true"); } if (root.HasValue) { args.Add(RootParam, root.ToString()); } if (thirdParty.HasValue) { args.Add(ThirdPartyParam, thirdParty.Value.ToString().ToLower()); } if (filterType.HasValue) { args.Add(FileTypeParam, filterType.Value.ToString()); } if (multiple) { args.Add(MultiSelectParam, "true"); } if (!string.IsNullOrEmpty(successButton = (successButton ?? "").Trim())) { args.Add(SuccessButtonParam, successButton); } return(Location + "?" + string.Join("&", args.Select(arg => HttpUtility.HtmlEncode(arg.Key) + "=" + HttpUtility.HtmlEncode(arg.Value)))); }
public FilterParameters ( FilterType?type = null, float?frequency = null, float?oneOverQ = null ) : this() { if (type is not null) { Type = type.Value; } if (frequency is not null) { Frequency = frequency.Value; } if (oneOverQ is not null) { OneOverQ = oneOverQ.Value; } }
internal static string ToSerializedValue(this FilterType?value) { return(value == null ? null : ((FilterType)value).ToSerializedValue()); }
public ColumnDescriptionTS(ColumnDescription a, object queryName) { var token = new ColumnToken(a, queryName); this.name = a.Name; this.type = new TypeReferenceTS(a.Type, a.Implementations); this.filterType = QueryUtils.TryGetFilterType(a.Type); this.typeColor = token.TypeColor; this.niceTypeName = token.NiceTypeName; this.isGroupable = token.IsGroupable; this.unit = a.Unit; this.format = a.Format; this.displayName = a.DisplayName; this.propertyRoute = token.GetPropertyRoute()?.ToString(); }
public override IFilter Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { if (reader.TokenType != JsonTokenType.StartObject) { throw new JsonException(); } FilterType? filterType = null; bool and = false; string path = null; object value = null; List <IFilter> filters = null; while (reader.Read()) { if (reader.TokenType == JsonTokenType.EndObject) { break; } if (reader.TokenType != JsonTokenType.PropertyName) { continue; } var propertyName = reader.GetString().ToLower(); reader.Read(); switch (propertyName) { case "path": path = reader.GetString(); break; case "type": filterType = GetFilterType(ref reader); break; case "and": and = reader.GetBoolean(); break; case "value": value = GetValue(JsonSerializer.Deserialize <JsonElement>(ref reader, options)); break; case "filters": var elm = JsonSerializer.Deserialize <JsonElement>(ref reader, options); filters = JsonSerializer.Deserialize <List <IFilter> >(elm.GetRawText(), options); break; } } if (filterType == null) { throw new JsonException("filterType error"); } // ICompositeFilter if (filterType == FilterType.Composite) { var compositeFilter = GetService <ICompositeFilter>(); compositeFilter.And = and; compositeFilter.Type = filterType.Value; compositeFilter.Filters = filters; return(compositeFilter); } if (string.IsNullOrEmpty(path)) { throw new JsonException("path error"); } // ISimpleFilter var simpleFilter = GetService <ISimpleFilter>(); simpleFilter.And = and; simpleFilter.Type = filterType.Value; simpleFilter.Path = path; simpleFilter.Value = value; return(simpleFilter); }
private static Tuple <FilterType, FilterType?, SecondaryFilterCondition> GetFilterTypes(JsonElement element) { var filterType = FilterType.Unknown; FilterType?secondaryFilterType = null; var secondaryConfition = SecondaryFilterCondition.NotSet; var typeProperty = element.GetPropertyString(ReportLayoutDocument.Type); if (typeProperty == null) { return(Tuple.Create <FilterType, FilterType?, SecondaryFilterCondition> (filterType, secondaryFilterType, secondaryConfition)); } if (string.Compare(typeProperty, "Categorical", true) == 0) { filterType = FilterType.BasicCategorical; } else if (string.Compare(typeProperty, "TopN", true) == 0) { filterType = FilterType.TopN; } else if (string.Compare(typeProperty, "Advanced", true) == 0) { var whereArray = element.GetChild(ReportLayoutDocument.Filter) ?.GetChild(ReportLayoutDocument.FilterWhere); if (whereArray != null && whereArray.Value.ValueKind == JsonValueKind.Array) { var whereEnumerator = whereArray.Value.EnumerateArray(); whereEnumerator.MoveNext(); var conditionalAnd = whereEnumerator.Current .GetChild(ReportLayoutDocument.FilterCondition) ?.GetChild("And"); var conditionalOr = whereEnumerator.Current .GetChild(ReportLayoutDocument.FilterCondition) ?.GetChild("Or"); if (conditionalAnd.HasValue || conditionalOr.HasValue) { var conditionalElement = conditionalAnd ?? conditionalOr; //main var leftCondition = conditionalElement?.GetChild("Left"); if (leftCondition.HasValue) { filterType = ReadAdvancedFilterType(leftCondition.Value); } var rightCondition = conditionalElement?.GetChild("Right"); if (rightCondition.HasValue) { secondaryFilterType = ReadAdvancedFilterType(rightCondition.Value); } secondaryConfition = conditionalAnd.HasValue ? SecondaryFilterCondition.And : SecondaryFilterCondition.Or; } else { filterType = ReadAdvancedFilterType(whereEnumerator.Current); } } } return(Tuple.Create <FilterType, FilterType?, SecondaryFilterCondition> (filterType, secondaryFilterType, secondaryConfition)); }
public IEnumerable <SymbolByFilterMessage> GetSymbolsByFilter(FieldToSearch fieldToSearch, string searchString, FilterType?filterType, IEnumerable <int> filterValues, string requestId = null) { return(GetSymbolsByFilterAsync(fieldToSearch, searchString, filterType, filterValues, requestId) .SynchronouslyAwaitTaskResult()); }
public Task <IEnumerable <SymbolByFilterMessage> > GetSymbolsByFilterAsync(FieldToSearch fieldToSearch, string searchString, FilterType?filterType, IEnumerable <int> filterValues, string requestId = null) { var request = _symbolRequestFormatter.ReqSymbolsByFilter(fieldToSearch, searchString, filterType, filterValues, requestId); return(string.IsNullOrEmpty(requestId) ? GetMessagesAsync(request, _symbolMessageHandler.GetSymbolByFilterMessages) : GetMessagesAsync(request, _symbolMessageHandler.GetSymbolByFilterMessagesWithRequestId)); }
public string ReqSymbolsByFilter(FieldToSearch fieldToSearch, string searchString, FilterType?filterType, IEnumerable <int> filterValues, string requestId = null) { // SBF,[Field To Search],[Search String],[Filter Type],[Filter Value],[RequestID]<CR><LF> var fieldToSearchFormat = ((char)fieldToSearch).ToString(); var filterTypeFormat = filterType.HasValue ? ((char)filterType).ToString() : string.Empty; var filterValuesFormat = filterType.HasValue ? string.Join(" ", filterValues) : string.Empty; var request = $"SBF,{fieldToSearchFormat},{searchString},{filterTypeFormat},{filterValuesFormat},{requestId}{IQFeedDefault.ProtocolTerminatingCharacters}"; return(request); }