public void CreateGrade(GradeDto grade)
{
if (grade == null)
{
throw new ArgumentNullException(nameof(grade));
}
var gradeEntity = new Grade
{
Id = grade.Id,
Score = grade.Score,
DateOfTheGrade = grade.DateOfTheGrade
};
Add(gradeEntity);
Commit();
var studentScore = new StudentScore
{
GradeId = gradeEntity.Id,
StudentId = grade.StudentId
};
_studentScoreRepo.Add(studentScore);
Commit();
}
partial void OnCreate(GradeDto grade, string username)
{
if (_context.Grades.Any(a => a.Name == grade.Name))
{
throw new Exception("Record not unique.");
}
}
public IHttpActionResult AddGradeAt(int id, GradeDto grade)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != grade.GradeId)
{
return(BadRequest());
}
try
{
gradeRepo.Update(Mapper.Map <Grade>(grade));
}
catch (DbUpdateConcurrencyException)
{
if (!GradeExists(id))
{
return(Content(HttpStatusCode.NotFound, "Item does not exist"));
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <ActionResult <GradeDto> > PostGrade(GradeDto grade)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
GradeDto gradeDto;
try
{
gradeDto = await gradeService.CreateGradeAsync(grade, User.Identity.Name);
if (gradeDto != null)
{
this.RemoveCache(CacheKeys.Grade);
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
// var gradeDto = await _context.Grades.Select(GradeDto.AsGradeDto).SingleOrDefaultAsync(m => m.Id == grade.Id);
return(CreatedAtAction("GetGrade", new { id = gradeDto.Id }, gradeDto));
}
public IHttpActionResult Put(int id, [FromBody] GradeDto form)
{
if (ModelState.IsValid)
{
var gradeInDb = _gradeService.Get(id);
if (gradeInDb == null)
{
return(NotFound());
}
try
{
Mapper.Map(form, gradeInDb);
_gradeService.Update(gradeInDb);
return(Ok());
}
catch (ArgumentNullException ane)
{
ModelState.AddModelError("", ane.Message);
}
catch (NonexistingEntityException)
{
return(NotFound());
}
}
return(BadRequest(ModelState));
}
public ICollection <GradeDto> GetGradesByStud(Guid courseId, Guid studentId)
{
var gradeDtos = new List <GradeDto>();
var grades = _repository.GetAllByFilter <Grade>(x => x.CourseId == courseId && x.StudentId == studentId);
foreach (var grade in grades)
{
var category = _repository.GetByFilter <GradeCategory>(x => x.Id == grade.CategoryId);
var gradeDto = new GradeDto
{
Id = grade.Id,
Value = grade.Value,
StudentId = grade.StudentId,
ProfId = grade.ProfId,
CourseId = grade.CourseId,
CategoryId = grade.CategoryId,
Category = category.Name
};
gradeDtos.Add(gradeDto);
}
return(gradeDtos);
}
public async Task GetCheckedInStudent_ShouldReturnStudentsThatCheckedInAtExam()
{
// Arrange
Grade grade = GradeTestUtils.GetInitialStateGrade();
var grades = new List <Grade> {
grade
};
GradeDto gradeDto = GradeTestUtils.GetInitialGradeDto(grade.Id);
Student student = StudentTestUtils.GetStudent();
_mockReadRepository.Setup(repo => repo.GetByIdAsync <Domain.Entities.Exam>(_exam.Id)).ReturnsAsync(_exam);
_mockReadRepository.Setup(repo => repo.GetAll <Grade>()).Returns(grades.AsQueryable().BuildMock);
_mockGradeMapper.Setup(mapper => mapper.Map(grade)).Returns(gradeDto);
_mockStudentMapper.Setup(mapper => mapper.Map(student, gradeDto))
.Returns(StudentTestUtils.GetStudentFetchingGradeDto(student.Id, gradeDto));
var expectedResult = new List <StudentFetchingGradeDto>
{
StudentTestUtils.GetStudentFetchingGradeDto(student.Id, gradeDto)
};
// Act
var result = await _examService.GetCheckedInStudents(_exam.Id);
// Assert
result.Should().BeEquivalentTo(expectedResult);
}
public int AddGrade(GradeDto gradeDto)
{
Grade grade = Mapper.Map <Grade>(gradeDto);
int res = mainRepo.AddGrade(grade);
return(res);
}
private static void AssertAreEqual(GradeDto gradeDto, Grade grade)
{
Assert.AreEqual(gradeDto.Value, grade.Value);
Assert.AreEqual(gradeDto.StudentId, grade.Student.Id);
Assert.AreEqual(gradeDto.TeacherId, grade.Teacher.Id);
Assert.AreEqual(gradeDto.SubjectId, grade.Subject.Id);
}
public IHttpActionResult PutUpdateGrade(int gradeId, GradeDto gradeDto)
{
var userData = IdentityHelper.GetLoggedInUser(RequestContext);
logger.Info("Update Grade {@gradeData} for Grade {@gradeId} by {@userData}", gradeDto, gradeId, userData);
if (gradeId != gradeDto.GradeId)
{
return(BadRequest("Ids do not match"));
}
if (userData.UserRole == "teachers")
{
if (gradeDto.TeacherId != userData.UserId)
{
throw new UnauthorizedAccessException();
}
}
GradeDto result = gradesService.UpdateGrade(gradeDto);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public async Task PutAsync(int id, GradeDto gradeDto, CancellationToken cancellationToken = default)
{
var gradeToUpdate = await _dataContext.Grades
.Include(grade => grade.Student)
.Include(grade => grade.Teacher)
.Include(grade => grade.Subject)
.SingleAsync(grade => grade.Id == id, cancellationToken);
gradeToUpdate.Value = gradeDto.Value;
gradeToUpdate.Student = gradeDto.StudentId != null
? await _dataContext.Students.SingleAsync(student => student.Id == gradeDto.StudentId,
cancellationToken)
: null;
gradeToUpdate.Subject = gradeDto.SubjectId != null
? await _dataContext.Subjects.SingleAsync(subject => subject.Id == gradeDto.SubjectId,
cancellationToken)
: null;
gradeToUpdate.Teacher = gradeDto.TeacherId != null
? await _dataContext.Teachers.SingleAsync(teacher => teacher.Id == gradeDto.TeacherId,
cancellationToken)
: null;
await _dataContext.SaveChangesAsync(cancellationToken);
}
public IHttpActionResult CreateGradeAsTeacher(int teacherId, GradeDto gradeDto)
{
var userData = IdentityHelper.GetLoggedInUser(RequestContext);
logger.Info("Create Grade {@gradeData} for Teacher {@teacherId} by {@userData}", gradeDto, teacherId, userData);
if (teacherId != gradeDto.TeacherId)
{
return(BadRequest("Id mismatch"));
}
if (userData.UserRole != "teachers")
{
return(Unauthorized());
}
if (teacherId != userData.UserId)
{
throw new UnauthorizedAccessException(string.Format("You are not allowed to assign grades for teacher {0}", teacherId));
}
GradeDto createdGrade = gradesService.CreateGradeDto(gradeDto);
logger.Info("Teacher {@userData} created grade {@gradeData}", userData, createdGrade);
return(CreatedAtRoute("GetGrade", new { gradeId = createdGrade.GradeId }, createdGrade));
}
public IHttpActionResult Post([FromBody] GradeDto form)
{
if (ModelState.IsValid)
{
try
{
var grade = Mapper.Map <GradeDto, Grade>(form);
_gradeService.Add(grade);
var gradeDto = GetGradeDto(grade);
return(Created(new Uri(gradeDto.Url), gradeDto));
}
catch (ArgumentNullException ane)
{
ModelState.AddModelError("", ane.Message);
}
catch (PreexistingEntityException pe)
{
ModelState.AddModelError("", pe.Message);
}
}
return(BadRequest(ModelState));
}
public async Task <int> AddGradeAsync(GradeDto grade)
{
using (var httpClient = new RestClient(CommonHelper.BaseUrl))
{
return(await httpClient.PostRequestGenericAsync <GradeDto, int>("grade/AddGrade?gradeId", grade));
}
}
public async Task <ActionResult <GradeDto> > Grade([FromBody] GradeSubmissionDto gradeSubmissionDto)
{
// Get language info
ComputerLanguage lang = await _context.ComputerLanguages.FindAsync(gradeSubmissionDto.LangId);
if (lang == null)
{
return(BadRequest(new { Message = "The supplied computer language id doesn't exist!" }));
}
string executionRootDir = Grader.GetExecutionRootDir();
string randomId = RandomString(32);
string sourceFileName = $"{randomId}.{lang.Extension}";
string binaryFileName = randomId;
string sourceFilePath = $"{executionRootDir}{sourceFileName}";
string binaryFilePath = $"{executionRootDir}{binaryFileName}";
// Create file from source code inside rootDir
System.IO.File.WriteAllText(sourceFilePath, gradeSubmissionDto.SourceCode);
GradeDto result = new GradeDto(); // this will be returned by the method
bool readyToRun = true;
// Check if compiled language
if (!string.IsNullOrEmpty(lang.CompileCmd))
{
// Compile submission
CompilationOutputDto co = Grader.Compile(lang, sourceFileName, binaryFileName);
if (co.ExitCode != 0)
{
// Compile error
result.Status = "CE"; // Mark status as Compile Error
result.Error = co.Error; // Set message as compile error message
readyToRun = false;
}
}
if (readyToRun)
{
// Compiled successfully or interpreted language, so we're ready to run the solution
string fileName = string.IsNullOrEmpty(lang.CompileCmd) ? sourceFileName : binaryFileName;
// Grade solution
result = Grader.Grade(lang, fileName, gradeSubmissionDto.Input, gradeSubmissionDto.ExpectedOutput, gradeSubmissionDto.TimeLimit, gradeSubmissionDto.MemoryLimit);
// Delete binary file
System.IO.File.Delete(binaryFilePath);
}
// Delete source file
System.IO.File.Delete(sourceFilePath);
return(Ok(result));
}
public void Setup()
{
this.grade = GradeTestUtils.GetInitialStateGrade();
this.gradeDto = GradeTestUtils.GetInitialGradeDto(grade.Id);
this.gradeCreationDto = GradeTestUtils.GetGradeCreationDto();
this.gradeEditingDto = GradeTestUtils.GetGradeEditingDto();
this.gradeMapper = new GradeMapper();
}
/// <summary>
/// Create grade from GradeDto return dto
/// </summary>
/// <param name="gradeDto"></param>
/// <returns></returns>
public GradeDto CreateGradeDto(GradeDto gradeDto)
{
logger.Info("Create grade {@gradeData} return dto", gradeDto);
var grade = CreateGrade(gradeDto);
return(Converters.GradesConverter.GradeToGradeDto(grade));
}
public void Setup()
{
client = new CustomWebApplicationFactory <Startup>().CreateClient();
this.grade = GradeTestUtils.GetInitialStateGrade();
this.gradeDto = GradeTestUtils.GetInitialGradeDto(grade.Id);
this.gradeCreationDto = GradeTestUtils.GetGradeCreationDto();
this.gradeEditingDto = GradeTestUtils.GetGradeEditingDto();
}
public async Task <ActionResult <IEnumerable <GradeDto> > > GetGrades(string searchText = null
, double?beginMarkText = null
, double?nextBeginMarkText = null
, double?pointText = null
/*, int pageNumber=1, int pageSize=7*/)
{
// var grades = _context.Grades.Select(GradeDto.AsGradeDto);
List <Expression <Func <GradeDto, bool> > > filters = null;
if (String.IsNullOrEmpty(searchText) &&
beginMarkText == null &&
nextBeginMarkText == null &&
pointText == null
)
{
// return null;
}
else
{
filters = new List <Expression <Func <GradeDto, bool> > >();
if (!String.IsNullOrEmpty(searchText))
{
if (searchText.CompareTo("*") != 0 && searchText.CompareTo("%") != 0)
{
filters.Add(x => x.Id.ToString().Contains(searchText));
}
}
if (beginMarkText != null)
{
filters.Add(x => x.BeginMark == beginMarkText);
}
if (nextBeginMarkText != null)
{
filters.Add(x => x.NextBeginMark == nextBeginMarkText);
}
if (pointText != null)
{
filters.Add(x => x.Point == pointText);
}
}
//sort
//return grades.OrderBy(o => o.Id).Skip(((pageNumber - 1) * pageSize)).Take(pageSize);
// OnSelectQuery(ref grades);
// return await grades.ToListAsync();
if (filters == null)
{
return(await gradeService.GetGradeDtoesAsync(GradeDto.IncludeNavigations()));
}
else
{
return(await gradeService.GetGradeDtoesAsync(GradeDto.IncludeNavigations(), filters.ToArray()));
}
}
public IActionResult AddGrade(Guid studentId, [FromBody] GradeDto grade)
{
EnsureArg.IsNotEmpty(studentId);
var command = new AddGradeCommand(grade, studentId);
CommandDispatcher.Execute(command);
return(Created("/api/students/{studentId}/grades", command));
}
public ActionResult AddAdministrators(GradeDto grade)
{
grade.GradeDesc = "test";
grade.GradeDesc2 = "test";
grade.GradeId = 1;
var item = gradeService.AddGradeAsync(grade);
return(View(item));
}
public IActionResult EditGrade(GradeDto grade)
{
if (!ModelState.IsValid)
{
return(View());
}
PopulateStudentsDropDownList(grade.StudentId);
_gradeService.GradeEdit(grade);
return(View(grade));
}
public IActionResult CreatePost(GradeDto newGrade)
{
if (!ModelState.IsValid)
{
return(View());
}
PopulateStudentsDropDownList(newGrade.StudentId);
_gradeService.CreateGrade(newGrade);
return(View(newGrade));
}
public GradeDto Map(Guid gradeId, GradeEditingDto gradeEditingDto)
{
GradeDto gradeDto = new GradeDto(gradeId, gradeEditingDto.Value, gradeEditingDto.Pages,
gradeEditingDto.Date, gradeEditingDto.Agree, gradeEditingDto.StudentId, gradeEditingDto.ExamId)
{
Id = gradeId
};
return(gradeDto);
}
public async Task <IActionResult> Put([FromBody] GradeDto pGrade, int pId)
{
if (ModelState.IsValid && pGrade.Id == pId)
{
var response = await _gradeSvc.UpdateAsync(pGrade);
return(response.ToHttpResponse());
}
return(BadRequest(ModelState));
}
public ActionResult <GradeDto> UpdateGrade(int id, [FromBody] GradeDto dto)
{
try
{
return(Ok(_settingsService.GradeRepo.Update(id, dto)));
}
catch (KeyNotFoundException e)
{
return(NotFound($"{e.Message} ID: {id}"));
}
}
public IHttpActionResult AddGrade(GradeDto grade)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
gradeRepo.Insert(Mapper.Map <Grade>(grade));
return(CreatedAtRoute("AddGrade", new { id = grade.GradeId }, grade));
}
public async Task <IActionResult> Post([FromBody] GradeDto pGradeObj)
{
if (ModelState.IsValid)
{
var response = await _gradeSvc.CreateAsync(pGradeObj);
return(CreatedAtAction(nameof(GetById), new { pGradeObj.Id }, response.Data));//return 201 created and its data entity
}
return(BadRequest(ModelState));
}
public async Task Update_ShouldReturnInstanceOfGradeDto()
{
// Arrange
_mockGradeMapper.Setup(mapper => mapper.Map(initialStateGrade.Id, gradeEditingDto)).Returns(initialStateGradeDto);
_mockReadRepository.Setup(repo => repo.GetByIdAsync <Grade>(initialStateGrade.Id)).ReturnsAsync(initialStateGrade);
// Act
GradeDto actualGrade = await _gradeService.Update(initialStateGrade.Id, gradeEditingDto);
// Assert
actualGrade.Should().BeEquivalentTo(initialStateGradeDto);
}
public async Task <IActionResult> Edit(GradeDto gradeDto)
{
if (await _gradeService.GetGradeByNameAsync(gradeDto.GradeName.ToLower()) == false)
{
await _gradeService.UpdateAsync(_mapper.Map <Grade>(gradeDto));
ViewBag.ErrorMessage = "";
return(RedirectToAction("GetAll", "Grade"));
}
ViewBag.ErrorMessage = "Sistemde aynı isme ait sınıf bulunmaktadır...!";
return(View(gradeDto));
}
