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);
}
/// <summary>
/// Extension used to convert an IPublishedContent back to a Typed model instance.
/// Your model does need to inherit from UmbracoGeneratedBase and contain the correct attributes
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="content"></param>
/// <returns></returns>
public T ConvertToModel <T>(IMedia content, CodeFirstModelContext parentContext = null) where T : MediaTypeBase
{
//TODO move to base class, use a lambda for the type-dependent operations
MediaTypeRegistration registration;
if (!_mediaTypeModule.TryGetMediaType(content.ContentType.Alias, out registration))
{
throw new CodeFirstException("Could not find media type registration for media type alias " + content.ContentType.Alias);
}
if (registration.ClrType != typeof(T))
{
if (registration.ClrType.Inherits(typeof(T)))
{
//Redirect to the underlying type and make one of those instead
if (!_mediaTypeModule.TryGetMediaType(typeof(T), out registration))
{
throw new CodeFirstException("Could not find media type registration for underlying type " + typeof(T).FullName);
}
}
else
{
throw new CodeFirstException("Registered type for media type " + content.ContentType.Alias + " is " + registration.ClrType.Name + ", not " + typeof(T).Name);
}
}
T instance = (T)CreateInstanceFromContent(content, registration, parentContext);
(instance as MediaTypeBase).NodeDetails = new MediaNodeDetails(content);
return(instance);
}
public T ConvertToModel <T>(IPublishedContent content, CodeFirstModelContext parentContext = null) where T : MemberTypeBase
{
var result = base.ConvertToModelInternal <T>(content, parentContext);
GetMemberSpecificProperties(result as MemberTypeBase, content as Umbraco.Web.PublishedCache.MemberPublishedContent);
return(result);
}
/// <summary>
/// Extension used to convert an IPublishedContent back to a Typed model instance.
/// Your model does need to inherit from UmbracoGeneratedBase and contain the correct attributes
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="content"></param>
/// <returns></returns>
public T ConvertToModel <T>(IContent content, CodeFirstModelContext parentContext = null) where T : DocumentTypeBase
{
//TODO move to derived
DocumentTypeRegistration registration;
if (!_documentTypeModule.TryGetDocumentType(content.ContentType.Alias, out registration))
{
throw new CodeFirstException("Could not find document type registration for document type alias " + content.ContentType.Alias);
}
if (registration.ClrType != typeof(T))
{
if (registration.ClrType.Inherits(typeof(T)))
{
//Redirect to the underlying type and make one of those instead
if (!_documentTypeModule.TryGetDocumentType(typeof(T), out registration))
{
throw new CodeFirstException("Could not find document type registration for underlying type " + typeof(T).FullName);
}
}
else
{
throw new CodeFirstException("Registered type for document type " + content.ContentType.Alias + " is " + registration.ClrType.Name + ", not " + typeof(T).Name);
}
}
T instance = (T)CreateInstanceFromContent(content, registration, parentContext);
(instance as DocumentTypeBase).NodeDetails = new DocumentNodeDetails(content);
return(instance);
}
private string GetHtml()
{
var prop = CodeFirstModelContext.GetContext(this).ContentType.Properties.FirstOrDefault(x => x.Alias == SpecialAliases.FileUpload);
if (prop == null)
{
return(string.Empty);
}
else
{
var val = prop.Metadata.GetValue(this);
if (val == null)
{
return(string.Empty);
}
else
{
if (val is IHtmlString)
{
return((val as IHtmlString).ToHtmlString());
}
else
{
return(HttpUtility.HtmlEncode(val.ToString()));
}
}
}
}
private static void GetContextAttributes <T>(CodeFirstModelContext context, List <T> attributes) where T : CodeFirstContextualAttribute
{
if (!CodeFirstManager.Current.Features.UseContextualAttributes)
{
return;
}
if (context.CurrentProperty != null)
{
//Add classes from property
attributes.AddRange(context.CurrentProperty.Metadata.GetCodeFirstAttributesWithInheritance <T>());
}
if (context.ContentType != null)
{
//Add classes from current content type
attributes.AddRange(context.ContentType.ClrType.GetCodeFirstAttributesWithInheritance <T>());
}
if (context.CurrentDataType != null)
{
//Add classes from the current data type
attributes.AddRange(context.CurrentDataType.ClrType.GetCodeFirstAttributesWithInheritance <T>());
}
}
private void SetPropertyValueOnModel(object objectInstance, PropertyRegistration registration, object umbracoStoredValue)
{
if (registration.DataType.ConverterType != null)
{
IDataTypeConverter converter = (IDataTypeConverter)Activator.CreateInstance(registration.DataType.ConverterType);
var val = converter.Create(umbracoStoredValue, x => CodeFirstModelContext.MoveNextContext(x, registration));
if (val != null)
{
CodeFirstModelContext.MoveNextContext(val, registration);
var attr = registration.Metadata.GetCodeFirstAttribute <ContentPropertyAttribute>();
if (attr != null && attr is IDataTypeRedirect)
{
val = (attr as IDataTypeRedirect).GetRedirectedValue(val);
if (val != null)
{
//Keep a second context so wrapped types can still find their property
//Will add nothing if the Redirector registered a context already (e.g. called ConvertToModel to create the value).
//Hopefully said redirector passed in a parent context so the converted value can still find its way back here.
CodeFirstModelContext.MoveNextContext(val, registration);
}
}
registration.Metadata.SetValue(objectInstance, val);
}
}
else if (umbracoStoredValue != null)
{
//Context currently not supported for PEVCs - many are value types, very unlikely to have unique hashes for all values in a request context, none except custom ones would have
//code to use the context anyway.
registration.Metadata.SetValue(objectInstance, umbracoStoredValue);
}
}
/// <summary>
/// Initialises the prevalues and options collections
/// </summary>
private void Init()
{
if (_preValues == null)
{
_preValues = CodeFirstModelContext.GetContext(this)?.CurrentPreValues
??
Current.Modules.PreValueCacheModule.Get(Current.Modules.DataTypeModule.GetDataType(GetType()));
_options = _preValues.Select(x => x.Value).ToList();
}
}
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 object ConvertToModel(IPublishedContent content, CodeFirstModelContext parentContext = null)
{
ContentTypeRegistration docType;
if (_contentTypeModule.TryGetContentType(content.DocumentTypeAlias, out docType))
{
MethodInfo convertToModel = GetConvertToModelMethod(docType.ClrType);
return(convertToModel.Invoke(this, new object[] { content, parentContext }));
}
else
{
return(null);
}
}
/// <summary>
/// Extension used to convert an IPublishedContent back to a Typed model instance.
/// Your model does need to inherit from UmbracoGeneratedBase and contain the correct attributes
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="content"></param>
/// <returns></returns>
protected Tmodel ConvertToModelInternal <Tmodel>(IPublishedContent content, CodeFirstModelContext parentContext = null) where Tmodel : CodeFirstContentBase <T>
{
ContentTypeRegistration registration;
if (content == null)
{
throw new ArgumentNullException("content", Environment.StackTrace);
}
if (!_contentTypeModule.TryGetContentType(content.ContentType.Alias, out registration))
{
throw new CodeFirstException("Could not find content type registration for content type alias " + content.ContentType.Alias);
}
if (registration.ClrType != typeof(Tmodel))
{
if (registration.ClrType.Inherits(typeof(Tmodel)))
{
if (typeof(Tmodel).GetCodeFirstAttribute <ContentTypeAttribute>(false) == null) //The base type is not an Umb content type, just create the full document and cast the result
{
}
else if (!_contentTypeModule.TryGetContentType(typeof(Tmodel), out registration)) //Redirect to the underlying type and make one of those instead
{
throw new CodeFirstException("Could not find content type registration for underlying type " + typeof(Tmodel).FullName);
}
}
else
{
throw new CodeFirstException("Registered type for content type " + content.ContentType.Alias + " is " + registration.ClrType.Name + ", not " + typeof(Tmodel).Name);
}
}
Tmodel instance = (Tmodel)CreateInstanceFromPublishedContent(content, registration, parentContext);
if (instance == null)
{
throw new CodeFirstException("Model could not be created. Target type: " + typeof(Tmodel).Name);
}
if ((instance as CodeFirstContentBase <T>) == null)
{
throw new CodeFirstException("Created model could not be cast to CodeFirstContentBase<T>. Type of T: " + typeof(T).Name);
}
(instance as CodeFirstContentBase <T>).NodeDetails = new T();
((instance as CodeFirstContentBase <T>).NodeDetails as ContentNodeDetails).Initialise(content);
ModelEventDispatcher <Tmodel> .OnLoad(instance, content, new HttpContextWrapper(HttpContext.Current), UmbracoContext.Current, ApplicationContext.Current, CodeFirstModelContext.GetContext(instance));
return(instance);
}
/// <summary>
/// Extension used to convert an IPublishedContent back to a Typed model instance.
/// Your model does need to inherit from UmbracoGeneratedBase and contain the correct attributes
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
public static object ConvertToModel(this IPublishedContent content, CodeFirstModelContext parentContext = null)
{
switch (content.ItemType)
{
case PublishedItemType.Content:
return(CodeFirstManager.Current.Modules.DocumentModelModule.ConvertToModel(content, parentContext));
case PublishedItemType.Media:
return(CodeFirstManager.Current.Modules.MediaModelModule.ConvertToModel(content, parentContext));
case PublishedItemType.Member:
return(CodeFirstManager.Current.Modules.MemberModelModule.ConvertToModel(content, parentContext));
default:
throw new NotImplementedException();
}
}
public static IEnumerable <T> GetAttributesFromContextTree <T>(this object key) where T : CodeFirstContextualAttribute
{
var attributes = new List <T>();
if (!CodeFirstManager.Current.Features.UseContextualAttributes)
{
return(attributes);
}
var context = CodeFirstModelContext.GetContext(key);
GetContextAttributes(context, attributes);
var current = context.ParentContext;
while (current != null)
{
GetContextAttributes(current, attributes);
current = current.ParentContext;
}
return(attributes);
}
internal static void OnLoadObject(object model, IPublishedContent contentInstance, HttpContextBase httpContext, UmbracoContext umbContext, ApplicationContext appContext, CodeFirstModelContext modelContext)
{
if (model.GetType().Inherits <CodeFirstContentBase>())
{
typeof(ModelEventDispatcher <>)
.MakeGenericType(model.GetType())
.GetTypeInfo()
.InvokeMember("OnLoad",
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.InvokeMethod,
null,
null,
new object[]
{
model,
contentInstance,
httpContext,
umbContext,
appContext,
modelContext
});
}
else
{
throw new CodeFirstException("Not a valid model type");
}
}
public static T ConvertMemberToModel <T>(this IPublishedContent content, CodeFirstModelContext parentContext = null) where T : MemberTypeBase
{
return(CodeFirstManager.Current.Modules.MemberModelModule.ConvertToModel <T>(content, parentContext));
}
public static T ConvertToModel <T>(this IMedia content, CodeFirstModelContext parentContext = null) where T : MediaTypeBase
{
return(CodeFirstManager.Current.Modules.MediaModelModule.ConvertToModel <T>(content, parentContext));
}
/// <summary>
/// Extension used to convert an IPublishedContent back to a Typed model instance.
/// Your model does need to inherit from UmbracoGeneratedBase and contain the correct attributes
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="content"></param>
/// <returns></returns>
public static T ConvertToModel <T>(this IContent content, CodeFirstModelContext parentContext = null) where T : DocumentTypeBase
{
return(CodeFirstManager.Current.Modules.DocumentModelModule.ConvertToModel <T>(content, parentContext));
}
public void OnLoad(Factoid model, HttpContextBase httpContext, UmbracoContext umbContext, ApplicationContext appContext, CodeFirstModelContext modelContext, IPublishedContent currentPage)
{
}
public T ConvertToModel <T>(IPublishedContent content, CodeFirstModelContext parentContext = null) where T : MediaTypeBase
{
return(base.ConvertToModelInternal <T>(content, parentContext));
}
protected override T GetModelFromId(int id)
{
var node = new Umbraco.Web.UmbracoHelper(Umbraco.Web.UmbracoContext.Current).TypedMedia(id);
return(node == null ? null : node.ConvertMediaToModel <T>(CodeFirstModelContext.GetContext(this)));
}
/// <summary>
/// An event raised whenever a QuestionSet document is being requested. The method
/// sets up a default viewmodel, which will be passed back and forth by the form postbacks or
/// ajax posts on the views.
/// </summary>
public void OnLoad(QuestionSet model, HttpContextBase httpContext, UmbracoContext umbContext, ApplicationContext appContext, CodeFirstModelContext modelContext, IPublishedContent currentPage, out QuestionSetViewModel viewModel)
{
viewModel = new QuestionSetViewModel()
{
MaxIndex = model?.Count - 1 ?? -1,
SetId = currentPage?.Id ?? -1,
QuestionIndex = model?.Count > 0 ? 0 : -1,
QuestionId = model.FirstOrDefault()?.NodeDetails?.UmbracoId ?? -1,
Answer = new QuestionSetViewModel.QuestionResponse()
{
AnswerIndex = -1
}
};
}
