public async Task UpdateNode()
{
var res = await _tvheadendService.NodesAsync(new QueryParams
{
Limit = 1,
Filters = new List <IQueryParamsFilter> {
FactoryQueryParamsFilter.CreateStringQueryParamsFilter("name", "bein")
}
}, API_URLS.CHANNELS_LIST, CancellationToken.None);
Assert.Single(res);
var expectedMediaName = (string)res.SingleOrDefault()["name"];
res.SingleOrDefault()["name"] = nameof(UpdateNode);
_tvheadendService.UpdateNode(res);
res = await _tvheadendService.NodesAsync(new QueryParams
{
Limit = 1,
Filters = new List <IQueryParamsFilter> {
FactoryQueryParamsFilter.CreateStringQueryParamsFilter("name", nameof(UpdateNode))
}
}, API_URLS.CHANNELS_LIST, CancellationToken.None);
Assert.Single(res);
res.SingleOrDefault()["name"] = expectedMediaName;
_tvheadendService.UpdateNode(res);
}
public void ListEpg(string field, string query, int count)
{
var res = _tvheadendService.EPG(new QueryParams
{
Limit = count,
Filters = new List <IQueryParamsFilter> {
FactoryQueryParamsFilter.CreateStringQueryParamsFilter(field, query)
}
});
Assert.Equal(count, res.Count());
}
public void UpdateMediaTest(string field, string query)
{
var res = _tvheadendService.Channels(new QueryParams
{
Filters = new List <IQueryParamsFilter> {
FactoryQueryParamsFilter.CreateStringQueryParamsFilter(field, query)
}
});
Assert.NotNull(res);
Assert.Equal(20, res.Count());
}
/// <summary>
/// filter:[{"type":"string","value":"bein","field":"name"},
/// {"type":"numeric","comparison":"lt","value":10000000,"intsplit":1000000,"field":"number"}]
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
protected override Expression VisitBinary(BinaryExpression node)
{
switch (node.NodeType)
{
case ExpressionType.And:
case ExpressionType.AndAlso:
case ExpressionType.Or:
case ExpressionType.OrElse:
Visit(node.Left);
Visit(node.Right);
break;
case ExpressionType.Constant:
return(node);
case ExpressionType.NotEqual:
case ExpressionType.Equal:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
// FIRST STEP
// We support only a comparison between constant
// and a possible flight query parameter
ConstantExpression constant =
(node.Left as ConstantExpression ?? node.Right as ConstantExpression);
MemberExpression memberAccess =
(node.Left as MemberExpression ?? node.Right as MemberExpression);
// SECOND STEP
// Sanity check of parameters
if ((memberAccess == null) || (constant == null))
{
throw new NotSupportedException(string.Format("The binary operator '{0}' must compare a valid " + "flight attribute with a constant", node.NodeType));
}
if (constant.Value == null)
{
throw new NotSupportedException(string.Format("NULL constant is not supported in binary operator {0}", node.ToString()));
}
switch (Type.GetTypeCode(constant.Value.GetType()))
{
case TypeCode.String:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Double:
break;
default:
throw new NotSupportedException(string.Format("Constant {0} is of an unsupported type ({1})", constant.ToString(), constant.Value.GetType().Name));
}
_queryParams.Filters.Add(FactoryQueryParamsFilter.CreateNumericQueryParamsFilter(memberAccess.Member.Name.ToLowerInvariant(), constant.Value.ToString(), GetComparaison(node.NodeType)));
break;
case ExpressionType.Parameter:
break;
case ExpressionType.IsTrue:
case ExpressionType.IsFalse:
CheckType(node, typeof(bool));
break;
default:
throw new NotSupportedException();
}
return(node);
}
