/// <summary>
/// Throws an exception if it has any assertion results.
/// </summary>
public void Assert()
{
if (Results.Any())
{
throw new AssertionFailedException(this);
}
}
private void TripleRetracted(object sender, TripleEventArgs args)
{
if (args.Triple.Predicate.Equals(Vocabulary.Result))
{
Conforms = !Results.Any();
}
}
public TreeNode ConsolidateLeaves(Func <NodeResult[], object> summationFunction = null)
{
if (summationFunction == null)
{
summationFunction = DefaultSummations;
}
foreach (var item in Children)
{
item.ConsolidateLeaves(summationFunction);
}
var keys = Children.SelectMany(x => x.Results).Select(x => x.Key).Distinct().ToArray();
foreach (string key in keys)
{
// Don't bother summing values that don't exist at this level
if (!Results.Any(x => x.Key == key))
{
continue;
}
var results = new List <NodeResult>();
foreach (var item in Children)
{
var result = item.Results.Single(x => x.Key == key);
results.Add(result);
}
// Set the summed value
Results.Single(x => x.Key == key).Value = summationFunction.Invoke(results.ToArray());
}
return(this);
}
private void OnLibraryUpdated(Track track)
{
if (Results != null && Results.Any())
{
OnSearch();
}
}
private bool CanSwitchPage()
{
var canExecute = (Results != null && Results.Any()) &&
TotalPagesCount > 1;
return(canExecute);
}
private void Query()
{
Contract.Requires(Results != null);
Contract.Ensures(Results.Any(ftr => ftr == null) == false);
Results.Clear();
if (ScriptText == null || string.IsNullOrEmpty(SearchText))
{
FIRE();
return;
}
int res = -1;
int index = 0;
while ((res = ScriptText.IndexOf(SearchText, res + 1, StringComparison.CurrentCultureIgnoreCase)) >= 0)
{
Results.Add(new FoundTextResult(index++)
{
StartOffset = res, EndOffset = res + SearchText.Length
});
}
_activeResultIndex = 0;
FIRE();
}
private void AssertCompetitorsExist()
{
if (!Results.Any())
{
throw new InvalidOperationException("No competitors available.");
}
}
private void UpdateResults(List <ResultViewModel> newResults, CancellationToken token = default)
{
lock (_collectionLock)
{
// update UI in one run, so it can avoid UI flickering
Results.Update(newResults, token);
if (Results.Any())
{
SelectedItem = Results[0];
}
}
switch (Visbility)
{
case Visibility.Collapsed when Results.Count > 0:
Margin = new Thickness {
Top = 8
};
SelectedIndex = 0;
Visbility = Visibility.Visible;
break;
case Visibility.Visible when Results.Count == 0:
Margin = new Thickness {
Top = 0
};
Visbility = Visibility.Collapsed;
break;
}
}
private void OnDeserialized(StreamingContext context)
{
if (Results.Any())
{
Results.SetKeysToNegative();
TransferredResults = true;
}
}
public MultiResult(IParser parser, Location location, ISequenceCheckpoint startCheckpoint, IEnumerable <IResultAlternative <TOutput> > results, IReadOnlyList <object>?data = null)
{
Parser = parser;
Results = results.ToList();
Success = Results.Any(r => r.Success);
Location = location;
StartCheckpoint = startCheckpoint;
_data = data;
}
private void OnSearch()
{
Results = _trackSearchService.GetTracks(this);
if (!Results.Any())
{
_messenger.Send(new ShowDialogMessage(_messenger, MessageType.Info, "Library Search", "The search criteria did not return any results"));
}
}
public void Calculate()
{
if (Results.Any())
{
base.Calculate(Results);
SymbolsSum = Results.Sum(x => x.Value.SymbolsCnt);
AvgTime = TimeSpan.FromSeconds(Results.Average(x => x.Value.Time.TotalSeconds));
AvgRealPlace = Results.Average(x => x.Value.RealPlace);
var notNullCalcPlaceResults = Results.Where(x => x.Value.CalculatedPlace.HasValue);
if (notNullCalcPlaceResults.Any())
{
AvgCalculatedPlace = notNullCalcPlaceResults.Average(x => x.Value.CalculatedPlace.Value);
}
}
for (int i = 1; i <= RacesCreated; i++)
{
if (!base.Results.ContainsKey(i))
{
continue;
}
if (base.Results[i].Speed == MaxSpeed)
{
base.Results[i].IsBestSpeed = true;
}
else if (base.Results[i].Speed == MinSpeed)
{
base.Results[i].IsWorstSpeed = true;
}
if (base.Results[i].ErRate == MinErRate)
{
base.Results[i].IsBestErRate = true;
}
else if (base.Results[i].ErRate == MaxErRate)
{
base.Results[i].IsWorstErRate = true;
}
if (base.Results[i].ErCnt == MinErCnt)
{
base.Results[i].IsBestErCnt = true;
}
else if (base.Results[i].ErCnt == MaxErCnt)
{
base.Results[i].IsWorstErCnt = true;
}
base.Results[i].RelativeSpeed = base.Results[i].Speed / AvgSpeed;
}
IsCalculated = true;
}
public string GetMostRecentTime()
{
if (MostRecentTime == null)
{
if (Results.Any())
{
MostRecentTime = Results.OrderByDescending(x => x.TestResult.Time).First().TestResult.Time;
}
}
return(MostRecentTime);
}
public void AddTestResult(TestResult result)
{
if (Results == null)
{
Results = new List <TestResult>();
}
// If the address is not already in the list
if (!Results.Any(x => x.PrimaryKey == result.PrimaryKey))
{
Results.Add(result);
result.ReportResult = this;
}
}
private async Task ProcessSearch(string query)
{
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (SfdcConfig.AppSearchMode != SearchMode.UseSearchPage)
{
return;
}
var suggestedMedia = await _searchContentDataService.FilterMediaLinkByQuery(_mediaLinks, query);
Results = suggestedMedia.Select(m => new SearchItemViewModel(m, IsInternalModeEnable)).Where(si => si.IsVisible).ToList();
NoResultsMessageVisible = Results.Any() == false;
NoResultsText = $"No results for query: {query}";
}
private void Find(PathEvaluatorControlViewModel vm, object parameter)
{
Results = string.Empty;
try
{
var input = JToken.Parse(Source);
var results = input.SelectTokens(Expression);
Results = string.Join(Environment.NewLine, results.Select(x => x.ToString()));
ErrorMessage = Results.Any() ? null :"Nothing found.";
}
catch (Exception e)
{
ErrorMessage = $"Search failed. {e.Message}";
}
}
private void Find(JsonPathEvaluatorTabViewModel vm, object parameter)
{
try
{
var input = JToken.Parse(Source);
var results = input.SelectTokens(Expression);
Results = results.Select(x => x.ToString());
Message = Results.Any() ? "" : " Nothing found. ";
}
catch (Exception e)
{
Results = Enumerable.Empty <string>();
Message = $" Failed to search using the expression. {e.Message} ";
}
}
public virtual void FindWinner()
{
if (IsGameEnd)
{
return;
}
if (IsGameWon())
{
IsGameEnd = true;
}
if (!Results.Any(f => f == MarkType.Free))
{
Winner = MarkType.Nought;
IsGameEnd = true;
}
}
public TrackReportVm(TrackVm source,
IUiLoggingService loggingService,
IUiService uiService,
SrtmRepository srtmRepository,
ITrackReportExporter[] reportExporters,
Func <TrackVm, TrackReportItemVm> reportItemGenerator,
TrekplannerConfiguration configuration)
{
_loggingService = loggingService;
_uiService = uiService;
_srtmRepository = srtmRepository;
_reportExporters = reportExporters;
_reportItemGenerator = reportItemGenerator;
_configuration = configuration;
Source = source;
Totals = new TrackReportTotalsVm(this);
Chart = new TrackChartVm(this);
ExportCommand = new DelegateCommand(o => Results.Any(), ExportReportAsync);
}
/// <summary>
/// This methods ensure that the time arrays in all <see cref="IndividualResults" /> are using the reference defined in
/// the parent <see cref="SimulationResults" />.
/// Also results will be reorderd by Individual Id
/// </summary>
public void SynchronizeResults()
{
if (!Results.Any())
{
return;
}
//Retrieve time array from the first individual that will be used as reference
var firstTime = Results.ElementAt(0).Time;
Results.Time = firstTime;
foreach (var individualResults in Results)
{
if (individualResults.Time.Values.IsEqual(firstTime.Values))
{
individualResults.Time = firstTime;
}
individualResults.UpdateQuantityTimeReference();
}
Results.ReorderByIndividualId();
}
public bool CanOk()
{
return(Results.Any(x => x.IsIncluded == true));
}
public async Task InitAsync(ApplicationDbContext dbContext, bool modelStateIsValid = true)
{
try
{
Subjects = Subjects?.Any() == true ? Subjects :
await dbContext.Subjects
.Where(s => s.Id < 14)
.OrderBy(s => s.Id)
.Select(s => new PropertyDto
{
Id = s.Id,
Name = s.Name,
Score = s.Id == 6 ? (int?)100 : null
}).ToListAsync();
var subjectNotInFilter = await dbContext.Subjects
.Where(s => s.Id > 13)
.OrderBy(s => s.Id)
.Select(s => new PropertyDto
{
Id = s.Id,
Name = s.Name,
Score = 100
}).ToListAsync();
var filterSubject = Subjects.Where(s => s.Score > 0)
.ToList();
var hasValues = filterSubject.Any();
filterSubject.AddRange(subjectNotInFilter);
var subjectIds = filterSubject
.Select(s => s.Id)
.ToList();
if (hasValues && modelStateIsValid)
{
var query = dbContext.Directions
.Include(d => d.EducationalDivision.University)
.Include(d => d.SubjectScores)
.ThenInclude(ss => ss.Subject)
.Where(d => d.SubjectScores.All(ss => subjectIds.Contains(ss.SubjectId)))
.Where(d => d.SubjectScores.Any())
.Where(d => d.SubjectScores.All(ss =>
ss.SubjectId == Subjects[0].Id && Subjects[0].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[1].Id && Subjects[1].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[2].Id && Subjects[2].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[3].Id && Subjects[3].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[4].Id && Subjects[4].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[5].Id && Subjects[5].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[6].Id && Subjects[6].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[7].Id && Subjects[7].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[8].Id && Subjects[8].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[9].Id && Subjects[9].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[10].Id && Subjects[10].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[11].Id && Subjects[11].Score >= ss.MinimumScore ||
ss.SubjectId == Subjects[12].Id && Subjects[12].Score >= ss.MinimumScore
));
var directions = await query
.ToListAsync();
Results = await directions.GroupBy(d => d.EducationalDivision.University, (u, dir) => new UniversityDto
{
UniversityName = u.Name,
UniversityUrl = u.Page,
Logo = u.logo,
Color = u.Color,
Divisions = dir.GroupBy(x => x.EducationalDivision, (d, dir) => new DivisionDto
{
DivisionName = d.Name,
DivisionUrl = d.PageUrl,
Directions = dir.Select(d => new DirectionDto
{
DirectionName = d.Name,
DirectionUrl = d.PageUrl,
SubjectScores = d.SubjectScores.Select(x => $"{x.Subject.Name}({x.MinimumScore})").ToList(),
BudgetPlacesCount = d.BudgetPlacesCount,
Form = d.EducationalForm,
Level = d.Level,
logo = d.EducationalDivision.University.logo,
PaidPlacesCount = d.PaidPlacesCount,
PeriodOfStudy = d.PeriodOfStudy,
Price = d.Price,
Code = d.Code
}).ToList()
}).ToList()
}).ToListAsync();
}
if (Results?.Any() != true)
{
Universities = await dbContext.Universities
.Include(u => u.Divisions)
.ThenInclude(d => d.EducationalDirections)
.Select(x => new UniversityDto
{
Logo = x.logo,
Color = x.Color,
DirectionsCount = x.Divisions.SelectMany(d => d.EducationalDirections).Count(),
DivisionsCount = x.Divisions.Count,
UniversityName = x.Name,
UniversityUrl = x.Page
}).ToListAsync();
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Checks if any results have the supplied ResultStatus
/// </summary>
/// <param name="status"></param>
/// <returns></returns>
public bool Any(ResultStatus status)
{
return(Results.Any(r => r.Status == status));
}
private bool CanAddToInvestigation()
{
return(Results.Any(i => i.IsSelected));
}
public bool ResultsContain(string resultTitle)
{
return(Results.Any(a => a.Text == resultTitle));
}
public T First() => Results.Any() ? Results.First() : default;
void StartReading()
{
var searchOptions = Options;
Results.Clear();
StatusName = _infoService.GetSearchStatus(SearchStatus.Initializing);
ItemsReady = false;
Stats.IsReady = false;
Stats.FilesAnalyzed = "0/0";
Stats.PagesAnalyzed = 0;
Stats.ExecutionTime = "...";
var fileCounter = 0;
var watch = System.Diagnostics.Stopwatch.StartNew();
if (!string.IsNullOrWhiteSpace(searchOptions.Keyword))
{
List <string> discoveredFiles = searchOptions.UseSubfolders ? Directory.GetFiles(searchOptions.Path, "*.pdf", SearchOption.AllDirectories).ToList()
: Directory.GetFiles(searchOptions.Path, "*.pdf").ToList();
if (discoveredFiles == null)
{
System.Diagnostics.Debug.WriteLine("No files found... ");
return;
}
StatusName = _infoService.GetSearchStatus(SearchStatus.Running);
ResultInfo = _infoService.GetSearchInfo(SearchInfo.Init);
Stats.FilesAnalyzed = "0/" + discoveredFiles.Count.ToString();
foreach (var pdf in discoveredFiles)
{
System.Diagnostics.Debug.WriteLine("Checking " + pdf);
using var docReader = _docLib.GetDocReader(pdf, _optionService.TranslatePrecision(searchOptions.SelectedPrecisionOCR).Item1);
for (var i = 0; i < docReader.GetPageCount(); i++)
{
using var pageReader = docReader.GetPageReader(i);
var parsedText = pageReader.GetText().ToString();
if (searchOptions.UseOCR && string.IsNullOrWhiteSpace(parsedText))
{
var rawBytes = pageReader.GetImage(_optionService.TranslatePrecision(searchOptions.SelectedPrecisionOCR).Item2);
var width = pageReader.GetPageWidth();
var height = pageReader.GetPageHeight();
using var bmp = new Bitmap(width, height, _optionService.TranslatePrecision(searchOptions.SelectedPrecisionOCR).Item3);
AddBytes(bmp, rawBytes);
using var stream = new MemoryStream();
bmp.Save(stream, _optionService.TranslatePrecision(searchOptions.SelectedPrecisionOCR).Item4);
parsedText = ImageToText(stream.ToArray(), searchOptions.SelectedLanguageOCR, searchOptions.SelectedPrecisionOCR);
}
SearchPage(parsedText, searchOptions.Keyword, pdf, i, searchOptions.CaseSensitive);
Stats.PagesAnalyzed += 1;
}
fileCounter += 1;
Stats.FilesAnalyzed = fileCounter.ToString() + "/" + discoveredFiles.Count.ToString();
}
}
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
System.Diagnostics.Debug.WriteLine("Total execution " + elapsedMs);
Stats.ExecutionTime = (elapsedMs / 1000.0).ToString() + " " + _infoService.GetSecondsString();
Stats.IsReady = true;
StatusName = _infoService.GetSearchStatus(SearchStatus.Ready);
if (!Results.Any())
{
ResultInfo = _infoService.GetSearchInfo(SearchInfo.NoResults);
ItemsReady = false;
}
}
public T Last() => Results.Any() ? Results.Last() : default;