public AnalyticsController(ISubCategoryRepository repo, ICategoryRepository repoCat,IUserRepository repoUser,IQuizRepository repoQuiz)
{
_repo = repo;
_repoCat = repoCat;
_repoUser = repoUser;
_repoQuiz = repoQuiz;
}
public QuizManagementServiceTest()
{
_entityValidator = A.Fake<EntityValidator>();
_quizRepository = A.Fake<IQuizRepository>();
_quizDtoMapper = A.Fake<IQuizDtoMapper>();
_questionDtoMapper = A.Fake<IQuestionDtoMapper>();
_assignedQuizDtoMapper = A.Fake<IAssignedQuizDtoMapper>();
_quizManagementService = new QuizManagementService(_quizRepository, _quizDtoMapper, _entityValidator, _questionDtoMapper, _assignedQuizDtoMapper);
_validQuiz = new Entities.Quiz
{
Name = "Test",
Description = "Description",
Questions =
new List<Question>
{
A.Fake<Question>(),
A.Fake<Question>()
}
};
_validAssignment = new AssignedQuizModel
{
Quiz = new Entities.Quiz(),
Group = new Group(),
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddDays(1)
};
}
public QuizManagementService(IQuizRepository quizRepository, IQuizDtoMapper quizDtoMapper, EntityValidator entityValidator,
IQuestionDtoMapper questionDtoMapper, IAssignedQuizDtoMapper assignedQuizDtoMapper)
{
if (quizRepository == null)
{
throw new ArgumentNullException("quizRepository");
}
if (quizDtoMapper == null)
{
throw new ArgumentNullException("quizDtoMapper");
}
if (entityValidator == null)
{
throw new ArgumentNullException("entityValidator");
}
if (questionDtoMapper == null)
{
throw new ArgumentNullException("questionDtoMapper");
}
if (assignedQuizDtoMapper == null)
{
throw new ArgumentNullException("assignedQuizDtoMapper");
}
_quizRepository = quizRepository;
_quizDtoMapper = quizDtoMapper;
_entityValidator = entityValidator;
_questionDtoMapper = questionDtoMapper;
_assignedQuizDtoMapper = assignedQuizDtoMapper;
}
protected void Page_Init(object sender, EventArgs e)
{
_QuizRepository = ModelContainer.Resolve<IQuizRepository>();
var quizzes = _QuizRepository.GetAllQuizzes();
quizGridView.DataSource = quizzes;
quizGridView.DataBind();
}
public QuizController(IUserScoreRepositories userScoreRepositories, IQuizRepository quizRepository, IQuestionRepository questionRepo
, IAnswerRepository answerRepository)
{
this.userScoreRepo = userScoreRepositories;
this.quizRepo = quizRepository;
this.questionRepo = questionRepo;
this.answerRepository = answerRepository;
}
public TeacherQuizesService(IQuizRepository quizRepository, IQuestionRepository questionRepository, IAnswerRepository answerRepository, IStudentQuizResultRepository studentQuizResultRepository, IBasicCrudService basicCrudService)
{
_quizRepository = quizRepository;
_questionRepository = questionRepository;
_answerRepository = answerRepository;
_studentQuizResultRepository = studentQuizResultRepository;
_basicCrudService = basicCrudService;
}
public PassedQuizService(IMapper mapper, IPassedQuizRepository passedquizRepository, IAnswerRepository answerRepository, IQuizRepository quizRepository, IUserService userService)
{
this._mapper = mapper;
this._passedquizRepository = passedquizRepository;
this._answerRepository = answerRepository;
this._quizRepository = quizRepository;
this._userService = userService;
}
public QuizBusiness(IQuizRepository _quizRepository, IQuestionRepository _questionRepository, IAnswerRepository _answerRepository, ICandidateQuizAssignResultRepository _candidateQuizAssignResultRepository, ICandidateQuizAssignRepository _candidateQuizAssignRepository)
{
this.quizRepository = _quizRepository;
this.questionRepository = _questionRepository;
this.answerRepository = _answerRepository;
this.candidateQuizAssignResultRepository = _candidateQuizAssignResultRepository;
this.candidateQuizAssignRepository = _candidateQuizAssignRepository;
}
public QuizsController(IQuizRepository repo, ICategoryRepository repoCat, ISubCategoryRepository repoSubCat, ILevelRepository repoLevel, IQuestionTypeRepository repoQuestionType)
{
_repo = repo;
_repoCat = repoCat;
_repoLevel = repoLevel;
_repoSubCat = repoSubCat;
_repoQuestionType = repoQuestionType;
}
public QuizQuestionController()
{
if (_quizRepo == null)
{
_quizRepo = new QuizRepositoryEF();
// quizRepo.LoadSampleQuestions();
}
}
public QuizController(IMapper mapper, UserManager <User> userManager, IQuizRepository quizRepo, ICourseRepository courseRepo, IWebHostEnvironment hostingEnvironment)
{
_mapper = mapper;
_userManager = userManager;
_quizRepo = quizRepo;
_courseRepo = courseRepo;
_hostingEnvironment = hostingEnvironment;
}
public QuizService(
IUnitOfWork database,
ILoggerManager logger,
IQuizRepository quizRepository,
IMapper mapper)
: base(database, logger, quizRepository, mapper)
{
this.mapper = mapper;
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="quizRepo"></param>
/// <param name="userManager"></param>
/// <param name="authorizeService"></param>
public QuizController(
IQuizRepository quizRepo,
UserManager <ApplicationUser> userManager,
IAuthorizeService authorizeService) : base(authorizeService)
{
_userManager = userManager;
_quizRepo = quizRepo;
_authorizeService = authorizeService;
}
public UnitOfWork(DbContext context, IRoleRepository roleRepository,
IUserRepository userRepository, IQuizRepository testRepository, IQuizStatisticRepository statisticRepository)
{
this.context = context;
this.userRepository = userRepository;
this.roleRepository = roleRepository;
this.testRepository = testRepository;
this.statisticRepository = statisticRepository;
}
public QuizService(
IQuizRepository quizRepository,
IPerguntaRepository perguntaRepository,
IAlternativaRepository alternativaRepository)
{
_quizRepository = quizRepository;
_perguntaRepository = perguntaRepository;
_alternativaRepository = alternativaRepository;
}
// we use this so that
public QuizManagerController()
{
if (_quizRepo == null)
{
_quizRepo = new QuizRepositoryEF();
//_quizRepo = new QuizRepositoryInMemory();
//_quizRepo.LoadSampleQuestions();
}
}
/// <summary>
/// This method will create an instance of an
/// IQuizRepository implementation.
/// </summary>
/// <returns>
/// A reference to an IQuizRepository
/// implementation.
/// </returns>
private IQuizRepository _PrepareQuizRepositoryForTesting()
{
var dataAccessStub = _GetQuizDataAccessStub();
//Inject the dependency via constructor injection
_QuizRepository = new QuizRepository(dataAccessStub);
return(_QuizRepository);
}
/// <summary>
/// This method will create an instance of an
/// IQuizRepository implementation.
/// </summary>
/// <returns>
/// A reference to an IQuizRepository
/// implementation.
/// </returns>
private IQuizRepository _PrepareQuizRepositoryForTesting()
{
_PrepareMockedQuizDataAccess();
//Inject the dependency via constructor injection
_QuizRepository = new QuizRepository(_QuizSqlDataAccess);
return(_QuizRepository);
}
public QuizController(IQuestService questService, IQuizService quizService, ITransactionScopeProvider transactionScopeProvider,
IQuestRepository questRepository, IQuizRepository quizRepository)
{
this.questService = questService;
this.quizService = quizService;
this.transactionScopeProvider = transactionScopeProvider;
this.questRepository = questRepository;
this.quizRepository = quizRepository;
}
public ListingsController(IUserRepository userRepo, IQuizRepository quizRepo, IQuestionRepository questionRepo, IAnswerRepository answerRepo, IImageRepository imageRepo, IVideoRepository videoRepo)
{
_userRepo = userRepo;
_quizRepo = quizRepo;
_questionRepo = questionRepo;
_answerRepo = answerRepo;
_imageRepo = imageRepo;
_videoRepo = videoRepo;
}
public UnitOfWork(DbContext context, IRoleRepository roleRepository,
IUserRepository userRepository, IQuizRepository testRepository, IQuizStatisticRepository statisticRepository)
{
this.context = context;
this.userRepository = userRepository;
this.roleRepository = roleRepository;
this.testRepository = testRepository;
this.statisticRepository = statisticRepository;
}
public QuizController(IQuizRepository quizRepository, IAnswerRepository answerRepository, IQuestionRepository questionRepository, IScoreRepository scoreRepository, UserManager <ApplicationUser> userManager, IHostingEnvironment e, IHttpContextAccessor httpContextAccessor)
{
_he = e;
_userManager = userManager;
_quizRepository = quizRepository;
_scoreRepository = scoreRepository;
_answerRepository = answerRepository;
_questionRepository = questionRepository;
_httpContextAccessor = httpContextAccessor;
}
public QuizService(IModelFactory modelFactory, IQuizRepository quizRepository, IQuizQuestionRepository quizQuestionRepository,
IQuestionRepository questionRepository, ICourseRepository courseRepository, IQuizPagesRepository quizPagesRepository)
{
_modelFactory = modelFactory;
_quizRepository = quizRepository;
_quizQuestionRepository = quizQuestionRepository;
_questionRepository = questionRepository;
_courseRepository = courseRepository;
_quizPagesRepository = quizPagesRepository;
}
public QuizService(IModelFactory modelFactory, IQuizRepository quizRepository, IQuizQuestionRepository quizQuestionRepository,
IQuestionRepository questionRepository, ICourseRepository courseRepository, IQuizPagesRepository quizPagesRepository)
{
_modelFactory = modelFactory;
_quizRepository = quizRepository;
_quizQuestionRepository = quizQuestionRepository;
_questionRepository = questionRepository;
_courseRepository = courseRepository;
_quizPagesRepository = quizPagesRepository;
}
public MainForm(IQuizRepository quizRepository)
{
InitializeComponent();
_quizRepository = quizRepository;
_quiz = new Quiz(_quizRepository.Get20Questions());
Size = new Size(700, 700);
FormBorderStyle = FormBorderStyle.FixedSingle;
NumBox.Hide();
labelSaisie.Hide();
}
public QuizCreateAdminValidator(
IQuizRepository quizRepository)
{
_quizRepository = quizRepository;
RuleFor(v => v.Title).NotEmpty().MaximumLength(100);
RuleFor(v => v.ShortDescription).NotEmpty().WithMessage("Special Instruction can not be empty").MaximumLength(400);
RuleFor(v => v.QuizCategoryId).NotEmpty().WithMessage("Category can not be empty.");
RuleFor(v => v.MetaTitle).MaximumLength(70);
RuleFor(v => v.MetaDescription).MaximumLength(300);
}
public QuizController(IQuizRepository QuizRepository, ILogManager logger, IHttpContextAccessor accessor)
{
_QuizRepository = QuizRepository;
_logger = logger;
if (accessor.HttpContext.Request.Query.ContainsKey("entityid"))
{
_entityId = int.Parse(accessor.HttpContext.Request.Query["entityid"]);
}
}
public RecommendationController(ILogger <RecommendationController> logger,
IQuizRepository quizRepository,
IDogRepository dogRepository,
UserManager <User> userManager)
{
this.logger = logger;
this.quizRepository = quizRepository;
this.dogRepository = dogRepository;
this.userManager = userManager;
}
public UserQuizzesController(IUserQuizRepository userQuizRepository,
IQuizRepository quizRepository,
UserManager <ApplicationUser> userManager,
ITranslator translator)
{
_userQuizRepository = userQuizRepository;
_quizRepository = quizRepository;
_userManager = userManager;
_translator = translator;
}
public AuxiliaryController(IPollRepository pollRepository, IQuizRepository quizRepository, IGroupManager groupManager,
IUserManager userManager, IGroupRepository groupRepository, IFileRepository fileRepository, IUserRepository userRepository)
{
_pollRepository = pollRepository;
_quizRepository = quizRepository;
_userManager = userManager;
_groupRepository = groupRepository;
_fileRepository = fileRepository;
_groupManager = groupManager;
_userRepository = userRepository;
}
public QuizController(IQuizRepository quizRepository, IAnswerRepository answerRepository, IQuestionRepository questionRepository, UserManager <ApplicationUser> userManager
, IHostingEnvironment e, IUserScoreRepositories userScoreRepo)
{
this.quizRepository = quizRepository;
this.answerRepository = answerRepository;
this.questionRepository = questionRepository;
this.userManager = userManager;
this.he = e;
this.userScoreRepo = userScoreRepo;
//this.scoreQuizRepository = scoreQuizRepository;
}
public GameController(
IDifficultyRepository difficultyRepository,
ITypeRepository typeRepository,
IQuizRepository quizRepository,
IQuestionRepository questionRepository)
{
_difficultyRepository = difficultyRepository;
_typeRepository = typeRepository;
_quizRepository = quizRepository;
_questionRepository = questionRepository;
}
public QuizDTOMapper(IQuizRepository quizRepository,
IApplicationUserRepository applicationUserRepository,
IApplicationUserDTOMapper userDTOMapper,
IQuizEntityMapper quizEntityMapper,
IJSONRepository jsonRepository)
{
this.quizRepository = quizRepository;
this.applicationUserRepository = applicationUserRepository;
this.userDTOMapper = userDTOMapper;
this.quizEntityMapper = quizEntityMapper;
this.jsonRepository = jsonRepository;
}
public UnitOfWork(
ApplicationContext appContext,
IQuizRepository quizRepository,
IUserRepository userRepository,
ISubscriptionRepository subscriptionRepository,
INotificationRepository <SiteNotification> siteNotificationRepository)
{
_appContext = appContext;
Quizes = quizRepository;
Users = userRepository;
Subscriptions = subscriptionRepository;
SiteNotifications = siteNotificationRepository;
}
public HomeController(
ILogger <HomeController> logger,
WiredService wiredService,
IQuestionService questionService,
IQuizRepository quizRepository,
UserManager <ApplicationUser> userManager)
{
_logger = logger;
_wiredService = wiredService;
_questionService = questionService;
_quizRepository = quizRepository;
_userManager = userManager;
}
public QuizService(
IUsuario usuario,
IQuizRepository quizRepository,
IPerguntaRepository perguntaRepository,
IRespostaRepository respostaRepository,
IAlternativaRepository alternativaRepository)
{
_usuario = usuario;
_quizRepository = quizRepository;
_perguntaRepository = perguntaRepository;
_respostaRepository = respostaRepository;
_alternativaRepository = alternativaRepository;
}
public QuizCrudViewModel(IQuizRepository quizRepository, IQuestionRepository questionRepository,
IQuizQuestionRepository quizQuestionRepository)
{
if (quizRepository == null)
throw new ArgumentNullException(nameof(quizRepository));
if (questionRepository == null)
throw new ArgumentNullException(nameof(questionRepository));
if (quizQuestionRepository == null)
throw new ArgumentNullException(nameof(quizQuestionRepository));
_quizRepository = quizRepository;
_questionRepository = questionRepository;
_quizQuestionRepository = quizQuestionRepository;
Initialize();
}
public async void Add_Quiz()
{
IQuizRepository sut1 = GetInMemoryQuizRepository();
Library.Models.Quiz quiz1 = new Library.Models.Quiz()
{
Score = 10,
UserId = 3,
QuizId = 1,
CategoryId = 1,
GameModeId = 1,
Time = DateTime.Now,
};
Library.Models.Quiz quiz2 = new Library.Models.Quiz()
{
Score = 10,
UserId = 3,
QuizId = 2,
CategoryId = 1,
GameModeId = 1,
Time = DateTime.Now,
};
Library.Models.Quiz quiz4 = new Library.Models.Quiz()
{
Score = 90,
UserId = 3,
QuizId = 2,
CategoryId = 1,
GameModeId = 1,
Time = DateTime.Now,
};
int x = await sut1.CreateQuiz(quiz1);
int y = await sut1.CreateQuiz(quiz2);
//Assert.True(sut1.GetQuizzes().ToList().Count() == 2);
Library.Models.Quiz quiz3 = await sut1.GetQuizById(1);
//Assert.Equal(10, quiz3.Score);
bool something = await sut1.EditQuiz(quiz4);
// Library.Models.Quiz testQuiz = await sut1.GetQuizById(2);
//Assert.Equal(90, testQuiz.Score);
var qzs = sut1.GetQuizzes();
var qzs1 = sut1.GetQuizzesByCategoryId(1);
var qzs2 = sut1.GetQuizzesByGameModeId(1);
var qzs3 = sut1.GetQuizzesByUserId(3);
//Library.Models.Question q = await sut1.GetRandomQuestion(1);
}
public HomeViewModel(IViewModelLocator viewModelLocator, IQuizRepository quizRepository,
ICategoryRepository categoryRepository,
IQuestionRepository questionRepository)
{
if (viewModelLocator == null)
throw new ArgumentNullException(nameof(viewModelLocator));
if (quizRepository == null)
throw new ArgumentNullException(nameof(quizRepository));
if (categoryRepository == null)
throw new ArgumentNullException(nameof(categoryRepository));
if (questionRepository == null)
throw new ArgumentNullException(nameof(questionRepository));
_viewModelLocator = viewModelLocator;
_quizRepository = quizRepository;
_categoryRepository = categoryRepository;
_questionRepository = questionRepository;
Initialize();
}
public QuizsController(IQuizRepository repo)
{
_repo = repo;
}
public CreateQuizWebForm()
{
_QuizRepository = ModelContainer.Resolve<IQuizRepository>();
_UserRepository = ModelContainer.Resolve<IUserRepository>();
_Questions = new List<Question>();
}
public QuizWebForm()
{
_QuizRepository = ModelContainer.Resolve<IQuizRepository>();
QuizService = ModelContainer.Resolve<IQuizService>();
}
public QuizController(IQuizRepository quizRepository, IQuizService quizService)
{
_quizService = quizService;
_quizRepository = quizRepository;
}
public void SetQuiz(IQuizRepository quizRepository, int quizId)
{
_Quiz = quizRepository.GetQuiz(quizId);
}
