public Task <RuleCheckResult> CheckRuleAsync(IWordDocument document)
{
var shapeDescNotBelow = document
.Shapes
.Where(f => f.Description.Position != Position.Below)
.ToList();
if (shapeDescNotBelow.Any())
{
var str = string.Join(
", ",
shapeDescNotBelow.Select(
f =>
{
var plainDesc = f.Description.PlainDescription;
if (string.IsNullOrEmpty(plainDesc))
{
plainDesc = NoDescription;
}
return(plainDesc);
}));
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, str)));
}
return(Task.FromResult(RuleCheckResult.CreatePassed(RuleName)));
}
public async Task <RuleCheckResult> CheckRuleAsync(IWordDocument document)
{
using var webClient = new HeadWebClient();
var invalidUris = new List <Uri>();
foreach (var link in document.ExternalHyperLinks)
{
try
{
await webClient.DownloadDataTaskAsync(link.Uri);
}
catch (WebException)
{
invalidUris.Add(link.Uri);
}
}
if (!invalidUris.Any())
{
return(RuleCheckResult.CreatePassed(RuleName));
}
var missingUrls = string.Join(", ", invalidUris.Select(f => f.AbsoluteUri));
return(RuleCheckResult.CreateFailure(RuleName, missingUrls));
}
public Task <RuleCheckResult> CheckRuleAsync(IWordDocument document)
{
if (!CheckMatching(document, document.Tables.Count) || !CheckMatching(document, document.ListOfTables.Entries.Count))
{
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, "List of tables not matching")));
}
return(Task.FromResult(RuleCheckResult.CreatePassed(RuleName)));
}
public Task <RuleCheckResult> CheckRuleAsync(IWordDocument document)
{
var tableDescsNotAbove = document
.Tables
.Where(f => f.Description.Position != Position.Above)
.ToList();
if (tableDescsNotAbove.Any())
{
var str = string.Join(", ", tableDescsNotAbove.Select(f => f.Description.PlainDescription));
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, str)));
}
return(Task.FromResult(RuleCheckResult.CreatePassed(RuleName)));
}
public Task <RuleCheckResult> CheckRuleAsync(IWordDocument document)
{
var words = _wordMatcher.MatchWords(document, WordPrefix);
var tables = document.Tables.Where(f => f.Description.PlainDescription.EndsWith(TableDescriptionSuffix))
.ToList();
if (!tables.Any())
{
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, $"Table {WordPrefix} not found")));
}
if (tables.Count > 1)
{
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, $"More than one Table {WordPrefix} found")));
}
var table = tables.Single();
var tableEntries = table
.Cells
.Where(f => f.ColumnIndex == 1)
.Skip(1)
.Select(f => f.Words.Single())
.Select(f => f.Characters.Text)
.ToList();
if (words.Count != tableEntries.Count())
{
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, $"Found {words.Count} words, but {tableEntries.Count} table entries")));
}
for (var i = 0; i < words.Count; i++)
{
var word = words.ElementAt(i).Value;
var tableValue = $"[{tableEntries.ElementAt(i)}]";
if (word != tableValue)
{
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, $"Found {word} word, but {tableValue} in table")));
}
}
return(Task.FromResult(RuleCheckResult.CreatePassed(RuleName)));
}
public Task <RuleCheckResult> CheckRuleAsync(IWordDocument document)
{
var differentFonts = document
.Words
.SelectMany(f => f.Characters.Entries)
.Select(f => f.Font)
.Select(f => f.Name)
.Where(f => !_nonFonts.Contains(f))
.Distinct()
.ToList();
if (differentFonts.Count() == 1)
{
return(Task.FromResult(RuleCheckResult.CreatePassed(RuleName)));
}
var differents = string.Join(", ", differentFonts);
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, $"Found the following different Fonts: {differents}")));
}
public Task <RuleCheckResult> CheckRuleAsync(IWordDocument document)
{
var glossaryTables = document
.Tables
.Where(f => f.Description.PlainDescription.EndsWith("Glossar"))
.ToList();
if (!glossaryTables.Any())
{
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, "GlossaryTable not found")));
}
if (glossaryTables.Count > 1)
{
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, "More than one GlossaryTable found")));
}
var missingWords = new List <string>();
var glossaryTable = glossaryTables.Single();
var glossaryCells = glossaryTable.Cells.Where(f => f.RowIndex > 1 && f.ColumnIndex == 1);
foreach (var cell in glossaryCells)
{
var cellWord = string.Join(string.Empty, cell.Words.Select(f => f.Characters.Text));
if (document.Words.Count(f => f.Characters.Text == cellWord) == 1)
{
missingWords.Add(cellWord);
}
}
if (missingWords.Any())
{
var str = string.Join(", ", missingWords);
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, str)));
}
return(Task.FromResult(RuleCheckResult.CreatePassed(RuleName)));
}
public Task <RuleCheckResult> CheckRuleAsync(IWordDocument document)
{
var wrongDescriptions = new List <string>();
for (var i = 1; i <= document.Shapes.Count; i++)
{
var shape = document.Shapes.ElementAt(i - 1);
var expectedShapePrefix = $"{ShapePrefix} {i}";
if (!shape.Description.PlainDescription.StartsWith(expectedShapePrefix))
{
wrongDescriptions.Add(shape.Description.PlainDescription);
}
}
if (wrongDescriptions.Any())
{
var str = string.Join(", ", wrongDescriptions);
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, str)));
}
return(Task.FromResult(RuleCheckResult.CreatePassed(RuleName)));
}
public Task <RuleCheckResult> CheckRuleAsync(IWordDocument document)
{
var matches = _wordMatcher.MatchWords(document, ElementPrefix);
var numbers = new List <int>();
foreach (var matchingWord in matches)
{
var numStr = matchingWord.Groups.Single(f => f.Name == WordMatcher.NumberGroupName).Value;
var num = int.Parse(numStr);
numbers.Add(num);
}
for (var i = 0; i < numbers.Count; i++)
{
var expectedLinkNumber = i + 1;
if (numbers.ElementAt(i) != expectedLinkNumber)
{
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, $"{numbers.ElementAt(i)} not matching")));
}
}
return(Task.FromResult(RuleCheckResult.CreatePassed(RuleName)));
}
private static Task <RuleCheckResult> Failure(string message)
{
return(Task.FromResult(RuleCheckResult.CreateFailure(RuleName, message)));
}
