public async Task <IActionResult> Post([FromBody] ExamViewModel exam)
{
// Save to the Database
try
{
var newExam = Mapper.Map <Exam>(exam);
_repository.AddExam(newExam);
if (await _repository.SaveChangesAsync())
{
return(Created($"api/exams/{exam.ExamName}", Mapper.Map <ExamViewModel>(exam)));
}
else
{
_logger.LogWarning("Could not save exam to the database");
}
}
catch (Exception ex)
{
_logger.LogError($"Threw exception while saving exam: {ex}");
}
return(BadRequest("Failed to save the exam"));
}
public ExamViewModel GetExamViewModel()
{
ExamViewModel exam = new ExamViewModel();
exam.Questions = _Context.Questions.ToList();
return(exam);
}
public CorrectExam(ExamViewModel examView)
{
examViewModel = examView;
InitializeComponent();
Score.BindingContext = examView;
startCorrect();
}
public ActionResult <Exam> Post([FromBody] ExamViewModel value)
{
Teacher teacher = dataService.FindById <Teacher>(value.ResponsibleTeacher);
Module module = dataService.FindById <Module>(value.Module);
if (teacher == null)
{
return(NotFound("Teacher not found"));
}
else if (module == null)
{
return(NotFound("Module not found"));
}
Exam exam = new Exam
{
AttemptOne = value.AttemptOne,
AttemptTwo = value.AttemptTwo,
Compensatable = value.Compensatable,
Language = value.Language,
Duration = new TimeSpan(value.DurationInMinutes * 60 * 1000),
EC = value.EC,
ExamType = value.ExamType,
GradeType = value.GradeType,
Module = module,
ResponsibleTeacher = teacher
};
if (dataService.Insert <Exam>(exam) != 1)
{
return(StatusCode(500));
}
return(new OkObjectResult(exam));
}
public ActionResult <Exam> Put(int id, [FromBody] ExamViewModel value)
{
Exam exam = dataService.FindById <Exam>(id);
if (exam == null)
{
return(NotFound("Exam not found"));
}
Teacher teacher = dataService.FindById <Teacher>(value.ResponsibleTeacher);
Module module = dataService.FindById <Module>(value.Module);
exam.AttemptOne = value.AttemptOne;
exam.AttemptTwo = value.AttemptTwo;
exam.Compensatable = value.Compensatable;
exam.Duration = new TimeSpan(value.DurationInMinutes * 60 * 1000);
exam.EC = value.EC;
exam.Language = value.Language;
exam.ExamType = value.ExamType;
exam.GradeType = value.GradeType;
exam.Module = module;
exam.ResponsibleTeacher = teacher;
if (dataService.Update <Exam>(exam) != 1)
{
return(StatusCode(500));
}
return(new OkObjectResult(exam));
}
public void Update(ExamViewModel examViewModel)
{
var examDetails = Mapper.Map <List <QuestionExamDetailViewModel>, List <QuestionExamDetail> >(examViewModel
.QuestionExamDetailViewModels);
var exam = new Exam()
{
Id = examViewModel.Id,
Examiner = examViewModel.Examiner,
DateCreated = examViewModel.DateCreated,
DateModified = examViewModel.DateModified,
ExamName = examViewModel.ExamName,
QuestionExamDetails = examDetails,
Status = examViewModel.Status,
Time = examViewModel.Time
};
var newDetails = exam.QuestionExamDetails;
var addedDetails = newDetails.Where(x => x.Id == 0).ToList();
var updatedDetails = newDetails.Where(x => x.Id != 0).ToList();
var existedDetails = _questiondetailRepository.FindAll(x => x.ExamId == examViewModel.Id);
exam.QuestionExamDetails.Clear();
foreach (var detail in updatedDetails)
{
_questiondetailRepository.Update(detail);
}
foreach (var detail in addedDetails)
{
_questiondetailRepository.Add(detail);
}
_examRepository.Update(exam);
}
public static Func <Exam, ExamViewModel> ToViewModel()
{
ExamViewModel func(Exam exam)
{
if (exam != null)
{
var model = new ExamViewModel()
{
Id = exam.Id,
Code = exam.Code,
Moment = exam.Moment,
Name = exam.Name,
Unit = exam.Unit.Name
};
return(model);
}
else
{
return(null);
}
}
return(func);
}
public async Task <ApiResponse <bool> > UdpateExam(ExamViewModel exam)
{
var result = new ApiResponse <bool>();
try
{
var oExam = new Exam
{
Id = exam.Id,
Title = exam.Title,
Status = exam.Status,
Description = exam.Description,
Duration = exam.Duration,
ImageUrl = exam.ImageUrl
};
dbContext.Exams.Update(oExam);
await dbContext.SaveChangesAsync();
result.Data = true;
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ActionResult> Store([FromBody] ExamViewModel model)
{
int id = model.Id;
var existingEntity = await _examsService.GetByIdAsync(id);
if (existingEntity == null)
{
return(NotFound());
}
ValidateEditRequest(existingEntity);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var exam = model.MapEntity(_mapper, CurrentUserId);
//先存檔
_examsService.SaveExam(existingEntity, exam);
//對答案
bool withOptions = true;
exam = _examsService.GetById(id, withOptions);
exam.SetAnswers();
exam.Finish();
await _examsService.UpdateAsync(exam);
return(Ok());
}
public ActionResult AddExam(ExamViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var currentUser = AccountServiceCaller.Get(User.Identity.Name);
var userOrganizer = OrganizerServiceCaller.Get(currentUser.OrganizerId);
var newExam = new ExamModel();
newExam.OrganizerId = userOrganizer.Id;
newExam.CourseName = model.CourseName;
newExam.Hour = model.Hour;
newExam.Date = model.ExamDay;
newExam.Room = model.ExamRoom;
newExam.Difficulty = model.Difficulty;
try
{
ExamServiceCaller.Add(newExam);
return(RedirectToAction("Index", "Exam"));
}
catch (Exception ex)
{
return(View(ex.Message));
}
}
public ActionResult ShowExam()
{
ExamViewModel examViewModel = new ExamViewModel();
examViewModel.QuestionList = new List <Exam>();
examViewModel.SideBarData = new SideBarViewModel();
examViewModel.SideBarData.CurrentIndex = 2;
ExamBusinessLayer examBusinessLayer = new ExamBusinessLayer();
List <Exam> exam = examBusinessLayer.GetExamList();
// 获取考试科目
string examName = Convert.ToString(RouteData.Values["examName"]);
if (examName != null)
{
foreach (Exam t in exam)
{
if (t.ExamName == examName)
{
Exam userexam = new Exam();
userexam.ExamID = t.ExamID;
userexam.ExamName = t.ExamName;
userexam.Problem = t.Problem;
userexam.ProblemProperty = t.ProblemProperty;
userexam.Answer = t.Answer;
userexam.ImgSrc = t.ImgSrc;
userexam.Score = t.Score;
// single-choice question
if (userexam.ProblemProperty == 1)
{
userexam.First = t.First;
userexam.Second = t.Second;
userexam.Third = t.Third;
userexam.Fourth = t.Fourth;
}
examViewModel.QuestionList.Add(userexam);
}
}
}
else
{
Response.Redirect("~");
}
examViewModel.QuestionNum = examViewModel.QuestionList.Count;
examViewModel.Name = examName;
examViewModel.ExamScore = -1;
if (HttpContext.Session["User"] != null && Session["User"].ToString() != "")
{
examViewModel.NavStatusData = new NavStatusViewModel();
examViewModel.NavStatusData.LeftLink = "/User/Profile/" + HttpContext.Session["User"].ToString();
examViewModel.NavStatusData.LeftText = Session["User"].ToString();
examViewModel.NavStatusData.RightLink = "/User/Logout";
examViewModel.NavStatusData.RightText = "Log out";
}
return(View("Content", examViewModel));
}
public ActionResult Save(Exam exam, FormCollection formValues)
{
if (!ModelState.IsValid)
{
var ex = new Exam();
var viewModel = new ExamViewModel()
{
exam = ex,
courses = _context.Courses.ToList(),
students = _context.Students.ToList()
};
return(View("ExamForm", viewModel));
}
if (exam.Id == 0)
{
_context.Exams.Add(exam);
_context.SaveChanges();
}
else
{
var examInDb = _context.Exams.Find(exam.Id);
// if (TryUpdateModel(examInDb,new string[] { "exam.StudentId", "exam.CourseId", "exam.Grade"}))
//examInDb.CourseId = exam.CourseId;
//examInDb.StudentId = exam.StudentId;
//examInDb.Grade = exam.Grade;
//UpdateModel(examInDb);
examInDb.CourseId = Int32.Parse(Request.Form["exam.CourseId"]);
examInDb.StudentId = Int32.Parse(Request.Form["exam.StudentId"]);
examInDb.Grade = Int32.Parse(Request.Form["exam.Grade"]);
_context.SaveChanges();
}
_context.SaveChanges();
return(RedirectToAction("Index", "Exams"));
}
private async Task <int> CalculateResult(ExamViewModel viewModel)
{
var trueQuestionsCount = 0;
foreach (var question in viewModel.Questions)
{
var trueChoicesList = await this.choiceRepository.All().Where(c => c.QuestionId == question.Id && c.IsTrue == true).ToListAsync();
var trueChoicesCount = trueChoicesList.Count();
var counter = 0;
var selectedChoicesCount = question.Choices.Where(c => c.IsSelected == true).Count();
foreach (var choice in question.Choices)
{
if (choice.IsSelected == true)
{
if (choice.IsTrue == true)
{
counter++;
}
}
}
if (selectedChoicesCount == trueChoicesCount && counter == trueChoicesCount)
{
trueQuestionsCount++;
}
}
var result = (trueQuestionsCount * 100) / viewModel.Questions.Count;
var asd = 0;
return(result);
}
public async Task <IActionResult> Create([Bind("CityId,Date,Comment,Id,Created,SelectedCity")] ExamViewModel examViewModel)
{
if (ModelState.IsValid)
{
var latestDate = _repository.Query <Exam>()
.OrderBy(x => x.Created)
.LastOrDefault();
var exam = ExamMappings.ToEntity(examViewModel);
var city = await _repository.Query <City>().FirstOrDefaultAsync(x => x.Name == examViewModel.SelectedCity);
exam.CityId = city.Id;
var previousUrl = TempData["ReturnPath"].ToString();
if (latestDate != null)
{
exam.Tasks = latestDate.Tasks;
await _repository.InsertAsync(exam);
_logger.LogInformation("New exam added to DB. User {User}.", _user);
return(Redirect(previousUrl));
}
else
{
_logger.LogWarning("Exam was null. Nothing added to DB. User {User}.", _user);
}
await _repository.InsertAsync(exam);
return(Redirect(previousUrl));
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult IndexProgramme()
{
//Console.ReadLine();
var student = new Student();
var programmeCode = student.Programmes.ProgrammeCode;
var listExam = new ExamViewModel();
var progcode = listExam.ProgrammeCode;
if (programmeCode == progcode)
{
listExam.Exams = _examRepository.GetMyExams();
}
// listExam.Exams = _examRepository.GetAllExams();
//var listProgrammes = _programmeRepository.GetAllProgrammes().Select(c => new { c.ProgrammeCode, c.ProgrammeName }).ToList();
//listExam.ProgrammesList = new SelectList(listProgrammes, "ProgrammeCode", "ProgrammeName");
//var student = new Student();
//if (programmeCode == "ITIS")
//{
// foreach (var item in programmeCode)
// {
// listExam.Exams.ToList();
// }
//}
return(View(listExam));
}
public ActionResult Index()
{
var examViewModel = new ExamViewModel();
examViewModel.departs = _departmentInfoAppService.GetAllDepartmentInfos();
return(View(examViewModel));
}
public async Task CheckIfCheckForPermissionsWorkCorrectly()
{
var user = new ApplicationUser
{
Id = Guid.NewGuid().ToString(),
};
var user2 = new ApplicationUser
{
Id = Guid.NewGuid().ToString(),
};
var exam = new ExamViewModel
{
Id = Guid.NewGuid().ToString(),
Creator = user,
};
ArgumentException exception = await Assert.ThrowsAsync <ArgumentException>(() => this.Service.CheckForPermissions(exam, user2));
Assert.Equal("You do not have permission to perform this action. Please contact an administrator.", exception.Message);
var checkForException = await Record.ExceptionAsync(() => this.Service.CheckForPermissions(exam, user));
Assert.Null(checkForException);
}
public bool CreateExam([FromBody] ExamViewModel data)
{
///Önce sınavda başlık ve makaleyi veritabanına kaydediyoruz
Exam exam = new Exam()
{
Title = data.Title,
Content = data.Content
};
using (var db = new Context())
{
db.Add(exam);
db.SaveChanges();
}
///Daha sonra ise sınava ait soruları veritabanına ekliyoruz
data.QuestionList.ForEach(question => {
question.ExamId = exam.ExamId;
using (var db = new Context())
{
db.Add(question);
db.SaveChanges();
}
});
return(true);
}
public IActionResult CreateExam([FromBody] ExamViewModel exam)
{
var examBlModel = exam.GetBlModel();
_examService.CreateExam(examBlModel, exam.Classrooms);
return(NoContent());
}
public ExamView()
{
InitializeComponent();
var vm = new ExamViewModel();
this.DataContext = vm;
}
public async Task CheckForPermissions(ExamViewModel exam, ApplicationUser user)
{
if (!await this.userManager.IsInRoleAsync(user, GlobalConstants.AdministratorRoleName) && exam.Creator.Id != user.Id)
{
throw new ArgumentException("You do not have permission to perform this action. Please contact an administrator.");
}
}
public IActionResult FinishExam(ExamViewModel examViewModel)
{
var user = _userService.GetUserByUserName(User.Identity.Name).Data;
var result = _questionService.FinishExam(examViewModel.Questions.Select(x => x.Id).ToList(), examViewModel.UserAnswers, user).Data;
return(View(result));
}
public IActionResult Edit(int id, [Bind("Id,Date,StartTime,EndTime,CourseId,TeacherId")] ExamViewModel examViewModel)
{
if (id != examViewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
Exam exam = MapToExam(examViewModel);
_examManager.Update(exam);
}
catch (DbUpdateConcurrencyException)
{
if (!ExamExists(examViewModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index), new { message = "edit" }));
}
return(View());
}
public ActionResult ApproeExamPaper()
{
string paperId = Request.QueryString["paperId"];
var examViewModel = new ExamViewModel();
examViewModel.PaperId = int.Parse(paperId);
return(View("~/Areas/Admin/Views/ExamPaper/ApproeExamPaper.cshtml", examViewModel));
}
public ActionResult ExamResult()
{
string examId = Request.QueryString["examId"];
ExamViewModel vm = new ExamViewModel();
vm.ExamId = int.Parse(examId);
return(View(vm));
}
public ActionResult PaperManage()
{
string examId = Request.QueryString["examId"];
var examViewModel = new ExamViewModel();
examViewModel.ExamId = int.Parse(examId);
return(View("~/Areas/Admin/Views/ExamManage/PaperManage.cshtml", examViewModel));
}
public ActionResult AddUsers(string keyword = "", int departmentId = 0, int jobPostId = 0, int pIndex = 1)
{
string examId = Request.QueryString["examId"];
var examViewModel = new ExamViewModel();
examViewModel.ExamId = int.Parse(examId);
return(View("~/Areas/Admin/Views/ExamManage/addUsers.cshtml", examViewModel));
}
public ActionResult Create(ExamViewModel exam)
{
//_context.Exams.Add();
_context.SaveChanges();
var data = _context.Exams.ToList();
return(PartialView("_InsertQuestion"));
}
public async Task <IActionResult> Take(ExamViewModel viewModel)
{
var user = await this.userManager.GetUserAsync(this.HttpContext.User);
await this.examsService.SaveResultAsync(viewModel, user);
return(this.RedirectToAction("Result", "Exams", new { id = viewModel.Id }));
}
public ExamPage(PatientItem PatientSelected)
{
examViewModel = new ExamViewModel();
InitializeComponent();
BindingContext = examViewModel;
examViewModel.PatientItem = PatientSelected;
startExam();
}
