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))); }