public async Task <ActionResult> CreateQuestionType([FromBody] QuestionTypeModel questionTypeModel)
{
int result = 0;
string message = String.Empty;
try
{
var currentUser = User.Identity.Name;
if (questionTypeModel.Id == 0)
{
result = await questionTypeBll.AddQuestionType(questionTypeModel.TypeName, questionTypeModel.Describtion, currentUser);
if (result == -1)
{
message = "已存在此类型，不能重复添加";
}
}
else
{
result = await questionTypeBll.UpdateQuestionType(questionTypeModel.TypeName, questionTypeModel.Describtion, currentUser, questionTypeModel.Id);
}
}
catch (Exception e)
{
logger.Log(Level.Error, e, "CreateQuestionType");
}
return(Json(new { Id = result, Message = message }, JsonRequestBehavior.AllowGet));
}
public QuestionModel(QuestionTypeModel questionType, string question, string[] answers, double idealTime)
{
this.questionType = questionType;
this.answers = answers;
this.question = question;
this.idealTime = idealTime;
}
public async Task <QuestionTypeModel> InsertQuestionTypeAsync(QuestionTypeModel questionType)
{
questionType.AddedDate = DateTime.Now;
var newQuestionType = await questionTypeRepository.InsertAsync(mapper.Map <QuestionType>(questionType));
await questionTypeRepository.SaveChangesAsync();
return(mapper.Map <QuestionTypeModel>(newQuestionType));
}
public async Task <QuestionTypeModel> UpdateQuestionTypeAsync(QuestionTypeModel questionType)
{
var questionTypeForUpdate = await questionTypeRepository.GetAsync(questionType.Id);
questionTypeForUpdate.ModifiedDate = DateTime.Now;
questionTypeForUpdate.Name = questionTypeForUpdate.Name;
await questionTypeRepository.SaveChangesAsync();
return(mapper.Map <QuestionTypeModel>(questionTypeForUpdate));
}
public async Task <IHttpActionResult> Update([FromBody] QuestionTypeModel questionType)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var created = await questionTypeService.UpdateQuestionTypeAsync(questionType);
return(Ok(created));
}
//
public void StartQuestionRound(QuestionTypeModel questionTypeModel, Action <List <QuestionResultModel> > onRoundResult)
{
if (!isDebug)
{
InitQuestionSystem();
}
roundResultList.Clear();
questionRoundTimer = new QuestionSystemTimer();
questionRoundTimer.InitQuestionSystemTimer(true);
this.onRoundResult = onRoundResult;
NextQuestion();
}
private QuizQuestionResult ConvertDto(QuizQuestionResultDTO resultDTO, QuizResult quizResult)
{
var instance = new QuizQuestionResult
{
Question = resultDTO.question,
IsCorrect = resultDTO.isCorrect,
QuestionType = QuestionTypeModel.GetById(resultDTO.questionTypeId),
QuizResult = quizResult,
QuestionRef = QuestionModel.GetOneById(resultDTO.questionId).Value
};
return(instance);
}
/// <summary>
/// Get Question Type List
/// </summary>
/// <returns></returns>
public List <QuestionTypeModel> GetQuesetionTypeList()
{
List <QuestionTypeModel> lstQuestionTypeModel = new List <QuestionTypeModel>();
DataTable dtQuestionType = DLQuestionType.GetQuesetionTypeList();
foreach (DataRow dr in dtQuestionType.Rows)
{
QuestionTypeModel objQuestionTypeModel = GetDataRowToEntity <QuestionTypeModel>(dr);
lstQuestionTypeModel.Add(objQuestionTypeModel);
}
return(lstQuestionTypeModel);
}
public static List <QuestionModel> GetQuestionList(int numberOfQuestions, QuestionTypeModel questionTypeModel)
{
List <QuestionModel> questions = new List <QuestionModel>();
Dictionary <string, int> dictionary = new Dictionary <string, int> ();
dictionary.Add("SelectLetter", 1);
dictionary.Add("Typing", 1);
dictionary.Add("ChangeOrderController", 1);
dictionary.Add("WordChoice", 1);
dictionary.Add("SlotMachine", 1);
dictionary.Add("LetterLink", 1);
dictionary.Add("StackSwipeController", 1);
string selectionFromRandom = QuestionGenerator.GetPseudoRandomValue(dictionary);
for (int i = 0; i < numberOfQuestions; i++)
{
if (QuestionSystemController.Instance.isDebug)
{
string questionType = questionTypeModel.selectionType.GetType().Name;
QuestionTypeModel questionModel = GetQuestionType(questionType);
questions.Add(GetQuestion(questionModel));
}
else
{
QuestionModel questionType = GetQuestion(GetQuestionType(selectionFromRandom));
if (i < 2)
{
questionType.questionType.contentLevel = QuestionSystemEnums.ContentLevel.Easy;
}
else if (i < 5)
{
questionType.questionType.contentLevel = QuestionSystemEnums.ContentLevel.Normal;
}
else
{
questionType.questionType.contentLevel = QuestionSystemEnums.ContentLevel.Hard;
}
questions.Add(questionType);
}
}
return(questions);
}
public void OnDebugClick(Button button)
{
questionTypeModel = QuestionBuilder.GetQuestionType(button.name);
InitQuestionSystem();
}
public IActionResult Post(QuestionTypeModel model)
{
return(Ok(_questionRepository.SaveQuestionType(model.Name)));
}
public static QuestionModel GetQuestion(QuestionTypeModel questionType)
{
int randomize = 0;
bool questionViable = false;
string question = "";
List <string> answersList = new List <string> ();
int numOfQuestions = questionList.Count;
int whileIndex = 0;
double idealTime = 2.5;
while (!questionViable)
{
randomize = UnityEngine.Random.Range(0, questionList.Count);
answersList.Clear();
switch (questionType.questionCategory)
{
case QuestionSystemEnums.TargetType.Antonym:
if (questionList [randomize].hasAntonym.ToString() == "1")
{
if (questionType.selectionType.GetType().Name.Equals("WordChoice"))
{
answersList.Add(questionList [randomize].antonym1);
answersList.Add(questionList [randomize].antonym2);
answersList.Add(wrongChoices [randomize]);
question = questionList [randomize].answer;
questionViable = true;
}
else
{
answersList.Add(questionList [randomize].answer);
question = questionList [randomize].antonym1;
questionViable = true;
}
}
break;
case QuestionSystemEnums.TargetType.Synonym:
if (questionList [randomize].hasSynonym.ToString() == "1")
{
if (questionType.selectionType.GetType().Name.Equals("WordChoice"))
{
answersList.Add(questionList [randomize].synonym1);
answersList.Add(questionList [randomize].synonym2);
answersList.Add(wrongChoices [randomize]);
question = questionList [randomize].answer;
questionViable = true;
}
else
{
answersList.Add(questionList [randomize].answer);
question = questionList [randomize].synonym1;
questionViable = true;
}
}
break;
case QuestionSystemEnums.TargetType.Definition:
if (questionList [randomize].hasDefinition.ToString() == "1")
{
answersList.Add(questionList [randomize].answer);
question = questionList [randomize].definition;
questionViable = true;
}
break;
case QuestionSystemEnums.TargetType.Association:
if (questionList [randomize].hasClues.ToString() == "1")
{
answersList.Add(questionList [randomize].answer);
question = questionList [randomize].clues1 + "/" + questionList [randomize].clues2
+ "/" + questionList [randomize].clues3 + "/" + questionList [randomize].clues4;
questionViable = true;
}
break;
}
switch (questionType.contentLevel)
{
case QuestionSystemEnums.ContentLevel.Easy:
if (!(questionList [randomize].levelId < 3))
{
questionViable = false;
}
break;
case QuestionSystemEnums.ContentLevel.Normal:
if (!(questionList [randomize].levelId < 7) && !(questionList [randomize].levelId >= 4))
{
questionViable = false;
}
break;
case QuestionSystemEnums.ContentLevel.Hard:
if (questionList [randomize].levelId < 7)
{
questionViable = false;
}
break;
}
if (questionType.selectionType.GetType().Name.Equals("SlotMachine"))
{
if (questionList [randomize].answer.Length > 6)
{
questionViable = false;
}
}
if (questionsDone.Contains(question))
{
questionViable = false;
if (whileIndex >= numOfQuestions)
{
questionsDone.Clear();
}
}
whileIndex++;
}
switch (questionType.questionCategory)
{
case QuestionSystemEnums.TargetType.Definition:
idealTime += 0.5;
break;
case QuestionSystemEnums.TargetType.Association:
idealTime += 1;
break;
}
switch (questionType.selectionType.GetType().Name)
{
case "Typing":
idealTime += 1.5;
break;
case "SelectLetter":
idealTime += 1;
break;
case "SlotMachine":
idealTime += 1;
break;
case "WordChoice":
idealTime += 0.5;
break;
}
QuestionModel questionGot = new QuestionModel(questionType, question, answersList.ToArray(), idealTime);
questionsDone.Add(question);
return(questionGot);
}
public static QuestionTypeModel GetQuestionType(string selection)
{
Dictionary <QuestionSystemEnums.TargetType, int> targetDictionary = new Dictionary <QuestionSystemEnums.TargetType, int> ();
targetDictionary.Add(QuestionSystemEnums.TargetType.Definition, 1);
targetDictionary.Add(QuestionSystemEnums.TargetType.Synonym, 1);
targetDictionary.Add(QuestionSystemEnums.TargetType.Antonym, 1);
targetDictionary.Add(QuestionSystemEnums.TargetType.Association, 1);
QuestionTypeModel typeModel = null;
switch (selection)
{
case "SelectLetter":
typeModel = new QuestionTypeModel(
// QuestionSystemEnums.TargetType.Definition,
QuestionGenerator.GetTargetWay(targetDictionary),
QuestionSystemEnums.ContentLevel.Normal,
QuestionSystemController.Instance.partAnswer.fillAnswer,
QuestionSystemController.Instance.partSelection.selectLetter
);
break;
case "Typing":
typeModel = new QuestionTypeModel(
// QuestionSystemEnums.TargetType.Definition,
QuestionGenerator.GetTargetWay(targetDictionary),
QuestionSystemEnums.ContentLevel.Normal,
QuestionSystemController.Instance.partAnswer.fillAnswer,
QuestionSystemController.Instance.partSelection.typing
);
break;
case "ChangeOrderController":
typeModel = new QuestionTypeModel(
// QuestionSystemEnums.TargetType.Synonym,
QuestionGenerator.GetTargetWay(targetDictionary),
QuestionSystemEnums.ContentLevel.Normal,
QuestionSystemController.Instance.partAnswer.showAnswer,
QuestionSystemController.Instance.partSelection.changeOrder
);
break;
case "WordChoice":
targetDictionary.Remove(QuestionSystemEnums.TargetType.Definition);
targetDictionary.Remove(QuestionSystemEnums.TargetType.Association);
typeModel = new QuestionTypeModel(
// QuestionSystemEnums.TargetType.Synonym,
QuestionGenerator.GetTargetWay(targetDictionary),
QuestionSystemEnums.ContentLevel.Normal,
QuestionSystemController.Instance.partAnswer.noAnswer,
QuestionSystemController.Instance.partSelection.wordChoice
);
break;
case "SlotMachine":
typeModel = new QuestionTypeModel(
// QuestionSystemEnums.TargetType.Definition,
QuestionGenerator.GetTargetWay(targetDictionary),
QuestionSystemEnums.ContentLevel.Normal,
QuestionSystemController.Instance.partAnswer.showAnswer,
QuestionSystemController.Instance.partSelection.slotMachine
);
break;
case "LetterLink":
typeModel = new QuestionTypeModel(
// QuestionSystemEnums.TargetType.Association,
QuestionGenerator.GetTargetWay(targetDictionary),
QuestionSystemEnums.ContentLevel.Normal,
QuestionSystemController.Instance.partAnswer.showAnswer,
QuestionSystemController.Instance.partSelection.letterLink
);
break;
case "StackSwipeController":
typeModel = new QuestionTypeModel(
// QuestionSystemEnums.TargetType.Association,
QuestionGenerator.GetTargetWay(targetDictionary),
QuestionSystemEnums.ContentLevel.Normal,
QuestionSystemController.Instance.partAnswer.noAnswer,
QuestionSystemController.Instance.partSelection.stackSwipe
);
break;
}
if (QuestionSystemController.Instance.isDebug)
{
switch (QuestionSystemController.Instance.difficultyDrop.value)
{
case 0: typeModel.contentLevel = QuestionSystemEnums.ContentLevel.Easy;
break;
case 1:
typeModel.contentLevel = QuestionSystemEnums.ContentLevel.Normal;
break;
case 2:
typeModel.contentLevel = QuestionSystemEnums.ContentLevel.Hard;
break;
}
}
return(typeModel);
}
public static QuestionType ToEntity(this QuestionTypeModel model, QuestionType destination)
{
return(model.MapTo(destination));
}
public static QuestionType ToEntity(this QuestionTypeModel model)
{
return(model.MapTo <QuestionTypeModel, QuestionType>());
}
