public void Displayed(ShapeDisplayedContext context)
{
// TODO: Configure duration of sliding expiration
var cacheContext = context.ShapeMetadata.Cache();
// If the shape is not cached, evaluate the ESIs
if(cacheContext == null)
{
string content;
using (var sw = new StringWriter())
{
context.ChildContent.WriteTo(sw, HtmlEncoder.Default);
content = sw.ToString();
}
ProcessESIs(ref content, GetDistributedCache);
context.ChildContent = new HtmlString(content);
}
else if (!_cached.Contains(cacheContext) && context.ChildContent != null)
{
var cacheEntries = GetCacheEntries(cacheContext).ToList();
string cacheKey = GetCacheKey(cacheContext.CacheId, cacheEntries);
using (var sw = new StringWriter())
{
context.ChildContent.WriteTo(sw, HtmlEncoder.Default);
var content = sw.ToString();
_cached.Add(cacheContext);
_cache[cacheKey] = content;
var contexts = String.Join(ContextSeparator.ToString(), cacheContext.Contexts.ToArray());
context.ChildContent = new HtmlString($"[[cache id='{cacheContext.CacheId}' contexts='{contexts}']]");
var bytes = Encoding.UTF8.GetBytes(content);
// Default duration is sliding expiration (permanent as long as it's used)
DistributedCacheEntryOptions options = new DistributedCacheEntryOptions
{
SlidingExpiration = new TimeSpan(0, 1, 0)
};
// If a custom duration is specified, replace the default options
if (cacheContext.Duration.HasValue)
{
options = new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = cacheContext.Duration
};
}
_dynamicCache.SetAsync(cacheKey, bytes, options).Wait();
_tagCache.Tag(cacheKey, cacheContext.Tags.ToArray());
}
}
}
private void OnDisplayed(ShapeDisplayedContext displayed)
{
string key = displayed.Shape.PleaseCache;
if (key == null) return;
// Setting up a token just for monitoring changes from menu service.
var menu = (IContent)displayed.Shape.Menu;
var token = _signals.When(CacheUtility.GetCacheSignal(menu.Id));
_tokenHolder.Set(key, token);
var value = displayed.ChildContent;
if (value != null)
_cache.Put(key, value.ToString());
}
public virtual void Displayed(ShapeDisplayedContext context) { }
public IHtmlString Execute(DisplayContext context)
{
var shape = _convertAsShapeCallsite.Target(_convertAsShapeCallsite, context.Value);
// non-shape arguments are returned as a no-op
if (shape == null)
return CoerceHtmlString(context.Value);
var shapeMetadata = shape.Metadata;
// can't really cope with a shape that has no type information
if (shapeMetadata == null || string.IsNullOrEmpty(shapeMetadata.Type))
return CoerceHtmlString(context.Value);
var workContext = _workContextAccessor.GetContext();
// CurrentTheme is now available in the background, so here we no longer use IsBackgroundContext().
// We only do a null check, so we can render in the background a view that only exists in the theme.
var shapeTable = _httpContextAccessor.Current() != null
? _shapeTableLocator.Value.Lookup(workContext.CurrentTheme.Id)
: _shapeTableLocator.Value.Lookup(null);
var displayingContext = new ShapeDisplayingContext {
Shape = shape,
ShapeMetadata = shapeMetadata
};
_shapeDisplayEvents.Invoke(sde => sde.Displaying(displayingContext), Logger);
// find base shape association using only the fundamental shape type.
// alternates that may already be registered do not affect the "displaying" event calls
ShapeBinding shapeBinding;
if (TryGetDescriptorBinding(shapeMetadata.Type, Enumerable.Empty<string>(), shapeTable, out shapeBinding)) {
shapeBinding.ShapeDescriptor.Displaying.Invoke(action => action(displayingContext), Logger);
// copy all binding sources (all templates for this shape) in order to use them as Localization scopes
shapeMetadata.BindingSources = shapeBinding.ShapeDescriptor.BindingSources.Where(x => x != null).ToList();
if (!shapeMetadata.BindingSources.Any()) {
shapeMetadata.BindingSources.Add(shapeBinding.ShapeDescriptor.BindingSource);
}
}
// invoking ShapeMetadata displaying events
shapeMetadata.Displaying.Invoke(action => action(displayingContext), Logger);
// use pre-fectched content if available (e.g. coming from specific cache implmentation)
if ( displayingContext.ChildContent != null ) {
shape.Metadata.ChildContent = displayingContext.ChildContent;
}
else {
// now find the actual binding to render, taking alternates into account
ShapeBinding actualBinding;
if ( TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, out actualBinding) ) {
shape.Metadata.ChildContent = Process(actualBinding, shape, context);
}
else {
throw new OrchardException(T("Shape type {0} not found", shapeMetadata.Type));
}
}
foreach (var frameType in shape.Metadata.Wrappers) {
ShapeBinding frameBinding;
if (TryGetDescriptorBinding(frameType, Enumerable.Empty<string>(), shapeTable, out frameBinding)) {
shape.Metadata.ChildContent = Process(frameBinding, shape, context);
}
}
var displayedContext = new ShapeDisplayedContext {
Shape = shape,
ShapeMetadata = shape.Metadata,
ChildContent = shape.Metadata.ChildContent,
};
_shapeDisplayEvents.Invoke(sde => {
var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent;
sde.Displayed(displayedContext);
// update the child content if the context variable has been reassigned
if (prior != displayedContext.ChildContent)
displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent;
}, Logger);
if (shapeBinding != null) {
shapeBinding.ShapeDescriptor.Displayed.Invoke(action => {
var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent;
action(displayedContext);
// update the child content if the context variable has been reassigned
if (prior != displayedContext.ChildContent)
displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent;
}, Logger);
}
// invoking ShapeMetadata displayed events
shapeMetadata.Displayed.Invoke(action => action(displayedContext), Logger);
return shape.Metadata.ChildContent;
}
public IHtmlString Execute(DisplayContext context)
{
var shape = _convertAsShapeCallsite.Target(_convertAsShapeCallsite, context.Value);
// non-shape arguments are returned as a no-op
if (shape == null)
{
return(CoerceHtmlString(context.Value));
}
var shapeMetadata = shape.Metadata;
// can't really cope with a shape that has no type information
if (shapeMetadata == null || string.IsNullOrEmpty(shapeMetadata.Type))
{
return(CoerceHtmlString(context.Value));
}
var workContext = _workContextAccessor.GetContext();
// CurrentTheme is now available in the background, so here we no longer use IsBackgroundContext().
// We only do a null check, so we can render in the background a view that only exists in the theme.
var shapeTable = _httpContextAccessor.Current() != null
? _shapeTableLocator.Value.Lookup(workContext.CurrentTheme.Id)
: _shapeTableLocator.Value.Lookup(null);
var displayingContext = new ShapeDisplayingContext {
Shape = shape,
ShapeMetadata = shapeMetadata
};
_shapeDisplayEvents.Invoke(sde => sde.Displaying(displayingContext), Logger);
// find base shape association using only the fundamental shape type.
// alternates that may already be registered do not affect the "displaying" event calls
ShapeBinding shapeBinding;
if (TryGetDescriptorBinding(shapeMetadata.Type, Enumerable.Empty <string>(), shapeTable, shapeMetadata.BindingType, out shapeBinding))
{
shapeBinding.ShapeDescriptor.Displaying.Invoke(action => action(displayingContext), Logger);
// copy all binding sources (all templates for this shape) in order to use them as Localization scopes
shapeMetadata.BindingSources = shapeBinding.ShapeDescriptor.BindingSources.Where(x => x != null).ToList();
if (!shapeMetadata.BindingSources.Any())
{
shapeMetadata.BindingSources.Add(shapeBinding.ShapeDescriptor.BindingSource);
}
}
// invoking ShapeMetadata displaying events
shapeMetadata.Displaying.Invoke(action => action(displayingContext), Logger);
// use pre-fectched content if available (e.g. coming from specific cache implmentation)
if (displayingContext.ChildContent != null)
{
shape.Metadata.ChildContent = displayingContext.ChildContent;
}
else
{
// now find the actual binding to render, taking alternates into account
ShapeBinding actualBinding;
if (TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, shapeMetadata.BindingType, out actualBinding))
{
shape.Metadata.ChildContent = Process(actualBinding, shape, context);
}
else
{
throw new OrchardException(T("Shape type {0} not found", shapeMetadata.Type));
}
}
foreach (var frameType in shape.Metadata.Wrappers)
{
ShapeBinding frameBinding;
if (TryGetDescriptorBinding(frameType, Enumerable.Empty <string>(), shapeTable, shapeMetadata.BindingType, out frameBinding))
{
shape.Metadata.ChildContent = Process(frameBinding, shape, context);
}
}
var displayedContext = new ShapeDisplayedContext {
Shape = shape,
ShapeMetadata = shape.Metadata,
ChildContent = shape.Metadata.ChildContent,
};
_shapeDisplayEvents.Invoke(sde => {
var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent;
sde.Displayed(displayedContext);
// update the child content if the context variable has been reassigned
if (prior != displayedContext.ChildContent)
{
displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent;
}
}, Logger);
if (shapeBinding != null)
{
shapeBinding.ShapeDescriptor.Displayed.Invoke(action => {
var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent;
action(displayedContext);
// update the child content if the context variable has been reassigned
if (prior != displayedContext.ChildContent)
{
displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent;
}
}, Logger);
}
// invoking ShapeMetadata displayed events
shapeMetadata.Displayed.Invoke(action => action(displayedContext), Logger);
return(shape.Metadata.ChildContent);
}
public async Task <IHtmlContent> ExecuteAsync(DisplayContext context)
{
var shape = context.Value as IShape;
// non-shape arguments are returned as a no-op
if (shape == null)
{
return(CoerceHtmlString(context.Value));
}
var shapeMetadata = shape.Metadata;
// can't really cope with a shape that has no type information
if (shapeMetadata == null || string.IsNullOrEmpty(shapeMetadata.Type))
{
return(CoerceHtmlString(context.Value));
}
var theme = await _themeManager.GetThemeAsync();
var shapeTable = _shapeTableManager.GetShapeTable(theme?.Id);
var displayingContext = new ShapeDisplayingContext
{
Shape = shape,
ShapeMetadata = shapeMetadata,
DisplayContext = context
};
// Evaluate global Shape Display Events
_shapeDisplayEvents.Invoke(sde => sde.Displaying(displayingContext), _logger);
// Find base shape association using only the fundamental shape type.
// Alternates that may already be registered do not affect the "displaying" event calls.
ShapeBinding shapeBinding;
if (TryGetDescriptorBinding(shapeMetadata.Type, Enumerable.Empty <string>(), shapeTable, out shapeBinding))
{
shapeBinding.ShapeDescriptor.Displaying.Invoke(action => action(displayingContext), _logger);
// copy all binding sources (all templates for this shape) in order to use them as Localization scopes
shapeMetadata.BindingSources = shapeBinding.ShapeDescriptor.BindingSources.Where(x => x != null).ToList();
if (!shapeMetadata.BindingSources.Any())
{
shapeMetadata.BindingSources.Add(shapeBinding.ShapeDescriptor.BindingSource);
}
}
// invoking ShapeMetadata displaying events
shapeMetadata.Displaying.Invoke(action => action(displayingContext), _logger);
// use pre-fectched content if available (e.g. coming from specific cache implementation)
if (displayingContext.ChildContent != null)
{
shape.Metadata.ChildContent = displayingContext.ChildContent;
}
else
{
// now find the actual binding to render, taking alternates into account
ShapeBinding actualBinding;
if (TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, out actualBinding))
{
shapeBinding.ShapeDescriptor.Processing.Invoke(action => action(displayingContext), _logger);
// invoking ShapeMetadata processing events
await shapeMetadata.Processing.InvokeAsync(processing => processing(shape), _logger);
shape.Metadata.ChildContent = await ProcessAsync(actualBinding, shape, context);
}
else
{
throw new OrchardException(T("Shape type {0} not found", shapeMetadata.Type));
}
}
foreach (var frameType in shape.Metadata.Wrappers)
{
ShapeBinding frameBinding;
if (TryGetDescriptorBinding(frameType, Enumerable.Empty <string>(), shapeTable, out frameBinding))
{
shape.Metadata.ChildContent = await ProcessAsync(frameBinding, shape, context);
}
}
var displayedContext = new ShapeDisplayedContext
{
Shape = shape,
ShapeMetadata = shape.Metadata,
ChildContent = shape.Metadata.ChildContent,
DisplayContext = context
};
_shapeDisplayEvents.Invoke(sde =>
{
var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent;
sde.Displayed(displayedContext);
// update the child content if the context variable has been reassigned
if (prior != displayedContext.ChildContent)
{
displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent;
}
}, _logger);
if (shapeBinding != null)
{
shapeBinding.ShapeDescriptor.Displayed.Invoke(action =>
{
var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent;
action(displayedContext);
// update the child content if the context variable has been reassigned
if (prior != displayedContext.ChildContent)
{
displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent;
}
}, _logger);
}
// invoking ShapeMetadata displayed events
shapeMetadata.Displayed.Invoke(action => action(displayedContext), _logger);
return(shape.Metadata.ChildContent);
}
public virtual void Displayed(ShapeDisplayedContext context)
{
}
public async Task<IHtmlContent> ExecuteAsync(DisplayContext context)
{
var shape = context.Value as IShape;
// non-shape arguments are returned as a no-op
if (shape == null)
return CoerceHtmlString(context.Value);
var shapeMetadata = shape.Metadata;
// can't really cope with a shape that has no type information
if (shapeMetadata == null || string.IsNullOrEmpty(shapeMetadata.Type))
return CoerceHtmlString(context.Value);
var theme = await _themeManager.GetThemeAsync();
var shapeTable = _shapeTableManager.GetShapeTable(theme?.Id);
var displayingContext = new ShapeDisplayingContext
{
Shape = shape,
ShapeMetadata = shapeMetadata,
DisplayContext = context
};
// Evaluate global Shape Display Events
_shapeDisplayEvents.Invoke(sde => sde.Displaying(displayingContext), _logger);
// Find base shape association using only the fundamental shape type.
// Alternates that may already be registered do not affect the "displaying" event calls.
ShapeBinding shapeBinding;
if (TryGetDescriptorBinding(shapeMetadata.Type, Enumerable.Empty<string>(), shapeTable, out shapeBinding))
{
shapeBinding.ShapeDescriptor.Displaying.Invoke(action => action(displayingContext), _logger);
// copy all binding sources (all templates for this shape) in order to use them as Localization scopes
shapeMetadata.BindingSources = shapeBinding.ShapeDescriptor.BindingSources.Where(x => x != null).ToList();
if (!shapeMetadata.BindingSources.Any())
{
shapeMetadata.BindingSources.Add(shapeBinding.ShapeDescriptor.BindingSource);
}
}
// invoking ShapeMetadata displaying events
shapeMetadata.Displaying.Invoke(action => action(displayingContext), _logger);
// use pre-fectched content if available (e.g. coming from specific cache implementation)
if (displayingContext.ChildContent != null)
{
shape.Metadata.ChildContent = displayingContext.ChildContent;
}
else
{
// now find the actual binding to render, taking alternates into account
ShapeBinding actualBinding;
if (TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, out actualBinding))
{
shapeBinding.ShapeDescriptor.Processing.Invoke(action => action(displayingContext), _logger);
// invoking ShapeMetadata processing events
await shapeMetadata.Processing.InvokeAsync(processing => processing(shape), _logger);
shape.Metadata.ChildContent = await ProcessAsync(actualBinding, shape, context);
}
else
{
throw new OrchardException(T("Shape type {0} not found", shapeMetadata.Type));
}
}
foreach (var frameType in shape.Metadata.Wrappers)
{
ShapeBinding frameBinding;
if (TryGetDescriptorBinding(frameType, Enumerable.Empty<string>(), shapeTable, out frameBinding))
{
shape.Metadata.ChildContent = await ProcessAsync(frameBinding, shape, context);
}
}
var displayedContext = new ShapeDisplayedContext
{
Shape = shape,
ShapeMetadata = shape.Metadata,
ChildContent = shape.Metadata.ChildContent,
DisplayContext = context
};
_shapeDisplayEvents.Invoke(sde =>
{
var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent;
sde.Displayed(displayedContext);
// update the child content if the context variable has been reassigned
if (prior != displayedContext.ChildContent)
displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent;
}, _logger);
if (shapeBinding != null)
{
shapeBinding.ShapeDescriptor.Displayed.Invoke(action =>
{
var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent;
action(displayedContext);
// update the child content if the context variable has been reassigned
if (prior != displayedContext.ChildContent)
displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent;
}, _logger);
}
// invoking ShapeMetadata displayed events
shapeMetadata.Displayed.Invoke(action => action(displayedContext), _logger);
return shape.Metadata.ChildContent;
}
public override void Displayed(ShapeDisplayedContext context)
{
}