public void AddRendering(Item item, string renderingID, string placeholder, Item datasource)
{
LayoutField layoutField = new LayoutField(item.Fields[FieldIDs.FinalLayoutField]);
LayoutDefinition layoutDefinition = LayoutDefinition.Parse(layoutField.Value);
DeviceDefinition deviceDefinition = layoutDefinition.GetDevice(GetDefaultDeviceItem(item.Database).ID.ToString());
foreach (RenderingDefinition rendering in deviceDefinition.Renderings)
{
if (rendering.ItemID.ToLower() == "{C1624533-ED68-41AC-B03C-BFDE4D9B1F2A}".ToLower())
{
placeholder = StringUtil.EnsurePrefix('/', rendering.Placeholder + "/" + placeholder + "_" + new Guid(rendering.UniqueId).ToString("D").ToLower());
break;
}
}
var newRendering = new RenderingDefinition
{
Placeholder = placeholder,
ItemID = renderingID,
Datasource = datasource.ID.ToString()
};
deviceDefinition.AddRendering(newRendering);
using (new SecurityDisabler())
{
item.Editing.BeginEdit();
layoutField.Value = layoutDefinition.ToXml();
item.Editing.EndEdit();
}
}
/// <summary>
/// Invokes Action on all Final Renderings on item
/// </summary>
private static void ApplyActionToLayoutField(Item item, ID fieldId, Action <RenderingDefinition> action)
{
var currentLayoutXml = LayoutField.GetFieldValue(item.Fields[fieldId]);
if (string.IsNullOrEmpty(currentLayoutXml))
{
return;
}
var newXml = ApplyActionToLayoutXml(currentLayoutXml, action);
if (newXml == null)
{
return;
}
using (new SecurityDisabler())
{
using (new EditContext(item))
{
// NOTE: when dealing with layouts its important to get and set the field value with LayoutField.Get/SetFieldValue()
// if you fail to do this you will not process layout deltas correctly and may instead override all fields (breaking full inheritance),
// or attempt to get the layout definition for a delta value, which will result in your wiping the layout details when they get saved.
LayoutField.SetFieldValue(item.Fields[fieldId], newXml);
}
}
}
/// <summary>
/// Gets the list of placeholder settings items attached to the context item for the
/// specified placeholder key.
/// </summary>
/// <param name="placeholderKey">The placeholder key.</param>
/// <param name="database">The database context.</param>
/// <returns>The list of placeholder settings items.</returns>
public static IEnumerable <Item> GetPlaceholderItems(string placeholderKey, Database database)
{
Assert.ArgumentNotNull(placeholderKey, nameof(placeholderKey));
Assert.ArgumentNotNull(database, nameof(database));
// If nothing has been defined in the 'Layout' field then fall back to base functionality
string layoutDefinition = null;
if (Context.PageDesigner.IsDesigning)
{
string pageDesignerHandle = Context.PageDesigner.PageDesignerHandle;
if (!string.IsNullOrEmpty(pageDesignerHandle))
{
layoutDefinition = WebUtil.GetSessionString(pageDesignerHandle);
}
}
Item item = Context.Item;
if (item != null && string.IsNullOrEmpty(layoutDefinition))
{
layoutDefinition = new LayoutField(item).Value;
}
// placeholder data is stored in the Layout fiels, do if the context item does not have any
// layout information then we can return null
if (string.IsNullOrEmpty(layoutDefinition))
{
return(null);
}
return(GetPlaceholderItems(placeholderKey, database, layoutDefinition));
}
protected override void ProcessPlaceholderSettings(Item item, LayoutDefinition layout, DeviceDefinition device,
List <PlaceholderDefinition> placeholders)
{
if (placeholders.Any())
{
if (!ShouldProcess(item.GetProviderPath(),
$"Remove placeholder setting(s) '{placeholders.Select(r => r.MetaDataItemId.ToString()).Aggregate((seed, curr) => seed + ", " + curr)}' from device {Device.Name}")
)
{
return;
}
foreach (
var placeholderSetting in
placeholders.Select(rendering => device.Placeholders.Cast <PlaceholderDefinition>()
.FirstOrDefault(r => r.UniqueId == rendering.UniqueId))
.Where(placeholder => placeholder != null)
.Reverse())
{
device.Placeholders.Remove(placeholderSetting);
}
item.Edit(p =>
{
var outputXml = layout.ToXml();
LayoutField.SetFieldValue(Item.Fields[LayoutFieldId], outputXml);
});
}
else
{
WriteError(typeof(ObjectNotFoundException), "Cannot find a placeholder setting to remove",
ErrorIds.PlaceholderSettingNotFound, ErrorCategory.ObjectNotFound, null);
}
}
private static void UpdateFinalRenderings(Item sourcePageItem, Item targetPageItem, Field sourceFinalRenderingsField, Field targetFinalRenderingsField)
{
// get source renderings
var sourceDefaultDevice = sourcePageItem.Database.Resources.Devices.GetAll().First(d => d.IsDefault);
var sourceLayoutField = new LayoutField(sourceFinalRenderingsField);
var sourceLayoutDefinition = LayoutDefinition.Parse(sourceLayoutField.Value);
var sourceDeviceDefinition = sourceLayoutDefinition.GetDevice(sourceDefaultDevice.ID.ToString());
// get target renderings
var targetDefaultDevice = targetPageItem.Database.Resources.Devices.GetAll().First(d => d.IsDefault);
var targetLayoutField = new LayoutField(targetFinalRenderingsField);
var targetLayoutDefinition = LayoutDefinition.Parse(targetLayoutField.Value);
var targetDeviceDefinition = targetLayoutDefinition.GetDevice(targetDefaultDevice.ID.ToString());
foreach (RenderingDefinition sourceRendering in sourceDeviceDefinition.Renderings)
{
var duplicateRendering =
targetDeviceDefinition.Renderings.Cast <RenderingDefinition>()
.FirstOrDefault(r => r.UniqueId.Equals(sourceRendering.UniqueId));
// Rendering isn't already on target renderings
if (duplicateRendering == null)
{
targetDeviceDefinition.Renderings.Add(sourceRendering);
}
}
// save changes
using (new EditContext(targetPageItem))
{
targetFinalRenderingsField.Value = targetLayoutDefinition.ToXml();
}
}
private static void ApplyActionToAllRenderings(Item item, ID fieldId, Func <RenderingDefinition, RenderingActionResult> action)
{
var currentLayoutXml = LayoutField.GetFieldValue(item.Fields[fieldId]);
if (string.IsNullOrEmpty(currentLayoutXml))
{
return;
}
var newXml = ApplyActionToLayoutXml(currentLayoutXml, action);
if (newXml == null)
{
return;
}
// save a modified layout value
using (new SecurityDisabler())
{
using (new EditContext(item))
{
LayoutField.SetFieldValue(item.Fields[fieldId], newXml);
}
}
}
public virtual LayoutField UpdateLayoutField(LayoutField entity)
{
if (entity.IsTransient())
{
return(entity);
}
LayoutField other = GetLayoutField(entity.LayoutFieldId);
if (entity.Equals(other))
{
return(entity);
}
string sql = @"Update LayoutField set [LayoutFieldGUID]=@LayoutFieldGUID
, [LayoutID]=@LayoutID
, [FieldType]=@FieldType
, [FieldID]=@FieldID
, [CreatedOn]=@CreatedOn
where LayoutFieldID=@LayoutFieldID" ;
SqlParameter[] parameterArray = new SqlParameter[] {
new SqlParameter("@LayoutFieldID", entity.LayoutFieldId)
, new SqlParameter("@LayoutFieldGUID", entity.LayoutFieldGuid)
, new SqlParameter("@LayoutID", entity.LayoutId ?? (object)DBNull.Value)
, new SqlParameter("@FieldType", entity.FieldType ?? (object)DBNull.Value)
, new SqlParameter("@FieldID", entity.FieldId)
, new SqlParameter("@CreatedOn", entity.CreatedOn)
};
SqlHelper.ExecuteNonQuery(this.ConnectionString, CommandType.Text, sql, parameterArray);
return(GetLayoutField(entity.LayoutFieldId));
}
/// <summary>
/// Identify the items with a presentation detail
/// </summary>
/// <param name="item">Item to check</param>
/// <returns></returns>
private bool IsPage(Item item)
{
var result = false;
var layoutField = new LayoutField(item.Fields[FieldIDs.LayoutField]);
if (!layoutField.InnerField.HasValue || string.IsNullOrEmpty(layoutField.Value))
{
return(false);
}
var layout = LayoutDefinition.Parse(layoutField.Value);
foreach (var deviceObj in layout.Devices)
{
var device = deviceObj as DeviceDefinition;
if (device == null)
{
return(false);
}
if (device.Renderings.Count > 0)
{
result = true;
}
}
return(result);
}
protected virtual void SetLayoutFieldValue([NotNull] Field field, [NotNull] string value)
{
// handle layout deltas
var layoutField = new LayoutField(field);
layoutField.Value = value;
}
protected override void OnLoad(EventArgs e)
{
Assert.CanRunApplication("Content Editor/Ribbons/Chunks/Layout");
Assert.ArgumentNotNull(e, "e");
base.OnLoad(e);
this.Tabs.OnChange += (sender, args) => this.Refresh();
if (!Context.ClientPage.IsEvent)
{
Item currentItem = GetCurrentItem();
Assert.IsNotNull(currentItem, "Item not found");
this.Layout = LayoutField.GetFieldValue(currentItem.Fields[FieldIDs.LayoutField]);
Field field = currentItem.Fields[FieldIDs.FinalLayoutField];
if (currentItem.Name != "__Standard Values")
{
this.LayoutDelta = field.GetValue(false, false) ?? field.GetInheritedValue(false);
}
else
{
this.LayoutDelta = field.GetStandardValue();
}
this.ToggleVisibilityOfControlsOnFinalLayoutTab(currentItem);
this.Refresh();
}
SiteContext site = Context.Site;
if (site != null)
{
site.Notifications.ItemSaved += new ItemSavedDelegate(this.ItemSavedNotification);
}
}
protected override void ProcessItem(Item item)
{
LayoutField layoutField = item.Fields[LayoutFieldId];
if (string.IsNullOrEmpty(layoutField?.Value))
{
return;
}
var layout = LayoutDefinition.Parse(layoutField.Value);
if (Device == null)
{
Device = CurrentDatabase.Resources.Devices.GetAll().FirstOrDefault(d => d.IsDefault);
}
if (Device == null)
{
WriteError(
new ErrorRecord(
new ObjectNotFoundException(
"Device not provided and no default device in the system is defined."),
"sitecore_device_not_found", ErrorCategory.InvalidData, null));
return;
}
var device = layout.GetDevice(Device.ID.ToString());
if (device != null)
{
ProcessLayout(item, layout, device);
}
}
protected override void ProcessItem(Item item)
{
if (ShouldProcess(item.GetProviderPath(), string.Format("Set layout '{0}'", Layout.GetProviderPath())))
{
LayoutField layoutField = item.Fields[LayoutFieldId];
if (layoutField == null)
{
return;
}
var layout = LayoutDefinition.Parse(layoutField.Value);
var device = layout.GetDevice(Device.ID.ToString());
if (string.Equals(device.Layout, Layout.ID.ToString(), StringComparison.OrdinalIgnoreCase))
{
//same layout as already set - no point in setting it again
return;
}
device.Layout = Layout.ID.ToString();
item.Edit(p =>
{
var outputXml = layout.ToXml();
LayoutField.SetFieldValue(item.Fields[LayoutFieldId], outputXml);
});
}
}
protected override void ProcessItem(Item item)
{
if (!ShouldProcess(item.GetProviderPath(),
$"Merging layout from '{item.Language.Name}' to shared layout."))
{
return;
}
var shared = new LayoutField(item.Fields[Sitecore.FieldIDs.LayoutField]);
var final = new LayoutField(item.Fields[Sitecore.FieldIDs.FinalLayoutField]);
//If we don't have a final layout delta, we're good!
if (string.IsNullOrWhiteSpace(final.Value))
{
WriteVerbose("No final layout - nothing to do.");
return;
}
var finalLayoutDefinition = LayoutDefinition.Parse(final.Value);
item.Edit(p =>
{
LayoutField.SetFieldValue(item.Fields[Sitecore.FieldIDs.LayoutField],
finalLayoutDefinition.ToXml());
shared.Value = finalLayoutDefinition.ToXml();
final.InnerField.Reset();
});
}
protected override void ProcessRenderings(Item item, LayoutDefinition layout, DeviceDefinition device,
List <RenderingDefinition> renderings)
{
if (renderings.Any())
{
if (!ShouldProcess(item.GetProviderPath(),
$"Switch rendering(s) '{renderings.Select(r => r.ItemID.ToString()).Aggregate((seed, curr) => seed + ", " + curr)}' for device {Device.Name}"))
{
return;
}
foreach (
var instanceRendering in
renderings.Select(rendering => device.Renderings.Cast <RenderingDefinition>()
.FirstOrDefault(r => r != null && r.UniqueId == rendering.UniqueId))
.Where(instanceRendering => instanceRendering != null)
.Reverse())
{
DoReplaceRendering(instanceRendering, NewRendering, device);
}
item.Edit(p =>
{
var outputXml = layout.ToXml();
LayoutField.SetFieldValue(item.Fields[LayoutFieldId], outputXml);
});
}
else
{
WriteError(typeof(ObjectNotFoundException), "Cannot find a rendering to remove",
ErrorIds.RenderingNotFound, ErrorCategory.ObjectNotFound, null);
}
}
public void CleanRenderings(Item item, string renderingID, string placeholder)
{
LayoutField layoutField = new LayoutField(item.Fields[FieldIDs.FinalLayoutField]);
LayoutDefinition layoutDefinition = LayoutDefinition.Parse(layoutField.Value);
DeviceDefinition deviceDefinition = layoutDefinition.GetDevice(GetDefaultDeviceItem(item.Database).ID.ToString());
List <string> placeholders = new List <string>();
foreach (RenderingDefinition rendering in deviceDefinition.Renderings)
{
if (rendering.ItemID.ToLower() == "{C1624533-ED68-41AC-B03C-BFDE4D9B1F2A}".ToLower())
{
placeholders.Add(StringUtil.EnsurePrefix('/', rendering.Placeholder + "/" + placeholder + "_" + new Guid(rendering.UniqueId).ToString("D").ToLower()));
}
}
List <RenderingDefinition> renderingsToRemove = new List <RenderingDefinition>();
foreach (RenderingDefinition rendering in deviceDefinition.Renderings)
{
if (rendering.ItemID.ToLower() == renderingID.ToLower() && placeholders.Contains(rendering.Placeholder))
{
renderingsToRemove.Add(rendering);
}
}
foreach (var rendering in renderingsToRemove)
{
deviceDefinition.Renderings.Remove(rendering);
}
using (new SecurityDisabler())
{
item.Editing.BeginEdit();
layoutField.Value = layoutDefinition.ToXml();
item.Editing.EndEdit();
}
}
public static void MergeLayouts([NotNull] this Item item)
{
//Grab the field that contains the layout
var layoutField = new LayoutField(item.Fields[Sitecore.FieldIDs.LayoutField]);
//Grab the field that contains the final layout
var finalLayoutField = new LayoutField(item.Fields[Sitecore.FieldIDs.FinalLayoutField]);
if (layoutField == null)
{
throw new Exception("Couldn't find layout on: {0}".FormatWith(item.Name));
}
if (finalLayoutField == null)
{
throw new Exception("Couldn't find final layout on: {0}".FormatWith(item.Name));
}
//If we don't have a final layout delta, we're good!
if (string.IsNullOrWhiteSpace(finalLayoutField.Value))
{
return;
}
var finalLayoutDefinition = LayoutDefinition.Parse(finalLayoutField.Value);
using (new EditContext(item))
{
layoutField.Value = finalLayoutDefinition.ToXml();
item.Fields["__Final Renderings"].Reset();
item.Editing.AcceptChanges();
}
}
/// <summary>
/// Queries the state of the command.
/// The command should only be triggered if a valid item is selected,
/// which has a version and a defined layout.
/// </summary>
/// <param name="context">The context</param>
/// <returns>The state of the command</returns>
public override CommandState QueryState(CommandContext context)
{
Assert.ArgumentNotNull(context, "context");
if (context.Items.Length != 1)
{
return(CommandState.Hidden);
}
Item selectedItem = context.Items[0];
if (selectedItem.TemplateID == TemplateIDs.Template ||
selectedItem.TemplateID == TemplateIDs.TemplateSection ||
selectedItem.TemplateID == TemplateIDs.TemplateField)
{
return(CommandState.Hidden);
}
Sitecore.Data.Version[] versionNumbers = selectedItem.Versions.GetVersionNumbers(false);
if (versionNumbers == null || versionNumbers.Length == 0 || selectedItem.Appearance.ReadOnly)
{
return(CommandState.Disabled);
}
if (!selectedItem.Access.CanWrite() || !selectedItem.Access.CanRemoveVersion() ||
IsLockedByOther(selectedItem))
{
return(CommandState.Disabled);
}
selectedItem.Fields.ReadAll();
LayoutField layoutField = new LayoutField(selectedItem.Fields[FieldIDs.LayoutField]);
return(string.IsNullOrEmpty(layoutField.Value) ? CommandState.Disabled : base.QueryState(context));
}
public void ShouldBeAbleToSetLayoutFieldValue()
{
ID itemId = ID.NewID;
using (var db = new Db
{
new DbItem("page", itemId)
{
new DbField(FieldIDs.LayoutField)
{
Value = "<r/>"
}
}
})
{
DbItem fakeItem = db.DataStorage.GetFakeItem(itemId);
Assert.Equal("<r/>", fakeItem.Fields[FieldIDs.LayoutField].Value);
var item = db.GetItem("/sitecore/content/page");
var layoutField = item.Fields[FieldIDs.LayoutField];
Assert.Equal("<r/>", layoutField.Value);
Assert.Equal("<r/>", item[FieldIDs.LayoutField]);
Assert.Equal("<r/>", item["__Renderings"]);
Assert.Equal("<r/>", LayoutField.GetFieldValue(item.Fields[FieldIDs.LayoutField]));
}
}
/// <summary>
/// Runs the pipeline, which opens the copy page to versions dialog
/// </summary>
/// <param name="args">The pipeline args.</param>
protected void Run(ClientPipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
Item[] items = DeserializeItems(args.Parameters["items"]);
Item selectedItem = items[0];
if (items.Length == 0)
{
SheerResponse.Alert("Unable to get the selected item for the copy to version dialog! Maybe it was deleted by another user, or it is not accessible.");
Context.ClientPage.SendMessage(this, "item:refresh");
return;
}
selectedItem.Fields.ReadAll();
var layoutField = new LayoutField(selectedItem.Fields[FieldIDs.LayoutField]);
if (string.IsNullOrEmpty(layoutField.Value))
{
SheerResponse.Alert("Unable to get the selected item for the copy to version dialog! Maybe it was deleted by another user, or it is not accessible.");
Context.ClientPage.SendMessage(this, "item:refresh");
return;
}
if (!SheerResponse.CheckModified())
{
return;
}
if (args.IsPostBack)
{
return;
}
if (selectedItem.Appearance.ReadOnly)
{
SheerResponse.Alert("You cannot edit the '{0}' item because it is protected.", selectedItem.DisplayName);
return;
}
if (!selectedItem.Access.CanWrite())
{
SheerResponse.Alert("You cannot edit this item because you do not have write access to it.");
return;
}
UrlString urlString = new UrlString("/sitecore/client/Applications/Dialogs/CopyPageToVersionsDialog");
selectedItem.Uri.AddToUrlString(urlString);
urlString["id"] = selectedItem.ID.ToString();
urlString["lang"] = selectedItem.Language.Name;
bool flag = string.Equals(Context.Language.Name, "ja-JP", StringComparison.InvariantCultureIgnoreCase);
SheerResponse.ShowModalDialog(urlString.ToString(), flag ? "650px" : "500px", flag ? "690px" : "650px", string.Empty, true);
args.WaitForPostBack();
}
protected override void ProcessLayout(Item item, LayoutDefinition layout, DeviceDefinition device)
{
if (!ShouldProcess(item.GetProviderPath(), "Add rendering " + Instance.ItemID))
{
return;
}
var rendering = new RenderingDefinition
{
ItemID = Instance.ItemID,
Placeholder = PlaceHolder ?? Instance.Placeholder,
Datasource = DataSource ?? Instance.Datasource,
Cachable = Instance.Cachable,
ClearOnIndexUpdate = Instance.ClearOnIndexUpdate,
VaryByData = Instance.VaryByData,
VaryByDevice = Instance.VaryByDevice,
VaryByLogin = Instance.VaryByLogin,
VaryByParameters = Instance.VaryByParameters,
VaryByQueryString = Instance.VaryByQueryString,
VaryByUser = Instance.VaryByUser
};
if (Parameter != null)
{
var parameters = new UrlString(rendering.Parameters ?? string.Empty);
foreach (string name in Parameter.Keys)
{
if (parameters.Parameters.AllKeys.Contains(name))
{
parameters.Parameters[name] = Parameter[name].ToString();
}
else
{
parameters.Add(name, Parameter[name].ToString());
}
}
rendering.Parameters = parameters.ToString();
}
//todo: add support for conditions
//renderingDefinition.Conditions
//todo: add support for multivariate tests
//rendering.MultiVariateTest
if (Index > -1)
{
device.Insert(Index, rendering);
}
else
{
device.AddRendering(rendering);
}
item.Edit(p =>
{
var outputXml = layout.ToXml();
LayoutField.SetFieldValue(item.Fields[LayoutFieldId], outputXml);
});
}
protected void Run(ClientPipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
string id = args.Parameters["id"];
Language sourceLang = Language.Parse(args.Parameters["sourceLang"]);
Language targetLang = Language.Parse(args.Parameters["targetLang"]);
LinkSet = new HashSet <ID>();
Item item = Context.ContentDatabase.GetItem(id, targetLang);
if (item == null)
{
return;
}
if (Context.IsAdministrator || (item.Access.CanWrite() && (item.Locking.CanLock() || item.Locking.HasLock())))
{
if (SheerResponse.CheckModified())
{
AddAllReferences(item);
LayoutField layoutField = item.Fields[FieldIDs.LayoutField];
if (!string.IsNullOrEmpty(layoutField.Value))
{
LayoutDefinition layout = LayoutDefinition.Parse(layoutField.Value);
foreach (DeviceDefinition device in layout.Devices)
{
foreach (RenderingDefinition rendering in device.Renderings)
{
Item datasourceItem = Context.ContentDatabase.GetItem(rendering.Datasource ?? string.Empty, targetLang);
if (datasourceItem == null)
{
continue;
}
AddAllReferences(datasourceItem);
if (ChildrenGroupingTemplates.Contains(datasourceItem.TemplateName))
{
foreach (Item childItem in datasourceItem.Children)
{
AddAllReferences(childItem);
}
}
}
}
}
foreach (ID linkId in LinkSet)
{
CopyVersion(linkId, sourceLang, targetLang);
}
}
}
}
public void Process(ExtractRenderingsDatasourceArgs args)
{
if (string.IsNullOrWhiteSpace(FieldId) || !ID.IsID(FieldId))
{
return;
}
var fieldId = new ID(FieldId);
var layoutField = args.IndexedItem.Fields[fieldId];
var layoutXml = LayoutField.GetFieldValue(layoutField);
if (string.IsNullOrEmpty(layoutXml))
{
return;
}
var renderings = args.IndexedItem.Visualization.GetRenderings(args.DeviceItem, false);
if (renderings == null || renderings.Length == 0)
{
return;
}
for (var renderingIndex = renderings.Length - 1; renderingIndex >= 0; renderingIndex--)
{
var rendering = renderings[renderingIndex];
if (rendering == null || rendering.Database != args.IndexedItem.Database)
{
continue;
}
if (!args.IndexableRenderingIds.Contains(rendering.RenderingID))
{
continue;
}
var datasourceId = rendering.Settings.DataSource;
if (!ID.IsID(datasourceId))
{
continue;
}
var datasourceItem = GetDatasourceWithFallback(args.IndexedItem.Database, new ID(datasourceId), args.IndexedItem.Language);
if (datasourceItem == null || datasourceItem.Versions.Count == 0)
{
continue;
}
args.DatasourceItems.Add(datasourceItem);
}
}
protected void Page_Load(object sender, EventArgs e)
{
LayoutField lfield = new LayoutField();
ThisLayout = (Page as SkinBase).ThisLayout;
ThisCustomer = (Page as SkinBase).ThisCustomer;
//ThisParser = (Page as SkinBase).GetParser;
if (ThisCustomer.IsAdminUser)
{
String tName = litTextPanelAdmin.NamingContainer.ID;
try
{
lfield = ThisLayout.LayoutFields.Single(lf => lf.FieldID.Equals(tName, StringComparison.OrdinalIgnoreCase) && lf.FieldType.Equals(LayoutFieldEnum.ASPDNSFTextField));
ThisField = lfield;
}
catch { }
litTextPanel.Visible = false;
litTextPanelAdmin.Visible = true;
btnTextPanel.Visible = true;
//lblTextPanel.Visible = true;
//ibEditImage.Style["borderwidth"] = "3px";
//imgEditImage.Attributes.Add("onMouseOver", "this.style='border: 1px solid;'");
//imgEditImage.Attributes.Add("onMouseOut", "this.style='border: 0px none;'");
}
else
{
String tName = litTextPanel.NamingContainer.ID;
try
{
lfield = ThisLayout.LayoutFields.Single(lf => lf.FieldID.Equals(tName, StringComparison.OrdinalIgnoreCase) && lf.FieldType.Equals(LayoutFieldEnum.ASPDNSFTextField));
ThisField = lfield;
}
catch { }
litTextPanel.Visible = true;
litTextPanelAdmin.Visible = false;
btnTextPanel.Visible = false;
}
ConfigureTextPanel ctp = (ConfigureTextPanel)FindControl("ctrlConfigureText");
ctp.Datasource = ThisField;
ctp.ThisLayout = ThisLayout;
//ConfigureImagePanel cip = (ConfigureImagePanel)FindControl("ctrlConfigureImage");
//cip.Datasource = ThisField;
//cip.ThisLayout = ThisLayout;
InitializeControls(lfield);
//GetDefaultImage();
}
internal static int CalculateOffset(this LayoutField field, LayoutField previousField, ParserTargetInfo targetInfo)
{
var type = field.QualifiedType.Type.Desugar();
var prevFieldSize = previousField.QualifiedType.Type.Desugar().GetWidth(targetInfo) / 8;
var unalignedOffset = previousField.Offset + prevFieldSize;
var alignment = type.GetAlignment(targetInfo) / 8;
var alignedOffset = (unalignedOffset + (alignment - 1)) & -alignment;
return((int)alignedOffset);
}
public void ShouldWorkWithLayoutDeltas()
{
ID templateId = ID.NewID;
string templateLayout =
@"<r xmlns:xsd=""http://www.w3.org/2001/XMLSchema"">
<d id=""{FE5D7FDF-89C0-4D99-9AA3-B5FBD009C9F3}"" l=""{4CA7478E-6184-4890-9072-1156DB468A1B}"" />
<d id=""{EF7176AE-2502-401A-96C0-1E9918A982F7}"" l=""{4CA7478E-6184-4890-9072-1156DB468A1B}"" />
<d id=""{5A6E7DC3-987F-4E74-AF78-AC0E544975F2}"" l=""{4CA7478E-6184-4890-9072-1156DB468A1B}"" />
</r>";
string itemDelta =
@"<r xmlns:p=""p"" xmlns:s=""s"" p:p=""1"">
<d id=""{FE5D7FDF-89C0-4D99-9AA3-B5FBD009C9F3}"">
<r uid=""{BC2FDEAE-A971-420B-A874-BA5C767C42FE}"" s:id=""{B5BFA387-74C8-416B-98AF-01C9230C24B2}"" s:ph=""Score Content Main"" />
</d>
</r>";
string merged = XmlDeltas.ApplyDelta(templateLayout, itemDelta);
using (var db = new Db()
{
new DbTemplate("main", templateId)
{
{ FieldIDs.LayoutField, templateLayout }
},
new DbItem("page", ID.NewID, templateId),
new DbItem("page2", ID.NewID, templateId)
{
new DbField(FieldIDs.LayoutField)
{
Value = itemDelta
}
}
})
{
Item item = db.GetItem("/sitecore/content/page");
#pragma warning disable 618
Assert.Equal(templateLayout, StandardValuesManager.Provider.GetStandardValue(item.Fields[FieldIDs.LayoutField]));
#pragma warning restore 618
Assert.Equal(templateLayout, LayoutField.GetFieldValue(item.Fields[FieldIDs.LayoutField]));
// standard values
Assert.Equal(templateLayout, item[FieldIDs.LayoutField]);
var item2 = db.GetItem("/sitecore/content/page2");
Assert.Equal(templateLayout, item2.Fields[FieldIDs.LayoutField].GetStandardValue());
// just checking
Assert.True(XmlPatchUtils.IsXmlPatch(itemDelta));
Assert.Equal(merged, LayoutField.GetFieldValue(item2.Fields[FieldIDs.LayoutField]));
}
}
public override string CreateRenderer()
{
DataTable table = this.DataSet.Tables[TableIndex];
List <LayoutField> layoutFields = new List <LayoutField>();
if (GridScheme != null)
{
HashSet <string> exist = new HashSet <string>();
foreach (var item in GridScheme.GridFields)
{
LibGridFieldScheme realItem = item.Field;
if (!exist.Contains(realItem.Name))
{
exist.Add(realItem.Name);
}
if (!table.Columns.Contains(realItem.Name))
{
continue;
}
LayoutField field = new LayoutField(table.Columns[realItem.Name], TableIndex);
if (realItem.Width != field.Width)
{
field.Width = realItem.Width;
}
layoutFields.Add(field);
}
foreach (var item in this.FieldList)
{
if (exist.Contains(item))
{
continue;
}
if (string.IsNullOrEmpty(item) || table.Columns.Contains(item) == false)
{
continue;
}
LayoutField field = new LayoutField(table.Columns[item], TableIndex);
field.Hidden = true;
layoutFields.Add(field);
}
}
else
{
foreach (var item in this.FieldList)
{
if (string.IsNullOrEmpty(item) || table.Columns.Contains(item) == false)
{
continue;
}
layoutFields.Add(new LayoutField(table.Columns[item], TableIndex));
}
}
return(JsBuilder.BuildGrid(layoutFields, AddAutoRowNo));
}
/// <summary>
/// Assume convention that rendering name matches prefab name
/// Lookup item from defined global repository
/// </summary>
/// <param name="args"></param>
public override void Process(CreatePrefabArgs args)
{
Assert.IsNotNull(args, "args");
Assert.IsNotNull(args.Result, "args.Result");
Assert.IsNotNullOrEmpty(args.Name, "args.Name");
Assert.IsNotNull(args.DeviceId, "args.DeviceId");
Assert.IsNotNull(args.LayoutId, "args.LayoutId");
var prefab = args.Result;
using (new SecurityDisabler())
{
using (new EventDisabler())
{
// Fill Prefab
prefab.Editing.BeginEdit();
try
{
// Display Name (if input wasn't valid name)
if (prefab.Name != args.Name)
{
prefab[FieldIDs.DisplayName] = args.Name;
}
var prefabSharedLayoutField = prefab.Fields[FieldIDs.LayoutField];
var prefabSharedLayout = LayoutDefinition.Parse(LayoutField.GetFieldValue(prefabSharedLayoutField));
DeviceDefinition prefabDevice = prefabSharedLayout.GetDevice(args.DeviceId); // match device
// Set Layout
prefabDevice.Layout = args.LayoutId;
// Add Renderings
foreach (var r in args.Renderings)
{
prefabDevice.AddRendering(r);
}
LayoutField.SetFieldValue(prefabSharedLayoutField, prefabSharedLayout.ToXml());
prefab.Editing.EndEdit(true, true); // Must be silent as to not break content editor context item
// Manually clear the cache (because we are in silent mode)
prefab.Database.Caches.DataCache.RemoveItemInformation(prefab.ID);
prefab.Database.Caches.ItemCache.RemoveItem(prefab.ID);
}
catch (Exception ex)
{
prefab.Editing.CancelEdit();
Log.Error($"{nameof(FillPrefab)}::{nameof(Process)} - Unable to fill prefab, {args.Result.ID}, {args.Name}", ex, this);
}
}
}
}
private List <KeyValuePair <string, string> > ChangeLayoutFieldForItem(Item currentItem, Field field)
{
var result = new List <KeyValuePair <string, string> >();
string xml = LayoutField.GetFieldValue(field);
if (!string.IsNullOrWhiteSpace(xml))
{
var details = LayoutDefinition.Parse(xml);
var device = details.GetDevice(DefaultDeviceId);
var deviceItem = currentItem.Database.Resources.Devices["Default"];
var renderings = currentItem.Visualization.GetRenderings(deviceItem, false);
if (device?.Renderings != null)
{
bool requiresUpdate = false;
foreach (RenderingDefinition rendering in device.Renderings)
{
if (!string.IsNullOrWhiteSpace(rendering.Placeholder))
{
var newPlaceholder = rendering.Placeholder;
foreach (Match match in Regex.Matches(newPlaceholder, PlaceholderRegex, RegexOptions.IgnoreCase))
{
var renderingId = match.Value;
var newRenderingId = "-{" + renderingId.ToUpper().Substring(1) + "}-0";
newPlaceholder = newPlaceholder.Replace(match.Value, newRenderingId);
requiresUpdate = true;
}
result.Add(new KeyValuePair <string, string>(rendering.Placeholder, newPlaceholder));
rendering.Placeholder = newPlaceholder;
}
}
if (requiresUpdate)
{
string newXml = details.ToXml();
using (new EditContext(currentItem))
{
LayoutField.SetFieldValue(field, newXml);
}
}
}
}
return(result);
}
public static LayoutDefinition GetFinalLayoutDefinition(this Item item)
{
var layoutField = item.Fields[FieldIDs.FinalLayoutField];
var fieldValue = LayoutField.GetFieldValue(layoutField);
if (string.IsNullOrEmpty(fieldValue))
{
return(null);
}
return(LayoutDefinition.Parse(fieldValue));
}
private Sitecore.Layouts.RenderingReference[] GetRenderingReferences(Item item, string deviceName)
{
LayoutField layoutField = item.Fields["__final renderings"];
if (layoutField == null)
{
return(null);
}
RenderingReference[] renderings = layoutField.GetReferences(GetDeviceItem(item.Database, deviceName));
return(renderings);
}
public void OnItemSaving(object sender, EventArgs args)
{
Item item = Event.ExtractParameter(args, 0) as Item;
if (item == null)
{
return;
}
LayoutField layoutField = new LayoutField(item.Fields[Sitecore.FieldIDs.LayoutField]);
if (!layoutField.InnerField.HasValue)
{
return;
}
Item existingItem = item.Database.GetItem(
item.ID,
item.Language,
item.Version);
if (existingItem == null)
{
return;
}
LayoutField oldLayout = new LayoutField(existingItem.Fields[Sitecore.FieldIDs.LayoutField]);
if (string.IsNullOrEmpty(layoutField.Value) || layoutField.Value == oldLayout.Value)
{
return;
}
LayoutDefinition layout = LayoutDefinition.Parse(layoutField.Value);
for (int i = 0; i < layout.Devices.Count; i++)
{
DeviceDefinition device = layout.Devices[i] as DeviceDefinition;
for (int j = 0; j < device.Renderings.Count; j++)
{
RenderingDefinition rendering = device.Renderings[j] as RenderingDefinition;
if (!string.IsNullOrEmpty(rendering.Datasource) && rendering.Datasource.StartsWith("/"))
{
Item datasourceItem = item.Database.GetItem(rendering.Datasource);
if (datasourceItem == null)
{
Sitecore.Diagnostics.Log.Warn(string.Format("Could not find datasource item at path {0} while saving item {1}", rendering.Datasource, item.ID), this);
continue;
}
rendering.Datasource = datasourceItem.ID.ToString();
}
}
}
layoutField.Value = layout.ToXml();
}
private void AddField(LayoutField field)
{
_fields.Add(field);
_fieldsByName[field.Name] = field;
}
private LayoutField(LayoutField.__Internal native, bool skipVTables = false)
: this(__CopyValue(native), skipVTables)
{
__ownsNativeInstance = true;
NativeToManagedMap[__Instance] = this;
}
private static void* __CopyValue(LayoutField.__Internal native)
{
var ret = Marshal.AllocHGlobal(40);
global::CppSharp.Parser.AST.LayoutField.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
return ret.ToPointer();
}
public static LayoutField __CreateInstance(LayoutField.__Internal native, bool skipVTables = false)
{
return new LayoutField(native, skipVTables);
}
protected virtual void SetLayoutFieldValue([Diagnostics.NotNull] Field field, [Diagnostics.NotNull] string value)
{
// handle layout deltas
var layoutField = new LayoutField(field);
layoutField.Value = value;
}
/// <summary>
/// Returns a parsed layout document
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private XDocument GetLayoutXml(Item item)
{
LayoutField lf = new LayoutField(item);
Field field = new LayoutField(item).InnerField;
if (field == null)
{
return null;
}
string layoutXml = LayoutField.GetFieldValue(field);
if (string.IsNullOrWhiteSpace(layoutXml))
{
return null;
}
try
{
return XDocument.Parse(layoutXml);
}
catch (Exception ex)
{
Log.Error("Could not parse layout for " + item.Paths.FullPath, ex, this);
return null;
}
}
