internal static QuizWithTags MapFrom(QuizEntity quiz)
=> new QuizWithTags
{
Id = quiz.Id,
Title = quiz.Title,
Tags = quiz.QuizTags.Select(qt => qt.Tag.Name)
};
public async Task When_AddMethodIsCalledWithValidParameter_Then_ShouldReturnCreatedAt()
{
// Arrange
CreateQuizModel entity = new CreateQuizModel
{
Name = "valid name",
Description = "valid description",
Questions = new List <CreateQuestionModel>
{
new CreateQuestionModel()
},
IsRanked = false
};
var quizEntity = new QuizEntity
{
QuizCreatorId = Guid.NewGuid()
};
var quizModel = new QuizModel
{
};
AddQuizMocking(quizEntity, quizModel);
// Act
var result = await SystemUnderTest.AddQuiz(entity);
// Assert
result.Should().BeOfType <CreatedAtRouteResult>();
_mockQuizService.Verify(x => x.CreateAsync(It.IsAny <QuizEntity>()), Times.Exactly(1));
_mockQuizService.Verify(x => x.GetQuizAsync(It.IsAny <Guid>()), Times.Exactly(1));
}
public string QuizValidity(string QuizName, long?QuizId)
{
QuizEntity Quiz = new QuizEntity();
if (QuizId != null)
{
Quiz = db.tblQuizs.Where(x => x.QuizName.ToLower() == QuizName.ToLower() && x.QuizId != QuizId).Select(x => new QuizEntity()
{
QuizName = x.QuizName,
}).FirstOrDefault();
}
else
{
Quiz = db.tblQuizs.Where(x => x.QuizName.ToLower() == QuizName.ToLower()).Select(x => new QuizEntity()
{
QuizName = x.QuizName,
}).FirstOrDefault();
}
List <QuizEntity> usrList = new List <QuizEntity>();
//var Usr = usrList.FirstOrDefault(x => x.QuizName.ToLower() == QuizName.ToLower());
if (Quiz != null)
{
return("Quiz already exist.");
}
else
{
return("Success");
}
}
public ActionResult DeleteQuiz(long id)
{
try
{
QuizFactory DeleteQuiz = new QuizFactory();
QuizEntity Quiz = new QuizEntity();
Quiz = DeleteQuiz.GetQuizById(id);
DataLayer.tblQuiz NewQuiz = new DataLayer.tblQuiz();
NewQuiz.QuizId = id;
NewQuiz.QuizName = Quiz.QuizName;
NewQuiz.CreatedDate = Quiz.CreatedDate;
NewQuiz.CreatedBy = Quiz.CreatedBy;
NewQuiz.UpdatedDate = DateTime.Now;
NewQuiz.UpdatedBy = null;
NewQuiz.IsActive = false; // IsActive will be false in delete record
DeleteQuiz.SaveQuiz(NewQuiz);
return(RedirectToAction("Quiz"));
}
catch
{
return(View());
}
}
public async Task When_UpdateMethodIsCalledWithNoAuthorization_Then_ShouldReturnUnauthorizedResult()
{
// Arrange
UpdateQuizModel entity = new UpdateQuizModel
{
Id = new Guid(),
Name = "valid name",
Description = "valid description",
Questions = new List <CreateQuestionModel>
{
new CreateQuestionModel()
},
IsRanked = false
};
var quizEntity = new QuizEntity
{
QuizCreatorId = Guid.NewGuid()
};
UpdateQuizMocking(quizEntity);
// Act
var result = await SystemUnderTest.UpdateQuiz(entity.Id, entity);
// Assert
result.Should().BeOfType <UnauthorizedResult>();
}
public override void Init(params object[] args)
{
Debug.Log("init quiz");
CurrentQuiz = GameControllerLevel2.Instance.QuizGame.GetQuest();
if (CurrentQuiz != null)
{
NumberQLabel.text = CurrentQuiz.Id.ToString();
QLabel.text = CurrentQuiz.Question;
Button1.SetActive(!string.IsNullOrEmpty(CurrentQuiz.Answer1));
Button2.SetActive(!string.IsNullOrEmpty(CurrentQuiz.Answer2));
Button3.SetActive(!string.IsNullOrEmpty(CurrentQuiz.Answer3));
V1Label.text = CurrentQuiz.Answer1;
V2Label.text = CurrentQuiz.Answer2;
V3Label.text = CurrentQuiz.Answer3;
}
else
{
Debug.Log("Вопросы кончились");
Close();
}
}
public async Task When_DeleteQuizMethodIsCalledCorrectly_Then_ShouldReturnNoContentResult()
{
// Arrange
var quizEntity = new QuizEntity
{
QuizCreatorId = Guid.NewGuid()
};
_mockMapper.Setup(x => x.Map <QuizModel>(It.IsAny <QuizEntity>()))
.Returns(It.IsAny <QuizModel>);
_mockQuizService.Setup(x => x.GetQuizAsync(quizEntity.QuizCreatorId))
.Returns(Task.FromResult(quizEntity));
_mockQuizService.Setup(x => x.DeleteAsync(quizEntity.QuizCreatorId))
.Returns(Task.CompletedTask);
_mockUserValidation.Setup(x => x.GetUserIdFromClaims(It.IsAny <HttpContext>())).Returns(quizEntity.QuizCreatorId);
// Act
var result = await SystemUnderTest.DeleteQuiz(quizEntity.QuizCreatorId);
// Assert
result.Should().BeOfType <NoContentResult>();
_mockQuizService.Verify(x => x.GetQuizAsync(It.IsAny <Guid>()), Times.Exactly(1));
_mockQuizService.Verify(x => x.DeleteAsync(It.IsAny <Guid>()), Times.Exactly(1));
}
public async Task When_UpdateMethodIsCalledWithValidParameter_Then_ShouldReturnNoContent()
{
// Arrange
UpdateQuizModel entity = new UpdateQuizModel
{
Id = new Guid(),
Name = "valid name",
Description = "valid description",
Questions = new List <CreateQuestionModel>
{
new CreateQuestionModel()
},
IsRanked = false
};
var quizEntity = new QuizEntity
{
QuizCreatorId = Guid.NewGuid()
};
UpdateQuizMocking(quizEntity);
_mockUserValidation.Setup(x => x.GetUserIdFromClaims(It.IsAny <HttpContext>())).Returns(quizEntity.QuizCreatorId);
// Act
var result = await SystemUnderTest.UpdateQuiz(entity.Id, entity);
// Assert
result.Should().BeOfType <NoContentResult>();
_mockQuizService.Verify(x => x.UpdateAsync(It.IsAny <QuizEntity>()), Times.Exactly(1));
_mockQuizService.Verify(x => x.GetQuizAsync(It.IsAny <Guid>()), Times.Exactly(1));
}
/// <summary>
/// セレクト問題の初期化を行います。
/// </summary>
public override void Initialize(QuizEntity quiz)
{
for (int i = 0; i < choiceObjects.Length; i++)
{
choiceObjects[i].Answer = quiz.Choices[i];
}
}
public void ViewSentence(QuizEntity quiz, ref int count)
{
if (isWaiting)
{
return;
}
count++;
if (count > quiz.Sentence.Length)
{
return;
}
// 改行が登場したら1秒ウェイト
int lastIndex = quiz.Sentence.Substring(0, count).LastIndexOf('\n');
if (lastIndex + 1 == count)
{
isWaiting = true;
Observable.ReturnUnit().Delay(TimeSpan.FromSeconds(1)).Subscribe(_ => {
isWaiting = false;
}).AddTo(this);
}
SentenceText.text = quiz.Sentence.Substring(0, count);
}
// GET: Quiz/Edit/5
public ActionResult EditQuiz(int id)
{
QuizFactory EditQuiz = new QuizFactory();
QuizEntity quiz = new QuizEntity();
quiz = EditQuiz.GetQuizById(id);
return(View(quiz));
}
///<summary>
///Ativa questionário
/// </summary>
public void Activating(int id)
{
QuizRepository repository = new QuizRepository();
QuizEntity quiz = repository.GetById(id);
quiz.status = true;
repository.update(quiz);
}
public ActionResult DeleteQuiz(int id)
{
QuizFactory EditQuiz = new QuizFactory();
QuizEntity channel = new QuizEntity();
channel = EditQuiz.GetQuizById(id);
return(View(channel));
}
public ActionResult Save(QuizEntity entity)
{
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
{
if (ModelState.IsValid)
{
if (entity.Name == null)
{
//return Json(new { status = "warn", message = "O campo nome é obrigatório!" });
ModelState.AddModelError("", "Alguns campos são obrigatórios para salvar o Questionário.");
return(PartialView("_Edit", entity));
}
if (entity.Id == 0)
{
QuizService service = QuizService.Instance;
entity.InitialDate = DateTime.Now;
entity.CreatedBy = CurrentUserEmail;
entity.LastUpdate = DateTime.Now;
entity.FirmId = CurrentFirm.Id;
entity.status = true;
service.Create(entity);
Success("Questionário cadastrado com sucesso.");
scope.Complete();
// return Json(new { status = "sucess", message = "Registro cadastrado com sucesso!" });
}
else
{
QuizService service = QuizService.Instance;
entity.LastUpdate = DateTime.Now;
entity.status = true;
entity.UpdatedBy = CurrentUserEmail;
entity.FirmId = CurrentFirm.Id;
service.Update(entity);
Success("Questionário atualizado com sucesso.");
scope.Complete();
// return Json(new { status = "sucess", message = "Registro atualizado com sucesso!" });
}
}
else
{
ModelState.AddModelError("", "Alguns campos são obrigatórios para salvar o questionário.");
return(PartialView("_Edit", entity));
}
}
}
catch (Exception ex)
{
Logger.LogException(ex);
//return Json(new { status = "error", message = "Ocorreu um problema!" });
ModelState.AddModelError("", "Ocorreu um problema!");
return(PartialView("_Edit", entity));
}
return(new EmptyResult());
}
public void UpdateQuizMocking(QuizEntity quizEntity)
{
_mockMapper.Setup(x => x.Map <QuizEntity>(It.IsAny <CreateQuizModel>()))
.Returns(quizEntity);
_mockQuizService.Setup(x => x.GetQuizAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(quizEntity));
_mockQuizService.Setup(x => x.UpdateAsync(quizEntity))
.Returns(Task.CompletedTask);
}
private Result Insert(QuizEntity entity, DapperConnectionManager con)
{
var query = new QueryEntity();
query.Entity = entity;
query.Query = @"INSERT INTO Quizzes (Name, Type , DomainId) VALUES(@Name, @Type , @DomainId)";
var result = con.InsertQuery(query);
return(result);
}
/// <summary>
/// クイズをリセットする
/// </summary>
public void Reset(QuizEntity quiz)
{
// すべてのパネルを非表示に
AnswerPanelList.ForEach(p => p.gameObject.SetActive(false));
// 出題に使用したパネルを初期状態へ
var panel = AnswerPanelList.Find(p => p.format == quiz.Format);
panel.Reset();
}
public async Task UpdateAsync(QuizEntity quiz)
{
Guard.ArgumentNotNull(quiz, nameof(quiz));
var insertedQuiz = await _repository.GetByIdAsync(quiz.Id).ConfigureAwait(false);
if (insertedQuiz != null)
{
await _repository.UpdateAsync(quiz).ConfigureAwait(false);
}
}
public async Task When_CallAddQuizAndTheQuizIsNotPresentInTheDatabase_Then_ShouldCreate()
{
// Arrange
var entity = new QuizEntity();
// Act
await SystemUnderTest.CreateAsync(entity);
// Assert
_mockQuizRepository.Verify(x => x.AddAsync(It.IsAny <QuizEntity>()), Times.Once);
}
/// <summary>
/// 初期化を行います。
/// </summary>
public override void Initialize(QuizEntity quiz)
{
Reset();
var answer = quiz.CorrectAnswer;
for (int i = 0; i < quiz.CorrectAnswer.Length; i++)
{
var reelStr = new string(quiz.Choices.Select(x => x[i]).OrderBy(_ => Guid.NewGuid()).ToArray());
var reel = reels[i];
reel.SetReelStr(reelStr);
}
}
public Result GetQuizByType(QuizTypes type)
{
var con = new DapperConnectionManager();
var query = new QueryEntity();
var result = new Result();
//ASSeSSMENT QUIZZES GET BY DOMAIN NO TYPE
if (QuizTypes.ASSESSMENT == type)
{
result.Success = false;
return(result);
}
query.Query = @"SELECT * FROM Quizzes
where Type = @Type";
query.Entity = new { Type = type.ToString() };
result = con.ExecuteQuery <QuizEntity>(query);
if (!result.Success)
{
result.Message = "An error occurred";
return(result);
}
var r = (IEnumerable <QuizEntity>)result.Entity;
var quiz = r.FirstOrDefault();
if (quiz == null)
{
//new quiz needs to be inserted
quiz = new QuizEntity
{
Name = type.ToString(),
Type = type.ToString()
};
result = Insert(quiz, con);
}
else
{
var resultQ = GetQuestionsByQuiz(quiz.QuizId, con);
if (!resultQ.Success)
{
return(resultQ);
}
quiz.Questions = (List <QuestionEntity>)resultQ.Entity;
}
result.Entity = quiz;
return(result);
}
/// <summary>
/// クイズを出題する
/// </summary>
public void StartQuiz(QuizEntity quiz)
{
// パネルの初期化
var panel = AnswerPanelList.Find(p => p.format == quiz.Format);
if (panel == null)
{
GeLogger.Error($"not found panel. format = {quiz.Format}");
return;
}
panel.Initialize(quiz);
// 出題パネルの表示
AnswerPanelList.ForEach(p => p.gameObject.SetActive(p.format == quiz.Format));
}
/// <summary>
/// 初期化を行います。
/// </summary>
public override void Initialize(QuizEntity quiz)
{
Reset();
for (int i = 0; i < quiz.Choices.Count; i++)
{
choiceObjects[i].Answer = quiz.Choices[i];
choiceObjects[i].gameObject.SetActive(true);
}
for (int i = quiz.Choices.Count; i < choiceObjects.Length; i++)
{
choiceObjects[i].gameObject.SetActive(false);
}
}
public QuizEntity GetQuizById(long Id)
{
QuizEntity Quiz = new QuizEntity();
Quiz = db.tblQuizs.Where(x => x.QuizId == Id).Select(x => new QuizEntity()
{
QuizName = x.QuizName,
CreatedBy = x.CreatedBy,
CreatedDate = x.CreatedDate,
UpdatedBy = x.UpdatedBy,
UpdatedDate = x.UpdatedDate,
IsActive = x.IsActive
}).FirstOrDefault();
return(Quiz);
}
public async Task When_CallDeleteQuizByIdAndTheQuizIsInDataBase_Then_ShouldDeleteTheQuizAsync()
{
// Arrange
var entity = new QuizEntity();
//-- nu merge sa returnezze entitatea.--
_mockQuizRepository.Setup(x => x.GetByIdAsync(entity.Id)).Returns(Task.FromResult(entity));
// Act
// var result = await SystemUnderTest.CreateAsync(entity);
await SystemUnderTest.DeleteAsync(entity.Id);
// Assert
_mockQuizRepository.Verify(x => x.GetByIdAsync(It.IsAny <Guid>()), Times.AtMost(1));
_mockQuizRepository.Verify(x => x.DeleteAsync(It.IsAny <Guid>()), Times.Once);
}
public async Task When_GetQuizByIdMethodIsCalledWithDifferentUserId_Then_ShouldReturnUnauthorizedResult()
{
// Arrange
var quizEntity = new QuizEntity
{
QuizCreatorId = Guid.NewGuid()
};
_mockQuizService.Setup(x => x.GetQuizAsync(quizEntity.QuizCreatorId))
.Returns(Task.FromResult(quizEntity));
// Act
var result = await SystemUnderTest.GetQuizById(quizEntity.QuizCreatorId);
// Assert
result.Should().BeOfType <UnauthorizedResult>();
}
/// <summary>
/// 並べ替え問題の初期化を行います。
/// </summary>
public override void Initialize(QuizEntity quiz)
{
var shuffleAnswer = quiz.CorrectAnswer.Shuffle();
for (int i = 0; i < shuffleAnswer.Length; i++)
{
var choiceObject = choiceObjects[i];
choiceObject.Answer = $"{shuffleAnswer[i]}";
choiceObject.gameObject.SetActive(true);
}
for (int i = shuffleAnswer.Length; i < choiceObjects.Count; i++)
{
var choiceObject = choiceObjects[i];
choiceObject.Answer = string.Empty;
choiceObject.gameObject.SetActive(false);
}
}
/// <summary>
/// 初期化を行います。
/// </summary>
public override void Initialize(QuizEntity quiz)
{
base.Initialize(quiz);
disposable = new CompositeDisposable();
// 選択肢をエフェクト代わりに使用
EffectText.text = quiz.Choices[0];
var elapsedTime = 0.0f;
this.UpdateAsObservable().Subscribe(_ => {
elapsedTime += Time.deltaTime;
// 時間経過によるスケール変化
var value = Mathf.Lerp(EndScale, DefaultScale, 1 - elapsedTime / (QuizConfig.LimitSeconds - EndAnimationSecond));
EffectText.transform.localScale = new Vector3(value, value);
}).AddTo(disposable);
}
public ActionResult SaveQuiz([FromForm] int quizId, [FromForm] string quizName, [FromForm] string quizIntro, [FromForm] string quizJson)
{
var quizObj = new QuizEntity();
int.TryParse(Request.Cookies["id"], out int creator);
quizObj.QuizBody = quizJson;
quizObj.QuizName = quizName;
quizObj.QuizIntro = quizIntro;
quizObj.QuizCreator = creator;
quizObj.QuizLikes = new List <string>();
dbc.Quiz.Add(quizObj);
if (quizId > 0)
{
var prevQues = dbc.Quiz.Find(quizId);
prevQues.QuizIsDeleted = true;
dbc.Quiz.Update(prevQues);
}
dbc.SaveChanges();
return(JsonReturn.ReturnSuccess());
}
/// <summary>
/// 初期化を行います。
/// </summary>
public override void Initialize(QuizEntity quiz)
{
Reset();
var answer = quiz.CorrectAnswer;
for (int i = 0; i < quiz.CorrectAnswer.Length; i++)
{
var tile = tiles[i];
tile.gameObject.SetActive(true);
}
var dummies = quiz.Choices[0];
for (int i = 0; i < dummies.Length; i++)
{
var panel = panels[i];
panel.Answer = $"{dummies[i]}";
panel.gameObject.SetActive(true);
}
}
/// <summary>
/// 初期化を行います。
/// </summary>
public override void Initialize(QuizEntity quiz)
{
Reset();
var countOfChoices = quiz.Choices.Count / 2;
var leftChoices = quiz.Choices.Take(countOfChoices).ToList();
var rightChoices = quiz.Choices.Skip(countOfChoices).ToList();
for (int i = 0; i < lefts.Count && i < leftChoices.Count; i++)
{
var left = lefts[i];
left.Answer = leftChoices[i];
left.gameObject.SetActive(true);
}
for (int i = 0; i < rights.Count && i < rightChoices.Count; i++)
{
var right = rights[i];
right.Answer = rightChoices[i];
right.gameObject.SetActive(true);
}
}
internal void SetAnswer(QuizEntity CurrentQuiz, bool isTrue)
{
if (isTrue)
{
ProgressBar += 0.1f;
GameControllerLevel2.Instance.Score += GameConst.ScoreTrueAnswer;
CurrentQuiz.IsTrue = true;
}
else
{
ProgressBar -= 0.1f;
CurrentQuiz.IsTrue = false;
}
}
