public bool RecycleBinSmells()
{
IAppPolicyCache cache = _cache.RuntimeCache;
var cacheKey = CacheKeys.MediaRecycleBinCacheKey;
// always cache either true or false
return(cache.GetCacheItem(cacheKey, () => CountChildren(RecycleBinId) > 0));
}
private IReadOnlyDictionary <string, string> GetIconDictionary() => _cache.GetCacheItem(
$"{typeof(IconService).FullName}.{nameof(GetIconDictionary)}",
() => GetAllIconsFiles()
.Select(GetIcon)
.Where(i => i != null)
.GroupBy(i => i.Name, StringComparer.OrdinalIgnoreCase)
.ToDictionary(g => g.Key, g => g.First().SvgString, StringComparer.OrdinalIgnoreCase)
);
public List <DtgeManifest> GetAllCachedManifests(bool purgeCache = false)
{
if (purgeCache)
{
_cache.ClearByKey("skttlDtgeTreeManifests");
}
return(_cache.GetCacheItem <List <DtgeManifest> >("skttlDtgeTreeManifests", () => GetAllManifests(), new TimeSpan(1, 0, 0)));
}
public List <Schema> GetIcons()
{
// GetCacheItem will automatically insert the object
// into cache if it doesn't exist.
return(_runtimeCache.GetCacheItem(Settings.CacheKey, () =>
{
using (var scope = _scopeProvider.CreateScope(autoComplete: true))
{
var database = scope.Database;
var results = scope.Database.Fetch <Schema>("SELECT * FROM U8SK_ContentNodeIcons");
scope.Complete();
return results;
}
}));
}
// gets this macro content from the cache
// ensuring that it is appropriate to use the cache
private MacroContent?GetMacroContentFromCache(MacroModel model)
{
if (!_umbracoContextAccessor.TryGetUmbracoContext(out IUmbracoContext? umbracoContext))
{
return(null);
}
// only if cache is enabled
if (umbracoContext.InPreviewMode || model.CacheDuration <= 0)
{
return(null);
}
IAppPolicyCache cache = _appCaches.RuntimeCache;
MacroContent? macroContent =
cache.GetCacheItem <MacroContent>(CacheKeys.MacroContentCacheKey + model.CacheIdentifier);
if (macroContent == null)
{
return(null);
}
_logger.LogDebug("Macro content loaded from cache '{MacroCacheId}'", model.CacheIdentifier);
// ensure that the source has not changed
// note: does not handle dependencies, and never has
FileInfo?macroSource = GetMacroFile(model); // null if macro is not file-based
if (macroSource != null)
{
if (macroSource.Exists == false)
{
_logger.LogDebug("Macro source does not exist anymore, ignore cache.");
return(null);
}
if (macroContent.Date < macroSource.LastWriteTime)
{
_logger.LogDebug("Macro source has changed, ignore cache.");
return(null);
}
}
return(macroContent);
}
/// <summary>
/// Calculate start nodes, combining groups' and user's, and excluding what's in the bin
/// </summary>
public static int[]? CalculateContentStartNodeIds(this IUser user, IEntityService entityService, AppCaches appCaches)
{
var cacheKey = CacheKeys.UserAllContentStartNodesPrefix + user.Id;
IAppPolicyCache runtimeCache = appCaches.IsolatedCaches.GetOrCreate <IUser>();
var result = runtimeCache.GetCacheItem(
cacheKey,
() =>
{
// This returns a nullable array even though we're checking if items have value and there cannot be null
// We use Cast<int> to recast into non-nullable array
var gsn = user.Groups.Where(x => x.StartContentId is not null).Select(x => x.StartContentId).Distinct()
.Cast <int>().ToArray();
var usn = user.StartContentIds;
if (usn is not null)
{
var vals = CombineStartNodes(UmbracoObjectTypes.Document, gsn, usn, entityService);
return(vals);
}
return(null);
},
/// <summary>
/// Get the GUIDs for all items in a folder
/// </summary>
/// <remarks>
/// This is disk intensive, (checking the .config files all the time)
/// so we cache it, and if we are using the flat folder stucture, then
/// we only do it once, so its quicker.
/// </remarks>
private IList <Guid> GetFolderKeys(string folder, bool flat)
{
// We only need to load all the keys once per handler (if all items are in a folder that key will be used).
var folderKey = folder.GetHashCode();
var cacheKey = $"keycache_{this.Alias}_{folderKey}";
return(runtimeCache.GetCacheItem(cacheKey, () =>
{
var keys = new List <Guid>();
var files = syncFileService.GetFiles(folder, "*.config");
foreach (var file in files)
{
var node = XElement.Load(file);
var key = node.GetKey();
if (!keys.Contains(key))
{
keys.Add(key);
}
}
return keys;
}, null));
}
/// <summary>
/// Get the GUIDs for all items in a folder
/// </summary>
/// <remarks>
/// This is disk intensive, (checking the .config files all the time)
/// so we cache it, and if we are using the flat folder stucture, then
/// we only do it once, so its quicker.
/// </remarks>
private IList <Guid> GetFolderKeys(string folder, bool flat)
{
// if it's flat, then we only need to load all the keys once per handler
var folderKey = flat == true ? 1 : folder.GetHashCode();
var cacheKey = $"uSyncKeyList_{folderKey}_{this.Alias}";
return(runtimeCache.GetCacheItem(cacheKey, () =>
{
var keys = new List <Guid>();
var files = syncFileService.GetFiles(folder, "*.config");
foreach (var file in files)
{
var node = XElement.Load(file);
var key = node.GetKey();
if (!keys.Contains(key))
{
keys.Add(key);
}
}
return keys;
}, null));
}
/// <summary>
/// This is used to configure the file sources with the main file sources shipped with Umbraco and also including supplemental/plugin based
/// localization files. The supplemental files will be loaded in and merged in after the primary files.
/// The supplemental files must be named with the 4 letter culture name with a hyphen such as : en-AU.xml
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="fileSourceFolder"></param>
/// <param name="supplementFileSources"></param>
public LocalizedTextServiceFileSources(
ILogger logger,
AppCaches appCaches,
DirectoryInfo fileSourceFolder,
IEnumerable <LocalizedTextServiceSupplementaryFileSource> supplementFileSources)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (appCaches == null)
{
throw new ArgumentNullException("cache");
}
if (fileSourceFolder == null)
{
throw new ArgumentNullException("fileSourceFolder");
}
_logger = logger;
_cache = appCaches.RuntimeCache;
//Create the lazy source for the _xmlSources
_xmlSources = new Lazy <Dictionary <CultureInfo, Lazy <XDocument> > >(() =>
{
var result = new Dictionary <CultureInfo, Lazy <XDocument> >();
if (_fileSourceFolder == null)
{
return(result);
}
foreach (var fileInfo in _fileSourceFolder.GetFiles("*.xml"))
{
var localCopy = fileInfo;
var filename = Path.GetFileNameWithoutExtension(localCopy.FullName).Replace("_", "-");
// TODO: Fix this nonsense... would have to wait until v8 to store the language files with their correct
// names instead of storing them as 2 letters but actually having a 4 letter culture. So now, we
// need to check if the file is 2 letters, then open it to try to find it's 4 letter culture, then use that
// if it's successful. We're going to assume (though it seems assuming in the legacy logic is never a great idea)
// that any 4 letter file is named with the actual culture that it is!
CultureInfo culture = null;
if (filename.Length == 2)
{
//we need to open the file to see if we can read it's 'real' culture, we'll use XmlReader since we don't
//want to load in the entire doc into mem just to read a single value
using (var fs = fileInfo.OpenRead())
using (var reader = XmlReader.Create(fs))
{
if (reader.IsStartElement())
{
if (reader.Name == "language")
{
if (reader.MoveToAttribute("culture"))
{
var cultureVal = reader.Value;
try
{
culture = CultureInfo.GetCultureInfo(cultureVal);
//add to the tracked dictionary
_twoLetterCultureConverter[filename] = culture;
}
catch (CultureNotFoundException)
{
Current.Logger.Warn <LocalizedTextServiceFileSources>("The culture {CultureValue} found in the file {CultureFile} is not a valid culture", cultureVal, fileInfo.FullName);
//If the culture in the file is invalid, we'll just hope the file name is a valid culture below, otherwise
// an exception will be thrown.
}
}
}
}
}
}
if (culture == null)
{
culture = CultureInfo.GetCultureInfo(filename);
}
//get the lazy value from cache
result[culture] = new Lazy <XDocument>(() => _cache.GetCacheItem <XDocument>(
string.Format("{0}-{1}", typeof(LocalizedTextServiceFileSources).Name, culture.Name), () =>
{
XDocument xdoc;
//load in primary
using (var fs = localCopy.OpenRead())
{
xdoc = XDocument.Load(fs);
}
//load in supplementary
MergeSupplementaryFiles(culture, xdoc);
return(xdoc);
}, isSliding: true, timeout: TimeSpan.FromMinutes(10), dependentFiles: new[] { localCopy.FullName }));
}
return(result);
});
if (fileSourceFolder.Exists == false)
{
Current.Logger.Warn <LocalizedTextServiceFileSources>("The folder does not exist: {FileSourceFolder}, therefore no sources will be discovered", fileSourceFolder.FullName);
}
else
{
_fileSourceFolder = fileSourceFolder;
_supplementFileSources = supplementFileSources;
}
}
public IEnumerable <IPublishedContent> GetCachedResult(string cacheKey, Func <IEnumerable <IPublishedContent> > function)
{
return(_runtimeCache.GetCacheItem <IEnumerable <IPublishedContent> >(cacheKey, () => function.Invoke()));
}
public T GetCacheItem <T>(string key, Func <T> getCacheItem)
{
return(_cacheEnabled ? _cache.GetCacheItem(key, getCacheItem, TimeSpan.FromSeconds(_cacheDuration)) : getCacheItem.Invoke());
}
private object GetPreValuesCollectionByDataTypeId(int dataTypeId)
{
return(_runtimeCache.GetCacheItem(
string.Concat("Bento.Core.Services.EmbeddedContentService.GetPreValuesCollectionByDataTypeId_", dataTypeId),
() => _dataTypeService.GetDataType(dataTypeId).Configuration));
}