public ActionResult DeleteConfirmed(int id)
{
Models.Quiz quiz = db.Quizs.Find(id);
db.Quizs.Remove(quiz);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Post([FromBody] Models.Quiz quiz)
{
context.Quizzes.Add(quiz); //new Models.Question(){text = "test"}
await context.SaveChangesAsync();
return(Ok(quiz));
}
public async Task <IActionResult> PutQuiz([FromRoute] long id, [FromBody] Models.Quiz quiz)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != quiz.Id)
{
return(BadRequest());
}
var userId = HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
quiz.OwnerId = userId;
_context.Entry(quiz).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuizExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Quiz quiz)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != quiz.ID)
{
return(BadRequest());
}
// indicate that the Quiz has been edited
context.Entry(quiz).State = EntityState.Modified;
try
{
await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuizExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutQuiz([FromRoute] long id, [FromBody] Models.Quiz quiz)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != quiz.Id)
{
return(BadRequest());
}
_context.Entry(quiz).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuizExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Demarrer(int id)
{
Models.Quiz quiz = db.Quizs.Find(id);
Utilisateur candidat = (Utilisateur)Session["user"];
QuizTest quizTest = new QuizTest(DateTime.Now, quiz, candidat, 0);
return(View(quizTest));
}
public Models.Quiz Get(int id)
{
Models.Quiz Quiz = _QuizRepository.GetQuiz(id);
if (Quiz != null && Quiz.ModuleId != _entityId)
{
Quiz = null;
}
return(Quiz);
}
public Models.Quiz Post([FromBody] Models.Quiz Quiz)
{
if (ModelState.IsValid && Quiz.ModuleId == _entityId)
{
Quiz = _QuizRepository.AddQuiz(Quiz);
_logger.Log(LogLevel.Information, this, LogFunction.Create, "Quiz Added {Quiz}", Quiz);
}
return(Quiz);
}
public void OnGet(int quizId, int?quizResponseId)
{
quiz = _context.Quizzes.Include(q => q.Questions).ThenInclude(q => q.Answers).FirstOrDefault(q => q.ID == quizId);
if (quizResponseId != null)
{
response = _context.QuizResponses.Include(qr => qr.Answers).FirstOrDefault(r => r.ID == quizResponseId);
}
}
public Models.Quiz Put(int id, [FromBody] Models.Quiz Quiz)
{
if (ModelState.IsValid && Quiz.ModuleId == _entityId)
{
Quiz = _QuizRepository.UpdateQuiz(Quiz);
_logger.Log(LogLevel.Information, this, LogFunction.Update, "Quiz Updated {Quiz}", Quiz);
}
return(Quiz);
}
public void Delete(int id)
{
Models.Quiz Quiz = _QuizRepository.GetQuiz(id);
if (Quiz != null && Quiz.ModuleId == _entityId)
{
_QuizRepository.DeleteQuiz(id);
_logger.Log(LogLevel.Information, this, LogFunction.Delete, "Quiz Deleted {QuizId}", id);
}
}
public ActionResult Edit(Models.Quiz quiz)
{
if (ModelState.IsValid)
{
db.Entry(quiz).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(quiz));
}
public async Task AddQuiz(Models.Quiz quiz)
{
var quizToAdd = new Models.Quiz()
{
QuizName = quiz.QuizName,
SchoolId = quiz.SchoolId
};
_context.Quiz.Add(quizToAdd);
await _context.SaveChangesAsync();
}
public ActionResult Create([Bind(Include = "Id,Subject")] Models.Quiz quiz)
{
if (ModelState.IsValid)
{
db.Quizs.Add(quiz);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(quiz));
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Quiz quiz)
{
if (id != quiz.Id)
{
return(BadRequest());
}
quizContext.Entry(quiz).State = EntityState.Modified;
await quizContext.SaveChangesAsync();
return(Ok(quiz));
}
// GET: Quizs/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Models.Quiz quiz = db.Quizs.Find(id);
if (quiz == null)
{
return(HttpNotFound());
}
return(View(quiz));
}
public async Task <IActionResult> Post([FromBody] Models.Quiz quiz)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = HttpContext.User.Claims.First();
context.Quizzes.Add(quiz);
await context.SaveChangesAsync();
return(CreatedAtAction("Get", new { id = quiz.ID }, quiz));
}
public async Task <IActionResult> PostQuiz([FromBody] Models.Quiz quiz)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
quiz.OwnerId = userId;
_context.Quiz.Add(quiz);
await _context.SaveChangesAsync();
return(Ok(quiz)); //CreatedAtAction("GetQuiz", new { id = quiz.Id }, quiz);
}
public async Task <IActionResult> PutQuiz(int id, [FromBody] Models.Quiz quizData)
{
//var question = await context.Questions.SingleOrDefaultAsync(q => q.ID == id);
if (id != quizData.ID)
{
return(BadRequest());
}
context.Entry(quizData).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Ok(quizData));
}
private void btAddQuiz_Click(object sender, RoutedEventArgs e)
{
Quiz Q = new Models.Quiz();
Q.Title = txtQuizName.Text;
Q.Description = txtQuizDesc.Text;
DatabaseContext c = new DatabaseContext();
c.Quizes.Add(Q);
c.SaveChanges();
MessageBox.Show("Quiz was registered !");
this.Close();
}
/// <summary>
/// Download data from db
/// </summary>
public async Task InitAsync(int categoryId, int userId)
{
using (var context = new DefaultContext())
{
this.Questions = await context.Questions.Where(q => q.CategoryId == categoryId).OrderBy(q => new Guid()).Take(5).ToListAsync();
this.CurrentQuestion = this.Questions[0];
Quiz = new Models.Quiz()
{
StartTime = DateTime.Now,
Status = Models.Quiz.StatusEnum.InProgress,
CategoryId = categoryId,
UserId = userId
};
}
}
public async Task <IActionResult> Post([FromBody] Models.Quiz quiz)
{
if (ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userID = HttpContext.User.Claims.First().Value;
quiz.OwnerID = userID;
_context.quizzes.Add(quiz);
await _context.SaveChangesAsync();
return(Ok(quiz));
}
private void AddLotsOfQuizzes(QuizDbContext ctx, Models.Quiz reference)
{
for (int k = 0; k < 100; k++)
{
var quizTemp = new Models.Quiz()
{
AllowPoints = true,
Category = reference.Category,
Created = DateTime.Now,
CreatedBy = "admin",
IsTimeable = true,
Locked = false,
Name = reference.Name + "-" + k,
Summary = "sum" + k,
};
for (int i = 0; i < 100; i++)
{
var q = new Question()
{
OrderId = i,
Text = "text",
EstimatedTime = 10,
Points = 5,
};
for (int j = 0; j < 50; j++)
{
q.Answers.Add(new Answer()
{
Explanation = "",
Text = "text",
OrderId = j,
});
}
quizTemp.Questions.Add(q);
}
ctx.Set <Models.Quiz>().AddOrUpdate(i => i.Name,
quizTemp
);
ctx.SaveChanges();
}
}
// GET: Quizs/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Models.Quiz quiz = db.Quizs.Find(id);
if (quiz == null)
{
return(HttpNotFound());
}
else
{
QuizCategoriesViewModel model = new QuizCategoriesViewModel();
model.Quiz = quiz;
model.QuizCategories = db.QuizCategories.ToList();
return(View(model));
}
}
public async Task <IActionResult> AddQuiz([FromBody] Models.Quiz quiz)
{
var quizExist = await _quizRepository.GetQuizzes(quiz.SchoolId);
if (quizExist != null && quizExist.Count > 0)
{
foreach (var name in quizExist)
{
if (name != null && name.QuizName.ToLower() == quiz.QuizName.ToLower())
{
return(Conflict($"A quiz with the name {quiz.QuizName} already exists"));
}
}
}
if (string.IsNullOrEmpty(quiz.QuizName))
{
return(NotFound($"Quiz name is required"));
}
var result = _quizRepository.AddQuiz(quiz);
return(Ok(result));
}
public void OnGet(int quizId)
{
quiz = _context.Quizzes.Include(q => q.Questions).ThenInclude(q => q.Answers).FirstOrDefault(q => q.ID == quizId);
}
public async Task <Models.Quiz> AddQuizAsync(Models.Quiz Quiz)
{
return(await PostJsonAsync <Models.Quiz>(CreateAuthorizationPolicyUrl($"{Apiurl}", Quiz.ModuleId), Quiz));
}
public void DeleteQuiz(int QuizId)
{
Models.Quiz Quiz = _db.Quizzes.Find(QuizId);
_db.Quizzes.Remove(Quiz);
_db.SaveChanges();
}
public async Task <Models.Quiz> UpdateQuizAsync(Models.Quiz Quiz)
{
return(await PutJsonAsync <Models.Quiz>(CreateAuthorizationPolicyUrl($"{Apiurl}/{Quiz.QuizId}", Quiz.ModuleId), Quiz));
}
public void OnGet(int quizId)
{
quiz = _context.Quizzes.Include(q => q.Responses).FirstOrDefault(q => q.ID == quizId);
}
