protected override Expression VisitBinary(BinaryExpression exp)
{
LeftOperator = ToOperator(exp.Left);
RightOperator = ToOperator(exp.Right);
FieldType dataType;
CamlFieldRef fieldRef = GetFieldRef(out dataType);
CamlValue value = GetValue(dataType);
if (fieldRef == null)
{
return(exp);
}
switch (exp.NodeType)
{
case ExpressionType.Equal:
if (exp.Right.IsNullValue())
{
Operator = new Caml.Operators.IsNull(fieldRef);
}
else
{
Operator = new Caml.Operators.Eq(fieldRef, value);
}
break;
case ExpressionType.NotEqual:
if (exp.Right.IsNullValue())
{
Operator = new Caml.Operators.IsNotNull(fieldRef);
}
else
{
Operator = new Caml.Operators.Neq(fieldRef, value);
}
break;
case ExpressionType.GreaterThan:
Operator = new Caml.Operators.Gt(fieldRef, value);
break;
case ExpressionType.GreaterThanOrEqual:
Operator = new Caml.Operators.Geq(fieldRef, value);
break;
case ExpressionType.LessThan:
Operator = new Caml.Operators.Lt(fieldRef, value);
break;
case ExpressionType.LessThanOrEqual:
Operator = new Caml.Operators.Leq(fieldRef, value);
break;
//case ExpressionType.Convert:
// Visit(exp);
// break;
default:
throw new NotSupportedException($"{exp.NodeType} operator is not supported in LinqToSP.");
}
return(exp);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if ((node.Method.Name == "LookupIncludes" || node.Method.Name == "LookupIdIncludes") && typeof(ListItemEntityExtensions).IsAssignableFrom(node.Method.DeclaringType))
{
Visit(node.Object);
foreach (var arg in node.Arguments)
{
if (arg.NodeType == ExpressionType.Constant || arg.NodeType == ExpressionType.Lambda)
{
Visit(arg);
}
}
FieldType dataType;
CamlFieldRef fieldRef = GetFieldRef(out dataType);
CamlValue value = GetValue(dataType);
if (fieldRef == null || value == null)
{
return(node);
}
if (node.Method.Name == "LookupIdIncludes")
{
fieldRef.LookupId = true;
}
Operator = new Caml.Operators.Includes(fieldRef, value);
return(node);
}
throw new NotSupportedException($"{node.NodeType} method is not supported in LinqToSP.");
}
protected FieldValueOperator(string operatorName, string fieldName, CamlValue <T> value)
: base(operatorName, value)
{
FieldRef = new CamlFieldRef {
Name = fieldName
};
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
Expression expression = node;
if (node.Method.Name == "Equals")
{
foreach (var arg in node.Arguments)
{
Visit(arg);
}
FieldType dataType;
CamlFieldRef fieldRef = GetFieldRef(out dataType);
CamlValue value = GetValue(dataType);
Operator = new Caml.Operators.Eq(fieldRef, value);
}
else if (node.Method.Name == "NotEquals")
{
Visit(node.Object);
foreach (var arg in node.Arguments)
{
Visit(arg);
}
FieldType dataType;
CamlFieldRef fieldRef = GetFieldRef(out dataType);
CamlValue value = GetValue(dataType);
Operator = new Caml.Operators.Neq(fieldRef, value);
//return null;
}
return(expression);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Method.Name == "DateRangesOverlap" && typeof(ListItemEntityExtensions).IsAssignableFrom(node.Method.DeclaringType))
{
Visit(node.Object);
foreach (var arg in node.Arguments)
{
if (arg.NodeType == ExpressionType.Constant || arg.NodeType == ExpressionType.Lambda)
{
Visit(arg);
}
}
FieldType dataType;
CamlFieldRef startTimeFieldRef = GetFieldRef(StartTimeFieldName, out dataType);
CamlFieldRef endTimeFieldRef = GetFieldRef(EndTimeFieldName, out dataType);
CamlFieldRef recurrenceDataFieldRef = GetFieldRef(RecurrenceDataFieldName, out dataType);
CamlValue value = GetValue(Microsoft.SharePoint.Client.FieldType.DateTime);
value.IncludeTimeValue = null;
if (startTimeFieldRef == null || endTimeFieldRef == null || recurrenceDataFieldRef == null || value == null)
{
return(node);
}
Operator = new Caml.Operators.DateRangesOverlap(startTimeFieldRef, endTimeFieldRef, recurrenceDataFieldRef, value);
return(node);
}
throw new NotSupportedException($"{node.NodeType} method is not supported in LinqToSP.");
}
protected FieldValueOperator(string operatorName, Guid fieldId, CamlValue <T> value)
: base(operatorName, value)
{
FieldRef = new CamlFieldRef {
Id = fieldId
};
}
protected ValueOperator(string operatorName, CamlValue <T> value)
: base(operatorName)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
Value = value;
}
protected ValueOperator(string operatorName, T value, FieldType type)
: base(operatorName)
{
if (value is CamlValue <T> )
{
Value = value as CamlValue <T>;
}
else
{
Value = new CamlValue <T>(value, type);
}
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Method.Name == "StartsWith")
{
Visit(node.Object);
foreach (var arg in node.Arguments)
{
Visit(arg);
}
FieldType dataType;
CamlFieldRef fieldRef = GetFieldRef(out dataType);
CamlValue value = GetValue(dataType);
if (fieldRef == null)
{
return(node);
}
Operator = new Caml.Operators.BeginsWith(fieldRef, value);
return(node);
}
throw new NotSupportedException($"{node.NodeType} method is not supported in LinqToSP.");
}
protected FieldValueOperator(string operatorName, CamlFieldRef fieldRef, CamlValue <T> value)
: base(operatorName, value)
{
FieldRef = fieldRef;
}
protected override void OnParsing(XElement existingValueOperator)
{
Value = new CamlValue <T>(existingValueOperator);
}
public Lt(CamlFieldRef fieldRef, CamlValue <object> value) : base(fieldRef, value)
{
}
public Includes(CamlFieldRef fieldRef, CamlValue <object> value) : base(fieldRef, value)
{
}
public Contains(CamlFieldRef fieldRef, CamlValue <string> value)
: base(fieldRef, value)
{
}
public DateRangesOverlap(Guid startField, Guid endField, Guid recurrenceIdField, CamlValue value)
: base(DateRangesOverlapTag, new[] { startField, endField, recurrenceIdField }, value, FieldType.DateTime)
{
}
public DateRangesOverlap(string startField, string endField, string recurrenceIdField, CamlValue <DateTime> value)
: base(DateRangesOverlapTag, new[] { startField, endField, recurrenceIdField }, value, FieldType.DateTime)
{
}
public BeginsWith(CamlFieldRef fieldRef, CamlValue value)
: base(fieldRef, value)
{
}
