public void Import(MigrationToolSettings settings)
{
var sourceImportFilePath = Path.Combine(settings.SourceDirectory, "localization-resource-translations.sql");
if (!File.Exists(sourceImportFilePath))
{
throw new IOException($"Source file '{sourceImportFilePath}' for import not found!");
}
// create DB structures in target database
using (var db = new LanguageEntities(settings.ConnectionString))
{
var resource = db.LocalizationResources.Where(r => r.Id == 0);
}
var fileInfo = new FileInfo(sourceImportFilePath);
var script = fileInfo.OpenText().ReadToEnd();
using (var connection = new SqlConnection(settings.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand(script, connection))
{
command.ExecuteNonQuery();
}
}
}
private static void InitializeDatabaseStructures(string connectionString)
{
using (var ctx = new LanguageEntities(connectionString))
{
var tmp = ctx.LocalizationResources.FirstOrDefault();
}
}
private void RegisterIfNotExist(LanguageEntities db, string resourceKey, string resourceValue, string defaultCulture, string author = "type-scanner")
{
var existingResource = db.LocalizationResources.Include(r => r.Translations).FirstOrDefault(r => r.ResourceKey == resourceKey);
if (existingResource != null)
{
existingResource.FromCode = true;
// if resource is not modified - we can sync default value from code
if (existingResource.IsModified.HasValue && !existingResource.IsModified.Value)
{
existingResource.ModificationDate = DateTime.UtcNow;
var defaultTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == defaultCulture);
if (defaultTranslation != null)
{
defaultTranslation.Value = resourceValue;
}
}
var fromCodeTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == ConfigurationContext.CultureForTranslationsFromCode);
if (fromCodeTranslation != null)
{
fromCodeTranslation.Value = resourceValue;
}
else
{
fromCodeTranslation = new LocalizationResourceTranslation
{
Language = ConfigurationContext.CultureForTranslationsFromCode,
Value = resourceValue
};
existingResource.Translations.Add(fromCodeTranslation);
}
}
else
{
// create new resource
var resource = new LocalizationResource(resourceKey)
{
ModificationDate = DateTime.UtcNow,
Author = author,
FromCode = true,
IsModified = false
};
resource.Translations.Add(new LocalizationResourceTranslation
{
Language = defaultCulture,
Value = resourceValue
});
resource.Translations.Add(new LocalizationResourceTranslation
{
Language = ConfigurationContext.CultureForTranslationsFromCode,
Value = resourceValue
});
db.LocalizationResources.Add(resource);
}
}
public void Execute(Command command)
{
if (string.IsNullOrEmpty(command.Key))
{
throw new ArgumentNullException(nameof(command.Key));
}
using (var db = new LanguageEntities())
{
var existingResource = db.LocalizationResources.FirstOrDefault(r => r.ResourceKey == command.Key);
if (existingResource == null)
{
return;
}
if (existingResource.FromCode)
{
throw new InvalidOperationException($"Cannot delete resource `{command.Key}` that is synced with code");
}
db.LocalizationResources.Remove(existingResource);
db.SaveChanges();
}
ConfigurationContext.Current.CacheManager.Remove(CacheKeyHelper.BuildKey(command.Key));
}
public void Execute(Command command)
{
if (string.IsNullOrEmpty(command.Key))
{
throw new ArgumentNullException(nameof(command.Key));
}
using (var db = new LanguageEntities())
{
var existingResource = db.LocalizationResources.FirstOrDefault(r => r.ResourceKey == command.Key);
if (existingResource != null)
{
throw new InvalidOperationException($"Resource with key `{command.Key}` already exists");
}
db.LocalizationResources.Add(new LocalizationResource(command.Key)
{
ModificationDate = DateTime.UtcNow,
FromCode = command.FromCode,
IsModified = false,
Author = command.UserName
});
db.SaveChanges();
}
}
public IEnumerable <LocalizationResource> Execute(GetAllResources.Query query)
{
using (var db = new LanguageEntities())
{
return(db.LocalizationResources.Include(r => r.Translations).ToList());
}
}
public void Import(MigrationToolOptions settings)
{
var sourceImportFilePath = Path.Combine(settings.SourceDirectory, "localization-resource-translations.sql");
if (!File.Exists(sourceImportFilePath))
{
throw new IOException($"Source file '{sourceImportFilePath}' for import not found!");
}
// create DB structures in target database
using (var db = new LanguageEntities(settings.ConnectionString))
{
var resource = db.LocalizationResources.Where(r => r.Id == 0);
}
var fileInfo = new FileInfo(sourceImportFilePath);
var script = fileInfo.OpenText().ReadToEnd();
using (var connection = new SqlConnection(settings.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand(script, connection))
{
command.ExecuteNonQuery();
}
}
}
public void DiscoverAndRegister()
{
if (!ConfigurationContext.Current.DiscoverAndRegisterResources)
{
return;
}
var discoveredTypes = TypeDiscoveryHelper.GetTypes(t => t.GetCustomAttribute <LocalizedResourceAttribute>() != null,
t => t.GetCustomAttribute <LocalizedModelAttribute>() != null);
var discoveredResources = discoveredTypes[0];
var foreignResources = ConfigurationContext.Current.ForeignResources;
if (foreignResources != null && foreignResources.Any())
{
discoveredResources.AddRange(foreignResources.Select(x => x.ResourceType));
}
// initialize db structures first (issue #53)
using (var ctx = new LanguageEntities())
{
var tmp = ctx.LocalizationResources.FirstOrDefault();
}
ResetSyncStatus();
Parallel.Invoke(() => RegisterDiscoveredResources(discoveredResources),
() => RegisterDiscoveredResources(discoveredTypes[1]));
if (ConfigurationContext.Current.PopulateCacheOnStartup)
{
PopulateCache();
}
}
public void Execute(RemoveTranslation.Command command)
{
using (var db = new LanguageEntities())
{
var resource = db.LocalizationResources.Include(r => r.Translations).FirstOrDefault(r => r.ResourceKey == command.Key);
if (resource == null)
{
return;
}
if (!resource.IsModified.HasValue || !resource.IsModified.Value)
{
throw new InvalidOperationException($"Cannot delete translation for unmodified resource `{command.Key}`");
}
var t = resource.Translations.FirstOrDefault(_ => _.Language == command.Language.Name);
if (t != null)
{
db.LocalizationResourceTranslations.Remove(t);
db.SaveChanges();
}
}
ConfigurationContext.Current.CacheManager.Remove(CacheKeyHelper.BuildKey(command.Key));
}
internal ICollection <LocalizationResource> Extract(MigrationToolSettings settings)
{
if (settings.ExportFromDatabase)
{
using (var db = new LanguageEntities(settings.ConnectionString))
{
return(db.LocalizationResources.Include(r => r.Translations).ToList());
}
}
// test few default conventions (lazy enough to read from EPiServer Framework configuration file)
string resourceFilesSourceDir;
if (!string.IsNullOrEmpty(settings.ResourceDirectory))
{
resourceFilesSourceDir = Path.Combine(settings.SourceDirectory, settings.ResourceDirectory);
}
else
{
resourceFilesSourceDir = Path.Combine(settings.SourceDirectory, "Resources\\LanguageFiles");
if (!Directory.Exists(resourceFilesSourceDir))
{
resourceFilesSourceDir = Path.Combine(settings.SourceDirectory, "lang");
}
}
if (!Directory.Exists(resourceFilesSourceDir))
{
throw new IOException($"Default resource directory '{resourceFilesSourceDir}' does not exist or can't be found. Use `-resourceDir` argument");
}
var resourceFiles = Directory.GetFiles(resourceFilesSourceDir, "*.xml");
if (!resourceFiles.Any())
{
Console.WriteLine($"No resource files found in '{resourceFilesSourceDir}'");
}
var fileProcessor = new ResourceFileProcessor();
var resources = fileProcessor.ParseFiles(resourceFiles);
// initialize DB - to generate data structures
try
{
using (var db = new LanguageEntities(settings.ConnectionString))
{
var resource = db.LocalizationResources.Where(r => r.Id == 0);
}
}
catch
{
// it's OK to have exception here
}
return(resources);
}
private void RegisterDiscoveredModels(LanguageEntities db, IEnumerable <Type> types)
{
var properties = types.SelectMany(type => TypeDiscoveryHelper.GetAllProperties(type, contextAwareScanning: false));
foreach (var property in properties)
{
RegisterIfNotExist(db, property.Key, property.Translation);
db.SaveChanges();
}
}
private void RegisterDiscoveredResources(LanguageEntities db, IEnumerable <Type> types)
{
var properties = types.SelectMany(type => TypeDiscoveryHelper.GetAllProperties(type));
foreach (var property in properties)
{
RegisterIfNotExist(db, property.Key, property.Translation);
}
db.SaveChanges();
}
internal ICollection<LocalizationResource> Extract(MigrationToolSettings settings)
{
if (settings.ExportFromDatabase)
{
using (var db = new LanguageEntities(settings.ConnectionString))
{
return db.LocalizationResources.Include(r => r.Translations).ToList();
}
}
// test few default conventions (lazy enough to read from EPiServer Framework configuration file)
string resourceFilesSourceDir;
if (!string.IsNullOrEmpty(settings.ResourceDirectory))
{
resourceFilesSourceDir = Path.Combine(settings.SourceDirectory, settings.ResourceDirectory);
}
else
{
resourceFilesSourceDir = Path.Combine(settings.SourceDirectory, "Resources\\LanguageFiles");
if (!Directory.Exists(resourceFilesSourceDir))
{
resourceFilesSourceDir = Path.Combine(settings.SourceDirectory, "lang");
}
}
if (!Directory.Exists(resourceFilesSourceDir))
{
throw new IOException($"Default resource directory '{resourceFilesSourceDir}' does not exist or can't be found. Use `-resourceDir` argument");
}
var resourceFiles = Directory.GetFiles(resourceFilesSourceDir, "*.xml");
if (!resourceFiles.Any())
{
Console.WriteLine($"No resource files found in '{resourceFilesSourceDir}'");
}
var fileProcessor = new ResourceFileProcessor();
var resources = fileProcessor.ParseFiles(resourceFiles);
// initialize DB - to generate data structures
try
{
using (var db = new LanguageEntities(settings.ConnectionString))
{
var resource = db.LocalizationResources.Where(r => r.Id == 0);
}
}
catch
{
// it's OK to have exception here
}
return resources;
}
public LocalizationResource Execute(GetResource.Query query)
{
using (var db = new LanguageEntities(ConnectionStringHelper.ConnectionString))
{
var resource = db.LocalizationResources
.Include(r => r.Translations)
.FirstOrDefault(r => r.ResourceKey == query.ResourceKey);
return(resource);
}
}
private static LocalizationResource GetResourceFromDb(string key)
{
using (var db = new LanguageEntities())
{
var resource = db.LocalizationResources
.Include(r => r.Translations)
.FirstOrDefault(r => r.ResourceKey == key);
return(resource);
}
}
public void RegisterManually(IEnumerable<ManualResource> resources)
{
using (var db = new LanguageEntities())
{
foreach (var resource in resources)
{
RegisterIfNotExist(db, resource.Key, resource.Translation, author: "manual");
}
db.SaveChanges();
}
}
private void RegisterDiscoveredResources(IEnumerable<Type> types)
{
var helper = new TypeDiscoveryHelper();
var properties = types.SelectMany(type => helper.ScanResources(type)).DistinctBy(r => r.Key);
using (var db = new LanguageEntities())
{
foreach (var property in properties)
RegisterIfNotExist(db, property.Key, property.Translation);
db.SaveChanges();
}
}
private IEnumerable <CultureInfo> GetAvailableLanguages()
{
using (var db = new LanguageEntities())
{
var availableLanguages = db.LocalizationResourceTranslations
.Select(t => t.Language)
.Distinct()
.ToList()
.Select(l => new CultureInfo(l)).ToList();
return(availableLanguages);
}
}
public void RegisterManually(IEnumerable <ManualResource> resources)
{
using (var db = new LanguageEntities())
{
var defaultCulture = DetermineDefaultCulture();
foreach (var resource in resources)
{
RegisterIfNotExist(db, resource.Key, resource.Translation, defaultCulture, "manual");
}
db.SaveChanges();
}
}
private void RegisterManuallySingle(IEnumerable <ManualResource> resources, string connectionString)
{
using (var db = new LanguageEntities(connectionString))
{
var defaultCulture = new DetermineDefaultCulture.Query().Execute();
foreach (var resource in resources)
{
RegisterIfNotExist(db, resource.Key, resource.Translation, defaultCulture, "manual");
}
db.SaveChanges();
}
}
private IEnumerable <CultureInfo> GetAvailableLanguages(bool includeInvariant)
{
using (var db = new LanguageEntities())
{
var availableLanguages = db.LocalizationResourceTranslations
.Select(t => t.Language)
.Distinct()
.Where(l => includeInvariant || l != CultureInfo.InvariantCulture.Name)
.ToList()
.Select(l => new CultureInfo(l)).ToList();
return(availableLanguages);
}
}
private void InitializeDb(MigrationToolOptions settings)
{
// initialize DB - to generate data structures
{
try
{
using (var db = new LanguageEntities(settings.ConnectionString))
{
var resource = db.LocalizationResources.Where(r => r.Id == 0);
}
}
catch
{
// it's OK to have exception here
}
}
}
internal ICollection <LocalizationResource> Extract(MigrationToolOptions settings)
{
ICollection <LocalizationResource> resources = new List <LocalizationResource>();
if (settings.ExportFromXmlOnly)
{
resources = GetXmlResources(settings);
}
if (settings.ExportFromDatabase)
{
using (var db = new LanguageEntities(settings.ConnectionString))
{
resources = db.LocalizationResources.Include(r => r.Translations).ToList();
}
InitializeDb(settings);
}
return(resources);
}
public void DiscoverAndRegister()
{
if (!ConfigurationContext.Current.DiscoverAndRegisterResources)
{
return;
}
var discoveredTypes = TypeDiscoveryHelper.GetTypes(t => t.GetCustomAttribute <LocalizedResourceAttribute>() != null,
t => t.GetCustomAttribute <LocalizedModelAttribute>() != null);
using (var db = new LanguageEntities())
{
ResetSyncStatus(db);
RegisterDiscoveredResources(db, discoveredTypes[0]);
RegisterDiscoveredModels(db, discoveredTypes[1]);
}
if (ConfigurationContext.Current.PopulateCacheOnStartup)
{
PopulateCache();
}
}
public void Execute(Command command)
{
using (var db = new LanguageEntities())
{
var resource = db.LocalizationResources.Include(r => r.Translations).FirstOrDefault(r => r.ResourceKey == command.Key);
if (resource == null)
{
// TODO: return some status response obj
return;
}
var translation = resource.Translations.FirstOrDefault(t => t.Language == command.Language.Name);
if (translation != null)
{
// update existing translation
translation.Value = command.Translation;
}
else
{
var newTranslation = new LocalizationResourceTranslation
{
Value = command.Translation,
Language = command.Language.Name,
ResourceId = resource.Id
};
db.LocalizationResourceTranslations.Add(newTranslation);
}
resource.ModificationDate = DateTime.UtcNow;
resource.IsModified = true;
db.SaveChanges();
}
ConfigurationContext.Current.CacheManager.Remove(CacheKeyHelper.BuildKey(command.Key));
}
private void RegisterIfNotExist(LanguageEntities db, string resourceKey, string resourceValue, string author = "type-scanner")
{
var existingResource = db.LocalizationResources.Include(r => r.Translations).FirstOrDefault(r => r.ResourceKey == resourceKey);
var defaultTranslationCulture = DetermineDefaultCulture();
if(existingResource != null)
{
existingResource.FromCode = true;
// if resource is not modified - we can sync default value from code
if(existingResource.IsModified.HasValue && !existingResource.IsModified.Value)
{
var defaultTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == defaultTranslationCulture);
if(defaultTranslation != null)
{
defaultTranslation.Value = resourceValue;
}
}
var fromCodeTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == ConfigurationContext.CultureForTranslationsFromCode);
if(fromCodeTranslation != null)
{
fromCodeTranslation.Value = resourceValue;
}
else
{
fromCodeTranslation = new LocalizationResourceTranslation
{
Language = ConfigurationContext.CultureForTranslationsFromCode,
Value = resourceValue
};
existingResource.Translations.Add(fromCodeTranslation);
}
existingResource.ModificationDate = DateTime.UtcNow;
}
else
{
// create new resource
var resource = new LocalizationResource(resourceKey)
{
ModificationDate = DateTime.UtcNow,
Author = author,
FromCode = true,
IsModified = false
};
resource.Translations.Add(new LocalizationResourceTranslation
{
Language = defaultTranslationCulture,
Value = resourceValue
});
resource.Translations.Add(new LocalizationResourceTranslation
{
Language = ConfigurationContext.CultureForTranslationsFromCode,
Value = resourceValue
});
db.LocalizationResources.Add(resource);
}
}
public object Import(IEnumerable<LocalizationResource> newResources, bool importOnlyNewContent)
{
var count = 0;
using (var db = new LanguageEntities())
{
// if we are overwriting old content - we need to get rid of it first
if (!importOnlyNewContent)
{
var existingResources = db.Set<LocalizationResource>();
db.LocalizationResources.RemoveRange(existingResources);
db.SaveChanges();
}
foreach (var localizationResource in newResources)
{
if (importOnlyNewContent)
{
// look for existing resource
var existingResource = db.LocalizationResources
.Include(r => r.Translations)
.FirstOrDefault(r => r.ResourceKey == localizationResource.ResourceKey);
if (existingResource == null)
{
// resource with this key does not exist - so we can just add it
AddNewResource(db, localizationResource);
count++;
}
else
{
// there is a resource with this key - looking for missing translations
foreach (var translation in localizationResource.Translations)
{
var existingTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == translation.Language);
if (existingTranslation == null)
{
// there is no translation in that language - adding one
// but before adding that - we need to fix its reference to resource (exported file might have different id)
translation.ResourceId = existingResource.Id;
db.LocalizationResourceTranslations.Add(translation);
}
else if (string.IsNullOrEmpty(existingTranslation.Value))
{
// we can check - if content of the translation is empty - for us - it's the same as translation would not exist
existingTranslation.Value = translation.Value;
}
}
}
}
else
{
// don't care about state in DB
// if we are importing all resources once again - all will be gone anyway
AddNewResource(db, localizationResource);
count++;
}
}
db.SaveChanges();
var c = new ClearCache.Command();
c.Execute();
}
return $"Import successful. Imported {count} resources";
}
private static void AddNewResource(LanguageEntities db, LocalizationResource localizationResource)
{
db.LocalizationResources.Add(localizationResource);
db.LocalizationResourceTranslations.AddRange(localizationResource.Translations);
}
private static void AddNewResource(LanguageEntities db, LocalizationResource localizationResource)
{
db.LocalizationResources.Add(localizationResource);
}
public IEnumerable <string> ImportChanges(ICollection <DetectedImportChange> changes)
{
var result = new List <string>();
var inserts = 0;
var updates = 0;
var deletes = 0;
using (var db = new LanguageEntities())
{
// process deletes
foreach (var delete in changes.Where(c => c.ChangeType == ChangeType.Delete))
{
var existingResource = db.LocalizationResources.FirstOrDefault(r => r.ResourceKey == delete.ExistingResource.ResourceKey);
if (existingResource != null)
{
db.LocalizationResources.Remove(existingResource);
}
}
// process inserts
foreach (var insert in changes.Where(c => c.ChangeType == ChangeType.Insert))
{
// fix incoming incomplete resource from web
insert.ImportingResource.ModificationDate = DateTime.UtcNow;
insert.ImportingResource.Author = "import";
insert.ImportingResource.IsModified = false;
// fix incoming resource translation invariant language (if any)
insert.ImportingResource.Translations.ForEach(t => t.Language = t.Language ?? "");
AddNewResource(db, insert.ImportingResource);
inserts++;
}
// process updates
foreach (var update in changes.Where(c => c.ChangeType == ChangeType.Update))
{
// look for existing resource
var existingResource = db.LocalizationResources
.Include(r => r.Translations)
.FirstOrDefault(r => r.ResourceKey == update.ImportingResource.ResourceKey);
if (existingResource == null)
{
// resource with this key does not exist - so we can just add it
update.ImportingResource.ModificationDate = DateTime.UtcNow;
update.ImportingResource.Author = "import";
update.ImportingResource.IsModified = false;
AddNewResource(db, update.ImportingResource);
inserts++;
continue;
}
foreach (var translation in update.ImportingResource.Translations.Where(_ => _.Value != null))
{
var existingTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == translation.Language);
if (existingTranslation == null)
{
// there is no translation in that language - adding one
// but before adding that - we need to fix its reference to resource (exported file might have different id)
translation.ResourceId = existingResource.Id;
db.LocalizationResourceTranslations.Add(translation);
}
else
{
existingTranslation.Value = translation.Value;
}
}
updates++;
}
db.SaveChanges();
var clearCommand = new ClearCache.Command();
clearCommand.Execute();
}
if (inserts > 0)
{
result.Add($"Inserted {inserts} resources.");
}
if (updates > 0)
{
result.Add($"Updated {updates} resources.");
}
if (deletes > 0)
{
result.Add($"Deleted {deletes} resources.");
}
return(result);
}
private static void AddNewResource(LanguageEntities db, LocalizationResource localizationResource)
{
db.LocalizationResources.Add(localizationResource);
db.LocalizationResourceTranslations.AddRange(localizationResource.Translations);
}
public object Import(IEnumerable <LocalizationResource> newResources, bool importOnlyNewContent)
{
var count = 0;
using (var db = new LanguageEntities())
{
// if we are overwriting old content - we need to get rid of it first
if (!importOnlyNewContent)
{
var existingResources = db.Set <LocalizationResource>();
db.LocalizationResources.RemoveRange(existingResources);
db.SaveChanges();
}
foreach (var localizationResource in newResources)
{
if (importOnlyNewContent)
{
// look for existing resource
var existingResource = db.LocalizationResources
.Include(r => r.Translations)
.FirstOrDefault(r => r.ResourceKey == localizationResource.ResourceKey);
if (existingResource == null)
{
// resource with this key does not exist - so we can just add it
AddNewResource(db, localizationResource);
count++;
}
else
{
// there is a resource with this key - looking for missing translations
foreach (var translation in localizationResource.Translations)
{
var existingTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == translation.Language);
if (existingTranslation == null)
{
// there is no translation in that language - adding one
// but before adding that - we need to fix its reference to resource (exported file might have different id)
translation.ResourceId = existingResource.Id;
db.LocalizationResourceTranslations.Add(translation);
}
else if (string.IsNullOrEmpty(existingTranslation.Value))
{
// we can check - if content of the translation is empty - for us - it's the same as translation would not exist
existingTranslation.Value = translation.Value;
}
}
}
}
else
{
// don't care about state in DB
// if we are importing all resources once again - all will be gone anyway
AddNewResource(db, localizationResource);
count++;
}
}
db.SaveChanges();
var c = new ClearCache.Command();
c.Execute();
}
return($"Import successful. Imported {count} resources");
}
