protected override IContentTypeBase UpdateContentType(ContentTypeRegistration registration, out bool modified)
{
var result = base.UpdateContentType(registration, out modified);
if (CodeFirstManager.Current.Features.InitialisationMode == InitialisationMode.Ensure)
{
if (modified)
{
throw new CodeFirstPassiveInitialisationException("The types defined in the database do not match the types passed in to initialise. In InitialisationMode.Ensure the types must match or the site will be prevented from starting.");
}
else
{
return(result);
}
}
else if (CodeFirstManager.Current.Features.InitialisationMode == InitialisationMode.Sync)
{
if (modified)
{
return(SyncMemberType(registration, result));
}
else
{
return(result);
}
}
else if (CodeFirstManager.Current.Features.InitialisationMode == InitialisationMode.Passive)
{
return(result);
}
else
{
throw new CodeFirstException("Unknown initialisation type");
}
}
protected object CreateInstanceFromContent(IContentBase content, ContentTypeRegistration registration, CodeFirstModelContext parentContext = null)
{
Dictionary <PropertyInfo, CodeFirstLazyInitialiser> dict;
var instance = CodeFirstModelContext.CreateContextualInstance(registration.ClrType, registration, out dict, parentContext, false);
//properties on Generic Tab
foreach (var property in registration.Properties)
{
CopyPropertyValueToModel(content, instance, property);
}
foreach (var tab in registration.Tabs)
{
//tab instance
Dictionary <PropertyInfo, CodeFirstLazyInitialiser> tabDict;
var tabInstance = CodeFirstModelContext.CreateContextualInstance(tab.ClrType, tab, out tabDict);
foreach (var property in tab.Properties)
{
CopyPropertyValueToModel(content, tabInstance, property);
}
tab.PropertyOfParent.SetValue(instance, tabInstance);
}
foreach (var composition in registration.Compositions)
{
CodeFirstModelContext.MoveNextContext(instance, composition);
composition.PropertyOfContainer.SetValue(instance, CreateInstanceFromContent(content, composition, CodeFirstModelContext.GetContext(instance)));
}
return(instance);
}
protected override void SyncAllowedChildren(ContentTypeRegistration registration)
{
if (CodeFirstManager.Current.Features.AllowAllMediaTypesInDefaultFolder && registration.ClrType == typeof(MediaFolder))
{
//TODO make this an attribute so it can be used on user-created folders too. Maybe all it on doc types too. Need separate attrs though as separate types of potential children.
AddAllTypesToAllowedChildren(registration);
}
base.SyncAllowedChildren(registration);
}
/// <summary>
/// <para>Creates an IContent populated with the current values of the model</para>
/// </summary>
private IContent CreateContent(int parentId, DocumentTypeBase model, ContentTypeRegistration registration)
{
//Get the type alias and create the content
var typeAlias = registration.Alias;
var node = ApplicationContext.Current.Services.ContentService.CreateContent(model.NodeDetails.Name, parentId, typeAlias);
MapModelToContent(node, model, registration);
return(node);
}
/// <summary>
/// Updates an existing IContent item with the current values of the model
/// </summary>
/// <returns></returns>
private IContent UpdateContent(DocumentTypeBase model, ContentTypeRegistration registration)
{
if (model.NodeDetails == null || model.NodeDetails.UmbracoId == -1)
{
throw new ArgumentException("Can't update content for a model with no ID. Try calling CreateContent instead. Check that the NodeDetails.UmbracoId property is set before calling UpdateContent.");
}
var node = ApplicationContext.Current.Services.ContentService.GetById(model.NodeDetails.UmbracoId);
MapModelToContent(node, model, registration);
return(node);
}
/// <summary>
/// <para>Creates an IContent populated with the current values of the model</para>
/// </summary>
private IMedia CreateContent(int parentId, MediaTypeBase model, ContentTypeRegistration registration)
{
//Get the type alias and create the content
var typeAlias = registration.Alias;
var node = ApplicationContext.Current.Services.MediaService.CreateMedia(model.NodeDetails.Name, parentId, typeAlias);
MapModelToContent(node, model, registration);
if (model.MediaFile != null && node.HasProperty("umbracoFile"))
{
var fn = System.IO.Path.GetFileName(model.MediaFile.Name);
node.SetValue("umbracoFile", fn, model.MediaFile);
}
return(node);
}
public void Register(ContentTypeRegistration registration)
{
if (!_instance._registerByAlias.TryAdd(registration.Alias, registration))
{
throw new CodeFirstException("Document type alias already registered");
}
if (!_instance._registerByType.TryAdd(registration.ClrType, registration))
{
ContentTypeRegistration r;
_instance._registerByAlias.TryRemove(registration.Alias, out r);
throw new CodeFirstException("Document type CLR type already registered");
}
}
/// <summary>
/// Updates an existing IContent item with the current values of the model
/// </summary>
/// <returns></returns>
private IMedia UpdateContent(MediaTypeBase model, ContentTypeRegistration registration)
{
if (model.NodeDetails == null || model.NodeDetails.UmbracoId == -1)
{
throw new ArgumentException("Can't update content for a model with no ID. Try calling CreateContent instead. Check that the NodeDetails.UmbracoId property is set before calling UpdateContent.");
}
var node = ApplicationContext.Current.Services.MediaService.GetById(model.NodeDetails.UmbracoId);
MapModelToContent(node, model, registration);
if (model.MediaFile != null && node.HasProperty("umbracoFile"))
{
node.SetValue("umbracoFile", System.IO.Path.GetFileNameWithoutExtension(model.MediaFile.Name), model.MediaFile);
}
return(node);
}
private void AddAllTypesToAllowedChildren(ContentTypeRegistration mediaTypeReg)
{
var list = new List <Type>();
if (mediaTypeReg.ContentTypeAttribute.AllowedChildren != null) //Add specified children
{
list.AddRange(mediaTypeReg.ContentTypeAttribute.AllowedChildren);
}
foreach (var reg in ContentTypeRegister.Registrations) //Add all other types
{
if (!list.Contains(reg.ClrType))
{
list.Add(reg.ClrType);
}
}
if (!list.Contains(mediaTypeReg.ClrType)) //Add self
{
list.Add(mediaTypeReg.ClrType);
}
mediaTypeReg.ContentTypeAttribute.AllowedChildren = list.ToArray();
}
/// <summary>
/// <para>Creates an IMember populated with the current values of the model</para>
/// </summary>
private IMember CreateContent(MemberTypeBase model, ContentTypeRegistration registration)
{
if (model.Name == null)
{
throw new CodeFirstException("Name must be set to create a member");
}
if (model.Username == null)
{
throw new CodeFirstException("Username must be set to create a member");
}
if (model.Email == null)
{
throw new CodeFirstException("Email must be set to create a member");
}
//Get the type alias and create the content
var typeAlias = registration.Alias;
var node = ApplicationContext.Current.Services.MemberService.CreateMemberWithIdentity(model.Username, model.Email, model.Name, typeAlias);
SetMemberSpecificProperties(model, node);
MapModelToContent(node, model, registration);
return(node);
}
private IContentTypeBase SyncMemberType(ContentTypeRegistration registration, IContentTypeBase result)
{
result.ResetDirtyProperties(false);
Save(result); //need to save to ensure no sync issues when we load from the legacy API
bool modified = false;
var member = new umbraco.cms.businesslogic.member.MemberType(result.Id);
foreach (var prop in member.PropertyTypes)
{
var propReg = registration.Properties.SingleOrDefault(x => x.Alias == prop.Alias);
if (propReg != null)
{
var attr = propReg.Metadata.GetCodeFirstAttribute <MemberPropertyAttribute>();
if (attr != null)
{
if (attr.MemberCanEdit != member.MemberCanEdit(prop))
{
member.setMemberCanEdit(prop, attr.MemberCanEdit);
modified = true;
}
if (attr.ShowOnProfile != member.ViewOnProfile(prop))
{
member.setMemberViewOnProfile(prop, attr.ShowOnProfile);
modified = true;
}
}
}
}
if (modified)
{
modified = false;
member.Save();
}
return(_service.Get(member.Id));
}
protected void MapModelToContent(IContentBase node, CodeFirstContentBase <T> model, ContentTypeRegistration registration, bool firstLevel = true)
{
if (firstLevel)
{
node.Name = model.NodeDetails.Name;
node.SortOrder = model.NodeDetails.SortOrder;
}
foreach (var prop in registration.Properties)
{
var val = prop.Metadata.GetValue(model);
if (val != null)
{
SetPropertyOnContent(node, prop, val);
}
}
//Get and then set all the properties from any tabs
var tabs = registration.Tabs;
foreach (var tab in tabs)
{
var tabInstance = tab.PropertyOfParent.GetValue(model);
if (tabInstance != null)
{
foreach (var prop in tab.Properties)
{
var val = prop.Metadata.GetValue(tabInstance);
if (val != null)
{
SetPropertyOnContent(node, prop, val);
}
}
}
}
foreach (var comp in registration.Compositions)
{
MapModelToContent(node, (CodeFirstContentBase <T>)comp.PropertyOfContainer.GetValue(model), comp, false);
}
}
protected object CreateInstanceFromPublishedContent(IPublishedContent content, ContentTypeRegistration registration, CodeFirstModelContext parentContext = null)
{
Dictionary <PropertyInfo, CodeFirstLazyInitialiser> dict;
var instance = CodeFirstModelContext.CreateContextualInstance(registration.ClrType, registration, out dict, parentContext);
//properties on Generic Tab
foreach (var property in registration.Properties)
{
if (CodeFirstManager.Current.Features.UseLazyLoadingProxies && property.Metadata.GetGetMethod().IsVirtual)
{
dict.Add(property.Metadata, new CodeFirstLazyInitialiser(() => CopyPropertyValueToModel(content, instance, property)));
}
else
{
CopyPropertyValueToModel(content, instance, property);
}
}
foreach (var tab in registration.Tabs)
{
//tab instance
Dictionary <PropertyInfo, CodeFirstLazyInitialiser> tabDict;
var tabInstance = CodeFirstModelContext.CreateContextualInstance(tab.ClrType, tab, out tabDict);
foreach (var property in tab.Properties)
{
if (CodeFirstManager.Current.Features.UseLazyLoadingProxies && property.Metadata.GetGetMethod().IsVirtual)
{
tabDict.Add(property.Metadata, new CodeFirstLazyInitialiser(() => CopyPropertyValueToModel(content, tabInstance, property)));
}
else
{
CopyPropertyValueToModel(content, tabInstance, property);
}
}
tab.PropertyOfParent.SetValue(instance, tabInstance);
}
foreach (var composition in registration.Compositions)
{
var parent = CodeFirstModelContext.GetCompositionParentContext(composition);
if (CodeFirstManager.Current.Features.UseLazyLoadingProxies && composition.PropertyOfContainer.GetGetMethod().IsVirtual)
{
dict.Add(composition.PropertyOfContainer, new CodeFirstLazyInitialiser(() => composition.PropertyOfContainer.SetValue(instance, CreateInstanceFromPublishedContent(content, composition, parent))));
}
else
{
composition.PropertyOfContainer.SetValue(instance, CreateInstanceFromPublishedContent(content, composition, parent));
}
}
CodeFirstModelContext.ResetContext();
return(instance);
}
public ContentTypeCompositionRegistration(ContentTypeRegistration basis, PropertyInfo propertyOfContainer)
{
_basis = basis;
PropertyOfContainer = propertyOfContainer;
}
public bool TryGetContentType(Type type, out ContentTypeRegistration registration)
{
type = StripProxy(type);
return(_registerByType.TryGetValue(type, out registration));
}
public bool TryGetContentType(string alias, out ContentTypeRegistration registration)
{
return(_registerByAlias.TryGetValue(alias, out registration));
}
