public ActionResult Create(Models.Question question, HttpPostedFileBase Image, List <Answer> listAnswers)
{
question.CreatedBy = int.Parse(Session["Name"].ToString());
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
{
question.Image = null;
}
var addQuestion = questionService.AddQuestion(question);
TranferID.ID = addQuestion;
// Create Answer
foreach (var i in listAnswers)
{
i.QuestionID = TranferID.ID;
if (i.QuestionID <= 0)
{
return(RedirectToAction("Create", "Question"));
}
else
{
answerService.AddAnswer(i);
}
}
return(RedirectToAction("Index"));
}
public object AddQuestion(PostQuestion question)
{
if (question == null || string.IsNullOrEmpty(question.Author) ||
string.IsNullOrEmpty(question.Content) || string.IsNullOrEmpty(question.Title))
{
return(new ReturnResult <QuestionModel>(-4, "传入参数错误!"));
}
return(_QuestionService.AddQuestion(question.ToModel()));
}
public ActionResult AddQuestion(DataModel data)
{
if (data.Question.Text == null)
{
ViewBag.errorQuestion = "Complete question text!";
data.Survey = surveyService.GetSurvey(data.Survey.Id);
ViewBag.question = questionService.GetCountQuestion(data.Survey.Id) + 1;
return(View("Views/Question/Index.cshtml", data));
}
data.Survey = surveyService.GetSurvey(data.Survey.Id);
Question question = new Question();
question.Survey = data.Survey;
question.Text = data.Question.Text;
questionService.AddQuestion(question);
DataModel model = new DataModel();
model.Question = question;
model.Survey = data.Survey;
ViewBag.option = 1;
ViewBag.question = questionService.GetCountQuestion(model.Survey.Id);
return(View("Views/Question/QuestionOption.cshtml", model));
}
public async Task <ActionResult> PostAsync([FromBody] Question question)
{
try
{
if (question.ValidationErrors().Any())
{
return(StatusCode((int)HttpStatusCode.PreconditionFailed, string.Join(" | ", question.ValidationErrors())));
}
var newQuestion = new Question
{
Content = question.Content,
IsDeleted = false,
IsDisplayed = true,
CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now
};
var result = await _questionService.AddQuestion(newQuestion);
if (result)
{
return(StatusCode((int)HttpStatusCode.Created, "Question created successfully !!!"));
}
return(StatusCode((int)HttpStatusCode.OK, "Question not created !!!"));
}
//catch (Exception ex) { return this.custom_error(ex); } // TODO
catch (Exception ex) { return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message)); }
}
public async Task <IActionResult> AddQuestion([FromBody] QuestionVm request)
{
if (await _questionService.AddQuestion(request))
{
return(Ok("Successfull"));
}
return(BadRequest("Question is exist"));
}
public async Task <ActionResult <Question> > AddQuestion(Question question)
{
var point_user = Int32.Parse(GetClaim("point"));
question = await _questionService.AddQuestion(point_user, question);
return(Ok(question));
}
public IActionResult Add(int id, QuestionViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
_questionService.AddQuestion(model);
return(RedirectToAction("Add", "Question"));
}
public IActionResult CreateQuestion([FromBody] QuestionDto question, int vacancyId)
{
if (ModelState.IsValid)
{
_questionService.AddQuestion(question, vacancyId);
return(StatusCode(StatusCodes.Status201Created));
}
return(BadRequest());
}
public ActionResult Create(QuestionViewModel question, int?testId) // [Bind(Include = "QuestionId,Name,Complexity,Rate,Duration,IsApproved")]
{
if (ModelState.IsValid)
{
QuestionDto questionDto = _mapper.Map <QuestionViewModel, QuestionDto>(question);
_questionService.AddQuestion(questionDto);
return(RedirectToAction("Details", "Tests", new { id = question.TestId }));
}
return(View(question));
}
public IHttpActionResult Post([FromBody] QuestionVM questionVM)
{
if (questionVM == null || !questionVM.isWalid())
{
return(BadRequest());
}
_questionService.AddQuestion(Mapper.Map <QuestionDTO>(questionVM));
return(Ok());
}
public IActionResult AddQuestion(AddQuestionRequest model)
{
string tokenString = Request.Headers["Authorization"];
int currentUserId = JwtAthentication.GetCurrentUserId(tokenString);
model.UserId = currentUserId;
var questionId = _questionService.AddQuestion(model);
return(Ok(new { questionId = questionId }));
}
public void AddQuestion(string questionContent, string position, int competenceId)
{
using (IUnityManagerModule dataContainer = new UnityManagerModule())
{
dataContainer.Init();
IQuestionService questionService = dataContainer.Resolve <IQuestionService>();
IQuestionRepository questionRepo = dataContainer.Resolve <IQuestionRepository>();
questionService.AddQuestion(questionContent, position, competenceId);
questionRepo.SaveChanges();
}
}
public IActionResult AddQuestion(string question)
{
var addQuestion = _questionService.AddQuestion(question);
if (addQuestion)
{
return(RedirectToAction("Index", "User"));
}
else
{
return(Content("Hata oluştu daha sonra tekrar deneyiniz."));
}
}
public IActionResult AddQuestion([FromBody] QuestionViewModel model)
{
ResponseViewModel response = new ResponseViewModel();
try
{
response.success = _questionService.AddQuestion(model);
}
catch (Exception e) {
response.success = false;
response.errMsg = e.ToString();
}
return(Json(response));
}
public async Task <IActionResult> AddQuestion(Question question)
{
if (question == null)
{
return(BadRequest($"{question} is null"));
}
var qtn = await _questionService.AddQuestion(question);
if (!string.IsNullOrEmpty(qtn))
{
return(NotFound(qtn));
}
return(Created("question/add", qtn));
}
public IActionResult Add(Question question)
{
ViewBag.Categories = new SelectList(_categoryService.GetList().Data, "Id", "CategoryName");
if (ModelState.IsValid)
{
var result = _questionService.AddQuestion(question, CurrentUserName);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(RedirectToAction("Index", "Question"));
}
return(View(question));
}
public IActionResult AddQuestion([FromBody] Question newQuestion)
{
if (newQuestion == null || newQuestion.Answers == null)
{
return(BadRequest("Error"));
}
try
{
_questionService.AddQuestion(newQuestion);
return(Created("", newQuestion));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <bool> UpdateQuestions(Question[] questions)
{
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
foreach (Question question in questions)
{
//four status :
//one: Destroyed and Exist : delete
//two: Destroyed and Not Exist : Nothing
//three: Not Destroyed and Exist: Update
//four: Not Destroyed and Not Exist: Add
bool exist = _questionService.QuestionExists(question.QuestionID);
if (question.IsDestroyed)
{
if (exist) //one
{
await _questionService.DeleteQuestion(question.QuestionID);
}
//else two
}
else
{
if (exist) //three
{
await _questionService.UpdateQuestion(question);
}
else //four
{
await _questionService.AddQuestion(question);
}
}
}
scope.Complete();
return(true);
}
}
catch (Exception e)
{
Console.Write(e.Message);
return(false);
}
}
public IActionResult CreateQuestion(TestParamViewModel testModel)
{
List <Question> questions = testModel.Test.Question;
if (questions.FirstOrDefault().Answer.Where(p => p.IsCorrect).Count() != 1)
{
ModelState.AddModelError("", $"Правильным должен быть 1 вариант ответа");
}
if (ModelState.IsValid)
{
handler.CheckValue(testModel);
questionService.AddQuestion(testModel.Test.Question.FirstOrDefault());
TempData["message"] = "Отлично!!! Вопрос успешно добавлен";
return(RedirectToAction(nameof(ChooseActionQuestions), new { id = testModel.Test.Id }));
}
else
{
return(View(nameof(BuildAnswers), testModel));
}
}
public ActionResult AddQuestion(QuestionModel model)
{
RekruQuestion q = null;
if (ModelState.IsValid)
{
q = _mapper.Map <RekruQuestion>(model);
Result result = _questionSrv.AddQuestion(q);
if (result.IsOK)
{
return(RedirectToAction("Details", routeValues: new { id = q.ID }));
}
else
{
return(RedirectToAction("AddQuestion"));
}
}
else
{
return(RedirectToAction("List"));
}
}
public IActionResult AddQuestion(AddQuestionViewModel model)
{
model.Signs = _signService.GetTypesSigns("");
model.Question.Sign = _signService.GetSign(model.Question.Sign.ID);
if (model.Question.Variants.Count < 2 || model.Question.Variants.Count > 5)
{
ModelState.AddModelError("Question.Variants", "Количество вариантов должно быть от 2 до 5");
return(View(model));
}
if (string.IsNullOrEmpty(model.Question.Text))
{
ModelState.AddModelError("Question.Text", "Введите текст вопроса");
return(View(model));
}
if (!(model.Question.ForKids || model.Question.ForBikers || model.Question.ForDrivers || model.Question.ForPedestrians))
{
ModelState.AddModelError("Question.ForKids", "Выберите хотя бы один из типов.");
return(View(model));
}
_questService.AddQuestion(model.Question);
return(RedirectToAction("AddQuestion"));
}
public async Task <IActionResult> Add([FromBody] QuestionDto dto)
{
_logger.LogInformation("Performing insert request...");
if (Util.IsAnyNullOrEmpty(dto))
{
_logger.LogWarning("Body from request is empty.");
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
_logger.LogInformation("Saving record...");
await _questionService.AddQuestion(dto);
_logger.LogInformation("Record saved successfully. Redirecting to record info...");
return(RedirectToAction(nameof(GetQuestionById), new { id = dto.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var q = new Models.Question
{
Text = Question,
QuestionForDate = Date,
Image = ImageFile != null?ImageFile.GetBase64HtmlString() : string.Empty,
Alternatives = new List <Models.Alternative>
{
new Models.Alternative
{
Description = Alternative1,
IsCorrect = IsCirrect1
},
new Models.Alternative
{
Description = Alternative2,
IsCorrect = IsCirrect2
},
new Models.Alternative
{
Description = Alternative3,
IsCorrect = IsCirrect3
}
}
};
await _questionService.AddQuestion(q);
return(RedirectToPage("/Admin/Questions"));
}
public ActionResult AddQuestion([FromForm] AddQuestionRequest request)
{
questionService.AddQuestion(request);
return(Ok());
}
public async Task <IActionResult> Post(QuestionViewModel question, Guid examId)
{
return(Ok(await questionService.AddQuestion(question, examId)));
}
public ActionResult ImportExamPaper(HttpPostedFileBase excelfile)
{
if (excelfile == null)
{
Failure = "Please choose excel file to import exam paper";
return(RedirectToAction("ImportExamPaper"));
}
else
{
if (excelfile.FileName.EndsWith("xls") || excelfile.FileName.EndsWith("xlsx"))
{
try
{
string path = Path.Combine(Server.MapPath("~/FileExcel/"), Guid.NewGuid().ToString() + Path.GetExtension(excelfile.FileName));
excelfile.SaveAs(path);
Excel.Application application = new Excel.Application
{
Visible = true
};
Excel.Workbook workbook = application.Workbooks.Open(path);
Excel.Worksheet worksheet = workbook.Sheets[@"ExamPaper"];
Excel.Range range = worksheet.UsedRange;
Models.ExamPaper examPaper = new Models.ExamPaper();
examPaper.Title = ((Excel.Range)range.Cells[3, 2]).Text;
examPaper.Time = int.Parse(((Excel.Range)range.Cells[4, 2]).Text);
if (((Excel.Range)range.Cells[5, 2]).Text == "Public")
{
examPaper.Status = true;
}
else if (((Excel.Range)range.Cells[5, 2]).Text == "Draff")
{
examPaper.Status = false;
}
else
{
Failure = "Exam paper status must be select from dropdown list";
return(RedirectToAction("ImportExamPaper"));
}
examPaper.IsActive = Boolean.Parse(((Excel.Range)range.Cells[6, 2]).Text);
examPaper.CreatedBy = int.Parse(Session["Name"].ToString());
examPaper.CreatedDate = DateTime.Now;
examPaper.ModifiedBy = int.Parse(Session["Name"].ToString());
examPaper.ModifiedDate = DateTime.Now;
int examPaperId = examPaperService.Create(examPaper);
var listQuestionCategory = questionCategorySevice.GetAll();
for (int row = 11; row <= range.Rows.Count; row++)
{
int level = 0;
if (((Excel.Range)range.Cells[row, 2]).Text == "Hard")
{
level = 3;
}
else if (((Excel.Range)range.Cells[row, 2]).Text == "Normal")
{
level = 2;
}
else if (((Excel.Range)range.Cells[row, 2]).Text == "Easy")
{
level = 1;
}
else
{
Failure = "Question level must be select from dropdown list";
return(RedirectToAction("ImportExamPaper"));
}
int categoryId = 0;
int k = 0;
foreach (var item in listQuestionCategory)
{
if (((Excel.Range)range.Cells[row, 3]).Text == item.Name)
{
categoryId = item.CategoryID;
k++;
}
}
if (k == 0)
{
Failure = "Question category must be select from dropdown list";
return(RedirectToAction("ImportExamPaper"));
}
Models.Question question = new Models.Question
{
Content = ((Excel.Range)range.Cells[row, 1]).Text,
CategoryID = categoryId,
Level = level,
IsActive = true,
CreatedBy = int.Parse(Session["Name"].ToString()),
CreatedDate = DateTime.Now,
ModifiedBy = int.Parse(Session["Name"].ToString()),
ModifiedDate = DateTime.Now
};
int questionId = questionService.AddQuestion(question);
Answer answer = new Answer();
int j = 5;
for (int i = 4; i <= 13; i += 2)
{
string content = ((Excel.Range)range.Cells[row, i]).Text;
if (content != "")
{
answer.AnswerContent = content;
answer.IsCorrect = Boolean.Parse(((Excel.Range)range.Cells[row, j]).Text);
answer.QuestionID = questionId;
answerService.AddAnswer(answer);
}
else
{
continue;
}
j += 2;
}
examPaperQuestionService.InsertExamPaperQuestion(examPaperId, questionId);
}
}
catch (Exception ex)
{
Failure = ex.Message;
return(RedirectToAction("ImportExamPaper"));
}
Success = "Import exam paper successfully!";
return(RedirectToAction("ExamPapers"));
}
else
{
Failure = "Please choose excel file to import exam paper";
return(RedirectToAction("ImportExamPaper"));
}
}
}
public async Task <HttpResponseMessage> AddQuestion(AddQuestionDto question, string orgId)
{
var data = await _questionService.AddQuestion(orgId, question);
return(Request.CreateResponse(HttpStatusCode.Created, data));
}
