public IActionResult Post(QuizViewModel model)
{
if (model == null)
{
return(new StatusCodeResult(500));
}
var quiz = DbContext.Quizzes.Where(q => q.Id ==
model.Id).FirstOrDefault();
if (quiz == null)
{
return(NotFound(new
{
Error = String.Format("Quiz ID {0} has not been found",
model.Id)
}));
}
quiz.Title = model.Title;
quiz.Description = model.Description;
quiz.Text = model.Text;
quiz.Notes = model.Notes;
quiz.LastModifiedDate = quiz.CreatedDate;
DbContext.SaveChanges();
return(new JsonResult(quiz.Adapt <QuizViewModel>(),
JsonSettings));
}
// Return a collection of unique questions that the user
private List <Question> getUsersQuestions(QuizViewModel quiz)
{
List <Question> questionPool = _quizData.SelectQuestionsForTopic(quiz.TopicID).ToList();
List <Question> UsersQuestions = questionPool.Where(q => q.Creator == _currentUser).ToList();
return(UsersQuestions);
}
public void PlayTest()
{
var answerCount = 0;
var quiz = new QuizViewModel(QuizGenerator.Generate());
var vm = new PlayViewModel(_locatorMock.Object, _quizMock.Object, _questionMock.Object, _answerMock.Object)
{
CurrentQuiz = quiz
};
// Verify that the quiz instance has been saved
_quizMock.Verify(q => q.CreateInstance(It.IsAny<QuizInstance>()), Times.Exactly(1));
// Iterate available questions
foreach (var quizQuestion in quiz.QuizQuestions)
{
var question = quizQuestion.Question;
answerCount += question.Answers.Count;
Assert.AreEqual(question.QuestionId, vm.CurrentQuestion.QuestionId, $"QuestionID should be \"{question.QuestionId}\"");
vm.SelectedAnswer = new AnswerViewModel(question.Answers.FirstOrDefault());
vm.NextCommand.Execute(null);
}
// Verify that the quiz has ended
Assert.AreEqual(true, vm.IsComplete, "Quiz should have ended by now");
// Verify that all the questions have been saved
_questionMock.Verify(q => q.CreateInstance(It.IsAny<QuestionInstance>()), Times.Exactly(quiz.QuizQuestionCount));
// Verify that all the answers have been saved
_answerMock.Verify(a => a.CreateInstance(It.IsAny<AnswerInstance>()), Times.Exactly(answerCount));
}
public IActionResult Put([FromBody] QuizViewModel model)
{
if (model == null)
{
return(new StatusCodeResult(500));
}
var quiz = DbContext.Quizzes.Where(q => q.Id == model.Id).FirstOrDefault();
if (quiz == null)
{
return(NotFound(new
{
Error = $"Quiz ID {model.Id} has not been found",
}));
}
quiz.Title = model.Title;
quiz.Description = model.Description;
quiz.Text = model.Text;
quiz.Notes = model.Notes;
quiz.LastModifiedDate = DateTime.Now;
quiz.UserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
DbContext.SaveChanges();
return(new JsonResult(
quiz.Adapt <QuizViewModel>(),
JsonSettings));
}
public async Task <ActionResult> Attempt(int QuizID)
{
var quiz = await db.Quizzes.FindAsync(QuizID);
if (quiz == null || !quiz.IsActive)
{
return(HttpNotFound());
}
QuizViewModel model = new QuizViewModel();
model.PageInfo = new PageInfo()
{
PageTitle = string.Format("Quiz : {0}", quiz.Name),
PageDescription = quiz.Description
};
model.ID = quiz.ID;
model.Name = quiz.Name;
model.Description = quiz.Description;
model.TimeDuration = quiz.TimeDuration;
model.Hours = quiz.TimeDuration.Hours;
model.Minutes = quiz.TimeDuration.Minutes;
return(View(model));
}
public void Add(QuizViewModel model)
{
if (model == null)
{
throw new HttpResponseException(HttpStatusCode.NoContent);
}
}
public IActionResult Post([FromBody] QuizViewModel model)
{
if (model == null)
{
return(new StatusCodeResult(500));
}
var quiz = new Quiz();
quiz.Title = model.Title;
quiz.Description = model.Description;
quiz.Text = model.Text;
quiz.Notes = model.Notes;
quiz.CreatedDate = DateTime.Now;
quiz.LastModifiedDate = quiz.CreatedDate;
quiz.UserId = DbContext.Users.Where(u => u.UserName == "Admin").FirstOrDefault().Id;
DbContext.Quizzes.Add(quiz);
DbContext.SaveChanges();
return(new JsonResult(
quiz.Adapt <QuizViewModel>(),
JsonSettings));
}
// GET: Quizs/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var quiz = await _quizData.Items
.Include(q => q.Topic)
.FirstOrDefaultAsync(m => m.QuizID == id);
if (quiz == null)
{
return(NotFound());
}
QuizViewModel QVM = new QuizViewModel
{
QuizID = quiz.QuizID,
NumberOfQuestions = quiz.NumberOfQuestions,
TopicDescription = quiz.Topic.Description,
Score = quiz.Score,
Questions = _quizData.QuizQuestions(quiz.QuizID).ToList()
};
return(View(QVM));
}
public async Task <QuizViewModel?> GetQuizAsync(string id)
{
var retrieveOperation = TableOperation.Retrieve <QuizEntity>(Quizzes, id);
var result = await _quizzesTable.ExecuteAsync(retrieveOperation);
return(result.Result is QuizEntity entity?QuizViewModel.FromJson(entity.Json) : null);
}
public async Task GetResultsAsync(string id)
{
if (id == HubConstants.Active)
{
var activeQuiz = await _quizDataContext.GetActiveQuizAsync();
if (activeQuiz != null)
{
await Groups.AddToGroupAsync(Context.ConnectionId, HubConstants.Active);
var quiz = QuizViewModel.FromJson(activeQuiz.Json);
id = quiz.ID;
var counter = await _quizDataContext.GetConnectionCountAsync();
await Clients.Caller.SendAsync(HubConstants.ConnectedMethod, new ConnectionViewModel()
{
Counter = counter
});
}
}
await Groups.AddToGroupAsync(this.Context.ConnectionId, id);
var resultsBuilder = new QuizResultBuilder(_quizDataContext);
var results = await resultsBuilder.GetResultsAsync(id);
await Clients.Caller.SendAsync(HubConstants.ResultsMethod, results);
}
public async Task <QuizViewModel?> ActivateQuizAsync(string id)
{
var retrieveOperation = TableOperation.Retrieve <QuizEntity>(Quizzes, id);
var result = await _quizzesTable.ExecuteAsync(retrieveOperation);
if (!(result.Result is QuizEntity quizEntity))
{
// No quiz found so clear the current active quiz
var retrieveActiveQuizOperation = TableOperation.Retrieve <QuizEntity>(Active, Active);
var activeQuizResult = await _quizzesTable.ExecuteAsync(retrieveActiveQuizOperation);
if (activeQuizResult.Result is QuizEntity activeQuiz)
{
var deleteOperation = TableOperation.Delete(activeQuiz);
await _quizzesTable.ExecuteAsync(deleteOperation);
}
return(null);
}
var quiz = QuizViewModel.FromJson(quizEntity.Json);
if (quiz.Questions.Any(q => q.Parameters.ClearOnActivation))
{
await DeleteResponsesAsync(quiz.ID);
}
quizEntity.PartitionKey = quizEntity.RowKey = Active;
var upsertOperation = TableOperation.InsertOrReplace(quizEntity);
var upsertResult = await _quizzesTable.ExecuteAsync(upsertOperation);
return(quiz);
}
public IActionResult EditQuiz(QuizViewModel vm)
{
var quizService = new QuestionService(CurrentUser.Id);
quizService.UpdateTitle(vm.Quiz.Id, vm.Quiz.Title);
return(RedirectToAction("EditQuiz", "User", new { id = vm.Quiz.Id }));
}
public IActionResult AddQuestion(QuizViewModel vm)
{
var quizService = new QuestionService(CurrentUser.Id);
quizService.InsertQuestion(vm.Quiz.Id, vm.NewQuestion);
return(RedirectToAction("EditQuiz", "User", new { id = vm.Quiz.Id }));
}
public QuizViewModel GetQuizById(int quizId)
{
var quiz = this.applicationDbContext.Quizes
.Include(x => x.Questions)
.ThenInclude(x => x.Answers)
.FirstOrDefault(x => x.Id == quizId);
var quizViewModel = new QuizViewModel
{
Id = quizId,
Title = quiz.Title,
Questions = quiz.Questions.Select(x => new QuestionViewModel
{
Id = x.Id,
Title = x.Title,
Answers = x.Answers.Select(a => new AnswerViewModel
{
Id = a.Id,
Title = a.Title
})
.ToList()
})
.ToList()
};
return(quizViewModel);
}
public IActionResult Put([FromBody] QuizViewModel model)
{
if (model == null)
{
return(new StatusCodeResult(500));
}
var quiz = new Quiz
{
Title = model.Title,
Description = model.Description,
Text = model.Text,
Notes = model.Notes,
CreatedDate = DateTime.Now,
LastModifiedDate = DateTime.Now
};
//dummy until we retrieve the actual user
//quiz.UserId = DbContext.Users.Where(u => u.UserName == "Admin").FirstOrDefault().Id;
quiz.UserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
DbContext.Quizzes.Add(quiz);
DbContext.SaveChanges();
return(new JsonResult(quiz.Adapt <QuizViewModel>(), JsonSettings));
}
public IActionResult Put([FromBody] QuizViewModel vm)
{
if (vm == null)
{
return(new StatusCodeResult(500));
}
var quiz = _context.Quizzes.Where(x => x.Id == vm.Id).FirstOrDefault();
if (quiz == null)
{
return(NotFound(new
{
Error = String.Format("Quiz {0} ID has not been found", vm.Id)
}));
}
quiz.Title = vm.Title;
quiz.Description = vm.Description;
quiz.Text = vm.Text;
quiz.Notes = vm.Notes;
quiz.LastModified = quiz.CreatedDate;
_context.SaveChanges();
return(new JsonResult(quiz.Adapt <QuizViewModel>(), JsonSettings));
}
public IActionResult Post([FromBody] QuizViewModel model)
{
if (model == null)
{
return(new StatusCodeResult(500));
}
var quiz = new Quiz();
quiz.Title = model.Title;
quiz.Description = model.Description;
quiz.Text = model.Text;
quiz.Notes = model.Notes;
quiz.CreatedDate = DateTime.Now;
quiz.LastModifiedDate = quiz.CreatedDate;
quiz.UserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
DbContext.Quizzes.Add(quiz);
DbContext.SaveChanges();
return(new JsonResult(quiz.Adapt <QuizViewModel>(), JsonSettings));
}
public async Task <QuizViewModel?> GetActiveQuizAsync()
{
var retrieveUserOperation = TableOperation.Retrieve <QuizEntity>(Active, Active);
var result = await _quizzesTable.ExecuteAsync(retrieveUserOperation);
return(result.Result is QuizEntity entity?QuizViewModel.FromJson(entity.Json) : null);
}
public IActionResult Put([FromBody] QuizViewModel model)
{
if (model == null)
{
return(new StatusCodeResult(500));
}
var quiz = DbContext.Quizzes.Where(q => q.Id == model.Id).FirstOrDefault();
if (quiz == null)
{
return(NotFound(new { Error = string.Format("nie znaleziono quizu o id: {0}", model.Id) }));
}
quiz.Title = model.Title;
quiz.Description = model.Description;
quiz.Notes = model.Description;
quiz.Text = model.Text;
quiz.LastModifiedDate = DateTime.Now;
DbContext.SaveChanges();
return(new JsonResult(quiz.Adapt <QuizViewModel>(), JsonSettings));
}
// Set short answer questions
public QuizViewModel SetQuestionsSAQuiz(QuizViewModel quizVM)
{
// Create a dictionary to help grade the quiz on server side
Dictionary <int, string> valuePairs = new Dictionary <int, string>();
// Set the displayed questions based on the boolean from the user
// Populate the keys of the dictionary with the appropriate QuestionIDs
if (quizVM.PrivateSource)
{
quizVM.Questions = getUsersQuestions(quizVM);
foreach (var item in quizVM.Questions)
{
valuePairs.Add(item.QuestionID, null);
}
}
else
{
quizVM.Questions = getUniqueQuestions(quizVM);
foreach (var item in quizVM.Questions)
{
valuePairs.Add(item.QuestionID, null);
}
}
// set the VM property to the new dictionary
quizVM.QidGuess = valuePairs;
return(quizVM);
}
public IActionResult Put([FromBody] QuizViewModel model)
{
// return a generic HTTP Status 500 (Server Error)
// if the client payload is invalid.
if (model == null)
{
return(new StatusCodeResult(500));
}
// handle the insert (without object-mapping)
var quiz = new Quiz
{
// properties taken from the request
Title = model.Title,
Description = model.Description,
Text = model.Text,
Notes = model.Notes,
// properties set from server-side
CreatedDate = DateTime.Now
};
quiz.LastModifiedDate = quiz.CreatedDate;
// Set a temporary author using the Admin user's userId
// as user login isn't supported yet: we'll change this later on.
// retrieve the current user's Id
quiz.UserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
// add the new quiz
DbContext.Quizzes.Add(quiz);
// persist the changes into the Database.
DbContext.SaveChanges();
// return the newly-created Quiz to the client.
return(new JsonResult(quiz.Adapt <QuizViewModel>(), JsonSettings));
}
public IActionResult GenerateRecentlyAddedQuestionsQuiz()
{
List <QuestionDto> quiz = _quizService.GenerateRecentlyAddedQuestionsQuiz();
var quizViewModel = new QuizViewModel(quiz);
return(View("Quiz", quizViewModel));
}
//copy constructor
public Quiz(QuizViewModel model)
{
this.Name = model.Name;
this.numberOfQustionsPerTry = model.NumberOdQuestionsPerTry;
this.time = model.Time;
this.Questions = new List <Question>();
foreach (QuestionModel questionModel in model.Questions)
{
Question tempQuestion = new Question();
tempQuestion.QuestionText = questionModel.QuestionText;
tempQuestion.Points = questionModel.Points;
tempQuestion.Picture = questionModel.PicturePath;
foreach (BaseAnswerModel answer in questionModel.Answers)
{
if (answer.type.Contains("text"))
{
TextAnswer temp = new TextAnswer(answer.text, answer.IsCorrect);
tempQuestion.Answers.Add(temp);
}
else if (answer.type.Contains("region"))
{
tempQuestion.Answers.Add(new RegionAnswer(answer.x1, answer.x2, answer.y1, answer.y2, answer.IsCorrect));
}
}
this.Questions.Add(tempQuestion);
}
}
public QuizViewModel GetQuizById(int quizId)
{
var quiz = this.db.Quizes
.Include(x => x.Questions)
.ThenInclude(x => x.Answers)
.FirstOrDefault(x => x.Id == quizId);
var quizViewModel = new QuizViewModel
{
Id = quizId,
Title = quiz.Title,
Questions = quiz.Questions.OrderBy(r => Guid.NewGuid()).Select(x => new QuestionViewModel
{
Id = x.Id,
Title = x.Title,
Answers = x.Answers.OrderBy(r => Guid.NewGuid()).Select(a => new AnswerViewModel
{
Id = a.Id,
Title = a.Title
})
.ToList()
})
.ToList()
};
return(quizViewModel);
}
public IActionResult Put([FromBody] QuizViewModel model)
{
// return a generic HTTP Status 500 (Server Error)
// if the client payload is invalid.
if (model == null)
{
return(new StatusCodeResult(500));
}
// handle the insert (without object-mapping)
var quiz = new Quiz();
// properties taken from the request
quiz.Title = model.Title;
quiz.Description = model.Description;
quiz.Text = model.Text;
quiz.Notes = model.Notes;
// properties set from server-side
quiz.CreatedDate = DateTime.Now;
quiz.LastModifiedDate = quiz.CreatedDate;
// Set a temporary author using the Admin user's userId
// as user login isn't supported yet: we'll change this later on.
quiz.UserId = DbContext.Users.Where(u => u.UserName == "Admin").FirstOrDefault().Id;
// add the new quiz
DbContext.Quizzes.Add(quiz);
// persist the changes into the Database.
DbContext.SaveChanges();
// return the newly-created Quiz to the client.
return(new JsonResult(quiz.Adapt <QuizViewModel>(), JsonSettings));
}
public IActionResult Post([FromBody] QuizViewModel model)
{
// return a generic HTTP Status 500 (Server Error)
// if the client payload is invalid.
if (model == null)
{
return(new StatusCodeResult(500));
}
// retrieve the quiz to edit
var quiz = DbContext.Quizzes.Where(q => q.Id == model.Id).FirstOrDefault();
// handle requests asking for non-existing quizzes
if (quiz == null)
{
return(NotFound(new
{
Error = String.Format("Quiz ID {0} has not been found", model.Id)
}));
}
// handle the update (without object-mapping)
// by manually assigning the properties
// we want to accept from the request
quiz.Title = model.Title;
quiz.Description = model.Description;
quiz.Text = model.Text;
quiz.Notes = model.Notes;
// properties set from server-side
quiz.LastModifiedDate = quiz.CreatedDate;
// persist the changes into the Database.
DbContext.SaveChanges();
// return the updated Quiz to the client.
return(new JsonResult(quiz.Adapt <QuizViewModel>(), JsonSettings));
}
public IActionResult Put([FromBody]QuizViewModel model)
{
// return a generic HTTP status 500 (Server Error)
// if the client payload is invalid.
if (model == null) return new StatusCodeResult(500);
// handle the insert (without object-mapping)
// properties taken from the request
var quiz = new Quiz
{
Title = model.Title,
Description = model.Description,
Text = model.Text,
Notes = model.Notes
};
// properties taken from server-side
quiz.CreatedDate = DateTime.Now;
quiz.LastModifiedDate = quiz.CreatedDate;
// retrieve the current user's Id
quiz.UserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
// add the new quiz
DbContext.Quizzes.Add(quiz);
DbContext.SaveChanges();
// return the newly-created Quiz to the client.
return new JsonResult(quiz.Adapt<QuizViewModel>(), JsonSettings);
}
public async Task <SelectList> GenerateQuizesDropdown(bool selectEmpty = false, string specificIdToSelect = null)
{
var allItems = await _quiz.GetAsync();
var emptyQuiz = new QuizViewModel()
{
Id = -1,
Name = "*** Leave this for no Quiz assignment ***"
};
allItems.Add(emptyQuiz);
var quizesDropdownValues = new SelectList(allItems, "Id", "Name");
if (selectEmpty)
{
var selected = quizesDropdownValues.Where(x => x.Value == "-1").First();
selected.Selected = true;
}
if (specificIdToSelect != null)
{
var selected = quizesDropdownValues.Where(x => x.Value == specificIdToSelect).First();
selected.Selected = true;
}
return(quizesDropdownValues);
}
public ActionResult Create(QuizViewModel model)
{
var user = User.Identity.GetUserId();
if (ModelState.IsValid)
{
Quiz quiz = new Quiz
{
TutorialId = db.Tutorials.First(x => x.Title == model.TutorialSelection).ID,
EducatorId = User.Identity.GetUserId(),
Name = model.Name,
Goal = model.Goal,
Instruction = model.Instruction,
DisplayedCode = model.DisplayedCode,
ExpectedInput = model.ExpectedInput,
ExpectedOutput = model.ExpectedOutput,
ErrorMessage = model.ErrorMessage,
Answer = model.Answer
};
db.Quiz.Add(quiz);
db.SaveChanges();
return RedirectToAction("Index");
}
ViewData["TutorialSelection"] = new SelectList(db.Tutorials.Where(x => x.EducatorId == user).ToList(), "Title", "Title");
return View();
}
public ActionResult Index(QuizViewModel model, QuizAction action)
{
long temp = 0;
string answer = this.Request.Form["Answer"];
if (!string.IsNullOrEmpty(answer))
{
temp = int.Parse(this.Request.Form["Answer"]);
}
switch (action)
{
case QuizAction.Submit:
model.ItemNumber++;
model.UserAnswer.Add(temp);
this.ModelState.Remove("ItemNumber");
calculationService.Num1 = randomiserService.RanFunc();
calculationService.Num2 = randomiserService.RanFunc();
model.QuizQuestions.Add(calculationService.RandomFunction(calculationService.Num1, calculationService.Num2));
model.QuizAnswer.Add(calculationService.RandomFunctionResult(calculationService.Num1, calculationService.Num2));
return(this.View(model));
case QuizAction.Finish:
for (int i = 0; i < model.QuizAnswer.Count - 1; i++)
{
if (model.UserAnswer[i] == model.QuizAnswer[i])
{
model.CorrectAnswers += 1;
}
}
return(this.View("Result", model));
default:
throw new ArgumentOutOfRangeException(nameof(action), action, null);
}
}
public async Task <bool> CreateQuizAsync(QuizViewModel quizViewModel, CancellationToken cancellationToken = default)
{
using (SqlConnection connection = new SqlConnection(DefaultDataConfig.ConnectionString))
{
int insertedRecord = 0;
try
{
SqlCommand command = new SqlCommand("qsp_createQuiz", connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@Name", quizViewModel.Name);
command.Parameters.AddWithValue("@PassPercentage", quizViewModel.PassPercentage);
connection.Open();
insertedRecord = await command.ExecuteNonQueryAsync(cancellationToken);
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
connection.Close();
}
return(false);
}
}
public IActionResult Put([FromBody] QuizViewModel model)
{
// return a generic HTTP Status 500 (Server Error)
// if the client payload is invalid.
if (model == null)
{
return(new StatusCodeResult(500));
}
// map the ViewModel to the Model
var quiz = model.Adapt <Quiz>();
// override those properties
// that should be set from the server-side only
quiz.CreatedDate = DateTime.Now;
quiz.LastModifiedDate = quiz.CreatedDate;
// Set a temporary author using the Admin user's userId
// as user login isn't supported yet: we'll change this later on.
quiz.UserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
// add the new quiz
DbContext.Quizzes.Add(quiz);
// persist the changes into the Database.
DbContext.SaveChanges();
// return the newly-created Quiz to the client.
return(new JsonResult(quiz.Adapt <QuizViewModel>(),
JsonSettings));
}
private void AddQuiz()
{
try
{
Quiz Q = new Quiz();
Q.Name = _QuizName;
DbContext.Quizen.Add(Q);
DbContext.SaveChanges();
QuizViewModel QVM = new QuizViewModel(Q);
this.Quizes.Add(QVM);
RaisePropertyChanged("Quizes");
}
catch { }
}
private void PlayRandom()
{
if (SelectedCategory == null) return;
var quiz = new QuizViewModel
{
QuizId = 1337,
Name = SelectedCategory.Name
};
var questions = _questionRepository.GetQuestions()
.Where(q => q.CategoryId == SelectedCategory.CategoryId)
.Select(qq => new QuizQuestion
{
QuizId = quiz.QuizId,
Quiz = quiz,
QuestionId = qq.QuestionId,
Question = qq
})
.ToList();
if (questions.Count < 2)
{
MessageBox.Show("De opgegeven categorie bevat niet genoeg vragen.");
return;
}
quiz.QuizQuestions = questions;
Play(quiz);
}
void OnRemoveQuiz()
{
if(_windowService.AskConfirmation("Wil je deze Quiz echt verwijderen?", "EditorView"))
{
SelectedQuiz.RemoveQuizCommand.Execute(null);
AllQuizes.Remove(SelectedQuiz);
SelectedQuiz = new QuizViewModel(new Quiz() { Questions = new List<QuizQuestion>() }, _quizRepo, _questionRepo, _categoryRepo, _notificationService);
RemoveQuizCommand.RaiseCanExecuteChanged();
}
}
void OnAddQuiz()
{
SelectedQuiz = new QuizViewModel(new Quiz() { Questions = new List<QuizQuestion>() }, _quizRepo, _questionRepo, _categoryRepo, _notificationService);
AllQuizes.Add(SelectedQuiz);
RaisePropertyChanged("CanEditQuiz");
}
public EditorViewModel(IRepository<Quiz> quizRepo,
IRepository<Category> categoryRepo,
IRepository<Question> questionRepo,
INotificationService notificationService,
IWindowService windowService)
{
_windowService = windowService;
_notificationService = notificationService;
_quizRepo = quizRepo;
_questionRepo = questionRepo;
_categoryRepo = categoryRepo;
AllQuizes = new ObservableCollection<QuizViewModel>();
AllQuestions = new ObservableCollection<QuestionViewModel>();
AllCategories = new ObservableCollection<CategoryViewModel>();
notificationService.OnStartedLoading += NotificationService_OnLoadingChanged;
notificationService.OnStoppedLoading += NotificationService_OnLoadingChanged;
notificationService.OnNewDisplayMessage += NotificationService_OnNewDisplayMessage;
notificationService.OnMessageReceived += NotificationService_OnMessageReceived;
LoadingVisibility = Visibility.Hidden;
NotificationVisibility = Visibility.Hidden;
RemoveQuizCommand = new RelayCommand(OnRemoveQuiz, CanRemoveQuiz);
AddQuizCommand = new RelayCommand(OnAddQuiz);
RemoveQuestionCommand = new RelayCommand(OnRemoveQuestion, CanRemoveQuestion);
AddQuestionCommand = new RelayCommand(OnAddQuestion);
AddAnswerCommand = new RelayCommand(OnAddAnwer, CanAddAnswer);
RemoveAnswerCommand = new RelayCommand(OnRemoveAnswer, CanRemoveAnswer);
SaveQuestionCommand = new RelayCommand(OnSaveQuestion, CanSaveQuestion);
CloseNotificationCommand = new RelayCommand(OnCloseNotification);
Task.Run(() =>
{
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
LoadingVisibility = Visibility.Visible;
});
var allQuizes = new List<QuizViewModel>();
var allQuestions = new List<QuestionViewModel>();
var allCategories = new List<CategoryViewModel>();
foreach (var quiz in _quizRepo.GetAllItems())
{
allQuizes.Add(new QuizViewModel(quiz, _quizRepo, _questionRepo, _categoryRepo, notificationService));
}
foreach (var question in _questionRepo.GetAllItems())
{
allQuestions.Add(new QuestionViewModel(question, _questionRepo, _categoryRepo, _notificationService));
}
foreach (var categorie in _categoryRepo.GetAllItems())
{
allCategories.Add(new CategoryViewModel(categorie, _categoryRepo, _notificationService));
}
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
allQuizes.ForEach(q => AllQuizes.Add(q));
allQuestions.ForEach(q => AllQuestions.Add(q));
allCategories.ForEach(c => AllCategories.Add(c));
RaisePropertyChanged("AllQuizes");
RaisePropertyChanged("AllQuestions");
RaisePropertyChanged("AllCategories");
LoadingVisibility = Visibility.Hidden;
});
});
SelectedQuiz = new QuizViewModel(new Quiz() { Questions = new List<QuizQuestion>() }, _quizRepo, _questionRepo, _categoryRepo, notificationService);
SelectedQuestion = new QuestionViewModel(new Question() { Answers = new List<Answer>(), Category = new Category() }, _questionRepo, _categoryRepo, _notificationService);
NewCategory = new CategoryViewModel(new Category(), _categoryRepo, _notificationService);
//SelectedTabIndex = 1;
}
private void SaveQuiz()
{
if (string.IsNullOrEmpty(SelectedQuiz.Name))
MessageBox.Show("Vul a.u.b. een naam in.");
else if (IsNewQuiz)
{
IsNewQuiz = false;
var poco = _quizRepository.CreateQuiz(SelectedQuiz);
SelectedQuiz = new QuizViewModel(poco);
Quizzes.Add(SelectedQuiz);
MessageBox.Show("Quiz toegevoegd.");
}
else if (SelectedQuiz != null)
{
_quizRepository.UpdateQuiz(SelectedQuiz);
MessageBox.Show("Quiz aagepast.");
}
}
private void Play(QuizViewModel quiz)
{
if (quiz == null)
MessageBox.Show("Onverwachte fout.");
var vm = _viewModelLocator.Get<PlayViewModel>();
vm.CurrentQuiz = quiz;
var wnd = WindowHelper.Switch<PlayWindow>();
wnd.Closed += (sender, args) => WindowHelper.Show<HomeWindow>();
}
private void AddQuiz()
{
if (IsNewQuiz) return;
IsNewQuiz = true;
SelectedQuiz = new QuizViewModel();
}
public GameViewModel(QuizViewModel quiz,
IRepository<Quiz> quizRepo,
IRepository<Question> questionRepo,
IRepository<Category> categoryRepo,
INotificationService notificationService,
IWindowService windowService)
{
_windowService = windowService;
_quizRepo = quizRepo;
_questions = new Queue<QuestionViewModel>();
_quiz = quiz;//new QuizViewModel(_quizRepo.AsQueryable().First(), quizRepo, questionRepo, categoryRepo, notificationService);
SelectAnswerCommand = new RelayCommand<Answer>(OnSelectAnswer);
CloseWindowCommand = new RelayCommand(OnCloseWindow);
foreach (var question in _quiz.Questions.Shuffle(new Random()))
{
_questions.Enqueue(question);
}
CurrentQuestion = _questions.Peek();
CurrentQuestionCount = 1;
LoadingVisibility = Visibility.Hidden;
DoneVisibility = Visibility.Hidden;
}
