public void Test()
{
SurveyResponse result = CreateResult();
var status = Entity.Get <SurveyStatusEnum>(new EntityRef("sseInProgress"));
var reviewer = Entity.Create <Person>();
var task = ReviewSurveyImplementation.ReviewSurvey(result, reviewer, status, new decimal(5), true, "taskName");
task.Save();
Assert.That(result.SurveyStatus.Id, Is.EqualTo(status.Id));
Assert.That(reviewer.TaskForUser.Count, Is.EqualTo(1));
Assert.That(task.AssignedToUser, Is.Not.Null);
Assert.That(task.AssignedToUser.Id, Is.EqualTo(reviewer.Id));
Assert.That(task.UserSurveyTaskAllowComments, Is.True);
Assert.That(task.UserTaskDueOn, Is.Not.Null);
var dueIn = ((DateTime)task.UserTaskDueOn) - DateTime.UtcNow;
Assert.That(dueIn.TotalDays, Is.GreaterThan(4));
Assert.That(dueIn.TotalDays, Is.LessThanOrEqualTo(5));
}
private void AddResponse(SurveyResponse response)
{
var examination = _context.Examinations.Find(response.UsedPermission.Id);
if (examination == null)
{
throw new ActionNotPermittedException("Permission with the id " + response.UsedPermission.Id + " does not exist.");
}
examination.IsSurveyCompleted = true;
_context.Update(examination);
_context.Add(new SurveyAboutDoctor()
{
ExaminationId = examination.Id,
AvailabilityOfDoctor = response.DoctorSurveyResponse.Availability.Value,
BehaviorOfDoctor = response.DoctorSurveyResponse.Behavior.Value,
GettingAdviceByDoctor = response.DoctorSurveyResponse.GivingAdvice.Value,
DoctorProfessionalism = response.DoctorSurveyResponse.Professionalism.Value
});
_context.Add(new SurveyAboutHospital()
{
ExaminationId = examination.Id,
Cleanliness = response.HospitalSurveyResponse.Cleanliness.Value,
Nursing = response.HospitalSurveyResponse.Nursing.Value,
OverallRating = response.HospitalSurveyResponse.General.Value,
SatisfiedWithDrugAndInstrument = response.HospitalSurveyResponse.MedicationAndInstrumments.Value
});
_context.Add(new SurveyAboutMedicalStaff()
{
ExaminationId = examination.Id,
BehaviorOfMedicalStaff = response.MedicalStaffSurveyResponse.Behavior.Value,
EaseInObtainingFollowUpInformation = response.MedicalStaffSurveyResponse.FollowUp.Value,
GettingAdviceByMedicalStaff = response.MedicalStaffSurveyResponse.GivingAdvice.Value,
MedicalStaffProfessionalism = response.MedicalStaffSurveyResponse.Professionalism.Value
});
}
public async Task <IActionResult> Create([Bind("Id,RespondantId,QuestionId,Response")] SurveyResponse surveyResponse, string[] quizresponse)
{
if (/*ModelState.IsValid*/ quizresponse.Length > 0)
{
foreach (var quizeAndResponse in quizresponse)
{
string[] ids = quizeAndResponse.Split(new char[] { '|' });
string response = ids[0];
int quizId = int.Parse(ids[1]);
string RespondantId = null;
if (User.Identity.IsAuthenticated)
{
RespondantId = _usermanager.GetUserId(User);
}
SurveyResponse newResponse = new SurveyResponse()
{
QuestionId = quizId,
Response = response,
RespondantId = RespondantId
};
/*foreach (var id in ids)
* {
* var sd = id;
* }*/
_context.Add(newResponse);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["RespondantId"] = new SelectList(_context.Users, "Id", "Id", surveyResponse.RespondantId);
ViewData["QuestionId"] = new SelectList(_context.Question, "Id", "Id", surveyResponse.QuestionId);
return(View(surveyResponse));
}
/// <summary>
/// Save weekly feedback and corresponding survey response
/// </summary>
/// <param name="response">instance of response</param>
/// <returns>success flag </returns>
public bool SaveWeeklySurveyResponseForTrainee(SurveyResponse response)
{
// Weekly feedback must have team associated with it.
if (!response.AddedBy.TeamId.HasValue)
{
return(false);
}
try
{
Survey survey = SurveyDataAccesor.GetWeeklySurveySetForTeam(response.AddedBy.TeamId.Value);
Feedback lastWeeklyFeedback = FeedbackDataAccesor.GetUserFeedback(response.AddedFor.UserId, 1, (int)Common.Enumeration.FeedbackType.Weekly)
.FirstOrDefault();
response.CodeReviewForTheWeek = FeedbackDataAccesor.GetUserFeedback(response.AddedFor.UserId,
1000,
(int)Common.Enumeration.FeedbackType.CodeReview)
.Where(x => x.AddedOn.Date >= response.Feedback.StartDate &&
(lastWeeklyFeedback == null || x.AddedOn >= lastWeeklyFeedback.AddedOn))
.ToList();
response.Feedback.FeedbackText = GenerateHtmlforFeedback(response, survey);
response.Feedback.FeedbackId = SurveyDataAccesor.SaveWeeklySurveyResponseForTrainee(response, survey);
return(response.Feedback.FeedbackId > 0 && new NotificationBl().AddFeedbackNotification(response.Feedback));
}
catch (Exception ex)
{
LogUtility.ErrorRoutine(ex);
return(false);
}
}
public SurveyResponse SaveSurvey([FromBody] List <SaveSurvey> surveyList)
{
try
{
SurveyResponse response = new SurveyResponse();
if (surveyList != null && surveyList.Count > 0)
{
var result = this._surveyser.SaveSurvey(surveyList);
if (result == -1)
{
response.Result = true;
}
else
{
response.Result = false;
}
}
else
{
response.Result = false;
}
return(response);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Maps SurveyMetaData entity to SurveyInfoBO business object.
/// </summary>
/// <param name="entity">A SurveyMetaData entity to be transformed.</param>
/// <returns>A SurveyInfoBO business object.</returns>
internal static SurveyResponseBO Map(SurveyResponse entity)
{
/* return new SurveyResponseBO
* {
* SurveyId = entity.SurveyId.ToString(),
* ResponseId = entity.ResponseId.ToString(),
* XML = entity.ResponseXML,
* Status = entity.StatusId,
* DateUpdated = entity.DateUpdated,
* DateCompleted = entity.DateCompleted,
* TemplateXMLSize = (long)entity.ResponseXMLSize,
* DateCreated = entity.DateCreated,
* IsDraftMode = entity.IsDraftMode ,
* RecordSourceId=(int)entity.RecordSourceId
*
* };*/
SurveyResponseBO SurveyResponseBO = new SurveyResponseBO();
SurveyResponseBO.SurveyId = entity.SurveyId.ToString();
SurveyResponseBO.ResponseId = entity.ResponseId.ToString();
SurveyResponseBO.XML = entity.ResponseXML;
SurveyResponseBO.Status = entity.StatusId;
SurveyResponseBO.DateUpdated = entity.DateUpdated;
SurveyResponseBO.DateCompleted = entity.DateCompleted;
SurveyResponseBO.TemplateXMLSize = (long)entity.ResponseXMLSize;
SurveyResponseBO.DateCreated = entity.DateCreated;
SurveyResponseBO.IsDraftMode = entity.IsDraftMode;
SurveyResponseBO.RecordSourceId = (int)entity.RecordSourceId;
if (entity.RelateParentId != null)
{
SurveyResponseBO.RelateParentId = entity.RelateParentId.ToString();
}
return(SurveyResponseBO);
}
public void TestQuestion1ShowsCurrentName()
{
// Arrange
var response = SurveyResponse.CreateNew(FakeNow);
response.Respondent.Name = ExcellentName;
var clientStorage = Substitute.For <IClientSideStorageService>();
var dateTime = Substitute.For <IDateTimeService>();
var repo = Substitute.For <ISurveyResponseRepository>();
var controller = new SurveyController(clientStorage, dateTime, null, null, repo)
{
CurrentResponse = response
};
// Act
var result = controller.Question1();
// Assert
Assert.IsType <ViewResult>(result);
var viewResult = result as ViewResult;
Assert.IsType <QuestionPageViewModel <string> >(viewResult.Model);
var model = viewResult.Model as QuestionPageViewModel <string>;
Assert.Equal(ExcellentName, model.Question.Answer);
}
public async Task <dynamic> PostSurveyAsync(SurveyResponse survey)
{
var position = 1;
try
{
survey.poll_Id = await _repository.GetIdSurvey() + 1;
await _repository.PostSurvey(survey);
foreach (var option in survey.options)
{
await _repository.PostOptions(survey.poll_Id, option, position);
position++;
}
dynamic result = new ExpandoObject();
result.poll_Id = survey.poll_Id;
return(result);
}
catch (Exception ex)
{
throw new Exception("Erro ao Cadastrar Enquete: " + ex.Message);
}
}
void Load()
{
SurveyName = SurveyResponse.SurveyDefinition.Name;
SurveyIntro = SurveyResponse.SurveyDefinition.Intro;
Response = SurveyResponse.NextUnansweredQuestion();
DoBindings();
}
/// <summary>
/// Method to save store survey response on the basis of coverage beat
/// </summary>
/// <param name="storeSurvey">store survey</param>
/// <returns>returns status</returns>
public long SaveStoreSurveyResponse(SurveyResponseDTO storeSurvey)
{
SurveyResponse survey = new SurveyResponse();
ObjectMapper.Map(storeSurvey, survey);
return(ActivityRepository.SaveStoreSurveyResponse(survey, storeSurvey.RaceProfile));
}
public IHttpActionResult PostSurveyResponse(SurveyResponse surveyResponse)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.SurveyResponses.Add(surveyResponse);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (SurveyResponseExists(surveyResponse.SurveyResponseId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = surveyResponse.SurveyResponseId }, surveyResponse));
}
public async Task <bool> Persist(SurveyResponse surveyResponse)
{
try
{
var client = new CosmosClient(_configuration.CosmosDbEndpoint,
_configuration.CosmosDbPrimaryKey,
new CosmosClientOptions()
{
ApplicationName = APPLICATION_NAME
});
Database database = await client.CreateDatabaseIfNotExistsAsync(DATABASE_NAME);
Container container = await database.CreateContainerIfNotExistsAsync(CONTAINER_NAME, "/year");
ItemResponse <SurveyResponse> response = await container.CreateItemAsync <SurveyResponse>(surveyResponse, new PartitionKey(surveyResponse.Year));
if (response.StatusCode == HttpStatusCode.Created)
{
return(true);
}
else
{
_logger.LogError($"Unable to save record to CosmosDB - received {response.StatusCode} - {response.ActivityId}");
return(false);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to save to CosmosDB");
return(false);
}
}
public IHttpActionResult PostSurveyResponse(SurveyResponse surveyResponse)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//var comments = CalculateScore(surveyResponse);
//surveyResponse.SurveyComments = JsonConvert.SerializeObject(comments);
surveyResponse.SurveyResponseId = System.Guid.NewGuid().ToString();
db.SurveyResponses.Add(surveyResponse);
try
{
db.SaveChanges();
}
catch (Exception ex)
{
if (SurveyResponseExists(surveyResponse.SurveyResponseId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = surveyResponse.SurveyResponseId }, surveyResponse));
}
private async void OnSelectAnswer(object sender, EventArgs e)
{
var selectedQuestion = GetSelectedQuestion();
Debug.Assert(selectedQuestion != null);
Debug.Assert(string.IsNullOrEmpty(userName) == false);
int pos = answerGroup.Children.IndexOf((Button)sender);
if (response == null)
{
response = new SurveyResponse {
Name = userName,
ResponseIndex = pos,
SurveyQuestionId = selectedQuestion.Id
};
}
else
{
Debug.Assert(response.Name == userName);
Debug.Assert(response.SurveyQuestionId == selectedQuestion.Id);
response.ResponseIndex = pos;
}
await service.AddOrUpdateSurveyResponseAsync(response);
SetSelectedAnswer();
}
public SurveyResponse GetStatisticsForDoctor(Doctor doctor)
{
List <SurveyResponse> allSurveys = this.GetSurveysForDoctor(doctor);
int quality = 0;
int security = 0;
int kindness = 0;
int professionalism = 0;
string comment = "";
foreach (SurveyResponse survey in allSurveys)
{
quality += (int)survey.Quality;
security += (int)survey.Security;
kindness += (int)survey.Kindness;
professionalism += (int)survey.Professionalism;
comment += survey.Comment + "\n";
}
SurveyResponse result = new SurveyResponse()
{
Quality = (Rate)Enum.ToObject(typeof(Rate), Convert.ToInt32(Math.Floor((double)quality / allSurveys.Count))),
Security = (Rate)Enum.ToObject(typeof(Rate), Convert.ToInt32(Math.Floor((double)security / allSurveys.Count))),
Kindness = (Rate)Enum.ToObject(typeof(Rate), Convert.ToInt32(Math.Floor((double)kindness / allSurveys.Count))),
Professionalism = (Rate)Enum.ToObject(typeof(Rate), Convert.ToInt32(Math.Floor((double)professionalism / allSurveys.Count))),
Comment = comment
};
return(result);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,RespondantId,QuestionId,Response")] SurveyResponse surveyResponse)
{
if (id != surveyResponse.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(surveyResponse);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SurveyResponseExists(surveyResponse.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["RespondantId"] = new SelectList(_context.Users, "Id", "Id", surveyResponse.RespondantId);
ViewData["QuestionId"] = new SelectList(_context.Question, "Id", "Id", surveyResponse.QuestionId);
return(View(surveyResponse));
}
public ActionResult Create(Visitor visitor, int surveyID)
{
ViewBag.SurveyID = surveyID;
if (ModelState.IsValid)
{
var alreadyFilled = db.SurveyResponses.Where(t => t.SurveyID == surveyID && t.Visitor.EmailID.ToLower().Trim().Contains(visitor.EmailID.ToLower().Trim())).Any();
if (!alreadyFilled)
{
db.Visitors.Add(visitor);
//db.SaveChanges();
var survey = db.Surveys.Find(surveyID);
survey.NoOfView = (survey.NoOfView ?? 0) + 1;
db.Entry(survey).State = EntityState.Modified;
SurveyResponse surveyResponse = new SurveyResponse()
{
FillFromSiteUrl = Convert.ToString(Session["FillFromSiteUrl"]),
ResponseDate = DateTime.Now,
SurveyID = surveyID,
VisitorID = visitor.VisitorID
};
db.SurveyResponses.Add(surveyResponse);
db.SaveChanges();
return(RedirectToAction("SurveyResponse", "Surveys", new { responseID = surveyResponse.SurveyResponseID }));
}
}
return(View(visitor));
}
private async Task OnSelectAnswer(AnswerViewModel answer)
{
if (string.IsNullOrEmpty(Name) || answer.IsSelected)
{
return;
}
try
{
if (response == null)
{
response = new SurveyResponse {
Name = this.Name,
ResponseIndex = answer.Index,
SurveyQuestionId = SelectedQuestion.Id
};
}
else
{
Debug.Assert(response.Name == Name);
Debug.Assert(response.SurveyQuestionId == SelectedQuestion.Id);
response.ResponseIndex = answer.Index;
}
await surveyService.AddOrUpdateSurveyResponseAsync(response);
UpdateAnswerSelection();
}
catch (Exception ex)
{
await dependencyService.Get <IMessageVisualizerService>()
.ShowMessage("Error", "Failed to update your answer: " + ex.Message, "OK");
}
}
public async Task <SurveyResponse> Create()
{
var surveyResponse = SurveyResponse.CreateNew(_dateTime.Now);
await _data.Responses.AddAsync(surveyResponse);
return(surveyResponse);
}
/// <summary>
///
/// </summary>
/// <param name="response"></param>
/// <param name="responseData"></param>
internal void SaveJsonResponse(SurveyResponse response, JObject responseData)
{
response.ResponseValues.Clear();
if (responseData.GetValue("values") != null)
{
var values = responseData.GetValue("values").ToObject <JArray> ();
foreach (var rValue in values)
{
response.ResponseValues.Add(new JsonResponse()
{
SurveyResponse = response,
Value = rValue.ToString()
});
}
}
else
{
var value = responseData.GetValue("value").Value <string> ();
response.ResponseValues.Add(new JsonResponse()
{
SurveyResponse = response,
Value = value
});
return;
}
// (response.ResponseValues[0] as JsonResponse).Value = responseData.ToString();
return;
}
/// <summary>
/// Maps SurveyMetaData entity to SurveyInfoBO business object.
/// </summary>
/// <param name="entity">A SurveyMetaData entity to be transformed.</param>
/// <returns>A SurveyInfoBO business object.</returns>
internal static SurveyResponseBO Map(SurveyResponse entity, User User = null, int LastActiveUseerId = -1)
{
SurveyResponseBO SurveyResponseBO = new SurveyResponseBO();
SurveyResponseBO.SurveyId = entity.SurveyId.ToString();
SurveyResponseBO.ResponseId = entity.ResponseId.ToString();
SurveyResponseBO.XML = entity.ResponseXML;
SurveyResponseBO.Status = entity.StatusId;
SurveyResponseBO.DateUpdated = entity.DateUpdated;
SurveyResponseBO.DateCompleted = entity.DateCompleted;
SurveyResponseBO.TemplateXMLSize = (long)entity.ResponseXMLSize;
SurveyResponseBO.DateCreated = entity.DateCreated;
SurveyResponseBO.IsDraftMode = entity.IsDraftMode;
SurveyResponseBO.IsLocked = entity.IsLocked;
SurveyResponseBO.LastActiveUserId = LastActiveUseerId;
if (entity.SurveyMetaData != null)
{
SurveyResponseBO.ViewId = (int)entity.SurveyMetaData.ViewId;
}
if (entity.ParentRecordId != null)
{
SurveyResponseBO.ParentRecordId = entity.ParentRecordId.ToString();
}
if (entity.RelateParentId != null)
{
SurveyResponseBO.RelateParentId = entity.RelateParentId.ToString();
}
if (User != null)
{
SurveyResponseBO.UserEmail = User.EmailAddress;
}
return(SurveyResponseBO);
}
public UserAuthenticationResponseBO GetAuthenticationResponse(UserAuthenticationRequestBO passcodeBO)
{
// TODO: Implement this correctly
var userAuthenticationResponseBO = new UserAuthenticationResponseBO {
PassCode = passcodeBO.PassCode, ResponseId = passcodeBO.ResponseId
};
return(userAuthenticationResponseBO);
#if false // from WebEnter
UserAuthenticationResponseBO UserAuthenticationResponseBO = Mapper.ToAuthenticationResponseBO(UserAuthenticationRequestBO);
try
{
Guid Id = new Guid(UserAuthenticationRequestBO.ResponseId);
using (var Context = DataObjectFactory.CreateContext())
{
SurveyResponse surveyResponse = Context.SurveyResponses.First(x => x.ResponseId == Id);
if (surveyResponse != null)
{
UserAuthenticationResponseBO.PassCode = surveyResponse.ResponsePasscode;
}
}
}
catch (Exception ex)
{
throw (ex);
}
return(UserAuthenticationResponseBO);
#endif
}
public async Task TestQuestion1SavesCurrentName()
{
// Arrange
var response = SurveyResponse.CreateNew(FakeNow);
response.Respondent.Name = "Wrong name";
var clientStorage = Substitute.For <IClientSideStorageService>();
var dateTime = Substitute.For <IDateTimeService>();
var repo = Substitute.For <ISurveyResponseRepository>();
var controller = new SurveyController(clientStorage, dateTime, null, null, repo)
{
CurrentResponse = response
};
var questionAnswer = new NameQuestionViewModel
{
Answer = ExcellentName
};
// Act
var result = await controller.Question1(questionAnswer);
// Assert
await repo.Received().SaveChanges();
Assert.IsType <RedirectToActionResult>(result);
Assert.Equal(ExcellentName, controller.CurrentResponse.Respondent.Name);
}
private void SetupRepositories()
{
_mockSurveyRepository.Setup(m => m.GetByID(It.IsAny <int>())).Returns(CreateSurvey());
SurveyResponse surveyResponse = CreateSurveyResponse();
_mockSurveyResponseRepository.Setup(m => m.Create(surveyResponse)).Returns(surveyResponse);
}
public IHttpActionResult PutSurveyResponse(int id, SurveyResponse surveyResponse)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != surveyResponse.Id)
{
return(BadRequest());
}
db.Entry(surveyResponse).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!SurveyResponseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
// GET: SurveyTaker/Take/5
public async Task <ActionResult> Take(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Survey survey = db.Surveys.Find(id);
if (survey == null)
{
return(HttpNotFound());
}
SurveyResponse surveyresponse = new SurveyResponse();
surveyresponse.SurveyID = survey.SurveyID;
surveyresponse.UserID = db.AspNetUsers.Where(u => u.UserName == User.Identity.Name).First().Id;
surveyresponse.DateTaken = System.DateTime.Now;
db.SurveyResponses.Add(surveyresponse);
await db.SaveChangesAsync();
ViewBag.ResponseID = surveyresponse.ResponseID;
ViewBag.UserID = new SelectList(db.AspNetUsers, "Id", "Email", survey.UserID);
return(View(surveyresponse));
}
private void BtnStartSurvey_Click(object sender, EventArgs e)
{
Guid currentResponseGuid = GetCurrentResponseGuid();
if (!chkUseOldResponses.Checked)
{
if (currentResponseGuid != Guid.Empty)
{
SurveyResponse.Delete(currentResponseGuid);
}
SurveyResponse response = new SurveyResponse();
response.Complete = false;
response.SurveyGuid = survey.SurveyGuid;
if (siteUser != null)
{
response.UserGuid = siteUser.UserGuid;
}
response.Save();
currentResponseGuid = response.ResponseGuid;
}
SetCookie(currentResponseGuid);
WebUtils.SetupRedirect(
this,
$"{SiteRoot}/Survey/CompleteSurvey.aspx?SurveyGuid={SurveyGuid.ToString()}&pageid={PageId.ToInvariantString()}&mid={ModuleId.ToInvariantString()}&SurveyPageGuid={surveyPageGuid.ToString()}");
}
public SummaryPageViewModel(SurveyResponse survey)
{
Name = survey.Respondent.Name;
Email = survey.Respondent.EmailAddress;
Address = survey.Respondent.Address.ToHtmlString();
HappyWithLighting = survey.HappyWithLighting == true ? "yes" : "no";
PercievedBrightness = survey.PerceivedBrightnessLevel.Value;
}
public void Save(SurveyResponse entity)
{
entity.Id = GenerateId();
List <SurveyResponse> allSurveys = (List <SurveyResponse>)FindAll();
allSurveys.Add(entity);
SaveAll(allSurveys);
}
public ActionResult DeleteConfirmed(int id)
{
SurveyResponse surveyResponse = db.SurveyResponses.Find(id);
db.SurveyResponses.Remove(surveyResponse);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Create(int id, SurveyResponse surveyResponse, QuestionAnswerParameter[] questions)
{
var survey = Repository.OfType<Survey>().GetNullableById(id);
if (survey == null || !survey.IsActive)
{
Message = "Survey not found or not active.";
return this.RedirectToAction<ErrorController>(a => a.Index());
}
var surveyResponseToCreate = new SurveyResponse(survey);
if (questions == null)
{
questions = new QuestionAnswerParameter[0];
}
ModelState.Clear();
//Set non-dynamic surveyResponse values
surveyResponseToCreate.StudentId = surveyResponse.StudentId;
surveyResponseToCreate.UserId = CurrentUser.Identity.Name.ToLower();
//Check each question, create an answer for it if there isn't one.
var length = questions.Length;
for (int i = 0; i < length; i++)
{
var question = Repository.OfType<Question>().GetNullableById(questions[i].QuestionId);
Check.Require(question != null, string.Format("Question not found.\n SurveyId: {0}\n QuestionId: {1}\n Question #: {2}", id, questions[i].QuestionId, i));
Check.Require(question.Category.IsActive, string.Format("Related Category is not active for question Id {0}", questions[i].QuestionId));
Check.Require(question.Category.IsCurrentVersion, string.Format("Related Category is not current version for question Id {0}", questions[i].QuestionId));
Check.Require(question.Survey.Id == survey.Id, string.Format("Related Survey does not match passed survey {0}--{1}", question.Survey.Id, survey.Id));
Answer answer;
if (surveyResponseToCreate.Answers.Where(a => a.Question.Id == question.Id).Any())
{
answer = surveyResponseToCreate.Answers.Where(a => a.Question.Id == question.Id).First();
}
else
{
answer = new Answer();
}
//Score question and specify any errors
questions[i] = _scoreService.ScoreQuestion(surveyResponseToCreate.Survey.Questions.AsQueryable(), questions[i]);
if (questions[i].Invalid && !questions[i].BypassQuestion)
{
ModelState.AddModelError(string.Format("Questions[{0}]", i), questions[i].Message);
}
if (questions[i].BypassQuestion)
{
answer.OpenEndedAnswer = null;
answer.Response = null;
answer.Score = 0;
answer.BypassScore = true;
questions[i].Answer = string.Empty;
questions[i].ResponseId = 0;
}
else
{
answer.OpenEndedAnswer = questions[i].OpenEndedNumericAnswer;
if (question.IsOpenEnded && question.OpenEndedQuestionType == (int)QuestionType.TimeRange)
{
answer.OpenEndedStringAnswer = string.Format("{0}_{1}", questions[i].Answer, questions[i].AnswerRange);
}
else
{
answer.OpenEndedStringAnswer = questions[i].Answer; // The actual answer they gave.
}
answer.Response = Repository.OfType<Response>().GetNullableById(questions[i].ResponseId);
answer.Score = questions[i].Score;
answer.BypassScore = false;
}
answer.Question = question;
answer.Category = question.Category;
surveyResponseToCreate.AddAnswers(answer);
}
surveyResponseToCreate.TransferValidationMessagesTo(ModelState);
if (survey.Questions.Where(a => a.IsActive && a.Category.IsActive && a.Category.IsCurrentVersion).Count() != questions.Count())
{
Message = "You must answer all survey questions.";
ModelState.AddModelError("Question", "You must answer all survey questions.");
}
if (ModelState.IsValid)
{
_scoreService.CalculateScores(Repository, surveyResponseToCreate);
_surveyResponseRepository.EnsurePersistent(surveyResponseToCreate);
Message = "Below are the customized goals for the survey you entered. You can use the \"Print Results\" link below to print this individual goal sheet. If you would like to print a text-only version or goal sheets for multiple participants at one time go to the Educators Dashboard and select the Review & Print section for the survey you are working with.";
return this.RedirectToAction(a => a.Results(surveyResponseToCreate.Id, null));
}
else
{
//foreach (var modelState in ModelState.Values.Where(a => a.Errors.Count() > 0))
//{
// var x = modelState;
//}
if (string.IsNullOrWhiteSpace(Message))
{
Message = "Please correct all errors and submit.";
}
var viewModel = SurveyResponseViewModel.Create(Repository, survey);
viewModel.SurveyResponse = surveyResponse;
viewModel.SurveyAnswers = questions;
return View(viewModel);
}
}
public static SurveyReponseDetailViewModel Create(IRepository repository, SurveyResponse surveyResponse)
{
Check.Require(repository != null, "Repository must be supplied");
Check.Require(surveyResponse != null);
var viewModel = new SurveyReponseDetailViewModel {SurveyResponse = surveyResponse};
//Get all the related categories that had answers.
var relatedCategoryIds = viewModel.SurveyResponse.Answers.Select(x => x.Category.Id).Distinct().ToList();
var bypassedAnswers = viewModel.SurveyResponse.Answers.Where(a => a.BypassScore);
viewModel.Scores = new List<Scores>();
foreach (var category in viewModel.SurveyResponse.Survey.Categories.Where(a => !a.DoNotUseForCalculations && relatedCategoryIds.Contains(a.Id)))
{
var score = new Scores();
score.Category = category;
var totalMax = repository.OfType<CategoryTotalMaxScore>().GetNullableById(category.Id);
if (totalMax == null) //No Questions most likely
{
continue;
}
score.MaxScore = totalMax.TotalMaxScore;
foreach (var bypassedAnswer in bypassedAnswers.Where(a => a.Category == category))
{
score.MaxScore = score.MaxScore - bypassedAnswer.Question.Responses.Where(a => a.IsActive).Max(a => a.Score);
}
//score.MaxScore = repository.OfType<CategoryTotalMaxScore>().GetNullableById(category.Id).TotalMaxScore;
score.TotalScore = viewModel.SurveyResponse.Answers.Where(a => a.Category == category).Sum(b => b.Score);
if (score.MaxScore == 0)
{
score.Percent = 100;
}
else
{
score.Percent = (score.TotalScore / score.MaxScore) * 100m;
}
score.Rank = category.Rank;
viewModel.Scores.Add(score);
}
return viewModel;
}
public static ResultsViewModel Create(SurveyResponse surveyResponse, bool showPdfPrint)
{
Check.Require(surveyResponse != null);
var viewModel = new ResultsViewModel {SurveyResponse = surveyResponse, ShowPdfPrint = showPdfPrint};
viewModel.PublicGuid = null;
return viewModel;
}
public static SingleAnswerSurveyResponseViewModel Create(IRepository repository, Survey survey, SurveyResponse pendingSurveyResponse)
{
Check.Require(repository != null, "Repository must be supplied");
Check.Require(survey != null);
var viewModel = new SingleAnswerSurveyResponseViewModel{Survey = survey, PendingSurveyResponse = pendingSurveyResponse, SurveyResponse = new SurveyResponse(survey)};
viewModel.Questions = viewModel.Survey.Questions
.Where(a => a.IsActive && a.Category != null && a.Category.IsActive && a.Category.IsCurrentVersion)
.OrderBy(a => a.Order).ToList();
viewModel.TotalActiveQuestions = viewModel.Questions.Count;
if (viewModel.PendingSurveyResponse != null)
{
viewModel.PendingSurveyResponseExists = true;
viewModel.AnsweredQuestions = viewModel.PendingSurveyResponse.Answers.Count;
var answeredQuestionIds = viewModel.PendingSurveyResponse.Answers.Select(a => a.Question.Id).ToList();
viewModel.CurrentQuestion = viewModel.Questions
.Where(a => !answeredQuestionIds.Contains(a.Id))
.OrderBy(a => a.Order)
.FirstOrDefault();
}
else
{
viewModel.PendingSurveyResponseExists = false;
viewModel.AnsweredQuestions = 0;
viewModel.CurrentQuestion = viewModel.Questions.FirstOrDefault();
}
viewModel.DisplayBypass = false;
return viewModel;
}
public void CalculateScores(IRepository repository, SurveyResponse surveyResponse)
{
var bypassedAnswers = surveyResponse.Answers.Where(a => a.BypassScore);
var scores = new List<Scores>();
foreach (var category in surveyResponse.Survey.Categories.Where(a => !a.DoNotUseForCalculations && a.IsActive && a.IsCurrentVersion))
{
var score = new Scores();
score.Category = category;
var totalMax = repository.OfType<CategoryTotalMaxScore>().GetNullableById(category.Id);
if (totalMax == null) //No Questions most likely
{
continue;
}
score.MaxScore = totalMax.TotalMaxScore;
Category category1 = category;
foreach (var bypassedAnswer in bypassedAnswers.Where(a => a.Category == category1))
{
score.MaxScore = score.MaxScore - bypassedAnswer.Question.Responses.Where(a => a.IsActive).Max(a => a.Score);
}
Category category2 = category;
score.TotalScore =
surveyResponse.Answers.Where(a => a.Category == category2).Sum(b => b.Score);
if (score.MaxScore == 0)
{
//?Don't score it?
continue;
}
score.Percent = (score.TotalScore / score.MaxScore) * 100m;
score.Rank = category.Rank;
scores.Add(score);
}
if (scores.OrderByDescending(a => a.Percent)
.FirstOrDefault() != null)
{
surveyResponse.PositiveCategory = scores
.OrderByDescending(a => a.Percent)
.ThenBy(a => a.Rank)
.FirstOrDefault().Category;
}
if (scores.Where(a => a.Category != surveyResponse.PositiveCategory)
.FirstOrDefault() != null)
{
surveyResponse.NegativeCategory1 = scores
.Where(a => a.Category != surveyResponse.PositiveCategory)
.OrderBy(a => a.Percent)
.ThenBy(a => a.Rank)
.FirstOrDefault().Category;
}
if (scores.Where(a => a.Category != surveyResponse.PositiveCategory && a.Category != surveyResponse.NegativeCategory1)
.FirstOrDefault() != null)
{
surveyResponse.NegativeCategory2 = scores
.Where(a => a.Category != surveyResponse.PositiveCategory && a.Category != surveyResponse.NegativeCategory1)
.OrderBy(a => a.Percent)
.ThenBy(a => a.Rank)
.FirstOrDefault().Category;
}
//If some are null because not questions are all answers were skipped for that category, still try to put something in.
if (surveyResponse.PositiveCategory == null)
{
surveyResponse.PositiveCategory = surveyResponse.Survey.Categories.Where(a => !a.DoNotUseForCalculations && a.IsActive && a.IsCurrentVersion).OrderBy(a => a.Rank).FirstOrDefault();
}
if (surveyResponse.NegativeCategory1 == null)
{
surveyResponse.NegativeCategory1 = surveyResponse.Survey.Categories.Where(a => !a.DoNotUseForCalculations && a.IsActive && a.IsCurrentVersion && a != surveyResponse.PositiveCategory).OrderBy(a => a.Rank).FirstOrDefault();
}
if (surveyResponse.NegativeCategory2 == null)
{
surveyResponse.NegativeCategory2 = surveyResponse.Survey.Categories.Where(a => !a.DoNotUseForCalculations && a.IsActive && a.IsCurrentVersion && a != surveyResponse.PositiveCategory && a != surveyResponse.NegativeCategory1).OrderBy(a => a.Rank).FirstOrDefault();
}
return;
}
public ActionResult StartSurvey(int id, SurveyResponse surveyResponse, Guid? publicGuid)
{
var survey = Repository.OfType<Survey>().GetNullableById(id);
if (survey == null || !survey.IsActive)
{
Message = "Survey not found or not active.";
return this.RedirectToAction<ErrorController>(a => a.Index());
}
ViewBag.surveyimage = string.Format("{0}-survey", survey.ShortName.ToLower().Trim());
surveyResponse.IsPending = true;
surveyResponse.Survey = survey;
surveyResponse.UserId = !string.IsNullOrWhiteSpace(CurrentUser.Identity.Name) ? CurrentUser.Identity.Name.ToLower() : publicGuid.ToString();
ModelState.Clear();
surveyResponse.TransferValidationMessagesTo(ModelState);
if (ModelState.IsValid)
{
if (!string.IsNullOrWhiteSpace(CurrentUser.Identity.Name))
{
_surveyResponseRepository.EnsurePersistent(surveyResponse);
}
else
{
Session[publicGuid.ToString()] = surveyResponse;
}
return this.RedirectToAction(a => a.AnswerNext(surveyResponse.Id, publicGuid));
}
Message = "Please correct errors to continue";
var viewModel = SingleAnswerSurveyResponseViewModel.Create(Repository, survey, null);
viewModel.SurveyResponse = surveyResponse;
viewModel.PublicGuid = publicGuid;
return View(viewModel);
}
