protected CamlFieldRef GetFieldRef(string fieldName, out FieldType dataType)
{
dataType = Microsoft.SharePoint.Client.FieldType.Invalid;
if (SpQueryArgs != null && !string.IsNullOrEmpty(fieldName))
{
if (SpQueryArgs.FieldMappings.ContainsKey(fieldName))
{
var fieldMap = SpQueryArgs.FieldMappings[fieldName];
var fieldRef = new CamlFieldRef()
{
Name = fieldMap.Name
};
if (fieldMap is LookupFieldAttribute)
{
if ((fieldMap as LookupFieldAttribute).Result == LookupItemResult.Id)
{
fieldRef.LookupId = true;
}
}
dataType = fieldMap.DataType;
return(fieldRef);
}
else
{
throw new Exception($"Cannot find '{fieldName}' mapping field. Check '{typeof(FieldAttribute)}'.");
}
}
return(null);
}
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 FieldValueOperator(string operatorName, Guid fieldId, T value, FieldType type)
: base(operatorName, value, type)
{
FieldRef = new CamlFieldRef {
Id = fieldId
};
}
protected FieldValueOperator(string operatorName, string fieldName, T value, FieldType type)
: base(operatorName, value, type)
{
FieldRef = new CamlFieldRef {
Name = fieldName
};
}
protected FieldValueOperator(string operatorName, string fieldName, CamlValue <T> value)
: base(operatorName, value)
{
FieldRef = new CamlFieldRef {
Name = fieldName
};
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if ((node.Method.Name == "IsMembership") && 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);
if (fieldRef == null || FieldValue == null)
{
return(node);
}
Operator = new Membership(fieldRef, (MembershipType)FieldValue);
return(node);
}
throw new NotSupportedException($"{node.NodeType} method is not supported in LinqToSP.");
}
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 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 FieldCamlMultiValue(string operatorName, Guid fieldId, IEnumerable <CamlValue <T> > values)
: base(operatorName, values)
{
FieldRef = new CamlFieldRef {
Id = fieldId
};
}
protected FieldCamlMultiValue(string operatorName, string fieldName, IEnumerable <CamlValue <T> > values)
: base(operatorName, values)
{
FieldRef = new CamlFieldRef {
Name = fieldName
};
}
protected FieldValueOperator(string operatorName, Guid fieldId, CamlValue <T> value)
: base(operatorName, value)
{
FieldRef = new CamlFieldRef {
Id = fieldId
};
}
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 FieldCamlMultiValue(string operatorName, string fieldName, IEnumerable <T> values,
FieldType type)
: base(operatorName, values, type)
{
FieldRef = new CamlFieldRef {
Name = fieldName
};
}
protected FieldCamlMultiValue(string operatorName, Guid fieldId, IEnumerable <T> values,
FieldType type)
: base(operatorName, values, type)
{
FieldRef = new CamlFieldRef {
Id = fieldId
};
}
protected override void OnParsing(XElement existingFieldValueOperator)
{
var existingFieldRef = existingFieldValueOperator.ElementIgnoreCase(CamlFieldRef.FieldRefTag);
if (existingFieldRef != null)
{
FieldRef = new CamlFieldRef(existingFieldRef);
}
}
protected override void OnParsing(XElement existingFieldValueOperator)
{
var existingFieldRef = existingFieldValueOperator.ElementIgnoreCase(CamlFieldRef.FieldRefTag);
if (existingFieldRef != null)
{
FieldRef = new CamlFieldRef(existingFieldRef);
}
}
protected FieldOperator(string operatorName, CamlFieldRef fieldRef)
: base(operatorName)
{
if (fieldRef == null)
{
throw new ArgumentNullException("fieldRef");
}
FieldRef = fieldRef;
}
protected override void OnParsing(XElement existingSingleFieldMultipleValueOperator)
{
var existingValues = existingSingleFieldMultipleValueOperator.ElementIgnoreCase(ValuesTag);
if (existingValues != null)
{
base.OnParsing(existingValues);
}
var existingFieldRef = existingSingleFieldMultipleValueOperator.ElementIgnoreCase(CamlFieldRef.FieldRefTag);
if (existingFieldRef != null)
{
FieldRef = new CamlFieldRef(existingFieldRef);
}
}
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.");
}
public In(CamlFieldRef fieldRef, IEnumerable <CamlValue <object> > values) : base(fieldRef, values)
{
}
public CamlOrderBy(CamlFieldRef fieldRef)
: this(new[] {fieldRef})
{
}
protected FieldValueOperator(string operatorName, CamlFieldRef fieldRef, CamlValue <T> value)
: base(operatorName, value)
{
FieldRef = fieldRef;
}
protected FieldValueOperator(string operatorName, CamlFieldRef fieldRef, T value, FieldType type)
: base(operatorName, value, type)
{
FieldRef = fieldRef;
}
protected FieldCamlMultiValue(string operatorName, CamlFieldRef fieldRef, IEnumerable <CamlValue <T> > values)
: base(operatorName, values)
{
FieldRef = fieldRef;
}
protected FieldCamlMultiValue(string operatorName, CamlFieldRef fieldRef, IEnumerable <T> values,
FieldType type)
: base(operatorName, values, type)
{
FieldRef = fieldRef;
}
public Lt(CamlFieldRef fieldRef, object value, FieldType type)
: base(fieldRef, value, type)
{
}
public Lt(CamlFieldRef fieldRef, CamlValue <object> value) : base(fieldRef, value)
{
}
public IsNotNull(CamlFieldRef fieldRef)
: base(IsNotNullTag, fieldRef)
{
}
public DateRangesOverlap(CamlFieldRef startField, CamlFieldRef endField, CamlFieldRef recurrenceIdField,
CamlValue value)
: base(DateRangesOverlapTag, new[] { startField, endField, recurrenceIdField }, value, FieldType.DateTime)
{
}
public IsNotNull(CamlFieldRef fieldRef)
: base(IsNotNullTag, fieldRef)
{
}
public Contains(CamlFieldRef fieldRef, CamlValue <string> value)
: base(fieldRef, value)
{
}
public Contains(CamlFieldRef fieldRef, string value)
: base(fieldRef, value, FieldType.Text)
{
}
public CamlGroupBy(CamlFieldRef fieldRef, bool? collapse = null, int? limit = 30)
: this(new[] { fieldRef }, collapse, limit)
{
}
public In(CamlFieldRef fieldRef, IEnumerable <object> values, FieldType type)
: base(fieldRef, values, type)
{
}
protected FieldOperator(string operatorName, CamlFieldRef fieldRef)
: base(operatorName)
{
if (fieldRef == null) throw new ArgumentNullException(nameof(fieldRef));
FieldRef = fieldRef;
}
public Membership(CamlFieldRef fieldRef, MembershipType membershipType)
: base(MembershipTag, fieldRef)
{
MembershipType = membershipType;
}