public ActionResult Create(FormCollection collection)
{
try
{
var id = new Guid(collection["Course"]);
var course = this.Context.Courses.FirstOrDefault(c => c.ID == id);
var problems = course.Problems.Shuffle().Take(Models.Test.QuestionsPerTest).ToList();
var test = new Models.Test();
test.ID = Guid.NewGuid();
test.Course = course;
test.Date = DateTime.Now;
test.Questions = new List<Models.Question>();
test.UserKey = this.UserID;
foreach (var problem in problems)
{
var question = new Models.Question();
question.ID = Guid.NewGuid();
question.Problem = problem;
question.Answers = new List<Models.Answer>();
test.Questions.Add(question);
}
this.Context.Tests.Add(test);
this.Context.SaveChanges();
}
catch
{
}
return RedirectToAction("Index");
}
public async Task <IActionResult> PutAsync(int id, [FromBody] Models.Question questionData)
{
if (id != questionData.Id)
{
return(BadRequest());
}
context.Entry(questionData).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Ok(questionData));
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Question question)
{
//var question = await context.Questions.SingleOrDefaultAsync(q=>q.ID==id);
if (id != question.ID)
{
return(BadRequest());
}
context.Entry(question).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Ok(question));
}
public IActionResult Edit(Models.Question question)
{
try
{
questionRep.Save(question);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View(question));
}
}
public async Task <IActionResult> Post([FromBody] Models.Question question)
{
if (context.Quiz.SingleOrDefault(q => q.Id == question.QuizId) == null)
{
return(NotFound());
}
context.Questions.Add(question);
await context.SaveChangesAsync();
return(Ok(question));
}
public static QuestionDto ToDto(this Models.Question entity)
{
return(new QuestionDto
{
Id = entity.Id,
Interogation = entity.Interogation,
Reponse = entity.Propositions.Count == 0 ? null : entity.Propositions.First(x => x.IsCorrect).Proposition,
QuestionType = entity.QuestionType,
Propositions = entity.Propositions.Select(x => PropositionDtoExtensions.ToDto(x)),
MediaQuestion = entity.MediaQuestions.Select(x => x.ToDto())
});
}
public static QuestionTexteDtoBO ToDto(this Models.Question entity)
{
return(new QuestionTexteDtoBO
{
Id = entity.Id,
Interogation = entity.Interogation,
Reponse = entity.Propositions == null ? null : (PropositionDtoBOExtensions.ToDto(entity.Propositions.First(x => x.IsCorrect))).ToReponse(),
Propositions = entity.Propositions.Where(x => !x.IsCorrect).Select(x => PropositionDtoBOExtensions.ToDto(x)).ToList(),
QuestionType = entity.QuestionType,
Media = entity.MediaQuestions.Count == 0 ? null : entity.MediaQuestions.First().ToDto()
});
}
public async Task <IActionResult> Post([FromBody] Models.Question question)
{
var project = context.Project.SingleOrDefault(q => q.ID == question.ProjectId);
if (project == null)
{
return(NotFound());
}
context.Questions.Add(question);
await context.SaveChangesAsync();
return(Ok(question));
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Question question) //id passed to explicity modify and check
{
if (id != question.QuestId)
{
return(BadRequest());
}
context.Entry(question).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Ok(question));
}
public async Task <IActionResult> Post([FromBody] Models.Question question)
{
var quiz = context.Quiz.SingleOrDefault(q => q.ID == question.QuizId); //context.Questions.Add( new Models.Question() { Text="text1"} );
if (quiz == null)
{
return(NotFound());
}
context.Questions.Add(question);
await context.SaveChangesAsync();
return(Ok(question));
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Question question)
{
if (id != question.ID)
{
return(BadRequest());
}
await _context.SaveChangesAsync();
_context.Entry(question).State = EntityState.Modified;
return(Ok(question));
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Question question)
{
// check for ID mismatch
if (id != question.ID)
{
return(BadRequest());
}
// indicate that the question has been edited
context.Entry(question).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Ok(question));
}
internal static Client.Models.Question ToQuestion(this Models.Question question)
{
if (question == null)
{
throw new ArgumentNullException(nameof(question));
}
return(new Client.Models.Question()
{
PossibleAnswers = question.PossibleAnswers,
Text = question.Text,
Type = question.Type.ToQuestionType()
});
}
public async Task <bool> UpdateQuestion(QuestionParam param)
{
Models.Question question = await _uow.QuestionRepository.GetFirst(filter : ques => ques.QuestionId == param.QuestionId);
if (question != null)
{
question.QuestionTime = param.QuestionTime;
question.QuestionContent = param.QuestionContent;
question.DispOrder = param.DispOrder;
question.SetId = param.SetId;
_uow.QuestionRepository.Update(question);
}
return(await _uow.CommitAsync() > 0);
}
public async Task <IActionResult> Post([FromBody] Models.Question question)
{
var quiz = _context.Quiz.SingleOrDefault(q => q.Id == question.QuizId);
if (quiz == null)
{
return(NotFound());
}
await _context.Questions.AddAsync(question);
_context.SaveChanges();
return(Ok(question));
}
public async Task <IActionResult> Post([FromBody] Models.Question question)
{
var quiz = quizeContext.Quizs
.SingleOrDefault(x => x.Id == int.Parse(question.QuizId));
if (quiz == null)
{
return(NotFound());
}
quizeContext.Questions.Add(question);
await quizeContext.SaveChangesAsync();
return(Ok(question));
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Question question)
{
if (id != question.ID)
{
return(BadRequest());
}
//Modifies a question
context.Entry(question).State = EntityState.Modified;
//Saves changes to the question
await context.SaveChangesAsync();
//Response
return(Ok(question));
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Question questionData)
{
// if the id in the url not the same in the object
if (id != questionData.ID)
{
return(BadRequest());
}
//var question = await context.Questions.SingleOrDefaultAsync(q => q.ID == id);
context.Entry(questionData).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Ok(questionData));
}
public static QuestionListItemsViewModel From(Models.Question question)
{
QuestionListItemsViewModel model = new QuestionListItemsViewModel();
if (question.User != null)
{
model.UserId = question.User.Id;
model.UserName = question.User.Contact.FullName;
}
model.ProductId = question.Product.Id;
model.ProductName = question.Product.Name;
model.Email = question.Email;
model.Text = question.Text;
model.Date = question.Date;
return(model);
}
public async Task <IActionResult> Post([FromBody] Models.Question question)
{
var quiz = context.Quiz.SingleOrDefault(q => q.ID == question.QuizId);
if (quiz == null)
{
return(NotFound());
}
//Adds a questions to the object
context.Questions.Add(question);
//Saves a questions
await context.SaveChangesAsync();
//Response
return(Ok(question));
}
public ActionResult Edit(Models.Question question, HttpPostedFileBase Image, int[] AnswerID, string[] AnswerContent, string[] IsCorrect)
{
List <Answer> listAnswer = new List <Answer>();
for (int i = 0; i < AnswerID.Length; i++)
{
Answer answer = new Answer();
answer.AnswerID = AnswerID[i];
answer.AnswerContent = AnswerContent[i];
answer.IsCorrect = IsCorrect.Contains(AnswerContent[i]);
listAnswer.Add(answer);
}
question.ModifiedBy = int.Parse(Session["Name"].ToString());
if (Image != null && Image.ContentLength > 0)
{
string filePath = Path.Combine(Server.MapPath("~/Content/QuestionUpload/Images/"),
Path.GetFileName(Image.FileName));
Image.SaveAs(filePath);
question.Image = Image.FileName;
}
else
{
var img = questionService.FindID(question.QuestionID).Image;
question.Image = img;
}
questionService.UpdateQuestion(question);
//
answerService.DelteAnswerbyQuestionID(question.QuestionID);
foreach (var item in listAnswer)
{
item.QuestionID = question.QuestionID;
if (item.QuestionID <= 0)
{
return(RedirectToAction("Edit", "Question"));
}
else
{
answerService.AddAnswer(item);
}
}
return(RedirectToAction("Index"));
}
public IActionResult Create()
{
var question = new Models.Question();
var list = new List <SelectListItem>();
foreach (var user in usersRep.GetAll())
{
list.Add(new SelectListItem
{
Text = user.Name + " (" + user.EMail + ")",
Value = user.Id.ToString()
});
}
ViewBag.users = list;
return(View(question));
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Question question)
{
if (id != question.ID)
{
return(BadRequest());
}
if (context.Quiz.SingleOrDefault(q => q.ID == question.QuizID) == null)
{
return(NotFound());
}
context.Entry(question).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Ok(question));
}
public async Task <bool> UpdateQuestion(Models.Question question)
{
var currentQuestion = await _quizManagerContext.Questions.Include(x => x.CorrectAnswer)
.Include(y => y.WrongAnswers)
.ThenInclude(z => z.Answers)
.FirstOrDefaultAsync(q => q.Id == question.Id);
if (currentQuestion != null)
{
currentQuestion.QuestionString = question.QuestionText;
currentQuestion.CorrectAnswer = new Answer {
AnswerText = question.CorrectAnswer
};
var newWrongAnswers = new WrongAnswers
{
Answers = new List <Answer>()
};
foreach (var answer in question.WrongAnswers)
{
var newWrongAnswer = new Answer
{
AnswerText = answer
};
newWrongAnswers.Answers.Add(newWrongAnswer);
}
currentQuestion.WrongAnswers = newWrongAnswers;
try
{
await _quizManagerContext.SaveChangesAsync();
return(true);
}
catch (Exception)
{
return(false);
}
}
return(false);
}
public async Task <IActionResult> Put(int id, [FromBody] Models.Question questionInput)
{
var existing = await _context.Questions.FirstOrDefaultAsync(q => q.Id == id).ConfigureAwait(false);
if (existing == null)
{
return(BadRequest(nameof(id)));
}
existing.Answer1 = questionInput.Answer1;
existing.Answer2 = questionInput.Answer2;
existing.Answer3 = questionInput.Answer3;
existing.CorrectAnswer = questionInput.CorrectAnswer;
existing.Text = questionInput.Text;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(Ok(existing));
}
public Game(Models.Question question)
{
InitializeComponent();
question.incorrect_answers.Add(question.correct_answer);
question.incorrect_answers.OrderBy(a => Guid.NewGuid()).ToList();
Question.Text = question.question;
foreach (string ques in question.incorrect_answers)
{
var btn = new Button()
{
CommandParameter = question.correct_answer, Text = ques
};
btn.Clicked += Btn_Clicked;
Answers.Children.Add(btn);
}
}
public async Task GetSurveyReturnsWithQuestionsFilteredBySlugName()
{
string slugName = "slug-name";
var mock = new Mock <IAzureBlobContainer <Models.Survey> >();
var question = new Models.Question {
Type = Enum.GetName(typeof(QuestionType), QuestionType.SimpleText)
};
var questions = new[] { question };
var surveyModel = new Models.Survey {
Questions = questions
};
mock.Setup(t => t.GetAsync(slugName)).ReturnsAsync(surveyModel).Verifiable();
var target = new SurveyManagementService(null, null, (containerName) => mock.Object);
var survey = await target.GetSurveyAsync(slugName);
Assert.AreEqual(1, survey.Questions.Count);
}
//this is called when user submits a POST request of the answer they selected
public string ProcessAnswer([FromBody] AnswerResult answer)
{
string returnText = "";
try
{
using (_context)
{
Answer dbAnswer = new Models.Answer(); //New instance of Answer class, representing one row in the DB's Answer table
//make sure the question id given is actually an int value potentially in the DB
if (Int32.Parse(answer.optionId) < 1)
{
throw new System.ArgumentException("Parameter must be greater than 0");
}
//update answer table, marking which question was answered
dbAnswer = _context.Answers.FirstOrDefault(a => a.Id == Int32.Parse(answer.optionId));
dbAnswer.WasSelected = true;
_context.Answers.Update(dbAnswer);
if (Int32.Parse(answer.questionId) < 1)
{
throw new System.ArgumentException("Parameter must be greater than 0");
}
//update question table, marking this question as answered
Question dbQuestion = new Models.Question();
dbQuestion = _context.Questions.FirstOrDefault(q => q.Id == Int32.Parse(answer.questionId));
dbQuestion.IsComplete = true;
_context.Questions.Update(dbQuestion);
_context.SaveChanges(); //Applies changes to DB
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
Response.StatusCode = 400;
returnText = e.ToString();
}
return(returnText);
}
public async Task <IActionResult> Post([FromBody] Models.Question question)
{
if (question == null)
{
throw new ArgumentNullException(nameof(question));
}
var existingQuiz = await _context.Quizzes.FirstOrDefaultAsync(q => q.Id == question.QuizId).ConfigureAwait(false);
if (existingQuiz == null)
{
return(NotFound($"Quiz with {question.QuizId} id cannot be found"));
}
existingQuiz.Questions.Add(question);
//await _context.Questions.AddAsync(question).ConfigureAwait(false);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(Ok(question));
}
public ActionResult Question(string questionId)
{
if (String.IsNullOrEmpty(questionId))
{
return(RedirectToAction("Index"));
}
HttpClient c = new HttpClient();
var a = new HttpRequestMessage(HttpMethod.Get, ApiHelper.GetApiUrl() + "vote?uniqueId=" + questionId);
c.Timeout = TimeSpan.FromSeconds(10);
var httpResponse = c.GetStringAsync(ApiHelper.GetApiUrl() + "vote?uniqueId=" + questionId);
while (httpResponse.Status == TaskStatus.WaitingForActivation)
{
}
string acceptedJSON = httpResponse.Result;
Models.Question q = JsonConvert.DeserializeObject <Question>(acceptedJSON);
return(View(q));
}
public IHttpActionResult CreateQuestion(
[FromBody] CreateQuestion questionItem)
{
if (questionItem == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var itemToInsert = new Models.Question()
{
Title = questionItem.Title,
Status = questionItem.Status
};
var item = QuestionRepository.CreateQuestion(Mapper.Map <Entities.Question>(itemToInsert));
return(Created("Created", Mapper.Map <Models.Question>(item)));
}
