private async void OpenCommandBinding_Executed(object sender, ExecutedRoutedEventArgs e)
{
try
{
pioClient = new PIOServiceClient(new BasicHttpBinding(), new EndpointAddress($@"http://127.0.0.1:8733/PIO/Service/"));
pioClient.Open();
botsClient = new BotsRESTClient($@"http://127.0.0.1:8734", new HttpConnector(), new ResponseDeserializer());
taskCallbackClient = new TaskCallbackServiceClient(new InstanceContext(this), new WSDualHttpBinding(), new EndpointAddress($@"http://localhost:8735/PIO/TaskCallback/Service"));
taskCallbackClient.Open();
taskCallbackClient.Subscribe();
isConnected = true;
}
catch (Exception ex)
{
ShowError(ex);
}
translationModule = new TranslationModule(NullLogger.Instance, pioClient);
ApplicationViewModel = new ApplicationViewModel(pioClient, botsClient, translationModule);
DataContext = ApplicationViewModel;
await translationModule.LoadAsync("FR");
await ApplicationViewModel.LoadAsync();
}
private void CloseCommandBinding_Executed(object sender, ExecutedRoutedEventArgs e)
{
try
{
taskCallbackClient?.Unsubscribe();
taskCallbackClient?.Close();
}
catch { }
try
{
pioClient?.Close();
}
catch { }
/*try
* {
* botsClient?.Close();
* }
* catch { }*/
DataContext = null;
ApplicationViewModel = null;
translationModule = null;
pioClient = null; botsClient = null;
isConnected = false;
}
public static void ToTMX(TranslationModule tp, string targetDir)
{
var tmx = new tmx();
var tus = new List <tu>();
foreach (var key in tp.ByKey)
{
var tu = new tu();
tu.tuid = key.Key;
var tuvs = new List <tuv>();
//tuvs.Add(new tuv() { lang = tp.masterLanguage.ToUpper(), lang1 = tp.masterLanguage.ToUpper(), seg = new seg() { Text = new string[] { kvp.Value } } });
/*
* foreach (var l in tp.Languages)
* {
* if (tp.Dicts.ContainsKey(l) && tp.Dicts[l].ContainsKey(key))
* tuvs.Add(new tuv() { lang = l.ToUpper(), lang1 = l.ToUpper(), seg = new seg() { Text = new string[] { tp.Dicts[l][key] } } });
* }
*/
foreach (var seg in key)
{
tuvs.Add(new tuv()
{
lang = seg.Language.ToUpper(), lang1 = seg.Language.ToUpper(), seg = new seg()
{
Text = new string[] { seg.Text }
}
});
}
tu.tuv = tuvs.ToArray();
tus.Add(tu);
}
tmx.body = tus.ToArray();
tmx.header = new header()
{
srclang = "*all*", creationtool = "iLuccaTranslationTool", segtype = headerSegtype.phrase
};
var extraTypes = new Type[] { typeof(tu), typeof(tuv), typeof(seg) };
XmlSerializer xs = new XmlSerializer(typeof(tmx), null, extraTypes, new XmlRootAttribute("tmx"), null);
//specify encoding to add BOM
using (var sw = new StreamWriter(targetDir + @"\" + tp.Name + ".tmx", false, new UTF8Encoding(false)))
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = false;
settings.NewLineHandling = NewLineHandling.None;
//xs.Serialize(sw, tmx);
using (XmlWriter writer = XmlWriter.Create(sw, settings))
{
xs.Serialize(writer, tmx);
//_serializer.Serialize(o, writer);
}
}
}
protected TranslationModule FromWorksheet(string project, WorksheetEntry worksheet)
{
// Define the URL to request the list feed of the worksheet.
AtomLink listFeedLink = worksheet.Links.FindService(GDataSpreadsheetsNameTable.ListRel, null);
// Fetch the list feed of the worksheet.
ListQuery listQuery = new ListQuery(listFeedLink.HRef.ToString());
ListFeed listFeed = this.Service.Query(listQuery);
Console.WriteLine("Results {0}", listFeed.Entries.Count);
List <string> languages = new List <string>();
var dicts = new Dictionary <string, Dictionary <string, string> >();
var comments = new Dictionary <string, string>();
//language information is in first row
var firstRow = (ListEntry)listFeed.Entries[0];
for (int column = 1; column < firstRow.Elements.Count; column++)
{
var lang = firstRow.Elements[column].LocalName;
languages.Add(lang);
dicts.Add(lang, new Dictionary <string, string>());
}
var tp = new TranslationModule(project, "en", languages.ToArray());
for (int rowIdx = 1; rowIdx < listFeed.Entries.Count; rowIdx++)
{
ListEntry row = (ListEntry)listFeed.Entries[rowIdx];
string comment = null;
string key = row.Elements[0].Value; // first column is the key
// Update the row's data.
for (int column = 1; column < row.Elements.Count; column++)
{
var element = row.Elements[column];
//in list based feeds localname always correponds to first row
if (element.LocalName.ToLower() == "comment")
{
comment = element.Value;
}
else
{
tp.Add(new Segment(element.LocalName, key, element.Value));
}
}
foreach (var seg in tp.ByKey[key])
{
seg.Comment = comment;
}
}
return(tp);
}
public static Stream ToXLSX2(TranslationModule project)
{
MemoryStream xlsStream = new MemoryStream();
var worksheet = new MemoryWorksheet();
Export.ToIWorksheet(project, worksheet);
using (SpreadsheetDocument myDoc = SpreadsheetDocument.Create(xlsStream, SpreadsheetDocumentType.Workbook))
{
WorkbookPart workbookPart = myDoc.AddWorkbookPart();
workbookPart.Workbook = new Workbook();
WorksheetPart worksheetPart = workbookPart.AddNewPart <WorksheetPart>();
SheetData sheetData = new SheetData();
worksheetPart.Worksheet = new Worksheet(sheetData);
Sheets sheets = myDoc.WorkbookPart.Workbook.AppendChild <Sheets>(new Sheets());
Sheet sheet = new Sheet()
{
Id = myDoc.WorkbookPart.GetIdOfPart(worksheetPart),
SheetId = 1,
Name = "mySheet"
};
sheets.AppendChild(sheet);
int cellIdx = 0;
for (uint row = 0; row < worksheet.Rows; row++)
{
var r = new Row();
r.RowIndex = row;
for (int col = 0; col < worksheet.Columns; col++)
{
/*
* var c = new Cell();
* c.DataType = CellValues.String;
* //string val = worksheet[row, col] != null ? worksheet[row, col].ToString() : "";
* string val = "test;";
* c.CellValue = new CellValue(val);
*
* r.InsertAt(c, col);
*/
var c = CreateTextCell(ColumnLetter(cellIdx++), row, "test");
r.AppendChild(c);
}
sheetData.AppendChild(r);
}
worksheetPart.Worksheet.Save();
workbookPart.Workbook.Save();
myDoc.Close();
}
return(xlsStream);
}
/// <summary>
/// Based on the matched keys, exchanges keys in the given translaton project
/// </summary>
/// <param name="tp"></param>
public void ChangeKeys(TranslationModule tp, bool concatMultipleMatches = false)
{
int counter = 0;
var byLanguage = tp.ByLanguage;
foreach (var kvp in Matches.Where(kvp => kvp.Key != kvp.Value))
{
foreach (var lang in byLanguage)
{
var newKey = lang.Where(s => s.Key == kvp.Key);
var existingKey = lang.Where(s => s.Key == kvp.Value);
if (newKey.Any() && !existingKey.Any())
{
//rename keys
foreach (var s in newKey)
{
s.Key = kvp.Key;
}
}
else if (!existingKey.Any())
{
//add empty value
tp.Add(new Segment(lang.Key, kvp.Value, ""));
}
else if (concatMultipleMatches)
{
//multiple matches found
//in this case we apply the special rule for lucca which consist in concetenating the strings
throw new NotImplementedException();
}
/*
* //var lang = tp.Dicts[langKey];
* if(lang)
* if (lang.ContainsKey(kvp.Key) && !lang.ContainsKey(kvp.Value))
* {
* lang.Add(kvp.Value, lang[kvp.Key]);
* lang.Remove(kvp.Key);
* counter++;
* }
* else if (!lang.ContainsKey(kvp.Key))
* {
* lang.Add(kvp.Value, "");
* }
* else if(concatMultipleMatches)
* {
* //multiple matches found
* //in this case we apply the special rule for lucca which consist in concetenating the strings
* lang[kvp.Value] += " <br /><br />" + lang[kvp.Key];
* lang.Remove(kvp.Key);
* }*/
}
}
}
public static Stream ToXLSX(TranslationModule project)
{
MemoryStream xlsStream = new MemoryStream();
using (var package = new OfficeOpenXml.ExcelPackage(xlsStream))
{
var worksheet = package.Workbook.Worksheets.Add("Traductions");
Export.ToIWorksheet(project, new XlsXWorksheet(worksheet));
package.Save();
}
return(xlsStream);
}
public static void ToArbAll(TranslationModule tp, string targetDir)
{
StringBuilder sb = new StringBuilder();
foreach (var l in tp.ByLanguage)
{
sb = ToArb(sb, tp.Name, l.Key, l);
}
using (StreamWriter outfile = new StreamWriter(targetDir + @"\" + tp.Name + ".arb", false, Encoding.UTF8))
{
outfile.Write(sb.ToString());
}
}
public static void ToXLSX(TranslationModule project, string fileName)
{
FileInfo newFile = new FileInfo(fileName);
if (newFile.Exists)
{
newFile.Delete(); // ensures we create a new workbook
newFile = new FileInfo(fileName);
}
using (var package = new OfficeOpenXml.ExcelPackage(newFile))
{
var worksheet = package.Workbook.Worksheets.Add("Traductions");
Export.ToIWorksheet(project, new XlsXWorksheet(worksheet));
package.Save();
}
}
public KeyMatcher(TranslationModule tpBase, TranslationModule tp, string masterLanguage = null)
{
var memory = new TranslationMemory(tpBase);
Matches = new Dictionary <string, string>();
NoMatches = new List <string>();
masterLanguage = masterLanguage ?? tp.MasterLanguage;
foreach (var seg in tp.ByLanguage[masterLanguage])
{
var results = memory.Query(masterLanguage, seg.Text);
if (results.Any())
{
Matches.Add(seg.Key, results.First().Key);
}
else
{
NoMatches.Add(seg.Key);
}
}
}
public static TranslationModule FromResX(string dir, string project, string masterLanguage)
{
var tp = new TranslationModule(project, masterLanguage);
List <DateTime> fileDates = new List <DateTime>();
var masterFile = dir + project + ".resx";
tp.Add(Segment.FromDict(masterLanguage, GetDictFromResX(masterFile)));
fileDates.Add(System.IO.File.GetLastWriteTimeUtc(masterFile));
foreach (var l in tp.Languages)
{
if (l == masterLanguage)
{
continue; //we skip master language since we treated it already as a special case
}
var file = dir + project + "." + l + ".resx";
tp.Add(Segment.FromDict(l, GetDictFromResX(file)));
fileDates.Add(System.IO.File.GetLastWriteTimeUtc(file));
}
tp.LastModified = fileDates.Max();
return(tp);
}
public TranslationMemory(TranslationModule tp)
{
this.Index = TranslationMemoryHelpers.BuildTranslationProjectIndex(new ITranslationModule[] { tp });
this.TranslationProject = tp;
}
public static TranslationModule FromIWorksheet(string project, string masterLanguage, IWorksheet worksheet)
{
// open the file "data.csv" which is a CSV file with headers
TranslationModule tp = null;
bool createMissingKeys = false;
Dictionary <int, string> languages = new Dictionary <int, string>();
string currentNS = project;
IEnumerable <string> labels = Enumerable.Empty <string>();
int commentColumn = -1;
for (int c = 1; c < worksheet.Columns; c++)
{
string language = ((string)worksheet[0, c]).ToLower();
if (language == "Comment")
{
commentColumn = c;
continue;
}
languages.Add(c, language);
}
tp = new TranslationModule(project, masterLanguage, languages.Values.ToArray());
for (int r = 1; r < worksheet.Rows; r++)
{
string key = ((string)worksheet[r, 0]);
if (string.IsNullOrWhiteSpace(key))
{
continue;
}
key = key.Trim();
bool isSpecialColumn = false;
if (key.Contains("ns:"))
{
currentNS = key.Split(':')[1];
isSpecialColumn = true;
}
if (key.StartsWith("#"))
{
isSpecialColumn = true;
labels = key.Split(',').Select(label => label.Trim());
}
if (currentNS == project && !isSpecialColumn)
{
if (string.IsNullOrWhiteSpace(key) && createMissingKeys)
{
string keyInspiration = commentColumn != 1 ? (string)worksheet[r, 1] : (string)worksheet[r, 2];
key = tp.KeyProposal(keyInspiration);
}
if (!string.IsNullOrWhiteSpace(key))
{
for (int c = 1; c < languages.Count + 1; c++)
{
var segment = new Segment(languages[c], key, (string)worksheet[r, c]);
segment.Tags = labels;
tp.Add(segment);
/*
* if (c != commentColumn)
* {
* tp.Dicts[languages[c].ToLower()].Add(key, (string) worksheet[r, c]);
* }
* else
* {
* tp.Comments.Add(key, (string) worksheet[r, c]);
* }*/
}
}
}
}
return(tp);
}
public static TranslationModule FromCSV(string file, string project, string masterLanguage, bool createMissingKeys = true)
{
// open the file "data.csv" which is a CSV file with headers
TranslationModule tp = null;
List <string> languages = new List <string>();
using (CsvReader csv =
new CsvReader(new StreamReader(file), true))
{
int fieldCount = csv.FieldCount;
string currentNS = "";
int commentColumn = -1;
string[] headers = csv.GetFieldHeaders();
for (int c = 1; c < headers.Length; c++)
{
string language = headers[c].ToLower();
if (language == "Comment")
{
commentColumn = c;
continue;
}
languages.Add(language);
}
tp = new TranslationModule(project, masterLanguage, languages.ToArray());
while (csv.ReadNextRecord())
{
string key = csv[0];
if (key.Contains("ns:"))
{
currentNS = key.Split(':')[1];
}
if (currentNS == project && !key.Contains("ns:"))
{
if (string.IsNullOrWhiteSpace(key) && createMissingKeys)
{
string keyInspiration = commentColumn != 1 ? csv[1] : csv[2];
key = tp.KeyProposal(keyInspiration);
}
if (!string.IsNullOrWhiteSpace(key))
{
for (int i = 1; i < fieldCount; i++)
{
if (i != commentColumn)
{
//tp.Dicts[headers[i].ToLower()].Add(key, csv[i]);
tp.Add(new Segment(headers[i].ToLower(), key, csv[i]));
}
}
if (commentColumn != -1)
{
foreach (var seg in tp.ByKey[key])
{
seg.Comment = csv[commentColumn];
}
}
}
}
}
}
return(tp);
}
static int Main(string[] args)
{
var options = new Options();
string verb = "";
object subOptions = null;
var ps = new CommandLine.ParserSettings();
IUserCredentialApplication credential = new Auth.UserCredentialApplicationFromFile();
CommandLine.Parser parser = new CommandLine.Parser(new CommandLine.ParserSettings {
MutuallyExclusive = true,
CaseSensitive = false,
HelpWriter = Console.Error
});
parser = CommandLine.Parser.Default;
if (parser.ParseArguments(args, options, (_verb, _subOptions) =>
{
verb = _verb;
subOptions = _subOptions;
}))
{
(subOptions as BaseOptions).CommandLine = string.Join(" ", args);
switch (verb)
{
case "upload":
{
var uploadOptions = subOptions as UploadOptions;
if (!uploadOptions.Batch && string.IsNullOrWhiteSpace(uploadOptions.ModuleName))
{
Console.Error.Write(options.GetUsage("upload"));
return(-1);
}
var drive = new IO.Google.Drive(credential);
var uploader = new Uploader(drive);
uploader.Upload(uploadOptions);
}
break;
case "download":
{
var drive = new IO.Google.Drive(credential);
var downloader = new Downloader(drive);
downloader.Download(subOptions as DownloadOptions);
}
break;
case "diff":
{
var diffOptions = subOptions as DiffOptions;
var drive = new IO.Google.Drive(credential);
var folder = drive.FindFolder(diffOptions.GDriveFolder);
ITranslationModule localModule = IO.ResX.FromResX(diffOptions.ResXDir, diffOptions.ModuleName, "en");
var downloader = new Downloader(drive);
var xlsx = downloader.DownloadXlsx(diffOptions);
var _remoteModule = IO.XlsX.FromXLSX(diffOptions.FileName, "en", xlsx);
_remoteModule.Name = diffOptions.ModuleName;
ITranslationModule remoteModule = _remoteModule.FilterByTags(diffOptions.Tags);
TranslationModuleDiff diff = localModule.Diff(remoteModule);
var diffJson = Newtonsoft.Json.JsonConvert.SerializeObject(diff, Newtonsoft.Json.Formatting.Indented);
Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.Write(diffJson);
if (diffOptions.HTML)
{
var htmlLogger = new HTMLConcatLogger();
diff.Print(htmlLogger);
var fileName = System.IO.Path.GetTempFileName() + ".html";
System.IO.File.WriteAllText(fileName, htmlLogger.HTML);
System.Diagnostics.Process.Start(fileName);
}
}
break;
case "patch":
{
var patchOptions = subOptions as PatchOptions;
//read patch data from stdin
Console.InputEncoding = System.Text.Encoding.UTF8;
var jsonReader = new System.Text.StringBuilder();
string s;
while ((s = Console.ReadLine()) != null)
{
jsonReader.AppendLine(s);
}
string json = jsonReader.ToString();
//string json = System.IO.File.ReadAllText(@".\diff");
var diff = Newtonsoft.Json.JsonConvert.DeserializeObject <TranslationModuleDiff>(json);
TranslationModule localModule = IO.ResX.FromResX(patchOptions.ResXDir, patchOptions.ModuleName, "en");
localModule.Patch(diff);
IO.ResX.ToResX(localModule, patchOptions.ResXDir);
}
break;
}
}
return(0);
}
public TranslationManager(SQLiteConnection dbContext) : base(dbContext)
{
_module = new TranslationModule(DbContext);
}
public TranslationManager(ApplicationDbContext dbContext) : base(dbContext)
{
_module = new TranslationModule(DbContext);
}
public static Stream ToXLSX(TranslationModule project)
{
MemoryStream xlsStream = new MemoryStream();
var worksheet = new MemoryWorksheet();
Export.ToIWorksheet(project, worksheet);
var ss = new Stylesheet();
ss.CellStyleFormats = new CellStyleFormats();
ss.CellStyleFormats.Count = 1;
ss.CellStyles = new CellStyles();
ss.CellStyles.Count = 1;
ss.DifferentialFormats = new DifferentialFormats();
ss.DifferentialFormats.Count = 0;
ss.TableStyles = new TableStyles();
ss.TableStyles.Count = 0;
using (SpreadsheetDocument myDoc = SpreadsheetDocument.Create(xlsStream, SpreadsheetDocumentType.Workbook))
{
WorkbookPart workbookPart = myDoc.AddWorkbookPart();
//workbookPart.Workbook = new Workbook();
WorkbookStylesPart stylesPart = workbookPart.AddNewPart <WorkbookStylesPart>();
stylesPart.Stylesheet = ss;
stylesPart.Stylesheet.Save();
WorksheetPart worksheetPart = workbookPart.AddNewPart <WorksheetPart>();
//SheetData sheetData = new SheetData();
//worksheetPart.Worksheet = new Worksheet(sheetData);
/*
* Sheets sheets = myDoc.WorkbookPart.Workbook.AppendChild<Sheets>(new Sheets());
* Sheet sheet = new Sheet()
* {
* Id = myDoc.WorkbookPart.GetIdOfPart(worksheetPart),
* SheetId = 1,
* Name = "mySheet"
* };
* sheets.Append(sheet);
*/
OpenXmlWriter writer = OpenXmlWriter.Create(worksheetPart);
writer.WriteStartElement(new Worksheet());
writer.WriteStartElement(new SheetData());
for (int row = 0; row < worksheet.Rows; row++)
{
var oxa = new List <OpenXmlAttribute>();
// this is the row index
oxa.Add(new OpenXmlAttribute("r", null, row.ToString()));
writer.WriteStartElement(new Row(), oxa);
for (int col = 0; col < worksheet.Columns; col++)
{
oxa = new List <OpenXmlAttribute>();
// this is the data type ("t"), with CellValues.String ("str")
oxa.Add(new OpenXmlAttribute("t", null, "str"));
string val = worksheet[row, col] != null ? worksheet[row, col].ToString() : "";
//var cell = new Cell(new CellValue(val));
writer.WriteStartElement(new Cell(), oxa);
//Cell c = new Cell();
CellValue v = new CellValue(val);
writer.WriteElement(v);
//c.AppendChild(v);
//writer.WriteElement();
writer.WriteEndElement();
}
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
writer.Close();
writer = OpenXmlWriter.Create(myDoc.WorkbookPart);
writer.WriteStartElement(new Workbook());
writer.WriteStartElement(new Sheets());
// you can use object initialisers like this only when the properties
// are actual properties. SDK classes sometimes have property-like properties
// but are actually classes. For example, the Cell class has the CellValue
// "property" but is actually a child class internally.
// If the properties correspond to actual XML attributes, then you're fine.
writer.WriteElement(new Sheet()
{
Name = "Sheet1",
SheetId = 1,
Id = myDoc.WorkbookPart.GetIdOfPart(worksheetPart)
});
// this is for Sheets
writer.WriteEndElement();
// this is for Workbook
writer.WriteEndElement();
writer.Close();
myDoc.Close();
}
return(xlsStream);
}
