public ActionResult CreateQuizItem(int id)
{
var service = new QuizService();
var model = service.InitializeEditQuizItemModel(id, null);
return(View("Quiz/CreateQuizItem", model));
}
public void DeleteQuizCorrect()
{
var quiz = new Quiz
{
Id = 1,
Naam = "Quiz 1"
};
//Arange
var unitOfWork = new Mock <ITeamQuizRondeUnitOfWork>();
unitOfWork.Setup(x => x.QuizRepository.Remove(1)).Returns(true);
var quizService = new QuizService(unitOfWork.Object);
//Act
var quizDTO = new QuizDTO
{
Id = 1,
Naam = "Quiz 1"
};
//Assert
Assert.IsFalse(quizService.Delete(1).DidError);
Assert.IsTrue(quizService.FindQuiz(quiz.Id).DidError);
Assert.IsNull(quizService.FindQuiz(quiz.Id).DTO);
}
protected void Page_Load(object sender, EventArgs e)
{
courseId = Request.QueryString["csid"];
lessonId = Request.QueryString["lsid"];
if (!IsPostBack)
{
ScormRepeater.DataSource = ScormService.LoadAllScorms(SessionVariable.Current.Company.Id).OrderBy(x => x.Name);
ScormRepeater.DataBind();
QuizRepeater.DataSource = QuizService.LoadAllQuizzes(SessionVariable.Current.Company.Id).OrderBy(x => x.Title);
QuizRepeater.DataBind();
var lesson = LessonService.GetLessonById(SessionVariable.Current.Company.Id, courseId, lessonId);
if (lesson != null)
{
LessonName.Text = lesson.Name;
Description.Text = lesson.Description;
if (lesson.Course.CourseType == CourseTypeEnum.External)
{
Panel1.Visible = false;
}
else
{
CurriculumType.SelectedValue = ((int)lesson.LessonType).ToString();
ScormId.Value = lesson.ScormId;
QuizId.Value = lesson.QuizId;
}
}
}
}
public async Task ExecuteGroupAsync(CommandContext ctx,
[Description("desc-game-quiz-cat-id")] int id,
[Description("desc-game-quiz-amount")] int amount = 10,
[Description("desc-game-quiz-diff")] int diff = 0)
{
if (amount is < 5 or > 20)
{
throw new CommandFailedException(ctx, "cmd-err-game-quiz-amount", 5, 20);
}
if (diff is < 0 or > 2)
{
throw new CommandFailedException(ctx, "cmd-err-game-quiz-diff");
}
if (this.Service.IsEventRunningInChannel(ctx.Channel.Id))
{
throw new CommandFailedException(ctx, "cmd-err-evt-dup");
}
IReadOnlyList <QuizQuestion>?questions = await QuizService.GetQuestionsAsync(id, amount, (QuestionDifficulty)diff);
if (questions is null || !questions.Any())
{
throw new CommandFailedException(ctx, "cmd-err-game-quiz-cat");
}
var quiz = new QuizGame(ctx.Client.GetInteractivity(), ctx.Channel, questions);
await this.RunQuizAsync(ctx, quiz);
}
protected async Task <bool> TrySavingChanges()
{
if (Id == 0)
{
var addedQuiz = await QuizService.AddQuiz(OneQuiz);
if (addedQuiz != null)
{
Console.WriteLine("Id:{0}", addedQuiz.Id);
Id = addedQuiz.Id;
OneQuiz.Id = addedQuiz.Id;
StatusClass = "uk-text-success";
Message = "New playlist added successfully";
StateHasChanged();
return(true);
}
else
{
StatusClass = "uk-text-danger";
Message = "Something went wrong";
return(false);
}
}
else
{
await QuizService.UpdateQuiz(OneQuiz);
StatusClass = "uk-text-success";
Message = "Playlist updated successfully";
StateHasChanged();
return(true);
}
}
public async Task <ActionResult> Play(string id)
{
var quizSubmissionId = Guid.NewGuid().ToString();
var quiz = await QuizService.GetQuiz(id);
var model = new Play
{
Id = quizSubmissionId,
QuizzardUserId = User.Identity.GetUserId(),
};
var partialList = new List <ViewWrapper>();
foreach (var question in quiz.Questions)
{
using (var container = AutofacSetup.Container.BeginLifetimeScope())
{
var controller = container.ResolveKeyed <QuestionBaseController>(question.QuestionTypeId);
var emptySubmissionAnswer = new QuizSubmissionAnswerModel(quizSubmissionId, question);
model.Answers.Add(emptySubmissionAnswer);
controller.ContextualizeController(nameof(controller.QuestionPlayView));
var result = await controller.QuestionPlayView(emptySubmissionAnswer);
var viewLocations = result.ViewEngineCollection.FindPartialView(controller.ControllerContext, result.ViewName);
result.View = viewLocations.View;
model.QuestionPartials.Add(new ViewWrapper((RazorView)viewLocations.View, result.Model));
}
}
model.Quiz = quiz;
model.QuizId = quiz.Id;
return(View(model));
}
public void Setup()
{
var questions = new List <Question>()
{
new Question(Guid.NewGuid(), "Question 1", new List <QuestionAnswer>()
{
new QuestionAnswer(Guid.NewGuid(), "", true)
}),
new Question(Guid.NewGuid(), "Question 2", new List <QuestionAnswer>()
{
new QuestionAnswer(Guid.NewGuid(), "", true)
}),
new Question(Guid.NewGuid(), "Question 3", new List <QuestionAnswer>()
{
new QuestionAnswer(Guid.NewGuid(), "", true)
}),
new Question(Guid.NewGuid(), "Question 4", new List <QuestionAnswer>()
{
new QuestionAnswer(Guid.NewGuid(), "", true)
}),
};
var questionRepo = Substitute.For <IQuestionRepository>();
questionRepo.GetAll().ReturnsForAnyArgs(questions);
var validator = new StartQuizCommandValidator();
_service = new QuizService(questionRepo, validator);
}
public ActionResult DeleteQuiz(int id, string test)
{
var service = new QuizService();
service.DeleteQuiz(id);
return(RedirectToAction("ManageQuiz"));
}
public async Task GetQuestionsAsyncTest()
{
IReadOnlyList <QuizQuestion> questions;
questions = await QuizService.GetQuestionsAsync(9);
Assert.IsNotNull(questions);
Assert.AreEqual(10, questions.Count);
CollectionAssert.AllItemsAreNotNull(questions);
CollectionAssert.AllItemsAreUnique(questions);
questions = await QuizService.GetQuestionsAsync(9, 5);
Assert.IsNotNull(questions);
Assert.AreEqual(5, questions.Count);
CollectionAssert.AllItemsAreNotNull(questions);
CollectionAssert.AllItemsAreUnique(questions);
questions = await QuizService.GetQuestionsAsync(9, 5, QuestionDifficulty.Hard);
Assert.IsNotNull(questions);
Assert.AreEqual(5, questions.Count);
CollectionAssert.AllItemsAreNotNull(questions);
CollectionAssert.AllItemsAreUnique(questions);
Assert.IsNull(await QuizService.GetQuestionsAsync(50000));
Assert.ThrowsAsync(typeof(ArgumentException), () => QuizService.GetQuestionsAsync(-1));
Assert.ThrowsAsync(typeof(ArgumentException), () => QuizService.GetQuestionsAsync(9, -1));
Assert.ThrowsAsync(typeof(ArgumentException), () => QuizService.GetQuestionsAsync(9, 0));
Assert.ThrowsAsync(typeof(ArgumentException), () => QuizService.GetQuestionsAsync(9, 100));
Assert.ThrowsAsync(typeof(ArgumentException), () => QuizService.GetQuestionsAsync(9, 21));
}
public ActionResult EditQuiz(Models.Quiz.QuizEditModel model)
{
var service = new QuizService();
service.UpdateQuiz(model);
return(RedirectToAction("QuizDetails", new { id = model.QuizId }));
}
public ActionResult DeleteQuiz(int id)
{
var service = new QuizService();
var model = service.GetQuizEditModel(id);
return(View("Quiz/Delete", model));
}
public ActionResult DeleteQuizItem(int id)
{
var service = new QuizService();
var quizId = service.DeleteQuizItem(id);
return(RedirectToAction("EditQuizItems", new { id = quizId }));
}
public ActionResult EditQuizItem(int quizId, int itemId)
{
var service = new QuizService();
var model = service.InitializeEditQuizItemModel(quizId, itemId);
return(View("Quiz/EditQuizItem", model));
}
public ActionResult CreateQuizItem(Models.Quiz.QuizItemEditModel model)
{
var service = new QuizService();
service.CreateNewQuizItemModel(model);
return(RedirectToAction("EditQuizItems", new { id = model.QuizId }));
}
public async Task GetAll_SimpleCase()
{
//Assumption: At this point, order of the quizzes isn't important.
var databaseContext = QuizTestData.GetPopulatedDatabase();
var quizManager = new Mock <IQuizManager>();
var quizService = new QuizService(databaseContext, quizManager.Object);
var quizzes = await quizService.GetAll();
Assert.IsNotNull(quizzes);
Assert.AreEqual(databaseContext.Quizzes.Count(), quizzes.Count);
Assert.AreEqual(databaseContext.Quizzes.Count(), quizzes.TotalCount);
HashSet <long> previousIds = new HashSet <long>();
foreach (QuizTerseDto quiz in quizzes.Data)
{
Assert.IsTrue(quiz.Id == QuizTestData.WeightQuiz.Id ||
quiz.Id == QuizTestData.PersonalityQuiz.Id ||
quiz.Id == QuizTestData.DisneyPrincessQuiz.Id);
//Check for duplicates.
Assert.IsFalse(previousIds.Contains(quiz.Id));
previousIds.Add(quiz.Id);
}
}
protected void CreateBtn_Click(object sender, EventArgs e)
{
QuizService.CreateQuiz(SessionVariable.Current.Company.Id, SessionVariable.Current.User.Id,
NameTextBox.Text, DescriptionTextBox.Text, float.Parse(PassPercentTextBox.Text));
Response.Redirect("QZ0001");
}
public async Task GetAll_Should_Return_List_of_Quizzes()
{
using var dbContext = GetDbContext();
var mapper = GetMapper();
var instructors = dbContext.Users.ToList();
Assert.NotEmpty(instructors);
var instructor = instructors.FirstOrDefault();
// Arrange
dbContext.Quizzes.Add(new QuizDbEntity {
Name = "TDD Quiz", InstructorId = instructor.Id, IsActive = true
});
dbContext.Quizzes.Add(new QuizDbEntity {
Name = "Design 2", InstructorId = instructor.Id, IsActive = true
});
await dbContext.SaveChangesAsync();
// Act
var service = new QuizService(dbContext, mapper);
var result = service.GetAll();
// Assert
Assert.NotNull(result);
//Assert.Equal(4, result.Count);
Assert.NotEmpty(result);
}
public ActionResult ContinueStudy(int id, string type = null)
{
IQuizService quizService = new QuizService();
ITrainingService trainingService = new TrainingService();
IAccountService accountService = new AccountService();
IModuleService moduleService = new ModuleService();
List <TrainingAccess> trainingListForModule = new List <TrainingAccess>();
List <QuizTransfer> quizListForModule = new List <QuizTransfer>();
AccountModuleAccess accountModule = new AccountModuleAccess();
string userName = User.Identity.Name;
//save data in Account_Module table
accountModule.AccountId = accountService.GetAccountId(userName);
accountModule.ModuleId = id;
accountModule.Status = "pass";
if (type == null)
{
moduleService.TakeModule(accountModule);
}
//get quiz and training list for the module assigned by customers
trainingListForModule = trainingService.GetTrainingDataForModule(id);
quizListForModule = quizService.GetQuizForModule(id);
Session["trainingListForModule"] = trainingListForModule;
Session["quizListForModule"] = quizListForModule;
return(View());
}
protected async void PageIndexChanged(PaginatedList <QuizTopic> context, int newPageNumber)
{
if (newPageNumber < 1 || newPageNumber > context.TotalPages)
{
return;
}
var cptr = context.Items.Count;
var filters = new Dictionary <string, string>();
var data = await QuizService.GetQuizzes(pageNumber : newPageNumber, filters : filters);
foreach (var elm in data.Items)
{
context.Items.Add(elm);
}
context.Items.RemoveRange(0, cptr);
context.PageIndex = data.PageIndex;
context.TotalPages = data.TotalPages;
StateHasChanged();
}
public async Task <IActionResult> PostAsync([FromBody] ResultViewModel model)
{
if (model == null)
{
return(new StatusCodeResult(500));
}
if (!await ResultService.Exists(model.QuizId))
{
return(NotFound(new { Error = String.Format("Result ID {0} has not been found", model.Id) }));
}
if (!await QuizService.Exists(model.QuizId))
{
return(NotFound(new { Error = String.Format("Quiz ID {0} has not been found", model.QuizId) }));
}
ResultDetailsServiceModel result = await ResultService.Update(
model.Id,
model.Text,
model.MinValue,
model.MaxValue,
model.QuizId);
return(new JsonResult(Mapper.Map <ResultDetailsServiceModel, ResultViewModel>(result), JsonSettings));
}
public void Add_quiz_to_database()
{
var options = new DbContextOptionsBuilder <QuizDbContext>()
.UseInMemoryDatabase(databaseName: "Add_quiz_to_database")
.Options;
using (var context = new QuizDbContext(options))
{
var service = new QuizService(context);
Quiz q1 = new Quiz {
Name = "AAA", Id = 1
};
Quiz q2 = new Quiz {
Name = "BBB", Id = 2
};
service.CreateQuiz(q1);
service.CreateQuiz(q2);
}
using (var context = new QuizDbContext(options))
{
var numberOfQuizesInDb = context.Quiz.Count();
numberOfQuizesInDb.Should().Be(2);
}
}
protected void EditBtn_Click(object sender, EventArgs e)
{
QuizService.EditQuiz(SessionVariable.Current.Company.Id, SessionVariable.Current.User.Id, quizId,
NameTextBox.Text, DescriptionTextBox.Text, float.Parse(PassPercentTextBox.Text));
Response.Redirect(Request.RawUrl);
}
public async Task ExecuteGroupAsync(CommandContext ctx)
{
IReadOnlyList <QuizCategory>?categories = await QuizService.GetCategoriesAsync();
string catStr = categories?.Select(c => $"- {Formatter.Bold(c.Name)} (ID: {c.Id})").JoinWith() ?? "";
await ctx.ImpInfoAsync(this.ModuleColor, Emojis.Question, "fmt-game-quiz-cat", catStr);
}
public async Task <ActionResult> SaveQuestion(QuestionModel model)
{
if (!ModelState.IsValid)
{
return(PartialView("_AlertSaveFailed"));
}
model.QuestionTypeId = Constants.QuestionTypes.FreeText;
if (model.QuizId == null)
{
await SaveUserQuestion(model);
}
try
{
bool success;
if (!QuizService.QuestionExists(model.Id))
{
success = await QuizService.AddQuestion(model.QuizId, model);
}
else
{
success = await QuizService.EditQuestion(model.Id, model);
}
if (!success)
{
return(PartialView("_AlertSaveFailed"));
}
}
catch (Exception e)
{
return(PartialView("_AlertSaveFailed"));
}
return(PartialView("_AlertSaveSuccess"));
}
private void RefreshQuiz()
{
try
{
curQuiz = QuizService.GetQuiz();
curQuiz?.init();
}
catch (Exception e)
{
e.CopeWith("get quiz");
return;
}
quest.OutlineColor = Color.Silver;
quest.BackgroundColor = Color.White;
(quest.Content as Label).Text = curQuiz.quest;
int a = 0;
foreach (var f in choices)
{
f.OutlineColor = Color.Silver;
f.BackgroundColor = Color.White;
(f.Content as Label).Text = curQuiz.choices[a++].Item1;
}
foreach (var l in chdess)
{
l.Text = " ";
}
}
public QuizziesPage(int quizCount)
{
InitializeComponent();
this.QuizCount = quizCount;
service = new QuizService();
getQuizzes();
}
public void AddQuizCorrect()
{
var quiz = new Quiz
{
Id = 1,
Naam = "Quiz 1",
EmailCreator = "*****@*****.**"
};
//Arange
var unitOfWork = new Mock <ITeamQuizRondeUnitOfWork>();
unitOfWork.Setup(x => x.QuizRepository.Add(It.IsAny <Quiz>())).Returns(quiz);
var quizService = new QuizService(unitOfWork.Object);
//Act
var quizDTO = new QuizDTO
{
Id = 1,
Naam = "Quiz 1",
EmailCreator = "*****@*****.**"
};
//Assert
Assert.IsFalse(quizService.AddQuiz(quizDTO).DidError);
Assert.That(quizService.AddQuiz(quizDTO).DTO.EmailCreator, Is.EqualTo(quizDTO.EmailCreator));
Assert.That(quizService.AddQuiz(quizDTO).DTO.Id, Is.EqualTo(quizDTO.Id));
Assert.That(quizService.AddQuiz(quizDTO).DTO.Naam, Is.EqualTo(quizDTO.Naam));
}
public async Task CheckGettingTheSkinQuizAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <QuizQuestion>(db);
var service = new QuizService(repository);
var firstQuestion = new QuizQuestion()
{
Id = Guid.NewGuid().ToString()
};
var secondQuestion = new QuizQuestion()
{
Id = Guid.NewGuid().ToString()
};
var thirdQuestion = new QuizQuestion()
{
Id = Guid.NewGuid().ToString()
};
await db.QuizQuestions.AddAsync(firstQuestion);
await db.QuizQuestions.AddAsync(secondQuestion);
await db.QuizQuestions.AddAsync(thirdQuestion);
await db.SaveChangesAsync();
var quiz = await service.GetQuizAsync <TestQuizModel>();
Assert.Equal(3, quiz.Count());
}
public async Task GetCategories_Should_ReturnAllCategories()
{
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
using (var context = new DataContext(options))
{
var service = new QuizService(context);
context.Categories.Add(new Category()
{
Id = 1, Name = "TestCategory", Questions = new List <Question>()
});
context.Categories.Add(new Category()
{
Id = 2, Name = "TestCategory2", Questions = new List <Question>()
});
context.SaveChanges();
var categories = service.GetCategories();
categories.Count.Should().Be(2);
categories[0].Name.Should().Be("TestCategory");
}
}
public ActionResult EditQuizItems(int id)
{
var service = new QuizService();
var model = service.GetQuizEditModel(id);
return(View("Quiz/EditQuizItems", model));
}
