private ResourceSyncStatistics CallSyncBundle(ResourceAssembly assembly, ResourceBundle bundle)
{
var bundles = new List<ResourceBundle>();
if (bundle != null)
bundles.Add(bundle);
return service.SyncBundles(assembly, bundles);
}
private ResourceSyncStatistics SyncBundleCallback(ResourceAssembly assembly, ResourceBundle bundle)
{
var bundles = new List<ResourceBundle>();
if (bundle != null)
bundles.Add(bundle);
return syncResourcesManager.SyncBundles(assembly, bundles);
}
public ResourceAssembly SyncTranslations(ResourceAssembly assembly, ResourceBundle bundle, List<ResourceTranslation> translations)
{
Project project = projectRepository.GetProjectByID(assembly.ProjectID);
if (project == null)
throw new ArgumentException("Project ID not found: {0}", assembly.ProjectID.ToString());
ResourceAssembly existingAssembly = assemblyRepository.FindAssemblyByName(assembly.ProjectID, assembly.FileName);
if (existingAssembly == null)
throw new ArgumentException("Assembly not found: {0}", assembly.FileName);
ResourceBundle existingBundle = bundleRepository.FindBundleWithResourcesAndTranslationsByName(assembly.ProjectID, existingAssembly.ID, bundle.Name);
if (existingBundle == null)
{
logger.Warn("Bundle not found: {0}", bundle.Name);
return null;
}
foreach (var translation in translations)
{
// also syncs resource translation status!
SyncTranslation(project, existingAssembly, existingBundle, translation);
}
new TranslationStatusUtil().CalcBundleTranslationStatusFromResources(existingBundle);
// Assembly status done by caller via CalculateAssemblyStatusFromBundles
return existingAssembly;
}
public void DeleteNonExistingBundles(ResourceAssembly ra, List<string> existingBundleNames)
{
var bundleList = bundleRepository.FindBundlesForAssembly(ra);
bundleList.RemoveAll(b => existingBundleNames.Contains(b.Name));
foreach (var remainingExistingBundle in bundleList)
MarkBundleDeleted(remainingExistingBundle);
}
public TranslationStatus GetWorstTranslationStatusForAssemblyFromBundles(ResourceAssembly ra)
{
var status = (from bundle in context.ResourceBundles
where bundle.ProjectID == ra.ProjectID
&& bundle.ResourceAssemblyID == ra.ID
&& bundle.WorstTranslationStatus >= 0
&& bundle.BundleSyncStatus != BundleSyncStatus.REMOVED
select (TranslationStatus?)bundle.WorstTranslationStatus).Min();
return status.HasValue ? status.Value : TranslationStatus.NO_NEED_TO_TRANSLATE;
}
public void CollectResourceAssembly()
{
assembly = new ResourceAssembly();
assembly.FileFormat = ".NET Assembly";
assembly.FileName = ass.GetName().Name;
assembly.ProjectID = 1; // TODO
logger.Info("Found assembly {0}", ass.FullName);
// nur Assembly
var stats = bundleSyncCallback(assembly, null);
AddStats(stats);
}
// TODO Import From Csv?
private TranslationSyncStatistics SyncTranslationsCallback(int projectID, string assemblyName, string bundleName, List<ResourceTranslation> translations)
{
var ra = new ResourceAssembly();
ra.ProjectID = projectID;
ra.FileName = assemblyName;
var rb = new ResourceBundle();
rb.ProjectID = projectID;
rb.Name = bundleName;
return syncTranslationsManager.SyncTranslations(ra, rb, translations);
}
public ResourceAssembly SyncResourceAssembly(ResourceAssembly template)
{
var existingAssembly = assemblyRepository.FindAssemblyByName(template.ProjectID, template.FileName);
if (existingAssembly == null)
{
existingAssembly = CreateNewAssembly(template);
}
else
{
existingAssembly.LastSyncDateTime = DateTime.UtcNow;
}
return existingAssembly;
}
private TranslationSyncStatistics SyncTranslationCallback(int projectID, string assemblyName, string bundleName, List<ResourceTranslation> translations)
{
logger.Info("Send {0} translations for asssembly {1}, bundle {2}",
translations.Count, assemblyName, bundleName);
var ra = new ResourceAssembly();
ra.ProjectID = projectID;
ra.FileName = assemblyName;
var rb = new ResourceBundle();
rb.ProjectID = projectID;
rb.Name = bundleName;
return service.SyncTranslations(ra, rb, translations);
}
public ResourceSyncStatistics SyncBundleDeletions(ResourceAssembly ra, List<string> existingBundleNames)
{
var context = new TinyTranslatorDbContext();
var task = new SyncResourcesTask(
new ResourceAssemblyRepository(context),
new ResourceBundleRepository(context),
new ResourceRepository(context),
new ResourceTranslationRepository(context)
);
var assembly = task.SyncResourceAssembly(ra);
task.DeleteNonExistingBundles(assembly, existingBundleNames);
context.SaveChanges();
task.CalculateAssemblyStatusFromBundles(assembly);
context.SaveChanges();
return task.Statistics;
}
public void SyncAllBundlesWithDeletions(ResourceAssembly existingAssembly, ICollection<ResourceBundle> newBundles)
{
var existingBundles = bundleRepository.FindBundlesForAssembly(existingAssembly);
foreach (var newBundle in newBundles)
{
var existingBundle = existingBundles.FirstOrDefault(b => b.Name == newBundle.Name);
if (existingBundle == null)
CreateNewBundle(existingAssembly, newBundle);
else
{
UpdateBundle(existingAssembly, existingBundle, newBundle);
existingBundles.Remove(existingBundle);
}
}
foreach (var remainingExistingBundle in existingBundles)
{
MarkBundleDeleted(remainingExistingBundle);
}
}
private ResourceSyncStatistics InnerSyncResourceAssembly(ResourceAssembly ra, ICollection<ResourceBundle> bundles, bool deleteBundles)
{
var context = new TinyTranslatorDbContext();
var task = new SyncResourcesTask(
new ResourceAssemblyRepository(context),
new ResourceBundleRepository(context),
new ResourceRepository(context),
new ResourceTranslationRepository(context)
);
var assembly = task.SyncResourceAssembly(ra);
if (deleteBundles)
task.SyncAllBundlesWithDeletions(assembly, bundles);
else
task.SyncSomeBundles(assembly, bundles);
context.SaveChanges();
task.CalculateAssemblyStatusFromBundles(assembly);
context.SaveChanges();
return task.Statistics;
}
public TranslationSyncStatistics SyncTranslations(ResourceAssembly assembly, ResourceBundle bundle, List<ResourceTranslation> translations)
{
var context = new TinyTranslatorDbContext();
var task = new SyncTranslationsTask(
new ProjectRepository(context),
new ResourceAssemblyRepository(context),
new ResourceBundleRepository(context),
new ResourceRepository(context),
new ResourceTranslationRepository(context)
);
var existingAssembly = task.SyncTranslations(assembly, bundle, translations);
context.SaveChanges();
if (existingAssembly != null)
{
task.CalculateAssemblyStatusFromBundles(existingAssembly);
context.SaveChanges();
}
return task.Statistics;
}
public ResourceSyncStatistics SyncBundles(ResourceAssembly ra, ICollection<ResourceBundle> bundles)
{
return InnerSyncResourceAssembly(ra, bundles, deleteBundles: false);
}
private ResourceSyncStatistics DeleteBundlesClassback(ResourceAssembly assembly, List<string> existingAssemblies)
{
return syncResourcesManager.SyncBundleDeletions(assembly, existingAssemblies);
}
public void AddAssembly(ResourceAssembly newAssembly)
{
context.ResourceAssemblies.Add(newAssembly);
}
public ResourceSyncStatistics SyncResourceAssembly(ResourceAssembly ra, ICollection<ResourceBundle> bundles)
{
return InnerSyncResourceAssembly(ra, bundles, true);
}
public List<ResourceBundle> FindBundlesForAssembly(ResourceAssembly ra)
{
var query = from rb in context.ResourceBundles where rb.ResourceAssemblyID == ra.ID select rb;
return query.ToList();
}
private void UpdateBundle(ResourceAssembly existingAssembly, ResourceBundle existingBundle, ResourceBundle newBundle)
{
bool haveChanges = UpdateResources(existingAssembly, existingBundle, newBundle.Resources);
if (haveChanges)
{
syncStatistics.UpdatedBundles++;
existingBundle.LastChangeDateTime = DateTime.UtcNow;
existingBundle.BundleSyncStatus = BundleSyncStatus.UPDATED;
new TranslationStatusUtil().CalcBundleTranslationStatusFromResources(existingBundle);
}
}
private ResourceSyncStatistics CallDeleteBundle(ResourceAssembly assembly, List<string> existingAssemblies)
{
return service.SyncBundleDeletions(assembly, existingAssemblies);
}
public void SyncSomeBundles(ResourceAssembly existingAssembly, ICollection<ResourceBundle> newBundles)
{
foreach (var newBundle in newBundles)
{
var existingBundle = bundleRepository.FindBundleByName(existingAssembly.ProjectID, existingAssembly.ID, newBundle.Name);
if (existingBundle == null)
CreateNewBundle(existingAssembly, newBundle);
else
UpdateBundle(existingAssembly, existingBundle, newBundle);
}
}
private ResourceAssembly CreateNewAssembly(ResourceAssembly template)
{
ResourceAssembly newAssembly = new ResourceAssembly();
newAssembly.CreateDateTime = DateTime.UtcNow;
newAssembly.LastSyncDateTime = DateTime.UtcNow;
newAssembly.FileFormat = template.FileFormat;
newAssembly.FileName = template.FileName;
newAssembly.ProjectID = template.ProjectID;
assemblyRepository.AddAssembly(newAssembly);
syncStatistics.AddedAssemblies++;
return newAssembly;
}
public TranslationSyncStatistics SyncTranslations(ResourceAssembly assembly, ResourceBundle bundle, List<ResourceTranslation> translations)
{
return syncTranslationsManager.SyncTranslations(assembly, bundle, translations);
}
private void CreateNewBundle(ResourceAssembly existingAssembly, ResourceBundle template)
{
var bundle = new ResourceBundle();
bundle.BundleSyncStatus = BundleSyncStatus.ADDED;
bundle.CreateDateTime = DateTime.UtcNow;
bundle.LastChangeDateTime = DateTime.UtcNow;
bundle.Name = template.Name;
bundle.ProjectID = existingAssembly.ProjectID;
bundle.ResourceAssembly = existingAssembly;
bundle.Resources = new List<Resource>();
bundleRepository.AddBundle(bundle);
foreach (var newResource in template.Resources)
CreateNewResource(existingAssembly, bundle, newResource);
// es gibt noch keine Translations für dieses Bundle
new TranslationStatusUtil().CalcBundleTranslationStatusFromResources(bundle);
syncStatistics.AddedBundles++;
}
private bool UpdateResources(ResourceAssembly existingAssembly, ResourceBundle existingBundle, ICollection<Resource> newResources)
{
bool changes = false;
var existingResources = resourceRepository.GetResourcesForBundle(existingBundle);
List<Resource> resourcesToDelete = new List<Resource>(existingResources);
foreach (var newResource in newResources)
{
var existingResource = existingResources.FirstOrDefault(r => r.Key == newResource.Key);
if (existingResource == null)
{
CreateNewResource(existingAssembly, existingBundle, newResource);
changes = true;
}
else
{
resourcesToDelete.Remove(existingResource);
if (HasResourceChanges(existingResource, newResource))
{
changes = true;
translationRepository.DeleteTranslationsForResource(existingResource);
ApplyChangesToResource(existingResource, newResource);
}
}
}
foreach (var resourceToDelete in resourcesToDelete)
{
changes = true;
MarkResourceDeleted(resourceToDelete);
}
return changes;
}
private void SyncTranslation(Project project, ResourceAssembly existingAssembly, ResourceBundle existingBundle, ResourceTranslation translation)
{
// try find resource
var existingResource = existingBundle.Resources.FirstOrDefault(r => r.Key == translation.Resource.Key);
if (existingResource == null)
{
Statistics.ResourceNotFound++;
return;
}
// compare resource
if (existingResource.ResourceClass != translation.Resource.ResourceClass)
{
Statistics.ResourceMismatch++;
return;
}
if (existingResource.StringValue == translation.StringValue &&
existingResource.BinaryValue.SequenceEqual(translation.BinaryValue))
{
Statistics.UnchangedResource++;
return;
}
// try find translation
var existingTranslation = existingResource.Translations.FirstOrDefault(t => t.Locale == translation.Locale);
if (existingTranslation != null &&
(existingTranslation.StringValue == translation.StringValue &&
existingTranslation.BinaryValue.SequenceEqual(translation.BinaryValue) ||
existingTranslation.TranslationStatus >= translation.TranslationStatus))
{
Statistics.ExistingTranslations++;
return;
}
// maybe delete old
if (existingTranslation != null)
translationRepository.DeleteTranslation(existingTranslation);
// add new translation
ResourceTranslation translationObj = CreateTranslation(existingAssembly, existingBundle, existingResource, translation);
translationRepository.AddTranslation(translationObj);
existingResource.Translations.Add(translationObj);
Statistics.AddedTranslations++;
// update resource translation status
new TranslationStatusUtil().CalcResourceTranslationStatusFromTranslations(project.Translations, existingResource);
}
public void CalculateAssemblyStatusFromBundles(ResourceAssembly assembly)
{
assembly.WorstTranslationStatus = bundleRepository.GetWorstTranslationStatusForAssemblyFromBundles(assembly);
}
private void CreateNewResource(ResourceAssembly existingAssembly, ResourceBundle existingBundle, Resource template)
{
Resource resource = new Resource();
resource.BinaryValue = template.BinaryValue;
resource.CreateDateTime = DateTime.UtcNow;
resource.DesignerSupportFlag = template.DesignerSupportFlag;
resource.Key = template.Key;
resource.LastChangeDateTime = DateTime.UtcNow;
resource.ProjectID = existingAssembly.ProjectID;
resource.ResourceBundle = existingBundle;
resource.ResourceClass = template.ResourceClass;
resource.ResourceSyncStatus = ResourceSyncStatus.ADDED;
resource.ResourceType = template.ResourceType;
resource.StringValue = template.StringValue;
resource.WorstTranslationStatus = resource.NeedsTranslation() ? TranslationStatus.NOT_TRANSLATED : TranslationStatus.NO_NEED_TO_TRANSLATE;
existingBundle.Resources.Add(resource);
resourceRepository.AddResource(resource);
syncStatistics.AddedResources++;
}
private ResourceTranslation CreateTranslation(ResourceAssembly existingAssembly, ResourceBundle existingBundle, Resource existingResource, ResourceTranslation template)
{
ResourceTranslation translation = new ResourceTranslation();
translation.BinaryValue = template.BinaryValue;
translation.Locale = template.Locale;
translation.ProjectID = existingAssembly.ProjectID;
translation.Resource = existingResource;
translation.ResourceAssemblyID = existingAssembly.ID;
translation.ResourceBundleID = existingBundle.ID;
translation.ResourceID = existingResource.ID;
translation.StringValue = template.StringValue;
translation.TranslationBy = template.TranslationBy;
translation.TranslationDateTime = template.TranslationDateTime;
translation.TranslationStatus = template.TranslationStatus;
return translation;
}
public ResourceSyncStatistics SyncResourceAssembly(ResourceAssembly ra, ICollection<ResourceBundle> bundles)
{
return syncResourcesManager.SyncResourceAssembly(ra, bundles);
}
