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;
}
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);
}
// 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 void CalcBundleTranslationStatusFromResources(ResourceBundle bundle)
{
TranslationStatus worstStatus = (TranslationStatus)int.MaxValue;
foreach (var resource in bundle.Resources)
if (resource.NeedsTranslation()
&& resource.WorstTranslationStatus >= 0
&& resource.WorstTranslationStatus < worstStatus)
worstStatus = resource.WorstTranslationStatus;
if (worstStatus == (TranslationStatus)int.MaxValue)
worstStatus = TranslationStatus.NO_NEED_TO_TRANSLATE;
bundle.WorstTranslationStatus = worstStatus;
}
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 void ExportTranslationsForBundle(ResourceBundle bundle, String locale, List<ResourceTranslation> translations)
{
String resourceName = bundle.Name + "." + locale + ".resources";
var writer = moduleBuilder.DefineResource(resourceName, "", ResourceAttributes.Public);
foreach (var translation in translations)
{
Debug.Assert(translation.Locale == locale);
Debug.Assert(bundle.ID == translation.ResourceBundleID);
if (translation.Resource.ResourceType == ResourceType.STRING || translation.Resource.ResourceType == ResourceType.STRING_ARRAY) //?
writer.AddResource(translation.Resource.Key, translation.StringValue);
else if (translation.Resource.ResourceType == ResourceType.IMAGE)
writer.AddResource(translation.Resource.Key, Image.FromStream(new MemoryStream(translation.BinaryValue)));
else
{
Object obj = ConvertToObject(translation.BinaryValue, translation.Resource.ResourceClass);
writer.AddResource(translation.Resource.Key, translation.BinaryValue);
}
}
}
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;
}
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 ResourceBundle CollectBundle(string resourceName)
{
Debug.Assert(resourceName.EndsWith(".resources"));
var bundle = new ResourceBundle();
bundle.CreateDateTime = DateTime.UtcNow;
bundle.LastChangeDateTime = DateTime.UtcNow;
bundle.Name = resourceName.Substring(0, resourceName.Length - ".resources".Length); // strip ".resources"
bundle.Resources = new List<Resource>();
CollectResourcesForBundle(resourceName, bundle);
return bundle;
}
private void CollectResourcesForBundle(string resourceName, ResourceBundle bundle)
{
var stream = ass.GetManifestResourceStream(resourceName);
var reader = new ResourceReader(stream);
IDictionaryEnumerator dict = reader.GetEnumerator();
while (dict.MoveNext())
CollectResourcesFromResource(resourceName, dict, bundle, reader);
}
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;
}
public TranslationSyncStatistics SyncTranslations(ResourceAssembly assembly, ResourceBundle bundle, List<ResourceTranslation> translations)
{
return syncTranslationsManager.SyncTranslations(assembly, bundle, translations);
}
private void CollectResourcesFromArray(string resourceName, IDictionaryEnumerator dict, ResourceBundle bundle)
{
String[] strings = (String[])dict.Value;
for (int i = 0; i < strings.Length; i++)
{
var resource = new Resource();
resource.Key = dict.Key.ToString() + "[" + i + "]";
resource.StringValue = strings[i];
resource.CreateDateTime = DateTime.UtcNow;
resource.LastChangeDateTime = DateTime.UtcNow;
resource.ResourceClass = "ResourceTypeCode.String";
resource.BinaryValue = Encoding.UTF8.GetBytes(strings[i]);
resource.ResourceType = ResourceType.STRING_ARRAY;
bundle.Resources.Add(resource);
}
}
public void AddBundle(ResourceBundle bundle)
{
context.ResourceBundles.Add(bundle);
}
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 void CollectSingleResource(string resourceName, IDictionaryEnumerator dict, ResourceBundle bundle, ResourceReader reader, Object dictValue)
{
var resource = new Resource();
resource.Key = dict.Key.ToString();
resource.CreateDateTime = DateTime.UtcNow;
resource.LastChangeDateTime = DateTime.UtcNow;
resource.DesignerSupportFlag = resource.Key.StartsWith(">>");
String type;
byte[] data;
reader.GetResourceData(dict.Key.ToString(), out type, out data);
resource.ResourceClass = type;
resource.BinaryValue = data;
bundle.Resources.Add(resource);
resource.StringValue = dictValue != null ? dictValue.ToString() : null;
if (dictValue is String)
resource.ResourceType = ResourceType.STRING;
else if (dictValue is Bitmap)
resource.ResourceType = ResourceType.IMAGE;
else
resource.ResourceType = ResourceType.OTHER_BINARY;
}
private void CollectResourcesFromResource(string resourceName, IDictionaryEnumerator dict, ResourceBundle bundle, ResourceReader reader)
{
Object dictValue = null;
try
{
dictValue = dict.Value;
}
catch (Exception)
{
// wenn eine Assembly wie MeonaKernel gebraucht wird, um dict.Value aufzulösen
}
CollectSingleResource(resourceName, dict, bundle, reader, dictValue);
if (dictValue is String[] && dict.Key.ToString().StartsWith(">>"))
CollectResourcesFromArray(resourceName, dict, bundle);
}
private void MarkBundleDeleted(ResourceBundle bundle)
{
if (bundle.BundleSyncStatus != BundleSyncStatus.REMOVED)
{
syncStatistics.RemovedBundles++;
bundle.BundleSyncStatus = BundleSyncStatus.REMOVED;
bundle.LastChangeDateTime = DateTime.UtcNow;
MarkResourcesDeletedForBundle(bundle);
}
}
private void MarkResourcesDeletedForBundle(ResourceBundle bundle)
{
var resources = resourceRepository.GetResourcesForBundle(bundle);
foreach (var resource in resources)
MarkResourceDeleted(resource);
}
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);
}
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 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 List<Resource> GetResourcesForBundle(ResourceBundle bundle)
{
return (from res in context.Resources where res.ResourceBundleID == bundle.ID select res).ToList();
}
