yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introduce support for content fragments

Browse Source
This commit is contained in:
Stephan
2014-03-03 13:29:33 +01:00
parent 3d4409e52a
commit 792ab8d088
6 changed files with 278 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
src/Umbraco.Web/PublishedCache/IPublishedContentCache.cs
View File

@@ -33,5 +33,53 @@ namespace Umbraco.Web.PublishedCache
/// <returns>The route.</returns>
/// <remarks>The value of <paramref name="preview"/> overrides the context.</remarks>
string GetRouteById(UmbracoContext umbracoContext, bool preview, int contentId);
/// <summary>
/// Creates a content fragment.
/// </summary>
/// <param name="contentTypeAlias">The content type alias.</param>
/// <param name="dataValues">The content property raw values.</param>
/// <param name="isPreviewing">A value indicating whether the fragment is previewing.</param>
/// <param name="managed">A value indicating whether the fragment is managed by the cache.</param>
/// <returns>The newly created content fragment.</returns>
//
// notes
//
// in XmlPublishedCache, IPublishedContent instances are not meant to survive longer
// that a request or else we cannot guarantee that the converted property values will
// be properly managed - because XmlPublishedProperty just stores the result of the
// conversion locally.
//
// in DrippingPublishedCache, IPublishedContent instances are meant to survive for as
// long as the content itself has not been modified, and the property respects the
// converter's indication ie whether the converted value should be cached at
// .Content - cache until the content changes
// .ContentCache - cache until any content changes
// .Request - cache for the current request
//
// a fragment can be either "detached" or "managed".
// detached: created from code, managed by code, converted property values are
// cached within the fragment itself for as long as the fragment lives
// managed: created from a property converter as part of a content, managed by
// the cache, converted property values can be cached...
//
// XmlPublishedCache: same as content properties, store the result of the
// conversion locally, neither content nor fragments should survive longer
// than a request
// DrippingPublishedCache: depends
// .Content: cache within the fragment
// .ContentCache, .Request: cache within the cache
//
// in the latter case, use a fragment-owned guid as the cache key. because we
// don't really have any other choice. this opens potential memory leaks: if the
// fragment is re-created on each request and has a property that caches its
// converted value at .ContentCache level then we'll flood that cache with data
// that's never removed (as long as no content is edited).
//
// so a requirement should be that any converter that creates fragment, should
// be marked .Content -- and nothing else
//
IPublishedContent CreateFragment(string contentTypeAlias, IDictionary<string, object> dataValues,
bool isPreviewing, bool managed);
}
}

10
src/Umbraco.Web/PublishedCache/XmlPublishedCache/PublishedContentCache.cs
View File

@@ -460,5 +460,15 @@ namespace Umbraco.Web.PublishedCache.XmlPublishedCache
}
#endregion
#region Fragments
public IPublishedContent CreateFragment(string contentTypeAlias, IDictionary<string, object> dataValues,
bool isPreviewing, bool managed)
{
return new PublishedFragment(contentTypeAlias, dataValues, isPreviewing, managed);
}
#endregion
}
}

169
src/Umbraco.Web/PublishedCache/XmlPublishedCache/PublishedFragment.cs Normal file
View File

@@ -0,0 +1,169 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Umbraco.Core;
using Umbraco.Core.Models;
using Umbraco.Core.Models.PublishedContent;
using Umbraco.Web.Models;
namespace Umbraco.Web.PublishedCache.XmlPublishedCache
{
class PublishedFragment : PublishedContentBase
{
private readonly PublishedContentType _contentType;
private readonly IPublishedProperty[] _properties;
public PublishedFragment(string contentTypeAlias, IDictionary<string, object> dataValues,
bool isPreviewing, bool managed)
{
IsPreviewing = isPreviewing;
_contentType = PublishedContentType.Get(PublishedItemType.Content, contentTypeAlias);
// we don't care about managed because in both cases, XmlPublishedCache stores
// converted property values in the IPublishedContent, which is not meant to
// survive the request
var dataValues2 = new Dictionary<string, object>();
foreach (var kvp in dataValues)
dataValues2[kvp.Key.ToLowerInvariant()] = kvp.Value;
_properties = _contentType.PropertyTypes
.Select(x =>
{
object dataValue;
return dataValues2.TryGetValue(x.PropertyTypeAlias.ToLowerInvariant(), out dataValue)
? new PublishedFragmentProperty(x, this, dataValue)
: new PublishedFragmentProperty(x, this);
})
.Cast<IPublishedProperty>()
.ToArray();
}
#region IPublishedContent
public override int Id
{
get { throw new NotImplementedException(); }
}
public override int DocumentTypeId
{
get { return _contentType.Id; }
}
public override string DocumentTypeAlias
{
get { return _contentType.Alias; }
}
public override PublishedItemType ItemType
{
get { return PublishedItemType.Content; }
}
public override string Name
{
get { throw new NotImplementedException(); }
}
public override int Level
{
get { throw new NotImplementedException(); }
}
public override string Path
{
get { throw new NotImplementedException(); }
}
public override int SortOrder
{
// note - could a published fragment have a sort order?
get { throw new NotImplementedException(); }
}
public override Guid Version
{
get { throw new NotImplementedException(); }
}
public override int TemplateId
{
get { throw new NotImplementedException(); }
}
public override string UrlName
{
get { return string.Empty; }
}
public override DateTime CreateDate
{
get { throw new NotImplementedException(); }
}
public override DateTime UpdateDate
{
get { throw new NotImplementedException(); }
}
public override int CreatorId
{
get { throw new NotImplementedException(); }
}
public override string CreatorName
{
get { throw new NotImplementedException(); }
}
public override int WriterId
{
get { throw new NotImplementedException(); }
}
public override string WriterName
{
get { throw new NotImplementedException(); }
}
public override bool IsDraft
{
get { throw new NotImplementedException(); }
}
public override IPublishedContent Parent
{
get { throw new NotImplementedException(); }
}
public override IEnumerable<IPublishedContent> Children
{
get { throw new NotImplementedException(); }
}
public override ICollection<IPublishedProperty> Properties
{
get { return _properties; }
}
public override IPublishedProperty GetProperty(string alias)
{
return _properties.FirstOrDefault(x => x.PropertyTypeAlias.InvariantEquals(alias));
}
public override PublishedContentType ContentType
{
get { return _contentType; }
}
#endregion
#region Internal
// used by PublishedFragmentProperty
internal bool IsPreviewing { get; private set; }
#endregion
}
}

43
src/Umbraco.Web/PublishedCache/XmlPublishedCache/PublishedFragmentProperty.cs Normal file
View File

@@ -0,0 +1,43 @@
using System;
using Umbraco.Core.Models.PublishedContent;
namespace Umbraco.Web.PublishedCache.XmlPublishedCache
{
class PublishedFragmentProperty : PublishedPropertyBase
{
private readonly object _dataValue;
private readonly PublishedFragment _content;
private readonly Lazy<object> _sourceValue;
private readonly Lazy<object> _objectValue;
private readonly Lazy<object> _xpathValue;
public PublishedFragmentProperty(PublishedPropertyType propertyType, PublishedFragment content)
: this(propertyType, content, null)
{ }
public PublishedFragmentProperty(PublishedPropertyType propertyType, PublishedFragment content, object dataValue)
: base(propertyType)
{
_dataValue = dataValue;
_content = content;
_sourceValue = new Lazy<object>(() => PropertyType.ConvertDataToSource(_dataValue, _content.IsPreviewing));
_objectValue = new Lazy<object>(() => PropertyType.ConvertSourceToObject(_sourceValue.Value, _content.IsPreviewing));
_xpathValue = new Lazy<object>(() => PropertyType.ConvertSourceToXPath(_sourceValue.Value, _content.IsPreviewing));
}
public override bool HasValue
{
get { return _dataValue != null && ((_dataValue is string) == false || string.IsNullOrWhiteSpace((string)_dataValue) == false); }
}
public override object DataValue
{
get { return _dataValue; }
}
public override object Value { get { return _objectValue.Value; } }
public override object XPathValue { get { return _xpathValue.Value; } }
}
}