/// <summary>
/// Processes the specified arguments.
/// </summary>
/// <param name="args">The arguments.</param>
public override void Process(RenderRenderingArgs args)
{
if (args.Rendered ||
HttpContext.Current == null ||
(!args.Cacheable) ||
args.Rendering.RenderingItem == null)
{
return;
}
Item rendering = args.PageContext.Database.GetItem(args.Rendering.RenderingItem.ID);
if (rendering == null || rendering["VaryByCurrency"] != "1")
{
return;
}
// When no cache key is present, we generate a full cache key; Otherwise we append to the existing ones.
if (string.IsNullOrWhiteSpace(args.CacheKey))
{
args.CacheKey = string.Format(CultureInfo.InvariantCulture, "_#varyByCurrency_{0}_{1}_{2}_{3}_{4}", Context.Site.Name, Sitecore.Context.Language.Name, HttpContext.Current.Request.Url.AbsoluteUri, args.Rendering.RenderingItem.ID.ToString(), StorefrontManager.GetCustomerCurrency());
}
else
{
args.CacheKey = string.Format(CultureInfo.InvariantCulture, "_#varybyCurrency_{0}_{1}_{2}", args.CacheKey, args.Rendering.RenderingItem.ID.ToString(), StorefrontManager.GetCustomerCurrency());
}
}
protected override bool Render(string cacheKey, TextWriter writer, RenderRenderingArgs args)
{
var htmlCache = Context.Site == null ? null : CacheManager.GetHtmlCache(Context.Site);
var html = htmlCache?.GetHtml(cacheKey);
if (html == null)
{
return(false);
}
//it's possible to tell the component to cache placeholders too, if the rendering item has a field named "CachePlaceholders" set to "1"
//or by setting a parameter with this name
var hasParam = args.Rendering != null && args.Rendering.Parameters != null &&
args.Rendering.Parameters.Contains("CachePlaceholders");
if ((hasParam && args.Rendering.Parameters["CachePlaceholders"] == "1") ||
(!hasParam && args.Rendering != null && args.Rendering.Item != null && args.Rendering.Item["CachePlaceholders"] == "1"))
{
writer.Write(html);
}
else
{
ReplacePlaceholders(html, writer, args.Rendering);
}
return(true);
}
/// <summary>
/// Processes the specified arguments.
/// </summary>
/// <param name="args">The arguments.</param>
public override void Process(RenderRenderingArgs args)
{
if (!string.IsNullOrEmpty(args.Rendering.DataSource) &&
args.PageContext.Item.Database.Name != "core" &&
args.PageContext.Item.Database.GetItem(args.Rendering.DataSource) == null)
{
Log.Warn(string.Format("'{0}' is not valid datasource.", (object)args.Rendering.DataSource), (object)this);
args.AbortPipeline();
}
else
{
if (args.Rendered || Context.Site == null || !Context.PageMode.IsExperienceEditorEditing)
{
return;
}
var marker = this.GetMarker();
if (marker == null)
{
return;
}
var index = args.Disposables.FindIndex((Predicate <IDisposable>)(x => x.GetType() == typeof(Wrapper)));
if (index < 0)
{
index = 0;
}
args.Disposables.Insert(index, (IDisposable) new Wrapper(args.Writer, marker));
}
}
public override void Process(RenderRenderingArgs args)
{
if (args.Rendered || HttpContext.Current == null || (!args.Cacheable || args.Rendering.RenderingItem == null))
{
return;
}
var obj = args.PageContext.Database.GetItem(args.Rendering.RenderingItem.ID);
if (obj == null || obj["VaryByStoreCatalog"] != "1")
{
return;
}
var storeHelper = new StoreHelper();
var storeId = storeHelper.GetCookie()?.StoreId ?? ((BackEnd.Catalog.Models.CommerceStorefront)StorefrontContext.CurrentStorefront).DefaultStoreID;
if (string.IsNullOrWhiteSpace(args.CacheKey))
{
args.CacheKey = string.Format(CultureInfo.InvariantCulture, "_#varyByStoreCatalog_{0}_{1}_{2}_{3}_{4}", Context.Site.Name, Context.Language.Name, HttpContext.Current.Request.Url.AbsoluteUri, args.Rendering.RenderingItem.ID.ToString(), storeId);
}
else
{
args.CacheKey = string.Format(CultureInfo.InvariantCulture, "_#varybyStoreCatalog_{0}_{1}_{2}", args.CacheKey, args.Rendering.RenderingItem.ID.ToString(), storeId);
}
}
protected override bool Render(Renderer renderer, TextWriter writer, RenderRenderingArgs args)
{
if (!Settings.GetBoolSetting(Constants.Enabled, false) || this.ExcludedURL(args.PageContext.RequestContext.HttpContext.Request.RawUrl.ToLower()))
{
return(base.Render(renderer, writer, args));
}
try
{
StringBuilder stringBuilder = new StringBuilder();
using (StringWriter stringWriter = new StringWriter(stringBuilder))
{
renderer.Render((TextWriter)stringWriter);
}
string value = markupMinifierService.Minify(stringBuilder.ToString(),
Settings.GetBoolSetting(Constants.RemoveWhiteSpaces, true),
Settings.GetBoolSetting(Constants.RemoveLineBreaks, true),
Settings.GetBoolSetting(Constants.RemoveHTMLComments, true));
writer.Write(value);
}
catch (Exception ex)
{
Log.Error("Failed to render rendering", ex, (object)this);
if (!IsHandledByErrorStrategy(renderer, ex, writer))
{
throw;
}
}
return(true);
}
public void InitializeOldProfiling()
{
InitializeProfiling profiling = new InitializeProfiling();
Rendering rendering = new Rendering();
var args1 = new RenderRenderingArgs(rendering, null)
{
Cacheable = true
};
// warm up
profiling.Process(args1);
Tracer.StartSession();
Stopwatch sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 100000; i++)
{
profiling.Process(args1);
}
sw.Stop();
Console.WriteLine("Elapsed {0}", sw.ElapsedMilliseconds);
Tracer.EndSession();
//Console.WriteLine(Tracer.GetFormattedTrace("trace.xslt"));
}
public override void Process(RenderRenderingArgs args)
{
if (args.Rendered || Context.Site == null || !Context.PageMode.IsExperienceEditorEditing ||
args.Rendering.RenderingType.Equals("Layout"))
{
return;
}
var marker = this.GetMarker(args.Rendering);
if (marker == null)
{
base.Process(args);
return;
}
var index = args.Disposables.FindIndex(x => x.GetType() == typeof(Wrapper));
if (index < 0)
{
index = 0;
}
args.Disposables.Insert(index, new Wrapper(args.Writer, marker));
}
public override void Process(RenderRenderingArgs args)
{
foreach (IDisposable wrapper in args.Disposables.OfType <EditorRenderingWrapper>())
{
wrapper.Dispose();
}
}
public override void Process(RenderRenderingArgs args)
{
foreach (IDisposable wrapper in args.Disposables.OfType<EditorRenderingWrapper>())
{
wrapper.Dispose();
}
}
/// <summary>
/// Processes the specified arguments.
/// </summary>
/// <param name="args">The arguments.</param>
public override void Process(RenderRenderingArgs args)
{
try
{
base.Process(args);
}
catch (Exception ex)
{
//ICommonLog log = DependencyResolver.Current.GetService<ICommonLog>();
//args.Cacheable = false;
//var parametersException = GetRenderingParametersException(ex);
//if (parametersException != null)
//{
// this.RenderParametersError(args, parametersException);
// log.Error(parametersException.Message, parametersException);
//}
//else
//{
// this.RenderError(args, ex);
// log.Error(ex.Message, ex);
//}
}
}
protected override bool Render(string cacheKey, TextWriter writer, RenderRenderingArgs args)
{
//Check if the Timeout key is in the cache key; if not, try the base/Sitecore version
if (!cacheKey.Contains(Settings.TimeoutRenderingKey))
{
return(base.Render(cacheKey, writer, args));
}
//Check if the caching site exists; if not, try the base/Sitecore version
SiteContext cachingSite = SiteContext.GetSite(Settings.CachingSite);
if (cachingSite == null)
{
return(base.Render(cacheKey, writer, args));
}
//Check if an HTML cache exists for the caching site and that the HTML is present; if not, try the base/Sitecore version
HtmlCache htmlCache = CacheManager.GetHtmlCache(cachingSite);
string html = htmlCache?.GetHtml(cacheKey);
if (html == null)
{
return(base.Render(cacheKey, writer, args));
}
//If everything is good, write the HTML from the cache
writer.Write(html);
return(true);
}
public override void Process(RenderRenderingArgs args)
{
if (args.Rendered)
{
return;
}
if (HttpContext.Current == null || !args.Cacheable ||
args.Rendering.RenderingItem?.InnerItem == null)
{
return;
}
var renderingItem = args.Rendering.RenderingItem.InnerItem;
if (renderingItem["VaryByResolution"] != "1")
{
return;
}
if (!AdaptiveMediaProvider.IsResolutionCookieSet())
{
// if no cookie set, it is better use largest resolution
args.CacheKey += "_#resolution:" + AdaptiveMediaProvider.GetLargestBreakpoint();
}
else if (AdaptiveMediaProvider.GetScreenResolution() != 0)
{
args.CacheKey += "_#resolution:" + AdaptiveMediaProvider.GetScreenResolution();
}
// else if screen is too big for preset resolution (resolution will be 0),
// return cached version of original image (without resolution cache key)
}
protected override bool Render(Renderer renderer, TextWriter writer, RenderRenderingArgs args)
{
bool success;
Sitecore.Diagnostics.Log.Info("Started ExecuteRenderer", " ExecuteRenderer ");
try
{
using (MiniProfiler.Current.Step($"Rendering:{args.Rendering.RenderingItem.DisplayName}"))
{
success = base.Render(renderer, writer, args);
}
}
catch (Exception e)
{
success = false;
if (Context.PageMode.IsExperienceEditor || Context.PageMode.IsPreview)
{
writer.Write("<p>Error rendering the following component: {0}</p><p>{1}</p>", args.Rendering.RenderingItem.Name, e);
}
Log.Error(e.Message, e, typeof(ExecuteRenderer));
}
Sitecore.Diagnostics.Log.Info("Ended ExecuteRenderer", " ExecuteRenderer");
return(success);
}
protected override bool IsCacheable(Rendering rendering, RenderRenderingArgs args)
{
if (base.IsCacheable(rendering, args))
{
return(new AxiomCachingDefinition(rendering).VaryByURL || PageContext.Current.Item != null);
}
return(false);
}
public bool SkipProcessor(RenderRenderingArgs args)
{
if (args.Rendering.RenderingType != "ViewRenderer")
{
return(true);
}
return(string.IsNullOrWhiteSpace(args.Rendering["ViewPath"]));
}
protected override bool Render(Renderer renderer, TextWriter writer, RenderRenderingArgs args)
{
if (Sitecore.Context.Site.Name == "kitchensink")
{
writer.WriteLine($"<span class=\"renderingInfo\" data-renderingid=\"{args.Rendering.RenderingItem.ID}\" />");
}
return(base.Render(renderer, writer, args));
}
/// <summary>
/// Renders the specified renderer.
/// </summary>
/// <param name="renderer">The renderer.</param>
/// <param name="writer">The writer.</param>
/// <param name="args">The arguments.</param>
/// <returns>Rendered</returns>
protected override bool Render(Renderer renderer, TextWriter writer, RenderRenderingArgs args)
{
if (Sitecore.Context.Database.Name == "web" && Sitecore.Context.PageMode.IsNormal)
{
writer.WriteLine($"<code uniqueid=\"{args.Rendering.UniqueId}\"></code>");
}
return(base.Render(renderer, writer, args));
}
public override void Process(RenderRenderingArgs args)
{
Assert.ArgumentNotNull(args, "args");
if (args.Rendered)
{
return;
}
this.EnterContext(args.Rendering, args);
}
public virtual string FindAreaByPath(RenderRenderingArgs args)
{
var path = args.Rendering["ViewPath"];
var areaName = GetAreaName(path);
return(string.IsNullOrWhiteSpace(areaName)
? null
: areaName);
}
public string Resolve(RenderRenderingArgs args)
{
var theme = _themeRetriever.GetThemeFromContextItem(args.PageContext.Item);
var areaName = theme?[Templates.Theme.FieldNames.MvcAreaName];
return(string.IsNullOrWhiteSpace(areaName)
? null
: areaName);
}
public string Resolve(RenderRenderingArgs args)
{
if (SkipProcessor(args))
{
return(null);
}
return(FindAreaByPath(args));
}
protected override void StartProfiling(RenderRenderingArgs args)
{
// This line is heavy
// string str = args.Rendering.ToString();
// Replaced with this as an example
string str = args.Rendering.Id.ToString();
Tracer.Info("Starting rendering \"" + str + "\".");
++Tracer.Indent;
Profiler.StartOperation("Render \"" + str + "\".");
}
public override void Process(RenderRenderingArgs args)
{
Rendering rendering = args.Rendering;
var siteContext = ServiceLocator.ServiceProvider.GetService <IContext>().Site;
if (rendering.Properties["PersonlizationRules"] != null && siteContext.IsSxaSite() && siteContext.DisplayMode != Sites.DisplayMode.Edit)
{
Evaluate(new CustomizeRenderingArgs(args.Rendering));
}
}
public override void Process(RenderRenderingArgs args)
{
if (args.CacheKey != null)
{
if (args.CacheKey.Contains("VaryByBlog"))
{
UpdateParametersForCaching(args);
}
}
}
public void UpdateParametersForCaching(RenderRenderingArgs args)
{
SiteContext site = Context.Site;
var currentBlog = ManagerFactory.BlogManagerInstance.GetCurrentBlog();
if (args.Rendering.Caching.Cacheable && site != null && site.CacheHtml && currentBlog != null)
{
var key = "CacheVaryByBlogKey=" + currentBlog.SafeGet(x => x.ID).SafeGet(x => x.ToShortID()).SafeGet(x => x.ToString());
args.CacheKey += String.Format("&{0}", key);
}
}
public override void Process(RenderRenderingArgs args)
{
if (args.CacheKey != null)
{
if (args.CacheKey.Contains("VaryByBlog"))
{
UpdateParametersForCaching(args);
}
}
}
protected override string GenerateKey(Rendering rendering, RenderRenderingArgs args)
{
string str = base.GenerateKey(rendering, args);
if (!string.IsNullOrEmpty(str) && new AxiomCachingDefinition(rendering).VaryByURL)
{
str = $"{str}_{System.Web.HttpContext.Current.Request.Url.AbsolutePath}_#uid:{args.Rendering.UniqueId.ToString()}";
}
return(str);
}
protected override bool IsCacheable(Rendering rendering, RenderRenderingArgs args)
{
bool ret = base.IsCacheable(rendering, args);
if (ret == false)
{
return(false);
}
return(!(args.PageContext.Database.GetItem(rendering.DataSource)?.HasTokens() ?? false));
}
protected virtual void StartRecording(RenderRenderingArgs args)
{
var writer = MinificationHelpers.ShouldMinify() ? new OptimizedRecordingTextWriter(args.Writer) : new RecordingTextWriter(args.Writer);
var item = new GenericDisposable(delegate
{
writer.Flush();
});
args.Disposables.Add(item);
args.Writer = writer;
}
public override void Process(RenderRenderingArgs args)
{
Assert.ArgumentNotNull(args, nameof(args));
// Ignore requests if itemresolver should not be applied (see method for details).
if (this.IgnoreRequest(args))
{
return;
}
this.StartRecording(args);
}
public void UpdateParametersForCaching(RenderRenderingArgs args)
{
SiteContext site = Context.Site;
var currentBlog = ManagerFactory.BlogManagerInstance.GetCurrentBlog();
if (args.Rendering.Caching.Cacheable && site != null && site.CacheHtml && currentBlog != null)
{
var key = "CacheVaryByBlogKey=" + currentBlog.SafeGet(x => x.ID).SafeGet(x => x.ToShortID()).SafeGet(x => x.ToString());
args.CacheKey += String.Format("&{0}", key);
}
}
public override void Process(RenderRenderingArgs args)
{
if (RequestExtensions.IsContextRequestForDynamicData() &&
Context.PageMode.IsNormal &&
args.Rendering != null &&
args.Rendering.RenderingType != "Layout" &&
args.Rendering.Placeholder.Equals(CDN.Constants.Layout.DefaultCDNPlaceholder))
{
args.Writer.Write($"<div data-rendering-id=\"{args.Rendering.UniqueId}\">");
}
}
protected string RenderControllerRendering(Database contextDatabase, ID dataSourceItemId)
{
var ri = new RenderingItem(contextDatabase.GetItem(ID.Parse(Constants.FormMvcRenderingId)));
var rendering = new Rendering {
RenderingType = "Controller", UniqueId = Guid.NewGuid(), DataSource = dataSourceItemId.ToString(), Placeholder = "forms", RenderingItem = ri
};
var stringBuilder = new StringBuilder();
var renderingArgs = new RenderRenderingArgs(rendering, new StringWriter(stringBuilder));
CorePipeline.Run("mvc.renderRendering", renderingArgs);
return(stringBuilder.ToString());
}
public IMarker GetMarker(RenderRenderingArgs args)
{
var renderingContext = RenderingContext.CurrentOrNull;
IMarker marker = null;
var renderingItem = args.Rendering.RenderingItem;
if (renderingItem != null)
{
marker = new EditorComponentRenderingMarker(renderingItem.Name);
}
return(marker);
}
public IMarker GetMarker(RenderRenderingArgs args)
{
var renderingContext = RenderingContext.CurrentOrNull;
IMarker marker = null;
var renderingItem = args.Rendering.RenderingItem;
if (renderingItem != null)
{
marker = new EditorComponentRenderingMarker(renderingItem.Name);
}
return marker;
}
public override void Process(RenderRenderingArgs args)
{
String dataSource = args.Rendering.DataSource;
if (!dataSource.StartsWith(Query, StringComparison.OrdinalIgnoreCase))
return;
String query = dataSource.Substring(Query.Length);
Item dataSourceItem = args.PageContext.Item.Axes.SelectSingleItem(query);
if (dataSourceItem != null)
{
args.Rendering.DataSource = dataSourceItem.Paths.FullPath;
}
}
/// <summary>
/// Determines whether the specified rendering is cacheable. Extending Sitecore functionality to check if
/// this shoudl be cached for GET requests. If Request.HttpMethod != "GET, return false.
/// </summary>
/// <param name="rendering">The rendering.</param>
/// <param name="args">The arguments.</param>
/// <returns></returns>
protected override bool IsCacheable(Rendering rendering, RenderRenderingArgs args)
{
var isCacheable = base.IsCacheable(rendering, args);
if (isCacheable)
{
RenderingCachingDefinition definition = new RenderingCachingDefinition(rendering);
if (definition.CacheGetOnly && args.PageContext.RequestContext.HttpContext.Request.HttpMethod != "GET")
{
return false;
}
}
return isCacheable;
}
protected override string GenerateKey(Rendering rendering, RenderRenderingArgs args)
{
string key = base.GenerateKey(rendering, args);
if (!string.IsNullOrEmpty(key))
{
RenderingCachingDefinition definition = new RenderingCachingDefinition(rendering);
if (definition.VaryByCustom)
{
key = string.Format("{0}{1}", key, GetCustomPart(rendering, definition));
}
}
return key;
}
public override void Process(RenderRenderingArgs args)
{
if (args.Rendered || Context.Site == null || !Context.PageMode.IsExperienceEditorEditing || args.Rendering.RenderingType == "Layout")
{
return;
}
var marker = GetMarker(args);
if (marker == null)
{
return;
}
args.Disposables.Add(new EditorRenderingWrapper(args.Writer, marker));
}
protected virtual RenderingErrorModel CreateRenderingErrorModel(RenderRenderingArgs args, Exception ex)
{
var renderingPath = CreateRenderingDisplayPathResolver().ResolveRenderingPath(args.Rendering);
var renderer = args.Rendering.Renderer;
var diags = renderer as RenderingDiagnosticsInjector.DiagnosticsRenderer;
if (diags != null) renderer = diags.InnerRenderer;
var viewRendering = renderer as ViewRenderer;
var expectedModelType = viewRendering != null ? CreateViewModelTypeResolver().GetViewModelType(renderingPath) : null;
return new RenderingErrorModel(renderingPath, args.Rendering.DataSource, expectedModelType, args.Rendering.Model, ex);
}
protected override void UpdateCache(string cacheKey, RenderRenderingArgs args)
{
var recordingTextWriter = args.Writer as RecordingTextWriter;
if (recordingTextWriter == null)
{
return;
}
if (!global::Sitecore.Context.PageMode.IsNormal)
{
this.AddHtmlToCache(cacheKey, recordingTextWriter.GetRecording(), args);
}
var recording = Minify(recordingTextWriter.GetRecording());
this.AddHtmlToCache(cacheKey, recording, args);
}
public override void Process(RenderRenderingArgs args)
{
try
{
base.Process(args);
}
catch (Exception ex)
{
args.Cacheable = false;
var renderingErrorException = this.GetRenderingException(ex);
if (renderingErrorException != null)
{
this.RenderRenderingError(args, renderingErrorException as RenderingException);
if (Logger != null)
{
Logger.Warn(
"Error while rendering view [{0}] on page '{1}. Please, make sure the rendering is configured properly. {2}",
this,
null,
this.GetRenderingName(args),
this.CurrentUrl,
renderingErrorException.Message);
}
}
else
{
this.RenderUnhandledException(args, ex);
if (Logger != null)
{
Logger.Error(
"Error while rendering view [{0}] on page '{1}'. {2}",
this,
ex,
this.GetRenderingName(args),
this.CurrentUrl,
ex.Message);
}
}
}
}
public override void Process(RenderRenderingArgs args)
{
try
{
base.Process(args);
}
catch (Exception ex)
{
args.Cacheable = false;
Log.Error("Error occurred rendering a view.", ex);
var processed = ProcessException(ex);
var model = CreateRenderingErrorModel(args, processed);
if (DispatchPossibleModelException(model, args.PageContext.RequestContext, args.Writer)) return;
DispatchException(model, args.PageContext.RequestContext, args.Writer);
}
}
protected override bool Render(string cacheKey, TextWriter writer, RenderRenderingArgs args)
{
var htmlCache = Context.Site == null ? null : CacheManager.GetHtmlCache(Context.Site);
var html = htmlCache?.GetHtml(cacheKey);
if (html == null)
return false;
//it's possible to tell the component to cache placeholders too, if the rendering item has a field named "CachePlaceholders" set to "1"
//or by setting a parameter with this name
var hasParam = args.Rendering != null && args.Rendering.Parameters != null &&
args.Rendering.Parameters.Contains("CachePlaceholders");
if ((hasParam && args.Rendering.Parameters["CachePlaceholders"] == "1") ||
(!hasParam && args.Rendering != null && args.Rendering.Item != null && args.Rendering.Item["CachePlaceholders"] == "1"))
{
writer.Write(html);
}
else
{
ReplacePlaceholders(html, writer, args.Rendering);
}
return true;
}
/// <summary>
/// Generates the Cache Key for the rendering.
/// </summary>
/// <param name="rendering">The Rendering</param>
/// <param name="args">The Arguments</param>
/// <returns>The Cache Key</returns>
protected override string GenerateKey(Rendering rendering, RenderRenderingArgs args)
{
var str1 = rendering.Caching.CacheKey.OrIfEmpty(args.Rendering.Renderer.ValueOrDefault(renderer => renderer.CacheKey));
if (str1.IsEmptyOrNull())
return null;
var str2 = str1 + "_#lang:" + Language.Current.Name.ToUpper() + this.GetAreaPart(args);
str2 += rendering.RenderingItem.InnerItem.Paths.FullPath;
RenderingCachingDefinition caching = rendering.Caching;
if (caching.VaryByData)
str2 += this.GetDataPart(rendering);
if (caching.VaryByDevice)
str2 += this.GetDevicePart(rendering);
if (caching.VaryByLogin)
str2 += this.GetLoginPart(rendering);
if (caching.VaryByUser)
str2 += this.GetUserPart(rendering);
if (caching.VaryByParameters)
str2 += this.GetParametersPart(rendering);
if (caching.VaryByQueryString)
str2 += this.GetQueryStringPart(rendering);
return str2;
}
/// <summary>
/// Processes the specified arguments.
/// </summary>
/// <param name="args">The arguments.</param>
public override void Process(RenderRenderingArgs args)
{
try
{
base.Process(args);
}
catch (Exception ex)
{
args.Cacheable = false;
var parametersException = GetRenderingParametersException(ex);
if (parametersException != null)
{
this.RenderParametersError(args, parametersException);
Log.Error(parametersException.Message, parametersException, this);
}
else
{
this.RenderError(args, ex);
Log.Error(ex.Message, ex, this);
}
}
}
protected virtual RenderingExceptionViewModel GetRenderingErrorModel(RenderRenderingArgs args, Exception ex)
{
return new RenderingExceptionViewModel(this.GetRenderingName(args), ex);
}
/// <summary>
/// Renders the parameters error.
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="ex">The ex.</param>
private void RenderParametersError(RenderRenderingArgs args, Exception ex)
{
args.Writer.Write(this.RenderViewToString("Errors/RenderingParametersError", GetRenderingErrorModel(args, ex), GetControllerContext(args)));
}
/// <summary>
/// Gets the rendering error model.
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="ex">The ex.</param>
/// <returns></returns>
private static RenderingErrorModel GetRenderingErrorModel(RenderRenderingArgs args, Exception ex)
{
return new RenderingErrorModel(args.Rendering.RenderingItem != null ? args.Rendering.RenderingItem.Name : string.Empty, ex);
}
/// <summary>
/// Gets the rendering error model.
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="ex">The ex.</param>
/// <returns></returns>
private static RenderingErrorViewModel GetRenderingErrorViewModel(RenderRenderingArgs args, Exception ex)
{
string renderingName = args.Rendering.RenderingItem != null ? args.Rendering.RenderingItem.Name : string.Empty;
return new RenderingErrorViewModel(renderingName, ex, Sitecore.Context.PageMode.IsExperienceEditor, HttpContext.Current.IsCustomErrorEnabled);
}
protected virtual string GetRenderingName(RenderRenderingArgs args)
{
return args.Rendering.RenderingItem != null ? args.Rendering.RenderingItem.Name : string.Empty;
}
protected virtual void RenderRenderingError(RenderRenderingArgs args, RenderingException ex)
{
var viewName = "RenderingExceptions/" + this.GetViewNameFromException(ex);
args.Writer.Write(this.RenderViewToString(viewName, this.GetRenderingErrorModel(args, ex), this.GetControllerContext(args)));
}
protected virtual void RenderUnhandledException(RenderRenderingArgs args, Exception ex)
{
var viewName = "RenderingExceptions/UnhandledException";
args.Writer.Write(this.RenderViewToString(viewName, this.GetRenderingErrorModel(args, ex), this.GetControllerContext(args)));
}
