public virtual IHtmlString RenderBeginField(object parameters, bool editing = true)
{
var renderFieldArgs = new RenderFieldArgs
{
Item = Field.Item,
FieldName = Field.Name,
DisableWebEdit = !editing
};
if (parameters != null)
{
TypeHelper.CopyProperties(parameters, renderFieldArgs);
TypeHelper.CopyProperties(parameters, renderFieldArgs.Parameters);
}
if (renderFieldArgs.Item == null)
{
return(new HtmlString(string.Empty));
}
CorePipeline.Run("renderField", renderFieldArgs);
var result = renderFieldArgs.Result;
var str = result.FirstPart ?? string.Empty;
EndFieldStack.Push(result.LastPart ?? string.Empty);
return(new HtmlString(str));
}
public new void Process(RenderFieldArgs args)
{
if (args.FieldTypeKey != "image")
{
return;
}
var useSrcSet = args.Parameters.ContainsKey("usesrcset") && args.Parameters["usesrcset"] == "True";
args.Parameters.Remove("usesrcset");
var suppressSrcParameters = args.Parameters.ContainsKey("suppressSrcParameters")
? (args.Parameters["suppressSrcParameters"] ?? "").Split(",|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
: new string[0];
args.Parameters.Remove("suppressSrcParameters");
base.Process(args);
if (string.IsNullOrWhiteSpace(args.Result.FirstPart))
{
return;
}
args.Result.FirstPart = RemoveSuppressedSrcParameters(suppressSrcParameters, args.Result.FirstPart);
if (!useSrcSet)
{
return;
}
args.Result.FirstPart = args.Result.FirstPart.Replace(" src=", " srcset=");
args.Result.FirstPart = Regex.Replace(args.Result.FirstPart, @"(\swidth=""[\w\d]+"")|(\sheight=""[\w\d]+"")", "");
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
string fieldTypeKey = args.FieldTypeKey;
if (fieldTypeKey != "youtubevideo") return;
args.DisableWebEditContentEditing = true;
YouTubeVideoField video = args.GetField();
if (Context.PageMode.IsPageEditorEditing)
{
YouTubeVideoField.ThumbnailSize size;
Enum.TryParse(args.Parameters["Size"], out size); // default is Small
args.Result.FirstPart = YouTubeVideoField.FormatValueForPageEditorDisplay(video.Value, size);
}
else
{
byte autoHide = GetByteOrDefault(args.Parameters["autohide"], 2);
bool autoPlay = GetBoolOrDefault(args.Parameters["autoplay"]);
byte controls = GetByteOrDefault(args.Parameters["controls"], 1);
bool loop = GetBoolOrDefault(args.Parameters["loop"]);
bool rel = GetBoolOrDefault(args.Parameters["rel"]);
bool showinfo = GetBoolOrDefault(args.Parameters["showinfo"]);
int start = GetIntOrDefault(args.Parameters["start"]);
args.Result.FirstPart = video.FormatValueForNormalDisplay(video.Value, autoHide, autoPlay, controls, loop, rel, showinfo, start);
}
}
protected virtual string RunPipeline(Field field, GetOptionsSc options)
{
RenderFieldArgs renderFieldArgs = new RenderFieldArgs
{
Item = field.Item,
FieldName = field.ID.ToString(),
DisableWebEdit = true,
};
try
{
if (options.Site != null)
{
using (new SiteContextSwitcher(options.Site))
{
CorePipeline.Run("renderField", renderFieldArgs);
}
}
else
{
CorePipeline.Run("renderField", renderFieldArgs);
}
}
catch (Exception ex)
{
throw new MapperException("Failed to render field {0} on item {1}".Formatted(field.ID, field.Item.ID), ex);
}
return(renderFieldArgs.Result.FirstPart + renderFieldArgs.Result.LastPart);
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
string fieldTypeKey = args.FieldTypeKey;
if (fieldTypeKey != "youtubevideo")
{
return;
}
args.DisableWebEditContentEditing = true;
if (!Context.PageMode.IsPageEditorEditing)
{
return;
}
YouTubeVideoField video = args.GetField();
YouTubeVideoField.ThumbnailSize size;
Enum.TryParse(args.Parameters["Size"], out size); // default is Small
args.Result.FirstPart = YouTubeVideoField.FormatValueForPageEditorDisplay(video.Value, size);
}
public void Process(RenderFieldArgs args)
{
var item = GetItem(args);
if (item == null)
{
return;
}
var oldText = item[args.FieldName];
var updatedText = args.Item[args.FieldName];
if (String.CompareOrdinal(updatedText, oldText) == 0)
{
if (!IndicateUnchangedFields)
{
return;
}
}
if (RenderBeforeComparison)
{
oldText = RenderWithoutDifferences(item, args);
updatedText = RenderWithoutDifferences(args.Item, args);
}
if (RenderTextualDifferences && args.FieldTypeKey != "image")
{
var evaluator = new FieldDifferenceEvaluator();
args.Result.FirstPart = evaluator.GetDifferences(oldText, updatedText);
}
}
public void Process(RenderFieldArgs args)
{
if (!CanProcess(args))
{
return;
}
string isTriggerCampaign = string.Empty;
if (!string.IsNullOrEmpty(GetXmlAttributeValue(args.FieldValue, "triggercampaign")))
{
if (GetXmlAttributeValue(args.FieldValue, "triggercampaign") == "1")
{
isTriggerCampaign = "true";
}
else
{
isTriggerCampaign = "false";
}
}
else
{
isTriggerCampaign = "false";
}
args.Result.FirstPart = AddCampaignAttributeValue(args.Result.FirstPart, CampaignAttributeName, GetXmlAttributeValue(args.FieldValue, CampaignXmlAttributeName));
args.Result.FirstPart = AddCampaignAttributeValue(args.Result.FirstPart, "triggercampaign", isTriggerCampaign);
args.Result.FirstPart = AddCampaignAttributeValue(args.Result.FirstPart, "onclick", "activateSelectedCampaign('" + GetXmlAttributeValue(args.FieldValue, CampaignXmlAttributeName) + "', '" + isTriggerCampaign + "');");
}
/// <summary>Gets the field value.</summary>
/// <param name="args">The arguments.</param>
/// <contract>
/// <requires name="args" condition="none" />
/// </contract>
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
if (!this.CanWebEdit(args) && !args.WebEditParameters.ContainsKey("sc-highlight-contentchange") || (args.Item == null || !this.CanEditItem(args.Item)))
{
return;
}
Field field = args.Item.Fields[args.FieldName];
if (field == null || !this.CanEditField(field))
{
return;
}
Item obj = field.Item;
string str = obj[FieldIDs.Revision].Replace("-", string.Empty);
string controlID = "fld_" + (object)obj.ID.ToShortID() + "_" + (object)field.ID.ToShortID() + "_" + (object)obj.Language + "_" + (object)obj.Version + "_" + str + "_" + (object)MainUtil.GetSequencer();
HtmlTextWriter output = new HtmlTextWriter((TextWriter) new StringWriter());
string rawValueContainer = this.GetRawValueContainer(field, controlID);
output.Write(rawValueContainer);
if (args.DisableWebEditContentEditing && args.DisableWebEditFieldWrapping)
{
this.RenderWrapperlessField(output, args, field, controlID);
}
else
{
this.RenderWrappedField(output, args, field, controlID);
}
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
if (!string.IsNullOrEmpty(args.FieldValue))
{
args.Result.FirstPart = args.FieldValue;
}
else
{
args.Result.FirstPart = args.Item[args.FieldName];
}
if (args.FieldTypeKey == "rich text")
{
WordFieldValue wordFieldValue = WordFieldValue.Parse(args.Result.FirstPart);
if (wordFieldValue.BlobId != ID.Null)
{
args.Result.FirstPart = wordFieldValue.GetHtmlWithStyles();
}
}
if (args.FieldTypeKey == "markdownfield")
{
var markdown = new Markdown();
args.Result.FirstPart = markdown.Transform(args.FieldValue);
}
}
public void Process(RenderFieldArgs args)
{
string fieldTypeKey = args.FieldTypeKey;
// Execute this code only for our custom field type
if (fieldTypeKey != "datetime with timezone")
{
return;
}
// Use existing DateRenderer to render our custom date field
DateRenderer renderer = new DateRenderer();
renderer.Item = args.Item;
renderer.FieldName = args.FieldName;
// Use the DateTimeWithTimeZoneField class to get strongly typed value of date instead of raw value
renderer.FieldValue = new DateTimeWithTimeZoneField(args.Item.Fields[args.FieldName]).ToString();
renderer.Parameters = args.Parameters;
// To allow passing format parameter to our field, same as DateTime field.
if (!string.IsNullOrEmpty(args.Parameters["format"]))
{
args.WebEditParameters["format"] = args.Parameters["format"];
}
// Allow editing from Experience Editor as well
args.DisableWebEditContentEditing = false;
args.WebEditClick = "return Sitecore.WebEdit.editControl($JavascriptParameters,'webedit:editdate');";
RenderFieldResult result = renderer.Render();
args.Result.FirstPart = result.FirstPart;
args.Result.LastPart = result.LastPart;
}
public IFieldRenderingResult Render(object parameters = null)
{
var renderFieldArgs = new RenderFieldArgs()
{
Item = item,
FieldName = fieldName
};
if (parameters != null)
{
renderFieldArgs.ApplyParameters(parameters);
}
CorePipeline.Run(renderFieldPipeline, renderFieldArgs);
var result = renderFieldArgs.Result;
var beginResult = result?.FirstPart;
var endResult = result?.LastPart;
var renderingResult = new FieldRenderingResult(beginResult, endResult);
RenderingResult = renderingResult.Some <IFieldRenderingResult>();
return(renderingResult);
}
public static HtmlString BeginField(ID fieldId, Item item, object parameters)
{
Assert.ArgumentNotNull(fieldId, "fieldName");
var renderFieldArgs = new RenderFieldArgs
{
Item = item,
FieldName = item.Fields[fieldId].Name
};
if (parameters != null)
{
CopyProperties(parameters, renderFieldArgs);
CopyProperties(parameters, renderFieldArgs.Parameters);
}
renderFieldArgs.Item = renderFieldArgs.Item ?? CurrentItem;
if (renderFieldArgs.Item == null)
{
EndFieldStack.Push(string.Empty);
return new HtmlString(string.Empty);
}
CorePipeline.Run("renderField", renderFieldArgs);
var result1 = renderFieldArgs.Result;
var str = result1.ValueOrDefault(result => result.FirstPart).OrEmpty();
EndFieldStack.Push(result1.ValueOrDefault(result => result.LastPart).OrEmpty());
return new HtmlString(str);
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
string fieldTypeKey = args.FieldTypeKey;
if (fieldTypeKey != "youtubevideo")
{
return;
}
args.DisableWebEditContentEditing = true;
YouTubeVideoField video = args.GetField();
if (Context.PageMode.IsPageEditorEditing)
{
YouTubeVideoField.ThumbnailSize size;
Enum.TryParse(args.Parameters["Size"], out size); // default is Small
args.Result.FirstPart = YouTubeVideoField.FormatValueForPageEditorDisplay(video.Value, size);
}
else
{
byte autoHide = GetByteOrDefault(args.Parameters["autohide"], 2);
bool autoPlay = GetBoolOrDefault(args.Parameters["autoplay"]);
byte controls = GetByteOrDefault(args.Parameters["controls"], 1);
bool loop = GetBoolOrDefault(args.Parameters["loop"]);
bool rel = GetBoolOrDefault(args.Parameters["rel"]);
bool showinfo = GetBoolOrDefault(args.Parameters["showinfo"]);
int start = GetIntOrDefault(args.Parameters["start"]);
args.Result.FirstPart = video.FormatValueForNormalDisplay(video.Value, autoHide, autoPlay, controls, loop, rel, showinfo, start);
}
}
public static HtmlString BeginField(ID fieldId, Item item, object parameters)
{
Assert.ArgumentNotNull(fieldId, nameof(fieldId));
var renderFieldArgs = new RenderFieldArgs
{
Item = item,
FieldName = item.Fields[fieldId].Name
};
if (parameters != null)
{
CopyProperties(parameters, renderFieldArgs);
CopyProperties(parameters, renderFieldArgs.Parameters);
}
renderFieldArgs.Item = renderFieldArgs.Item ?? CurrentItem;
if (renderFieldArgs.Item == null)
{
EndFieldStack.Push(string.Empty);
return(new HtmlString(string.Empty));
}
CorePipeline.Run("renderField", renderFieldArgs);
var result1 = renderFieldArgs.Result;
var str = result1.ValueOrDefault(result => result.FirstPart).OrEmpty();
EndFieldStack.Push(result1.ValueOrDefault(result => result.LastPart).OrEmpty());
return(new HtmlString(str));
}
/// <summary>
/// Replaces the field value with the value with the token values injected
/// </summary>
/// <param name="args"></param>
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
string fieldValue = args.FieldValue;
if (string.IsNullOrWhiteSpace(args.Result.FirstPart))
{
args.Result.FirstPart = string.IsNullOrEmpty(fieldValue) ? args.Item[args.FieldName] : fieldValue;
}
if (args.FieldTypeKey != "rich text")
{
return;
}
try
{
if (Context.PageMode.IsNormal || Context.PageMode.IsPreview)
{
args.Result.FirstPart = TokenKeeper.CurrentKeeper.ReplaceRTETokens(args, args.Result.FirstPart);
}
}
catch (MethodAccessException)
{
args.Result.FirstPart = TokenKeeper.CurrentKeeper.ReplaceRTETokens(args, args.Result.FirstPart);
}
WordFieldValue wordFieldValue = WordFieldValue.Parse(args.Result.FirstPart);
if (wordFieldValue.BlobId == ID.Null)
{
return;
}
args.Result.FirstPart = wordFieldValue.GetHtmlWithStyles();
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
if (!string.IsNullOrEmpty(args.FieldValue))
{
args.Result.FirstPart = args.FieldValue;
}
else
{
args.Result.FirstPart = args.Item[args.FieldName];
}
if (args.FieldTypeKey == "rich text")
{
WordFieldValue wordFieldValue = WordFieldValue.Parse(args.Result.FirstPart);
if (wordFieldValue.BlobId != ID.Null)
{
args.Result.FirstPart = wordFieldValue.GetHtmlWithStyles();
}
}
if (args.FieldTypeKey == "markdownfield")
{
var markdown = new Markdown();
args.Result.FirstPart = markdown.Transform(args.FieldValue);
}
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
if (ShouldFieldBeProcessed(args))
{
ReplaceFormTags(args);
}
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
if (args.Result.FirstPart == string.Empty && Sitecore.Context.Site.DisplayMode != Sitecore.Sites.DisplayMode.Edit)
{
args.Result.FirstPart = FallbackValue(args.Item, args.FieldName.ToLower(), "en");
}
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
if (!args.Parameters.ContainsKey("disable-web-editing") && WebEditStateSwitcher.CurrentValue == WebEditState.Disabled)
{
args.Parameters.Add("disable-web-editing", "true");
}
}
/// <summary>
/// Checks if the field should not be handled by the processor.
/// </summary>
/// <param name="args">The arguments.</param>
/// <returns>true if the field should not be handled by the processor; otherwise false</returns>
protected virtual bool SkipProcessor(RenderFieldArgs args)
{
if (args == null)
{
return(true);
}
return(args.FieldTypeKey != "ultra link");
}
private static Dictionary <string, string> GetFieldHtmls(Item item, List <string> FieldNames)
{
Assert.ArgumentNotNull(item, "item");
Assert.ArgumentNotNullOrEmpty(RenderFieldPipelineName, "renderField");
Dictionary <string, string> argsResult = new Dictionary <string, string>();
foreach (var fieldName in FieldNames)
{
if (item == null)
{
return(argsResult);
}
RenderFieldArgs args = new RenderFieldArgs {
Item = item, FieldName = fieldName
};
CorePipeline.Run(RenderFieldPipelineName, args);
if (!args.Result.IsEmpty)
{
string contents = args.Result.ToString();
string multilistItems = "";
// Image Field Type - Get only image path
if (args.FieldTypeKey == "image")
{
Sitecore.Data.Fields.ImageField iFld = args.Item.Fields[fieldName];
Sitecore.Resources.Media.MediaUrlOptions opt = new Sitecore.Resources.Media.MediaUrlOptions();
//opt.AlwaysIncludeServerUrl = true;
opt.AbsolutePath = true;
string mediaUrl = Sitecore.Resources.Media.MediaManager.GetMediaUrl(iFld.MediaItem, opt);
contents = mediaUrl;
}
// Multilist Field Type - Convert Item ID to Item Name
if (args.FieldTypeKey == "multilist")
{
List <string> itemId = args.Result.ToString().Split('|').ToList();
int count = 1;
foreach (string i in itemId)
{
Item theItem = item.Database.GetItem(Sitecore.Data.ID.Parse(i));
if (theItem != null)
{
multilistItems += theItem.Name;
if (count != itemId.Count)
{
multilistItems += "|";
}
}
count++;
}
contents = multilistItems;
}
argsResult.Add(fieldName, contents);
}
}
return(argsResult);
}
public void Process(RenderFieldArgs args)
{
if (args.FieldTypeKey != "rich text" ||
(String.IsNullOrEmpty(args.Result.FirstPart) && String.IsNullOrEmpty(args.Result.LastPart)))
return;
args.Result.FirstPart = ReplaceImage(args.Result.FirstPart);
args.Result.LastPart = ReplaceImage(args.Result.LastPart);
}
public void Process(RenderFieldArgs args)
{
try
{
if (args == null)
{
return;
}
// Trigger the code to transform the img tags only for rich text and image fields
if (!(args.FieldTypeKey != "rich text" || args.FieldTypeKey != "image") || string.IsNullOrEmpty(args.FieldValue) ||
!Context.PageMode.IsNormal)
{
return;
}
if (!string.IsNullOrWhiteSpace(args.Result?.FirstPart))
{
HtmlDocument doc = new HtmlDocument {
OptionWriteEmptyNodes = true
};
doc.LoadHtml(args.Result.FirstPart);
if (doc.DocumentNode != null)
{
// Search for all img tags
HtmlNodeCollection imgTag = doc.DocumentNode.SelectNodes("//img");
if (imgTag == null || imgTag.Count == 0)
{
return;
}
foreach (HtmlNode node in imgTag)
{
if (node.Attributes["src"] != null && node.ParentNode != null)
{
string imgUrl = node.Attributes["src"].Value;
node.Attributes.Add("responsive-src", imgUrl);
node.Attributes["src"].Value = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
string currentClass = node.Attributes["class"] != null ? node.Attributes["class"].Value : "";
node.Attributes.Remove("class");
node.Attributes.Add("class", (string.IsNullOrWhiteSpace(currentClass) ? "" : currentClass + " ")
+ Settings.GetSetting("ImageLazyLoadModule.Selector", "b-lazy"));
node.Attributes.Remove("width");
node.Attributes.Remove("height");
}
}
args.Result.FirstPart = doc.DocumentNode.OuterHtml;
}
}
}
catch (Exception ex)
{
Log.Error("Error in ImageLazyLoadModule.ImageLazyLoad:" + ex.Message, ex);
}
}
private bool CanWebEdit(RenderFieldArgs args)
{
if (args.DisableWebEdit)
{
return(false);
}
var site = Context.Site;
return(site != null && site.DisplayMode == DisplayMode.Edit && (WebUtil.GetQueryString("sc_duration") != "temporary" && Context.PageMode.IsExperienceEditorEditing));
}
static public string GetRichTextRenderFieldPipeline(this Item item, ID fieldId)
{
RenderFieldArgs args = new RenderFieldArgs();
args.Item = item;
args.DisableWebEditFieldWrapping = true;
args.FieldName = GetFieldName(item, fieldId);
CorePipeline.Run("renderField", args);
return(args.Result.ToString());
}
protected virtual bool CanProcess(RenderFieldArgs args)
{
return(!string.IsNullOrWhiteSpace(this.AttributeName) &&
!string.IsNullOrWhiteSpace(this.BeginningHtml) &&
!string.IsNullOrWhiteSpace(this.XmlAttributeName) &&
args != null &&
args.Result != null &&
this.HasXmlAttributeValue(args.FieldValue, this.AttributeName) &&
!string.IsNullOrWhiteSpace(args.Result.FirstPart) &&
args.Result.FirstPart.ToLower().StartsWith(this.BeginningHtml.ToLower()));
}
/// <summary>
/// Processes the specified arguments,get the field value.
/// </summary>
/// <param name="args">The arguments.</param>
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
string fieldTypeKey = args.FieldTypeKey;
if (fieldTypeKey != "video")
{
return;
}
args.Result.FirstPart = BuildVideoTag(args.Result.FirstPart);
}
/// <summary>
/// Sets the webedit parameters.
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="parameterNames">The parameter names.</param>
/// <contract>
/// <requires name="args" condition="not null" />
/// <requires name="parameterNames" condition="not null" />
/// </contract>
private static void SetWebEditParameters(RenderFieldArgs args, params string[] parameterNames)
{
Assert.ArgumentNotNull(args, "args");
Assert.ArgumentNotNull(parameterNames, "parameterNames");
foreach (string key in parameterNames)
{
if (!string.IsNullOrEmpty(args.Parameters[key]))
{
args.WebEditParameters[key] = args.Parameters[key];
}
}
}
public virtual void Process(RenderFieldArgs args)
{
if (!ShouldRun())
{
return;
}
if (!Sitecore.Context.PageMode.IsPageEditorEditing)
{
args.Result.FirstPart = ExpandVelocityTokens(args.Result.FirstPart);
args.Result.LastPart = ExpandVelocityTokens(args.Result.LastPart);
}
}
public void Process(RenderFieldArgs args)
{
/*
* if (Sitecore.Context.PageMode.IsPageEditorEditing)
* return;
*/
if (args.FieldTypeKey.StartsWith("__"))
{
return;
}
args.Result.FirstPart = HashImageReferences(args.Result.FirstPart);
args.Result.LastPart = HashImageReferences(args.Result.LastPart);
}
protected virtual string RunPipeline(Field field)
{
RenderFieldArgs renderFieldArgs = new RenderFieldArgs
{
Item = field.Item,
FieldName = field.Name,
DisableWebEdit = true
};
CorePipeline.Run("renderField", renderFieldArgs);
return(renderFieldArgs.Result.FirstPart + renderFieldArgs.Result.LastPart);
}
public virtual string ReplaceRTETokens(RenderFieldArgs args, string text)
{
StringBuilder sb = new StringBuilder(text);
var current = args.GetField().ID;
if (!TrackTokens(args.Item, current, args.Item.Language, args.Item.Version.Number, text))
{
return(text);
}
foreach (
var location in
TokenLocations[args.Item.ID.ToString() + current + args.Item.Language.Name + args.Item.Version.Number].Item2)
{
if (location.Item1 + location.Item2 > text.Length && !args.WebEditParameters.ContainsKey("reseted"))
{
ResetTokenLocations(args.Item.ID, current, args.Item.Language, args.Item.Version.Number);
args.WebEditParameters["reseted"] = "1";
return(ReplaceRTETokens(args, text));
}
try
{
string token = sb.ToString(location.Item1, location.Item2);
if (Regex.IsMatch(token, TokenRegex))
{
try
{
var value = ParseTokenValueFromTokenIdentifier(token, args.Item);
sb.Replace(token, value, location.Item1, location.Item2);
}
catch
{
// error rendering token - still replace the raw value, but do it with an empty string
sb.Replace(token, string.Empty, location.Item1, location.Item2);
throw;
}
}
else if (!args.WebEditParameters.ContainsKey("reseted"))
{
ResetTokenLocations(args.Item.ID, current, args.Item.Language, args.Item.Version.Number);
args.WebEditParameters["reseted"] = "1";
return(ReplaceRTETokens(args, text));
}
}
catch (Exception e)
{
Log.Error("unable to expand tokens for item " + args.Item.ID, e, this);
}
}
return(sb.ToString());
}
public void Process(RenderFieldArgs args)
{
if (args.FieldTypeKey == "classification")
{
string temp = RenderToHtml(args);
RenderFieldResult result = new RenderFieldResult(temp);
args.Result.FirstPart = result.FirstPart;
args.Result.LastPart = result.LastPart;
args.DisableWebEditContentEditing = false;
args.DisableWebEditContentSelecting = false;
}
}
public static string EditField(string fieldName, Item item)
{
using (new ContextItemSwitcher(item))
{
RenderFieldArgs renderFieldArgs = new RenderFieldArgs();
renderFieldArgs.Item = item;
renderFieldArgs.FieldName = fieldName;
renderFieldArgs.DisableWebEdit = false;
CorePipeline.Run("renderField", (PipelineArgs)renderFieldArgs);
return(renderFieldArgs.Result.ToString());
}
}
public static void ApplyParameters(this RenderFieldArgs args, object parameters)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
CopyProperties(parameters, args);
CopyProperties(parameters, args.Parameters);
}
/// <summary>
/// Processor main method.
/// </summary>
/// <param name="args">
/// The arguments.
/// </param>
public void Process(RenderFieldArgs args)
{
if (args.FieldTypeKey == "classification")
{
using (new LanguageSwitcher(WebUtil.GetCookieValue("shell", "lang", Sitecore.Context.Language.Name)))
{
Database coreDb = Factory.GetDatabase("core");
Item fieldTexts = coreDb.GetItem("/sitecore/content/Applications/WebEdit/WebEdit Texts/Classification Texts");
if (fieldTexts != null)
{
args.RenderParameters["default-text"] = fieldTexts["Default Text"];
}
}
}
}
/// <summary>
/// Replaces the field value with the value with the token values injected
/// </summary>
/// <param name="args"></param>
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
string fieldValue = args.FieldValue;
if (string.IsNullOrWhiteSpace(args.Result.FirstPart))
args.Result.FirstPart = string.IsNullOrEmpty(fieldValue) ? args.Item[args.FieldName] : fieldValue;
if (args.FieldTypeKey != "rich text")
return;
if (!Context.PageMode.IsPageEditorEditing)
args.Result.FirstPart = TokenKeeper.CurrentKeeper.ReplaceRTETokens(args, args.Result.FirstPart);
WordFieldValue wordFieldValue = WordFieldValue.Parse(args.Result.FirstPart);
if (wordFieldValue.BlobId == ID.Null)
return;
args.Result.FirstPart = wordFieldValue.GetHtmlWithStyles();
}
public void Process(RenderFieldArgs args)
{
if (args.FieldTypeKey == "classification")
{
string temp = RenderToHtml(args);
RenderFieldResult result = new RenderFieldResult(temp);
args.Result.FirstPart = result.FirstPart;
args.Result.LastPart = result.LastPart;
args.DisableWebEditContentEditing = false;
args.DisableWebEditContentSelecting = false;
}
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
string fieldTypeKey = args.FieldTypeKey;
if (fieldTypeKey != "youtubevideo") return;
args.DisableWebEditContentEditing = true;
if (!Context.PageMode.IsPageEditorEditing) return;
YouTubeVideoField video = args.GetField();
YouTubeVideoField.ThumbnailSize size;
Enum.TryParse(args.Parameters["Size"], out size); // default is Small
args.Result.FirstPart = YouTubeVideoField.FormatValueForPageEditorDisplay(video.Value, size);
}
/// <summary>
/// Gets the field value.
///
/// </summary>
/// <param name="args">The arguments.</param><contract><requires name="args" condition="none"/></contract>
public new void Process(RenderFieldArgs args)
{
if (args.FieldTypeKey != "image with cropping")
return;
ImageRenderer renderer = CreateRenderer();
renderer.Item = args.Item;
renderer.FieldName = args.FieldName;
XmlValue xmlValue = new XmlValue(args.FieldValue, "image");
string width = xmlValue.GetAttribute("width");
string height = xmlValue.GetAttribute("height");
if (string.IsNullOrWhiteSpace(width) || string.IsNullOrWhiteSpace(height))
{
string cropRegion = xmlValue.GetAttribute("cropregion");
try
{
var coordinates = CustomMediaManager.ConvertToIntArray(cropRegion);
if ((coordinates[2] - coordinates[0] + coordinates[3] + coordinates[1]) > 0)
{
xmlValue.SetAttribute("width", (coordinates[2] - coordinates[0]).ToString());
xmlValue.SetAttribute("height", (coordinates[3] - coordinates[1]).ToString());
renderer.FieldValue = xmlValue.ToString();
}
}
catch (Exception ex)
{
Log.Error(ex.Message, ex, this);
}
}
if (renderer.FieldValue == null)
{
renderer.FieldValue = args.FieldValue;
}
renderer.Parameters = args.Parameters;
args.WebEditParameters.AddRange(args.Parameters);
RenderFieldResult renderFieldResult = renderer.Render();
args.Result.FirstPart = renderFieldResult.FirstPart;
args.Result.LastPart = renderFieldResult.LastPart;
args.DisableWebEditContentEditing = true;
args.DisableWebEditFieldWrapping = true;
args.WebEditClick = "return Sitecore.WebEdit.editControl($JavascriptParameters, 'webedit:chooseimage')";
}
/// <summary>Gets the field value.</summary>
/// <param name="args">The arguments.</param>
/// <contract>
/// <requires name="args" condition="none" />
/// </contract>
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
if (!this.CanWebEdit(args) && !args.WebEditParameters.ContainsKey("sc-highlight-contentchange") || (args.Item == null || !this.CanEditItem(args.Item)))
return;
Field field = args.Item.Fields[args.FieldName];
if (field == null || !this.CanEditField(field))
return;
Item obj = field.Item;
string str = obj[FieldIDs.Revision].Replace("-", string.Empty);
string controlID = "fld_" + (object)obj.ID.ToShortID() + "_" + (object)field.ID.ToShortID() + "_" + (object)obj.Language + "_" + (object)obj.Version + "_" + str + "_" + (object)MainUtil.GetSequencer();
HtmlTextWriter output = new HtmlTextWriter((TextWriter)new StringWriter());
string rawValueContainer = this.GetRawValueContainer(field, controlID);
output.Write(rawValueContainer);
if (args.DisableWebEditContentEditing && args.DisableWebEditFieldWrapping)
this.RenderWrapperlessField(output, args, field, controlID);
else
this.RenderWrappedField(output, args, field, controlID);
}
private string RenderToHtml(RenderFieldArgs args)
{
Database db = Sitecore.Context.ContentDatabase ?? Sitecore.Context.Database;
CategoryItem categoryItem;
string rowValue = string.Empty;
string htmlValue = string.Empty;
string tagId = string.Empty;
string tagWeight = string.Empty;
List<String> listId = new List<String>();
if(!String.IsNullOrEmpty(args.FieldValue))
{
rowValue = args.FieldValue;
args.RawParameters = rowValue;
listId.AddRange(rowValue.Split("|".ToCharArray()));
foreach (string tId in listId)
{
string span;
tagId = StringUtil.GetPrefix(tId, ':');
tagWeight = StringUtil.GetPostfix(tId, ':');
if ((tagId != "Null") && (tagId != ID.Null.ToString()))
{
categoryItem = new CategoryItem(db.GetItem(new ID(tagId)));
span = "<span class='tagSet' tagId='" + tagId + "' weightId='" + tagWeight + "' onclick='tag_select(event);' ondblclick='showAlert(\"" + tagId + "\")'>" + categoryItem.CategoryName + "<wbr /></span>;";
}
else
{
span = "<span class='tagNotFound' tagId='" + tagId + "'>" + tagWeight + "<wbr /></span>;";
}
htmlValue += span;
}
}
return htmlValue;
}
public IFieldRenderingResult Render(object parameters = null)
{
var renderFieldArgs = new RenderFieldArgs()
{
Item = item,
FieldName = fieldName
};
if (parameters != null)
{
renderFieldArgs.ApplyParameters(parameters);
}
CorePipeline.Run(renderFieldPipeline, renderFieldArgs);
var result = renderFieldArgs.Result;
var beginResult = result?.FirstPart;
var endResult = result?.LastPart;
var renderingResult = new FieldRenderingResult(beginResult, endResult);
RenderingResult = renderingResult.Some<IFieldRenderingResult>();
return renderingResult;
}
/// <summary>
/// Processes render field pipline.
/// </summary>
/// <param name="args">
/// The render field argument list.
/// </param>
public new void Process(RenderFieldArgs args)
{
if (args.FieldTypeKey != "image")
{
return;
}
MediaObject mediaObject = new MediaObject
{
// Database = Context.Database.Name,
// DataSource = args.Item.ID.ToString(),
Item = args.Item,
FieldName = args.FieldName,
FieldValue = args.FieldValue,
RenderParameters = args.Parameters
};
args.WebEditParameters.AddRange(args.Parameters);
RenderFieldResult result = new RenderFieldResult(HtmlUtil.RenderControl(mediaObject));
args.Result.FirstPart = result.FirstPart;
args.Result.LastPart = result.LastPart;
args.DisableWebEditContentEditing = true;
args.WebEditClick = "return Sitecore.WebEdit.editControl($JavascriptParameters, 'webedit:chooseimage')";
}
/// <summary>Gets the default image.</summary>
/// <param name="args">The args.</param>
/// <returns>The default image.</returns>
private static string GetDefaultText(RenderFieldArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
string @string = StringUtil.GetString(new string[2]
{
args.RenderParameters["default-text"],
string.Empty
});
using (new LanguageSwitcher(WebUtil.GetCookieValue("shell", "lang", Sitecore.Context.Language.Name)))
{
if (@string.IsNullOrEmpty())
{
Database database = Factory.GetDatabase("core");
Assert.IsNotNull((object)database, "core");
Item obj = database.GetItem("/sitecore/content/Applications/WebEdit/WebEdit Texts");
Assert.IsNotNull((object)obj, "/sitecore/content/Applications/WebEdit/WebEdit Texts");
@string = obj["Default Text"];
}
if (string.Compare(args.RenderParameters["show-title-when-blank"], "true", StringComparison.InvariantCultureIgnoreCase) == 0)
@string = GetFieldDisplayName(args) + ": " + @string;
}
return @string;
}
protected virtual string RunPipeline(Field field)
{
RenderFieldArgs renderFieldArgs = new RenderFieldArgs
{
Item = field.Item,
FieldName = field.Name,
DisableWebEdit = true
};
CorePipeline.Run("renderField", renderFieldArgs);
return renderFieldArgs.Result.FirstPart + renderFieldArgs.Result.LastPart;
}
/// <summary>Gets the display name of the field.</summary>
/// <param name="args">The arguments.</param>
/// <returns>The get field display name.</returns>
private static string GetFieldDisplayName(RenderFieldArgs args)
{
Assert.IsNotNull((object)args, "args");
Assert.IsNotNull((object)args.Item, "item");
Item obj;
if (string.Compare(WebUtil.GetCookieValue("shell", "lang", Sitecore.Context.Language.Name), args.Item.Language.Name, StringComparison.InvariantCultureIgnoreCase) != 0)
{
obj = args.Item.Database.GetItem(args.Item.ID);
Assert.IsNotNull((object)obj, "Item");
}
else
obj = args.Item;
Field field = obj.Fields[args.FieldName];
if (field != null)
return field.DisplayName;
return args.FieldName;
}
/// <summary>Gets the word style string.</summary>
/// <param name="tag">The tag.</param>
/// <param name="args">The arguments.</param>
/// <returns>The word style string.</returns>
private static void ApplyWordFieldStyle(Tag tag, RenderFieldArgs args)
{
Assert.ArgumentNotNull((object)tag, "tag");
Assert.ArgumentNotNull((object)args, "args");
string str1 = args.Parameters["editorwidth"] ?? Settings.WordOCX.Width;
string str2 = args.Parameters["editorheight"] ?? Settings.WordOCX.Height;
string str3 = args.Parameters["editorpadding"] ?? Settings.WordOCX.Padding;
string str4 = str1.ToLowerInvariant().Replace("px", string.Empty);
int int1 = MainUtil.GetInt(str4, -1);
string str5 = str2.ToLowerInvariant().Replace("px", string.Empty);
int int2 = MainUtil.GetInt(str5, -1);
int int3 = MainUtil.GetInt(str3.ToLowerInvariant().Replace("px", string.Empty), -1);
if (int3 >= 0)
{
if (int1 >= 0)
str4 = (int1 + 2 * int3).ToString() + string.Empty;
if (int2 >= 0)
str5 = (int2 + 2 * int3).ToString() + string.Empty;
}
tag.Class += " scWordContainer";
tag.Style = "width:{0}px;height:{1}px;padding:{2};".FormatWith((object)str4, (object)str5, (object)str3);
}
protected abstract void DoRenderField(RenderFieldArgs args);
private string GetResult(Field field, bool isRichText)
{
if (!isRichText)
{
return field.Value;
}
RenderFieldArgs renderFieldArgs = new RenderFieldArgs
{
Item = field.Item,
FieldName = field.Name,
DisableWebEdit = true
};
CorePipeline.Run("renderField", renderFieldArgs);
return renderFieldArgs.Result.FirstPart + renderFieldArgs.Result.LastPart;
}
/// <summary>
/// Determines whether this instance [can web edit] the specified args.
/// </summary>
/// <param name="args">The arguments.</param>
private bool CanWebEdit(RenderFieldArgs args)
{
if (EnableWebEditMode.AllowWebEdit)
{
return true;
}
if (args.DisableWebEdit)
return false;
SiteContext site = Sitecore.Context.Site;
return site != null
&& site.DisplayMode == DisplayMode.Edit && (!(WebUtil.GetQueryString("sc_duration") == "temporary")
#if SC82
&& Sitecore.Context.PageMode.IsExperienceEditorEditing);
#else
&& Sitecore.Context.PageMode.IsPageEditorEditing);
#endif
}
/// <summary>Creates the field tag.</summary>
/// <param name="tagName">Name of the tag.</param>
/// <param name="args">The arguments.</param>
/// <param name="controlID"> </param>
/// <returns>The field tag.</returns>
private static Tag CreateFieldTag(string tagName, RenderFieldArgs args, string controlID)
{
Assert.ArgumentNotNull((object)tagName, "tagName");
Assert.ArgumentNotNull((object)args, "args");
Tag tag = new Tag(tagName)
{
ID = controlID + "_edit"
};
tag.Add("scFieldType", args.FieldTypeKey);
return tag;
}
public virtual IHtmlString RenderBeginField(string parameters = null, bool editing = true)
{
var renderFieldArgs = new RenderFieldArgs
{
Item = Field.Item,
FieldName = Field.Name,
DisableWebEdit = !editing,
RawParameters = parameters ?? string.Empty
};
if (renderFieldArgs.Item == null)
{
return new HtmlString(string.Empty);
}
CorePipeline.Run("renderField", renderFieldArgs);
var result = renderFieldArgs.Result;
var str = result.FirstPart ?? string.Empty;
EndFieldStack.Push(result.LastPart ?? string.Empty);
return new HtmlString(str);
}
protected virtual string RunPipeline(Field field)
{
RenderFieldArgs renderFieldArgs = new RenderFieldArgs
{
Item = field.Item,
FieldName = field.Name,
DisableWebEdit = true
};
try
{
CorePipeline.Run("renderField", renderFieldArgs);
}
catch (Exception ex)
{
throw new MapperException("Failed to render field {0} on item {1}".Formatted(field.ID, field.Item.ID), ex);
}
return renderFieldArgs.Result.FirstPart + renderFieldArgs.Result.LastPart;
}
public void Process(RenderFieldArgs args)
{
args.Result = new RenderFieldResult(args.FieldValue.Replace(ReplacementKey, ReplacementValue));
}
/// <summary>Gets the name of the editable element tag.</summary>
/// <param name="args">The arguments.</param>
/// <returns></returns>
private string GetEditableElementTagName(RenderFieldArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
string str = "span";
if ((UIUtil.IsFirefox() || UIUtil.IsWebkit()) && (UIUtil.SupportsInlineEditing() && MainUtil.GetBool(args.Parameters["block-content"], false)))
str = "div";
return str;
}
/// <summary>Renders the bottom bar.</summary>
/// <param name="args">The arguments.</param>
/// <param name="field">The field.</param>
/// <param name="controlID"> </param>
private static string GetFieldData(RenderFieldArgs args, Field field, string controlID)
{
Assert.ArgumentNotNull((object)args, "args");
Assert.ArgumentNotNull((object)field, "field");
Assert.ArgumentNotNull((object)controlID, "controlID");
Item obj = field.Item;
Assert.IsNotNull((object)Sitecore.Context.Site, "site");
using (new LanguageSwitcher(WebUtil.GetCookieValue("shell", "lang", Sitecore.Context.Site.Language)))
{
GetChromeDataArgs args1 = new GetChromeDataArgs("field", obj, args.Parameters);
args1.CustomData["field"] = (object)field;
GetChromeDataPipeline.Run(args1);
ChromeData chromeData = args1.ChromeData;
SetCommandParametersValue((IEnumerable<WebEditButton>)chromeData.Commands, field, controlID);
return chromeData.ToJson();
}
}
public virtual IHtmlString RenderBeginField(object parameters, bool editing = true)
{
var renderFieldArgs = new RenderFieldArgs
{
Item = Field.Item,
FieldName = Field.Name,
DisableWebEdit = !editing
};
if (parameters != null)
{
TypeHelper.CopyProperties(parameters, renderFieldArgs);
TypeHelper.CopyProperties(parameters, renderFieldArgs.Parameters);
}
if (renderFieldArgs.Item == null)
{
return new HtmlString(string.Empty);
}
CorePipeline.Run("renderField", renderFieldArgs);
var result = renderFieldArgs.Result;
var str = result.FirstPart ?? string.Empty;
EndFieldStack.Push(result.LastPart ?? string.Empty);
return new HtmlString(str);
}
public void Process(RenderFieldArgs args)
{
KernelContainer.Inject(this);
this.DoRenderField(args);
}
public static string GetRichTextRenderFieldPipeline(this Item item, ID fieldId)
{
RenderFieldArgs args = new RenderFieldArgs();
args.Item = item;
args.DisableWebEditFieldWrapping = true;
args.FieldName = GetFieldName(item, fieldId);
CorePipeline.Run("renderField", args);
return args.Result.ToString();
}
