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)); }