private Tuple <string, TDbParameter> GenerateBasicCondition(IFilterTerm term) { var fieldName = GetColumnName(term.PropertyName); var clause = fieldName + " "; var paramName = GetParameterName(); switch (term.Operator) { case FilterOperators.Equal when term.Value == null: clause += "IS NULL"; break; case FilterOperators.NotEqual when term.Value == null: clause += "IS NOT NULL"; break; case FilterOperators.Equal: clause += $"= {paramName}"; break; case FilterOperators.NotEqual: clause += $"!= {paramName}"; break; case FilterOperators.LessThan: clause += $"< {paramName}"; break; case FilterOperators.LessThanOrEqual: clause += $"<= {paramName}"; break; case FilterOperators.GreaterThan: clause += $"> {paramName}"; break; case FilterOperators.GreaterThanOrEqual: clause += $">= {paramName}"; break; case FilterOperators.StartsWith: clause += $"LIKE {paramName} + '%'"; break; case FilterOperators.EndsWith: clause += $"LIKE '%' + {paramName}"; break; case FilterOperators.Contains: clause += $"LIKE '%' + {paramName} + '%'"; break; } return(term.Value == null ? new Tuple <string, TDbParameter>(clause, default(TDbParameter)) : new Tuple <string, TDbParameter>(clause, GetDbParameter(paramName, term.Value))); }
public IAttributeDefinition Filter(IFilterTerm filter) { if (AttributeType == AttributeType.Relation) { return(metaModel.GetAttributeDefinition(Token + "[" + filter.ShortToken + "]")); } throw new MetaException("Cannot filter non-relation attributes"); }
private FilterTerm ConvertToTypedTerm(IFilterTerm term) { var member = GetTypeMember(term.PropertyName); EnsureValidOperator(term.Operator, member.Type); var value = StringConverter.FromString((string)term.Value, member.Type); return(new FilterTerm(member.Name, term.Operator, value)); }
private AssetList GetStoryAssets(IFilterTerm filter) { var query = new Query(storyType) { Filter = filter }; query.Selection.AddRange(attributesToQuery); return(services.Retrieve(query).Assets); }
public AssetList Query(string workitemTypeName, IFilterTerm filter) { try { var workitemType = metaModel.GetAssetType(workitemTypeName); var query = new Query(workitemType) { Filter = filter}; AddSelection(query, workitemTypeName, workitemType); return services.Retrieve(query).Assets; } catch (Exception ex) { throw new VersionOneException(ex.Message); } }
private AssetList GetFieldList(IFilterTerm filter, IEnumerable <IAttributeDefinition> selection) { var attributeDefinitionAssetType = services.Meta.GetAssetType("AttributeDefinition"); var query = new Query(attributeDefinitionAssetType); foreach (var attribute in selection) { query.Selection.Add(attribute); } query.Filter = filter; return(services.Retrieve(query).Assets); }
public AssetList Query(string workitemTypeName, IFilterTerm filter) { try { var workitemType = metaModel.GetAssetType(workitemTypeName); var query = new Query(workitemType) { Filter = filter}; if(sortBy != null) { var order = sortBy.Order == Order.Ascending ? OrderBy.Order.Ascending : OrderBy.Order.Descending; query.OrderBy.MajorSort(workitemType.GetAttributeDefinition(sortBy.Attribute), order); } AddSelection(query, workitemTypeName, workitemType); return services.Retrieve(query).Assets; } catch (Exception ex) { throw new VersionOneException(ex.Message); } }
private QueryResult FindExistingChangeset(int revision) { var q = new Query(ChangeSetType); q.Selection.Add(ChangeSetType.GetAttributeDefinition("Reference")); q.Selection.Add(ChangeSetType.GetAttributeDefinition("Links.URL")); var referenceTerm = new FilterTerm(ChangeSetType.GetAttributeDefinition("Reference")); referenceTerm.Equal(revision); IFilterTerm term = referenceTerm; q.Filter = term; q.Paging = new Paging(0, 1); return(V1Connection.Data.Retrieve(q)); }
private Tuple <string, IList <TDbParameter> > GenerateCondition(IFilterTerm term) { switch (term.Operator) { case FilterOperators.Range: return(GenerateBetweenCondition((RangeFilterTerm)term)); case FilterOperators.In: return(GenerateInCondition((InFilterTerm)term)); default: var condition = GenerateBasicCondition(term); var parameters = new List <TDbParameter>(); if (condition.Item2 != null) { parameters.Add(condition.Item2); } return(new Tuple <string, IList <TDbParameter> >(condition.Item1, parameters)); } }
private static Expression GetExpression(IFilterTerm filterTerm, dynamic filterValue, dynamic propertyValue) { switch (filterTerm.OperatorParsed) { case FilterOperator.Equals: return(Expression.Equal(propertyValue, filterValue)); case FilterOperator.NotEquals: return(Expression.NotEqual(propertyValue, filterValue)); case FilterOperator.GreaterThan: return(Expression.GreaterThan(propertyValue, filterValue)); case FilterOperator.LessThan: return(Expression.LessThan(propertyValue, filterValue)); case FilterOperator.GreaterThanOrEqualTo: return(Expression.GreaterThanOrEqual(propertyValue, filterValue)); case FilterOperator.LessThanOrEqualTo: return(Expression.LessThanOrEqual(propertyValue, filterValue)); case FilterOperator.Contains: return(Expression.Call(propertyValue, typeof(string).GetMethods() .First(m => m.Name == "Contains" && m.GetParameters().Length == 1), filterValue)); case FilterOperator.StartsWith: return(Expression.Call(propertyValue, typeof(string).GetMethods() .First(m => m.Name == "StartsWith" && m.GetParameters().Length == 1), filterValue)); default: return(Expression.Equal(propertyValue, filterValue)); } }
/// <inheritdoc /> public IFilter <U> Convert <U>(Func <string, string> propertyNameConverter) { var convertedTerms = new List <IFilterTerm>(); foreach (var term in Terms) { IFilterTerm convertedTerm = null; var convertedField = propertyNameConverter(term.PropertyName); if (string.IsNullOrWhiteSpace(convertedField)) { throw new InvalidOperationException( $"No mapping from '{term.PropertyName}' on '{typeof(T)}' to '{typeof(U)}'"); } switch (term.Operator) { case FilterOperators.In: var inTerm = (InFilterTerm)term; convertedTerm = new InFilterTerm(convertedField, inTerm.Value); break; case FilterOperators.Range: var rangeTerm = (RangeFilterTerm)term; convertedTerm = new RangeFilterTerm(convertedField, rangeTerm.From, rangeTerm.To); break; default: convertedTerm = new FilterTerm(convertedField, term.Operator, term.Value); break; } convertedTerms.Add(convertedTerm); } return(new Filter <U>(convertedTerms)); }
public AssetList Query(string workitemTypeName, IFilterTerm filter) { try { var workitemType = services.Meta.GetAssetType(workitemTypeName); var query = new Query(workitemType) { Filter = filter }; if (sortBy != null) { var order = sortBy.Order == Order.Ascending ? OrderBy.Order.Ascending : OrderBy.Order.Descending; query.OrderBy.MajorSort(workitemType.GetAttributeDefinition(sortBy.Attribute), order); } AddSelection(query, workitemTypeName, workitemType); return(services.Retrieve(query).Assets); } catch (Exception ex) { throw new VersionOneException(ex.Message); } }
private AssetList GetFieldList(IFilterTerm filter, IEnumerable<IAttributeDefinition> selection) { var attributeDefinitionAssetType = services.Meta.GetAssetType("AttributeDefinition"); var query = new Query(attributeDefinitionAssetType); foreach(var attribute in selection) { query.Selection.Add(attribute); } query.Filter = filter; return services.Retrieve(query).Assets; }
public IAttributeDefinition Filter(IFilterTerm filter) { if (AttributeType == AttributeType.Relation) { return metaModel.GetAttributeDefinition(Token + "[" + filter.ShortToken + "]"); } throw new MetaException("Cannot filter non-relation attributes"); }
public IAttributeDefinition Filter(IFilterTerm filter) { return(null); }
public IAttributeDefinition Filter(IFilterTerm filter) { throw new System.NotImplementedException(); }
/// <summary> /// The Remove. /// </summary> /// <param name="item">The item<see cref="IFilterTerm"/>.</param> /// <returns>The <see cref="bool"/>.</returns> public bool Remove(IFilterTerm item) { return(Remove(new FilterTerm(item.RubricName, item.Operand, item.Value, item.Logic, item.Stage))); }
/// <summary> /// The Contains. /// </summary> /// <param name="item">The item<see cref="IFilterTerm"/>.</param> /// <returns>The <see cref="bool"/>.</returns> public bool Contains(IFilterTerm item) { return(Contains(new FilterTerm(item.RubricName, item.Operand, item.Value, item.Logic, item.Stage))); }
/// <summary> /// The Add. /// </summary> /// <param name="item">The item<see cref="IFilterTerm"/>.</param> public void Add(IFilterTerm item) { Add(new FilterTerm(item.RubricName, item.Operand, item.Value, item.Logic, item.Stage)); }
public IAttributeDefinition Filter(IFilterTerm filter) { return null; }
private AssetList GetAssetsByOid(Oid oid, IEnumerable<IAttributeDefinition> attributesToLoad, IFilterTerm filter = null, bool historicalQuery = false) { var query = new Query(oid, historicalQuery); query.Selection.AddRange(attributesToLoad); if(filter != null) { query.Filter = filter; } return services.Retrieve(query).Assets; }
private AssetList GetAssetsByOid(Oid oid, IEnumerable <IAttributeDefinition> attributesToLoad, IFilterTerm filter = null, bool historicalQuery = false) { var query = new Query(oid, historicalQuery); query.Selection.AddRange(attributesToLoad); if (filter != null) { query.Filter = filter; } return(services.Retrieve(query).Assets); }
private AssetList GetStoryAssets(IFilterTerm filter) { var query = new Query(storyType) {Filter = filter}; query.Selection.AddRange(attributesToQuery); return services.Retrieve(query).Assets; }