public LoadModel()
{
actionText = "load";
secondActionText = "";
quiz = new Quizz("");
answers = new Quizz("");
}
public void LoadQuizzQuestions(Quizz quizz)
{
this.Reset();
respondQuizzScrollerController.Reset();
respondQuizzScrollerController.Initialize();
this._quizz = quizz;
this._questions = GameManager.Instance.GetApiManager().GetQuestionsForQuizz(quizz.GetQuizzId());
// Error/Exception managing
if (this._questions == null)
{
Debug.LogError("[WARNING]: questions is equal to null. Is your QuestionsQuizzData superclass class configured in the same way the API (json) data is ?");
PopupManager.PopupAlert("Error", "Question is equal to null (is data from API valid ?).\n" + NetworkRequestManager.lastHttpWebRequestErrorMessage, "Return to menu", GameManager.Instance.pagesManager.ShowMenuPage);
return;
}
numberOfQuestions = _questions.GetQuestionsList().Count;
// Error/Exception managing
if (numberOfQuestions == 0)
{
Debug.LogError("[WARNING]: Number of questions is equal to 0, impossible to respond to this quizz.");
PopupManager.PopupAlert("Error", "There is no question in this quizz\n" + NetworkRequestManager.lastHttpWebRequestErrorMessage, "Return to menu", GameManager.Instance.pagesManager.ShowMenuPage);
return;
}
LoadQuestionAndAnswersForIndex(0);
}
void Start()
{
m_dialogueManager = GetComponent <DialogueManager>();
m_QuizzCanvas.SetActive(false);
m_actualQuizz = Quizz.LoadFromFile(Application.dataPath + m_FilePath);
}
public static QuizzViewModel MapToQuizzViewModel(this Quizz quizz)
{
if (quizz == null)
{
return(new QuizzViewModel());
}
var technoName = "";
var difficultyName = "";
using (var db = new DataBaseContext())
{
technoName = db.Technos.Find(quizz.TechnoID).Wording;
difficultyName = db.MasterDifficulties.Find(quizz.MasterDifficultyID).Wording;
}
return(new QuizzViewModel
{
QuizzID = quizz.QuizzID,
CandidateFirstname = quizz.CandidateFirstname,
CandidateLastname = quizz.CandidateLastname,
TechnoName = technoName,
DifficultyName = difficultyName,
TechnoID = quizz.TechnoID,
DifficultyID = quizz.MasterDifficultyID,
NbQuestions = quizz.NbQuestions
});
}
/// <summary>
/// Créer un quizz de manière aléatoire, selon le niveau spécifié
/// </summary>
/// <param name="tech">La technologie liée au quizz</param>
/// <param name="diff">La difficulté du Quizz</param>
/// <param name="nbQuestions">Le nombre de questions voulues</param>
/// <param name="fName">Prénom du candidat</param>
/// <param name="lName">Nom du candidat</param>
/// <returns>Un quizz créé aléatoirement avec le nombre de questions selon le niveau</returns>
public Quizz CreateQuiz(Techno tech, MasterDifficulty diff, int nbQuestions, string fName, string lName)
{
Quizz quizz = new Quizz
{
CandidateFirstname = fName,
CandidateLastname = lName,
LinkedTechno = tech,
LinkedMasterDifficulty = diff,
NbQuestions = nbQuestions
};
var begginerQuestions = ReferencesService.GetQuestionByDifficulty("Débutant")
.Where(q => q.LinkedTechno == tech)
.ToList();
var interQuestions = ReferencesService.GetQuestionByDifficulty("Intermédiaire")
.Where(q => q.LinkedTechno == tech)
.ToList();
var expertQuestions = ReferencesService.GetQuestionByDifficulty("Expert")
.Where(q => q.LinkedTechno == tech)
.ToList();
quizz.LinkedQuestions.AddRange(GenerateRandomQuestionsList(begginerQuestions, (int)diff.LinkedPercent.Beginner));
quizz.LinkedQuestions.AddRange(GenerateRandomQuestionsList(interQuestions, (int)diff.LinkedPercent.Intermediate));
quizz.LinkedQuestions.AddRange(GenerateRandomQuestionsList(expertQuestions, (int)diff.LinkedPercent.Expert));
return(quizz);
}
public void Create(QuizzAddViewModel model)
{
using (var ctx = new QuizzContext())
{
Quizz quizz = new Quizz()
{
CreatedBy = model.CreatedBy,
CreatedOn = model.CreatedOn,
ModifiedBy = model.ModifiedBy,
ModifiedOn = model.ModifiedOn,
QuizzQuestions = model.QuizzQuestions,
QuizzCandidate = new Candidate()
{
Name = model.CandidateName,
Age = model.CandidateAge,
Mail = model.CandidateMail,
},
QuizzSkillLevel = model.QuizzSkillLevel,
QuizzTechno = model.QuizzTechno,
QuizzUser = model.QuizzUser
};
ctx.Quizzs.Add(quizz);
ctx.SaveChanges();
}
}
/// <summary>
/// Génère un quizz
/// </summary>
/// <param name="createQuizzDto">Objetc quizz à créer</param>
/// <param name="nbreQuestion">Nombre de questions composant le quizz</param>
/// <returns></returns>
public FindQuizzDto GenerateQuizz(CreateQuizzDto createQuizzDto, int nbreQuestion)
{
// Récupère le nombre de questions par niveau de difficultés
string key = TransformeIdLevelToString(createQuizzDto.IdLevel);
double nbreQuestionJunior = Math.Round(nbreQuestion * Double.Parse(ConfigurationManager.AppSettings.Get(key + "_junior")));
double nbreQuestionConfirme = Math.Round(nbreQuestion * Double.Parse(ConfigurationManager.AppSettings.Get(key + "_confirme")));
double nbreQuestionExpert = nbreQuestion - nbreQuestionJunior - nbreQuestionConfirme;
// Récupère les questions du quizz
QuestionsRepository repoQuestion = new QuestionsRepository(new QueryBuilder());
List <Question> questions = new List <Question>();
questions.AddRange(repoQuestion.GenererQuestionQuizz(ID_JUNIOR, createQuizzDto.IdCategory, (int)nbreQuestionJunior));
questions.AddRange(repoQuestion.GenererQuestionQuizz(ID_CONFIRME, createQuizzDto.IdCategory, (int)nbreQuestionConfirme));
questions.AddRange(repoQuestion.GenererQuestionQuizz(ID_EXPERT, createQuizzDto.IdCategory, (int)nbreQuestionExpert));
// Creation et enregistrement du quizz
Quizz quizz = new Quizz(null, GenerateCode(12), null, createQuizzDto.IdCategory, createQuizzDto.IdLevel, createQuizzDto.IdUser, createQuizzDto.IdCandidate);
quizz = quizzRepository.Create(quizz);
// Enregistrement des questions du quizz
PersisteQuizzQuestion(questions, quizz);
return(TransformModelToDto(quizz));
}
public static QuizzAnswerReponsesViewModel MapToQuizzAnswerReponsesViewModel(this Quizz quizz)
{
//QuizzService _quizzService = new QuizzService();
//var userReponse = _quizzService.GetQuizzUserAnswer(quizz.QuizzId);
var quizzAnswerReponsesViewModel = new QuizzAnswerReponsesViewModel();
if (quizz == null)
{
return(quizzAnswerReponsesViewModel);
}
quizzAnswerReponsesViewModel = new QuizzAnswerReponsesViewModel
{
QuizzId = quizz.QuizzId,
ContactName = quizz.Contact.Name,
ContactEmail = quizz.Contact.Email,
DifficultyName = quizz.Difficulty.DifficultyName,
TechnologyName = quizz.Technology.TechnoName,
//UserReponses = userReponse,
EtatQuizz = quizz.EtatQuizz,
NombreQuestion = quizz.NombreQuestion,
NomUser = quizz.NomUser,
PrenomUser = quizz.PrenomUser,
QuestionLibre = quizz.QuestionLibre,
Questions = quizz.Questions.Select(q => q.MapToQuestionsViewModel()).ToList()
//Technology = quizz.Technology
};
return(quizzAnswerReponsesViewModel);
}
public void Init(Quizz q, Action <Quizz, int> onQuizzClick, int quizzOder = 0)
{
quidID = quizzOder;
quiz = q;
_OnQuizzClick = onQuizzClick;
int num = 0;
for (int i = 0; i < root.childCount; i++)
{
BoxWorld bx = root.GetChild(i).GetComponent <BoxWorld>();
int startto = q.startFrom + q.keyword.Length;
if (i >= q.startFrom && i < startto)
{
bx.Init(q.keyword[num].ToString(), false, false, false, GotoQuiz, quidID, num);
if (i == q.keyhightlight)
{
bx.Init(q.keyword[num].ToString(), false, false, true, GotoQuiz, quidID, num);
}
num++;
}
else
{
bx.Init("", true, false, false, GotoQuiz, quidID, -1);
}
if (q.keySetStart == i || q.keysetEnd == i)
{
bx.Init("", false, true, false, GotoQuiz, quidID, -1);
}
}
}
public IHttpActionResult Get(int?id)
{
if (id == null)
{
return(this.BadRequest());
}
var quizz = quizzAccessLayer.Get((int)id);
if (quizz == null)
{
return(this.NotFound());
}
var result = new Quizz
{
QuizzId = quizz.QuizzId,
Niveau = quizz.Niveau,
Questions = quizz.QuizzQuestions.Select(qq => new Question
{
QuestionId = qq.Question.QuestionId,
Niveau = qq.Question.Niveau,
Libelle = qq.Question.Libelle,
Commentaire = qq.Question.Commentaire,
Libre = qq.Question.Libre,
Reponses = qq.Question.QuestionReponses.Select(r => new Reponse
{
ReponseId = r.Reponse.ReponseId,
Libelle = r.Reponse.Libelle
}).ToList()
}).ToList(),
};
return(this.Ok(result));
}
public void OnInitQuiz(Quizz _quiz, int idQuiz)
{
currentSelectQuizz = idQuiz;
txtHint.text = _quiz.hints[0];
quizz = _quiz;
if (!listGenerate[idQuiz].isGenerate)
{
listGenerate[idQuiz].isGenerate = true;
Root.SetActive(true);
Init();
}
else
{
for (int i = 0; i < totalLettersPanel; i++)
{
Button currentButton = panelButtons.transform.GetChild(i).GetComponent <Button>();
currentButton.transform.GetChild(1).GetComponent <Text>().text = listGenerate[currentSelectQuizz].charGen[i].ToString();
if (GetFillButton(i))
{
panelButtons.transform.GetChild(i).GetComponent <ButtonPanelCtrl>().HideButton();
}
else
{
panelButtons.transform.GetChild(i).GetComponent <ButtonPanelCtrl>().ShowButton();
}
}
}
for (int i = 0; i < totalLettersPanel; i++)
{
panelButtons.transform.GetChild(i).GetComponent <ButtonPanelCtrl>().HideHint();
}
}
/// <summary>
/// Publishes a quizz, notifying the users of such publication and publishing the url via email.
/// There will also be created a news warning that a quizz has been published.
/// The quizz is supposed to only be filled by students who finished the mobility process.
/// </summary>
/// <param name="id">Quizz id.</param>
/// <param name="employeeId">Logged employee id.</param>
/// <returns></returns>
public IActionResult Publish(int id, string employeeId)
{
Quizz quizz = _context.Quizzs.Where(q => q.Id == id).FirstOrDefault();
if (quizz != null)
{
string title = "Questionário " + quizz.Year + " " + quizz.Semester + "º semestre";
string content = "Encontra-se no email dos alunos que terminaram a mobilização uma " +
"ligação para a realização do questionário" +
" sobre o que acharam da experiência, este é de realização opcional mas irá ajudar na" +
" melhoria do nosso serviço. Obrigado, CIMOB.";
News news = new News()
{
EmployeeId = employeeId,
IsPublished = true,
Title = title,
TextContent = content
};
EmailSender sender = new EmailSender();
sender.SendMultipleEmail(filterFinalStudents(), title, $"Aqui está o seu questionário:" +
$" <a href='{HtmlEncoder.Default.Encode(quizz.QuizzUrl)}'>link</a>.");
quizz.IsPublished = true;
_context.Update(quizz);
_context.Add(news);
_context.SaveChanges();
}
return(RedirectToAction("Index", "News"));
}
/// <summary>
/// Permet l'ajout d'un quizz dans la base de données.
/// </summary>
/// <param name="quizz">Quizz à ajouter.</param>
/// <returns>L'identifiant du quizz ajouté.</returns>
public async Task <int> AddAsync(Quizz quizz)
{
this.context.Quizzs.Add(quizz);
await this.context.SaveChangesAsync().ConfigureAwait(false);
return(quizz.QuizzId);
}
/// <summary>
/// Convertir/ mapper une "quizz" en ViewModel "quizzViewModel"
/// </summary>
/// <param name="quizz"></param>
/// <returns></returns>
public static QuizzViewModel MapToQuizzViewModel(this Quizz quizz)
{
var quizzViewModel = new QuizzViewModel();
if (quizz == null)
{
return(quizzViewModel);
}
quizzViewModel = new QuizzViewModel
{
QuizzId = quizz.QuizzId,
EtatQuizz = quizz.EtatQuizz,
NombreQuestion = quizz.NombreQuestion,
NomUser = quizz.NomUser,
PrenomUser = quizz.PrenomUser,
TechnologyId = quizz.TechnologyId,
DifficultyId = quizz.DifficultyId,
QuestionLibre = quizz.QuestionLibre,
Timer = quizz.Timer,
QuestionId = quizz.Questions.Select(o => o.QuestionId).ToList(),
ContactId = quizz.ContactId
//TODO Rajouter difficultiesID quand pret
};
return(quizzViewModel);
}
public async Task <IHttpActionResult> PutQuizz(int id, Quizz quizz)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != quizz.Id_Player)
{
return(BadRequest());
}
db.Entry(quizz).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuizzExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Edit(int id, [Bind("IdentityKey,IdentityKeyMatiere,Titre,Description")] Quizz quizz)
{
if (id != quizz.IdentityKey)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(quizz);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuizzExists(quizz.IdentityKey))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdentityKeyMatiere"] = new SelectList(_context.QuizzMatiere, "IdentityKey", "Titre", quizz.IdentityKeyMatiere);
return(View(quizz));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Year,Semester,QuizzUrl")] Quizz quizz)
{
if (id != quizz.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(quizz);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuizzExists(quizz.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(quizz));
}
public void TestingPublishQuizz()
{
QuizzsController controller = new QuizzsController(_context);
Quizz toPublish = _context.Quizzs.FirstOrDefault();
Employee employee = _context.Employees.FirstOrDefault();
var result = controller.Publish(toPublish.Id, employee.Id);
var viewResult = Assert.IsType <RedirectToActionResult>(result);
}
public void SelectQuizzInIndex(object imageNameAsAQuizzId)
{
// Here we create a new Quizz and define its id (
Quizz quizzToShow = new Quizz();
quizzToShow.SetQuizzId(imageNameAsAQuizzId);
GameManager.Instance.selectQuizzManager.SelectQuizzToShow(quizzToShow);
}
public void Reset()
{
_quizz = null;
_questions = null;
numberOfQuestions = 0;
actualQuestionArrayIndex = 0;
rightResponses = 0;
falseResponses = 0;
}
void Start()
{
if (instance == null)
{
instance = this;
}
questionGUIs = new List <QuizzQuestionGUI>();
RefreshQuestionsGUI();
}
/// <summary>
/// Comme GetById, mais de manière eager (on récupère les questions, et les réponses)
/// </summary>
/// <param name="id">L'identifiant du quizz</param>
/// <returns>Un quizz</returns>
public Quizz GetByIdStringEager(string id)
{
Quizz q = Quizzes
.Include(qu => qu.Questions.Select(a => a.OtherAnsweres))
.Where(qu => qu.IdQuizz.ToString() == id)
.FirstOrDefault();
return(q);
}
/// <summary>
/// Création d'un Quizz
/// </summary>
/// <param name="difficultyid"></param>
/// <param name="technoid"></param>
/// <param name="userid"></param>
/// <param name="nomuser"></param>
/// <param name="prenomuser"></param>
/// <param name="questionlibre"></param>
/// <param name="nombrequestions"></param>
public Quizz CreateQuizz(QuizzViewModel quizzViewModel, int difficultymasterid)
{
Quizz unQuizz = null;
using (FilRougeDBContext db = new FilRougeDBContext())
{
var quizz = quizzViewModel.MapToQuizz();
List <Questions> questionsQuizz = AddQuestionToQuizz(quizz.QuestionLibre, quizz.NombreQuestion, quizz.TechnologyId, difficultymasterid, db);
int timer = quizz.Timer;
try
{
//TODO creer un viewbag des users => authorize create quizz
// verifier paramètres de création d'un quizz
Contact creatingQuizzContact = db.Users.Single(e => e.Id == quizz.ContactId);
Difficulty difficultyQuizz = db.Difficulties.Single(e => e.DifficultyId == difficultymasterid);
Technology technoQuizz = db.Technologies.Single(e => e.TechnoId == quizz.TechnologyId);
unQuizz = new Quizz
{
ContactId = creatingQuizzContact.Id,
DifficultyId = difficultymasterid,
TechnologyId = quizz.TechnologyId,
Timer = quizz.Timer,
PrenomUser = quizz.PrenomUser,
NomUser = quizz.NomUser,
NombreQuestion = quizz.NombreQuestion,
EtatQuizz = quizz.EtatQuizz,
QuestionLibre = quizz.QuestionLibre,
Contact = creatingQuizzContact,
Difficulty = difficultyQuizz,
Questions = questionsQuizz,
Technology = technoQuizz
};
db.Quizz.Add(unQuizz);
db.SaveChanges();
db.Dispose();
}
catch (AlreadyInTheQuestionsList e)
{
Console.WriteLine(e.Message);
db.Dispose();
}
catch (NoQuestionsForYou e)
{
Console.WriteLine(e.Message);
db.Dispose();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
return(unQuizz);
}
public ActionResult CreateQiuzz(Quizz newQuizz)
{
using (EducationDBContext db = new EducationDBContext())
{
db.Quizzs.Add(newQuizz);
db.SaveChanges();
}
return(RedirectToAction("Index", "Home"));
}
private void CreateNewQuizzNotification(NotificationTypeEnum type, Quizz quizz)
{
var editor = new NewNotificationEditor(type, _currentUser.Id, quizz.OwnerId);
editor.AddQuizz(quizz.Id);
var entity = editor.GetEntity();
_uow.NewNotifications.Add(entity);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Quizz quizz = await db.Quizzs.FindAsync(id);
db.Quizzs.Remove(quizz);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
/// <summary>
/// Remplis la table QuizzQuestion en associant chaque question du quizz
/// </summary>
/// <param name="questions">Listes des questions du quizz</param>
/// <param name="quizz">le quizz</param>
private void PersisteQuizzQuestion(List <Question> questions, Quizz quizz)
{
QuizzQuestionRepository questionQuizzRepo = new QuizzQuestionRepository(new QueryBuilder());
foreach (Question question in questions)
{
QuizzQuestion quizzQuestion = new QuizzQuestion((int)quizz.idQuizz, (int)question.IdQuestion, "", null);
questionQuizzRepo.Create(quizzQuestion);
}
}
/// <summary>
/// Fournit un Quizz en particulier
/// </summary>
/// <param name="id">ID du quizz à récupérer</param>
/// <returns>Retourn le Quizz spécifié</returns>
public Quizz GetQuizById(int id)
{
Quizz rQuizz = new Quizz();
using (_db)
{
rQuizz = _db.Quizzes.Single(m => m.QuizzID == id);
}
return(rQuizz);
}
public async Task <IActionResult> Create([Bind("QuizzId,Ques,Option1,Option2,Option3,Option4,Correct")] Quizz quizz)
{
if (ModelState.IsValid)
{
_context.Add(quizz);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(quizz));
}
public async Task <IHttpActionResult> GetQuizz(int id)
{
Quizz quizz = await db.Quizzs.FindAsync(id);
if (quizz == null)
{
return(NotFound());
}
return(Ok(quizz));
}
