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 };
}
/// <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 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);
}
}
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");
}
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 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 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 }
;
}
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 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.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
};
}
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);
}
}
}
/// <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));
}
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 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);
}
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 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 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 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);
}
public override void RenderField(RenderVariantFieldArgs args)
{
var variantField = args.VariantField as VariantImageWithClass;
if (args.Item.Paths.IsMediaItem)
{
args.ResultControl = CreateResponsiveImage(args.Item, variantField, args.Item[Templates.Image.Fields.Alt]);
args.Result = RenderControl(args.ResultControl);
}
else
{
if (string.IsNullOrWhiteSpace(variantField != null ? variantField.FieldName : null))
{
return;
}
if (PageMode.IsExperienceEditorEditing)
{
args.ResultControl = new FieldRenderer()
{
Item = args.Item,
FieldName = variantField.FieldName,
DisableWebEditing = !args.IsControlEditable
};
args.Result = RenderControl(args.ResultControl);
}
else
{
Field field1 = args.Item.Fields[variantField.FieldName];
if (field1 == null)
{
return;
}
ImageField field2 = FieldTypeManager.GetField(field1) as ImageField;
if ((field2 != null ? field2.MediaItem : null) == null)
{
return;
}
string altText = string.IsNullOrWhiteSpace(field2.Alt) ? field2.MediaItem[Templates.Image.Fields.Alt] : field2.Alt;
args.ResultControl = CreateResponsiveImage(field2.MediaItem, variantField, altText);
args.Result = RenderControl(args.ResultControl);
}
}
}
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);
}
}
public static void SetDateTime(this Item item, string fieldID, DateTime?value)
{
Field field = item.Fields[new ID(fieldID)];
Assert.IsNotNull(field, "item does not have field: " + fieldID);
DateField field2 = FieldTypeManager.GetField(field) as DateField;
if (value.HasValue)
{
field2.Value = DateUtil.ToIsoDate(value.Value);
}
else
{
item.SetString(fieldID, null);
}
}
/// <summary>
/// Returns lookup field value as an item display name instead of item ID.
/// </summary>
/// <returns></returns>
public override string GetValue()
{
var value = String.Empty;
if (FieldTypeManager.GetField(_field) is LookupField)
{
var lookupField = new LookupField(_field);
value = IdHelper.NormalizeGuid(lookupField.TargetID);
}
if (FieldTypeManager.GetField(_field) is ReferenceField)
{
var referenceField = new ReferenceField(_field);
value = IdHelper.NormalizeGuid(referenceField.TargetID);
}
return(value);
}
public virtual void UpdateReferrers(Item oldItem, Item newItem)
{
Assert.ArgumentNotNull(oldItem, "oldItem");
Assert.ArgumentNotNull(newItem, "newItem");
try
{
var itemLinks = Sitecore.Globals.LinkDatabase.GetReferrers(oldItem);
foreach (ItemLink itemLink in itemLinks)
{
if (itemLink.SourceFieldID == Sitecore.FieldIDs.Source)
{
continue;
}
Item sourceItem = itemLink.GetSourceItem();
if (sourceItem == null)
{
continue;
}
foreach (Item item in sourceItem.Versions.GetVersions(true))
{
Field field = item.Fields[itemLink.SourceFieldID];
CustomField customField = FieldTypeManager.GetField(field);
if (customField != null)
{
using (new SecurityDisabler())
{
item.Editing.BeginEdit();
customField.Relink(itemLink, newItem);
item.Editing.EndEdit();
}
}
}
}
}
catch (Exception ex)
{
LogHelper.Error(string.Format("Item links could not be updated. Old Item:{0}; New Item:{1}", oldItem.Uri, newItem.Uri), this, ex);
}
}
public override object GetFieldValue(IIndexableDataField indexableField)
{
Field field = (indexableField as SitecoreItemDataField);
var strongTypeField = FieldTypeManager.GetField(field);
if (strongTypeField is LookupField)
{
return(GetRefernceValue(new LookupField(field).TargetItem));
}
if (strongTypeField is ReferenceField)
{
return(GetRefernceValue(new ReferenceField(field).TargetItem));
}
return(null);
}
public void Process(GetFieldModelArgs args)
{
if (args.Result != null || !args.Field.HasValue)
{
return;
}
if (!(FieldTypeManager.GetField(args.Field) is NameValueListField valueListField))
{
return;
}
args.Result = new
{
values = valueListField.NameValues,
type = valueListField.InnerField.Type
};
}
public override object GetFieldValue(IIndexableDataField indexableField)
{
Field field = indexableField as SitecoreItemDataField;
DateField dateField = FieldTypeManager.GetField(field) as DateField;
if (dateField != null)
{
var date = dateField.DateTime;
if (date == DateTime.MinValue)
{
return(null);
}
return((Int32)(date.Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
}
return(null);
}