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(WordDocument wordDocument)
{
return(await Task.Run(
() =>
{
var forbiddenCounts = new List <Tuple <int, string> >();
var forbiddenWords = ForbiddenWords.CreateDefault();
foreach (var forbiddenWord in forbiddenWords.Words)
{
var foundForbiddenWords = wordDocument
.Words
.Where(word => word.Text.ToUpper(CultureInfo.InvariantCulture) == forbiddenWord.ToUpper(CultureInfo.InvariantCulture))
.ToList();
if (foundForbiddenWords.Any())
{
forbiddenCounts.Add(new Tuple <int, string>(foundForbiddenWords.Count, forbiddenWord));
}
}
if (forbiddenCounts.Any())
{
var overviewMessage = $"Found {forbiddenCounts.Count} forbidden Words.";
var sorted = forbiddenCounts
.OrderByDescending(w => w.Item1)
.Select(w => $"{w.Item1}: {w.Item2}")
.ToList();
return new RuleCheckResult(false, RuleName, overviewMessage, new RuleCheckResultDetails(sorted));
}
return 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 async Task <RuleCheckResult> CheckRuleAsync(WordDocument wordDocument)
{
return(await Task.Run(
() =>
{
var glossaryTable = wordDocument.Tables.Single(f => f.Caption.Entries.Any(e => e.CharacterRepresentation.EndsWith("Glossar", StringComparison.Ordinal)));
var glossaryWords = glossaryTable.Cells.Where(f => f.ColumnIndex == 1 && f.RowIndex > 1).Select(f => f.Value).ToList();
var wordsNotFound = new List <string>();
var wordsCombined = string.Join(" ", wordDocument.Select(word => word.Text));
foreach (var glossaryWord in glossaryWords)
{
var occurrences = FindOccurrences(wordsCombined, glossaryWord);
if (occurrences <= 1)
{
wordsNotFound.Add(glossaryWord);
}
}
if (wordsNotFound.Any())
{
var overviewMessage = $"Found {wordsNotFound.Count} unused Glossary Words.";
return new RuleCheckResult(false, RuleName, overviewMessage, new RuleCheckResultDetails(wordsNotFound));
}
return RuleCheckResult.CreatePassed(RuleName);
}));
}
public async Task <RuleCheckResult> CheckElementsAsync(string ruleName, string captionPrefix, IReadOnlyCollection <IElementWithCaption> elementsWithCaption)
{
return(await Task.Run(
() =>
{
var details = new List <string>();
for (var i = 1; i <= elementsWithCaption.Count; i++)
{
var expectedPrefix = $"{captionPrefix} {i}: ";
var actualText = elementsWithCaption.ElementAt(i - 1).CaptionText;
if (!actualText.StartsWith(expectedPrefix, StringComparison.Ordinal))
{
details.Add($"Expected {actualText} to start with {expectedPrefix}");
}
}
if (details.Any())
{
return new RuleCheckResult(false, ruleName, $"Found {details.Count} wrong element sortings", new RuleCheckResultDetails(details));
}
return RuleCheckResult.CreatePassed(ruleName);
}));
}
public async Task <RuleCheckResult> CheckRuleAsync(WordDocument wordDocument)
{
return(await Task.Run(
() =>
{
var shapesWithExternalLink = wordDocument.Shapes.Where(f => f.Caption.Entries.Any(e => e.CharacterRepresentation.Contains("[PIC"))).ToList();
var details = new List <string>();
for (var i = 1; i <= shapesWithExternalLink.Count; i++)
{
var expectedPicLink = $"[PIC{i}]";
var currentItem = shapesWithExternalLink[i - 1];
if (!currentItem.Caption.Entries.First().CharacterRepresentation.EndsWith(expectedPicLink, StringComparison.Ordinal))
{
details.Add($"Expected {currentItem.Caption.Entries.First().CharacterRepresentation} to end with ${expectedPicLink}");
}
}
if (details.Any())
{
return new RuleCheckResult(false, RuleName, $"Found {details.Count} elements with invalid external link", new RuleCheckResultDetails(details));
}
return RuleCheckResult.CreatePassed(RuleName);
}));
}
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 async Task <RuleCheckResult> CheckElementsAsync(string ruleName, IReadOnlyCollection <IElementWithCaption> elementsWithCaption)
{
return(await Task.Run(
() =>
{
var elementsWithoutCaption = elementsWithCaption.Where(f => string.IsNullOrEmpty(f.CaptionText)).ToList();
if (elementsWithoutCaption.Any())
{
return new RuleCheckResult(false, ruleName, $"{elementsWithoutCaption.Count} elements have no caption.", RuleCheckResultDetails.CreateEmpty());
}
return 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 async Task <RuleCheckResult> CheckRuleAsync(WordDocument wordDocument)
{
return(await Task.Run(
() =>
{
var invalidLinks = _uriCheckService.CheckInvalidUris(wordDocument.HyperLinks);
if (!invalidLinks.Any())
{
return RuleCheckResult.CreatePassed(RuleName);
}
var overviewMessage = $"Found {invalidLinks.Count} invalid Links.";
var invalidLinkUris = invalidLinks.Select(link => link.Address.AbsoluteUri).ToList();
return new RuleCheckResult(false, RuleName, overviewMessage, new RuleCheckResultDetails(invalidLinkUris));
}));
}
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)
{
if (!document.Sections.Entries.Any())
{
return(Failure(FailureNoSections));
}
var firstSection = document.Sections.Entries.First();
if (!firstSection.PageNumberDefinitions.Any())
{
return(Failure(FailureNoPageNumbers));
}
if (firstSection.PageNumberDefinitions.First().ShowFirstPageNumber)
{
return(Failure(FailurePageNumber));
}
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)));
}
