private void AnalyzeDatabaseSettingsResults(ReportResults results, IEnumerable <SettingsKey> databaseSettingsKeys)
{
var explicitlyEnabledSettings = databaseSettingsKeys.Where(x => x.KeyValue == true && x.KeyDefaultValue == false);
var explicitlyEnabledSettingsCount = explicitlyEnabledSettings.Count();
if (explicitlyEnabledSettingsCount > 0)
{
if (results.Status != ReportResultsStatus.Error)
{
results.Status = ReportResultsStatus.Warning;
}
results.Summary += Metadata.Terms.Database.Summary.With(new { explicitlyEnabledSettingsCount });
results.Data.DatabaseSettingsEnabledNotByDefaultResults = new TableResult <SettingsKey>()
{
Name = Metadata.Terms.Database.ExplicitlyEnabledSettingsTableHeader,
Rows = explicitlyEnabledSettings
};
}
results.Data.AllDatabaseSettings = new TableResult <SettingsKey>()
{
Name = Metadata.Terms.Database.OverviewTableHeader,
Rows = databaseSettingsKeys
};
}
private static void GetGuidsFromReport(MailTrigger Trigger)
{
string folder = "\\AutoMailer\\";
FileSystemEntry fileSystemEntry = new FileSystemEntry(folder, FileSystemEntry.Types.Folder, (string)null);
Sessions.Session defaultInstance = Session.DefaultInstance;
FSExplorer rptExplorer = new FSExplorer(defaultInstance);
ReportMainControl r = new ReportMainControl(defaultInstance, false);
ReportIFSExplorer ifsExplorer = new ReportIFSExplorer(r, defaultInstance);
FileSystemEntry report = ifsExplorer.GetFileSystemEntries(fileSystemEntry).Where(x => x.Name.Equals(Trigger.ReportFilter)).FirstOrDefault();
ReportSettings reportSettings = Session.DefaultInstance.ReportManager.GetReportSettings(report);
LoanReportParameters reportParams1 = new LoanReportParameters();
reportParams1.Fields.AddRange((IEnumerable <ColumnInfo>)reportSettings.Columns);
reportParams1.FieldFilters.AddRange((IEnumerable <FieldFilter>)reportSettings.Filters);
reportParams1.UseDBField = reportSettings.UseFieldInDB;
reportParams1.UseDBFilter = reportSettings.UseFilterFieldInDB;
reportParams1.UseExternalOrganization = reportSettings.ForTPO;
reportParams1.CustomFilter = CreateLoanCustomFilter(reportSettings);
ReportResults results = Session.DefaultInstance.ReportManager.QueryLoansForReport(reportParams1, null);
List <string[]> reportResults = ReportResults.Download(results);
List <string> guids = results.GetAllResults().Select(x => x.FirstOrDefault()).ToList();
bool fieldsAreGuids = Guid.TryParse(guids.FirstOrDefault(), out Guid _);
if (fieldsAreGuids)
{
SendEmails(Trigger, guids);
}
}
public void SetData(DataSchema dataSchema, ReportResults reportResults, ClusteringSpec clusteringSpec)
{
_clusterSpecRows.Clear();
_clusterSpecRows.AddRange(MakeRows(dataSchema, reportResults, clusteringSpec));
comboDistanceMetric.SelectedItem =
ClusterMetricType.FromName(clusteringSpec?.DistanceMetric) ?? ClusterMetricType.DEFAULT;
}
private ReportResults CompileResults(params ReportResults[] allReportResults)
{
var combinedResults = new ReportResults();
combinedResults.Type = ReportResultsType.TableList;
combinedResults.Status = ReportResultsStatus.Good;
foreach (var reportResults in allReportResults)
{
var name = ((string)reportResults.Data.Name);
// TODO: Make this WAY better
((IDictionary <string, object>)combinedResults.Data).Add(reportResults.Data.Name, reportResults.Data);
if (reportResults.Status == ReportResultsStatus.Error)
{
combinedResults.Summary += Metadata.Terms.NameFound.With(new { name });
combinedResults.Status = ReportResultsStatus.Error;
}
}
if (combinedResults.Status == ReportResultsStatus.Good)
{
combinedResults.Summary = Metadata.Terms.NoContentTreeConsistencyIssuesFound;
}
return(combinedResults);
}
protected TransformResults Transform(CancellationToken cancellationToken, DataSchema dataSchema, TransformResults input,
TransformStack transformStack)
{
if (transformStack == null || transformStack.StackIndex >= transformStack.RowTransforms.Count)
{
return(input);
}
cancellationToken.ThrowIfCancellationRequested();
if (transformStack.Predecessor != null)
{
input = Transform(cancellationToken, dataSchema, input, transformStack.Predecessor);
}
var filter = transformStack.CurrentTransform as RowFilter;
if (filter != null)
{
var filteredRows = new ReportResults(Filter(cancellationToken, dataSchema, filter, input.PivotedRows),
input.PivotedRows.ItemProperties);
filteredRows = Sort(cancellationToken, dataSchema, filter, filteredRows);
return(new TransformResults(input, filter, filteredRows));
}
var pivotSpec = transformStack.CurrentTransform as PivotSpec;
if (pivotSpec != null)
{
var pivotedRows = GroupAndTotaler.GroupAndTotal(cancellationToken, dataSchema, pivotSpec, input.PivotedRows);
return(new TransformResults(input, pivotSpec, pivotedRows));
}
return(input);
}
private ReportResults CompileResults(IEnumerable <IdenticalPageLayouts> identicalPageLayouts)
{
var countIdenticalPageLayouts = identicalPageLayouts.Count();
var results = new ReportResults
{
Status = ReportResultsStatus.Information,
Type = ReportResultsType.Table,
Data = new TableResult <dynamic>()
{
Name = Metadata.Terms.IdenticalPageLayouts,
Rows = identicalPageLayouts
}
};
if (countIdenticalPageLayouts == 0)
{
results.Summary = Metadata.Terms.NoIdenticalPageLayoutsFound;
}
else
{
results.Summary = Metadata.Terms.CountIdenticalPageLayoutFound.With(new { count = countIdenticalPageLayouts });
}
return(results);
}
private ReportResults CompileResults(IEnumerable <ClassField> fieldsWithMismatchedTypes)
{
var fieldErrorCount = fieldsWithMismatchedTypes.Count();
var fieldResults = new TableResult <dynamic>()
{
Name = Metadata.Terms.TableTitles.FieldsWithMismatchedTypes,
Rows = fieldsWithMismatchedTypes
};
var results = new ReportResults
{
Type = ReportResultsType.TableList
};
results.Data.FieldResults = fieldResults;
switch (fieldErrorCount)
{
case 0:
results.Status = ReportResultsStatus.Good;
results.Summary = Metadata.Terms.Summaries.Good;
break;
default:
results.Status = ReportResultsStatus.Information;
results.Summary = Metadata.Terms.Summaries.Information.With(new { fieldResultCount = fieldErrorCount });
break;
}
return(results);
}
private ReportResults CompileResults(IEnumerable <CmsPageTypeField> fieldsWithMismatchedTypes)
{
if (!fieldsWithMismatchedTypes.Any())
{
return(new ReportResults
{
Status = ReportResultsStatus.Good,
Summary = Metadata.Terms.Summaries.Good
});
}
var fieldResultCount = fieldsWithMismatchedTypes.Count();
var fieldResults = new TableResult <dynamic>()
{
Name = Metadata.Terms.TableTitles.MatchingPageTypeFieldsWithDifferentDataTypes,
Rows = fieldsWithMismatchedTypes
};
var results = new ReportResults
{
Type = ReportResultsType.TableList,
Status = ReportResultsStatus.Information,
Summary = Metadata.Terms.Summaries.Information.With(new { fieldResultCount }),
};
results.Data.FieldResults = fieldResults;
return(results);
}
private void AnalyzeWebConfigSettings(ReportResults results, bool isCompilationDebugEnabled, bool isTraceEnabled)
{
var isDebugOrTraceEnabledInWebConfig = isCompilationDebugEnabled || isTraceEnabled;
if (isDebugOrTraceEnabledInWebConfig)
{
results.Status = ReportResultsStatus.Error;
var enabledSettingsText = isCompilationDebugEnabled ? "`Debug`" : string.Empty;
enabledSettingsText += isCompilationDebugEnabled && isTraceEnabled ? " & " : string.Empty;
enabledSettingsText += isTraceEnabled ? "`Trace`" : string.Empty;
results.Summary += Metadata.Terms.WebConfig.Summary.With(new { enabledSettingsText });
}
var webconfigSettingsValues = new List <SettingsKey>();
webconfigSettingsValues.Add(new SettingsKey("Debug", Metadata.Terms.WebConfig.DebugKeyDisplayName, isCompilationDebugEnabled, false));
webconfigSettingsValues.Add(new SettingsKey("Trace", Metadata.Terms.WebConfig.TraceKeyDisplayName, isTraceEnabled, false));
results.Data.WebConfigSettingsResults = new TableResult <SettingsKey>()
{
Name = Metadata.Terms.WebConfig.OverviewTableHeader,
Rows = webconfigSettingsValues
};
}
private ReportResults CompileResults(IEnumerable <CmsPageTypeField> fieldsWithMismatchedTypes)
{
if (!fieldsWithMismatchedTypes.Any())
{
return new ReportResults(ResultsStatus.Good)
{
Summary = Metadata.Terms.Summaries.Good
}
}
;
var fieldResultCount = fieldsWithMismatchedTypes.Count();
var results = new ReportResults
{
Summary = Metadata.Terms.Summaries.Information.With(
new
{
fieldResultCount
}
),
Data = fieldsWithMismatchedTypes.AsResult()
.WithLabel(Metadata.Terms.TableTitles.MatchingPageTypeFieldsWithDifferentDataTypes)
};
return(results);
}
private static TResult GetAnonymousTableResult <TResult>(ReportResults results, string resultName)
{
return(results
.Data
.GetType()
.GetProperty(resultName)
.GetValue(results.Data));
}
private static TResult GetResult <TResult>(ReportResults results)
{
IDictionary <string, object> dictionaryData = results.Data;
return(dictionaryData
.Values
.OfType <TResult>()
.First());
}
public async Task <IActionResult> Accounts([FromServices] IReportsRepository data, [FromForm] ReportParms parms)
{
if (!ModelState.IsValid)
{
return(new BadRequestResult());
}
ReportResults results = await data.GetAccountSearchResults(parms);
return(Content(JsonConvert.SerializeObject(results), "application/json"));
}
public static ReportResults GetSuddenCariacArrest(DateTime start, DateTime end)
{
using (emsDBDataContext db = new emsDBDataContext())
{
int limit = 6 * 60; // in seconds
ReportResults results = new ReportResults();
results.NumberOnTime = db.EntryDetails.Where(c => c.Date >= start && c.Date <= end && c.CTAS_raw == 1 && c.VSA_raw > 1 && c.TDiff <= limit).Count();
results.NumberOfCalls = db.EntryDetails.Where(c => c.Date >= start && c.Date <= end && c.CTAS_raw == 1 && c.VSA_raw > 1).Count();
return results;
}
}
public static ReportResults GetCTAS(int CTAS, int minutes, DateTime start, DateTime end)
{
using (emsDBDataContext db = new emsDBDataContext())
{
int limit = minutes * 60; // in seconds
ReportResults results = new ReportResults();
results.NumberOnTime = db.EntryDetails.Where(c => c.Date >= start && c.Date <= end && c.CTAS_raw == CTAS && c.TDiff <= limit).Count();
results.NumberOfCalls = db.EntryDetails.Where(c => c.Date >= start && c.Date <= end && c.CTAS_raw == CTAS).Count();
return results;
}
}
private void ExecuteQueryImpl()
{
try {
var report = new QueryReport(User, _model, IsDistinct);
var results = new ReportResults(report);
PluginManager.Instance.AddDocumentContent(Owner, results, new DockableContentOptions {
Title = report.Name, IsFloating = Preferences.OpenReportResultsInFloatingWindow.Value
});
} catch (Exception ex) {
ErrorMessage.Show(ex.Message);
}
}
public void UpdateResults()
{
if (null == _queryRequestor)
{
return;
}
if (ReferenceEquals(_queryRequestor.QueryResults, QueryResults))
{
return;
}
var queryResults = _queryRequestor.QueryResults;
if (queryResults == null)
{
return;
}
_queryResults = queryResults;
bool rowCountChanged = Count != QueryResults.ResultRows.Count;
var newRow = _newRow;
if (newRow != null)
{
int newRowPos = Items.IndexOf(newRow);
CancelNew(newRowPos);
}
RowItemList.Clear();
RowItemList.AddRange(QueryResults.ResultRows);
if (newRow != null && !NewRowHandler.IsNewRowEmpty(newRow))
{
_newRow = newRow;
AddNew();
}
bool propsChanged = !ItemProperties.SequenceEqual(QueryResults.ItemProperties);
_reportResults = QueryResults.TransformResults.PivotedRows;
AllowNew = NewRowHandler != null;
AllowEdit = true;
AllowRemove = false;
if (propsChanged)
{
OnListChanged(new ListChangedEventArgs(ListChangedType.PropertyDescriptorChanged, 0));
ResetBindings();
}
else if (rowCountChanged || 0 == Count)
{
ResetBindings();
}
else
{
OnAllRowsChanged();
}
}
public static ReportResults GroupAndTotal(CancellationToken cancellationToken, DataSchema dataSchema,
PivotSpec pivotSpec, ReportResults input)
{
if (pivotSpec.IsEmpty)
{
return(input);
}
var groupAndTotaller = new GroupAndTotaler(cancellationToken, dataSchema, pivotSpec, input.ItemProperties);
var newProperties = new List <DataPropertyDescriptor>();
var newRows = ImmutableList.ValueOf(groupAndTotaller.GroupAndTotal(input.RowItems, newProperties));
return(new ReportResults(newRows, newProperties));
}
private ReportResults CompileResults(IEnumerable <SettingsKey> databaseSettingsKeys, bool isCompilationDebugEnabled, bool isTraceEnabled)
{
var results = new ReportResults()
{
Status = ReportResultsStatus.Information,
Summary = string.Empty,
Type = ReportResultsType.TableList
};
AnalyzeDatabaseSettingsResults(results, databaseSettingsKeys);
AnalyzeWebConfigSettings(results, isCompilationDebugEnabled, isTraceEnabled);
return(results);
}
public ReportResults ExpandAndPivot(CancellationToken cancellationToken, IEnumerable <RowItem> rowItems)
{
var expandedItems = rowItems.SelectMany(rowItem => Expand(cancellationToken, rowItem, 0)).ToArray();
var pivotedItems = expandedItems.Select(item => Pivot(cancellationToken, item));
var filteredItems = Filter(cancellationToken, pivotedItems);
var rows = ImmutableList.ValueOf(filteredItems);
var result = new ReportResults(rows, GetItemProperties(rows));
if (ViewInfo.HasTotals)
{
result = GroupAndTotal(cancellationToken, result);
}
return(result);
}
public static bool EqualValuesInAllRows(CancellationToken cancellationToken, ReportResults reportResults, PivotedProperties.Series series)
{
foreach (var propertyDescriptor in series.PropertyDescriptors)
{
cancellationToken.ThrowIfCancellationRequested();
var distinctValues = reportResults.RowItems.Select(propertyDescriptor.GetValue)
.Where(value => null != value).Distinct();
if (distinctValues.Skip(1).Any())
{
return(false);
}
}
return(true);
}
protected ReportResults Sort(CancellationToken cancellationToken, DataSchema dataSchema, RowFilter rowFilter,
ReportResults pivotedRows)
{
if (rowFilter.ColumnSorts.Count == 0)
{
return(pivotedRows);
}
var sortDescriptions = rowFilter.GetListSortDescriptionCollection(pivotedRows.ItemProperties);
if (sortDescriptions.Count == 0)
{
return(pivotedRows);
}
return(pivotedRows.ChangeRowItems(Sort(cancellationToken, dataSchema, sortDescriptions, pivotedRows)));
}
private static void GenerateInitialReportSheet(ReportResults reportResults, XLWorkbook wb)
{
var wsReport = wb.Worksheet("Evaluation Report_Initial");
wsReport.Cell("B9").Value = DateTime.Now.ToString("dd-MMM-yyyy");
wsReport.Cell("L8").Value = "TQA";
wsReport.Cell("L11").Value = reportResults.QualityLevel;
wsReport.Protect(ProtectionPassword);
wsReport.Range(14, 1, 21, 9).Style.Protection.SetLocked(true); // only second table should be protected
AjustCommentSize(wsReport);
ChangeStyleForEvaluationReport(wsReport);
for (var i = 0; i < reportResults.EvaluationComments.Count; i++)
{
wsReport.Row(i + 42).Cell(1).Value = reportResults.EvaluationComments[i];
}
}
private ReportResults CompileResults(IEnumerable <TableWithNoClass> tablesWithMissingClass, IEnumerable <ClassWithNoTable> classesWithMissingTable)
{
var tableErrors = tablesWithMissingClass.Count();
var tableResults = new TableResult <dynamic>()
{
Name = Metadata.Terms.DatabaseTablesWithMissingKenticoClasses,
Rows = tablesWithMissingClass
};
var classErrors = classesWithMissingTable.Count();
var classResults = new TableResult <dynamic>()
{
Name = Metadata.Terms.KenticoClassesWithMissingDatabaseTables,
Rows = classesWithMissingTable
};
var totalErrors = tableErrors + classErrors;
var results = new ReportResults
{
Type = ReportResultsType.TableList
};
results.Data.TableResults = tableResults;
results.Data.ClassResults = classResults;
switch (totalErrors)
{
case 0:
results.Status = ReportResultsStatus.Good;
results.Summary = Metadata.Terms.NoIssuesFound;
break;
default:
results.Status = ReportResultsStatus.Error;
results.Summary = Metadata.Terms.CountIssueFound.With(new { count = totalErrors });
break;
}
return(results);
}
private ReportResults CompileResults(
IEnumerable <CmsSettingsKeyResult> cmsSettingsKeyResults,
IEnumerable <WebConfigSettingResult> webConfigSettingsResults
)
{
if (!cmsSettingsKeyResults.Any() && !webConfigSettingsResults.Any())
{
return(new ReportResults
{
Status = ReportResultsStatus.Good,
Summary = Metadata.Terms.Summaries.Good
});
}
var errorReportResults = new ReportResults
{
Type = ReportResultsType.TableList,
Status = ReportResultsStatus.Warning
};
var cmsSettingsKeyResultsCount = IfAnyAddTableResult(
errorReportResults.Data,
cmsSettingsKeyResults,
Metadata.Terms.TableTitles.AdminSecuritySettings
);
var webConfigSettingsResultsCount = IfAnyAddTableResult(
errorReportResults.Data,
webConfigSettingsResults,
Metadata.Terms.TableTitles.WebConfigSecuritySettings
);
errorReportResults.Summary = Metadata.Terms.Summaries.Warning.With(new
{
cmsSettingsKeyResultsCount,
webConfigSettingsResultsCount
});
return(errorReportResults);
}
private ReportResults CompileResults(
IEnumerable <CmsClassResult> cmsClassesWithAddedFields,
IEnumerable <TableResult> tablesWithAddedColumns
)
{
if (!cmsClassesWithAddedFields.Any() && !tablesWithAddedColumns.Any())
{
return(new ReportResults()
{
Status = ReportResultsStatus.Good,
Summary = Metadata.Terms.Summaries.Good
});
}
var errorReportResults = new ReportResults
{
Type = ReportResultsType.TableList,
Status = ReportResultsStatus.Error
};
var cmsClassesResultCount = IfAnyAddTableResult(
errorReportResults.Data,
cmsClassesWithAddedFields,
Metadata.Terms.TableTitles.ClassesWithAddedFields
);
var tablesResultCount = IfAnyAddTableResult(
errorReportResults.Data,
tablesWithAddedColumns,
Metadata.Terms.TableTitles.TablesWithAddedColumns
);
errorReportResults.Summary = Metadata.Terms.Summaries.Error.With(new
{
cmsClassesResultCount,
tablesResultCount
});
return(errorReportResults);
}
private ReportResults CompileResults(IEnumerable <ApplicationRestartEvent> applicationRestartEvents)
{
var data = new TableResult <dynamic>()
{
Name = Metadata.Terms.ApplicationRestartEvents,
Rows = applicationRestartEvents
};
var totalEvents = applicationRestartEvents.Count();
var totalStartEvents = applicationRestartEvents.Where(e => e.EventCode == "STARTAPP").Count();
var totalEndEvents = applicationRestartEvents.Where(e => e.EventCode == "ENDAPP").Count();
var earliestTime = totalEvents > 0 ? applicationRestartEvents.Min(e => e.EventTime) : new DateTime();
var latestTime = totalEvents > 0 ? applicationRestartEvents.Max(e => e.EventTime) : new DateTime();
var totalEventsText = Metadata.Terms.CountTotalEvent.With(new { count = totalEvents });
var totalStartEventsText = Metadata.Terms.CountStartEvent.With(new { count = totalStartEvents });
var totalEndEventsText = Metadata.Terms.CountEndEvent.With(new { count = totalEndEvents });
string timeSpanText = string.Empty;
if (earliestTime.Year > 1)
{
timeSpanText = Metadata.Terms.SpanningEarliestLatest.With(new { earliestTime, latestTime });
}
var results = new ReportResults
{
Type = ReportResultsType.Table,
Status = ReportResultsStatus.Information,
Summary = $"{totalEventsText} ({totalStartEventsText}, {totalEndEventsText}) {timeSpanText}",
Data = data
};
return(results);
}
private ReportResults CompileResults(
IEnumerable <CmsUserResult> usersWithEmptyPasswords,
IEnumerable <CmsUserResult> usersWithPlaintextPasswords)
{
if (!usersWithEmptyPasswords.Any() && !usersWithPlaintextPasswords.Any())
{
return(new ReportResults
{
Type = ReportResultsType.String,
Status = ReportResultsStatus.Good,
Summary = Metadata.Terms.GoodSummary
});
}
var errorReportResults = new ReportResults
{
Type = ReportResultsType.TableList,
Status = ReportResultsStatus.Error,
Data = new List <TableResult <CmsUserResult> >()
};
var emptyCount = IfAnyAddTableResult(
errorReportResults.Data,
usersWithEmptyPasswords,
Metadata.Terms.TableTitles.EmptyPasswords
);
var plaintextCount = IfAnyAddTableResult(
errorReportResults.Data,
usersWithPlaintextPasswords,
Metadata.Terms.TableTitles.PlaintextPasswords
);
errorReportResults.Summary = Metadata.Terms.ErrorSummary.With(new { emptyCount, plaintextCount });
return(errorReportResults);
}
private ReportResults CompileResults(params ConsistencyResult?[] allResults)
{
var errorResults = allResults.Where(result => result != null);
if (!errorResults.Any())
{
return new ReportResults(ResultsStatus.Good)
{
Summary = Metadata.Terms.GoodSummary
}
}
;
var results = new ReportResults(ResultsStatus.Error);
foreach (var reportResult in errorResults)
{
if (reportResult != null)
{
results.Data.Add(reportResult.Data);
var tableName = reportResult.Data.Label;
var count = reportResult.Count;
results.Summary += Metadata.Terms.ErrorSummary.With(
new
{
tableName,
count
}
);
}
}
return(results);
}
}
private ReportResults CompileResults(IEnumerable <PageType> unassignedPageTypes)
{
var results = new ReportResults
{
Status = ReportResultsStatus.Good,
Summary = Metadata.Terms.NoIssuesFound,
Type = ReportResultsType.Table,
Data = new TableResult <PageType>()
{
Name = Metadata.Terms.UnassignedPageTypesTableHeader,
Rows = unassignedPageTypes
}
};
var unassignedPageTypeCount = unassignedPageTypes.Count();
if (unassignedPageTypeCount > 0)
{
results.Status = ReportResultsStatus.Warning;
results.Summary = Metadata.Terms.WarningSummary.With(new { unassignedPageTypeCount });
}
return(results);
}
public static ReportResults ExtractFromXml(string path, string qualityLevel)
{
var report = XDocument.Load(path);
var languages = report.Descendants("language");
var reportResults = new ReportResults
{
Entries = new List <Entry>(),
EvaluationComments = new List <string>(),
QualityLevel = qualityLevel
};
foreach (var language in languages)
{
var languageString = language.Attribute("name").Value;
var files = language.Descendants("file");
foreach (var file in files)
{
var fileString = file.Attribute("name").Value;
var evaluationComment = file.Attribute("evaluationComment").Value;
if (!string.IsNullOrEmpty(evaluationComment))
{
reportResults.EvaluationComments.Add(evaluationComment);
}
var segments = file.Descendants("segment");
foreach (var segment in segments)
{
var segmentId = segment.Attribute("id").Value;
var sourceContent = segment.Element("sourceContent");
var sourceContentText = new List <Tuple <string, TextType> >();
foreach (var group in sourceContent.Descendants("item"))
{
switch (group.Attribute("type").Value)
{
case "":
sourceContentText.Add(new Tuple <string, TextType>(group.Attribute("content").Value, TextType.Regular));
break;
case "FeedbackAdded":
if (sourceContent.Elements().Contains(group))
{
sourceContentText.Add(new Tuple <string, TextType>(group.Attribute("content").Value, TextType.Added));
}
else
{
sourceContentText.Add(new Tuple <string, TextType>(group.Attribute("content").Value, TextType.Regular));
}
break;
case "FeedbackDeleted":
if (sourceContent.Elements().Contains(group))
{
sourceContentText.Add(new Tuple <string, TextType>(group.Attribute("content").Value, TextType.Deleted));
}
else
{
sourceContentText.Add(new Tuple <string, TextType>(group.Attribute("content").Value, TextType.Regular));
}
break;
case "FeedbackComment":
sourceContentText.Add(new Tuple <string, TextType>(group.Attribute("content").Value, TextType.Comment));
break;
}
}
var originalTranslation = segment.Attribute("originalTranslation").Value;
var revisedTranslations = segment.Element("revisedTranslation").Elements()
.Where(e => e.Name == "group" && (e.Attribute("category") != null || e.Attribute("severity") != null));
foreach (var revisedTranslation in revisedTranslations)
{
var translation = revisedTranslation.Element("item").Attribute("content").Value;
var category = revisedTranslation.Attribute("category").Value;
var severity = revisedTranslation.Attribute("severity").Value;
var comment = revisedTranslation.Attribute("comment").Value;
var revisedTranslationText = new List <Tuple <string, TextType> >();
foreach (var rTrans in segment.Element("revisedTranslation").Descendants().Where(e => e.Name == "item"))
{
switch (rTrans.Attribute("type").Value)
{
case "":
revisedTranslationText.Add(
new Tuple <string, TextType>(rTrans.Attribute("content").Value, TextType.Regular));
break;
case "FeedbackAdded":
if (revisedTranslation.Elements().Contains(rTrans))
{
revisedTranslationText.Add(
new Tuple <string, TextType>(rTrans.Attribute("content").Value, TextType.Added));
}
else
{
revisedTranslationText.Add(
new Tuple <string, TextType>(rTrans.Attribute("content").Value, TextType.Regular));
}
break;
case "FeedbackDeleted":
if (revisedTranslation.Elements().Contains(rTrans))
{
revisedTranslationText.Add(
new Tuple <string, TextType>(rTrans.Attribute("content").Value, TextType.Deleted));
}
else
{
revisedTranslationText.Add(
new Tuple <string, TextType>(rTrans.Attribute("content").Value, TextType.Regular));
}
break;
case "FeedbackComment":
revisedTranslationText.Add(
new Tuple <string, TextType>(rTrans.Attribute("content").Value, TextType.Comment));
break;
}
}
var entry = new Entry(languageString, fileString, segmentId, originalTranslation, revisedTranslationText,
sourceContentText, category, severity, comment, translation);
reportResults.Entries.Add(entry);
}
}
}
}
return(reportResults);
}
public static void WriteExcel(string path, ReportResults reportResults)
{
using (var fs = new FileStream(path, FileMode.Create))
{
fs.Write(PluginResources.template, 0, PluginResources.template.Length);
}
var rows = reportResults.Entries;
var rowsArray = rows.ToArray();
var rowsCollection = rows.Select(r => r.GetArray()).ToArray();
var wb = new XLWorkbook(path);
var ws = wb.Worksheet("Evaluation details_input");
for (var i = 0; i < rows.Count; i++)
{
for (var j = 0; j < rowsCollection[i].Length; j++)
{
ws.Row(i + 4).Cell(j + 1).Value = rowsCollection[i][j];
}
var cell = ws.Cell(i + 4, 5);
var entry = rowsArray[i].RevisedTranslation;
for (var k = 0; k < entry.Count; k++)
{
cell.RichText.AddText(entry[k].Item1);
switch (entry[k].Item2)
{
case TextType.Added:
cell.RichText.ToArray()[k].SetFontColor(XLColor.GreenPigment);
cell.RichText.ToArray()[k].SetUnderline();
break;
case TextType.Deleted:
cell.RichText.ToArray()[k].SetFontColor(XLColor.Red);
cell.RichText.ToArray()[k].SetStrikethrough(true);
break;
case TextType.Regular:
continue;
case TextType.Comment:
cell.RichText.ToArray()[k].SetFontColor(XLColor.Blue);
cell.RichText.ToArray()[k].SetBold();
break;
}
}
cell = ws.Cell(i + 4, 3);
entry = rowsArray[i].SourceContent;
for (var k = 0; k < entry.Count; k++)
{
cell.RichText.AddText(entry[k].Item1);
switch (entry[k].Item2)
{
case TextType.Added:
cell.RichText.ToArray()[k].SetFontColor(XLColor.GreenPigment);
cell.RichText.ToArray()[k].SetUnderline();
break;
case TextType.Deleted:
cell.RichText.ToArray()[k].SetFontColor(XLColor.Red);
cell.RichText.ToArray()[k].SetStrikethrough(true);
break;
case TextType.Regular:
continue;
case TextType.Comment:
cell.RichText.ToArray()[k].SetFontColor(XLColor.Blue);
cell.RichText.ToArray()[k].SetBold();
break;
}
}
}
GenerateInitialReportSheet(reportResults, wb);
GenerateFinalReportSheet(wb);
wb.CalculateMode = XLCalculateMode.Auto;
wb.Save();
var spreadsheet = SpreadsheetDocument.Open(path, true);
AddGradient(spreadsheet, "B6B6B6", "FFFF0000", "FFFFC000");
AddGradient(spreadsheet, "B6B6B7", "FFFFC000", "FF009B00");
spreadsheet.Save();
spreadsheet.Close();
}
