/// <summary> /// Gets all variation labels in a site collection. This method is safe when called in console. /// </summary> /// <param name="publishingSite">Site collection.</param> /// <param name="includePending">Whether to return pending variation labels.</param> /// <returns>A read-only collection of all variation labels.</returns> public static ReadOnlyCollection <VariationLabel> GetVariationLabels(this PublishingSite publishingSite, bool includePending) { if (GetVariationLabelMethod == null) { throw new MissingMethodException("GetVariationLabel"); } List <VariationLabel> collection = new List <VariationLabel>(); publishingSite.Site.WithElevatedPrivileges(elevatedSite => { string variationsListId = (string)elevatedSite.RootWeb.AllProperties["_VarLabelsListId"]; if (!String.IsNullOrEmpty(variationsListId)) { SPList variationsList = elevatedSite.RootWeb.Lists[new Guid(variationsListId)]; CamlExpression queryExpr = Caml.IsNotNull(SPBuiltInFieldName.Title); if (!includePending) { queryExpr &= Caml.IsNotNull("Top_x0020_Web_x0020_URL"); } SPQuery query = new SPQuery { Query = queryExpr.ToString() }; foreach (SPListItem listItem in variationsList.GetItems(query)) { VariationLabel label = GetVariationLabelMethod.Invoke <VariationLabel>(null, listItem); collection.Add(label); } } }); return(collection.AsReadOnly()); }
public CamlExpression GetContentTypeExpression(SPModelDescriptor other) { CommonHelper.ConfirmNotNull(other, "other"); IEnumerable <SPContentTypeId> contentTypeIds = this == other ? this.ContentTypeIds : IntersectContentTypeIds(this.ContentTypeIds.ToArray(), other.ContentTypeIds.ToArray()); return(contentTypeIds.Aggregate(Caml.False, (v, a) => v | Caml.OfContentType(a))); }
private int GetLookupIdByValue(string fieldName, object value) { SPField lookupField = GetLookupField(fieldName); string cacheKey = String.Concat("LookupValue-", this.ListId, "-", fieldName); Dictionary <string, int> dict = this.ObjectCache[cacheKey] as Dictionary <string, int>; if (this.ObjectCache[cacheKey] == null) { this.ObjectCache[cacheKey] = dict = new Dictionary <string, int>(); } ICamlParameterBinding binding = CamlParameterBinding.GetValueBinding(this.Site, lookupField, value); string lookupValue = binding.Bind(CamlExpression.EmptyBindings); int lookupId; if (dict.TryGetValue(lookupValue, out lookupId)) { if (lookupId == 0) { throw new ArgumentOutOfRangeException("value"); } return(lookupId); } if (lookupField.ParentList.ItemCount == 0) { throw new ArgumentOutOfRangeException("value"); } if (dict.Count == 0 && lookupField.ParentList.ItemCount < 1000) { foreach (SPListItem item in lookupField.ParentList.GetItems(lookupField.InternalName)) { ICamlParameterBinding b1 = CamlParameterBinding.GetValueBinding(this.Site, lookupField, item[lookupField.Id]); dict[b1.Bind(CamlExpression.EmptyBindings)] = item.ID; } if (dict.TryGetValue(lookupValue, out lookupId)) { return(lookupId); } throw new ArgumentOutOfRangeException("value"); } SPQuery query = new SPQuery(); query.ViewFields = Caml.ViewFields(SPBuiltInFieldName.ID).ToString(); query.Query = Caml.Equals(lookupField.InternalName, binding).ToString(); query.RowLimit = 1; SPListItemCollection collection = lookupField.ParentList.GetItems(query); if (collection.Count > 0) { dict[lookupValue] = collection[0].ID; return(collection[0].ID); } dict[lookupValue] = 0; throw new ArgumentOutOfRangeException("value"); }
private CamlExpression UpdateExpression(CamlExpression expression, CamlParameterBindingFieldRef field, bool equals) { ICollection <int> ids = GetDeletedTermIDs(); if (ids.Count == 0) { return(expression); } CamlExpression constraint = Caml.LookupIdEqualsAny(field, ids); return(equals ? expression | constraint : expression& ~constraint); }
internal IEnumerable <T> TryGetCachedModel <T>(ISPListItemAdapter source, string fieldName, params int[] lookupIds) { List <T> collection = new List <T>(); SPObjectCache cache = this.Manager.ObjectCache; SPFieldLookup lookupField = cache.GetField(source.WebId, source.ListId, fieldName) as SPFieldLookup; if (lookupField != null) { if (hashtable == null) { hashtable = new Hashtable(); } Guid listId = lookupField.LookupList == "Self" ? source.ListId : new Guid(lookupField.LookupList); List <int> lookupIdsToQuery = new List <int>(); foreach (int id in lookupIds) { LookupKey key = new LookupKey(listId, id); if (hashtable.ContainsKey(key)) { object cachedItem = hashtable[key]; if (cachedItem is T) { collection.Add((T)cachedItem); } } else { lookupIdsToQuery.Add(id); } } if (lookupIdsToQuery.Count > 0) { ISPModelManagerInternal manager = hashtable.EnsureKeyValue(typeof(T), () => (ISPModelManagerInternal)SPModel.GetDefaultManager(typeof(T), this.manager.Site.RootWeb, cache)); SPList list = cache.GetList(lookupField.LookupWebId, listId); SPQuery query = new SPQuery { Query = Caml.EqualsAny(SPBuiltInFieldName.ID, lookupIdsToQuery).ToString() }; foreach (SPListItem item in list.GetItems(query)) { object model = manager.TryCreateModel(new SPListItemAdapter(item, cache), false); hashtable[new LookupKey(listId, item.ID)] = model; if (model is T) { collection.Add((T)model); } cache.AddListItem(item); } } } return(collection); }
public CamlExpression GetContentTypeExpression(SPModelDescriptor other) { CommonHelper.ConfirmNotNull(other, "other"); CamlExpression expression = Caml.False; foreach (SPContentTypeId contentTypeId in this.ContentTypeIds) { if (other == this || other.ContentTypeIds.Any(v => v.IsParentOf(contentTypeId))) { expression |= Caml.OfContentType(contentTypeId); } } return(expression); }
private ListItem GetListItemByUri(string uri, DocLibContext context) { CamlQuery query = new CamlQuery(); query.ViewXml = Caml.SimpleView(Caml.Field("FileRef").Eq(Caml.Value("Text", uri)), CamlBuilder.ViewType.RecursiveAll).ToCamlString(); ListItemCollection itemCollection = context.BaseList.GetItems(query); context.Load(itemCollection); context.ExecuteQuery(); if (itemCollection.Count == 0) { return(null); } return(itemCollection[0]); }
public DCTFolder DCMGetFolderByUri(string uri) { using (DocLibContext clientContext = new DocLibContext(ServiceHelper.GetDocumentLibraryName())) { Folder folder = clientContext.Web.GetFolderByServerRelativeUrl(uri); clientContext.Load(folder); CamlQuery query = new CamlQuery(); query.ViewXml = Caml.SimpleView(Caml.Field("FileRef").Eq(Caml.Value("Text", uri)), CamlBuilder.ViewType.RecursiveAll).ToCamlString(); ListItemCollection items = clientContext.BaseList.GetItems(query); clientContext.Load(items); DCTFolder result; try { clientContext.ExecuteQuery(); if (string.Compare(folder.ServerRelativeUrl, this.DCMGetRootFolder().Uri, true) == 0) { result = new DCTFolder() { ID = 0, IsRootFolder = true } } ; else { result = new DCTFolder() { ID = items[0].Id, IsRootFolder = false } }; DCTConverterHelper.Convert(folder, result); } catch { result = null; } return(result); } }
private static ListItem GetListItemById(int id, DocLibContext clientContext) { List list = clientContext.BaseList; CamlQuery query = new CamlQuery(); Caml caml = Caml.SimpleView(Caml.Field("ID").Eq(Caml.Value("Counter", id.ToString())), CamlBuilder.ViewType.RecursiveAll); query.ViewXml = caml.ToCamlString(); ListItemCollection items = list.GetItems(query); clientContext.Load(items); clientContext.ExecuteQuery(); if (items.Count == 0) { return(null); } return(items[0]); }
private CamlExpression HandleNullExpression(SPModelQueryFieldInfo field, bool negate) { CamlExpression expression = Caml.IsNull(field.FieldRef); if (field.FieldTypeAsString == "TaxonomyFieldType" || field.FieldTypeAsString == "TaxonomyFieldTypeMulti") { SPList taxonomyHiddenList = SPExtensionHelper.GetTaxonomyHiddenList(manager.Site); foreach (SPListItem item in taxonomyHiddenList.GetItems("IdForTerm")) { if (manager.TermStore.GetTerm(new Guid((string)item["IdForTerm"])) == null) { expression |= Caml.LookupIdEquals(field.FieldRef, item.ID); } } } if (negate) { return(~expression); } return(expression); }
private ICollection <int> GetDeletedTermIDs() { if (deletedTerms == null) { deletedTerms = new List <int>(); SPList taxonomyHiddenList = SPExtensionHelper.GetTaxonomyHiddenList(manager.Site); TermStore termStore = manager.TermStore; SPQuery query = new SPQuery { Query = Caml.Equals("IdForTermStore", termStore.Id.ToString()).ToString(), ViewFields = Caml.ViewFields("IdForTerm").ToString() }; foreach (SPListItem item in taxonomyHiddenList.GetItems(query)) { if (termStore.GetTerm(new Guid((string)item["IdForTerm"])) == null) { deletedTerms.Add(item.ID); } } } return(deletedTerms); }
public DCTFolder DCMGetParentFolder(DCTStorageObject storageObject) { using (DocLibContext clientContext = new DocLibContext(ServiceHelper.GetDocumentLibraryName())) { ListItem listItem = LoadItem(storageObject, clientContext); (listItem == null).TrueThrow <ArgumentException>("无法找到文件夹,传入的为根目录或文件、文件夹不存在。"); DCTFolder folder = null; clientContext.Load(clientContext.BaseList.RootFolder); clientContext.ExecuteQuery(); if (string.Compare(listItem.FieldValues["FileDirRef"].ToString(), clientContext.BaseList.RootFolder.ServerRelativeUrl, true) == 0) { folder = new DCTFolder() { ID = 0, IsRootFolder = true }; DCTConverterHelper.Convert(clientContext.BaseList.RootFolder, folder); } else { CamlQuery query = new CamlQuery(); query.ViewXml = Caml.SimpleView(Caml.Field("ServerUrl").Eq(Caml.Value("Text", listItem.FieldValues["FileDirRef"].ToString())), CamlBuilder.ViewType.RecursiveAll).ToCamlString(); ListItemCollection parentListItem = clientContext.BaseList.GetItems(query); clientContext.Load(parentListItem); clientContext.ExecuteQuery(); folder = new DCTFolder(); DCTConverterHelper.Convert(parentListItem[0], folder); } return(folder); } }
/// <summary> /// Called when visiting a logical comparison expression inside a <Where/> element. /// </summary> /// <param name="expression">An instance of the <see cref="CamlWhereLogicalExpression"/> class representing the logical comparison expression.</param> /// <returns>When overriden, returns an expression to replace the expression given in arguments.</returns> protected virtual CamlExpression VisitWhereLogicalExpression(CamlWhereLogicalExpression expression) { CommonHelper.ConfirmNotNull(expression, "expression"); CamlExpression l = VisitChecked(expression.Left, CamlExpressionType.Where); CamlExpression r = VisitChecked(expression.Right, CamlExpressionType.Where); if (l != expression.Left || r != expression.Right) { switch (expression.Operator) { case CamlLogicalOperator.And: return(Caml.And(l, r)); case CamlLogicalOperator.Or: return(Caml.Or(l, r)); case CamlLogicalOperator.Not: return(Caml.Not(l)); } throw new InvalidOperationException(); } return(expression); }
public DCTFolder DCMCreateFolder(string name, DCTFolder parentFolder) { DCTFolder folder = new DCTFolder(); using (DocLibContext clientContext = new DocLibContext(ServiceHelper.GetDocumentLibraryName())) { Folder cOMParentFolder = clientContext.Web.GetFolderByServerRelativeUrl(LoadUri(parentFolder, clientContext)); if (cOMParentFolder != null) { cOMParentFolder.Folders.Add(UriHelper.CombinePath(parentFolder.Uri, name)); } clientContext.ExecuteQuery(); CamlQuery query = new CamlQuery() { FolderServerRelativeUrl = parentFolder.Uri }; query.ViewXml = Caml.SimpleView(Caml.Field("ServerUrl").Eq(Caml.Value("Text", (parentFolder.Uri[parentFolder.Uri.Length - 1] != '/' ? parentFolder.Uri + "/" : parentFolder.Uri) + name)), CamlBuilder.ViewType.Default).ToCamlString(); ListItemCollection items = clientContext.BaseList.GetItems(query); clientContext.Load(items); clientContext.ExecuteQuery(); if (items.Count != 0) { folder.AbsoluteUri = UriHelper.CombinePath(parentFolder.AbsoluteUri, name); folder.Name = name; folder.Uri = UriHelper.CombinePath(parentFolder.Uri, name); folder.IsRootFolder = false; folder.ID = items[0].Id; } } return(folder); }
public BaseCollection <DCTStorageObject> DCMGetChildren(DCTFolder folder, DCTContentType contentType) { BaseCollection <DCTStorageObject> childs = new BaseCollection <DCTStorageObject>(); BaseCollection <DCTFile> childFiles = new BaseCollection <DCTFile>(); BaseCollection <DCTFolder> childFolders = new BaseCollection <DCTFolder>(); using (DocLibContext clientContext = new DocLibContext(ServiceHelper.GetDocumentLibraryName())) { Folder clientOMFolder = clientContext.Web.GetFolderByServerRelativeUrl(folder.Uri); CamlQuery query = new CamlQuery(); query.FolderServerRelativeUrl = LoadUri(folder, clientContext); query.ViewXml = Caml.SimpleView(Caml.EmptyCaml(), CamlBuilder.ViewType.Default).ToCamlString(); ListItemCollection items = clientContext.BaseList.GetItems(query); clientContext.Load(items); clientContext.ExecuteQuery(); foreach (ListItem item in items) { switch (item.FileSystemObjectType) { case FileSystemObjectType.File: if ((contentType & DCTContentType.File) != DCTContentType.None) { DCTFile itemFile = new DCTFile(); DCTConverterHelper.Convert(item, itemFile); childs.Add(itemFile); //childFiles.Add(itemFile); } break; case FileSystemObjectType.Folder: if ((contentType & DCTContentType.Folder) != DCTContentType.None) { DCTFolder itemFolder = new DCTFolder(); DCTConverterHelper.Convert(item, itemFolder); childs.Add(itemFolder); //childFolders.Add(itemFolder); } break; case FileSystemObjectType.Invalid: break; case FileSystemObjectType.Web: break; default: break; } } } foreach (DCTFolder item in childFolders) { childs.Add(item); } foreach (DCTFile item in childFiles) { childs.Add(item); } return(childs); }
/// <summary> /// Gets a list item of model type <typeparamref name="T"/> with the specified list item ID. /// </summary> /// <typeparam name="T">Model type.</typeparam> /// <param name="manager">A model manager instance.</param> /// <param name="id">List item ID.</param> /// <returns>A list item; or *null* if there is no list item with the specified ID.</returns> public static T GetItemByID <T>(this SPModelManager <T> manager, int id) { return(manager.GetItems(Caml.Equals(SPBuiltInFieldName.ID, id), 1u).FirstOrDefault()); }
/// <summary> /// Gets a list item of model type <typeparamref name="T"/> with the specified unique ID. /// </summary> /// <typeparam name="T">Model type.</typeparam> /// <param name="manager">A model manager instance.</param> /// <param name="uniqueId">Unique ID.</param> /// <returns>A list item; or *null* if there is no list item with the specified unique ID.</returns> public static T GetItemByUniqueId <T>(this SPModelManager <T> manager, Guid uniqueId) { return(manager.GetItems(Caml.Equals(SPBuiltInFieldName.UniqueId, uniqueId), 1u).FirstOrDefault()); }
private SPModelParameterizedQuery(ParameterizedExpression expression, ISPModelManagerInternal manager) { SPModelQueryBuilder builder = SPModelQueryExpressionVisitor.Translate(expression, manager); this.Descriptor = builder.ModelType != null?SPModelDescriptor.Resolve(builder.ModelType) : manager.Descriptor; this.Expression = builder.Expression; this.TaxonomyFields = new ReadOnlyCollection <string>(builder.TaxonomyFields.ToArray()); this.expression = expression; this.executeMode = builder.ExecuteMode; this.emptyArray = Array.CreateInstance(this.Descriptor.ModelType, 0); if (builder.SelectExpression != null) { this.projector = ((Expression <ResultEvaluator>)builder.SelectExpression).Compile(); } else { this.projector = (ResultEvaluator)Delegate.CreateDelegate(typeof(ResultEvaluator), mOfType.MakeGenericMethod(this.Descriptor.ModelType)); } this.evaluators = new ReadOnlyDictionary <string, ParameterEvaluator>(builder.ParameterEvaluators); for (int i = 0; i < PIndexMax; i++) { parameterNames[i] = (string)builder.Parameters[i]; } if (builder.ModelType != null) { this.ContentTypeFilterExpression = builder.ContentTypeIds.Aggregate(Caml.False, (v, a) => v | Caml.OfContentType(a)); } if (!builder.SelectAllProperties) { List <string> properties = new List <string>(builder.SelectProperties); if (!properties.Contains(SPBuiltInFieldName.ContentTypeId)) { properties.Add(SPBuiltInFieldName.ContentTypeId); } this.SelectProperties = new ReadOnlyCollection <string>(properties); } }
public CamlableVisitor() { _caml = new Caml <T>(); }
private CamlExpression GetExpressionFromQueryableMethod(MethodCallExpression expression) { int argCount = expression.Arguments.Count; if (argCount > 1) { LambdaExpression lamdba = StripQuotes(expression.Arguments[1]) as LambdaExpression; if (lamdba != null) { lambdaParam = lamdba.Parameters[0]; } } switch (expression.Method.Name) { case "Count": case "Any": case "FirstOrDefault": case "First": case "SingleOrDefault": case "Single": if (argCount == 2) { Visit(expression.Arguments[1]); } builder.ExecuteMode = Enum <SPModelQueryExecuteMode> .Parse(expression.Method.Name); AppendSelectExpression(expression, builder.ExecuteMode.ToString(), true); return(currentScope.Expression); case "All": Visit(expression.Arguments[1]); builder.ExecuteMode = SPModelQueryExecuteMode.Any; AppendSelectExpression(expression, builder.ExecuteMode.ToString(), true); return(~currentScope.Expression); case "ElementAtOrDefault": case "ElementAt": Visit(expression.Arguments[1]); builder.Parameters[SPModelParameterizedQuery.PIndexOffset] = currentScope.ParameterName; builder.ExecuteMode = expression.Method.Name == "ElementAt" ? SPModelQueryExecuteMode.First : SPModelQueryExecuteMode.FirstOrDefault; AppendSelectExpression(expression, builder.ExecuteMode.ToString(), true, Expression.Constant(0)); return(Caml.Empty); case "Aggregate": case "Average": case "Max": case "Min": case "Sum": case "Select": case "SelectMany": AppendSelectExpression(expression); return(Caml.Empty); case "Take": Visit(expression.Arguments[1]); builder.Parameters[SPModelParameterizedQuery.PIndexLimit] = currentScope.ParameterName; return(Caml.Empty); case "Skip": Visit(expression.Arguments[1]); builder.Parameters[SPModelParameterizedQuery.PIndexOffset] = currentScope.ParameterName; return(Caml.Empty); case "OrderBy": case "ThenBy": case "OrderByDescending": case "ThenByDescending": CamlOrder dir = expression.Method.Name.Contains("Descending") ? CamlOrder.Descending : CamlOrder.Ascending; Visit(expression.Arguments[1]); return(this.currentScope.GetExpression(s => Caml.OrderBy(s.FieldRef, dir), true)); case "Where": Visit(expression.Arguments[1]); return(currentScope.Expression); case "OfType": if (builder.SelectExpression != null) { AppendSelectExpression(expression); } else { if (builder.ModelType == null) { builder.ContentTypeIds.AddRange(manager.Descriptor.ContentTypeIds); } builder.ModelType = expression.Method.GetGenericArguments()[0]; SPModelDescriptor descriptor; try { descriptor = SPModelDescriptor.Resolve(builder.ModelType); } catch (ArgumentException) { throw new NotSupportedException("'OfType' constraint must be used with valid model type or interface type"); } SPContentTypeId[] result = SPModelDescriptor.IntersectContentTypeIds(builder.ContentTypeIds, descriptor.ContentTypeIds.ToArray()); builder.ContentTypeIds.Clear(); builder.ContentTypeIds.AddRange(result); } return(Caml.Empty); } throw ThrowMethodNotSupported(expression.Method); }
protected override Expression VisitMemberAccess(MemberExpression expression) { if (invariantExpression) { return(base.VisitMemberAccess(expression)); } if (expression.Expression != lambdaParam) { if (expression.Member.DeclaringType == typeof(ISPModelMetaData) && ((expression.Expression.NodeType == ExpressionType.Call && ((MethodCallExpression)expression.Expression).Method == typeof(SPModelExtension).GetMethod("GetMetaData") && ((MethodCallExpression)expression.Expression).Arguments[0] == lambdaParam) || (expression.Expression.NodeType == ExpressionType.Convert && ((UnaryExpression)expression.Expression).Operand == lambdaParam))) { // allow non-direct field access on the ISPModelMetaData interface } else { Expression result = base.VisitMemberAccess(expression); if (expression.Member.DeclaringType.IsGenericType && expression.Member.DeclaringType.GetGenericTypeDefinition() == typeof(Nullable <>) && expression.Member.Name == "HasValue") { CamlExpression expr = currentScope.GetExpression(v => Caml.IsNotNull(v.FieldRef)); currentScope.Reset(); currentScope.Expression = expr; } return(result); } } currentScope.MemberType = expression.Type; currentScope.Member = expression.Member; currentScope.Field = default(SPModelQueryFieldInfo); currentScope.FieldAssociations = null; if (expression.Member.DeclaringType == typeof(ISPModelMetaData)) { switch (expression.Member.Name) { case "ID": currentScope.Field = SPModelQueryFieldInfo.ID; break; case "UniqueId": currentScope.Field = SPModelQueryFieldInfo.UniqueId; break; case "FileRef": currentScope.Field = SPModelQueryFieldInfo.FileRef; break; case "FileLeafRef": currentScope.Field = SPModelQueryFieldInfo.FileLeafRef; break; case "LastModified": currentScope.Field = SPModelQueryFieldInfo.LastModified; break; case "CheckOutUserID": currentScope.Field = SPModelQueryFieldInfo.CheckOutUserID; break; default: throw new NotSupportedException(String.Format("Member '{0}' is not supported", GetMemberFullName(expression.Member))); } } else { currentScope.FieldAssociations = SPModelFieldAssociationCollection.GetByMember(expression.Member); foreach (SPFieldAttribute field in currentScope.FieldAssociations.Fields) { if (field.TypeAsString == "TaxonomyFieldType" || field.TypeAsString == "TaxonomyFieldTypeMulti") { builder.TaxonomyFields.Add(field.ListFieldInternalName); } } } if (builder.SelectExpression != null) { if (currentScope.Field.FieldRef != null) { builder.AddSelectProperty(currentScope.Field.FieldRef); } else if (currentScope.FieldAssociations.Queryable && expression.Member.MemberType == MemberTypes.Property && ((PropertyInfo)expression.Member).GetGetMethod().IsAbstract) { builder.AddSelectProperty(currentScope.FieldAssociations.Fields.First().ListFieldInternalName); } else { builder.SelectAllProperties = true; } } return(expression); }
protected override Expression VisitMethodCall(MethodCallExpression expression) { SPModelQueryExpressionScope currentScope = stack.Peek(); SPModelQueryExpressionScope childScope = new SPModelQueryExpressionScope(this); stack.Push(childScope); if (expression.Method.DeclaringType == typeof(Queryable)) { Visit(expression.Arguments[0]); currentScope.Expression = childScope.Expression; childScope.Reset(); switch (expression.Method.Name) { case "Where": if (expression.Arguments.Count == 3) { throw new NotSupportedException(String.Format("The method '{0}' with element's index used in the logic is not supported", expression.Method.Name)); } Visit(expression.Arguments[1]); currentScope.Expression += childScope.Expression; break; case "Union": if (expression.Arguments.Count == 3) { throw new NotSupportedException(String.Format("The method '{0}' with element's index used in the logic is not supported", expression.Method.Name)); } Visit(expression.Arguments[1]); currentScope.Expression |= childScope.Expression; break; case "Count": result.ExecuteMode = Enum <SPModelQueryExecuteMode> .Parse(expression.Method.Name); if (expression.Arguments.Count > 1) { Visit(expression.Arguments[1]); currentScope.Expression += childScope.Expression; } break; case "All": case "Any": case "FirstOrDefault": case "First": case "SingleOrDefault": case "Single": case "ElementAtOrDefault": case "ElementAt": result.ExecuteMode = Enum <SPModelQueryExecuteMode> .Parse(expression.Method.Name); if (result.ExecuteMode == SPModelQueryExecuteMode.ElementAt || result.ExecuteMode == SPModelQueryExecuteMode.ElementAtOrDefault) { result.Limit += Math.Max(0, Convert.ToInt32(((ConstantExpression)expression.Arguments[1]).Value)); } else if (result.ExecuteMode == SPModelQueryExecuteMode.Single || result.ExecuteMode == SPModelQueryExecuteMode.SingleOrDefault) { result.Limit = 2; } else { result.Limit = 1; } if (expression.Arguments.Count > 1) { Visit(expression.Arguments[1]); currentScope.Expression += childScope.Expression; } break; case "Take": result.Limit = Math.Max(0, Convert.ToInt32(((ConstantExpression)expression.Arguments[1]).Value)); break; case "Skip": result.Offset = Math.Max(0, Convert.ToInt32(((ConstantExpression)expression.Arguments[1]).Value)); break; case "OrderBy": case "ThenBy": if (expression.Arguments.Count == 3) { throw new NotSupportedException(String.Format("The method '{0}' with specified comparer is not supported", expression.Method.Name)); } Visit(expression.Arguments[1]); currentScope.Expression += childScope.GetExpression(s => Caml.OrderByAscending(s.FieldRef), true); break; case "OrderByDescending": case "ThenByDescending": if (expression.Arguments.Count == 3) { throw new NotSupportedException(String.Format("The method '{0}' with specified comparer is not supported", expression.Method.Name)); } Visit(expression.Arguments[1]); currentScope.Expression += childScope.GetExpression(s => Caml.OrderByDescending(s.FieldRef), true); break; case "Select": result.SelectExpression = (LambdaExpression)StripQuotes(expression.Arguments[1]); break; case "OfType": result.ModelType = expression.Method.GetGenericArguments()[0]; break; default: throw new NotSupportedException(String.Format("The method '{0}' is not supported", expression.Method.Name)); } } else if (expression.Method.DeclaringType == typeof(Enumerable)) { switch (expression.Method.Name) { case "Contains": if (expression.Arguments.Count == 3) { throw new NotSupportedException(String.Format("The method '{0}' with specified comparer is not supported", expression.Method.Name)); } Visit(expression.Arguments[0]); Visit(expression.Arguments[1]); if (childScope.Value is IEnumerable) { if (((IEnumerable)childScope.Value).OfType <object>().Any()) { currentScope.Expression = childScope.GetExpression(Caml.EqualsAny); } else { currentScope.Expression = CamlExpression.False; } } else { currentScope.Expression = childScope.GetExpression(Caml.Includes); } break; default: throw new NotSupportedException(String.Format("The method '{0}' is not supported", expression.Method.Name)); } } else if (expression.Method.DeclaringType == typeof(String)) { Visit(expression.Object); switch (expression.Method.Name) { case "StartsWith": Visit(expression.Arguments[0]); currentScope.Expression = childScope.GetExpression(s => Caml.BeginsWith(s.FieldRef, (childScope.Value ?? String.Empty).ToString())); break; default: throw new NotSupportedException(String.Format("The method '{0}' is not supported", expression.Method.Name)); } } else if (expression.Method.DeclaringType.IsOf(typeof(ICollection <>))) { switch (expression.Method.Name) { case "Contains": Visit(expression.Object); Visit(expression.Arguments[0]); if (childScope.Value is IEnumerable) { if (((IEnumerable)childScope.Value).OfType <object>().Any()) { currentScope.Expression = childScope.GetExpression(Caml.EqualsAny); } else { currentScope.Expression = CamlExpression.False; } } else { currentScope.Expression = childScope.GetExpression(Caml.Includes); } break; default: throw new NotSupportedException(String.Format("The method '{0}' is not supported", expression.Method.Name)); } } else if (expression.Method.Name == "Equals" && expression.Arguments.Count == 1) { Visit(expression.Object); Visit(expression.Arguments[0]); currentScope.Expression = childScope.GetExpression((SPModelQueryExpressionScope.ExpressionGenerator)Caml.Equals); } else { throw new NotSupportedException(String.Format("The method '{0}' is not supported", expression.Method.Name)); } stack.Pop(); return(expression); }
public BaseCollection <DCTFile> DCMQueryDocByField(BaseCollection <DCTFileField> fields) { BaseCollection <DCTFile> files = new BaseCollection <DCTFile>(); using (DocLibContext clientContext = new DocLibContext(ServiceHelper.GetDocumentLibraryName())) { CamlQuery query = new CamlQuery(); CamlExpression caml = null; foreach (DCTFileField item in fields) { string valueText = string.Empty; switch (item.Field.ValueType) { case DCTFieldType.Boolean: break; case DCTFieldType.DateTime: break; case DCTFieldType.Decimal: break; case DCTFieldType.Integer: valueText = "Counter"; break; case DCTFieldType.Note: break; case DCTFieldType.Text: valueText = "Text"; break; case DCTFieldType.User: break; default: break; } if (caml == null) { caml = Caml.Field(item.Field.InternalName).Eq(Caml.Value(valueText, item.FieldValue)); } else { caml = caml.And(Caml.Field(item.Field.InternalName).Eq(Caml.Value(valueText, item.FieldValue))); } } query.ViewXml = Caml.SimpleView(caml, CamlBuilder.ViewType.RecursiveAll).ToCamlString(); ListItemCollection items = clientContext.BaseList.GetItems(query); clientContext.Load(items); clientContext.ExecuteQuery(); foreach (ListItem item in items) { DCTFile file = new DCTFile(); DCTConverterHelper.Convert(item, file); files.Add(file); } } return(files); }