/// <summary>
/// Check if the report was successfully generated
/// </summary>
/// <param name="reportOutputPath"></param>
/// <param name="isChecked"></param>
/// <param name="optionalInformation"></param>
/// <param name="projects"></param>
/// <returns></returns>
public bool GenerateReportFile(BindingList <ProjectDetails> projects, OptionalInformation optionalInformation, string reportOutputPath, bool isChecked)
{
try
{
Directory.CreateDirectory(reportOutputPath);
var projectsToBeExported = projects.Where(p => p.ShouldBeExported).ToList();
var areCheckedLanguages = projectsToBeExported.Any(p => p.ProjectLanguages.Any(l => l.Value));
if (areCheckedLanguages || projectsToBeExported.Count > 0)
{
foreach (var project in projectsToBeExported)
{
// check which languages to export
if (project.ProjectLanguages == null)
{
continue;
}
var checkedLanguages = project.ProjectLanguages.Where(l => l.Value).ToList();
foreach (var languageReport in checkedLanguages)
{
project.ReportPath = reportOutputPath;
WriteReportFile(project, optionalInformation, languageReport, isChecked);
}
}
return(true);
}
_messageBoxService.ShowInformationMessage(PluginResources.SelectLanguage_Export_Message, PluginResources.ExportResult_Label);
return(false);
}
catch (Exception exception)
{
Log.Logger.Error($"GenerateReport method: {exception.Message}\n {exception.StackTrace}");
throw;
}
}
public string GetCsvContent(bool includeHeader, OptionalInformation aditionalHeaders)
{
try
{
var csvSeparator = CultureInfo.CurrentCulture.TextInfo.ListSeparator;
var csvHeader = GetCsvHeaderRow(csvSeparator, _analyzedFiles?.FirstOrDefault()?.Fuzzies, aditionalHeaders);
var sb = new StringBuilder();
if (includeHeader)
{
sb.Append(csvHeader).Append(Environment.NewLine);
}
if (_analyzedFiles != null)
{
foreach (var file in _analyzedFiles)
{
WriteCsvInformation(sb, aditionalHeaders, file, csvSeparator);
}
}
return(sb.ToString());
}
catch (Exception ex)
{
Log.Logger.Error($"GetCsvContent method: {ex.Message}\n {ex.StackTrace}");
}
return(string.Empty);
}
private void InitializeSettings(List <string> studioProjectsPaths = null)
{
DisableButtons();
_help = new Helpers.Help();
includeHeaderCheck.Checked = true;
_allStudioProjectsDetails = new List <ProjectDetails>();
LoadProjectsList(_projectService.ProjectsXmlPath, studioProjectsPaths);
reportOutputPath.Text = _reportService.GetJsonReportPath(_reportService.JsonPath);
targetBtn.Enabled = !IsNullOrEmpty(reportOutputPath.Text);
_optionalInformation = SetOptionalInformation();
projectStatusComboBox.SelectedIndex = 0;
}
// Write to string builder the information used in csv file
private void WriteCsvInformation(StringBuilder sb, OptionalInformation optionalInformation, AnalyzedFile file, string csvSeparator)
{
sb.Append(file.FileName).Append(csvSeparator).Append(file.Repeated.Words).Append(csvSeparator);
if (optionalInformation.IncludeLocked)
{
sb.Append(file.Locked.Words).Append(csvSeparator);
}
if (optionalInformation.IncludePerfectMatch)
{
sb.Append(file.Perfect.Words).Append(csvSeparator);
}
if (optionalInformation.IncludeContextMatch)
{
sb.Append(file.InContextExact.Words).Append(csvSeparator);
}
if (optionalInformation.IncludeCrossRep)
{
sb.Append(file.CrossRep.Words).Append(csvSeparator);
}
// the 100% match is actually a sum of Exact, Perfect and InContextExact matches
sb.Append((file.Exact.Words + file.Perfect.Words + file.InContextExact.Words).ToString()).Append(csvSeparator);
foreach (var fuzzy in file.Fuzzies.OrderByDescending(fz => fz.Max))
{
sb.Append(fuzzy.Words).Append(csvSeparator);
var internalFuzzy = file.InternalFuzzy(fuzzy.Min, fuzzy.Max);
sb.Append(internalFuzzy != null ? internalFuzzy.Words : 0).Append(csvSeparator);
if (optionalInformation.IncludeInternalFuzzies)
{
sb.Append(internalFuzzy != null ? internalFuzzy.FullRecallWords : 0).Append(csvSeparator);
}
}
if (optionalInformation.IncludeAdaptiveBaseline)
{
sb.Append(file.NewBaseline.FullRecallWords).Append(csvSeparator);
}
if (optionalInformation.IncludeAdaptiveLearnings)
{
sb.Append(file.NewLearnings.FullRecallWords).Append(csvSeparator);
}
sb.Append(file.Untranslated.Words).Append(csvSeparator).Append(file.Total.Words).Append(csvSeparator).Append(Environment.NewLine);
}
private void InitializeSettings()
{
_areExternalStudioProjects = false;
copyBtn.Enabled = false;
csvBtn.Enabled = false;
targetBtn.Enabled = false;
includeHeaderCheck.Checked = true;
_projectXmlPath = Help.GetStudioProjectsPath();
_allStudioProjectsDetails = new List <ProjectDetails>();
LoadProjectsList(_projectXmlPath);
_optionalInformation = new OptionalInformation
{
IncludeAdaptiveBaseline = adaptiveMT.Checked,
IncludeAdaptiveLearnings = adaptiveLearnings.Checked,
IncludeInternalFuzzies = internalFuzzies.Checked,
IncludeContextMatch = contextMatch.Checked,
IncludeCrossRep = crossRep.Checked,
IncludeLocked = locked.Checked,
IncludePerfectMatch = perfectMatch.Checked
};
}
private void InitializeSettings()
{
copyBtn.Enabled = false;
csvBtn.Enabled = false;
includeHeaderCheck.Checked = true;
_projectXmlPath = Help.GetStudioProjectsPath();
_allStudioProjectsDetails = new List <ProjectDetails>();
LoadProjectsList(_projectXmlPath);
reportOutputPath.Text = Help.GetJsonReportPath(Help.JsonPath);
targetBtn.Enabled = !string.IsNullOrEmpty(reportOutputPath.Text) ? true : false;
_optionalInformation = new OptionalInformation
{
IncludeAdaptiveBaseline = adaptiveMT.Checked,
IncludeAdaptiveLearnings = adaptiveLearnings.Checked,
IncludeInternalFuzzies = internalFuzzies.Checked,
IncludeContextMatch = contextMatch.Checked,
IncludeCrossRep = crossRep.Checked,
IncludeLocked = locked.Checked,
IncludePerfectMatch = perfectMatch.Checked
};
}
// Write the report file based on the Analyse file
private void WriteReportFile(ProjectDetails project, OptionalInformation optionalInformation, KeyValuePair <string, bool> languageReport, bool isChecked)
{
try
{
var streamPath = Path.Combine($"{project.ReportPath}{Path.DirectorySeparatorChar}", $"{project.ProjectName}_{languageReport.Key}.csv");
using (var sw = new StreamWriter(streamPath))
{
if (project.LanguageAnalysisReportPaths == null)
{
return;
}
var analyseReportPath = project.LanguageAnalysisReportPaths.FirstOrDefault(l => l.Key.Equals(languageReport.Key));
if (!analyseReportPath.Equals(new KeyValuePair <string, string>()))
{
PrepareAnalysisReport(analyseReportPath.Value);
sw.Write(GetCsvContent(isChecked, optionalInformation));
}
}
}
catch (Exception ex)
{
Log.Logger.Error($"WriteReportFile method: {ex.Message}\n {ex.StackTrace}");
}
}
private string GetCsvHeaderRow(string separator, IEnumerable <BandResult> fuzzies, OptionalInformation aditionalHeaders)
{
try
{
var headerColumns = new List <string> {
"\"Filename\"", "\"Repetitions\"",
};
if (aditionalHeaders.IncludeLocked)
{
headerColumns.Add("\"Locked\"");
}
if (aditionalHeaders.IncludePerfectMatch)
{
headerColumns.Add("\"Perfect Match\"");
}
if (aditionalHeaders.IncludeContextMatch)
{
headerColumns.Add("\"Context Match\"");
}
if (aditionalHeaders.IncludeCrossRep)
{
headerColumns.Add("\"Cross File Repetitions\"");
}
headerColumns.Add("\"100% (TM)\"");
fuzzies.OrderByDescending(br => br.Max).ToList().ForEach(br => {
headerColumns.Add(string.Format("\"{0}% - {1}% (TM)\"", br.Max, br.Min));
headerColumns.Add(string.Format("\"{0}% - {1}% (AP)\"", br.Max, br.Min));
if (aditionalHeaders.IncludeInternalFuzzies)
{
headerColumns.Add(string.Format("\"{0}% - {1}% (Internal)\"", br.Max, br.Min));
}
});
if (aditionalHeaders.IncludeAdaptiveBaseline)
{
headerColumns.Add("\"AdaptiveMT Baseline\"");
}
if (aditionalHeaders.IncludeAdaptiveLearnings)
{
headerColumns.Add("\"AdaptiveMT with Learnings\"");
}
headerColumns.Add("\"New\"");
headerColumns.Add("\"Total Words\"");
return(headerColumns.Aggregate((res, next) => res + separator + next));
}
catch (Exception ex)
{
Log.Logger.Error($"GetCsvHeaderRow method: {ex.Message}\n {ex.StackTrace}");
}
return(string.Empty);
}
public string ToCsv(bool includeHeader, OptionalInformation aditionalHeaders)
{
try
{
var csvSeparator = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ListSeparator;
var csvNewLine = Environment.NewLine;
var csvHeader = GetCsvHeaderRow(csvSeparator, AnalyzedFiles.First().Fuzzies, aditionalHeaders);
var sb = new StringBuilder();
if (includeHeader)
{
sb.Append(csvHeader).Append(csvNewLine);
}
foreach (var file in AnalyzedFiles)
{
sb.Append(file.FileName).Append(csvSeparator)
.Append(file.Repeated.Words).Append(csvSeparator);
if (aditionalHeaders.IncludeLocked)
{
sb.Append(file.Locked.Words).Append(csvSeparator);
}
if (aditionalHeaders.IncludePerfectMatch)
{
sb.Append(file.Perfect.Words).Append(csvSeparator);
}
if (aditionalHeaders.IncludeContextMatch)
{
sb.Append(file.InContextExact.Words).Append(csvSeparator);
}
if (aditionalHeaders.IncludeCrossRep)
{
sb.Append(file.CrossRep.Words).Append(csvSeparator);
}
// the 100% match is actually a sum of Exact, Perfect and InContextExact matches
sb.Append((file.Exact.Words + file.Perfect.Words + file.InContextExact.Words).ToString()).Append(csvSeparator);
foreach (var fuzzy in file.Fuzzies.OrderByDescending(fz => fz.Max))
{
sb.Append(fuzzy.Words).Append(csvSeparator);
var internalFuzzy = file.InternalFuzzy(fuzzy.Min, fuzzy.Max);
sb.Append(internalFuzzy != null ? internalFuzzy.Words : 0).Append(csvSeparator);
if (aditionalHeaders.IncludeInternalFuzzies)
{
sb.Append(internalFuzzy != null ? internalFuzzy.FullRecallWords : 0).Append(csvSeparator);
}
}
if (aditionalHeaders.IncludeAdaptiveBaseline)
{
sb.Append(file.NewBaseline.FullRecallWords).Append(csvSeparator);
}
if (aditionalHeaders.IncludeAdaptiveLearnings)
{
sb.Append(file.NewLearnings.FullRecallWords).Append(csvSeparator);
}
sb.Append(file.Untranslated.Words).Append(csvSeparator)
.Append(file.Total.Words).Append(csvSeparator)
.Append(csvNewLine);
}
return(sb.ToString());
}
catch (Exception ex)
{
Log.Logger.Error($"ToCsv method: {ex.Message}\n {ex.StackTrace}");
}
return(string.Empty);
}
