private AnswerTest MapTo(QuestionTest questionTest)
{
return new AnswerTest
{
Text = questionTest.Text,
SuggestedAnswers = questionTest.SuggestedAnswers.ToList(),
};
}
private AnswerTest MapTo(QuestionTest questionTest)
{
return(new AnswerTest
{
Text = questionTest.Text,
SuggestedAnswers = questionTest.SuggestedAnswers.ToList(),
});
}
///-------------------------------------------------------------------------------------------------
/// <summary> Adds parsed questions IDs to a Test. </summary>
///
/// <param name="test"> The test. </param>
/// <param name="questionCheckboxes"> The question IDs in string form to be parsed first. </param>
///-------------------------------------------------------------------------------------------------
public void AddQuestionsToTest(Test test, string[] questionCheckboxes)
{
var questionList = GetAndParseQuestions(questionCheckboxes);
for (int i = 0; i < questionList.Count(); i++)
{
QuestionTest questionTest = new QuestionTest()
{
Test = test,
QuestionID = questionList[i].ID
};
db.QuestionTests.Add(questionTest);
}
}
public async Task <ActionResult <VtScore> > ValidExamination([FromBody] QuestionTest value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var examination = value.Examination;
var past = 0;
var notPast = 0;
var totalQuestion = 0;
examination.ForEach(item =>
{
totalQuestion += 1;
var answer = ctx.VtQuestion.FirstOrDefault(p => p.Id == item.QuestionId && p.Answer == item.Answer);
if (answer != null)
{
past += 1;
}
else
{
notPast += 1;
}
});
var score = new VtScore
{
Past = past,
NotPast = notPast,
TotalQuestion = totalQuestion,
UserId = examination.First().UserId,
UserName = examination.First().UserName,
CareerType = examination.First().CareerType
};
ctx.VtScore.Add(score);
await ctx.SaveChangesAsync();
var _userId = 1;
return(CreatedAtAction(nameof(GetScoreByCon), new { userId = _userId }, score));
}
public GetQuestionResponse GetQuestion(GetQuestionRequest request)
{
GetQuestionResponse response = new GetQuestionResponse();
AuthToken authToken = null;
try
{
Common.Helpers.ValidationHelper.ValidateRequiredField(request.AuthToken, "Auth Token");
if (!UserController.ValidateSession(request.AuthToken, out authToken))
{
throw new AuthenticationException("Authentication failed.");
}
DbContext context = DataController.CreateDbContext();
E::Question question = context.Questions
.Where(q => q.ID == request.QuestionID)
.FirstOrDefault();
response.QuestionBody = DataController.DownloadBlob(question.QuestionBody.ToString());
response.Name = question.Name;
response.LastUpdatedBy = question.LastUpdatedBy;
response.LastUpdatedDate = question.LastUpdatedDate.ToShortDateString();
response.CreatedBy = question.CreatedBy;
response.CreatedDate = question.CreatedDate.ToShortDateString();
response.CanEdit = !context.InterviewQuestions
.Where(q => q.QuestionID == request.QuestionID)
.Where(q => q.Interview.StartedDate.HasValue)
.Any();
response.IsCodedTest = question.QuestionTypeID == (short)QuestionType.Coded;
if (!response.IsCodedTest)
{
var tests = TestsController.FromJson(DataController.DownloadBlob(question.Tests.Value.ToString()));
IList <QuestionTest> questionTests = new List <QuestionTest>();
foreach (var test in tests.AsEnumerable())
{
QuestionTest questionTest = new QuestionTest();
questionTest.ID = test.ID;
questionTest.Name = test.Name;
questionTest.Input = test.Input;
questionTest.ExpectedOutput = test.ExpectedOutput;
questionTests.Add(questionTest);
}
response.Tests = questionTests.ToArray();
}
else
{
response.Tests = new QuestionTest[0];
}
}
catch (AuthenticationException ex)
{
throw new WebFaultException <string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Common.Exceptions.ValidationException ex)
{
throw new WebFaultException <string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Exception ex)
{
ExceptionHelper.Log(ex, authToken == null ? null : authToken.Username);
throw new WebFaultException <string>("An unknown error has occurred.", System.Net.HttpStatusCode.InternalServerError);
}
return(response);
}
