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));
}
_pathwayAssessments = SeedPathwayAssessmentsData(tqPathwayAssessmentsSeedData);
AssessmentRepositoryLogger = new Logger <AssessmentRepository>(new NullLoggerFactory());
AssessmentRepository = new AssessmentRepository(AssessmentRepositoryLogger, DbContext);
}
public override void Given()
{
AoUkprn = 10011881;
_ulns = new Dictionary <long, RegistrationPathwayStatus> {
{ 1111111111, RegistrationPathwayStatus.Active }, { 1111111112, RegistrationPathwayStatus.Active }, { 1111111113, RegistrationPathwayStatus.Withdrawn }
};
/// Registrations seed
SeedTestData(EnumAwardingOrganisation.Pearson, true);
_registrations = SeedRegistrationsDataByStatus(_ulns, TqProvider);
// Assessments seed
var tqPathwayAssessmentsSeedData = new List <TqPathwayAssessment>();
var tqPathwayResultsSeedData = new List <TqPathwayResult>();
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;
var pathwayAssessments = GetPathwayAssessmentsDataToProcess(registration.TqRegistrationPathways.ToList(), isLatestActive, isHistoricAssessent);
tqPathwayAssessmentsSeedData.AddRange(pathwayAssessments);;
// Build Pathway results
tqPathwayResultsSeedData.AddRange(GetPathwayResultsDataToProcess(pathwayAssessments, isLatestActive, isHistoricAssessent));
}
_pathwayAssessments = SeedPathwayAssessmentsData(tqPathwayAssessmentsSeedData, false);
SeedPathwayResultsData(tqPathwayResultsSeedData);
AssessmentRepositoryLogger = new Logger <AssessmentRepository>(new NullLoggerFactory());
AssessmentRepository = new AssessmentRepository(AssessmentRepositoryLogger, DbContext);
}
public void InitialSetup()
{
Repository = new AssessmentRepository();
Context = new StudentAssAttSysContext();
CleanUp();
}
public UnitOfWork(IAnalysisToolContext context)
{
_context = context;
Assessments = new AssessmentRepository(_context);
AssessmentSessions = new AssessmentSessionRepository(_context);
PrescribedAssessments = new PrescribedAssessmentRepository(_context);
}
public override void Given()
{
// Parameters
AoUkprn = 10011881;
_ulns = new Dictionary <long, RegistrationPathwayStatus>
{
{ 1111111111, RegistrationPathwayStatus.Active },
{ 1111111112, RegistrationPathwayStatus.Active },
{ 1111111113, RegistrationPathwayStatus.Withdrawn },
{ 1111111114, RegistrationPathwayStatus.Active },
{ 1111111115, RegistrationPathwayStatus.Active },
};
// Create mapper
CreateMapper();
// Registrations seed
SeedTestData(EnumAwardingOrganisation.Pearson, true);
_registrations = SeedRegistrationsData(_ulns, TqProvider);
// Assessments seed
var tqPathwayAssessmentsSeedData = new List <TqPathwayAssessment>();
var tqSpecialismAssessmentsSeedData = new List <TqSpecialismAssessment>();
var tqPathwayResultsSeedData = new List <TqPathwayResult>();
var industryPlacementUln = 1111111115;
foreach (var registration in _registrations.Where(x => x.UniqueLearnerNumber != 1111111111 && x.UniqueLearnerNumber != industryPlacementUln))
{
var hasHitoricData = new List <long> {
1111111112
};
var isHistoricAssessent = hasHitoricData.Any(x => x == registration.UniqueLearnerNumber);
var isLatestActive = _ulns[registration.UniqueLearnerNumber] != RegistrationPathwayStatus.Withdrawn;
var pathwayAssessments = GetPathwayAssessmentsDataToProcess(registration.TqRegistrationPathways.ToList(), isLatestActive, isHistoricAssessent);
tqPathwayAssessmentsSeedData.AddRange(pathwayAssessments);
foreach (var pathway in registration.TqRegistrationPathways)
{
tqSpecialismAssessmentsSeedData.AddRange(GetSpecialismAssessmentsDataToProcess(pathway.TqRegistrationSpecialisms.ToList(), isLatestActive, isHistoricAssessent));
}
// Build Pathway results
tqPathwayResultsSeedData.AddRange(GetPathwayResultsDataToProcess(pathwayAssessments, isLatestActive, isHistoricAssessent));
}
_pathwayAssessments = SeedPathwayAssessmentsData(tqPathwayAssessmentsSeedData, false);
_specialismAssessments = SeedSpecialismAssessmentsData(tqSpecialismAssessmentsSeedData, false);
SeedIndustyPlacementData(industryPlacementUln);
DbContext.SaveChanges();
AssessmentRepositoryLogger = new Logger <AssessmentRepository>(new NullLoggerFactory());
AssessmentSeriesRepositoryLogger = new Logger <GenericRepository <AssessmentSeries> >(new NullLoggerFactory());
AssessmentRepository = new AssessmentRepository(AssessmentRepositoryLogger, DbContext);
AssessmentSeriesRepository = new GenericRepository <AssessmentSeries>(AssessmentSeriesRepositoryLogger, DbContext);
AssessmentService = new AssessmentService(AssessmentRepository, PathwayAssessmentRepository, SpecialismAssessmentRepository, AssessmentSeriesRepository, AssessmentMapper, AssessmentRepositoryLogger);
}
public async Task WhenAsync(long aoUkprn, int profileId)
{
if (_result != null)
{
return;
}
_result = await AssessmentRepository.GetAssessmentsAsync(aoUkprn, profileId);
}
public async Task WhenAsync(long aoUkprn, int assessmentId)
{
if (_result != null)
{
return;
}
_result = await AssessmentRepository.GetPathwayAssessmentDetailsAsync(aoUkprn, assessmentId);
}
public async Task WhenAsync()
{
if (_result != null)
{
return;
}
_result = await AssessmentRepository.GetBulkAssessmentsAsync(_aoUkprn, _ulns.Keys);
}
public async Task WhenAsync(long aoUkprn, int profileId, int startInYear)
{
if (_actualResult != null)
{
return;
}
_actualResult = await AssessmentRepository.GetAvailableAssessmentSeriesAsync(aoUkprn, profileId, startInYear);
}
public override void Given()
{
CreateMapper();
SeedTestData(EnumAwardingOrganisation.Pearson);
AssessmentRepositoryLogger = new Logger <AssessmentRepository>(new NullLoggerFactory());
AssessmentSeriesRepositoryLogger = new Logger <GenericRepository <AssessmentSeries> >(new NullLoggerFactory());
AssessmentRepository = new AssessmentRepository(AssessmentRepositoryLogger, DbContext);
AssessmentSeriesRepository = new GenericRepository <AssessmentSeries>(AssessmentSeriesRepositoryLogger, DbContext);
AssessmentService = new AssessmentService(AssessmentRepository, PathwayAssessmentRepository, SpecialismAssessmentRepository, AssessmentSeriesRepository, AssessmentMapper, AssessmentRepositoryLogger);
_assessmentRecords = new AssessmentsBuilder().BuildValidList();
}
public RatingsViewModel(AssessmentRepository assessmentRepository, EnrolledCourseRepository enrolledCourseRepository, IMessenger messenger)
{
_assessmentRepository = assessmentRepository;
_enrolledCourseRepository = enrolledCourseRepository;
_messenger = messenger;
_messenger.Register <SelectedStudentMessage>(SelectedStudent);
_messenger.Register <SelectedCourseMessage>(SelectedCourse);
_messenger.Register <UpdatedAssessmentRatingMessage>((p) => LoadAssessments());
_messenger.Register <DeletedAssessmentRatingMessage>((p) => LoadAssessments());
SelectAssessmentCommand = new RelayCommand(AssessmentSelectionChanged);
}
public IViewComponentResult Invoke(int employeeId, int page = 1, int pageSize = 20)
{
AssessmentRepository assessmentRepo = new AssessmentRepository();
IQueryable <Performanceappraisal> assessments = assessmentRepo.GetPerfAppByEmployeeId(employeeId);
IPagedList <Performanceappraisal> assessmentPaged = assessments.OrderByDescending(x => x.Createdate).ToPagedList(page, pageSize);
int ps = page * pageSize;
int datacount = assessments.Count();
ViewBag.showEntriesLabel = "Showing " + ((page == 1 ? 1 : ((page - 1) * pageSize) + 1)) + " to " + (ps > datacount ? datacount : ps) + " of " + datacount + " entries.";
return(View(assessmentPaged));
}
public AddRatingViewModel(AssessmentRepository assessmentRepository, EnrolledCourseRepository enrolledCourseRepository, IMessenger messenger)
{
_assessmentRepository = assessmentRepository;
_enrolledCourseRepository = enrolledCourseRepository;
_messenger = messenger;
DeleteCommand = new RelayCommand(Delete);
NewAssessmentCommand = new RelayCommand(NewAssessment);
SaveCommand = new SaveAssessmentCommand(assessmentRepository, this, messenger);
_messenger.Register <SelectedAssessmentRatingMessage>(SelectedAssessment);
_messenger.Register <SelectedCourseMessage>(SelectedCourse);
_messenger.Register <SelectedStudentMessage>(SelectedStudent);
}
public override void Given()
{
// Parameters
_ulns = new Dictionary <long, RegistrationPathwayStatus> {
{ 1111111111, RegistrationPathwayStatus.Active }
};
// Registrations seed
SeedTestData(EnumAwardingOrganisation.Pearson, true);
_registrations = SeedRegistrationsDataByStatus(_ulns, TqProvider);
AssessmentRepositoryLogger = new Logger <AssessmentRepository>(new NullLoggerFactory());
AssessmentRepository = new AssessmentRepository(AssessmentRepositoryLogger, DbContext);
}
public IActionResult SaveFormAssessment(AssessmentModels model)
{
AssessmentRepository repo = new AssessmentRepository();
try
{
model.EmployeeId = Convert.ToInt32(ViewBag.employeeId);
repo.CreateAssessment(model);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(RedirectToAction("IndividualAssessment", model));
}
}
protected int SetAssessmentNotifications(int courseId, int notificationId)
{
var assessmentRepo = new AssessmentRepository();
var assessments = assessmentRepo.RetrieveAll(courseId);
if (assessments == null)
{
return(notificationId);
}
foreach (var assessment in assessments.Where(assessment => assessment.DisplayNotification))
{
CrossLocalNotifications.Current.Show(assessment.Name, $"{assessment.Name} is starting.", notificationId, assessment.StartDateTime);
notificationId++;
}
return(notificationId);
}
protected void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
AssessmentRepository?.Dispose();
EnrolleeRepository?.Dispose();
FacultyRepository?.Dispose();
FacultyEnrolleeRepository?.Dispose();
_dbContext?.Dispose();
}
_disposed = true;
}
public override void Given()
{
CreateMapper();
// Data seed
SeedTestData(EnumAwardingOrganisation.Pearson);
SeedRegistrationsData(_ulns, TqProvider);
// Dependencies
AssessmentRepositoryLogger = new Logger <AssessmentRepository>(new NullLoggerFactory());
AssessmentSeriesRepositoryLogger = new Logger <GenericRepository <AssessmentSeries> >(new NullLoggerFactory());
AssessmentRepository = new AssessmentRepository(AssessmentRepositoryLogger, DbContext);
AssessmentSeriesRepository = new GenericRepository <AssessmentSeries>(AssessmentSeriesRepositoryLogger, DbContext);
// TestClass
AssessmentService = new AssessmentService(AssessmentRepository, PathwayAssessmentRepository, SpecialismAssessmentRepository, AssessmentSeriesRepository, AssessmentMapper, AssessmentRepositoryLogger);
// setup input parameter
SetupInputParameter();
}
public StudentListViewModel(StudentRepository studentRepository, EnrolledCourseRepository enrolledCourseRepository,
AssessmentRepository assessmentRepository, IMessenger messenger)
{
_studentRepository = studentRepository;
_enrolledCourseRepository = enrolledCourseRepository;
_assessmentRepository = assessmentRepository;
_messenger = messenger;
_allStudents = new ObservableCollection <StudentBasicModel>(_studentRepository.GetAllStudents().Select(_mapper.MapStudentModelToStudentBasicModel));
_messenger.Register <DeletedStudentMessage>(DeletedStudentMessageReceived);
_messenger.Register <SelectedCourseMessage>(SelectedCourseMessageReceived);
_messenger.Register <EnrollStudentInCurrentCourseMessage>(EnrollStudentInCourseReceived);
_messenger.Register <UpdatedStudentMessage>((p) => OnLoad());
SelectStudentCommand = new RelayCommand(StudentSelectionChanged);
FilterStudentCommand = new RelayCommand(FilterStudentChanged);
SortByNameCommand = new RelayCommand(SortByName);
SortBySirNameCommand = new RelayCommand(SortBySurName);
SortByLoginCommand = new RelayCommand(SortByLogin);
SortByCurrentRatingCommand = new RelayCommand(SortByCurrentRating);
}
//IGenericRepository IUnitOfWork.Repository => throw new NotImplementedException();
public UnitOfWork()
{
dbContext = new DatabaseContext();
Repository = new GenericRepository(dbContext);
SchoolRepository = new SchoolRepository(dbContext);
ExceptionLoggerRepository = new ExceptionLoggerRepository(dbContext);
ApiLogRepository = new ApiLogRepository(dbContext);
ImageFileTypeRepository = new ImageFileTypeRepository(dbContext);
AssessmentRepository = new AssessmentRepository(dbContext);
AttendanceRepository = new AttendanceRepository(dbContext);
BookRepository = new BookRepository(dbContext);
BookTransactionRepository = new BookTransactionRepository(dbContext);
EventRepository = new EventRepository(dbContext);
HomeworkRepository = new HomeworkRepository(dbContext);
ImageFileUrlRepository = new ImageFileUrlRepository(dbContext);
ParentRepository = new ParentRepository(dbContext);
StandardRepository = new StandardRepository(dbContext);
StudentRepository = new StudentRepository(dbContext);
SubjectRepository = new SubjectRepository(dbContext);
TeacherRepository = new TeacherRepository(dbContext);
YearRepository = new YearRepository(dbContext);
OperationalStaffRepository = new OperationalStaffRepository(dbContext);
}
public async Task WhenAsync()
{
_result = await AssessmentRepository.GetBulkSpecialismAssessmentsAsync(_specialismAssessments);
}
public AssessmentListViewModel(Course course)
{
_assessmentRepository = new AssessmentRepository();
Course = course;
GetAssessments();
}
public async Task WhenAsync()
{
_result = await AssessmentRepository.GetBulkPathwayAssessmentsAsync(_pathwayAssessments);
}
public IActionResult IndividualAssessment(AssessmentModels model = null)
{
string ESMJson = HttpContext.Session.GetString("ESM");
EmployeeSessionModel ESM = JsonConvert.DeserializeObject <EmployeeSessionModel>(ESMJson);
if (!string.IsNullOrEmpty(ESM.EmployeeId))
{
if (model.DocumentId != 0)
{
model = this.InitModel(model.DocumentId);
model.BODescription = new List <string>();
AssessmentRepository assesmentRepo = new AssessmentRepository();
Performanceappraisal assessment = assesmentRepo.GetPerfAppById(model.DocumentId);
foreach (var item in assessment.Businessobjective)
{
model.BODescription.Add(item.Description);
model.BOEmployeeScore.Add(item.Employeescore);
model.BOGoals.Add(item.Goalachievement);
model.BOWeight.Add(item.Weight);
}
foreach (var item in assessment.Globalbehavior)
{
model.GBDemonstatedBehavior.Add(item.Demonstratedbehavior);
model.GBEmployeeScore.Add(item.Employeescore);
model.GBExpectedBehavior.Add(item.Expectedbehavior);
}
model.BODescriptiveScore = assessment.Bodescriptivescore;
model.BONumericalScore = assessment.Bonumericscore;
model.GBNumericalScore = assessment.Gbnumericscore;
model.GBDescriptiveScore = assessment.Gbdescriptivescore;
model.CareerAspirationComment = assessment.Careeraspirationcomment;
foreach (var item in assessment.Developmentplan)
{
model.DPDevelopmentArea = item.Developmentarea;
model.DPMethods = item.Methods;
model.DPPlan = item.Plan;
model.DPStrengthArea = item.Strengtharea;
}
model.EmployeeComment = assessment.Employeecomment;
model.ManagerComment = assessment.Managercomment;
model.MobilityStatusId = (int)assessment.MobilityId;
model.MobilityStatusDesc = assessment.Mobilitydesc;
model.OverallDescriptiveScore = assessment.Overalldescriptivescore;
model.OverallNumericalScore = assessment.Overallnumericscore;
model.SecondLevelManagerComment = assessment._2ndlvlmanagercomment;
model.ESM = ESM;
}
else
{
model = this.InitModel(0);
model.ESM = ESM;
}
}
else
{
model = this.InitModel(0);
model.ESM = ESM;
}
DepartmentRepository deptRepo = new DepartmentRepository();
SubDeparmentRepository subDeptRepo = new SubDeparmentRepository();
ViewBag.departmentId = ESM.DepartmentId;
ViewBag.subdepartmentId = ESM.SubDeparmentId;
ViewBag.Department = deptRepo.GetDepartments();
ViewBag.SubDepartment = subDeptRepo.GetSubdepartments();
return(View(model));
}
public SaveAssessmentCommand(AssessmentRepository assessmentRepository, AddRatingViewModel viewModel, IMessenger messenger)
{
_assessmentRepository = assessmentRepository;
_viewModel = viewModel;
_messenger = messenger;
}
