public async Task <RepoResponse <int> > EvaluateStudent(Guid sId, Guid cId,
DateTime date, int score)
{
var student = await _context.CurrentCourseStudents
.AsNoTracking()
.Include(ccs => ccs.Course)
.Include(ccs => ccs.Student)
.FirstOrDefaultAsync(ccs => ccs.StudentId == sId && ccs.CourseId == cId);
if (student == null)
{
return(new RepoResponse <int>()
{
IsSuccess = false,
Content = 0,
Message = _config["ErrorCodes:student_course"]
});
}
var newScore = new Score()
{
Id = Guid.NewGuid(),
CourseId = student.CourseId,
StudentId = student.StudentId,
Date = date,
ScoreOver100 = score
};
await _context.Scores.AddAsync(newScore);
var dbResult = await _context.SaveChangesAsync();
if (dbResult > 0)
{
return(new RepoResponse <int>()
{
Content = dbResult,
IsSuccess = true,
Message = _config["SuccessCodes:created"]
});
}
return(new RepoResponse <int>()
{
IsSuccess = false,
Content = 0,
Message = _config["ErrorCodes:db_error"]
});
}
public async Task <RepoResponse <StudentReturnDto> > RegisterStudent(StudentRegisterDto registerCreds)
{
// Check for existing student:
var oldStudent = await _context.Students
.FirstOrDefaultAsync(s => registerCreds.Email.ToLower() == s.Email.ToLower() ||
s.CardNumber.ToLower() == registerCreds.CardNumber.ToLower());
if (oldStudent != null)
{
return(new RepoResponse <StudentReturnDto>()
{
IsSuccess = false,
Message = _config["ErrorCodes:record_exists"]
});
}
var student = new Student()
{
Id = Guid.NewGuid(),
Details = registerCreds.Details,
Email = registerCreds.Email,
Gender = registerCreds.Gender,
Name = registerCreds.Name,
Password = Helper.ComputeHash(registerCreds.Password),
Role = Role.Student,
SpecialityId = registerCreds.SpecialityId,
RegisterStatus = RegistrationStatus.Pending,
CardNumber = registerCreds.CardNumber
};
await _context.Students.AddAsync(student);
var contextResult = await _context.SaveChangesAsync();
if (contextResult > 0)
{
var studentReturn = await _context.Students
.AsNoTracking()
.Include(s => s.Speciality)
.Select(s => new StudentReturnDto()
{
Id = s.Id,
Details = s.Details,
Email = s.Email,
Gender = s.Gender,
Name = s.Name,
SpecialityId = s.SpecialityId,
SpecialityName = s.Speciality.Name,
RegisterStatus = s.RegisterStatus
})
.FirstOrDefaultAsync(s => s.Id == student.Id);
if (studentReturn != null)
{
return(new RepoResponse <StudentReturnDto>()
{
Content = studentReturn,
IsSuccess = true,
Message = _config["SuccessCodes:created"]
});
}
}
return(new RepoResponse <StudentReturnDto>()
{
IsSuccess = false,
Message = _config["ErrorCodes:db_error"]
});
}
public async Task <RepoResponse <List <CourseNameIdDto> > > ChooseCourses(Guid studentId,
List <CourseNameIdDto> courseIds)
{
// Delete unselected courses.
courseIds = courseIds
.Where(c => c.Id != Guid.Empty)
.ToList();
var student = await _context.Students
.AsNoTracking()
.FirstOrDefaultAsync(s => s.Id == studentId);
var wantedCourses = new List <Course>();
foreach (var want in courseIds)
{
var c = await _context.Courses
.AsNoTracking()
.Include(co => co.Prerequisites)
.FirstOrDefaultAsync(co => co.Id == want.Id);
wantedCourses.Add(c);
}
var takenCourses = await _context.TakenCourseStudents
.AsNoTracking()
.Include(cs => cs.Course)
.Where(cs => cs.StudentId == studentId)
.ToListAsync();
// Find courses that unavaliable to choose because
// of prerequisites.
var unavaliableCourses = new List <CourseNameIdDto>();
foreach (var wantedCourse in wantedCourses)
{
if (wantedCourse.Prerequisites.Count == 0)
{
continue;
}
bool isAvaliable = false;
foreach (var requisite in wantedCourse.Prerequisites)
{
if (takenCourses.Any(tc => tc.CourseId == requisite.Id))
{
isAvaliable = true;
}
else
{
isAvaliable = false;
}
}
if (!isAvaliable)
{
unavaliableCourses.Add(
new CourseNameIdDto()
{
Id = wantedCourse.Id,
CourseName = wantedCourse.Name
}
);
}
}
// If you fail:
if (unavaliableCourses.Count != 0)
{
return(new RepoResponse <List <CourseNameIdDto> >()
{
IsSuccess = false,
Message = _config["ErrorCodes:unable_to_choose"],
Content = unavaliableCourses
});
}
// If there is no unavaliable courses:
var currentCourseStudents = courseIds
.Select(wc => new CurrentCourseStudent()
{
CourseId = wc.Id,
StudentId = student.Id,
CourseTeacherId = wc.TeacherId
})
.ToList();
await _context.CurrentCourseStudents
.AddRangeAsync(currentCourseStudents);
var dbResult = await _context.SaveChangesAsync();
if (dbResult > 0)
{
return(new RepoResponse <List <CourseNameIdDto> >()
{
IsSuccess = true,
Content = null,
Message = _config["SuccessCodes:choice"]
});
}
return(new RepoResponse <List <CourseNameIdDto> >()
{
IsSuccess = false,
Content = null,
Message = _config["ErrorCodes:db_error"]
});
}
