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