private string RemoveReferenceLinks(Item item)
{
var links = Globals.LinkDatabase.GetItemReferrers(item, true);
if (links.Length == 0)
{
return("No referrence found");
}
foreach (var link in links)
{
var sourceItem = link.GetSourceItem();
foreach (var item1 in sourceItem.Versions.GetVersions(true))
{
var field = item1.Fields[link.SourceFieldID];
var field2 = FieldTypeManager.GetField(field);
if (field2 == null)
{
return(string.Empty);
}
using (new SecurityDisabler())
{
item1.Editing.BeginEdit();
field2.RemoveLink(link);
item1.Editing.EndEdit();
}
}
}
return("All reference removed");
}
public static FieldTypes GetFieldType(this Field field)
{
if (FieldTypeManager.GetField(field) is TextField)
{
return(FieldTypes.TextField);
}
else if (FieldTypeManager.GetField(field) is HtmlField)
{
return(FieldTypes.HTMLField);
}
else if (FieldTypeManager.GetField(field) is LookupField)
{
return(FieldTypes.LookUpField);
}
else if (FieldTypeManager.GetField(field) is MultilistField)
{
return(FieldTypes.MultilistField);
}
else if (FieldTypeManager.GetField(field) is ImageField)
{
return(FieldTypes.Image);
}
else
{
return(FieldTypes.TextField);
}
}
/// <summary>
/// Tries to get the URL for the MediaItem referenced in the given image field on the given item.
/// </summary>
/// <param name="fieldName">The name of the field that references the MediaItem. Note, this field name must reference an ImageField.</param>
/// <param name="item">The item that contains the given field.</param>
/// <param name="url">The URL for the MediaItem.</param>
/// <returns>True if a URL could be returned for the MediaItem; otherwise, false.</returns>
public static Boolean GetMediaImageFriendlyURL(string fieldName, Item item, out String url)
{
url = "";
if (string.IsNullOrEmpty(fieldName) || item == null)
{
return(false);
}
var rawField = item.Fields[fieldName];
var fieldIsValidAndHasContent = rawField != null && !string.IsNullOrEmpty(rawField.Value) &&
FieldTypeManager.GetField(rawField) is Sitecore.Data.Fields.ImageField;
if (!fieldIsValidAndHasContent)
{
return(false);
}
Sitecore.Data.Fields.ImageField imageField = rawField;
if (imageField.MediaItem == null)
{
return(false);
}
return(GetMediaURL(imageField.MediaItem, out url));
}
private void ProcessLink(ItemLink link)
{
var linkedItem = Factory.GetDatabase(link.TargetDatabaseName)
.GetItem(link.TargetItemID, link.TargetItemLanguage, link.TargetItemVersion);
var referer = linkedItem.Database.GetItem(link.SourceItemID, link.SourceItemLanguage,
link.SourceItemVersion);
var itemField = referer.Fields[link.SourceFieldID];
var field = FieldTypeManager.GetField(itemField);
if (NewTarget != null)
{
if (ShouldProcess(referer.GetProviderPath(),
$"Changing link in field '{itemField.Name}' from '{linkedItem.GetProviderPath()}' to '{NewTarget.GetProviderPath()}' "))
{
referer.Editing.BeginEdit();
field.Relink(link, NewTarget);
referer.Editing.EndEdit(true, false);
}
}
else
{
if (ShouldProcess(referer.GetProviderPath(),
$"Removing link to '{linkedItem.GetProviderPath()}' from field '{itemField.Name}'"))
{
referer.Editing.BeginEdit();
field.RemoveLink(link);
referer.Editing.EndEdit(true, false);
}
}
}
public void ShouldNotThrowOnGetDefaultFieldTypeItem()
{
using (new Db("core"))
{
FieldTypeManager.GetDefaultFieldTypeItem();
}
}
/// <summary>
/// Tries to get the URL for the link field on the item.
/// </summary>
/// <param name="item">The item containing the link field.</param>
/// <param name="fieldName">The name of the link field on the item.</param>
/// <param name="url">The URL contained in the link field.</param>
/// <returns>True if able to return a URL; otherwise, false.</returns>
public static bool GetGeneralLinkURL(Item item, string fieldName, out string url)
{
url = string.Empty;
try
{
if (item == null || string.IsNullOrEmpty(fieldName))
{
return(false);
}
var rawLinkField = item.Fields[fieldName];
var linkFieldIsValidAndHasContent = rawLinkField != null &&
!string.IsNullOrEmpty(rawLinkField.Value) &&
FieldTypeManager.GetField(rawLinkField) is LinkField;
if (!linkFieldIsValidAndHasContent)
{
return(false);
}
LinkField linkField = rawLinkField;
return(GetGeneralLinkURL(linkField, out url));
}
catch
{
return(false);
}
}
public void Process(GetFieldModelArgs args)
{
if (args.RecursionLevel > 5 || args.Result != null || !args.Field.HasValue)
{
return;
}
if (!(FieldTypeManager.GetField(args.Field) is MultilistField listField))
{
return;
}
var items = new List <object>();
foreach (var item in listField.GetItems())
{
var dict = item.ToFieldsDictionary(args.RecursionLevel + 1);
var path = LinkManager.GetItemUrl(item, new UrlOptions
{
AddAspxExtension = false,
AlwaysIncludeServerUrl = false,
EncodeNames = true,
LanguageEmbedding = LanguageEmbedding.Never,
LowercaseUrls = true
});
items.Add(new { name = item.Name, displayName = item.DisplayName, path, fields = dict });
}
args.Result = new { items, type = listField.InnerField.Type }
;
}
private void RenderResizable(Control parent, Editor.Field field)
{
var type = field.TemplateField.Type;
if (string.IsNullOrEmpty(type))
{
return;
}
var fieldType = FieldTypeManager.GetFieldType(type);
if (fieldType == null || !fieldType.Resizable)
{
return;
}
var text1 =
"<div style=\"cursor:row-resize; position: relative; height: 5px; width: 100%; top: 0px; left: 0px;\" onmousedown=\"scContent.fieldResizeDown(this, event)\" onmousemove=\"scContent.fieldResizeMove(this, event)\" onmouseup=\"scContent.fieldResizeUp(this, event, '" +
field.TemplateField.ID.ToShortID() + "')\">" + Images.GetSpacer(1, 4) + "</div>";
AddLiteralControl(parent, text1);
var text2 = "<div class style=\"display:none\" \">" + Images.GetSpacer(1, 4) + "</div>";
AddLiteralControl(parent, text2);
}
public override object GetFieldValue(IIndexableDataField field)
{
Field field1 = (Field)(field as SitecoreItemDataField);
if (field1 != null)
{
if (string.IsNullOrEmpty(field1.Value))
{
return((object)null);
}
if (FieldTypeManager.GetField(field1) is DateField)
{
DateField dateField = new DateField(field1);
if (dateField.DateTime > DateTime.MinValue)
{
return((object)dateField.DateTime);
}
}
}
else if (field.Value is DateTime)
{
return((object)(DateTime)field.Value);
}
return((object)null);
}
public void Process(GetFieldModelArgs args)
{
if (args.Result != null || !args.Field.HasValue)
{
return;
}
if (!(FieldTypeManager.GetField(args.Field) is ImageField imagefield))
{
return;
}
args.Result = new
{
@class = imagefield.Class.ToJsonValueString(),
alt = imagefield.Alt.ToJsonValueString(),
src = imagefield.MediaItem != null
? MediaManager.GetMediaUrl(imagefield.MediaItem, new MediaUrlOptions
{
AlwaysIncludeServerUrl = false,
IncludeExtension = true,
LowercaseUrls = true
})
: null,
linkType = imagefield.LinkType.ToJsonValueString(),
border = imagefield.Border.ToJsonValueString(),
hspace = imagefield.HSpace.ToJsonValueString(),
height = imagefield.Height.ToJsonValueString(),
width = imagefield.Width.ToJsonValueString(),
type = imagefield.InnerField.Type
};
}
protected override IEnumerable <Item> GetSourceItems(T ruleContext)
{
Assert.ArgumentNotNullOrEmpty(this.FieldName, "FieldName");
Assert.ArgumentNotNull(ruleContext, "ruleContext");
Assert.ArgumentNotNull(ruleContext.Item, "ruleContext.Item");
var item = ruleContext.Item;
var field = item.Fields[this.FieldName];
if (field == null)
{
return(null);
}
var sourceItems = new List <Item>();
var customField = FieldTypeManager.GetField(field);
if (customField is LookupField)
{
var f2 = customField as LookupField;
sourceItems.Add(f2.TargetItem);
}
else if (customField is ReferenceField)
{
var f2 = customField as ReferenceField;
sourceItems.Add(f2.TargetItem);
}
else if (customField is MultilistField)
{
var f2 = customField as MultilistField;
sourceItems.AddRange(f2.GetItems());
}
return(sourceItems);
}
public override object GetFieldValue(IIndexableDataField indexableField)
{
Field field = indexableField as SitecoreItemDataField;
var list = new List <string>();
var multiField = FieldTypeManager.GetField(field) as MultilistField;
if (multiField != null)
{
foreach (string key in multiField.List)
{
string itm = key;
if (ID.IsID(itm))
{
itm = ShortID.Encode(itm).ToLowerInvariant();
list.Add(itm);
}
}
return(list);
}
return(list);
}
public void Process(GetFieldModelArgs args)
{
if (args.RecursionLevel > 5 || args.Result != null || !args.Field.HasValue)
{
return;
}
var lookupField = FieldTypeManager.GetField(args.Field) as LookupField;
var itemField = FieldTypeManager.GetField(args.Field) as ReferenceField;
if (lookupField == null && itemField == null)
{
return;
}
var item = itemField?.TargetItem ?? lookupField?.TargetItem;
if (item == null)
{
args.AbortPipeline();
return;
}
var dict = item.ToFieldsDictionary(args.RecursionLevel + 1);
var path = LinkManager.GetItemUrl(item, new UrlOptions
{
AddAspxExtension = false,
AlwaysIncludeServerUrl = false,
EncodeNames = true,
LanguageEmbedding = LanguageEmbedding.Never,
LowercaseUrls = true
});
args.Result = new { name = item.Name, displayName = item.DisplayName, path, fields = dict };
}
public static string LinkFieldUrl(this Item item, ID fieldId)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (ID.IsNullOrEmpty(fieldId))
{
throw new ArgumentNullException(nameof(fieldId));
}
var field = item.Fields[fieldId];
if (field == null || !(FieldTypeManager.GetField(field) is LinkField))
{
return(string.Empty);
}
LinkField linkField = field;
switch (linkField.LinkType.ToLower())
{
case "internal":
// Use LinkMananger for internal links, if link is not empty
return(linkField.TargetItem != null?LinkManager.GetItemUrl(linkField.TargetItem) : string.Empty);
case "media":
// Use MediaManager for media links, if link is not empty
return(linkField.TargetItem != null?MediaManager.GetMediaUrl(linkField.TargetItem) : string.Empty);
case "external":
// Just return external links
return(linkField.Url);
case "anchor":
// Prefix anchor link with # if link if not empty
return(!string.IsNullOrEmpty(linkField.Anchor) ? "#" + linkField.Anchor : string.Empty);
case "mailto":
// Just return mailto link
return(linkField.Url);
case "javascript":
// Just return javascript
return(linkField.Url);
default:
// Just please the compiler, this
// condition will never be met
return(linkField.Url);
}
}
public static string GetLinkFieldUrl(this SitecoreHelper sitecoreHelper, Item item, string fieldName)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (string.IsNullOrEmpty(fieldName))
{
throw new ArgumentNullException(nameof(fieldName));
}
var fieldalue = item[fieldName];
if (ID.IsID(item[fieldName]))
{
var linkItem = item.Database.GetItem(ID.Parse(fieldalue));
return(linkItem != null?Sitecore.Links.LinkManager.GetItemUrl(linkItem) : string.Empty);
}
var field = item.Fields[fieldName];
if (field == null || !(FieldTypeManager.GetField(field) is LinkField))
{
return(string.Empty);
}
else
{
LinkField linkField = (LinkField)field;
switch (linkField.LinkType.ToLower())
{
case "internal":
// Use LinkMananger for internal links, if link is not empty
return(linkField.TargetItem != null?Sitecore.Links.LinkManager.GetItemUrl(linkField.TargetItem) : string.Empty);
case "media":
// Use MediaManager for media links, if link is not empty
return(linkField.TargetItem != null?Sitecore.Resources.Media.MediaManager.GetMediaUrl(linkField.TargetItem) : string.Empty);
case "external":
// Just return external links
return(linkField.Url);
case "anchor":
// Prefix anchor link with # if link if not empty
return(!string.IsNullOrEmpty(linkField.Anchor) ? "#" + linkField.Anchor : string.Empty);
case "mailto":
// Just return mailto link
return(linkField.Url);
case "javascript":
// Just return javascript
return(linkField.Url);
default:
// Just please the compiler, this
// condition will never be met
return(linkField.Url);
}
}
}
/// <summary>
/// Maps the specified source.
/// </summary>
/// <typeparam name="TDestination">The type of the destination.</typeparam>
/// <param name="field">The field.</param>
/// <param name="destination">The destination.</param>
/// <param name="context">The context.</param>
/// <returns></returns>
internal static TDestination Map <TDestination>(Field field, TDestination destination, ResolutionContext context)
{
var customField = FieldTypeManager.GetField(field);
context.Mapper.Map(customField, destination, customField.GetType(), destination.GetType());
return(destination);
}
public static Type GetFieldType(this TemplateFieldItem field)
{
FieldType fieldType = FieldTypeManager.GetFieldType(field.Type);
Type result;
if (field.Type == "Number")
{
result = typeof(double);
}
else
{
if (field.Type == "Integer")
{
result = typeof(int);
}
else
{
if (fieldType != null)
{
string fullName = fieldType.Type.FullName;
switch (fullName)
{
case "Sitecore.Data.Fields.TextField":
case "Sitecore.Data.Fields.HtmlField":
case "Sitecore.Data.Fields.ValueLookupField":
result = typeof(string);
return(result);
case "Sitecore.Data.Fields.DateField":
result = typeof(DateTime);
return(result);
case "Sitecore.Data.Fields.LookupField":
case "Sitecore.Data.Fields.ReferenceField":
case "Sitecore.Data.Fields.GroupedDroplinkField":
case "Sitecore.Data.Fields.GroupedDroplistField":
result = typeof(Item);
return(result);
case "Sitecore.Data.Fields.MultilistField":
result = typeof(IEnumerable <Item>);
return(result);
case "Sitecore.Data.Fields.CheckboxField":
result = typeof(bool);
return(result);
}
result = fieldType.Type;
}
else
{
result = typeof(string);
}
}
}
return(result);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
var name = binder.Name.ToLower();
var field = _item.Fields[name];
result = field != null?FieldTypeManager.GetField(field) : null;
return(field != null);
}
public void ShouldNotThrowOnGetFieldTypeItem()
{
// arrange
using (new Db("core"))
{
// act
FieldTypeManager.GetFieldTypeItem("text");
}
}
private void FindLinks([NotNull] DeleteItemPipeline pipeline, [NotNull] Item item)
{
var links = Globals.LinkDatabase.GetReferrers(item);
if (links.Length <= 0)
{
return;
}
foreach (var itemLink in links)
{
var sourceItem = item.Database.GetItem(itemLink.SourceItemID);
if (sourceItem == null)
{
continue;
}
if (pipeline.WillBeDeleted(sourceItem))
{
continue;
}
var sourceFieldId = itemLink.SourceFieldID;
if (ID.IsNullOrEmpty(sourceFieldId))
{
continue;
}
var field = sourceItem.Fields[sourceFieldId];
if (field == null)
{
continue;
}
var customField = FieldTypeManager.GetField(field);
if (customField == null)
{
continue;
}
pipeline.Output.WriteStartElement("item");
pipeline.Output.WriteAttributeString("section", "Links");
pipeline.Output.WriteAttributeString("id", item.ID.ToString());
pipeline.Output.WriteAttributeString("sourceid", itemLink.SourceItemID.ToString());
pipeline.Output.WriteAttributeString("path", item.Paths.Path);
pipeline.Output.WriteAttributeString("sourcepath", sourceItem.Paths.Path);
pipeline.Output.WriteAttributeString("level", "warning");
pipeline.Output.WriteValue(string.Format("Removes the link in the \"{2}\" field from \"{0}\" to \"{1}\".", sourceItem.Paths.Path, item.Paths.Path, field.Name));
pipeline.Output.WriteEndElement();
if (!pipeline.DryRun)
{
RemoveLink(sourceItem, itemLink);
}
}
}
/// <summary>
/// The get values.
/// </summary>
/// <returns>
/// The IEnumberable of values
/// </returns>
public IEnumerable <string> GetValues()
{
if (FieldTypeManager.GetField(_field) is MultilistField)
{
MultilistField field = _field;
return(field.TargetIDs.Select(IdHelper.NormalizeGuid));
}
return(new string[0]);
}
public static string LinkFieldUrl(this Item item, ID fieldID)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (ID.IsNullOrEmpty(fieldID))
{
throw new ArgumentNullException(nameof(fieldID));
}
var field = item.Fields[fieldID];
if (field == null || !(FieldTypeManager.GetField(field) is LinkField))
{
return(string.Empty);
}
else
{
LinkField linkField = (LinkField)field;
switch (linkField.LinkType.ToLower())
{
case "internal":
{
var qs = LinkFieldOptions(item, fieldID, LinkFieldOption.QueryString);
// Use LinkMananger for internal links, if link is not empty
return(linkField.TargetItem != null?Sitecore.Links.LinkManager.GetItemUrl(linkField.TargetItem) + (string.IsNullOrWhiteSpace(qs)? string.Empty: "?" + qs) : string.Empty);
}
case "media":
// Use MediaManager for media links, if link is not empty
return(linkField.TargetItem != null?Sitecore.Resources.Media.MediaManager.GetMediaUrl(linkField.TargetItem) : string.Empty);
case "external":
// Just return external links
return(linkField.Url);
case "anchor":
// Prefix anchor link with # if link if not empty
return(!string.IsNullOrEmpty(linkField.Anchor) ? "#" + linkField.Anchor : string.Empty);
case "mailto":
// Just return mailto link
return(linkField.Url);
case "javascript":
// Just return javascript
return(linkField.Url);
default:
// Just please the compiler, this
// condition will never be met
return(linkField.Url);
}
}
}
public virtual Item GetFieldTypeItem(Item field)
{
string fieldType = field["Type"];
if (string.IsNullOrEmpty(fieldType))
{
fieldType = "text";
}
return(FieldTypeManager.GetFieldTypeItem(fieldType) ?? FieldTypeManager.GetDefaultFieldTypeItem());
}
public static IEnumerable <Item> GetItemsFromMultilist(Item carrier, string fieldName)
{
var multilistField = carrier.Fields[fieldName];
if (FieldTypeManager.GetField(multilistField) is MultilistField)
{
return(((MultilistField)multilistField).GetItems());
}
return(new Item[0]);
}
public Item GetFieldType(Field itemField)
{
Assert.ArgumentNotNull(itemField, "itemField");
Item fieldTypeItem = FieldTypeManager.GetFieldTypeItem(StringUtil.GetString(new string[] { itemField.Type, "text" }));
if (fieldTypeItem == null)
{
fieldTypeItem = FieldTypeManager.GetDefaultFieldTypeItem();
}
return(fieldTypeItem);
}
public void ShouldGetLayoutField()
{
using (var db = new Db {
new DbItem("home")
})
{
var home = db.GetItem("/sitecore/content/home");
FieldTypeManager.GetField(home.Fields[FieldIDs.LayoutField]).Should().BeOfType <LayoutField>();
FieldTypeManager.GetFieldType("Layout").Type.Should().Be <LayoutField>();
}
}
public void ShouldGetTrackingField()
{
// arrange
using (var db = new Db {
new DbItem("home")
})
{
var home = db.GetItem("/sitecore/content/home");
// act & assert
FieldTypeManager.GetField(home.Fields["__Tracking"]).Should().BeOfType <TrackingField>();
FieldTypeManager.GetFieldType("Tracking").Type.Should().Be <TrackingField>();
}
}
public void ShouldNotThrowOnGetTemplateFieldItem()
{
using (var db = new Db
{
new DbItem("home")
{
new DbField("field")
}
})
{
var home = db.GetItem("/sitecore/content/home");
FieldTypeManager.GetTemplateFieldItem(home.Fields["field"]);
}
}
public override object GetFieldValue(IIndexableDataField field)
{
Field field1 = (Field)(field as SitecoreItemDataField);
if (field1 != null)
{
CheckboxField checkboxField = FieldTypeManager.GetField(field1) as CheckboxField;
return(checkboxField == null ? 0 : (checkboxField.Checked ? 1 : 0));
}
if (field.Value is bool)
{
return(field.Value);
}
return(field.Value);
}
private void Update([NotNull] Item item)
{
using (new SecurityDisabler())
{
var itemLinks = Globals.LinkDatabase.GetReferrers(item);
if (itemLinks.Length > 0)
{
foreach (var itemLink in itemLinks)
{
var database = Factory.GetDatabase(itemLink.SourceDatabaseName);
if (database == null)
{
continue;
}
var source = database.GetItem(itemLink.SourceItemID);
if (source == null)
{
continue;
}
foreach (var version in source.Versions.GetVersions())
{
var sourceField = version.Fields[itemLink.SourceFieldID];
if (sourceField == null)
{
continue;
}
var customField = FieldTypeManager.GetField(sourceField);
if (customField == null)
{
continue;
}
version.Editing.BeginEdit();
customField.UpdateLink(itemLink);
version.Editing.EndEdit();
}
}
}
}
foreach (Item child in item.Children)
{
Update(child);
}
}
