/// <summary>
/// Returns the integer id for a given GUID
/// </summary>
/// <param name="key"></param>
/// <param name="umbracoObjectType"></param>
/// <returns></returns>
public Attempt <int> GetIdForKey(Guid key, UmbracoObjectTypes umbracoObjectType)
{
var result = _runtimeCache.GetCacheItem <int?>(CacheKeys.IdToKeyCacheKey + key, () =>
{
using (var uow = UowProvider.GetUnitOfWork())
{
switch (umbracoObjectType)
{
case UmbracoObjectTypes.Document:
case UmbracoObjectTypes.MemberType:
case UmbracoObjectTypes.Media:
case UmbracoObjectTypes.Template:
case UmbracoObjectTypes.MediaType:
case UmbracoObjectTypes.DocumentType:
case UmbracoObjectTypes.Member:
case UmbracoObjectTypes.DataType:
return(uow.Database.ExecuteScalar <int?>(new Sql().Select("id").From <NodeDto>().Where <NodeDto>(dto => dto.UniqueId == key)));
case UmbracoObjectTypes.RecycleBin:
case UmbracoObjectTypes.Stylesheet:
case UmbracoObjectTypes.MemberGroup:
case UmbracoObjectTypes.ContentItem:
case UmbracoObjectTypes.ContentItemType:
case UmbracoObjectTypes.ROOT:
case UmbracoObjectTypes.Unknown:
default:
throw new NotSupportedException();
}
}
});
return(result.HasValue ? Attempt.Succeed(result.Value) : Attempt <int> .Fail());
}
/// <inheritdoc/>
public TreeNode <ProductFilterGroupNode> GetTree(params Guid[] collectionKeys)
{
var cacheKey = GetCacheKey(collectionKeys);
var tree = (TreeNode <ProductFilterGroupNode>)_cache.GetCacheItem(cacheKey);
if (tree != null)
{
return(tree);
}
// get all of the filter groups
var filterGroups = _getter.Invoke().ToArray();
// create a specific context for each filter group and filter (within the group)
var contextKeys = GetContextKeys(filterGroups, collectionKeys);
var tuples = CountKeysThatExistInAllCollections(contextKeys);
tree = BuildTreeNode(filterGroups, tuples, collectionKeys);
return((TreeNode <ProductFilterGroupNode>)_cache.GetCacheItem(cacheKey, () => tree, TimeSpan.FromHours(6)));
}
/// <summary>
/// Gets the Url from the UmbracoUrl type
/// </summary>
/// <param name="umbracoUrl">The umbraco url object from the app's config</param>
/// <returns>The Unauthorised Url, or null</returns>
public string Url(UmbracoUrl umbracoUrl)
{
if (string.IsNullOrEmpty(umbracoUrl.Value))
{
LogHelper.Error <UmbracoUrlService>("Error: No Unauthorized URL set in configuration", null);
return(null);
}
if (umbracoUrl.Type == UmbracoUrlTypes.Url)
{
return(umbracoUrl.Value);
}
if (cache == null)
{
cache = ApplicationContext.Current.ApplicationCache.RuntimeCache;
}
return(cache.GetCacheItem <string>(CacheKeyUrl + umbracoUrl.Value, () =>
{
EnsureUmbracoContext(HttpContext.Current);
var umbContext = UmbracoContext.Current;
if (umbContext == null)
{
LogHelper.Error <UmbracoUrlService>("Need to run this method from within a valid HttpContext request", null);
return null;
}
var umbracoContentService = new UmbracoContentService(umbContext);
switch (umbracoUrl.Type)
{
case UmbracoUrlTypes.XPath:
var xpathId = umbracoContentService.XPath(umbracoUrl.Value);
if (xpathId != null)
{
return umbracoContentService.Url((int)xpathId);
}
LogHelper.Error <UmbracoUrlService>($"Error: Unable to find content using xpath of '{umbracoUrl.Value}'", null);
break;
case UmbracoUrlTypes.ContentPicker:
if (int.TryParse(umbracoUrl.Value, out var id))
{
return umbracoContentService.Url(id);
}
LogHelper.Error <UmbracoUrlService>("Error: Unable to parse the selected unauthorized URL content picker item. Please ensure a valid content node is selected", null);
break;
default:
LogHelper.Error <UmbracoUrlService>("Error: Unable to determine which method to use to get the unauthorized URL. Please ensure URL, XPath or Content Picker is selected", null);
break;
}
return null;
}, CacheDuration));
}
public void GetCachedItem_ReturnsNull()
{
//// Arrange
var key = Guid.NewGuid().ToString();
//// Act
var result = runtimeCache.GetCacheItem(key);
//// Assert
Assert.That(result, Is.Null);
}
public TT GetCacheItem <TT>(string cacheKey)
{
if (_enableCache == false)
{
return(_nullHttpCache.GetCacheItem <TT>(cacheKey));
}
else
{
return(_httpCache.GetCacheItem <TT>(cacheKey));
}
}
/// <summary>
/// Gets all entities of type TEntity or a list according to the passed in Guid Keys
/// </summary>
/// <param name="keys">The keys of the entities to be returned</param>
/// <returns>A collection of entities</returns>
public IEnumerable <TEntity> GetAll(params Guid[] Keys)
{
if (Keys.Any())
{
var entities = new List <TEntity>();
foreach (var key in Keys)
{
var entity = _cache.GetCacheItem(GetCacheKey(key));
if (entity != null)
{
entities.Add((TEntity)entity);
}
}
if (entities.Count().Equals(Keys.Count()) && entities.Any(x => x.Equals(default(TEntity))) == false)
{
return(entities);
}
}
else
{
var allEntities = _cache.GetCacheItemsByKeySearch(typeof(TEntity).Name + ".").ToArray();
if (allEntities.Any())
{
var query = this.GetBaseQuery(true);
var totalCount = PerformCount(query);
if (allEntities.Count() == totalCount)
{
return(allEntities.Select(x => (TEntity)x));
}
}
}
var entityCollection = PerformGetAll(Keys).ToArray();
foreach (var entity in entityCollection)
{
if (!entity.Equals(default(TEntity)))
{
var en = entity;
_cache.GetCacheItem(GetCacheKey(entity.Key), () => en);
}
}
return(entityCollection);
}
internal static void DeleteRow(IGatewayProviderService gatewayProviderService, IRuntimeCacheProvider cache, IShippingFixedRateTable rateTable, IShipRateTier shipRateTier)
{
//var row = Rows.FirstOrDefault(x => x.Key == shipRateTier.Key);
//if (!Rows.Any() || row == null) return;
//if (Rows.IndexOf(Rows.Last()) != Rows.IndexOf(row))
//{
// _shipRateTiers[Rows.IndexOf(row) + 1].RangeLow = row.RangeLow;
//}
//_shipRateTiers.Remove(row);
var row = rateTable.Rows.FirstOrDefault(x => x.Key == shipRateTier.Key);
if (!rateTable.Rows.Any() || row == null)
{
return;
}
if (rateTable.Rows.IndexOf(rateTable.Rows.Last()) != rateTable.Rows.IndexOf(row))
{
rateTable.Rows.First(x => x.RangeLow == row.RangeHigh).RangeLow = row.RangeLow;
}
// clear the current cached item
// TODO : This should use the distributed cache referesher
cache.ClearCacheItem(CacheKeys.GatewayShipMethodCacheKey(rateTable.ShipMethodKey));
gatewayProviderService.Save(rateTable.Rows);
gatewayProviderService.Delete(shipRateTier);
cache.GetCacheItem(CacheKeys.GatewayShipMethodCacheKey(rateTable.ShipMethodKey), () => rateTable);
}
/// <summary>
/// Returns the enumerable of all extension method info's in the app domain = USE SPARINGLY!!!
/// </summary>
/// <returns></returns>
/// <remarks>
/// We cache this as a sliding 5 minute exiration, in unit tests there's over 1100 methods found, surely that will eat up a bit of memory so we want
/// to make sure we give it back.
/// </remarks>
private static IEnumerable <MethodInfo> GetAllExtensionMethodsInAppDomain(IRuntimeCacheProvider runtimeCacheProvider)
{
if (runtimeCacheProvider == null)
{
throw new ArgumentNullException("runtimeCacheProvider");
}
return(runtimeCacheProvider.GetCacheItem <MethodInfo[]>(typeof(ExtensionMethodFinder).Name, () => TypeFinder.GetAssembliesWithKnownExclusions()
// assemblies that contain extension methods
.Where(a => a.IsDefined(typeof(ExtensionAttribute), false))
// types that contain extension methods
.SelectMany(a => a.GetTypes()
.Where(t => t.IsDefined(typeof(ExtensionAttribute), false) && t.IsSealed && t.IsGenericType == false && t.IsNested == false))
// actual extension methods
.SelectMany(t => t.GetMethods(BindingFlags.Static | BindingFlags.Public)
.Where(m => m.IsDefined(typeof(ExtensionAttribute), false)))
// and also IEnumerable<T> extension methods - because the assembly is excluded
.Concat(typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public))
//If we don't do this then we'll be scanning all assemblies each time!
.ToArray(),
//only cache for 5 minutes
timeout: TimeSpan.FromMinutes(5),
//each time this is accessed it will be for 5 minutes longer
isSliding: true));
}
public List <DtgeManifest> GetAllCachedManifests(bool purgeCache = false)
{
if (purgeCache)
{
_cache.ClearCacheItem("skttlDtgeTreeManifests");
}
return(_cache.GetCacheItem <List <DtgeManifest> >("skttlDtgeTreeManifests", () => GetAllManifests(), new TimeSpan(1, 0, 0)));
}
/// <summary>
/// Get all registered manifests
/// </summary>
/// <returns></returns>
/// <remarks>
/// This ensures that we only build and look for all manifests once per Web app (based on the IRuntimeCache)
/// </remarks>
public IEnumerable <PackageManifest> GetManifests()
{
return(_cache.GetCacheItem <IEnumerable <PackageManifest> >(typeof(ManifestParser) + "GetManifests", () =>
{
//get all Manifest.js files in the appropriate folders
var manifestFileContents = GetAllManifestFileContents(_pluginsDir);
return CreateManifests(manifestFileContents.ToArray());
}, new TimeSpan(0, 10, 0)));
}
/// <summary>
/// The perform geocode.
/// </summary>
/// <param name="formattedAddress">
/// The formatted address.
/// </param>
/// <returns>
/// The <see cref="IGeocodeProviderResponse"/>.
/// </returns>
private IGeocodeProviderResponse TryGetGeocode(string formattedAddress)
{
return(_settings.EnableCaching
? (IGeocodeProviderResponse)_cache
.GetCacheItem(
Caching.CacheKeys.GetGeocodeRequestCacheKey(GetType(), formattedAddress),
() => GetResponse(formattedAddress),
new TimeSpan(0, 0, 0, _settings.CacheDuration))
: GetResponse(formattedAddress));
}
/// <summary>
/// The get ship rate table.
/// </summary>
/// <param name="gatewayProviderService">
/// The gateway provider service.
/// </param>
/// <param name="runtimeCacheProvider">
/// The runtime cache provider.
/// </param>
/// <param name="shipMethodKey">
/// The ship method key.
/// </param>
/// <returns>
/// The <see cref="ShippingFixedRateTable"/>.
/// </returns>
internal static ShippingFixedRateTable GetShipRateTable(IGatewayProviderService gatewayProviderService, IRuntimeCacheProvider runtimeCacheProvider, Guid shipMethodKey)
{
return((ShippingFixedRateTable)runtimeCacheProvider.GetCacheItem(
CacheKeys.GatewayShipMethodCacheKey(shipMethodKey),
delegate
{
var rows = gatewayProviderService.GetShipRateTiersByShipMethodKey(shipMethodKey);
return new ShippingFixedRateTable(shipMethodKey, rows);
}, TimeSpan.FromHours(6)));
}
/// <summary>
/// The save.
/// </summary>
/// <param name="gatewayProviderService">
/// The gateway provider service.
/// </param>
/// <param name="cache">
/// The cache.
/// </param>
/// <param name="rateTable">
/// The rate table.
/// </param>
internal static void Save(IGatewayProviderService gatewayProviderService, IRuntimeCacheProvider cache, IShippingFixedRateTable rateTable)
{
// clear the current cached item
// TODO : This should use the distributed cache referesher
cache.ClearCacheItem(CacheKeys.GatewayShipMethodCacheKey(rateTable.ShipMethodKey));
// persist and enter into cache
gatewayProviderService.Save(rateTable.Rows);
cache.GetCacheItem(CacheKeys.GatewayShipMethodCacheKey(rateTable.ShipMethodKey), () => rateTable, TimeSpan.FromHours(6));
}
public static JArray GetResult(IRuntimeCacheProvider cache, string url)
{
return((JArray)cache.GetCacheItem(url, () =>
{
using (var client = new HttpClient())
{
var result = client.GetStringAsync(url);
Task.WaitAll(result);
return JsonConvert.DeserializeObject <JArray>(result.Result);
}
}));
}
public static T GetCacheItem <T>(this IRuntimeCacheProvider provider,
string cacheKey,
Func <T> getCacheItem,
TimeSpan?timeout,
bool isSliding = false,
CacheItemPriority priority = CacheItemPriority.Normal,
CacheItemRemovedCallback removedCallback = null,
string[] dependentFiles = null)
{
var result = provider.GetCacheItem(cacheKey, () => getCacheItem(), timeout, isSliding, priority, removedCallback, dependentFiles);
return(result == null ? default(T) : result.TryConvertTo <T>().Result);
}
public static JArray GetResult(IRuntimeCacheProvider cache, string url)
{
return (JArray)cache.GetCacheItem(url, () =>
{
using (var client = new HttpClient())
{
var result = client.GetStringAsync(url);
Task.WaitAll(result);
return JsonConvert.DeserializeObject<JArray>(result.Result);
}
});
}
/// <summary>
/// Returns permissions for a given user for any number of nodes
/// </summary>
/// <param name="userId"></param>
/// <param name="entityIds"></param>
/// <returns></returns>
public IEnumerable <EntityPermission> GetUserPermissionsForEntities(int userId, params int[] entityIds)
{
var entityIdKey = string.Join(",", entityIds.Select(x => x.ToString(CultureInfo.InvariantCulture)));
return(_runtimeCache.GetCacheItem <IEnumerable <EntityPermission> >(
string.Format("{0}{1}{2}", CacheKeys.UserPermissionsCacheKey, userId, entityIdKey),
() =>
{
var whereBuilder = new StringBuilder();
//where userId = @userId AND
whereBuilder.Append(_sqlSyntax.GetQuotedColumnName("userId"));
whereBuilder.Append("=");
whereBuilder.Append(userId);
if (entityIds.Any())
{
whereBuilder.Append(" AND ");
//where nodeId = @nodeId1 OR nodeId = @nodeId2, etc...
whereBuilder.Append("(");
for (var index = 0; index < entityIds.Length; index++)
{
var entityId = entityIds[index];
whereBuilder.Append(_sqlSyntax.GetQuotedColumnName("nodeId"));
whereBuilder.Append("=");
whereBuilder.Append(entityId);
if (index < entityIds.Length - 1)
{
whereBuilder.Append(" OR ");
}
}
whereBuilder.Append(")");
}
var sql = new Sql();
sql.Select("*")
.From <User2NodePermissionDto>()
.Where(whereBuilder.ToString());
//ToArray() to ensure it's all fetched from the db once.
var result = _unitOfWork.Database.Fetch <User2NodePermissionDto>(sql).ToArray();
return ConvertToPermissionList(result);
},
//Since this cache can be quite large (http://issues.umbraco.org/issue/U4-2161) we will only have this exist in cache for 20 minutes,
// then it will refresh from the database.
new TimeSpan(0, 20, 0),
//Since this cache can be quite large (http://issues.umbraco.org/issue/U4-2161) we will make this priority below average
priority: CacheItemPriority.BelowNormal));
}
public string[] GetResult()
{
return((string[])_cache.GetCacheItem(typeof(GitHubFeed).ToString(), () =>
{
using (var client = new HttpClient())
{
var result = client.GetStringAsync(_url);
Task.WaitAll(result);
var xml = XDocument.Parse(result.Result);
var ns = XNamespace.Get("http://www.w3.org/2005/Atom");
return xml.Root.Descendants(ns + "content").Select(x => x.Value).Take(_maxResults).ToArray();
}
}, TimeSpan.FromHours(0.5)));
}
/// <summary>
/// Unit of work method that tells the repository to persist the new entity
/// </summary>
/// <param name="entity">The entity to be created</param>
public virtual void PersistNewItem(IEntity entity)
{
try
{
PersistNewItem((TEntity)entity);
_cache.GetCacheItem(GetCacheKey(entity.Key), () => entity);
}
catch (Exception)
{
////if an exception is thrown we need to remove the entry from cache, this is ONLY a work around because of the way
//// that we cache entities: http://issues.umbraco.org/issue/U4-4259
_cache.ClearCacheItem(GetCacheKey(entity.Key));
throw;
}
}
/// <summary>
/// Unit of work method that tells the repository to persist the new entity
/// </summary>
/// <param name="entity">The entity to be created</param>
public virtual void PersistNewItem(IEntity entity)
{
try
{
PersistNewItem((TEntity)entity);
_cache.GetCacheItem(GetCacheKey(entity.Key), () => entity);
}
catch (Exception ex)
{
LogHelper.Error(GetType(), "An error occurred trying to add a new entity", ex);
////if an exception is thrown we need to remove the entry from cache, this is ONLY a work around because of the way
//// that we cache entities: http://issues.umbraco.org/issue/U4-4259
_cache.ClearCacheItem(GetCacheKey(entity.Key));
throw;
}
}
/// <summary>
/// Gets an entity by the passed in Id
/// </summary>
/// <returns></returns>
public TEntity Get(Guid key)
{
var fromCache = TryGetFromCache(key);
if (fromCache.Success)
{
return(fromCache.Result);
}
var entity = PerformGet(key);
if (entity != null)
{
_cache.GetCacheItem(GetCacheKey(key), () => entity);
}
if (entity != null)
{
entity.ResetDirtyProperties();
}
return(entity);
}
protected IEnumerable <DeliveryOption> GetCollectionFromCache(IShipment shipment)
{
return(_runtimeCache.GetCacheItem(MakeCacheKey(shipment)) as IEnumerable <DeliveryOption>);
}
public static string GetCropUrl(
this IPublishedContent mediaItem,
int?width = null,
int?height = null,
string propertyAlias = Constants.Conventions.Media.File,
string cropAlias = null,
int?quality = null,
ImageCropMode?imageCropMode = null,
ImageCropAnchor?imageCropAnchor = null,
bool preferFocalPoint = false,
bool useCropDimensions = false,
bool cacheBuster = true,
string furtherOptions = null,
ImageCropRatioMode?ratioMode = null,
bool upScale = true,
bool resolveCdnPath = false)
{
string cropUrl = ImageCropperTemplateExtensions.GetCropUrl(
mediaItem, width, height, propertyAlias, cropAlias, quality, imageCropMode, imageCropAnchor,
preferFocalPoint, useCropDimensions, cacheBuster, furtherOptions, ratioMode, upScale);
if (!resolveCdnPath)
{
return(cropUrl);
}
string cachePrefix = "Jaywing-AzureBlobCache";
string cacheKey = $"{cachePrefix}{cropUrl}";
string currentDomain = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority);
string absoluteCropPath = $"{currentDomain}{cropUrl}";
IRuntimeCacheProvider runtimeCache = DependencyResolver.Current.GetService <ApplicationContext>()?.ApplicationCache?.RuntimeCache;
if (runtimeCache == null)
{
return(cropUrl);
}
var cachedItem = runtimeCache.GetCacheItem <CachedImage>(cacheKey);
if (cachedItem != null)
{
return(cachedItem.CacheUrl);
}
var newCachedImage = new CachedImage {
WebUrl = cropUrl
};
try
{
var request = (HttpWebRequest)WebRequest.Create(absoluteCropPath);
request.Method = WebRequestMethods.Http.Head;
using (var response = (HttpWebResponse)request.GetResponse())
{
HttpStatusCode responseCode = response.StatusCode;
if (!responseCode.Equals(HttpStatusCode.OK))
{
return(cachedItem.CacheUrl);
}
newCachedImage.CacheUrl = response.ResponseUri.AbsoluteUri;
runtimeCache.InsertCacheItem <CachedImage>(cacheKey, () => newCachedImage);
return(response.ResponseUri.AbsoluteUri);
}
}
catch
{
return(cropUrl);
}
}
/// <summary>
/// The get ship rate table.
/// </summary>
/// <param name="gatewayProviderService">
/// The gateway provider service.
/// </param>
/// <param name="runtimeCacheProvider">
/// The runtime cache provider.
/// </param>
/// <param name="shipMethodKey">
/// The ship method key.
/// </param>
/// <returns>
/// The <see cref="ShippingFixedRateTable"/>.
/// </returns>
internal static ShippingFixedRateTable GetShipRateTable(IGatewayProviderService gatewayProviderService, IRuntimeCacheProvider runtimeCacheProvider, Guid shipMethodKey)
{
return (ShippingFixedRateTable) runtimeCacheProvider.GetCacheItem(
CacheKeys.GatewayShipMethodCacheKey(shipMethodKey),
delegate
{
var rows = gatewayProviderService.GetShipRateTiersByShipMethodKey(shipMethodKey);
return new ShippingFixedRateTable(shipMethodKey, rows);
});
}
/// <summary>
/// The save.
/// </summary>
/// <param name="gatewayProviderService">
/// The gateway provider service.
/// </param>
/// <param name="cache">
/// The cache.
/// </param>
/// <param name="rateTable">
/// The rate table.
/// </param>
internal static void Save(IGatewayProviderService gatewayProviderService, IRuntimeCacheProvider cache, IShippingFixedRateTable rateTable)
{
// clear the current cached item
// TODO : This should use the distributed cache referesher
cache.ClearCacheItem(CacheKeys.GatewayShipMethodCacheKey(rateTable.ShipMethodKey));
// persist and enter into cache
gatewayProviderService.Save(rateTable.Rows);
cache.GetCacheItem(CacheKeys.GatewayShipMethodCacheKey(rateTable.ShipMethodKey), () => rateTable);
}
public T GetCacheValue <T>(string cacheKey) where T : class
{
return((T)_runtimeCache.GetCacheItem($"TeaCommerce_{cacheKey}"));
}
/// <summary>
/// Returns the cached <see cref="IShipmentRateQuote"/> if it exists
/// </summary>
/// <param name="shipment">
/// The shipment.
/// </param>
/// <param name="shippingGatewayMethod">
/// The shipping Gateway Method.
/// </param>
/// <returns>
/// The <see cref="IShipmentRateQuote"/>.
/// </returns>
protected IShipmentRateQuote TryGetCachedShipmentRateQuote(IShipment shipment, IShippingGatewayMethod shippingGatewayMethod)
{
return(_runtimeCache.GetCacheItem(GetShipmentRateQuoteCacheKey(shipment, shippingGatewayMethod)) as ShipmentRateQuote);
}
/// <summary>
/// The delete row.
/// </summary>
/// <param name="gatewayProviderService">
/// The gateway provider service.
/// </param>
/// <param name="cache">
/// The cache.
/// </param>
/// <param name="rateTable">
/// The rate table.
/// </param>
/// <param name="shipRateTier">
/// The ship rate tier.
/// </param>
internal static void DeleteRow(IGatewayProviderService gatewayProviderService, IRuntimeCacheProvider cache, IShippingFixedRateTable rateTable, IShipRateTier shipRateTier)
{
var row = rateTable.Rows.FirstOrDefault(x => x.Key == shipRateTier.Key);
if (!rateTable.Rows.Any() || row == null) return;
if (rateTable.Rows.IndexOf(rateTable.Rows.Last()) != rateTable.Rows.IndexOf(row))
{
rateTable.Rows.First(x => x.RangeLow == row.RangeHigh).RangeLow = row.RangeLow;
}
// clear the current cached item
// TODO : This should use the distributed cache referesher
cache.ClearCacheItem(CacheKeys.GatewayShipMethodCacheKey(rateTable.ShipMethodKey));
gatewayProviderService.Save(rateTable.Rows);
gatewayProviderService.Delete(shipRateTier);
cache.GetCacheItem(CacheKeys.GatewayShipMethodCacheKey(rateTable.ShipMethodKey), () => rateTable);
}
/// <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,
IRuntimeCacheProvider cache,
DirectoryInfo fileSourceFolder,
IEnumerable <LocalizedTextServiceSupplementaryFileSource> supplementFileSources)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (cache == null)
{
throw new ArgumentNullException("cache");
}
if (fileSourceFolder == null)
{
throw new ArgumentNullException("fileSourceFolder");
}
_logger = logger;
_cache = cache;
//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. wtf. 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)
{
LogHelper.Warn <LocalizedTextServiceFileSources>(
string.Format("The culture {0} found in the file {1} 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)
{
LogHelper.Warn <LocalizedTextServiceFileSources>("The folder does not exist: {0}, therefore no sources will be discovered", () => fileSourceFolder.FullName);
}
else
{
_fileSourceFolder = fileSourceFolder;
_supplementFileSources = supplementFileSources;
}
}