/// <summary>
/// Saves test data
/// </summary>
/// <param name="data">Session data</param>
/// <param name="sessionId">Session id (needed if data stores in database)</param>
/// <param name="saveToCookie">'True' to make data stored in cookie</param>
private void SetTestData(TestData data, int sessionId = 0, bool saveToCookie = false)
{
string dataString = XmlManager.SerializeObjectUTF8(data);
string tokenString;
string testInfoString;
if (saveToCookie)
{
testInfoString = HttpUtility.UrlEncode(dataString);
tokenString = MD5HashManager.GenerateKey(testInfoString);
}
else
{
tokenString = MD5HashManager.GenerateKey(dataString);
testInfoString = TestSessionManager.Write(dataString, sessionId).ToString(CultureInfo.InvariantCulture);
}
var testInfo = new HttpCookie("TestInfo", testInfoString);
var securityToken = new HttpCookie("SecurityToken", tokenString);
Response.Cookies.Add(testInfo);
Response.Cookies.Add(securityToken);
TempData["testInfo"] = testInfo;
TempData["securityToken"] = securityToken;
}
public async Task <ActionResult <TestSessionResponse> > StartNewTestSessionAsync(
[FromServices] IUnitOfWork unitOfWork,
[FromRoute] Guid userId,
[FromBody] NewTestSessionRequest request)
{
try
{
var newSession =
await TestSessionManager.StartTestSessionAsync(unitOfWork, userId, request.QuizId);
return(Ok(SessionToResponse(newSession)));
}
catch (UserNotFoundException)
{
_log.LogWarning("user {UserId} not found", userId);
return(NotFound("user not found"));
}
catch (QuizNotFoundException)
{
_log.LogWarning("quiz {QuizId} not found", request.QuizId);
return(NotFound("quiz not found"));
}
catch (AlreadyHasActiveSessionException)
{
_log.LogWarning("user {UserId} already has active session", userId);
return(Conflict("already has active session"));
}
}
public async Task <ActionResult <GetResultResponse> > EndSessionAsync(
[FromServices] IUnitOfWork unitOfWork,
[FromRoute] Guid userId)
{
try
{
var(sessionId, result) =
await TestSessionManager.EndCurrentSessionAsync(unitOfWork, userId);
return(Ok(new GetResultResponse
{
Result = result,
TestSessionId = sessionId
}));
}
catch (NoActiveSessionsException)
{
_log.LogInformation("user {UserId} has no active sessions", userId);
return(NotFound("session not found"));
}
catch (UserNotFoundException)
{
_log.LogWarning("user {UserId} not found", userId);
return(NotFound("user not found"));
}
}
public async Task Should_add_answers_and_return_result()
{
await StartNewSessionAsync();
await TestSessionManager.AddAnswersAsync(_unitOfWork, _user.UserId, new List <(int, string)> {
(0, "abc")
});
private async Task StartNewSessionAsync()
{
_unitOfWork.Quizzes.FindQuizAsync(Arg.Is(_quiz.QuizId)).Returns(_quiz);
_unitOfWork.Users.FindUserAsync(Arg.Is(_user.UserId)).Returns(_user);
await TestSessionManager.StartTestSessionAsync(_unitOfWork, _user.UserId, _quiz.QuizId);
}
/// <summary>
/// Returns test data
/// </summary>
/// <param name="databaseRecordId">Returns ID for records are storing in Data Base</param>
/// <param name="getFromCookie">'True' to get data from cookie rather then database</param>
/// <returns></returns>
private TestData GetTestData(out int databaseRecordId, bool getFromCookie = false)
{
var testInfoCookie = (HttpCookie)TempData["TestInfo"];
var securityTokenCookie = (HttpCookie)TempData["SecurityToken"];
databaseRecordId = 0;
if (testInfoCookie == null || securityTokenCookie == null || string.IsNullOrWhiteSpace(testInfoCookie.Value) || string.IsNullOrWhiteSpace(securityTokenCookie.Value))
{
testInfoCookie = Request.Cookies["TestInfo"];
securityTokenCookie = Request.Cookies["SecurityToken"];
if (testInfoCookie == null || securityTokenCookie == null ||
string.IsNullOrWhiteSpace(testInfoCookie.Value) ||
string.IsNullOrWhiteSpace(securityTokenCookie.Value))
{
return(null);
}
}
else
{
Response.Cookies.Add(testInfoCookie);
Response.Cookies.Add(securityTokenCookie);
}
string data = testInfoCookie.Value;
string securityToken = securityTokenCookie.Value;
if (getFromCookie)
{
data = HttpUtility.UrlDecode(data);
}
else
{
var id = 0;
try
{
id = int.Parse(testInfoCookie.Value);
}
catch (Exception)
{
return(null);
}
databaseRecordId = id;
data = TestSessionManager.Read(id);
}
if (MD5HashManager.GenerateKey(data) != securityToken)
{
return(null);
}
return(XmlManager.DeserializeObject <TestData>(data));
}
public async Task <IActionResult> AddAnswersAsync(
[FromServices] IUnitOfWork unitOfWork,
[FromRoute] Guid userId,
[FromBody] AddAnswersRequest request)
{
try
{
await TestSessionManager.AddAnswersAsync(unitOfWork, userId,
request.Answers.Select(a => (a.TaskNumber, a.Answer)));
return(Ok());
}
catch (UserNotFoundException)
{
_log.LogWarning("user {UserId} not found");
return(NotFound());
}
}
public async Task <ActionResult <TestSessionResponse> > GetCurrentSession(
[FromServices] IUnitOfWork unitOfWork,
[FromRoute] Guid userId)
{
try
{
var currentSession = await
TestSessionManager.GetActiveSession(unitOfWork, userId);
return(Ok(SessionToResponse(currentSession)));
}
catch (NoActiveSessionsException)
{
_log.LogWarning("no active sessions found for {UserId}", userId);
return(NotFound("no active sessions"));
}
catch (UserNotFoundException)
{
_log.LogWarning("user {UserId} not found", userId);
return(NotFound("user not found"));
}
}
/// <summary>
/// Clears session data
/// </summary>
/// <param name="clearDataBaseRecord">True to clean data from db</param>
private void ClearTestData(bool clearDataBaseRecord = true)
{
HttpCookie testInfo = Request.Cookies["TestInfo"];
HttpCookie securityToken = Request.Cookies["SecurityToken"];
if (testInfo != null)
{
try
{
int id = int.Parse(testInfo.Value);
TestSessionManager.Remove(id);
}
catch { }
testInfo.Expires = DateTime.Now.AddDays(-1);
Response.Cookies.Add(testInfo);
}
if (securityToken != null)
{
securityToken.Expires = DateTime.Now.AddDays(-1);
Response.Cookies.Add(securityToken);
}
}
public async Task <ActionResult <GetResultsResponse> > GetResultsAsync(
[FromServices] IUnitOfWork unitOfWork,
[FromRoute] Guid userId)
{
try
{
var results =
await TestSessionManager.GetResultsAsync(unitOfWork, userId);
return(Ok(new GetResultsResponse
{
Results = results.Select(r => new GetResultResponse
{
Result = r.result,
TestSessionId = r.sessionId
}).ToList()
}));
}
catch (UserNotFoundException)
{
_log.LogWarning("user {UserId} not found");
return(NotFound("user not found"));
}
}
