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