public SPModelQueryExpressionVisitor(ISPModelManagerInternal manager, string[] allowedFields)
{
CommonHelper.ConfirmNotNull(manager, "manager");
this.manager = manager;
this.allowedFields = allowedFields;
this.result.Limit = (int)manager.Site.WebApplication.MaxItemsPerThrottledOperation;
}
protected void ResolveManager()
{
SPModelDescriptor.RegisterReferencedAssemblies(this.Web.Read().Site);
this.Descriptor = SPModelDescriptor.Resolve(this.TypeName);
this.Manager = this.Descriptor.CreateManager(this.Web.Read());
OnManagerResolved();
}
private SPModelParameterizedQuery BindParameters(object[] args, ISPModelManagerInternal manager)
{
CamlParameterBindingHashtable hashtable = new CamlParameterBindingHashtable(manager);
for (int i = 0, count = args.Length; i < count; i++)
{
hashtable[expression.Parameters[i].Name] = args[i];
}
foreach (KeyValuePair <string, ParameterEvaluator> item in evaluators)
{
hashtable[item.Key] = item.Value(args);
}
SPModelParameterizedQuery other = (SPModelParameterizedQuery)MemberwiseClone();
other.Expression = other.Expression.Bind(hashtable);
other.ContentTypeFilterExpression = null;
other.args = args;
other.Manager = manager;
if (parameterNames[PIndexOffset] != null)
{
other.Offset = Convert.ToInt32(hashtable[parameterNames[PIndexOffset]]);
}
if (parameterNames[PIndexLimit] != null)
{
other.Limit = Convert.ToInt32(hashtable[parameterNames[PIndexLimit]]);
}
return(other);
}
/// <summary>
/// Gets the default manager instantiated with the specified site and an existing SharePoint object cache.
/// Actual type of the created manager can be set through <see cref="SPModelManagerDefaultTypeAttribute"/> on the model type.
/// If there is no <see cref="SPModelManagerDefaultTypeAttribute"/> specified, an <see cref="SPModelManager{T}"/> object is instantiated with <paramref name="type"/>.
/// </summary>
/// <param name="type">Model type.</param>
/// <param name="contextWeb">A site object.</param>
/// <param name="cache">An instance of SharePoint object cache.</param>
/// <returns>A manager object.</returns>
public static ISPModelManager GetDefaultManager(Type type, SPWeb contextWeb, SPObjectCache cache)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(type);
ISPModelManagerInternal manager = descriptor.CreateManager(contextWeb);
manager.ObjectCache = cache;
return(manager);
}
internal SPModelEventArgs(SPModelEventType eventType, SPModel model, ISPListItemAdapter previousAdapter, SPItemEventProperties properties)
{
CommonHelper.ConfirmNotNull(model, "model");
CommonHelper.ConfirmNotNull(properties, "properties");
this.properties = properties;
this.previousAdapter = previousAdapter;
this.manager = model.ParentCollection.Manager;
this.eventType = eventType;
}
public static SPModelParameterizedQuery Create(Expression expression, ISPModelManagerInternal manager)
{
CommonHelper.ConfirmNotNull(expression, "expression");
CommonHelper.ConfirmNotNull(manager, "manager");
object[] args;
ParameterizedExpression pq = ParameterizedExpression.Create(expression, out args);
SPModelParameterizedQuery cached = cache.GetInstance(pq, p => new SPModelParameterizedQuery(pq, manager));
return(cached.BindParameters(args, manager));
}
public SPModelQuery(ISPModelManagerInternal manager, Type modelType, CamlExpression expression, int limit, int startRow)
{
CommonHelper.ConfirmNotNull(manager, "manager");
CommonHelper.ConfirmNotNull(modelType, "modelType");
this.Manager = manager;
this.Descriptor = SPModelDescriptor.Resolve(modelType);
this.ContentTypeFilterExpression = manager.Descriptor.GetContentTypeExpression(this.descriptor);
this.Expression = expression;
this.Offset = startRow;
this.Limit = limit;
}
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);
}
CacheDependency ISiteConfigProvider.GetCacheDependency()
{
ISPModelManagerInternal manager = this.manager;
foreach (SPModelUsage usage in manager.ContextLists)
{
SPList list = usage.EnsureList(manager.ObjectCache).List;
if (list != null)
{
return(new SPListCacheDependency(list));
}
}
return(null);
}
public SPModelQueryExpressionTranslateResult Translate(Expression expression)
{
string[] allowedFields = null;
ISPModelManagerInternal manager = this.manager;
if (!useOfficeSearch && manager.ImplicitQueryMode == SPModelImplicitQueryMode.ListQuery)
{
SPList targetList = manager.ContextLists.First().EnsureList(manager.ObjectCache).List;
if (targetList != null)
{
allowedFields = targetList.Fields.OfType <SPField>().Select(v => v.InternalName).ToArray();
}
}
return(new SPModelQueryExpressionVisitor(manager, allowedFields).Translate(expression));
}
/// <summary>
/// Creates a model object representing the list item.
/// </summary>
/// <param name="adapter">A data access adapter of the list item.</param>
/// <returns>A model object or *null* if there is no types associated with the content type of the list item.</returns>
public static SPModel TryCreate(ISPListItemAdapter adapter)
{
CommonHelper.ConfirmNotNull(adapter, "adapter");
SPContentTypeId contentTypeId;
try {
contentTypeId = adapter.ContentTypeId;
} catch (MemberAccessException) {
return(null);
}
SPModelDescriptor descriptor;
try {
descriptor = SPModelDescriptor.Resolve(contentTypeId, adapter.Site);
} catch (ArgumentException) {
return(null);
}
ISPModelManagerInternal manager = descriptor.CreateManager(adapter.Web);
return(manager.TryCreateModel(adapter, false));
}
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 CamlParameterBindingHashtable(ISPModelManager manager)
{
CommonHelper.ConfirmNotNull(manager, "manager");
this.manager = (ISPModelManagerInternal)manager;
}
public SPModelQuery(ISPModelManagerInternal manager)
: this(CommonHelper.ConfirmNotNull(manager, "manager"), manager.Descriptor.ModelType, Caml.Empty, 0, 0)
{
}
private SPModelQueryExpressionVisitor(ISPModelManagerInternal manager, ReadOnlyCollection <ParameterExpression> parameters)
{
this.manager = manager;
this.parameters = parameters;
this.currentScope = new SPModelQueryExpressionScope(this);
}
public SPModelQueryProvider(ISPModelManagerInternal manager)
{
CommonHelper.ConfirmNotNull(manager, "manager");
this.manager = manager;
}
protected override void Initialize(SPModelQuery query)
{
this.manager = query.Manager;
this.transformFields = ((SPModelParameterizedQuery)query).TaxonomyFields;
}
public static SPModelQueryBuilder Translate(ParameterizedExpression expression, ISPModelManagerInternal manager)
{
CommonHelper.ConfirmNotNull(manager, "manager");
CommonHelper.ConfirmNotNull(expression, "expression");
SPModelQueryExpressionVisitor visitor = new SPModelQueryExpressionVisitor(manager, expression.Parameters);
visitor.Visit(expression);
return(visitor.builder);
}
public SPModelQueryProvider(ISPModelManagerInternal manager, string[] keywords, KeywordInclusion keywordInclusion)
: this(manager) {
this.useOfficeSearch = true;
this.keywords = keywords;
this.keywordInclusion = keywordInclusion;
}
internal SPModelCollection(ISPModelManagerInternal manager, bool readOnly)
{
CommonHelper.ConfirmNotNull(manager, "manager");
this.manager = manager;
this.readOnly = readOnly;
}
