public override void Given()
{
_ulns = new List <long> {
1111111111, 1111111112, 1111111113
};
_ulnForInactivePathways = 1111111113;
// Seed Tlevel data for pearson
SeedTestData(EnumAwardingOrganisation.Pearson, true);
// Seed Registrations Data
var registrations = SeedRegistrationsData(_ulns);
var tqPathwayAssessmentsSeedData = new List <TqPathwayAssessment>();
foreach (var registration in registrations)
{
var seedPathwayAssessmentsAsActive = registration.UniqueLearnerNumber != _ulnForInactivePathways;
tqPathwayAssessmentsSeedData.AddRange(GetPathwayAssessmentsDataToProcess(registration.TqRegistrationPathways.ToList(), seedPathwayAssessmentsAsActive));
}
var pathwayAssessments = SeedPathwayAssessmentsData(tqPathwayAssessmentsSeedData);
_pathwayResults = SeedPathwayResultsData(GetPathwayResultsDataToProcess(pathwayAssessments));
ResultRepositoryLogger = new Logger <ResultRepository>(new NullLoggerFactory());
ResultRepository = new ResultRepository(ResultRepositoryLogger, DbContext);
}
public override void Given()
{
CreateMapper();
SeedTestData(EnumAwardingOrganisation.Pearson);
// Dependencies
PathwayResultRepositoryLogger = new Logger <GenericRepository <TqPathwayResult> >(new NullLoggerFactory());
PathwayResultRepository = new GenericRepository <TqPathwayResult>(PathwayResultRepositoryLogger, DbContext);
AssessmentSeriesRepositoryLogger = new Logger <GenericRepository <AssessmentSeries> >(new NullLoggerFactory());
AssessmentSeriesRepository = new GenericRepository <AssessmentSeries>(AssessmentSeriesRepositoryLogger, DbContext);
TlLookupRepositoryLogger = new Logger <GenericRepository <TlLookup> >(new NullLoggerFactory());
TlLookupRepository = new GenericRepository <TlLookup>(TlLookupRepositoryLogger, DbContext);
ResultRepositoryLogger = new Logger <ResultRepository>(new NullLoggerFactory());
ResultRepository = new ResultRepository(ResultRepositoryLogger, DbContext);
ResultServiceLogger = new Logger <ResultService>(new NullLoggerFactory());
// Service
ResultService = new ResultService(AssessmentSeriesRepository, TlLookupRepository, ResultRepository, PathwayResultRepository, ResultMapper, ResultServiceLogger);
_resultRecords = new ResultsBuilder().BuildValidList();
}
private IList <Result> GetResults(ClassEntity classContract, ResultRepository resultRepository)
{
if (classContract.NoTimePresentation)
{
var results = resultRepository.Get(_eventRaceId, _eventId, classContract.Id);
var resultContracts = results.ToContractsWithoutTimes();
return(resultContracts);
}
else
{
var results = resultRepository.GetWithSplitTimes(_eventRaceId, _eventId, classContract.Id);
IList <Result> resultContracts;
if (classContract.Courses.Count == 1 && classContract.Courses.Single().SplitControls.Count > 0)
{
resultContracts = results.ToContractsWithSplitTimes(classContract.Courses.Single());
}
else
{
resultContracts = results.ToContracts();
}
if (!classContract.NoTimePresentation)
{
resultContracts = ResultOrderer.OrderByStatusAndTime(resultContracts);
resultContracts = OrdinalCalculator.AddOrdinal(resultContracts);
resultContracts = ResultOrderer.OrderBySplitTimes(resultContracts);
}
return(resultContracts);
}
}
public override void Given()
{
// Parameters
_aoUkprn = 10011881;
_ulns = new Dictionary <long, RegistrationPathwayStatus> {
{ 1111111111, RegistrationPathwayStatus.Active }, { 1111111112, RegistrationPathwayStatus.Active }, { 1111111113, RegistrationPathwayStatus.Withdrawn }
};
// Registrations seed
SeedTestData(EnumAwardingOrganisation.Pearson, true);
var registrations = SeedRegistrationsDataByStatus(_ulns, TqProvider);
// Assessments seed
var tqPathwayAssessmentsSeedData = new List <TqPathwayAssessment>();
foreach (var registration in registrations.Where(x => x.UniqueLearnerNumber != 1111111111))
{
var hasHitoricData = new List <long> {
1111111112
};
var isHistoricAssessent = hasHitoricData.Any(x => x == registration.UniqueLearnerNumber);
var isLatestActive = _ulns[registration.UniqueLearnerNumber] != RegistrationPathwayStatus.Withdrawn;
tqPathwayAssessmentsSeedData.AddRange(GetPathwayAssessmentsDataToProcess(registration.TqRegistrationPathways.ToList(), isLatestActive, isHistoricAssessent));
}
_pathwayAssessments = SeedPathwayAssessmentsData(tqPathwayAssessmentsSeedData, false);
DbContext.SaveChanges();
// TestClass
ResultRepositoryLogger = new Logger <ResultRepository>(new NullLoggerFactory());
ResultRepository = new ResultRepository(ResultRepositoryLogger, DbContext);
}
public ServiceImpl(UserRepository userRepo, ResultRepository resultRepo, ParticipantRepository participantRepo, StageRepository stageRepo)
{
this.userRepo = userRepo;
this.resultRepo = resultRepo;
this.participantRepo = participantRepo;
this.stageRepo = stageRepo;
loggedClients = new Dictionary <int, IObserver>();
}
public ResultController()
{
var entities = new Entities.Entities();
ResultRepository = new ResultRepository(entities);
EvaluationRepository = new EvaluationRepository(entities);
PupilRepository = new PupilRepository(entities);
}
public bool ClassHasNewResults(int competitionClassId, DateTime lastCheckTime)
{
using (var connection = new MySqlConnection(_databaseConfiguration.GetConnectionString()))
{
var resultRepository = new ResultRepository(connection);
return(resultRepository.HasNewResults(_eventId, _eventRaceId, competitionClassId, lastCheckTime));
}
}
public async Task WhenAsync(long aoUkprn, int profileId)
{
if (_result != null)
{
return;
}
_result = await ResultRepository.GetResultsAsync(aoUkprn, profileId);
}
public async Task WhenAsync()
{
if (_result != null)
{
return;
}
_result = await ResultRepository.GetBulkResultsAsync(_aoUkprn, _ulns.Keys);
}
public void Execute(IJobExecutionContext context)
{
using (var testRepository = new TestRepository())
{
using (var codeRepository = new CodeRepository())
{
using (var resultRepository = new ResultRepository())
{
ICompiler compiler = new CSharpCompiler();
var processBuilder = new ProcessBuilder();
var runer = new Runer();
List<Code> codes = codeRepository.ExtractAll().ToList();
codes.ForEach(item =>
{
if (!compiler.TryCompile(item.Text, @"F://test.exe"))
{
resultRepository.Add(new TestDatabase.Entities.Result(item.Id, "compilation error"));
}
else
{
var tests = testRepository.GetTestsByTaskId(item.TaskId).ToList();
for (var i = 0; i < tests.Count; i++)
{
var proc = processBuilder.Create(@"F://test.exe");
string output;
try
{
if (!runer.TryGetResult(proc, tests[i].Input, out output))
{
resultRepository.Add(new TestDatabase.Entities.Result(item.Id,
"out of time on test " + (i + 1).ToString()));
return;
}
}
catch (Exception e)
{
resultRepository.Add(new TestDatabase.Entities.Result(item.Id,
"out of memory on test " + (i + 1).ToString()));
return;
}
if (output == tests[i].Output) continue;
resultRepository.Add(new TestDatabase.Entities.Result(item.Id,
"wrong answer on test " + (i + 1).ToString()));
return;
}
resultRepository.Add(new TestDatabase.Entities.Result(item.Id,
"success"));
}
});
}
}
}
}
public RunCommand(
ResultRepository resultRepository,
ChatRepository chatRepository,
UserRepository userRepository,
CitationRepository citationRepository)
{
_resultRepository = resultRepository;
_chatRepository = chatRepository;
_userRepository = userRepository;
_citationRepository = citationRepository;
}
public IList <Result> Finish(int limit)
{
using (var connection = new MySqlConnection(_databaseConfiguration.GetConnectionString()))
{
var resultRepository = new ResultRepository(connection);
return(resultRepository
.GetFinish(_eventId, _eventRaceId, limit)
.ToContracts());
}
}
public SqlRunner(SqlCredentialReader credentialReader, SqlQueryReader queryReader,
SessionRepository sessionRepository,
ResultRepository resultRepository,
IEnumerable <IServerDriver> drivers)
{
_credentialReader = credentialReader;
_queryReader = queryReader;
_sessionRepository = sessionRepository;
_resultRepository = resultRepository;
_drivers = drivers;
}
public SqlQueriesController(SqlQueryReader sqlQueryReader,
SqlRunner runner,
ResultRepository resultRepository,
SessionRepository sessionRepository,
Tabularizer tabularizer)
{
_sqlQueryReader = sqlQueryReader;
_runner = runner;
_resultRepository = resultRepository;
_sessionRepository = sessionRepository;
_tabularizer = tabularizer;
}
public IEnumerable <ExperimentReport> GetAll()
{
return(ResultRepository
.GetWith(e => e.Experiment)
#if IN_MEMORY
.Select(r => {
r.Experiment = ExperimentRepository.Get(r.ExperimentId);
return r;
})
#endif
.Select(r => Mapper.Map <ExperimentReport>(r)));
}
public ViewResult Result(Result guestResponse)
{
if (ModelState.IsValid)
{
ResultRepository.AddResponse(guestResponse);
return(View("Thanks", "Result"));
}
else
{
//there is a validation error
return(View());
}
}
public CompetitionClass GetClass(int competitionClassId)
{
using (var connection = new MySqlConnection(_databaseConfiguration.GetConnectionString()))
{
var classRepository = new ClassRepository(connection);
var resultRepository = new ResultRepository(connection);
var classEntity = classRepository.GetWithSplitControls(_eventId, _eventRaceId, competitionClassId);
var classContract = classEntity.ToContract();
classContract.Results = GetResults(classEntity, resultRepository);
return(classContract);
}
}
public override void Given()
{
// Create mapper
CreateMapper();
// Parameters
_ulns = new Dictionary <long, RegistrationPathwayStatus> {
{ 1111111111, RegistrationPathwayStatus.Withdrawn }, { 1111111112, RegistrationPathwayStatus.Active }, { 1111111113, RegistrationPathwayStatus.Active }
};
// Registrations seed
SeedTestData(EnumAwardingOrganisation.Pearson, true);
_registrations = SeedRegistrationsData(_ulns, TqProvider);
// Assessments seed
var tqPathwayAssessmentsSeedData = new List <TqPathwayAssessment>();
foreach (var registration in _registrations.Where(x => x.UniqueLearnerNumber != 1111111111))
{
var hasHitoricData = new List <long> {
1111111112
};
var isHistoricAssessent = hasHitoricData.Any(x => x == registration.UniqueLearnerNumber);
var isLatestActive = _ulns[registration.UniqueLearnerNumber] != RegistrationPathwayStatus.Withdrawn;
tqPathwayAssessmentsSeedData.AddRange(GetPathwayAssessmentsDataToProcess(registration.TqRegistrationPathways.ToList(), isLatestActive, isHistoricAssessent));
}
_pathwayAssessments = SeedPathwayAssessmentsData(tqPathwayAssessmentsSeedData, false);
DbContext.SaveChanges();
PathwayResultRepositoryLogger = new Logger <GenericRepository <TqPathwayResult> >(new NullLoggerFactory());
PathwayResultRepository = new GenericRepository <TqPathwayResult>(PathwayResultRepositoryLogger, DbContext);
AssessmentSeriesRepositoryLogger = new Logger <GenericRepository <AssessmentSeries> >(new NullLoggerFactory());
AssessmentSeriesRepository = new GenericRepository <AssessmentSeries>(AssessmentSeriesRepositoryLogger, DbContext);
TlLookupRepositoryLogger = new Logger <GenericRepository <TlLookup> >(new NullLoggerFactory());
TlLookupRepository = new GenericRepository <TlLookup>(TlLookupRepositoryLogger, DbContext);
ResultRepositoryLogger = new Logger <ResultRepository>(new NullLoggerFactory());
ResultRepository = new ResultRepository(ResultRepositoryLogger, DbContext);
ResultServiceLogger = new Logger <ResultService>(new NullLoggerFactory());
ResultService = new ResultService(AssessmentSeriesRepository, TlLookupRepository, ResultRepository, PathwayResultRepository, ResultMapper, ResultServiceLogger);
}
public UnitOfWork(UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, RoleManager <IdentityRole> roleManager, HighSchoolContext context)
{
/* Aggregates */
Account = new AccountRepository(userManager, signInManager, roleManager);
Class = new ClassRepository(context);
Result = new ResultRepository(context);
//Conduct = new ConductRepository(context);
/* Standalone Aggregates */
Teacher = new TeacherRepository(context);
TeachingAssignment = new TeachingAssignmentRepository(context);
Subject = new SubjectRepository(context);
Student = new StudentRepository(context);
Semester = new SemesterRepository(context);
_context = context;
}
public State PushResult(TaskResult result)
{
ResultRepository resultRepo = new ResultRepository();
HostRepository hostRepo = new HostRepository();
TaskRepository taskRepo = new TaskRepository();
if (resultRepo.Get(result.HostId, result.TaskId, result.PartId) != null)
{
return(new State()
{
IsError = true, Message = "Result was already pushed!"
});
}
if (hostRepo.Get(result.HostId) == null)
{
return(new State()
{
IsError = true, Message = "There is no any host with this id!"
});
}
if (taskRepo.Get(result.HostId, result.TaskId) == null)
{
return(new State()
{
IsError = true, Message = "There is no any task with this id for this host!"
});
}
resultRepo.Create(new TaskResultEntity
{
HostId = result.HostId,
TaskId = result.TaskId,
PartId = result.PartId,
//Array = result.Data.Array,
Height = result.Data.Height,
Width = result.Data.Width,
StepFrom = result.StepFrom,
StepTo = result.StepTo
});
resultRepo.Save();
return(new State()
{
IsError = false, Message = "Push was succesed complete!"
});
}
public UnitOfWork(ApplicationContext context)
{
_context = context;
_context.Configuration.AutoDetectChangesEnabled = false;
Answers = new AnswerRepository(_context);
Questions = new QuestionRepository(_context);
Results = new ResultRepository(_context);
Tests = new TestRepository(_context);
Themes = new ThemeRepository(_context);
UserInfoes = new UserInfoRepository(_context);
TempResults = new TempResultRepository(_context);
UserQuestions = new UserQuestionsRepository(_context);
UserAnswers = new UserAnswersRepository(_context);
ApplicationRoleManagers = new ApplicationRoleManager
(new RoleStore <ApplicationRole>(_context));
ApplicationUserManagers = new ApplicationUserManager
(new UserStore <ApplicationUser>(_context));
}
public void GetResultsGetsResults()
{
//arrange
//configure the context
var options = new DbContextOptionsBuilder <DatLib.Entities.ecgbhozpContext>()
.UseInMemoryDatabase("GetResultsGetsResults")
.Options;
using var arrangeContext = new DatLib.Entities.ecgbhozpContext(options);
int resultId = 1;
int score = 5;
int takerId = 1;
int titleId = 1;
var resultEnt = new DatLib.Entities.Result
{
ResultId = resultId,
Score = score,
TakerId = takerId,
TitleId = titleId
};
arrangeContext.Result.Add(resultEnt);
arrangeContext.SaveChanges();
using var actContext = new DatLib.Entities.ecgbhozpContext(options);
var repo = new ResultRepository(actContext /*, new NullLogger<UserRepository>()*/);
//act
List <LogLib.Models.Result> actual = repo.GetResults(resultId).ToList();
//assert
Assert.NotEmpty(actual);
}
public void Save(ExperimentReport report)
{
ResultRepository.Add(Mapper.Map <ExperimentResult>(report));
}
public ResultController(ResultRepository resultRepository)
{
this.resultRepository = resultRepository;
}
public override void Execute()
{
if (string.IsNullOrEmpty(ExecutorParameters.TargetsFilePath))
{
throw new ApplicationException("Processing failed. TargetsFilePath is empty. Check your parameter file.");
}
if (!File.Exists(ExecutorParameters.TargetsFilePath))
{
throw new FileNotFoundException("File not found error for the TargetsFilePath. Check your parameter file for " + ExecutorParameters.TargetsFilePath);
}
TargetedResultFromTextImporter resultImporter = new UnlabelledTargetedResultFromTextImporter(ExecutorParameters.TargetsFilePath);
var allresults = resultImporter.Import();
var resultsSortedByDataset = allresults.Results.OrderBy(p => p.DatasetName);
var totalResults = resultsSortedByDataset.Count();
ResultRepository.Clear();
//iterate over results
var resultCounter = 0;
foreach (var result in resultsSortedByDataset)
{
resultCounter++;
_currentResult = result;
if (result.DatasetName != _currentDatasetName)
{
if (Run != null)
{
Run.Close();
}
InitializeRun(result.DatasetName);
if (Run == null)
{
throw new ApplicationException("Error initializing dataset. (Run is null)");
}
_currentDatasetName = Run.DatasetName;
}
SetCurrentWorkflowTarget(result);
try
{
this.TargetedWorkflow.Execute();
ResultRepository.AddResult(this.TargetedWorkflow.Result);
}
catch (Exception ex)
{
var errorString = "Error on MT\t" + result.TargetID + "\tchargeState\t" + result.ChargeState + "\t" + ex.Message + "\t" + ex.StackTrace;
ReportProcessingProgress(errorString, resultCounter);
throw;
}
var progressString = "Processed " + resultCounter + " of " + totalResults;
if (_backgroundWorker != null)
{
if (_backgroundWorker.CancellationPending)
{
return;
}
}
ReportProcessingProgress(progressString, resultCounter);
}
}
public ResultController()
{
_resultRepo = new ResultRepository();
_playerRop = new PlayerRepository();
_resultsService = new ResultsService(new PlayerRepository(), new ResultRepository());
}
public async Task WhenAsync()
{
_result = await ResultRepository.GetBulkPathwayResultsAsync(_pathwayResults);
}
public void InitialSetup()
{
Repository = new ResultRepository();
CleanUp();
}
public ResultLogic()
{
repository = new ResultRepository(_context);
}
public ResultController()
{
resultRepository = new ResultRepository(dataContext);
}
public ResultController()
{
resultRepository = new ResultRepository();
}
