private static Expression ParaseBetween(ParameterExpression parameter, FilterNode conditions)
{
ParameterExpression p = parameter;
Expression key = Expression.Property(p, conditions.key);
var valueArr = conditions.value.ToString().Split(',');
if (valueArr.Length != 2)
{
throw new NotImplementedException("ParaseBetween参数错误");
}
try
{
int.Parse(valueArr[0]);
int.Parse(valueArr[1]);
}
catch
{
throw new NotImplementedException("ParaseBetween参数只能为数字");
}
Expression expression = Expression.Constant(true, typeof(bool));
//开始位置
Expression startvalue = Expression.Constant(int.Parse(valueArr[0]));
Expression start = Expression.GreaterThanOrEqual(key, Expression.Convert(startvalue, key.Type));
Expression endvalue = Expression.Constant(int.Parse(valueArr[1]));
Expression end = Expression.GreaterThanOrEqual(key, Expression.Convert(endvalue, key.Type));
return(Expression.AndAlso(start, end));
}
/// <summary>
/// Add a general binder.
/// </summary>
/// <param name="binder"></param>
/// <returns></returns>
public FluentBinder Bind(IBindingProvider binder)
{
if (this._hook != null)
{
var fluidBinder = (FluentBindingProvider <TAttribute>)binder;
fluidBinder.BuildParameterDescriptor = _hook;
_hook = null;
}
// Apply filters
if (this._filterDescription.Count > 0)
{
binder = new FilteringBindingProvider <TAttribute>(
_configuration,
this._nameResolver,
binder,
FilterNode.And(this._filterDescription));
this._filterDescription.Clear();
}
var opts = new FluentBinder(_configuration, _nameResolver, binder);
_binders.Add(opts);
return(opts);
}
public void ParseOrQuoted()
{
var node = FilterNode.Parse("LastName = 'Smi*' OR FirstName = 'J*'");
Assert.IsNotNull(node);
Assert.IsNull(node.Evaluated);
Assert.IsNotNull(node.Left);
Assert.IsNull(node.Left.Evaluated);
Assert.IsNull(node.Left.Left);
Assert.IsNull(node.Left.Right);
Assert.AreEqual(LogicalOperator.None, node.Left.Operator);
Assert.IsNotNull(node.Left.Term);
Assert.AreEqual(RelationalOperator.Equal, node.Left.Term.Operator);
Assert.AreEqual("LastName", node.Left.Term.PropertyName);
Assert.AreEqual("Smi*", node.Left.Term.Value);
Assert.IsNotNull(node.Right);
Assert.IsNull(node.Right.Evaluated);
Assert.IsNull(node.Right.Left);
Assert.IsNull(node.Right.Right);
Assert.AreEqual(LogicalOperator.None, node.Right.Operator);
Assert.IsNotNull(node.Right.Term);
Assert.AreEqual(RelationalOperator.Equal, node.Right.Term.Operator);
Assert.AreEqual("FirstName", node.Right.Term.PropertyName);
Assert.AreEqual("J*", node.Right.Term.Value);
Assert.AreEqual(LogicalOperator.Or, node.Operator);
Assert.IsNull(node.Term);
}
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError)
{
var count = context.Path.Count();
if (value != null && (count == 0 || (count == 2 && context.Path.Last() == InvariantPartitioning.Key)))
{
FilterNode <ClrValue>?filter = null;
if (value is string s)
{
filter = ClrFilter.Eq(Path(context), s);
}
else if (value is double d)
{
filter = ClrFilter.Eq(Path(context), d);
}
if (filter != null)
{
var found = await checkUniqueness(filter);
if (found.Any(x => x.Id != context.ContentId))
{
addError(context.Path, T.Get("contents.validation.unique"));
}
}
}
}
public static ValueTask <FilterNode <ClrValue>?> TransformAsync(FilterNode <ClrValue> nodeIn, DomainId appId, ITagService tagService)
{
Guard.NotNull(nodeIn, nameof(nodeIn));
Guard.NotNull(tagService, nameof(tagService));
return(nodeIn.Accept(new FilterTagTransformer(appId, tagService)));
}
/// <summary>
/// create the subcategories for each unique propellant combination found
/// </summary>
private void GenerateEngineTypes()
{
var engines = new List <SubCategoryItem>();
foreach (List <string> ls in propellantCombos)
{
string propList = string.Join(",", ls.ToArray());
string name = propList;
string icon = propList;
SetName(ref name);
if (!string.IsNullOrEmpty(name) && !subCategoriesDict.ContainsKey(name))
{
var checks = new List <ConfigNode>()
{
CheckNodeFactory.MakeCheckNode(CheckPropellant.ID, propList, exact: true)
};
var filters = new List <ConfigNode>()
{
FilterNode.MakeFilterNode(false, checks)
};
var sC = new SubcategoryNode(SubcategoryNode.MakeSubcategoryNode(name, icon, false, filters), this);
subCategoriesDict.Add(name, sC);
}
}
}
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError)
{
if (context.Mode == ValidationMode.Optimized)
{
return;
}
var count = context.Path.Count();
if (value != null && (count == 0 || (count == 2 && context.Path.Last() == InvariantPartitioning.Key)))
{
FilterNode <ClrValue>?filter = null;
if (value is string s)
{
filter = ClrFilter.Eq(Path(context), s);
}
else if (value is double d)
{
filter = ClrFilter.Eq(Path(context), d);
}
if (filter != null)
{
var found = await checkUniqueness(filter);
if (found.Any(x => x.Id != context.ContentId))
{
addError(context.Path, "Another content with the same value exists.");
}
}
}
}
public static FilterNode Transform(FilterNode nodeIn, Guid appId, ISchemaEntity schema, ITagService tagService)
{
Guard.NotNull(tagService, nameof(tagService));
Guard.NotNull(schema, nameof(schema));
return(nodeIn.Accept(new FilterTagTransformer(appId, schema, tagService)));
}
/// <summary>
/// Determines if the specified path is included by the filter.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>True if the specified path is included by the filter.</returns>
public bool IsPathIncluded(string path)
{
PropertyPath propertyPath = PropertyPath.TryParse(path, null);
if (propertyPath == null || propertyPath.IsExcluded)
{
return(false);
}
FilterNode node = m_rootNode;
foreach (string part in propertyPath.Parts)
{
FilterNode childNode = node.FindChild(part);
if (!ShouldIncludeProperty(node, childNode))
{
return(false);
}
if (childNode == null)
{
break;
}
node = childNode;
}
return(true);
}
public async Task ValidateAsync(object value, ValidationContext context, AddError addError)
{
var count = context.Path.Count();
if (value != null && (count == 0 || (count == 2 && context.Path.Last() == InvariantPartitioning.Key)))
{
FilterNode <ClrValue> filter = null;
if (value is string s)
{
filter = ClrFilter.Eq(Path(context), s);
}
else if (value is double d)
{
filter = ClrFilter.Eq(Path(context), d);
}
if (filter != null)
{
var found = await context.GetContentIdsAsync(context.SchemaId, filter);
if (found.Any(x => x != context.ContentId))
{
addError(context.Path, "Another content with the same value exists.");
}
}
}
}
public async Task <IActionResult> FilterRecords(string model, int pageNo, [FromBody] FilterNode filter, int pageSize = Globals.AdminDefaultPageCount, string orderBy = null)
{
try
{
ICoreAdminService coreAdminService = new CoreAdminService(Area, _serviceProvider);
var modelType = coreAdminService.GetModelType(model);
if (modelType == null)
{
return(BadRequest($"Model {model} is not found"));
}
var result = await coreAdminService.GetAllFor(modelType, pageNo, pageSize, orderBy, filter); //_adminRepository.GetAllFor(model, pageNo, pageSize, orderBy);
if (result != null)
{
return(Ok(result));
}
return(NotFound());
}
catch (Exception ex)
{
_logger.LogError($"Error occured while getting all records for model: {model}", ex);
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
public async Task ValidateAsync(object value, ValidationContext context, AddError addError)
{
var count = context.Path.Count();
if (value != null && (count == 0 || (count == 2 && context.Path.Last() == InvariantPartitioning.Instance.Master.Key)))
{
FilterNode filter = null;
if (value is string s)
{
filter = new FilterComparison(Path(context), FilterOperator.Equals, new FilterValue(s));
}
else if (value is double d)
{
filter = new FilterComparison(Path(context), FilterOperator.Equals, new FilterValue(d));
}
if (filter != null)
{
var found = await context.GetContentIdsAsync(context.SchemaId, filter);
if (found.Any(x => x != context.ContentId))
{
addError(context.Path, "Another content with the same value exists.");
}
}
}
}
protected QueryBase VisitFilter(FilterNode node, ElasticQueryMapperState state)
{
// TODO: Both Solr and Lucene creates a new state from the ExecutionContexts - not sure why
// var state2 = new LuceneQueryMapperState((IEnumerable<IExecutionContext>) state.ExecutionContexts);
return(Visit(node.PredicateNode, state));
}
public List <FilterNode> BuildFiltersTree()
{
var filters = new List <FilterNode>();
var type = typeof(IOnlineFilter);
var types = _nwaves.GetTypes()
.Where(p => type.IsAssignableFrom(p) && p != type);
foreach (var tp in types)
{
// at the first level add only "direct implementers" of IOnlineFilter:
if (tp.BaseType.Name != "Object")
{
continue;
}
var newNode = new FilterNode
{
FilterType = tp
};
filters.Add(newNode);
AddFilterNodes(tp, ref newNode);
}
return(filters);
}
public static FilterNode <ClrValue> Transform(FilterNode <ClrValue> nodeIn, Guid appId, ITagService tagService)
{
Guard.NotNull(nodeIn, nameof(nodeIn));
Guard.NotNull(tagService, nameof(tagService));
return(nodeIn.Accept(new FilterTagTransformer(appId, tagService)));
}
public void ParseOr()
{
var node = FilterNode.Parse("name = value Or orders > 50");
Assert.IsNotNull(node);
Assert.IsNull(node.Evaluated);
Assert.IsNotNull(node.Left);
Assert.IsNull(node.Left.Evaluated);
Assert.IsNull(node.Left.Left);
Assert.IsNull(node.Left.Right);
Assert.AreEqual(LogicalOperator.None, node.Left.Operator);
Assert.IsNotNull(node.Left.Term);
Assert.AreEqual(RelationalOperator.Equal, node.Left.Term.Operator);
Assert.AreEqual("name", node.Left.Term.PropertyName);
Assert.AreEqual("value", node.Left.Term.Value);
Assert.IsNotNull(node.Right);
Assert.IsNull(node.Right.Evaluated);
Assert.IsNull(node.Right.Left);
Assert.IsNull(node.Right.Right);
Assert.AreEqual(LogicalOperator.None, node.Right.Operator);
Assert.IsNotNull(node.Right.Term);
Assert.AreEqual(RelationalOperator.Greater, node.Right.Term.Operator);
Assert.AreEqual("orders", node.Right.Term.PropertyName);
Assert.AreEqual("50", node.Right.Term.Value);
Assert.AreEqual(LogicalOperator.Or, node.Operator);
Assert.IsNull(node.Term);
}
public XDocument SaveToXml()
{
XDocument document = new XDocument();
XElement rootElement;
switch (this.ModelType)
{
case YamsterModelType.Message:
rootElement = new XElement("YamsterMessageQuery");
break;
case YamsterModelType.Thread:
rootElement = new XElement("YamsterThreadQuery");
break;
default:
throw new NotSupportedException();
}
document.Add(rootElement);
rootElement.Add(new XAttribute("Title", this.Title));
XElement filterNodeElement = null;
if (FilterNode != null)
{
filterNodeElement = FilterNode.SaveToXml();
}
rootElement.Add(new XElement("FilterNode", filterNodeElement));
return(document);
}
public static FilterNode Filter(ODataNode expr)
{
var result = new FilterNode(new Token(TokenType.QueryName, "$filter"));
result.Children.Add(expr);
return(result);
}
public override void WritePropertyName(string name)
{
m_reentrancy++;
base.WritePropertyName(name);
m_reentrancy--;
if (m_reentrancy == 0)
{
// pop the previous property off the stack if we aren't the first one
if (m_statusStack.Peek().IsProperty)
{
m_statusStack.Pop();
}
// check to see if this property has been included, or an ancestor or a descendant
Status status = m_statusStack.Peek();
FilterNode node = status.Node;
FilterNode childNode = node == null ? null : node.FindChild(name);
bool isIncluded = status.IsIncluded && (node == null || ShouldIncludeProperty(node, childNode));
if (isIncluded)
{
m_writer.WritePropertyName(name);
}
// push a node for this property onto the stack
m_statusStack.Push(new Status {
IsIncluded = isIncluded, IsProperty = true, Node = childNode
});
}
}
public GridPage <DingNew> GetNew(int id)
{
var res = new GridPage <DingNew>()
{
code = ResCode.Success
};
var result = new GridPage <List <DingNew> >()
{
code = ResCode.Success
};
FilterNode node = new FilterNode();
node.andorop = "and";
node.binaryop = "eq";
node.key = "Id";
node.value = id;
var pageReq = new DatetimePointPageReq();
pageReq.query.Add(node);
result = DataBaseHelper <DingNew> .GetList(_uowProvider, result, pageReq, x => x.Include(a => a.DingClassify));
if (result.data.Count > 0)
{
res.data = result.data[0];
}
return(res);
}
public GridPage <List <DingNew> > GetNews(DatetimePointPageReq pageReq, int?id)
{
var res = new GridPage <List <DingNew> >()
{
code = ResCode.Success
};
if (id != null)
{
FilterNode node = new FilterNode();
node.andorop = "and";
node.binaryop = "eq";
node.key = "DingClassify.Id";
node.value = id;
if (pageReq == null)
{
pageReq = new DatetimePointPageReq();
}
pageReq.query.Add(node);
res = DataBaseHelper <DingNew> .GetList(_uowProvider, res, pageReq, x => x.Include(a => a.DingClassify));
}
else
{
//all
res = DataBaseHelper <DingNew> .GetList(_uowProvider, res, pageReq, x => x.Include(a => a.DingClassify));
}
return(res);
}
// var tok = this.expect('code')
// , node = new nodes.Code(tok.val, tok.buffer, tok.escape)
// , block
// , i = 1;
// node.line = this.line();
// while (this.lookahead(i) && 'newline' == this.lookahead(i).type) ++i;
// block = 'indent' == this.lookahead(i).type;
// if (block) {
// this.skip(i-1);
// node.block = this.block();
// }
// return node;
private Node parseFilter()
{
Token token = expect(GetType())
;
Filter filterToken = (Filter)token;
Attribute attr = (Attribute)accept(typeof(Attribute))
;
_jadeLexer.setPipeless(true);
Node tNode = parseTextBlock();
_jadeLexer.setPipeless(false);
FilterNode node = new FilterNode();
node.setValue(filterToken.getValue());
node.setLineNumber(line());
node.setFileName(filename);
node.setTextBlock(tNode);
if (attr != null)
{
node.setAttributes(attr.getAttributes());
}
return(node);
}
public ActionResult <DataRes <List <SingleProductSell> > > GetList(OrderReq req)
{
var res = new DataRes <List <SingleProductSell> >()
{
code = ResCode.Success
};
if (req != null)
{
using (var uow = _uowProvider.CreateUnitOfWork())
{
string sql = "select x.Plateform,x.UserAccount,x.SaleOrderCode," +
"x.ShippingMethodPlatform, x.ShippingMethod, x.WarehouseCode," +
"x.DatePaidPlatform, x.PlatformShipTime, x.DateLatestShip, x.Currency," +
"x.CountryCode, ProductCount,a.ProductSku, a.Qty,c.pcrProductSku SubProductSku," +
" a.Qty * c.PcrQuantity SubQty, b.WarehouseId " +
"from EC_SalesOrder x join EC_SalesOrderDetail a on x.OrderId = a.OrderId " +
"join EC_SkuRelation b on a.ProductSku = b.ProductSku " +
"join EC_SkuRelationItems c on b.relationid = c.relationid " +
"order by x.SaleOrderCode";
var repository = uow.GetRepository <SingleProductSell>();
string orderStr = req.order + (req.order.reverse ? " desc" : "");
res.data = repository.ListFromSql(sql, FilterNode.ListToString(req.query), orderStr).ToList();
}
}
else
{
res.code = ResCode.NoValidate;
res.msg = ResMsg.ParameterIsNull;
}
return(res);
}
public static ValueTask <FilterNode <ClrValue>?> TransformAsync(FilterNode <ClrValue> nodeIn, Guid appId, ISchemaEntity schema, ITagService tagService)
{
Guard.NotNull(nodeIn, nameof(nodeIn));
Guard.NotNull(tagService, nameof(tagService));
Guard.NotNull(schema, nameof(schema));
return(nodeIn.Accept(new FilterTagTransformer(appId, schema, tagService)));
}
public static FilterNode <ClrValue>?Transform(FilterNode <ClrValue> nodeIn, Guid appId, ISchemaEntity schema, ITagService tagService)
{
Guard.NotNull(nodeIn);
Guard.NotNull(tagService);
Guard.NotNull(schema);
return(nodeIn.Accept(new FilterTagTransformer(appId, schema, tagService)));
}
public FilteredJsonWriter(JsonWriter writer, FilterNode node)
{
m_writer = writer;
m_statusStack = new Stack <Status>();
m_statusStack.Push(new Status {
IsIncluded = true, Node = node
});
}
/// <summary>
/// The subsequent Bind* operations only apply when the Attribute's property is not null.
/// </summary>
/// <param name="propertyName"></param>
/// <returns></returns>
public FluentBindingRule <TAttribute> WhenIsNotNull(string propertyName)
{
var prop = ResolveProperty(propertyName);
AppendFilter(FilterNode.NotNull(prop));
return(this);
}
public IEnumerable <ASTNode> Transform(FilterNode item)
{
yield return(item);
foreach (var child in TransformAll(item.FilterContents))
{
yield return(child);
}
}
public void ConstructTerminalNode()
{
RelationalExpression exp = new RelationalExpression("Name", "Smith", RelationalOperator.Equal);
FilterNode node = new FilterNode(exp);
Assert.AreEqual(exp, node.Term);
Assert.IsFalse(node.Evaluated.HasValue);
Assert.IsNull(node.Left);
Assert.IsNull(node.Right);
Assert.AreEqual(LogicalOperator.None, node.Operator);
}
public void EvaluateTerminalNodeFalse()
{
var exp = new RelationalExpression("Name", "Smith", RelationalOperator.Equal);
var node = new FilterNode(exp);
node.Evaluate(delegate { return(false); });
Assert.IsTrue(node.Evaluated.HasValue);
Assert.IsFalse(node.Evaluated.Value);
}
private void addNewFilter_Click(object sender, EventArgs e)
{
FilterNode filterNode = new FilterNode();
filterNode.FilterablePropertyDescription = this.PropertiesToFilter[0];
filterNode.Operator = (PropertyFilterOperator)this.PropertiesToFilter[0].SupportedOperators.Values.GetValue(0);
this.incompleteItems.Add(filterNode);
this.filterNodes.Add(filterNode);
this.filterNode_PropertyChanged(filterNode, EventArgs.Empty);
}
public void EvaluateTerminalNodeFalse()
{
RelationalExpression exp = new RelationalExpression("Name", "Smith", RelationalOperator.Equal);
FilterNode node = new FilterNode(exp);
node.Evaluate(delegate(FilterNode n) { return false; });
Assert.IsTrue(node.Evaluated.HasValue);
Assert.IsFalse(node.Evaluated.Value);
}
public IEnumerable<Changeset> GetChangesetsByProject(string projectName, FilterNode rootFilterNode, int topRequestValue)
{
var key = this.GetChangesetsByProjectKey(projectName, rootFilterNode, topRequestValue);
if (HttpContext.Current.Items[key] == null)
{
HttpContext.Current.Items[key] = this.RequestChangesetsByProject(projectName, rootFilterNode, topRequestValue);
}
return (IEnumerable<Changeset>)HttpContext.Current.Items[key];
}
public IEnumerable<Changeset> GetChangesetsByBranch(string path, FilterNode rootFilterNode, int topRequestValue)
{
var key = this.GetChangesetsByBranchKey(path, rootFilterNode, topRequestValue);
if (HttpContext.Current.Items[key] == null)
{
HttpContext.Current.Items[key] = this.RequestChangesetsByBranch(path, rootFilterNode, topRequestValue);
}
return (IEnumerable<Changeset>)HttpContext.Current.Items[key];
}
public IEnumerable<Changeset> GetChangesetsByProjectCollection(FilterNode rootFilterNode, int topRequestValue)
{
var key = this.GetChangesetsByProjectCollectionKey(rootFilterNode, topRequestValue);
if (HttpContext.Current.Items[key] == null)
{
HttpContext.Current.Items[key] = this.RequestChangesetsByProjectCollection(rootFilterNode, topRequestValue);
}
return (IEnumerable<Changeset>)HttpContext.Current.Items[key];
}
public IEnumerable<Build> GetBuildsByProject(string projectName, FilterNode rootFilterNode)
{
var key = this.GetBuildsByProjectKey(projectName, rootFilterNode);
if (HttpContext.Current.Items[key] == null)
{
HttpContext.Current.Items[key] = this.RequestBuildsByProject(projectName, rootFilterNode);
}
return (IEnumerable<Build>)HttpContext.Current.Items[key];
}
public IEnumerable<Build> GetBuildsByProjectCollection(FilterNode rootFilterNode)
{
var key = this.GetBuildsByProjectCollectionKey(rootFilterNode);
if (HttpContext.Current.Items[key] == null)
{
HttpContext.Current.Items[key] = this.RequestBuildsByProjectCollection(rootFilterNode);
}
return (IEnumerable<Build>)HttpContext.Current.Items[key];
}
public FilterEvaluator(FilterNode expressionTree, PropertyDescriptorCollection listItemProperties)
{
if (expressionTree == null)
throw new ArgumentNullException("expressionTree");
if (listItemProperties == null)
throw new ArgumentNullException("listItemProperties");
if (listItemProperties.Count == 0)
throw new ArgumentException("listItemProperties");
this.tree = expressionTree;
this.CreatePredicates(expressionTree, listItemProperties);
}
public void ConstructOrNode()
{
RelationalExpression expLeft = new RelationalExpression("Name", "Smith", RelationalOperator.Less);
RelationalExpression expRight = new RelationalExpression("Name", "Smith", RelationalOperator.Greater);
FilterNode nodeLeft = new FilterNode(expLeft);
FilterNode nodeRight = new FilterNode(expRight);
FilterNode node = new FilterNode(nodeLeft, nodeRight, LogicalOperator.Or);
Assert.IsNull(node.Term);
Assert.IsFalse(node.Evaluated.HasValue);
Assert.AreEqual(nodeLeft, node.Left);
Assert.AreEqual(nodeRight, node.Right);
Assert.AreEqual(LogicalOperator.Or, node.Operator);
}
private string GetChangesetsByProjectCollectionKey(FilterNode rootFilterNode, int topRequestValue)
{
return string.Format(CultureInfo.InvariantCulture, "TFSChangesetProxy.GetChangesetsByProjectCollection_{0}_{1}", this.GetFilterNodeKey(rootFilterNode), topRequestValue);
}
private string GetChangesetsByProjectKey(string projectName, FilterNode rootFilterNode, int topRequestValue)
{
return string.Format(CultureInfo.InvariantCulture, "TFSChangesetProxy.GetChangesetsByProject_{0}_{1}_{2}", projectName, this.GetFilterNodeKey(rootFilterNode), topRequestValue);
}
private IEnumerable<Changeset> RequestChangesetsByProject(string projectName, FilterNode rootFilterNode, int topRequestValue)
{
var versionControlServer = this.TfsConnection.GetService<TeamFoundation.VersionControl.Client.VersionControlServer>();
var preliminaryChangesets = versionControlServer.QueryHistory(
GetRequestedPath(null, projectName, rootFilterNode),
TeamFoundation.VersionControl.Client.VersionSpec.Latest,
0,
TeamFoundation.VersionControl.Client.RecursionType.Full,
GetRequestedCommitter(rootFilterNode),
GetRequestedVersionFrom(rootFilterNode),
GetRequestedVersionTo(rootFilterNode),
topRequestValue,
false,
false,
false);
return FilterChangesets(preliminaryChangesets.Cast<TeamFoundation.VersionControl.Client.Changeset>().Select(c => c.ToModel(this.GetTfsWebAccessArtifactUrl(c.ArtifactUri))), rootFilterNode).ToArray();
}
private IEnumerable<Changeset> RequestChangesetsByProjectCollection(FilterNode rootFilterNode, int topRequestValue)
{
var css = this.TfsConnection.GetService<Microsoft.TeamFoundation.Server.ICommonStructureService3>();
var teamProjects = css.ListAllProjects();
return teamProjects.SelectMany(p => this.GetChangesetsByProject(p.Name, rootFilterNode, topRequestValue));
}
private static IEnumerable<Changeset> FilterChangesets(IEnumerable<Changeset> changesets, FilterNode rootFilterNode)
{
if (rootFilterNode != null)
{
changesets = FilterChangesetsByCreationDate(changesets, rootFilterNode);
changesets = FilterChangesetsByOwner(changesets, rootFilterNode);
changesets = FilterChangesetsByComment(changesets, rootFilterNode);
changesets = FilterChangesetsByArtifactUri(changesets, rootFilterNode);
}
return changesets;
}
private static IEnumerable<Build> FilterBuilds(IEnumerable<Build> builds, FilterNode rootFilterNode)
{
if (rootFilterNode != null)
{
var startTimeParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("StartTime"));
var finishTimeParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("FinishTime"));
var buildFinishedParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("BuildFinished"));
var requestedByParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("RequestedBy"));
var startTimeValue = default(DateTime);
if (startTimeParameter != null && DateTime.TryParse(startTimeParameter.Value, out startTimeValue))
{
switch (startTimeParameter.Sign)
{
case FilterExpressionType.Equal:
builds = builds.Where(b => b.StartTime.Equals(startTimeValue));
break;
case FilterExpressionType.NotEqual:
builds = builds.Where(b => !b.StartTime.Equals(startTimeValue));
break;
case FilterExpressionType.GreaterThan:
builds = builds.Where(b => b.StartTime > startTimeValue);
break;
case FilterExpressionType.LessThan:
builds = builds.Where(b => b.StartTime < startTimeValue);
break;
default:
throw new NotSupportedException("Start time field can only be filtered with equality, inequality, greater than and less than operators");
}
}
var finishTimeValue = default(DateTime);
if (finishTimeParameter != null && DateTime.TryParse(finishTimeParameter.Value, out finishTimeValue))
{
switch (finishTimeParameter.Sign)
{
case FilterExpressionType.Equal:
builds = builds.Where(b => b.FinishTime.Equals(finishTimeValue));
break;
case FilterExpressionType.NotEqual:
builds = builds.Where(b => !b.FinishTime.Equals(finishTimeValue));
break;
case FilterExpressionType.GreaterThan:
builds = builds.Where(b => b.FinishTime > finishTimeValue);
break;
case FilterExpressionType.LessThan:
builds = builds.Where(b => b.FinishTime < finishTimeValue);
break;
default:
throw new NotSupportedException("Finish time field can only be filtered with equality, inequality, greater than and less than operators");
}
}
var buildFinishedValue = default(bool);
if (buildFinishedParameter != null && bool.TryParse(buildFinishedParameter.Value, out buildFinishedValue))
{
switch (buildFinishedParameter.Sign)
{
case FilterExpressionType.Equal:
builds = builds.Where(b => b.BuildFinished == buildFinishedValue);
break;
case FilterExpressionType.NotEqual:
builds = builds.Where(b => b.BuildFinished != buildFinishedValue);
break;
default:
throw new NotSupportedException("Build Finished field can only be filtered with equality and inequality operators");
}
}
if (requestedByParameter != null)
{
switch (requestedByParameter.Sign)
{
case FilterExpressionType.Equal:
builds = builds.Where(b => b.RequestedBy.Equals(requestedByParameter.Value));
break;
case FilterExpressionType.NotEqual:
builds = builds.Where(b => !b.RequestedBy.Equals(requestedByParameter.Value));
break;
default:
throw new NotSupportedException("Requested By field can only be filtered with equality and inequality operators");
}
}
}
return builds;
}
private static TeamFoundation.Build.Client.IBuildDetailSpec CreateBuildDetailSpec(TeamFoundation.Build.Client.IBuildServer buildServer, string projectName, FilterNode rootFilterNode)
{
var detailSpec = default(TeamFoundation.Build.Client.IBuildDetailSpec);
if (rootFilterNode != null)
{
var definitionSpec = buildServer.CreateBuildDefinitionSpec(projectName);
var definition = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Definition", StringComparison.OrdinalIgnoreCase));
var number = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Number", StringComparison.OrdinalIgnoreCase));
var quality = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Quality", StringComparison.OrdinalIgnoreCase));
var reason = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Reason", StringComparison.OrdinalIgnoreCase));
var status = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Status", StringComparison.OrdinalIgnoreCase));
var requestedFor = rootFilterNode.SingleOrDefault(p => p.Key.Equals("RequestedFor", StringComparison.OrdinalIgnoreCase));
if (definition != null)
{
if (definition.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Definition can only be filtered with an equality operator", "en-US", null);
}
definitionSpec.Name = definition.Value;
}
detailSpec = buildServer.CreateBuildDetailSpec(definitionSpec);
if (number != null)
{
if (number.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Number can only be filtered with an equality operator", "en-US", null);
}
detailSpec.BuildNumber = number.Value;
}
if (quality != null)
{
if (quality.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Quality can only be filtered with an equality operator", "en-US", null);
}
detailSpec.Quality = quality.Value;
}
if (requestedFor != null)
{
if (requestedFor.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Requested For can only be filtered with an equality operator", "en-US", null);
}
detailSpec.RequestedFor = requestedFor.Value;
}
if (status != null)
{
if (status.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Status can only be filtered with an equality operator", "en-US", null);
}
var statusValue = default(TeamFoundation.Build.Client.BuildStatus);
if (Enum.TryParse<TeamFoundation.Build.Client.BuildStatus>(status.Value, out statusValue))
{
detailSpec.Status = statusValue;
}
}
if (reason != null)
{
if (reason.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Build Reason can only be filtered with an equality operator", "en-US", null);
}
var reasonValue = default(TeamFoundation.Build.Client.BuildReason);
if (Enum.TryParse<TeamFoundation.Build.Client.BuildReason>(reason.Value, out reasonValue))
{
detailSpec.Reason = reasonValue;
}
}
return detailSpec;
}
else
{
detailSpec = buildServer.CreateBuildDetailSpec(projectName);
}
return detailSpec;
}
public void EvaluateAndTreeTrueTrue()
{
FilterNode nodeLeft = new FilterNode(new TestFilterNode(true), new TestFilterNode(false), LogicalOperator.Or);
FilterNode nodeRight = new FilterNode(new TestFilterNode(true), new TestFilterNode(true), LogicalOperator.And);
FilterNode node = new FilterNode(nodeLeft, nodeRight, LogicalOperator.And);
Assert.IsTrue(node.Evaluate(delegate(FilterNode n) { return ((TestFilterNode)n).Result; }));
Assert.IsTrue(nodeLeft.Evaluated.HasValue);
Assert.IsTrue(nodeLeft.Evaluated.Value);
Assert.IsTrue(nodeRight.Evaluated.HasValue);
Assert.IsTrue(nodeRight.Evaluated.Value);
Assert.IsTrue(node.Evaluated.HasValue);
Assert.IsTrue(node.Evaluated.Value);
}
private string GetChangesetsByBranchKey(string path, FilterNode rootFilterNode, int topRequestValue)
{
return string.Format(CultureInfo.InvariantCulture, "TFSChangesetProxy.GetChangesetsByBranch_{0}_{1}_{2}", path, this.GetFilterNodeKey(rootFilterNode), topRequestValue);
}
private bool Evaluator(FilterNode node)
{
return this.nodePredicates[node](this.currentListItem);
}
private string GetBuildsByProjectCollectionKey(FilterNode rootFilterNode)
{
return string.Format(CultureInfo.InvariantCulture, "TFSBuildProxy.GetBuildsByProjectCollection_{0}", this.GetFilterNodeKey(rootFilterNode));
}
private string GetBuildsByProjectKey(string projectName, FilterNode rootFilterNode)
{
return string.Format(CultureInfo.InvariantCulture, "TFSBuildProxy.GetBuildsByProject_{0}_{1}", projectName, this.GetFilterNodeKey(rootFilterNode));
}
private IEnumerable<Build> RequestBuildsByProject(string projectName, FilterNode rootFilterNode)
{
var buildServer = this.TfsConnection.GetService<TeamFoundation.Build.Client.IBuildServer>();
var spec = CreateBuildDetailSpec(buildServer, projectName, rootFilterNode);
var preliminaryResults = buildServer.QueryBuilds(spec).Builds.Select(b => b.ToModel());
return FilterBuilds(preliminaryResults, rootFilterNode).ToArray();
}
private IEnumerable<Build> RequestBuildsByProjectCollection(FilterNode rootFilterNode)
{
var teamProjects = this.TfsConnection.CatalogNode.QueryChildren(
new Guid[] { CatalogResourceTypes.TeamProject },
false,
CatalogQueryOptions.None);
IEnumerable<Build> preliminaryResults = null;
var buildServer = this.TfsConnection.GetService<TeamFoundation.Build.Client.IBuildServer>();
if (rootFilterNode != null && rootFilterNode.Count(p => p.Key.Equals("Project", StringComparison.OrdinalIgnoreCase)) > 0)
{
var projectParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Project", StringComparison.OrdinalIgnoreCase));
var spec = CreateBuildDetailSpec(buildServer, projectParameter.Value, rootFilterNode);
preliminaryResults = buildServer.QueryBuilds(spec).Builds.Select(b => b.ToModel());
}
else
{
var specs = teamProjects.Select(t => CreateBuildDetailSpec(buildServer, t.Resource.DisplayName, rootFilterNode));
preliminaryResults = specs.Select(s => buildServer.QueryBuilds(s)).SelectMany(r => r.Builds).Select(b => b.ToModel());
}
return FilterBuilds(preliminaryResults, rootFilterNode).ToArray();
}
private static TeamFoundation.VersionControl.Client.VersionSpec GetRequestedVersionTo(FilterNode rootFilterNode)
{
if (rootFilterNode != null)
{
if (rootFilterNode.SingleOrDefault(p => p.Key.Equals("Id", StringComparison.OrdinalIgnoreCase)) != null)
{
return GetRequestedIdVersionTo(rootFilterNode);
}
else if (rootFilterNode.SingleOrDefault(p => p.Key.Equals("CreationDate", StringComparison.OrdinalIgnoreCase)) != null)
{
return GetRequestedDateVersionTo(rootFilterNode);
}
}
return null;
}
public void ConstructAndTree()
{
FilterNode nodeLeft = new FilterNode(new TestFilterNode(true), new TestFilterNode(true), LogicalOperator.Or);
FilterNode nodeRight = new FilterNode(new TestFilterNode(true), new TestFilterNode(true), LogicalOperator.Or);
FilterNode node = new FilterNode(nodeLeft, nodeRight, LogicalOperator.And);
Assert.IsNull(node.Term);
Assert.IsFalse(node.Evaluated.HasValue);
Assert.AreEqual(nodeLeft, node.Left);
Assert.AreEqual(nodeRight, node.Right);
Assert.AreEqual(LogicalOperator.And, node.Operator);
}
protected virtual void CreatePredicates(FilterNode tree, PropertyDescriptorCollection properties)
{
nodePredicates = new Dictionary<FilterNode, Predicate>();
List<PropertyDescriptor> propList = new List<PropertyDescriptor>();
foreach (FilterNode node in tree)
{
// Only create predicates for terminal nodes.
if (node.Term == null)
continue;
string propertyName = node.Term.PropertyName;
string propertyValue = node.Term.Value;
PropertyDescriptor property = null;
// Verify that the property name in the expression is a property of the list item type.
// If the property name is of the form "A.B", it is assumed to refer to a property of a property (a property path).
if (propertyName.Contains("."))
{
property = new PropertyPathDescriptor(properties[0].ComponentType, propertyName);
}
else
{
foreach (PropertyDescriptor prop in properties)
{
if (prop.Name == propertyName)
{
property = prop;
break;
}
}
}
if (property == null)
throw new ArgumentException("The property '" + propertyName + "' is not a property of the list item type.", "Filter");
if (!propList.Contains(property))
propList.Add(property);
// "null" is a special literal meaning a null value, not the characters 'n' 'u' 'l' 'l'.
if (string.Compare(propertyValue, "null", true) == 0)
propertyValue = null;
// If the property is of string type, create a predicate that does regular expression matching. Otherwise create a predicate
// that uses the default Comparer<T> where T is the property type.
Predicate predicate = null;
if (property.PropertyType == typeof(string))
{
predicate = new StringComparerPredicate(property, propertyValue, node.Term.Operator).Matches;
}
else
{
Type predicateType = typeof(PropertyComparerPredicate<>).MakeGenericType(new Type[] { property.PropertyType });
object pred = Activator.CreateInstance(predicateType, property, propertyValue, node.Term.Operator);
predicate = (Predicate)Delegate.CreateDelegate(typeof(Predicate), pred, predicateType.GetMethod("Matches"));
}
// Save the predicate for use by the Evaluator method.
this.nodePredicates.Add(node, predicate);
}
// Save the list of properties referenced in the filter expression.
this.props = new PropertyDescriptorCollection(propList.ToArray(), true);
}
/// <summary>
/// Gets the count treshold to minimize the number of elements retrieved from TFS
/// </summary>
private int GetTopRequestValue(ODataQueryOperation operation, FilterNode parameters)
{
int topRequestValue = int.MaxValue;
if (parameters == null || !parameters.Any(p => p.Key.Equals("Owner") || p.Key.Equals("CreationDate") || p.Key.Equals("Comment") || p.Key.Equals("ArtifactUri")))
{
if (operation.IsCountRequest)
{
if (!string.IsNullOrEmpty(operation.ContinuationToken))
{
var parts = operation.ContinuationToken.Split(':').Select(int.Parse);
topRequestValue = parts.First() + parts.Last() + 1;
}
}
else
{
if (operation.TopCount > 0)
{
topRequestValue = operation.TopCount + operation.SkipCount + 1;
}
}
}
return topRequestValue;
}
private void AddFilterNode(string fieldName, object value, FilterExpressionType expressionType, FilterNodeRelationship filterNodeRelationship)
{
if (this.rootFilterNode != null && this.rootFilterNode.SingleOrDefault(p => p.Key.Equals(fieldName, StringComparison.OrdinalIgnoreCase)) != null)
{
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "More than one filter expression found for attribute {0}. Only one filter expression per attribute is supported.", fieldName));
}
var filterNode = new FilterNode { Key = fieldName, Value = (value == null) ? "null" : value.ToString(), Sign = expressionType, NodeRelationship = filterNodeRelationship };
if (this.rootFilterNode != null)
{
this.rootFilterNode.AddNode(filterNode);
}
else
{
this.rootFilterNode = filterNode;
}
}
public void EvaluateOrNodeFalseFalse()
{
RelationalExpression expLeft = new RelationalExpression("Name", "Smith", RelationalOperator.Less);
RelationalExpression expRight = new RelationalExpression("Name", "Smith", RelationalOperator.Greater);
FilterNode nodeLeft = new FilterNode(expLeft);
FilterNode nodeRight = new FilterNode(expRight);
FilterNode node = new FilterNode(nodeLeft, nodeRight, LogicalOperator.Or);
Assert.IsFalse(node.Evaluate(delegate(FilterNode n) { return false; }));
Assert.IsTrue(nodeLeft.Evaluated.HasValue);
Assert.IsFalse(nodeLeft.Evaluated.Value);
Assert.IsTrue(nodeRight.Evaluated.HasValue);
Assert.IsFalse(nodeRight.Evaluated.Value);
Assert.IsTrue(node.Evaluated.HasValue);
Assert.IsFalse(node.Evaluated.Value);
}
private static string GetRequestedPath(string branch, string projectName, FilterNode rootFilterNode)
{
var path = "$/";
var branchParameter = default(FilterNode);
if (rootFilterNode != null)
{
branchParameter = rootFilterNode.SingleOrDefault(p => p.Key.Equals("Branch", StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(branch))
{
var branchName = EntityTranslator.DecodePath(branch);
path = string.Format(CultureInfo.InvariantCulture, branchName.StartsWith("$/", StringComparison.Ordinal) ? "{0}/*" : "$/{0}/*", branchName);
}
else if (branchParameter != null && !string.IsNullOrEmpty(branchParameter.Value))
{
if (branchParameter.Sign != FilterExpressionType.Equal)
{
throw new DataServiceException(501, "Not Implemented", "Changeset Branch can only be filtered with an equality operator", "en-US", null);
}
var branchName = EntityTranslator.DecodePath(branchParameter.Value);
path = string.Format(CultureInfo.InvariantCulture, branchName.StartsWith("$/", StringComparison.Ordinal) ? "{0}/*" : "$/{0}/*", branchName);
}
else if (!string.IsNullOrEmpty(projectName))
{
path = string.Format(CultureInfo.InvariantCulture, "$/{0}", projectName);
}
return path;
}
