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 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));
}
private void HandleDictionary(Item item, EnterspeedSitecoreConfiguration configuration, bool itemIsDeleted, bool itemIsPublished)
{
if (item == null)
{
return;
}
// Skip, if the item published is not a dictionary item
if (!item.IsDictionaryItem())
{
return;
}
if (!IsItemReferencedFromEnabledContent(item, configuration))
{
return;
}
SitecoreDictionaryEntity sitecoreDictionaryEntity = _sitecoreDictionaryEntityModelMapper.Map(item);
if (sitecoreDictionaryEntity == null)
{
return;
}
if (itemIsDeleted)
{
string id = _identityService.GetId(item);
_loggingService.Info($"Beginning to delete dictionary entity ({id}).");
Response deleteResponse = _enterspeedIngestService.Delete(id);
if (!deleteResponse.Success)
{
_loggingService.Warn($"Failed deleting dictionary entity ({id}). Message: {deleteResponse.Message}", deleteResponse.Exception);
}
else
{
_loggingService.Debug($"Successfully deleting dictionary entity ({id})");
}
return;
}
if (itemIsPublished)
{
string id = _identityService.GetId(item);
_loggingService.Info($"Beginning to ingest dictionary entity ({id}).");
Response saveResponse = _enterspeedIngestService.Save(sitecoreDictionaryEntity);
if (!saveResponse.Success)
{
_loggingService.Warn($"Failed ingesting dictionary entity ({id}). Message: {saveResponse.Message}", saveResponse.Exception);
}
else
{
_loggingService.Debug($"Successfully ingested dictionary entity ({id})");
}
}
}
private void HandleRendering(Item item, EnterspeedSitecoreConfiguration configuration, bool itemIsDeleted, bool itemIsPublished)
{
try
{
if (item == null)
{
return;
}
// Skip, if the item published is not a rendering item
if (!item.IsRenderingItem())
{
return;
}
RenderingItem renderingItem = item;
if (renderingItem?.InnerItem == null)
{
return;
}
if (!IsItemReferencedFromEnabledContent(item, configuration))
{
return;
}
if (itemIsDeleted)
{
DeleteEntity(renderingItem);
}
else if (itemIsPublished)
{
SaveEntity(renderingItem);
}
}
catch (Exception exception)
{
Debug.WriteLine(exception.ToString());
}
}
public void OnItemProcessed(object sender, EventArgs args)
{
PublishItemContext context = args is ItemProcessedEventArgs itemProcessedEventArgs
? itemProcessedEventArgs.Context
: null;
if (context == null)
{
return;
}
EnterspeedSitecoreConfiguration configuration = _enterspeedConfigurationService.GetConfiguration();
if (!configuration.IsEnabled)
{
return;
}
Language language = context.PublishOptions.Language;
// Getting the source item first
Item sourceItem = _itemManager.GetItem(context.ItemId, language, Version.Latest, context.PublishHelper.Options.SourceDatabase);
if (sourceItem == null)
{
return;
}
if (!HasAllowedPath(sourceItem))
{
return;
}
// Handling if the item was deleted or unpublished
bool itemIsDeleted = context.Action == PublishAction.DeleteTargetItem;
if (itemIsDeleted)
{
HandleContentItem(sourceItem, configuration, true, false);
HandleRendering(sourceItem, configuration, true, false);
HandleDictionary(sourceItem, configuration, true, false);
return;
}
// Handling if the item was published
Item targetItem = _itemManager.GetItem(context.ItemId, language, Version.Latest, context.PublishHelper.Options.TargetDatabase);
if (targetItem == null || targetItem.Versions.Count == 0)
{
return;
}
if (!HasAllowedPath(targetItem))
{
return;
}
HandleContentItem(targetItem, configuration, false, true);
HandleRendering(targetItem, configuration, false, true);
HandleDictionary(targetItem, configuration, false, true);
}
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 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);
}
