/// <summary>
/// Creates content type(s) associated with the specified type to the given site, and create list if any.
/// </summary>
/// <remarks>
/// Children content types associated with derived types are also created. Content types and site columns are prosivioned on the root site.
/// If a <see cref="SPListAttribute"/> is attributed to the specified type, a list with URL specified by <see cref="SPListAttribute.Url"/> will be created on the given site.
/// However, if another <see cref="SPListAttribute"/> is attributed to derived types, lists will *not* be created.</remarks>
/// <param name="type">A type that derives from <see cref="SPModel"/>.</param>
/// <param name="targetWeb">Site object.</param>
/// <returns>A collection of lists affected.</returns>
public static ICollection <SPList> Provision(Type type, SPWeb targetWeb)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(type);
SPModelUsageCollection collection = descriptor.Provision(targetWeb);
return(collection.GetListCollection());
}
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)));
}
internal static SPModel TryCreate(ISPListItemAdapter adapter, SPModelCollection parentCollection)
{
CommonHelper.ConfirmNotNull(adapter, "adapter");
CommonHelper.ConfirmNotNull(parentCollection, "parentCollection");
SPModelDescriptor exactType;
try {
exactType = SPModelDescriptor.Resolve(adapter.ContentTypeId);
} catch (ArgumentException) {
return(null);
}
if (exactType.ModelType.IsGenericType)
{
throw new InvalidOperationException(String.Format("Cannot create object from generic type '{0}'. Consider adding SPModelManagerDefaultTypeAttribute to the model class.", exactType.ModelType.FullName));
}
try {
calledByInternal = true;
SPModel item = (SPModel)exactType.ModelInstanceType.CreateInstance();
item.Adapter = Intercept.ThroughProxy(adapter, new TransparentProxyInterceptor(), new[] { new SPListItemAdapterInterceptionBehavior(item, adapter, parentCollection) });
item.ParentCollection = parentCollection;
return(item);
} finally {
calledByInternal = false;
}
}
/// <summary>
/// Creates content type(s) associated with the specified type to the given list.
/// </summary>
/// <remarks>
/// Children content types associated with derived types are also created. Content types and site columns are prosivioned on the root site.
/// If a <see cref="SPListAttribute"/> is attributed to the specified type, values specified on the attribute are copied to the given list.
/// </remarks>
/// <param name="type">A type that derives from <see cref="SPModel"/>.</param>
/// <param name="targetList">A list object.</param>
/// <returns>A collection of lists affected.</returns>
public static ICollection <SPList> Provision(Type type, SPList targetList)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(type);
SPModelUsageCollection collection = descriptor.Provision(targetList.ParentWeb, new SPModelListProvisionOptions(targetList));
return(collection.GetListCollection());
}
/// <summary>
/// Creates content type(s) associated with the specified type to the given site, and create list with the specified URL and title if any.
/// </summary>
/// <param name="type">A type that derives from <see cref="SPModel"/>.</param>
/// <param name="targetWeb">Site object.</param>
/// <param name="webRelativeUrl">List URL.</param>
/// <param name="title">List title.</param>
/// <returns>A collection of lists affected.</returns>
public static ICollection <SPList> Provision(Type type, SPWeb targetWeb, string webRelativeUrl, string title)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(type);
SPModelUsageCollection collection = descriptor.Provision(targetWeb, new SPModelListProvisionOptions(webRelativeUrl, title));
return(collection.GetListCollection());
}
/// <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);
}
private static ReadOnlyCollection <string> GetAllSelectProperties(SPModelDescriptor descriptor)
{
List <string> viewFields = new List <string>();
viewFields.AddRange(descriptor.RequiredViewFields);
viewFields.AddRange(SPModel.RequiredViewFields);
return(new ReadOnlyCollection <string>(viewFields));
}
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;
}
private SPModelMonitor(SPSite site)
{
this.siteId = site.ID;
this.descriptor = SPModelDescriptor.Resolve(typeof(T));
foreach (SPModelUsage usage in descriptor.GetUsages(site.RootWeb))
{
monitoredLists.Add(usage.ListId);
}
Initialize(site.ID,
new SPChangeMonitorFilter(SPChangeObjectType.List, SPChangeFlags.ListContentTypeAdd | SPChangeFlags.ListContentTypeDelete),
new SPChangeMonitorFilter(SPChangeObjectType.Item, SPChangeFlags.Add | SPChangeFlags.Update | SPChangeFlags.Delete | SPChangeFlags.SystemUpdate));
}
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);
}
public static SPModelDescriptor Resolve(SPContentTypeId contentTypeId, SPSite lookupSite)
{
CommonHelper.ConfirmNotNull(lookupSite, "lookupSite");
try {
SPModelDescriptor descriptor = Resolve(contentTypeId);
if (descriptor.ContentTypeIds.Contains(contentTypeId))
{
return(descriptor);
}
} catch (ArgumentException) { }
RegisterReferencedAssemblies(lookupSite);
return(Resolve(contentTypeId));
}
/// <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));
}
public void AddImplementedType(SPModelDescriptor descriptor)
{
CommonHelper.ConfirmNotNull(descriptor, "descriptor");
foreach (SPModelDescriptor otherType in base.Children)
{
if (otherType != descriptor)
{
foreach (SPFieldAttribute attribute in otherType.Fields)
{
descriptor.AddInterfaceDepenedentField(attribute);
}
foreach (SPFieldAttribute attribute in descriptor.Fields)
{
otherType.AddInterfaceDepenedentField(attribute);
}
}
}
foreach (SPFieldAttribute attribute in descriptor.Fields)
{
AddRequiredViewField(attribute);
}
SPContentTypeId contentTypeId = descriptor.ContentTypeIds.First();
foreach (SPModelDescriptor otherType in base.Children)
{
if (contentTypeId.IsChildOf(otherType.ContentTypeIds.First()))
{
return;
}
}
if (!baseType.HasValue)
{
baseType = descriptor.BaseType;
}
else if (baseType != descriptor.BaseType)
{
baseType = SPBaseType.UnspecifiedBaseType;
}
base.Children.Add(descriptor);
}
protected void CheckFieldConsistency(SPModelDescriptor other)
{
foreach (SPFieldAttribute definition in fieldAttributes)
{
SPFieldAttribute parentDefinition = other.fieldAttributes.FirstOrDefault(v => v.InternalName == definition.InternalName);
if (parentDefinition != null)
{
if (definition.GetType() != parentDefinition.GetType())
{
throw new SPModelProvisionException(String.Format("Definition for field '{0}' in content type '{1}' conflicts with parent content type.", definition.InternalName, contentTypeAttribute.Name));
}
foreach (PropertyInfo property in definition.GetType().GetProperties())
{
object myValue = property.GetValue(definition, null);
object paValue = property.GetValue(parentDefinition, null);
if (!Object.Equals(myValue, paValue))
{
if (property.PropertyType == typeof(SPOption) && (SPOption)myValue == SPOption.Unspecified)
{
continue;
}
if (property.PropertyType == typeof(StringCollection))
{
StringCollection sourceCollection = (StringCollection)myValue;
StringCollection targetCollection = (StringCollection)paValue;
if (sourceCollection.Count == targetCollection.Count && !sourceCollection.Cast <string>().Except(targetCollection.Cast <string>()).Any())
{
continue;
}
}
throw new SPModelProvisionException(String.Format("Definition for field '{0}' in content type '{1}' conflicts with parent content type.", definition.InternalName, contentTypeAttribute.Name));
}
}
}
}
}
internal static Type BuildTypeFromAbstractBaseType(Type baseType)
{
Random random = new Random();
string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
string randomTypeName = String.Concat(baseType.Name, "__", new String(Enumerable.Repeat(chars, 8).Select(s => s[random.Next(s.Length)]).ToArray()));
TypeBuilder typeBuilder = ModuleBuilder.DefineType(randomTypeName, TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit, baseType);
MethodInfo spModelGetAdapterMethod = typeof(SPModel).GetMethod("get_Adapter", true);
MethodInfo spModelGetManagerMethod = typeof(SPModel).GetMethod("get_Manager", true);
MethodInfo spModelGetParentCollectionMethod = typeof(SPModel).GetMethod("get_ParentCollection", true);
MethodInfo ispModelManagerGetTermStoreMethod = typeof(ISPModelManager).GetMethod("get_TermStore");
foreach (PropertyInfo sourceProperty in baseType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
MethodInfo sourceGetter = sourceProperty.GetGetMethod(true);
MethodInfo sourceSetter = sourceProperty.GetSetMethod(true);
if ((sourceGetter != null && sourceGetter.IsAbstract) || (sourceSetter != null && sourceSetter.IsAbstract))
{
SPModelFieldAssociationCollection association = SPModelFieldAssociationCollection.GetByMember(sourceProperty);
if (!association.Queryable)
{
continue;
}
SPFieldAttribute field = association.Fields.First();
MethodInfo getterMethod = null;
MethodInfo setterMethod = null;
MethodInfo postGetterMethod = null;
MethodInfo preSetterMethod = null;
Type secondParameterType = null;
if (sourceProperty.PropertyType == typeof(bool))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetBoolean");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetBoolean");
}
else if (sourceProperty.PropertyType == typeof(int))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetInteger");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetInteger");
}
else if (sourceProperty.PropertyType == typeof(double))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetNumber");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetNumber");
}
else if (sourceProperty.PropertyType == typeof(string))
{
if (field.Type == SPFieldType.Lookup)
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetLookupFieldValue");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetLookupFieldValue");
}
else if (field.Type == SPFieldType.URL)
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetUrlFieldValue");
setterMethod = typeof(SPExtension).GetMethod("SetUrlFieldValue", new[] { typeof(ISPListItemAdapter), typeof(string), typeof(string) });
postGetterMethod = typeof(SPFieldUrlValue).GetProperty("Url").GetGetMethod();
}
else
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetString");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetString");
}
}
else if (sourceProperty.PropertyType == typeof(Guid))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetGuid");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetGuid");
}
else if (sourceProperty.PropertyType == typeof(DateTime?))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetDateTime");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetDateTime");
}
else if (sourceProperty.PropertyType == typeof(DateTime))
{
getterMethod = typeof(SPExtension).GetMethod("GetDateTimeOrMin");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetDateTime");
preSetterMethod = typeof(DateTime?).GetMethod("op_Implicit");
}
else if (sourceProperty.PropertyType == typeof(Term))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetTaxonomy");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetTaxonomy");
secondParameterType = typeof(TermStore);
}
else if (sourceProperty.PropertyType == typeof(SPFieldUrlValue))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetUrlFieldValue");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetUrlFieldValue");
}
else if (sourceProperty.PropertyType == typeof(SPPrincipal))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetUserFieldValue");
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetUserFieldValue");
}
else if (sourceProperty.PropertyType.IsOf <Enum>())
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetEnum").MakeGenericMethod(sourceProperty.PropertyType);
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetEnum").MakeGenericMethod(sourceProperty.PropertyType);
}
else if (sourceProperty.PropertyType.IsOf <SPModel>())
{
getterMethod = typeof(ISPListItemAdapter).GetMethod("GetModel").MakeGenericMethod(sourceProperty.PropertyType);
setterMethod = typeof(ISPListItemAdapter).GetMethod("SetModel").MakeGenericMethod(sourceProperty.PropertyType);
secondParameterType = typeof(SPModelCollection);
}
else
{
Type elementType;
if (sourceProperty.PropertyType.IsOf(typeof(IEnumerable <>), out elementType))
{
bool isReadOnly = sourceProperty.PropertyType.IsOf(typeof(ReadOnlyCollection <>));
if (elementType == typeof(Term))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod(isReadOnly ? "GetTaxonomyMultiReadOnly" : "GetTaxonomyMulti");
secondParameterType = typeof(TermStore);
}
else if (elementType == typeof(SPPrincipal))
{
getterMethod = typeof(ISPListItemAdapter).GetMethod(isReadOnly ? "GetMultiUserFieldValueReadOnly" : "GetMultiUserFieldValue");
}
else if (elementType == typeof(string))
{
if (field.Type == SPFieldType.MultiChoice)
{
getterMethod = typeof(ISPListItemAdapter).GetMethod(isReadOnly ? "GetMultiChoiceFieldValueReadOnly" : "GetMultiChoiceFieldValue");
}
else
{
getterMethod = typeof(ISPListItemAdapter).GetMethod(isReadOnly ? "GetMultiLookupFieldValueReadOnly" : "GetMultiLookupFieldValue");
}
}
else
{
try {
SPModelDescriptor.Resolve(elementType);
getterMethod = typeof(ISPListItemAdapter).GetMethod(isReadOnly ? "GetModelCollectionReadOnly" : "GetModelCollection").MakeGenericMethod(elementType);
secondParameterType = typeof(SPModelCollection);
} catch (ArgumentException) { }
}
if (sourceSetter != null)
{
throw new InvalidOperationException("Collection property cannot have setter.");
}
}
}
if ((sourceGetter != null && getterMethod == null) || (sourceSetter != null && setterMethod == null))
{
throw new InvalidOperationException(String.Format("Unable to find suitable method for '{0}.{1}'.", baseType.Name, sourceProperty.Name));
}
PropertyBuilder property = typeBuilder.DefineProperty(sourceProperty.Name, PropertyAttributes.HasDefault, sourceProperty.PropertyType, null);
if (sourceGetter != null)
{
MethodBuilder propertyGetter = typeBuilder.DefineMethod(sourceGetter.Name, GetMethodVisibility(sourceGetter) | MethodAttributes.ReuseSlot | MethodAttributes.Virtual | MethodAttributes.SpecialName | MethodAttributes.HideBySig, sourceProperty.PropertyType, Type.EmptyTypes);
ILGenerator propertyGetterIL = propertyGetter.GetILGenerator();
propertyGetterIL.Emit(OpCodes.Ldarg_0);
propertyGetterIL.Emit(OpCodes.Call, spModelGetAdapterMethod);
propertyGetterIL.Emit(OpCodes.Ldstr, field.InternalName);
if (secondParameterType != null)
{
if (secondParameterType == typeof(TermStore))
{
propertyGetterIL.Emit(OpCodes.Ldarg_0);
propertyGetterIL.Emit(OpCodes.Call, spModelGetManagerMethod);
propertyGetterIL.Emit(OpCodes.Callvirt, ispModelManagerGetTermStoreMethod);
}
else if (secondParameterType == typeof(SPModelCollection))
{
propertyGetterIL.Emit(OpCodes.Ldarg_0);
propertyGetterIL.Emit(OpCodes.Call, spModelGetParentCollectionMethod);
}
else
{
throw new NotSupportedException();
}
}
if (getterMethod.DeclaringType.IsInterface || getterMethod.IsAbstract)
{
propertyGetterIL.Emit(OpCodes.Callvirt, getterMethod);
}
else
{
propertyGetterIL.Emit(OpCodes.Call, getterMethod);
}
if (postGetterMethod != null)
{
propertyGetterIL.Emit(OpCodes.Call, postGetterMethod);
}
propertyGetterIL.Emit(OpCodes.Ret);
property.SetGetMethod(propertyGetter);
}
if (sourceSetter != null)
{
MethodBuilder propertySetter = typeBuilder.DefineMethod(sourceSetter.Name, GetMethodVisibility(sourceSetter) | MethodAttributes.ReuseSlot | MethodAttributes.Virtual | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new Type[] { sourceProperty.PropertyType });
ILGenerator propertySetterIL = propertySetter.GetILGenerator();
propertySetterIL.Emit(OpCodes.Ldarg_0);
propertySetterIL.Emit(OpCodes.Call, spModelGetAdapterMethod);
propertySetterIL.Emit(OpCodes.Ldstr, field.InternalName);
propertySetterIL.Emit(OpCodes.Ldarg_1);
if (preSetterMethod != null)
{
propertySetterIL.Emit(OpCodes.Call, preSetterMethod);
}
if (setterMethod.DeclaringType.IsInterface || setterMethod.IsAbstract)
{
propertySetterIL.Emit(OpCodes.Callvirt, setterMethod);
}
else
{
propertySetterIL.Emit(OpCodes.Call, setterMethod);
}
propertySetterIL.Emit(OpCodes.Nop);
propertySetterIL.Emit(OpCodes.Ret);
property.SetSetMethod(propertySetter);
}
}
}
return(typeBuilder.CreateType());
}
public bool Contains(SPModelDescriptor other)
{
return(this == other || this.Interfaces.Contains(other) || this.Children.Any(v => v.Contains(other)));
}
/// <summary>
/// Determines whether the specified list contains the content type associated with the model type.
/// </summary>
/// <param name="list">A list object.</param>
/// <param name="type">Model type.</param>
/// <exception cref="ArgumentException">The type <paramref name="type"/> does not associate with any content type.</exception>
/// <returns>*true* if the specified list contains content type that is associated with the model type.</returns>
public static bool DoesListContainsType(SPList list, Type type)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(type);
return(descriptor.UsedInList(list));
}
/// <summary>
/// Gets all lists under the specified site and all its descendant sites which contains the content type associated with the model type.
/// </summary>
/// <param name="type">Model type.</param>
/// <param name="contextWeb">A site object.</param>
/// <exception cref="ArgumentException">The type <paramref name="type"/> does not associate with any content type.</exception>
/// <returns>An enumerable of list objects.</returns>
public static IEnumerable <SPList> EnumerateLists(Type type, SPWeb contextWeb)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(type);
return(descriptor.GetUsages(contextWeb).GetListCollection());
}
/// <summary>
/// Gets the default manager instantiated with the specified site.
/// 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>
/// <returns>A manager object.</returns>
public static ISPModelManager GetDefaultManager(Type type, SPWeb contextWeb)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(type);
return(descriptor.CreateManager(contextWeb));
}
private SPModelDescriptor(Type targetType, SPModelDefaultsAttribute defaultsAttribute)
{
this.ModelType = targetType;
TargetTypeDictionary.TryAdd(targetType, this);
TargetTypeDictionary.TryGetValue(targetType.BaseType, out this.Parent);
if (this.Parent is SPModelInterfaceTypeDescriptor)
{
this.Parent = null;
}
this.contentTypeAttribute = targetType.GetCustomAttribute <SPContentTypeAttribute>(false);
ResolveContentTypeId(contentTypeAttribute, targetType);
ContentTypeDictionary.Add(contentTypeAttribute.ContentTypeId, this);
this.defaultManagerType = GetDefaultManagerType(targetType);
this.provisionEventReceiverType = contentTypeAttribute.ProvisionEventReceiverType;
this.hasExplicitListAttribute = targetType.GetCustomAttribute <SPListAttribute>(false) != null;
this.listAttribute = targetType.GetCustomAttribute <SPListAttribute>(true) ?? new SPListAttribute();
this.fieldAttributes = SPModelFieldAssociationCollection.EnumerateFieldAttributes(this, targetType).ToArray();
if (contentTypeAttribute.Group == null && defaultsAttribute != null)
{
contentTypeAttribute.Group = defaultsAttribute.DefaultContentTypeGroup;
}
foreach (SPFieldAttribute attribute in fieldAttributes)
{
if (attribute.Group == null)
{
if (this.Parent != null)
{
SPFieldAttribute baseAttribute = this.Parent.fieldAttributes.FirstOrDefault(v => v.InternalName == attribute.InternalName);
if (baseAttribute != null)
{
attribute.Group = baseAttribute.Group;
continue;
}
}
if (defaultsAttribute != null)
{
attribute.Group = defaultsAttribute.DefaultFieldGroup;
}
}
}
if (contentTypeAttribute.ContentTypeId.IsChildOf(ContentTypeId.Page))
{
this.ItemType = SPModelItemType.PublishingPage;
}
else if (contentTypeAttribute.ContentTypeId.IsChildOf(SPBuiltInContentTypeId.DocumentSet))
{
this.ItemType = SPModelItemType.DocumentSet;
}
else if (contentTypeAttribute.ContentTypeId.IsChildOf(SPBuiltInContentTypeId.Folder))
{
this.ItemType = SPModelItemType.Folder;
}
else if (contentTypeAttribute.ContentTypeId.IsChildOf(SPBuiltInContentTypeId.Document))
{
this.ItemType = SPModelItemType.File;
}
if (this.ItemType == SPModelItemType.GenericItem)
{
this.baseType = SPBaseType.GenericList;
}
else if (contentTypeAttribute.ContentTypeId.IsChildOf(SPBuiltInContentTypeId.Issue))
{
this.baseType = SPBaseType.Issue;
}
else
{
this.baseType = SPBaseType.DocumentLibrary;
}
if (this.Parent != null)
{
this.Parent.Children.Add(this);
this.fieldAttributes = fieldAttributes.Concat(this.Parent.fieldAttributes).Distinct().ToArray();
if (provisionEventReceiverType == null)
{
this.provisionEventReceiverType = this.Parent.provisionEventReceiverType;
}
}
foreach (SPFieldAttribute v in fieldAttributes)
{
AddRequiredViewField(v);
}
foreach (Type interfaceType in targetType.GetInterfaces())
{
if (!interfaceType.IsDefined(typeof(SPModelIgnoreAttribute), true))
{
SPModelInterfaceTypeDescriptor interfaceDescriptor = (SPModelInterfaceTypeDescriptor)TargetTypeDictionary.EnsureKeyValue(interfaceType, SPModelInterfaceTypeDescriptor.Create);
interfaceDescriptor.AddImplementedType(this);
this.Interfaces.Add(interfaceDescriptor);
}
}
if (targetType.BaseType != typeof(SPModel) && targetType.BaseType.GetCustomAttribute <SPContentTypeAttribute>(false) == null)
{
SPModelInterfaceTypeDescriptor interfaceDescriptor = (SPModelInterfaceTypeDescriptor)TargetTypeDictionary.EnsureKeyValue(targetType.BaseType, SPModelInterfaceTypeDescriptor.Create);
interfaceDescriptor.AddImplementedType(this);
this.Interfaces.Add(interfaceDescriptor);
}
if (!targetType.IsAbstract)
{
instanceType = new Lazy <Type>(() => targetType);
}
else
{
instanceType = new Lazy <Type>(() => SPModel.BuildTypeFromAbstractBaseType(targetType), LazyThreadSafetyMode.ExecutionAndPublication);
}
}
/// <summary>
/// Resolves inherited <see cref="SPModel"/> type associated with the specified content type ID.
/// For details of associating Content type ID for a given type, see <see cref="SPContentTypeAttribute"/>.
/// </summary>
/// <param name="contentTypeId">Content type ID.</param>
/// <exception cref="System.ArgumentException">No types are found with the specified content type ID.</exception>
/// <returns>A resolved type.</returns>
public static Type ResolveType(SPContentTypeId contentTypeId)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(contentTypeId);
return(descriptor.ModelType);
}
/// <summary>
/// Gets a list of field internal names needed when querying list item represented by the specified model type.
/// </summary>
/// <param name="type">A type that derives from <see cref="SPModel"/>.</param>
/// <returns>A list of internal names.</returns>
public static string[] GetRequiredViewFields(Type type)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(type);
return(descriptor.RequiredViewFields);
}
/// <summary>
/// Gets a list of content type ID associated with the specified model type.
/// </summary>
/// <param name="type">A type that derives from <see cref="SPModel"/>.</param>
/// <returns>A list of content type ID.</returns>
public static SPContentTypeId[] ResolveContentTypeId(Type type)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(type);
return(descriptor.ContentTypeIds.ToArray());
}
internal void HandleEvent(SPModelEventArgs e)
{
SPModelDescriptor descriptor = SPModelDescriptor.Resolve(this.GetType());
foreach (SPModelInterfaceTypeDescriptor d in descriptor.Interfaces)
{
if (d.EventHandlerType != null)
{
ISPModelEventHandler handler = (ISPModelEventHandler)d.EventHandlerType.CreateInstance();
handler.HandleEvent(this, e);
}
}
switch (e.EventType)
{
case SPModelEventType.Adding:
OnAdding(e);
OnAddingOrUpdating(e);
return;
case SPModelEventType.Added:
OnAdded(e);
OnAddedOrUpdated(e);
return;
case SPModelEventType.AddedAsync:
OnAddedAsync(e);
OnAddedOrUpdatedAsync(e);
return;
case SPModelEventType.Updating:
OnUpdating(e);
OnAddingOrUpdating(e);
return;
case SPModelEventType.Updated:
OnUpdated(e);
OnAddedOrUpdated(e);
return;
case SPModelEventType.UpdatedAsync:
OnUpdatedAsync(e);
OnAddedOrUpdatedAsync(e);
return;
case SPModelEventType.Deleting:
OnDeleting(e);
return;
case SPModelEventType.Deleted:
OnDeleted(e);
return;
case SPModelEventType.Publishing:
OnPublishing(e);
return;
case SPModelEventType.Published:
OnPublished(e);
return;
}
}