public async Task <IActionResult> Edit(int id, [Bind("Title,Id,Content,Tags")] QuestionEntity questionEntity)
{
if (id != questionEntity.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var question = await _context.Questions.FirstOrDefaultAsync(x => x.Id == questionEntity.Id);
question.Content = questionEntity.Content;
question.Title = questionEntity.Title;
_context.Questions.Update(question);
_context.Questions.Update(question);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuestionEntityExists(questionEntity.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(questionEntity));
}
public QuestionDTO Get(int ID)
{
QuestionEntity getquestion = ur.Get(ID);
QuestionDTO question = Mapper.Map <QuestionDTO>(getquestion);
return(question);
}
private IQuestionEntity Decoder()
{
Task task = tasks.Find(item => item.Id == RandomizeFromList());
IQuestionEntity questionEntity = new QuestionEntity();
questionEntity.QuestionType = QuestionType.EasyReturn;
questionEntity.CodeType = CodeType;
questionEntity.Description = "Закодировать число: " + task.NumbToCoding;
Console.WriteLine("Закодировать число: " + task.NumbToCoding);
Console.WriteLine("Маска: " + task.Mask);
int[] maskNumbs = TransferMaskToArr(task.Mask);
questionEntity.Answer = new BaseValue()
{
Value = GenerateResult(maskNumbs, task.NumbToCoding)
};
questionEntity.Question = new BaseValue()
{
Value = "Маска: " + task.Mask
};
return(questionEntity);
}
public async Task <bool> Handle(AskQuestionCommand request, CancellationToken cancellationToken)
{
var question = new QuestionEntity(
request.Title,
request.UserId,
request.Tags
);
question.DefineId(request.Id);
var questionBody = new AnswerEntity(
request.Body,
request.UserId,
AnswerKind.QuestionBody,
votes: 0
);
questionBody.DefineId(Guid.NewGuid());
question.SetQuestionBody(questionBody);
await _repository.RegisterAsync(question);
return(true);
}
public void RequestQuestion(int id)
{
QuestionEntity qe = Utils.GetQuestionById(id);
if (qe == null)
{
Debug.LogError("问题id不存在！");
return;
}
kQuestionName.text = qe.questionName;
//Debug.Log("qe.dubStr: " + qe.dubStr);
audioManager.PlayAudio(id, qe.dubStr);
List <OptionEntity> randomOptions = GetRandomOptions(qe.options);
int optionsCount = randomOptions.Count;
for (int i = 0; i < kOptions.Length; i++)
{
if (i >= optionsCount)
{
kOptions[i].gameObject.SetActive(false);
continue;
}
kOptions[i].transform.Find("Label_option").GetComponent <Text>().text = randomOptions[i].optionName;
kOptions[i].transform.GetComponent <OptionState>().optionId = randomOptions[i].optionId;
}
correctAnswer = qe.answers;
cPoint = qe.point;
}
public QuestionModel(QuestionEntity question)
{
Id = question.Id;
Message = question.Message;
SelectedAnswerId = question.SelectedAnswerId;
Answers = question.Answers.Select(x => new AnswerModel(x)).ToList();
}
public async Task <Response <IQuestion> > CreateQuestion(QuestionDTO createQuestion)
{
var response = new Response <IQuestion>();
try
{
if (createQuestion.Name == null)
{
response.Error = new Error(400, "Not valid model");
return(response);
}
var question = new QuestionEntity()
{
Name = createQuestion.Name,
Description = createQuestion.Description,
AnswerForQuestionEntity = new List <AnswerForQuestionEntity>()
};
_context.Questions.Add(question);
await _context.SaveChangesAsync();
response.Data = question;
}
catch (Exception e)
{
response.Error = new Error(500, "Can`t create question: " + e);
}
return(response);
}
public void ShouldReturnQuestion()
{
//arrange
var questionEntity = new QuestionEntity
{
Id = 1,
Text = "Test question"
};
var context = TestDbContextCreator.CreateInMemory(nameof(ShouldReturnQuestion));
context.Questions.Add(questionEntity);
context.SaveChanges();
var expected = new Question
{
Id = questionEntity.Id,
Text = questionEntity.Text
};
var sut = new QuestionsService(context);
//act
var actual = sut.GetQuestion(questionEntity.Id);
//assert
actual.Should().BeEquivalentTo(expected);
}
public bool insertQuestion(QuestionEntity question)
{
SqlConnection con = new SqlConnection("Server= arquisqlserver.database.windows.net; Database= arquitectura;User Id=arquisqlserver;Password = arquitectura2019!;"); int i = 0;
//insert the information to the database
StringBuilder stringquery = new StringBuilder();
stringquery.Append("insert into Pregunta (DescripcionPregunta,TipoPregunta,AreaPregunta,PuntajeMaximo,curso) values ");
stringquery.Append("('" + question.descripcionPregunta + "','" + question.TipoPregunta + "','" + question.AreaPregunta + "'," + question.PuntajeMaximo + ",'" + question.curso + "')");
SqlCommand cmd = new SqlCommand(stringquery.ToString(), con);
if (con.State == ConnectionState.Closed)
{
con.Open();
i = cmd.ExecuteNonQuery();
con.Close();
}
if (i > 0)
{
return(true);
}
else
{
return(false);
}
}
public void AddQuestion(string userId, QuestionModel questionModel)
{
var questionId = Guid.NewGuid().ToString();
var question = new QuestionEntity()
{
Question = questionModel.Question,
Options = String.Join(", ", questionModel.Options),
QuestionType = (int)questionModel.QuestionType,
QuestionId = questionId,
UserId = userId
};
UnitOfWork.QuestionRepository.Insert(question);
UnitOfWork.Commit();
var questionCount = UserProgressService.GetAnsweredQuestionCount(userId);
var userProgress = UserProgressRepository.GetCurrentProgress(userId);
userProgress.Question = question;
userProgress.QuestionNumber++;
UnitOfWork.UserProgressRepository.Update(userProgress);
UnitOfWork.Commit();
}
private IQuestionEntity Encoder()
{
IQuestionEntity questionEntity = new QuestionEntity();
questionEntity.QuestionType = QuestionType.EasyReturn;
questionEntity.CodeType = CodeType;
Console.WriteLine("\n==================================\n");
string numbToDecoding = GenerateNumbToDecoding();
questionEntity.Description = "Число для декодирования: " + numbToDecoding;
Task task = tasks.Find(item => item.Id == RandomizeFromList());
string decodMask = task.Mask;
Console.WriteLine("Число для декодирования: " + numbToDecoding);
Console.WriteLine("Маска: " + decodMask);
int[] maskNumbs = TransferMaskToArr(decodMask);
string[] numbToDecodingParts = TransferResToParts(numbToDecoding, maskNumbs);
string answer = GetMyltipliedByMask(maskNumbs, numbToDecodingParts);
questionEntity.Question = new BaseValue()
{
Value = string.Format("Маска: {1}", numbToDecoding, decodMask)
};
questionEntity.Answer = new BaseValue()
{
Value = answer.ToString()
};
return(questionEntity);
}
public virtual void AddItem(QuestionEntity question)
{
if (question != null)
{
Questions.Add(question);
}
}
public async Task <CloseQuestionResult> CloseQuestionAsync(CloseQuestionCommand command)
{
ThrowIfDisposed();
QuestionEntity questionEntity = await QuestionRepository.GetQuestionAsync(command.QuestionId);
if (questionEntity == null)
{
return(new CloseQuestionResult(new Error("Not Found", "Question not found")));
}
if (questionEntity.IsClosed)
{
return(new CloseQuestionResult(new Error("Can't close", "Question is already closed")));
}
if (questionEntity.Token != command.Token)
{
return(new CloseQuestionResult(new Error("Can't close", "Token is not valid")));
}
questionEntity.IsClosed = true;
await QuestionRepository.UpdateAsync(questionEntity, CancellationToken);
return(new CloseQuestionResult());
}
/// <summary>
/// Saves a question and its choices
/// </summary>
/// <param name="questionToUpdate">The question to be saved</param>
/// <returns>True if succeeded</returns>
public async Task <bool> SaveQuestion(QuestionEntity question)
{
BlissRecruitmentDBContext.Questions.Add(question);
int result = await BlissRecruitmentDBContext.SaveChangesAsync();
return(result > -1);
}
public async Task <bool> UpdateQuestion(Question question)
{
var table = _tableClient.GetTableReference(TableNames.Player);
// Get old entity
QuestionEntity oldEntity = await GetQuestionEntity(question.Id);
if (oldEntity == null)
{
_logger.LogError($"Could not update question, no question with ID {question.Id} found.");
return(false);
}
QuestionEntity newQuestion = new QuestionEntity(question)
{
ETag = oldEntity.ETag
};
TableOperation mergeOperation = TableOperation.Merge(newQuestion);
TableResult result = await table.ExecuteAsync(mergeOperation);
if (result.HttpStatusCode != 204)
{
return(false);
}
return(true);
}
public ActionResult DeleteQuestion(long id, FormCollection collection)
{
try
{
QuestionFactory DeleteQuestion = new QuestionFactory();
QuestionEntity Question = new QuestionEntity();
Question = DeleteQuestion.GetQuestionById(id);
DataLayer.tblQuestion NewQuestion = new DataLayer.tblQuestion();
NewQuestion.QuestionId = id;
NewQuestion.QuizId = Question.QuizId;
NewQuestion.Question = Question.Question;
NewQuestion.CreatedDate = Question.CreatedDate;
NewQuestion.CreatedBy = Question.CreatedBy;
NewQuestion.UpdatedDate = DateTime.Now;
NewQuestion.UpdatedBy = null;
NewQuestion.IsActive = false; // IsActive will be false in delete record
DeleteQuestion.SaveQuestion(NewQuestion);
return(RedirectToAction("Question"));
}
catch
{
return(View());
}
}
public string QuestionValidity(string QuestionName, long?QuestionId)
{
List <QuestionEntity> usrList = new List <QuestionEntity>();
QuestionEntity Question = new QuestionEntity();
if (QuestionId != null)
{
Question = db.tblQuestions.Where(x => x.Question.ToLower() == QuestionName.ToLower() && x.QuestionId != QuestionId).Select(x => new QuestionEntity()
{
Question = x.Question,
}).FirstOrDefault();
}
else
{
Question = db.tblQuestions.Where(x => x.Question.ToLower() == QuestionName.ToLower()).Select(x => new QuestionEntity()
{
Question = x.Question,
}).FirstOrDefault();
}
if (Question != null)
{
return("Question already exist.");
}
else
{
return("Success");
}
}
///<summary>
///Desativa questionário
/// </summary>
public void Desactivateing(int id)
{
QuestionRepository repository = new QuestionRepository();
QuestionEntity entity = repository.GetById(id);
entity.status = false;
repository.update(entity);
}
// GET: Question/Delete/5
public ActionResult DeleteQuestion(long id)
{
QuestionFactory EditQuestion = new QuestionFactory();
QuestionEntity topic = new QuestionEntity();
topic = EditQuestion.GetQuestionById(id);
return(View(topic));
}
public override void RemoveLine(QuestionEntity question)
{
if (question != null)
{
base.RemoveLine(question);
Session.SetQuestionStorageToSession("QuestionStorage", this);
}
}
public async Task <bool> UpdateAsync(QuestionEntity entity)
{
List <QuestionEntity> questions = await GetAsync();
bool response = await base.UpdateAsync(questions);
return(response);
}
public override void AddItem(QuestionEntity question)
{
if (question != null)
{
base.AddItem(question);
Session.SetQuestionStorageToSession("QuestionStorage", this);
}
}
public ActionResult Save(QuestionEntity entity)
{
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
{
if (ModelState.IsValid)
{
if (entity.Question == null)
{
ModelState.AddModelError("", "O campo pergunta é obrigatório!");
return(PartialView("_Edit", entity));
//return Json(new { status = "warn", message = "O campo pergunta é obrigatório!" });
}
if (entity.Id == 0)
{
QuestionService service = QuestionService.Instance;
entity.InitialDate = DateTime.Now;
entity.CreatedBy = CurrentUserEmail;
entity.LastUpdate = DateTime.Now;
entity.FirmId = CurrentFirm.Id;
entity.status = true;
service.Create(entity);
Success("Registro cadastrado com sucesso!");
scope.Complete();
//return Json(new { status = "sucess", message = "Registro cadastrado com sucesso!" });
}
else
{
QuestionService service = QuestionService.Instance;
entity.LastUpdate = DateTime.Now;
entity.status = true;
entity.UpdatedBy = CurrentUserEmail;
entity.FirmId = CurrentFirm.Id;
service.Update(entity);
Success("Registro 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 a Pergunta.");
return(PartialView("_Edit", entity));
}
}
}
catch (Exception ex)
{
Logger.LogException(ex);
ModelState.AddModelError("", "Ocorreu um problema!");
return(PartialView("_Edit", entity));
// return Json(new { status = "error", message = "Ocorreu um problema!" });
}
return(new EmptyResult());
}
public async Task <bool> InsertAsync(QuestionEntity entity)
{
QuestionEntity lastQuestion = (await GetAsync())?.OrderByDescending(q => q.QuestionID)?.FirstOrDefault();
entity.QuestionID = (lastQuestion?.QuestionID ?? 0) + 1;
bool response = await base.InsertAsync(entity);
return(response);
}
public async Task <QuestionEntity> UpsertQuestion(QuestionEntity question)
{
await this.dbCtx.AddAsync(question);
await this.dbCtx.SaveChangesAsync();
this.DetachEntity(question);
return(question);
}
public void postQuestionAsync(int areaId, int courseId, int lessonId, QuestionEntity question)
{
question.State = true;
question.Status = true;
question.CreateDate = DateTime.Now;
question.UpdateDate = DateTime.Now;
PIDBContext.Entry(question.Lesson).State = EntityState.Unchanged;
PIDBContext.Questions.Add(question);
}
/// <summary>
/// Crear un nuevo objeto QuestionEntity.
/// </summary>
/// <param name="idQuestion">Valor inicial de IdQuestion.</param>
/// <param name="question">Valor inicial de Question.</param>
/// <param name="difficulty">Valor inicial de Difficulty.</param>
public static QuestionEntity CreateQuestionEntity(int idQuestion, string question, byte difficulty)
{
QuestionEntity questionEntity = new QuestionEntity();
questionEntity.IdQuestion = idQuestion;
questionEntity.Question = question;
questionEntity.Difficulty = difficulty;
return(questionEntity);
}
public static QuestionTreeNode ToQuestionTreeNode(this QuestionEntity entity, QuestionAnswer?type)
{
return(new QuestionTreeNode
{
Id = entity.Id,
Text = entity.Text,
Type = type,
});
}
private async Task <QuestionEntity> CreateQuestion(QuestionEntity questionEntity)
{
var user = await GetCurentUser();
questionEntity.Author = user.UserName;
questionEntity.AuthorId = user.Id;
questionEntity.Created = DateTime.Now;
return(questionEntity);
}
public static QuestionViewModel ToMvcQuestion(this QuestionEntity questionEntity)
{
return(new QuestionViewModel
{
Id = questionEntity.Id,
QuestionContent = questionEntity.QuestionContent,
QuantityPoint = questionEntity.QuantityPoint,
TestId = questionEntity.TestId
});
}
public static QuestionEntity ToEntity(this QuestionViewModel questionViewModel)
{
QuestionEntity questionEntity = new QuestionEntity()
{
Id = questionViewModel.Id,
Options = new List<OptionEntity>(),
Text = questionViewModel.Text,
TestId = questionViewModel.TestId
};
foreach (var valuePair in questionViewModel.Options)
{
questionEntity.Options.Add(valuePair.Value.ToEntity());
}
return questionEntity;
}
public static QuestionEntity ToBllQuestion(this DalQuestion question)
{
QuestionEntity questionEntity = new QuestionEntity()
{
Id = question.Id,
TestId = question.TestId,
Text = question.Text,
Options = new List<OptionEntity>()
};
foreach (var dalOption in question.Options)
{
questionEntity.Options.Add(dalOption.ToBllOption());
}
return questionEntity;
}
/// <summary>
/// 获取本例中包含的知识图
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public List<QuestionEntity> GetKnowledge(string text)
{
List<QuestionEntity> result = new List<QuestionEntity>();
try
{
string[] lines = text.Split(new string[] { ".", "。", ",", "，", "\r\n", "\n", "!" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var line in lines)
{
Tuple<string[], string[]> tuple = segment.SplitToArray(line);
for (int i = 0; i < knowledgePatterns.Count; i++)
{
string entityA = "";
string relation = "";
string entityB = "";
string[] entities = knowledgePatterns[i].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
int index = 0;
bool flag = false;
int current = 0;
List<string> resultList = new List<string>();
for (int j = 0; j < tuple.Item1.Length; j++)
{
if (entities.Length == index)
{
entityB = string.Join("", resultList.ToArray());
QuestionEntity entity = new QuestionEntity();
entity.EntityA = entityA;
entity.EntityB = entityB;
entity.Relation = relation;
entity.KnowledgePattern = knowledgePatterns[i];
string[] qus = questionPatterns[i].Replace("[1]", entityA)
.Replace("[2]", relation)
.Replace("[3]", entityB).Split(new[] { "key=" }, StringSplitOptions.RemoveEmptyEntries);
entity.QuestionDesc = qus[0];
entity.Answer = qus[1];
result.Add(entity);
break;
}
if (entities[index] == "*")
{
if (current == 1)
{
entityA = string.Join("", resultList.ToArray());
}
if (current == 2)
{
relation = string.Join("", resultList.ToArray());
}
resultList.Clear();
current++;
index++;
}
if (tuple.Item2[j] == entities[index])
{
resultList.Add(tuple.Item1[j]);
flag = true;
index++;
}
if (index < entities.Length && j < tuple.Item2.Length - 1 &&
tuple.Item2[j + 1] != entities[index] && entities[index] != "*" && flag && resultList.Count > 0)
{
resultList.RemoveAt(resultList.Count - 1);
index--;
flag = false;
}
}
if (entityB == string.Empty && entityA != string.Empty && relation != string.Empty &&
resultList.Count > 0)
{
entityB = string.Join("", resultList.ToArray());
QuestionEntity entity = new QuestionEntity();
entity.EntityA = entityA;
entity.EntityB = entityB;
entity.Relation = relation;
entity.KnowledgePattern = knowledgePatterns[i];
string[] qus = questionPatterns[i].Replace("[1]", entityA)
.Replace("[2]", relation)
.Replace("[3]", entityB).Split(new[] { "key=" }, StringSplitOptions.RemoveEmptyEntries);
entity.QuestionDesc = qus[0];
entity.Answer = qus[1];
result.Add(entity);
}
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
return result;
}
/// <summary>
/// No hay ningún comentario para QuestionEntities en el esquema.
/// </summary>
public void AddToQuestionEntities(QuestionEntity questionEntity)
{
base.AddObject("QuestionEntities", questionEntity);
}
/// <summary>
/// Crear un nuevo objeto QuestionEntity.
/// </summary>
/// <param name="idQuestion">Valor inicial de IdQuestion.</param>
/// <param name="question">Valor inicial de Question.</param>
/// <param name="difficulty">Valor inicial de Difficulty.</param>
public static QuestionEntity CreateQuestionEntity(int idQuestion, string question, byte difficulty)
{
QuestionEntity questionEntity = new QuestionEntity();
questionEntity.IdQuestion = idQuestion;
questionEntity.Question = question;
questionEntity.Difficulty = difficulty;
return questionEntity;
}
