public DatabaseDictionaryService(
LocalizationConfiguration configuration,
CultureUoW cultureUoW,
StaticTextUoW staticTextUoW,
PluralizedStaticTextUoW pluralizedStaticTextUoW,
ConstantStaticTextUoW constantStaticTextUoW,
DictionaryScopeUoW dictionaryScopeUoW,
ILogger <DatabaseDictionaryService> logger,
IMemoryCache memoryCache
) : base(configuration, cultureUoW, dictionaryScopeUoW, logger, memoryCache)
{
m_staticTextUoW = staticTextUoW;
m_pluralizedStaticTextUoW = pluralizedStaticTextUoW;
m_constantStaticTextUoW = constantStaticTextUoW;
}
/// <summary>
/// Checks if configuration is valid.
/// </summary>
/// <param name="configuration">Configuration to check.</param>
private void CheckConfiguration(LocalizationConfiguration configuration)
{
if (!configuration.SupportedCultures.Contains(configuration.DefaultCulture))
{
const string defaultCultureErrorMsg = "Default language in configuration is not in supported languages.";
var localizationLibraryException = new LocalizationLibraryException(defaultCultureErrorMsg);
if (m_logger != null && m_logger.IsErrorEnabled())
{
m_logger.LogError(defaultCultureErrorMsg, localizationLibraryException);
}
throw localizationLibraryException;
}
}
public DatabaseTranslateService(
FallbackCultureResolver fallbackCultureResolver,
CultureHierarchyUoW cultureHierarchyUoW,
StaticTextUoW staticTextUoW,
LocalizationConfiguration configuration,
CultureUoW cultureUoW,
DictionaryScopeUoW dictionaryScopeUoW,
ILogger <DatabaseTranslateService> logger,
IMemoryCache memoryCache
) : base(configuration, cultureUoW, dictionaryScopeUoW, logger, memoryCache)
{
m_fallbackCultureResolver = fallbackCultureResolver;
m_cultureHierarchyUoW = cultureHierarchyUoW;
m_staticTextUoW = staticTextUoW;
}
public void AutoLoadDictionariesTest()
{
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "LocalizationTree",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("en"),
new CultureInfo("es"),
},
AutoLoadResources = true,
};
var dictionaryManager = new FileDictionaryManager(localizationConfiguration, JsonDictionaryFactory.FactoryInstance);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
LocalizationConfiguration localizationConfig)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
app.UseHttpsRedirection();
}
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Monero Tutorials V1");
});
app.UseSignalR(routes =>
{
routes.MapHub <AppStatusHub>("/api/hubs/app-status");
});
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller}/{action=Index}/{id?}");
});
app.MapSpaForLanguages(env, localizationConfig.AvailableLanguages);
var timers = new AsyncSafeTimer[] {
app.ApplicationServices.GetRequiredService <AppStatusHubBroadcaster>(),
};
foreach (var timer in timers)
{
timer.StartTimer();
}
}
public void InitLibTest()
{
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "Localization",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("en"),
new CultureInfo("es"),
new CultureInfo("cs"),
}
};
var instance = new LocalizationLib(localizationConfiguration);
Assert.IsNotNull(instance);
}
public void LibInit()
{
var configuration = new LocalizationConfiguration
{
BasePath = "Localization",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>()
{
new CultureInfo("en"),
new CultureInfo("cs"),
},
TranslateFallbackMode = LocTranslateFallbackMode.EmptyString,
AutoLoadResources = true,
FirstAutoTranslateResource = LocLocalizationResource.File
};
m_localizationManager = new LocalizationLib(configuration).LocalizationManager;
}
public void SetUp()
{
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "Localization",
DefaultCulture = new CultureInfo(DefaultCulture),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo(SupportedCulture),
new CultureInfo("es"),
new CultureInfo(DefaultCulture),
},
FirstAutoTranslateResource = LocLocalizationResource.File,
AutoLoadResources = true
};
m_dictionaryManager = new LocalizationLib(localizationConfiguration).DictionaryManager;
}
public void UndefinedGlobalScopeTest()
{
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "LocalizationTree",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("de")
},
AutoLoadResources = true,
};
Assert.ThrowsException <DictionaryLoadException>(
() => new FileDictionaryManager(localizationConfiguration, JsonDictionaryFactory.FactoryInstance),
$"Not found 'global' scope in 'de' culture, unable to construct dictionary tree"
);
}
public void CheckScopeResourceFilesTest()
{
var configuration = new LocalizationConfiguration
{
BasePath = "Localization",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("cs"),
new CultureInfo("en"),
new CultureInfo("es"),
},
};
var folderScanner = new FolderScanner(JsonDictionaryFactory.FactoryInstance);
folderScanner.CheckResourceFiles(configuration);
}
/// <summary>
/// Configures the specified application.
/// </summary>
/// <param name="app">The application.</param>
/// <param name="env">The env.</param>
/// <param name="loggerFactory">The logger factory.</param>
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection(DefaultConstants.Logging));
loggerFactory.AddDebug();
#if RELEASE
loggerFactory.AddFile(Configuration.GetSection("Logging"));
#endif
// Localization support
LocalizationConfiguration.Configure(app);
app.UseMiddleware <ExceptionHandlerMiddleware>();
app.UseStaticFiles();
//Cunfigure the Swagger API documentation
SwaggerConfiguration.Configure(app);
app.UseMvc();
}
/// <summary>
/// Initializes Localization library.
/// </summary>
/// <param name="configuration">Library configuration</param>
/// <param name="databaseConfiguration">Configure database storage, e.g. NHibernateDatabaseConfiguration</param>
/// <param name="loggerFactory">Logger factory for enabling logging</param>
public LocalizationLib(
LocalizationConfiguration configuration,
IDatabaseConfiguration databaseConfiguration = null,
ILoggerFactory loggerFactory = null
)
{
var services = new ServiceCollection();
services.AddLocalizationCore(configuration, databaseConfiguration);
// Logger
services.AddSingleton(loggerFactory ?? NullLoggerFactory.Instance);
services.AddSingleton(typeof(ILogger <>), typeof(Logger <>));
// Init from IoC
var container = services.BuildServiceProvider();
m_localizationManager = container.GetRequiredService <IAutoLocalizationManager>();
m_dictionaryManager = container.GetRequiredService <IAutoDictionaryManager>();
}
public void Undefined_Localization_Source_Should_Be_Humanized()
{
// Default configuration
_localizationConfiguration = new LocalizationConfiguration();
// Fallback to the same text as It's already in sentence case
_resourceFileLocalizationSource
.GetString("Lorem ipsum dolor sit amet", new CultureInfo("en-US"))
.ShouldBe("Lorem ipsum dolor sit amet");
// Text in PascalCase should be converted properly
_resourceFileLocalizationSource
.GetString("LoremIpsumDolorSitAmet", new CultureInfo("en-US"))
.ShouldBe("Lorem ipsum dolor sit amet");
// Text with mixed cases should be converted properly
_resourceFileLocalizationSource
.GetString("LoremIpsum dolor sit amet", new CultureInfo("en-US"))
.ShouldBe("Lorem ipsum dolor sit amet");
}
public void PerformanceTest()
{
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "Localization",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("en"),
new CultureInfo("es"),
new CultureInfo("hu"),
new CultureInfo("zh"),
new CultureInfo("cs"),
},
TranslateFallbackMode = LocTranslateFallbackMode.Key,
AutoLoadResources = true
};
var instance = new LocalizationLib(localizationConfiguration);
var sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 1000; i++)
{
for (var j = 0; j < 50; j++)
{
var ls = instance.Translate(LocTranslationSource.File, null, null, "text-2-odst");
var lsQQ = instance.Translate(LocTranslationSource.File, null, null, "text-qq-odst");
var lsEn = instance.Translate(LocTranslationSource.File, new CultureInfo("en"), null, "text-2-odst");
var ls2 = instance.Translate(LocTranslationSource.File, null, null, "text-1-odst");
var ls2QQ = instance.Translate(LocTranslationSource.File, null, null, "q");
var ls2En = instance.Translate(LocTranslationSource.File, new CultureInfo("en"), null, "text-5-odst");
}
}
sw.Stop();
Debug.WriteLine("300 000 translations in " + sw.ElapsedMilliseconds + " miliseconds");
}
public void Init()
{
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "Localization",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("en"),
new CultureInfo("cs"),
},
TranslateFallbackMode = LocTranslateFallbackMode.Key
};
m_dictionaryManager = new FileDictionaryManager(localizationConfiguration, JsonDictionaryFactory.FactoryInstance);
var fallbackCultureResolver = new FallbackCultureResolver(localizationConfiguration);
m_fileLocalizationManager = new FileLocalizationManager(
localizationConfiguration, m_dictionaryManager, fallbackCultureResolver
);
}
/// <summary>
/// Creates dictionary filename by provided directory
/// </summary>
/// <param name="libConfiguration"></param>
/// <param name="directory"></param>
/// <param name="cultureInfo"></param>
/// <returns></returns>
public string ConstructResourceFileName(LocalizationConfiguration libConfiguration, string directory, CultureInfo cultureInfo, string fileExtension)
{
var cutString = string.Concat(libConfiguration.BasePath, Path.DirectorySeparatorChar);
var nameBase = directory.Split(new[] { cutString }, StringSplitOptions.None);
if (nameBase.Length != 2)
{
var message = string.Format(@"Provided path ""{0}"" is not inside basepath: ""{1}""", directory, libConfiguration.BasePath);
if (m_logger != null && m_logger.IsErrorEnabled())
{
m_logger.LogError(message);
}
throw new DictionaryLoadException(message);
}
var dotNotatedFileName = nameBase[1].Replace(Path.DirectorySeparatorChar, '.');
dotNotatedFileName = string.Concat(dotNotatedFileName, '.', cultureInfo.Name, '.', fileExtension);
return(Path.Combine(directory, dotNotatedFileName));
}
public void ConstructResourceFileName()
{
var configuration = new LocalizationConfiguration
{
BasePath = "Localization",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("cs"),
new CultureInfo("en"),
new CultureInfo("es"),
},
};
var folderScanner = new FolderScanner(JsonDictionaryFactory.FactoryInstance);
var fileName = folderScanner.ConstructResourceFileName(
configuration, Path.Combine("Localization", "slovniky"), new CultureInfo("cs"), JsonLocalizationDictionary.JsonExtension
);
Assert.AreEqual(Path.GetFullPath("Localization/slovniky/slovniky.cs.json"), Path.GetFullPath(fileName));
}
public void ScopeAliasSupportTest()
{
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "Localization",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("en"),
new CultureInfo("es")
},
AutoLoadResources = true
};
var dictionaryManager = new FileDictionaryManager(
localizationConfiguration, JsonDictionaryFactory.FactoryInstance
);
var dictionaryScope = dictionaryManager.GetLocalizationDictionary(new CultureInfo("cs"), "global");
var dictionaryAlias1 = dictionaryManager.GetLocalizationDictionary(new CultureInfo("cs"), "personalScope1");
var dictionaryAlias2 = dictionaryManager.GetLocalizationDictionary(new CultureInfo("cs"), "personalScope2");
Assert.AreSame(dictionaryScope, dictionaryAlias1);
Assert.AreSame(dictionaryScope, dictionaryAlias2);
}
public void InitTest()
{
m_sessionFactory = NHibernateConfigurator.GetSessionFactory(nameof(DatabaseTranslateTest));
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "localization",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("en"),
new CultureInfo("cs"),
new CultureInfo("es"),
new CultureInfo("jp"),
new CultureInfo("ru"),
},
TranslateFallbackMode = LocTranslateFallbackMode.Key
};
m_localizationConfiguration = localizationConfiguration;
var services = new ServiceCollection();
services.AddLocalizationCore(localizationConfiguration, new NHibernateDatabaseConfiguration(m_sessionFactory));
services.AddSingleton <ILoggerFactory>(NullLoggerFactory.Instance);
services.AddSingleton(typeof(ILogger <>), typeof(Logger <>));
var container = services.BuildServiceProvider();
var dbTranslateService = container.GetRequiredService <IDatabaseTranslateService>();
var dbDynamicTextService = container.GetRequiredService <IDatabaseDynamicTextService>();
m_databaseLocalizationManager =
new DatabaseLocalizationManager(localizationConfiguration, dbTranslateService, dbDynamicTextService);
AddTestData(container);
}
public void InitTest()
{
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "localization",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("en"),
new CultureInfo("cs"),
},
TranslateFallbackMode = LocTranslateFallbackMode.Key
};
m_builderOptions = new DbContextOptionsBuilder <StaticTextsContext>()
.UseInMemoryDatabase("DatabaseTranslateTest").Options;
var dbTranslateService = new DatabaseTranslateService(CreateStaticTextContext, localizationConfiguration);
var dbDynamicTextService =
new DatabaseDynamicTextService(CreateStaticTextContext, localizationConfiguration);
m_databaseLocalizationManager =
new DatabaseLocalizationManager(localizationConfiguration, dbTranslateService, dbDynamicTextService);
}
/**
* Serialize a LocalizationConfiguration
* @param _config instance to serialize
*/
public static string SerializeConfiguration(LocalizationConfiguration _config)
{
return Newtonsoft.Json.JsonConvert.SerializeObject(_config);
}
public void TreeTest()
{
var localizationConfiguration = new LocalizationConfiguration
{
BasePath = "LocalizationTree",
DefaultCulture = new CultureInfo("cs"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("en"),
new CultureInfo("en-US"),
new CultureInfo("en-GB"),
new CultureInfo("en-CA"),
new CultureInfo("es-MX"),
new CultureInfo("es-US"),
},
TranslateFallbackMode = LocTranslateFallbackMode.Key,
AutoLoadResources = true
};
var dictionaryManager = new FileDictionaryManager(
localizationConfiguration, JsonDictionaryFactory.FactoryInstance
);
var fallbackCultureResolver = new FallbackCultureResolver(localizationConfiguration);
var fileLocalizationManager = new FileLocalizationManager(
localizationConfiguration, dictionaryManager, fallbackCultureResolver
);
var s1 = fileLocalizationManager.Translate("text-1-odst", new CultureInfo("cs"));
Assert.AreEqual("global cs [text-1-odst]", s1);
var s2 = fileLocalizationManager.Translate("extra-cs-key", new CultureInfo("en-MX"));
Assert.AreEqual("extra string in CS culture", s2);
var s3 = fileLocalizationManager.Translate("extra-cs-key", new CultureInfo("es-MX"));
Assert.AreEqual("extra string in CS culture", s3);
const string nopeKey = "nope-key";
var sNope = fileLocalizationManager.Translate(nopeKey, new CultureInfo("es-MX"));
Assert.AreEqual(nopeKey, sNope);
localizationConfiguration.TranslateFallbackMode = LocTranslateFallbackMode.EmptyString;
var sNope2 = fileLocalizationManager.Translate(nopeKey, new CultureInfo("es-MX"));
Assert.AreEqual("", sNope2);
localizationConfiguration.TranslateFallbackMode = LocTranslateFallbackMode.Exception;
var exceptionThrown = false;
try
{
var sNope3 = fileLocalizationManager.Translate(nopeKey, new CultureInfo("es-MX"));
}
catch (TranslateException)
{
exceptionThrown = true;
}
Assert.IsTrue(exceptionThrown);
}
public DatabaseDictionaryManager(
LocalizationConfiguration configuration, IDatabaseDictionaryService dbDictionaryService, ILogger <DatabaseDictionaryManager> logger = null
) : base(configuration, logger)
{
m_dbDictionaryService = dbDictionaryService;
}
/// <summary>
/// Check for resource files base on folders structure in basePath.
/// </summary>
/// <param name="configuration">Library configuration.</param>
/// <param name="dictionaryFactory"></param>
/// <returns>List of resource files to load.</returns>
private IEnumerable <string> CheckResourceFiles(LocalizationConfiguration configuration, IDictionaryFactory dictionaryFactory)
{
var fs = new FolderScanner(dictionaryFactory);
return(fs.CheckResourceFiles(configuration));
}
protected override void Load(ContainerBuilder builder)
{
MvcAutoMapperConfiguration.Initialize();
builder.RegisterGeneric(typeof(RequestPreProcessorBehavior <,>))
.As(typeof(IPipelineBehavior <,>));
builder.RegisterGeneric(typeof(RequestPostProcessorBehavior <,>))
.As(typeof(IPipelineBehavior <,>));
builder.RegisterType <MenuConfigurationContext>()
.As <IMenuConfigurationContext>()
.InstancePerRequest();
builder.RegisterType <PermissionChecker>()
.As <IPermissionChecker>()
.InstancePerRequest();
ILocalizationConfiguration localization = new LocalizationConfiguration();
localization.Languages.Add(new LanguageInfo("en", "English", icon: "famfamfam-flag-england", isDefault: false));
localization.Languages.Add(new LanguageInfo("vi-VN", "Tiếng Việt", icon: "famfamfam-flag-vn", isDefault: true));
DictionaryBasedLocalizationSource localizationSource = new DictionaryBasedLocalizationSource(
"IdentityServer",
new JsonFileLocalizationDictionaryProvider(
HttpContext.Current.Server.MapPath("~/Localization/JsonSources")));
localization.Sources.Add(localizationSource);
builder.Register(c => localizationSource)
.As <ILocalizationSource>()
.SingleInstance();
builder.Register(c => localization)
.As <ILocalizationConfiguration>()
.SingleInstance();
builder.Register(c => new AbpWebLocalizationConfiguration())
.As <IAbpWebLocalizationConfiguration>()
.SingleInstance();
builder.Register(c => new CurrentCultureSetter())
.As <ICurrentCultureSetter>()
.SingleInstance();
builder.RegisterType <DefaultLanguageProvider>()
.As <ILanguageProvider>()
.SingleInstance();
builder.RegisterType <LanguageManager>()
.As <ILanguageManager>()
.SingleInstance();
builder.RegisterModule(new DTWebCommonModule(localization));
builder.Register(c => new LocalizationManager(c.Resolve <ILanguageManager>(),
c.Resolve <ILocalizationConfiguration>(), null))
.As <ILocalizationManager>()
.OnActivated(e => e.Instance.Initialize())
.SingleInstance();
builder.RegisterType <MenuManager>()
.As <IMenuManager>()
.InstancePerRequest();
builder.RegisterControllers(typeof(LocalizationController).Assembly);
base.Load(builder);
}
public AutoDictionaryManager(
IDictionaryManager fileDictionaryManager, IDictionaryManager databaseDictionaryManager, LocalizationConfiguration configuration,
ILogger <AutoDictionaryManager> logger = null
) : base(configuration, logger)
{
m_fileDictionaryManager = fileDictionaryManager;
m_databaseDictionaryManager = databaseDictionaryManager;
}
protected DatabaseServiceBase(ILogger logger, Func <IDatabaseStaticTextContext> dbContext, LocalizationConfiguration configuration)
{
m_logger = logger;
m_dbContextFunc = dbContext;
m_configuration = configuration;
}
public DatabaseDictionaryService(Func <IDatabaseStaticTextContext> dbContext, LocalizationConfiguration configuration)
: base(LogProvider.GetCurrentClassLogger(), dbContext, configuration)
{
//Should be empty.
}
private IEnumerable <string> CheckGlobalResourceFiles(LocalizationConfiguration libConfiguration)
{
IList <string> localizationFiles = new List <string>();
var exceptionLogStringBuilder = new StringBuilder();
var shouldThrowException = false;
var defaultCulture = libConfiguration.DefaultCulture;
var defaultCultureResourceFilePath = Path.Combine(libConfiguration.BasePath, defaultCulture.Name);
defaultCultureResourceFilePath = string.Concat(defaultCultureResourceFilePath, ".",
m_dictionaryFactory.FileExtension);
if (File.Exists(defaultCultureResourceFilePath))
{
localizationFiles.Add(defaultCultureResourceFilePath);
}
else
{
var message = string.Format(@"Cannot init library. Dictionary file ""{0}"" is missing.",
defaultCultureResourceFilePath);
if (m_logger != null && m_logger.IsErrorEnabled())
{
m_logger.LogError(message);
}
exceptionLogStringBuilder.AppendLine(message);
shouldThrowException = true;
}
foreach (var supportedCulture in libConfiguration.SupportedCultures)
{
var supportedFilePathWithoutExtension =
Path.Combine(libConfiguration.BasePath, supportedCulture.Name);
var supportedcultureFilePath = string.Concat(supportedFilePathWithoutExtension, ".",
m_dictionaryFactory.FileExtension);
if (File.Exists(supportedcultureFilePath))
{
localizationFiles.Add(supportedcultureFilePath);
}
else
{
var message = string.Format(@"Cannot init library. Dictionary file ""{0}"" is missing.",
supportedcultureFilePath);
if (m_logger != null && m_logger.IsErrorEnabled())
{
m_logger.LogError(message);
}
exceptionLogStringBuilder.AppendLine(message);
shouldThrowException = true;
}
}
if (shouldThrowException)
{
throw new DictionaryLoadException(string.Concat("Missing resource file/s.", '\n', exceptionLogStringBuilder.ToString()));
}
return(localizationFiles);
}
/// <summary>
/// Check for resource files base on folders structure in basePath.
/// </summary>
/// <param name="libConfiguration">Library configuration.</param>
public IList <string> CheckResourceFiles(LocalizationConfiguration libConfiguration)
{
return(CheckScopeResourceFiles(libConfiguration, ScanScopeDirectories(libConfiguration.BasePath))
.Union(CheckGlobalResourceFiles(libConfiguration)).ToList());
}
/// <summary>
/// Check for resource files in provided folders.
/// Each folder represents scope. Scopes can be nested "infinitely".
/// </summary>
/// <param name="libConfiguration">Library configuration.</param>
/// <param name="scopeDirectories">Array with all folders inside localization folder</param>
private IEnumerable <string> CheckScopeResourceFiles(LocalizationConfiguration libConfiguration, string[] scopeDirectories)
{
IList <string> localizationFiles = new List <string>();
var exceptionLogStringBuilder = new StringBuilder();
var shouldThrowException = false;
foreach (var scopeDirectory in scopeDirectories)
{
foreach (var supportedCulture in libConfiguration.SupportedCultures)
{
var currentPath = ConstructResourceFileName(libConfiguration, scopeDirectory, supportedCulture);
if (File.Exists(currentPath))
{
localizationFiles.Add(currentPath);
}
else
{
var message = string.Format(@"Cannot init library. Dictionary file ""{0}"" is missing.",
currentPath);
if (m_logger != null && m_logger.IsErrorEnabled())
{
m_logger.LogError(message);
}
exceptionLogStringBuilder.AppendLine(message);
shouldThrowException = true;
}
}
var defaultPath = ConstructResourceFileName(libConfiguration, scopeDirectory, libConfiguration.DefaultCulture);
if (File.Exists(defaultPath))
{
localizationFiles.Add(defaultPath);
}
else
{
var message = string.Format(@"Cannot init library. Dictionary file ""{0}"" is missing.",
defaultPath);
if (m_logger != null && m_logger.IsErrorEnabled())
{
m_logger.LogError(message);
}
exceptionLogStringBuilder.AppendLine(message);
shouldThrowException = true;
}
}
foreach (var supportedCulture in libConfiguration.SupportedCultures)
{
var globalPath = string.Concat(supportedCulture.Name, ".", m_dictionaryFactory.FileExtension);
globalPath = Path.Combine(libConfiguration.BasePath, globalPath);
if (File.Exists(globalPath))
{
localizationFiles.Add(globalPath);
}
else
{
var message = string.Format(@"Cannot init library. Dictionary file ""{0}"" is missing.", globalPath);
if (m_logger != null && m_logger.IsErrorEnabled())
{
m_logger.LogError(message);
}
exceptionLogStringBuilder.AppendLine(message);
shouldThrowException = true;
}
}
if (shouldThrowException)
{
throw new DictionaryLoadException(string.Concat("Missing resource file/s.", '\n', exceptionLogStringBuilder.ToString()));
}
return(localizationFiles);
}