public string GetItemUrl(Item item, bool enableLanguageEmbedding = false)
{
if (item == null)
{
return(null);
}
EnterspeedSitecoreConfiguration configuration = _enterspeedConfigurationService.GetConfiguration();
EnterspeedSiteInfo siteInfo = configuration.GetSite(item);
var urlBuilderOptions = new ItemUrlBuilderOptions
{
SiteResolving = true,
AlwaysIncludeServerUrl = true,
LowercaseUrls = true,
LanguageEmbedding = enableLanguageEmbedding ? LanguageEmbedding.Always : LanguageEmbedding.Never
};
if (siteInfo != null)
{
SiteContext siteContext = _siteContextFactory.GetSiteContext(siteInfo.Name);
urlBuilderOptions.Site = siteContext;
}
return(_linkManager.GetItemUrl(item, urlBuilderOptions));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
if (string.IsNullOrEmpty(field?.Value))
{
return(null);
}
NameValueCollection values = HttpUtility.ParseQueryString(field.Value);
if (values.Count == 0)
{
return(null);
}
var list = new List <StringEnterspeedProperty>();
foreach (string key in values)
{
if (string.IsNullOrEmpty(key))
{
continue;
}
string value = values[key];
if (string.IsNullOrEmpty(value))
{
continue;
}
list.Add(new StringEnterspeedProperty(key, value));
}
return(new ArrayEnterspeedProperty(_fieldService.GetFieldName(field), list.ToArray()));
}
public IDictionary <string, IEnterspeedProperty> GetProperties(Item item)
{
if (item.IsDictionaryItem())
{
IDictionary <string, IEnterspeedProperty> dictionaryProperties = _fieldConverter.ConvertFields(item, null, _fieldValueConverters.ToList());
return(dictionaryProperties);
}
EnterspeedSiteInfo siteOfItem = _enterspeedConfigurationService
.GetConfiguration()
.GetSite(item);
if (siteOfItem == null)
{
return(null);
}
IDictionary <string, IEnterspeedProperty> properties = _fieldConverter.ConvertFields(item, siteOfItem, _fieldValueConverters.ToList());
properties.Add(MetaData, CreateMetaData(item));
IEnterspeedProperty renderings = CreateRenderings(item);
if (renderings != null)
{
properties.Add(Renderings, renderings);
}
return(properties);
}
public SitecoreContentEntity Map(Item input)
{
var output = new SitecoreContentEntity
{
Id = _enterspeedIdentityService.GetId(input),
Type = input.TemplateName,
Properties = _enterspeedPropertyService.GetProperties(input)
};
EnterspeedSiteInfo siteInfo = _enterspeedConfigurationService.GetConfiguration().GetSite(input);
if (siteInfo != null)
{
if (input.Paths.FullPath.StartsWith(siteInfo.HomeItemPath, StringComparison.OrdinalIgnoreCase))
{
// Routable content resides on or below the Home item path.
output.Url = _urlService.GetItemUrl(input);
}
if (!input.Paths.FullPath.Equals(siteInfo.SiteItemPath, StringComparison.OrdinalIgnoreCase))
{
// If the input item is the Site item, we do not set a parent ID.
output.ParentId = _enterspeedIdentityService.GetId(input.Parent);
}
}
return(output);
}
private bool IsItemReferencedFromEnabledContent(Item item, EnterspeedSitecoreConfiguration configuration)
{
GetLinksStrategy linksStrategy = _linkStrategyFactory.Resolve(item);
var strategyContextArgs = new StrategyContextArgs(item);
linksStrategy.ProcessReferrers(strategyContextArgs);
if (strategyContextArgs.Result != null &&
strategyContextArgs.Result.Any())
{
foreach (ItemLink itemLink in strategyContextArgs.Result)
{
Item sourceItem = itemLink?.GetSourceItem();
if (sourceItem == null)
{
continue;
}
EnterspeedSiteInfo site = configuration.GetSite(sourceItem);
if (site != null)
{
// This rendering is referenced on content from an enabled site
return(true);
}
}
}
return(false);
}
public IDictionary <string, IEnterspeedProperty> ConvertFields(Item item, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
var output = new Dictionary <string, IEnterspeedProperty>();
FieldCollection fieldsCollection = item.Fields;
if (fieldsCollection == null || !fieldsCollection.Any())
{
return(output);
}
// Mapping all fields, by default
List <Field> fields = fieldsCollection.ToList();
if (item.IsDictionaryItem())
{
// Only include dictionary fields
fields = fields.Where(field =>
field.InnerItem != null &&
field.InnerItem.Paths.FullPath.StartsWith("/sitecore/templates/System/Dictionary", StringComparison.OrdinalIgnoreCase))
.ToList();
}
else if (item.IsContentItem() || item.IsRenderingItem())
{
// Exclude system fields for content and renderings
fields = fields.Where(field =>
field.InnerItem != null &&
!field.InnerItem.Paths.FullPath.StartsWith("/sitecore/templates/system", StringComparison.OrdinalIgnoreCase))
.ToList();
}
if (!fields.Any())
{
return(output);
}
foreach (Field field in fields)
{
if (field == null)
{
continue;
}
IEnterspeedFieldValueConverter converter = fieldValueConverters.FirstOrDefault(x => x.CanConvert(field));
var value = converter?.Convert(item, field, siteInfo, fieldValueConverters);
if (value == null)
{
continue;
}
output.Add(_fieldService.GetFieldName(field), value);
}
return(output);
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
var value = 0;
if (!string.IsNullOrEmpty(field.Value))
{
value = int.Parse(field.Value);
}
return(new NumberEnterspeedProperty(_fieldService.GetFieldName(field), value));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
ReferenceField referenceField = field;
if (string.IsNullOrEmpty(referenceField?.Value))
{
return(null);
}
return(new StringEnterspeedProperty(_fieldService.GetFieldName(field), referenceField.Value));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
ReferenceField referenceField = field;
if (referenceField?.TargetItem == null)
{
return(null);
}
return(new StringEnterspeedProperty(_fieldService.GetFieldName(field), _enterspeedIdentityService.GetId(referenceField.TargetItem)));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
DateField dateField = field;
if (dateField == null ||
dateField.DateTime == DateTime.MinValue)
{
return(null);
}
return(new StringEnterspeedProperty(_fieldService.GetFieldName(field), _dateFormatter.FormatDate(dateField.DateTime)));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
string value = FieldRenderer.Render(item, field.Name);
if (siteInfo != null)
{
value = PrefixRelativeImagesWithDomain(value, siteInfo.BaseUrl);
value = PrefixRelativeLinksWithDomain(value, siteInfo.BaseUrl);
}
return(new StringEnterspeedProperty(_fieldService.GetFieldName(field), value));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
if (string.IsNullOrEmpty(field?.Value))
{
return(null);
}
NameValueCollection values = HttpUtility.ParseQueryString(field.Value);
if (values.Count == 0)
{
return(null);
}
var items = new List <Item>();
foreach (string key in values)
{
if (string.IsNullOrEmpty(key))
{
continue;
}
string value = values[key];
if (string.IsNullOrEmpty(value))
{
continue;
}
if (!Guid.TryParse(value, out var itemId))
{
continue;
}
Item referencedItem = _itemManager.GetItem(new ID(itemId), item.Language, Version.Latest, item.Database);
if (referencedItem == null ||
referencedItem.Versions.Count == 0)
{
continue;
}
items.Add(referencedItem);
}
var referenceIds = items.Select(x => new StringEnterspeedProperty(null, _enterspeedIdentityService.GetId(x))).ToArray();
return(new ArrayEnterspeedProperty(_fieldService.GetFieldName(field), referenceIds));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
FileField fileField = field;
if (fileField?.MediaItem == null)
{
return(null);
}
string mediaUrl = _urlService.GetMediaUrl(fileField.MediaItem);
if (string.IsNullOrEmpty(mediaUrl))
{
return(null);
}
return(new StringEnterspeedProperty(_fieldService.GetFieldName(field), mediaUrl));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
if (string.IsNullOrEmpty(field.Value))
{
return(null);
}
var value = 0d;
if (field.Value.Contains("."))
{
double.TryParse(field.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out value);
}
else if (field.Value.Contains(","))
{
double.TryParse(field.Value, NumberStyles.Any, new CultureInfo("da-DK"), out value);
}
return(new NumberEnterspeedProperty(_fieldService.GetFieldName(field), value));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
MultilistField multilistField = field;
if (multilistField == null)
{
return(null);
}
var items = multilistField.GetItems()?.ToList() ?? new List <Item>();
if (!items.Any())
{
return(null);
}
var referenceIds = items.Select(x => new StringEnterspeedProperty(null, _enterspeedIdentityService.GetId(x))).ToArray();
return(new ArrayEnterspeedProperty(_fieldService.GetFieldName(field), referenceIds));
}
private void HandleContentItem(Item item, EnterspeedSitecoreConfiguration configuration, bool itemIsDeleted, bool itemIsPublished)
{
try
{
if (item == null)
{
return;
}
// Skip, if the item published is not a content item
if (!item.IsContentItem())
{
return;
}
EnterspeedSiteInfo siteOfItem = configuration.GetSite(item);
if (siteOfItem == null)
{
// If no enabled site was found for this item, skip it
return;
}
SitecoreContentEntity sitecoreContentEntity = _sitecoreContentEntityModelMapper.Map(item);
if (sitecoreContentEntity == null)
{
return;
}
if (itemIsDeleted)
{
string id = _identityService.GetId(item);
_loggingService.Info($"Beginning to delete content entity ({id}).");
Response deleteResponse = _enterspeedIngestService.Delete(id);
if (!deleteResponse.Success)
{
_loggingService.Warn($"Failed deleting content entity ({id}). Message: {deleteResponse.Message}", deleteResponse.Exception);
}
else
{
_loggingService.Debug($"Successfully deleting content entity ({id})");
}
return;
}
if (itemIsPublished)
{
string id = _identityService.GetId(item);
_loggingService.Info($"Beginning to ingest content entity ({id}).");
Response saveResponse = _enterspeedIngestService.Save(sitecoreContentEntity);
if (!saveResponse.Success)
{
_loggingService.Warn($"Failed ingesting content entity ({id}). Message: {saveResponse.Message}", saveResponse.Exception);
}
else
{
_loggingService.Debug($"Successfully ingested content entity ({id})");
}
}
}
catch (Exception exception)
{
Debug.WriteLine(exception.ToString());
}
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
LinkField linkField = field;
if (linkField == null)
{
return(null);
}
var properties = new Dictionary <string, IEnterspeedProperty>();
if (!string.IsNullOrEmpty(linkField.Target))
{
properties.Add(PropertyTarget, new StringEnterspeedProperty(PropertyTarget, linkField.Target));
}
if (!string.IsNullOrEmpty(linkField.Anchor))
{
properties.Add(PropertyAnchor, new StringEnterspeedProperty(PropertyAnchor, linkField.Anchor));
}
if (!string.IsNullOrEmpty(linkField.Text))
{
properties.Add(PropertyText, new StringEnterspeedProperty(PropertyText, linkField.Text));
}
if (!string.IsNullOrEmpty(linkField.Title))
{
properties.Add(PropertyTitle, new StringEnterspeedProperty(PropertyTitle, linkField.Title));
}
if (!string.IsNullOrEmpty(linkField.Class))
{
properties.Add(PropertyClass, new StringEnterspeedProperty(PropertyClass, linkField.Class));
}
string url = null;
if (linkField.LinkType == "media")
{
url = _urlService.GetMediaUrl(linkField.TargetItem);
}
else if (linkField.LinkType == "internal")
{
url = _urlService.GetItemUrl(linkField.TargetItem);
if (linkField.TargetItem != null)
{
properties.Add(PropertyTargetType, new StringEnterspeedProperty(PropertyTargetType, linkField.TargetItem.TemplateName));
properties.Add(PropertyTargetId, new StringEnterspeedProperty(PropertyTargetId, _enterspeedIdentityService.GetId(linkField.TargetItem)));
}
}
else if (linkField.LinkType == "external" ||
linkField.LinkType == "anchor" ||
linkField.LinkType == "mailto" ||
linkField.LinkType == "javascript")
{
url = linkField.GetFriendlyUrl();
}
if (!string.IsNullOrEmpty(url))
{
properties.Add(PropertyUrl, new StringEnterspeedProperty(PropertyUrl, url));
}
else
{
return(null);
}
return(new ObjectEnterspeedProperty(_fieldService.GetFieldName(field), properties));
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
bool value = item[field.Name] == "1";
return(new BooleanEnterspeedProperty(_fieldService.GetFieldName(field), value));
}
public EnterspeedSitecoreConfiguration GetConfiguration()
{
Item enterspeedConfigurationItem = _itemManager.GetItem(EnterspeedIDs.Items.EnterspeedConfigurationID, Language.Parse("en"), Version.Latest, _factory.GetDatabase("web"));
if (enterspeedConfigurationItem == null || enterspeedConfigurationItem.Versions.Count == 0)
{
return(new EnterspeedSitecoreConfiguration());
}
string enabled = enterspeedConfigurationItem[EnterspeedIDs.Fields.EnterspeedEnabledFieldID] ?? string.Empty;
if (enabled != "1")
{
return(new EnterspeedSitecoreConfiguration());
}
if (!IsConfigurationUpdated(enterspeedConfigurationItem, out Guid currentRevisionId))
{
return(_configuration);
}
var config = new EnterspeedSitecoreConfiguration
{
IsEnabled = true
};
string configApiBaseUrl = enterspeedConfigurationItem[EnterspeedIDs.Fields.EnterspeedApiBaseUrlFieldID];
config.BaseUrl = (configApiBaseUrl ?? string.Empty).Trim();
string configApiKey = enterspeedConfigurationItem[EnterspeedIDs.Fields.EnterspeedApiKeyFieldID];
config.ApiKey = (configApiKey ?? string.Empty).Trim();
config.ItemNotFoundUrl = GetItemNotFoundUrl(_settings);
MultilistField enabledSitesField = enterspeedConfigurationItem.Fields[EnterspeedIDs.Fields.EnterspeedEnabledSitesFieldID];
var enabledSites = enabledSitesField?.GetItems()?.ToList() ?? new List <Item>();
if (enabledSites.Any())
{
List <SiteInfo> allSiteInfos = _siteContextFactory.GetSites();
foreach (Item enabledSite in enabledSites)
{
SiteInfo matchingSite = allSiteInfos.FirstOrDefault(x => x.RootPath.Equals(enabledSite.Paths.FullPath, StringComparison.OrdinalIgnoreCase));
if (matchingSite == null)
{
continue;
}
SiteContext siteContext = _siteContextFactory.GetSiteContext(matchingSite.Name);
Language siteLanguage = _languageManager.GetLanguage(siteContext.Language);
Item homeItem = _itemManager.GetItem(siteContext.StartPath, siteLanguage, Version.Latest, siteContext.Database);
if (homeItem == null || homeItem.Versions.Count == 0)
{
// TODO - KEK: throw exception here?
continue;
}
string name = siteContext.SiteInfo.Name;
string startPathUrl = _linkManager.GetItemUrl(homeItem, new ItemUrlBuilderOptions
{
SiteResolving = true,
Site = siteContext,
AlwaysIncludeServerUrl = true,
LowercaseUrls = true,
LanguageEmbedding = LanguageEmbedding.Never
});
var enterspeedSiteInfo = new EnterspeedSiteInfo
{
Name = name,
BaseUrl = startPathUrl,
HomeItemPath = siteContext.StartPath,
SiteItemPath = siteContext.RootPath
};
if (siteContext.Properties["scheme"] != null &&
siteContext.Properties["scheme"].Equals("https", StringComparison.OrdinalIgnoreCase))
{
enterspeedSiteInfo.IsHttpsEnabled = true;
}
config.SiteInfos.Add(enterspeedSiteInfo);
}
}
// Settings caching values
_configuration = config;
_configurationRevisionId = currentRevisionId;
return(_configuration);
}
public IEnterspeedProperty Convert(Item item, Field field, EnterspeedSiteInfo siteInfo, List <IEnterspeedFieldValueConverter> fieldValueConverters)
{
string value = FieldRenderer.Render(item, field.Name);
return(new StringEnterspeedProperty(_fieldService.GetFieldName(field), value));
}
