public async Task <IActionResult> AddSurveyResponse(SurveyResponseDto surveyResponse)
{
if (surveyResponse.SurveyId == 0)
{
ModelState.AddModelError("Error", "No survey id");
return(BadRequest(ModelState));
}
var survey = await _surveryRepo.GetSurvey(surveyResponse.SurveyId);
if (survey == null)
{
ModelState.AddModelError("Error", "Invalid survey id");
return(BadRequest(ModelState));
}
if (surveyResponse.Answers.Count == 0)
{
ModelState.AddModelError("Error", "No answers in survey response");
return(BadRequest(ModelState));
}
var responseSaved = await _surveryRepo.AddSurveyResponse(survey, surveyResponse);
if (!responseSaved)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
return(Ok());
}
public async Task <bool> AddSurveyResponse(Survey survey, SurveyResponseDto surveyResponse)
{
var answers = new List <Answer>();
foreach (var question in survey.Questions)
{
var responseAnswer = surveyResponse.Answers.FirstOrDefault(a => a.QuestionId == question.Id);
if (responseAnswer != null)
{
var answer = new Answer
{
Question = question,
QuestionId = question.Id,
QuestionAnswer = responseAnswer.QuestionAnswer
};
answers.Add(answer);
}
}
var response = new Response
{
Email = surveyResponse.Email,
Name = surveyResponse.Name,
Survey = survey,
SurveyId = survey.Id,
Answers = answers
};
_context.SurveyResponses.Add(response);
var saved = await _context.SaveChangesAsync();
return(saved > 0);
}
public async Task <ActionResult <SurveyResponseDto> > AddSurveyResponse(SurveyResponseDto surveyResponse)
{
var errorDictionary = ValidateSurveyResponse(surveyResponse);
if (errorDictionary.Count > 0)
{
return(BadRequest(new { errors = errorDictionary, code = 400 }));
}
var surveyResponseEntity = surveyResponse.Adapt <SurveyResponse>();
var survey = await _context.Surveys.FirstAsync(x => x.Id == surveyResponse.SurveyId);
if (!survey.Anonymous)
{
surveyResponseEntity.RespondentId = int.Parse(User.FindFirstValue(ClaimTypes.Name));
}
else
{
var surveyResponseStamp = surveyResponse.Adapt <SurveyResponse>();
surveyResponseStamp.Answers = null;
surveyResponseStamp.RespondentId = int.Parse(User.FindFirstValue(ClaimTypes.Name));
surveyResponseStamp.IsStamp = true;
await _context.SurveyResponses.AddAsync(surveyResponseStamp);
}
surveyResponseEntity.Date = DateTime.Now;
await _context.SurveyResponses.AddAsync(surveyResponseEntity);
await _context.SaveChangesAsync();
//await _pushNotificationService.Send("New survey response" ,$"New response added to {survey.Name}", survey.Name.RemoveDiactrics().RemoveWhiteSpaces());
return(Ok());
}
public async Task <HttpResponseMessage> UploadResponse(SurveyResponseDto survey)
{
var cts = new CancellationTokenSource();
var task = RemoteRequestAsync(_surveyResponseApi.GetApi(Priority.UserInitiated).UploadSurvey(survey), string.Empty);
_runningTasks.Add(task.Id, cts);
return(await task);
}
public async void AddSurveyResponse_Adds_Survey_Response()
{
var options = new DbContextOptionsBuilder <SurveyContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
await GenerateSurveys(options);
using (var context = new SurveyContext(options))
{
var surveyRepository = new SurveyRepository(context);
var survey = await surveyRepository.GetSurvey(1);
var surveyResponse = new SurveyResponseDto
{
Name = "Test User",
Email = "*****@*****.**",
SurveyId = survey.Id,
Answers = new List <SurveyResponseAnswerDto>
{
new SurveyResponseAnswerDto {
QuestionId = 1, QuestionAnswer = "Answer 1"
},
new SurveyResponseAnswerDto {
QuestionId = 2, QuestionAnswer = "Answer 2"
},
new SurveyResponseAnswerDto {
QuestionId = 3, QuestionAnswer = "Answer 3"
}
}
};
var success = await surveyRepository.AddSurveyResponse(survey, surveyResponse);
var responseList = await context.SurveyResponses.ToListAsync();
var response = responseList.First();
Assert.True(success);
Assert.NotNull(responseList);
Assert.NotNull(response);
}
}
public IHttpActionResult Post([FromBody] SurveyResponseDto value)
{
if (!ModelState.IsValid)
{
Logger.Info("Modelstate invalid: {@value1}", value);
return(BadRequest(ModelState));
}
try
{
SurveyResponse sr = Mapper.Map <SurveyResponse>(value);
db.SurveyResponses.Add(sr);
db.SaveChanges();
Logger.Info("Survey {id} created successfully", sr.ID);
return(StatusCode(HttpStatusCode.NoContent));
}
catch (DbEntityValidationException eve)
{
List <String> errors = new List <string>();
foreach (DbEntityValidationResult vr in eve.EntityValidationErrors)
{
foreach (DbValidationError ve in vr.ValidationErrors)
{
string error = $"{vr.Entry.Entity.GetType().Name}.{ve.PropertyName}: {ve.ErrorMessage}";
if (!errors.Contains(error))
{
errors.Add(error);
}
}
}
Logger.Error(eve, eve.Message);
return(InternalServerError(new InvalidOperationException(eve.Message + "\r\n" + String.Join("\r\n", errors.ToArray()), eve)));
}
catch (Exception ex)
{
Logger.Error(ex, ex.Message);
return(InternalServerError(ex));
}
}
public async Task AddSurveyResponse()
{
var surveyResponse = new SurveyResponseDto
{
SurveyId = 0,
Answers = new List <AnswerDto> {
new AnswerDto
{
QuestionId = 0,
Value = 4.ToString(),
},
new AnswerDto
{
QuestionId = 1,
Value = DateTime.Now.ToString(CultureInfo.InvariantCulture)
}
}
};
var result = await _controller.AddSurveyResponse(surveyResponse);
Assert.IsType <OkResult>(result.Result);
}
private async void BuildResultData()
{
PageDialog.ShowLoading("Loading");
if (App.LatestSurveyResponse != null)
{
_response = App.LatestSurveyResponse;
}
else
{
try
{
await RunSafe(GetSurveyResults());
_response = App.LatestSurveyResponse;
}
catch (Exception ex)
{
MetricsManager.TrackException(ex.Message, ex);
}
}
if (_response != null)
{
var chartData = new List <ChartDataModel>();
var answers = _response.QuestionResponses;
var statements = new Dictionary <string, List <string> >();
var isSuitable = true;
var lowestScore = 5;
foreach (var stage in App.LatestSurvey.Stages)
{
//Hardcoded skip of stage 1, this could be a parameter in the stage model instead?
if (stage.ID > 1)
{
try
{
//Add Stage to spidergraph
var score = answers.Where(a => a.StageID == stage.ID && a.QuestionResponse == true).Count();
chartData.Add(new ChartDataModel(stage.StageText, score));
if (score <= 2)
{
isSuitable = false;
}
if (score < lowestScore)
{
lowestScore = score;
}
//Add any statements from questions answered 'No'
if (answers.Where(a => a.StageID == stage.ID && a.QuestionResponse == false).Count() > 0)
{
var stageStatements = new List <string>();
foreach (var answer in answers.Where(a => a.StageID == stage.ID && a.QuestionResponse == false))
{
stageStatements.Add(answer.QuestionStatement);
}
statements.Add(stage.StageText, stageStatements);
}
}
catch (Exception ex)
{
MetricsManager.TrackException("Failed to build summary data", ex);
}
}
}
RadarData = new ObservableCollection <ChartDataModel>(chartData);
Statements = new ObservableDictionary <string, List <string> >(statements);
if (isSuitable)
{
SuitabilityStatement = AppTextResource.SurveyResultSdctSuitable;
}
RadarColour = ReturnHexValue(lowestScore);
AssessmentDate = _response.SubmittedDate.ToShortDateString();
}
PageDialog.HideLoading();
}
/// <summary>
/// Gets the filename of the survey response, based on the survey response <see cref="Guid"/>.
/// </summary>
/// <param name="response">The survey response.</param>
/// <returns>The filename.</returns>
private static string GetFilename(this SurveyResponseDto response)
{
return($"{response.ResponseIdentifier}.survey.json");
}
/// <summary>
/// Deletes the survey from local storage asynchronously.
/// </summary>
/// <param name="response">The survey response.</param>
/// <returns>A task to await the delete operation.</returns>
public static Task DeleteAsync(this SurveyResponseDto response)
{
var fileHelper = new FileHelper();
return(fileHelper.DeleteAsync(response.GetFilename()));
}
