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;
}
