async void OnAssessmentSelected(object sender, SelectedItemChangedEventArgs args)
{
var assessment = args.SelectedItem as Assessment;
if (assessment == null)
{
return;
}
// TODO: verify assessment gets set in app
App.Assessment = assessment;
viewModel.Assessment = assessment;
Task <List <AssessmentQuestion> > assessmentQuestionsInTask = App.AssesmentQuestionDB.GetAssessmentQuestionsByAssessmentId(App.Assessment.AssessmentId);
List <AssessmentQuestion> assessmentQuestions = assessmentQuestionsInTask.Result;
AssessmentQuestion[] assessmentQuestionsArray = new AssessmentQuestion[assessmentQuestions.Count];
foreach (AssessmentQuestion assessmentQuestion in assessmentQuestions)
{
assessmentQuestionsArray[assessmentQuestion.OrderNum - 1] = assessmentQuestion;
}
App.CurrentAssessmentQuestions.AddRange(assessmentQuestionsArray);
await Navigation.PushAsync(new AssessmentHome(viewModel));
AssessmentListView.SelectedItem = null;
}
public bool UpdateAssessmentQuestion(AssessmentQuestionRequest request)
{
AssessmentQuestion AQ = new AssessmentQuestion();
AQ.ID = request.ID;
AQ.SelectedAssessmentId = request.SelectedAssessmentId;
AQ.Question = request.Question;
AQ.Option1 = request.Option1;
AQ.Option2 = request.Option2;
AQ.Option3 = request.Option3;
AQ.Option4 = request.Option4;
AQ.Option5 = request.Option5;
AQ.Marks = request.Marks;
AQ.CorrectOption = request.CorrectOption;
AQ.CorrectOptionSequence = request.CorrectOptionSequence;
bool response = false;
try
{
SqlSvrDAL dal = new SqlSvrDAL(request.ClientInfo);
response = dal.UpdateAssessmentQuestion(AQ);
}
catch (Exception ex)
{
//LogHelper.AddLog("AssessmentQuestionController", ex.Message, ex.StackTrace, "HCL.Academy.Service", request.ClientInfo.emailId);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
return(response);
}
public async Task <ActionResult> Create(AssessmentQuestion AQ)
{
InitializeServiceClient();
try
{
if (ModelState.IsValid)
{
AssessmentQuestionRequest AQR = new AssessmentQuestionRequest();
AQR.CorrectOption = AQ.CorrectOption;
AQR.CorrectOptionSequence = AQ.CorrectOptionSequence;
AQR.Marks = AQ.Marks;
AQR.Question = AQ.Question;
AQR.SelectedAssessmentId = AQ.SelectedAssessmentId;
AQR.Option1 = AQ.Option1;
AQR.Option2 = AQ.Option2;
AQR.Option3 = AQ.Option3;
AQR.Option4 = AQ.Option4;
AQR.Option5 = AQ.Option5;
HttpResponseMessage response = await client.PostAsJsonAsync("AssessmentQuestion/AddAssessmentQuestion", AQR);
client.Dispose();
TempData["CreateSuccess"] = true;
TempData.Keep();
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
//LogHelper.AddLog("AssessmentQuestionController", ex.Message, ex.StackTrace, "HCL.Academy.Web", user.EmailID);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
return(View());
}
public async Task <ActionResult> Edit(int Id)
{
InitializeServiceClient();
AssessmentQuestion aq = new AssessmentQuestion();
List <AssessmentMaster> assessmentlist = new List <AssessmentMaster>();
List <Competence> competencelist = new List <Competence>();
try
{
HttpResponseMessage response = await client.PostAsJsonAsync("AssessmentQuestion/GetAssessmentQuestionById?id=" + Id, req);
aq = await response.Content.ReadAsAsync <AssessmentQuestion>();
response = await client.PostAsJsonAsync("AssessmentMaster/GetAllAssessments", req);
assessmentlist = await response.Content.ReadAsAsync <List <AssessmentMaster> >();
aq.Assessments = assessmentlist;
}
catch (Exception ex)
{
//LogHelper.AddLog("AssessmentQuestionController", ex.Message, ex.StackTrace, "HCL.Academy.Web", user.EmailID);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
return(View(aq));
}
public void ConvertTo(AssessmentQuestionView assessmentQuestionView, AssessmentQuestion assessmentQuestion)
{
assessmentQuestion.AssessmentQuestionPK = assessmentQuestionView.AssessmentQuestionPK;
assessmentQuestion.Name = assessmentQuestionView.Name;
assessmentQuestion.AssessmentGroupFK = assessmentQuestionView.AssessmentGroupFK;
assessmentQuestion.Deleted = assessmentQuestionView.Deleted;
}
public ObservableCollection <MissingComponentDisplayDataLabel> GetMissingComponentsDisplayLabels(
Guid SessionID,
AssessmentQuestion question)
{
lock ((object)this._AssessmentsClient)
return(this.AssessmentsClient.GetMissingComponentsListDisplayLabels(SessionID, question));
}
private AssessmentQuestion GetLevelDescriptorsForAssessmentQuestion(AssessmentQuestion assessmentQuestion)
{
if (assessmentQuestion.AssessmentQuestionInputTypeID != 2)
{
assessmentQuestion.LevelDescriptors = selfAssessmentService.GetLevelDescriptorsForAssessmentQuestion(assessmentQuestion.Id, assessmentQuestion.MinValue, assessmentQuestion.MaxValue, assessmentQuestion.MinValue == 0).ToList();
}
return(assessmentQuestion);
}
public async Task <AssessmentQuestion> Add(AssessmentQuestion assessmentQuestion)
{
assessmentQuestion.Id = Guid.NewGuid().ToString();
assessmentQuestion.CreatedOn = DateTime.Now;
assessmentQuestion.CreatedBy = null;
await _context.AssessmentQuestions.AddAsync(assessmentQuestion);
return(assessmentQuestion);
}
public Task <int> SaveItemAsync(AssessmentQuestion item)
{
if (item.AssessmentQuestionId != 0)
{
return(database.UpdateAsync(item));
}
else
{
return(database.InsertAsync(item));
}
}
public TripleTextTemplateViewModel(Question question, AssessmentQuestion assessmentQuestion) : base(question, assessmentQuestion)
{
Question = question;
AssessmentQuestion = assessmentQuestion;
Result = new Result();
Result.QuestionId = question.QuestionId;
Result.AssesmentQuestionId = assessmentQuestion.AssessmentQuestionId;
Result.AssessmentSessionId = App.AssessmentSession.SessionId;
TemplateNavigation = new TemplateNavigation();
}
public SessionCompetencyLearningResourceSignpostingParameter(FrameworkCompetency frameworkCompetency, string resourceName, List <AssessmentQuestion> questions, AssessmentQuestion selectedQuestion, CompareAssessmentQuestionType selectedCompareQuestionType, CompetencyResourceAssessmentQuestionParameter assessmentQuestionParameter)
{
FrameworkCompetency = frameworkCompetency;
ResourceName = resourceName;
Questions = questions;
AssessmentQuestionParameter = assessmentQuestionParameter;
SelectedQuestion = selectedQuestion;
SelectedCompareQuestionType = selectedCompareQuestionType;
TriggerValuesConfirmed = false;
CompareQuestionConfirmed = false;
}
public BaseViewModel(Question question, AssessmentQuestion assessmentQuestion)
{
if (assessmentQuestion.OrderNum == App.CurrentAssessmentQuestions.Count)
{
IsLastQuestion = true;
}
else
{
IsLastQuestion = false;
}
}
public void ConvertFrom(AssessmentQuestion assessmentQuestion, AssessmentQuestionView assessmentQuestionView, ObjectContext db)
{
assessmentQuestionView.AssessmentQuestionPK = assessmentQuestion.AssessmentQuestionPK;
assessmentQuestionView.Name = assessmentQuestion.Name;
assessmentQuestionView.AssessmentGroupFK = assessmentQuestion.AssessmentGroupFK;
assessmentQuestionView.Deleted = assessmentQuestion.Deleted;
//get assement type fk
IAssessmentGroupsRepository assessmentGroupsRepository = new AssessmentGroupsRepository(db);
assessmentQuestionView.AssessmentTypeFK = assessmentGroupsRepository.GetAssessmentGroupByPK((int)assessmentQuestionView.AssessmentGroupFK).AssessmentTypeFK;
}
public TwoWayMCTemplateViewModel(Question question, AssessmentQuestion assessmentQuestion) : base(question, assessmentQuestion)
{
Question = question;
AssessmentQuestion = assessmentQuestion;
OptionsParser();
Result = new Result();
Result.QuestionId = question.QuestionId;
Result.AssesmentQuestionId = assessmentQuestion.AssessmentQuestionId;
Result.AssessmentSessionId = App.AssessmentSession.SessionId;
}
public ActionResult NewQuestion(NewQuestionViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(ViewNewQuestion(viewModel));
}
var question = new AssessmentQuestion(viewModel.AssessmentSubGoalID, viewModel.AssessmentQuestionText);
viewModel.UpdateModel(question, CurrentFirmaSession);
HttpRequestStorage.DatabaseEntities.AllAssessmentQuestions.Add(question);
return(new ModalDialogFormJsonResult());
}
public ActionResult AssessmentQuestions(AssignQuestionsModel model, FormCollection frm)
{
if (!_permissionService.Authorize("ManageAssessment"))
{
return(AccessDeniedView());
}
if (ModelState.IsValid && model.SelectedQuestion != null && model.SelectedQuestion.Length > 0)
{
var alreadyAddedQuestions = _smsService.GetQuestionsByAssessmentId(model.AssessmentId);
foreach (var id in model.SelectedQuestion)
{
var aQuestion = new AssessmentQuestion();
aQuestion.QuestionId = id;
aQuestion.AssessmentId = model.AssessmentId;
aQuestion.RightMarks = (frm["RightMarks_" + id] != null && !string.IsNullOrEmpty(frm["RightMarks_" + id].ToString())) ? Convert.ToDouble(frm["RightMarks_" + id].ToString()) : 0;
aQuestion.NegativeMarks = (frm["NegativeMarks_" + id] != null && !string.IsNullOrEmpty(frm["NegativeMarks_" + id].ToString())) ? Convert.ToDouble(frm["NegativeMarks_" + id].ToString()) : 0;
aQuestion.DisplayOrder = (frm["DisplayOrder_" + id] != null && !string.IsNullOrEmpty(frm["DisplayOrder_" + id].ToString())) ? Convert.ToInt32(frm["DisplayOrder_" + id].ToString()) : 0;
aQuestion.SolveTime = (frm["SolveTime_" + id] != null && !string.IsNullOrEmpty(frm["SolveTime_" + id].ToString())) ? frm["SolveTime_" + id].ToString() : "";
aQuestion.IsTimeBound = (frm["IsTimeBound_" + id] != null && !string.IsNullOrEmpty(frm["IsTimeBound_" + id].ToString())) ? Convert.ToBoolean(frm["IsTimeBound_" + id].ToString()) : false;
if (alreadyAddedQuestions.Any(x => x.QuestionId == id))
{
var assessmentQuestion = alreadyAddedQuestions.FirstOrDefault(x => x.QuestionId == id);
assessmentQuestion.RightMarks = aQuestion.RightMarks;
assessmentQuestion.NegativeMarks = aQuestion.NegativeMarks;
assessmentQuestion.DisplayOrder = aQuestion.DisplayOrder;
assessmentQuestion.SolveTime = aQuestion.SolveTime;
assessmentQuestion.IsTimeBound = aQuestion.IsTimeBound;
assessmentQuestion.ModifiedOn = DateTime.Now;
_smsService.UpdateAssessmentQuestion(assessmentQuestion);
}
else
{
aQuestion.CreatedOn = aQuestion.ModifiedOn = DateTime.Now;
aQuestion.UserId = _userContext.CurrentUser.Id;
_smsService.InsertAssessmentQuestion(aQuestion);
}
}
if (alreadyAddedQuestions.Count > 0)
{
var removeQuestions = alreadyAddedQuestions.Where(y => model.SelectedQuestion.Any(z => z != y.QuestionId)).ToList();
foreach (var q in removeQuestions)
{
_smsService.DeleteAssessmentQuestion(q.QuestionId);
}
}
}
SuccessNotification("Assessment updated successfully.");
return(RedirectToAction("AssessmentQuestions", new { id = model.AssessmentId }));
}
public SingleTextTemplateViewModel(Question question, AssessmentQuestion assessmentQuestion) : base(question, assessmentQuestion)
{
App.CurrentAssessmentQuestionId = assessmentQuestion.AssessmentQuestionId;
App.CurrentQuestionId = question.QuestionId;
Question = question;
AssessmentQuestion = assessmentQuestion;
//Result = new Result();
//Result.QuestionId = question.QuestionId;
//Result.AssesmentQuestionId = assessmentQuestion.AssessmentQuestionId;
//Result.AssessmentSessionId = App.AssessmentSession.SessionId;
// TemplateNavigation = new TemplateNavigation();
}
public async Task <ActionResult> Edit(AssessmentQuestion AQ)
{
InitializeServiceClient();
List <AssessmentMaster> assessmentlist = new List <AssessmentMaster>();
try
{
if (ModelState.IsValid)
{
AssessmentQuestionRequest AQR = new AssessmentQuestionRequest();
AQR.ID = AQ.ID;
AQR.CorrectOption = AQ.CorrectOption;
AQR.CorrectOptionSequence = AQ.CorrectOptionSequence;
AQR.Marks = AQ.Marks;
AQR.Question = AQ.Question;
AQR.SelectedAssessmentId = AQ.SelectedAssessmentId;
AQR.Option1 = AQ.Option1;
AQR.Option2 = AQ.Option2;
AQR.Option3 = AQ.Option3;
AQR.Option4 = AQ.Option4;
AQR.Option5 = AQ.Option5;
HttpResponseMessage response = await client.PostAsJsonAsync("AssessmentQuestion/UpdateAssessmentQuestion", AQR);
bool result = await response.Content.ReadAsAsync <bool>();
if (result)
{
ViewBag.Success = true;
}
else
{
ViewBag.Success = false;
}
response = await client.PostAsJsonAsync("AssessmentMaster/GetAllAssessments", req);
assessmentlist = await response.Content.ReadAsAsync <List <AssessmentMaster> >();
AQ.Assessments = assessmentlist;
}
}
catch (Exception ex)
{
//LogHelper.AddLog("AssessmentQuestionController", ex.Message, ex.StackTrace, "HCL.Academy.Web", user.EmailID);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
return(View(AQ));
}
public ActionResult Delete(int?assessmentQuestionPK)
{
IAssessmentQuestionsRepository assessmentQuestionsRepository = new AssessmentQuestionsRepository(db);
if (assessmentQuestionPK != null)
{
AssessmentQuestion assessmentQuestion = assessmentQuestionsRepository.GetAssessmentQuestionByPK((int)assessmentQuestionPK);
assessmentQuestion.Deleted = true;
assessmentQuestionsRepository.SaveChanges();
TempData["message"] = LayoutHelper.GetMessage("DELETE", assessmentQuestion.AssessmentQuestionPK);
}
return(Redirect(Request.UrlReferrer.AbsoluteUri));
}
public AssessmentQuestion GetAssessmentQuestionById(RequestBase req, int id)
{
AssessmentQuestion response = new AssessmentQuestion();
try
{
SqlSvrDAL dal = new SqlSvrDAL(req.ClientInfo);
response = dal.GetAssessmentQuestionById(id);
}
catch (Exception ex)
{
//LogHelper.AddLog("AssessmentQuestionController", ex.Message, ex.StackTrace, "HCL.Academy.Service", req.ClientInfo.emailId);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
return(response);
}
public ActionResult Edit(int?assessmentQuestionPK)
{
if (assessmentQuestionPK != null)
{
IAssessmentQuestionsRepository assessmentQuestionsRepository = new AssessmentQuestionsRepository(db);
AssessmentQuestion assessmentQuestion = assessmentQuestionsRepository.GetAssessmentQuestionByPK((int)assessmentQuestionPK);
AssessmentQuestionView assessmentQuestionView = new AssessmentQuestionView();
assessmentQuestionView.ConvertFrom(assessmentQuestion, assessmentQuestionView, db);
assessmentQuestionView.BindDDLs(assessmentQuestionView, db);
return(View(assessmentQuestionView));
}
else
{
return(RedirectToAction("Index", "AssessmentQuestion"));
}
}
/// <summary>
/// Add new Queston to a Category
/// </summary>
/// <param name="id">ID of Assessment Category</param>
/// <param name="heading">Heading of Question</param>
/// <param name="body">Body of Question</param>
/// <param name="questionCode">Question Code</param>
/// <returns></returns>
public int AddQuestion(int id, string heading, string body, string questionCode)
{
var prevQuestion = db.AssessmentQuestions.Where(o => o.AssessmentCategoryID == id).OrderByDescending(o => o.QuestionOrder).FirstOrDefault();
var question = new AssessmentQuestion
{
AssessmentCategoryID = id,
Translation = new Translation {
EN = heading
},
Translation1 = new Translation {
EN = body
},
QuestionOrder = prevQuestion != null ? prevQuestion.QuestionOrder + 1 : 1,
QuestionCode = questionCode
};
db.AssessmentQuestions.Add(question);
db.SaveChanges();
return(question.ID);
}
async void Start_Clicked(object sender, EventArgs e)
{
AssessmentSession assessmentSession = new AssessmentSession();
assessmentSession.AssessmentId = App.Assessment.AssessmentId;
assessmentSession.StudentId = App.Student.StudentId;
assessmentSession.SessionDate = JulianDateParser.ConverToJD(DateTime.Now);
int success = App.AssesmentSessionDB.SaveItemAsync(assessmentSession).Result;
if (success == 1)
{
App.AssessmentSession = assessmentSession;
App.CurrentAssessmentSessionId = assessmentSession.SessionId;
}
Question question = App.CurrentQuestions[0];
AssessmentQuestion assessmentQuestion = App.CurrentAssessmentQuestions[0];
NavigateToNextQuestionViewAsync(question, assessmentQuestion);
}
public async void NavigateToNextQuestionViewAsync(Question question, AssessmentQuestion assessmentQuestion)
{
switch (question.Qtype)
{
case "5WayMC":
await Navigation.PushAsync(new FiveWayMCTemplate(new FiveWayMCTemplateViewModel(question, assessmentQuestion)));
Navigation.RemovePage(this);
break;
case "3WayMC":
await Navigation.PushAsync(new ThreeWayMCTemplate(new ThreeWayMCTemplateViewModel(question, assessmentQuestion)));
Navigation.RemovePage(this);
break;
case "2WayMC":
await Navigation.PushAsync(new TwoWayMCTemplate(new TwoWayMCTemplateViewModel(question, assessmentQuestion)));
Navigation.RemovePage(this);
break;
case "SingleText":
await Navigation.PushAsync(new SingleTextTemplate(new SingleTextTemplateViewModel(question, assessmentQuestion)));
Navigation.RemovePage(this);
break;
case "TripleText":
await Navigation.PushAsync(new TripleTextTemplate(new TripleTextTemplateViewModel(question, assessmentQuestion)));
Navigation.RemovePage(this);
break;
default:
await Navigation.PushModalAsync(new AdminHome());
break;
}
}
public ActionResult Edit(AssessmentQuestionView assessmentQuestionView, FormCollection form)
{
if (ModelState.IsValid)
{
IAssessmentQuestionsRepository assessmentQuestionsRepository = new AssessmentQuestionsRepository(db);
AssessmentQuestion assessmentQuestion = assessmentQuestionsRepository.GetAssessmentQuestionByPK((int)assessmentQuestionView.AssessmentQuestionPK);
assessmentQuestionView.ConvertTo(assessmentQuestionView, assessmentQuestion);
assessmentQuestionsRepository.SaveChanges();
TempData["message"] = LayoutHelper.GetMessage("UPDATE", assessmentQuestion.AssessmentQuestionPK);
return(RedirectToAction("Index", "AssessmentQuestion"));
}
else
{
assessmentQuestionView.BindDDLs(assessmentQuestionView, db);
return(View(assessmentQuestionView));
}
}
public async void NavigateToNextQuestionViewAsync(Question question, AssessmentQuestion assessmentQuestion)
{
/*
* "5WayMC"
* "3WayMC"
* "2WayMC"
* "SingleText"
* "TripleText"
*/
switch (question.Qtype)
{
case "5WayMC":
await Navigation.PushAsync(new FiveWayMCTemplate(new FiveWayMCTemplateViewModel(question, assessmentQuestion)));
break;
case "3WayMC":
// TODO
break;
case "2WayMC":
// TODO
break;
case "SingleText":
await Navigation.PushAsync(new SingleTextTemplate(new SingleTextTemplateViewModel(question, assessmentQuestion)));
break;
default:
await Navigation.PushModalAsync(new AdminHome());
break;
}
}
public void UpdateModel(AssessmentQuestion question, FirmaSession currentFirmaSession)
{
question.AssessmentQuestionText = AssessmentQuestionText;
question.AssessmentSubGoalID = AssessmentSubGoalID;
}
private void LoadData()
{
//--------------------------------------------------------------------------------------------------------------
int assessId = 0;
Assessment assessment = App.AssesmentDB.GetAssessmentByAssessNameAsync(EnumHatersGonnaVerify.AssessName_FeelingsCheckIn).Result;
if (assessment == null)
{
Assessment assess1 = new Assessment();
assess1.AssessName = EnumHatersGonnaVerify.AssessName_FeelingsCheckIn;
assessId = App.AssesmentDB.SaveItemAsync(assess1).Result;
}
else
{
assessId = assessment.AssessmentId;
}
//--------------------------------------------------------------------------------------------------------------
Student s1 = new Student();
s1.FirstName = "James";
s1.MiddleName = "Spencer";
s1.LastName = "Bell";
s1.Grade = "K";
s1.Age = 5;
Student s1Verify = App.StudentDB.GetStudentByName(s1.FirstName, s1.MiddleName, s1.LastName).Result;
if (s1Verify == null)
{
App.StudentDB.SaveItemAsync(s1);
}
Student s2 = new Student();
s2.FirstName = "Garret";
s2.MiddleName = "Danger";
s2.LastName = "Allen";
s2.Grade = "1";
s2.Age = 6;
Student s2Verify = App.StudentDB.GetStudentByName(s2.FirstName, s2.MiddleName, s2.LastName).Result;
if (s2Verify == null)
{
App.StudentDB.SaveItemAsync(s2);
}
Student s3 = new Student();
s3.FirstName = "Bryon";
s3.MiddleName = "Byron";
s3.LastName = "Steinwand";
s3.Grade = "2";
s3.Age = 7;
Student s3Verify = App.StudentDB.GetStudentByName(s3.FirstName, s3.MiddleName, s3.LastName).Result;
if (s3Verify == null)
{
App.StudentDB.SaveItemAsync(s3);
}
//--------------------------------------------------------------------------------------------------------------
List <AssessmentQuestion> assessmentQuestions = App.AssesmentQuestionDB.GetItemsAsync().Result;
List <Question> questions = App.QuestionDB.GetItemsAsync().Result;
if (assessmentQuestions.Count > 0)
{
foreach (AssessmentQuestion assessmentQuestion in assessmentQuestions)
{
App.AssesmentQuestionDB.DeleteItemAsync(assessmentQuestion);
}
}
if (questions.Count > 0)
{
foreach (Question question in questions)
{
App.QuestionDB.DeleteItemAsync(question);
}
}
//--------------------------------------------------------------------------------------------------------------
int success = 0;
Question q1 = new Question();
q1.DisplayText = EnumHatersGonnaVerify.DisplayText_HowDoYouFeelRightNow;
q1.Qtype = EnumHatersGonnaVerify.QType_5WayMultipleChoice;
q1.Option1 = EnumHatersGonnaVerify.OptionText_HappySadExcitedMadScared;
success = App.QuestionDB.SaveItemAsync(q1).Result;
AssessmentQuestion aq1 = new AssessmentQuestion();
aq1.AssessmentId = assessId;
aq1.QuestionId = q1.QuestionId;
aq1.OrderNum = 1;
App.AssesmentQuestionDB.SaveItemAsync(aq1);
//--------------------------------------------------------------------------------------------------------------
Question q2 = new Question();
q2.DisplayText = EnumHatersGonnaVerify.DisplayText_WhereDoYouLive;
q2.Qtype = EnumHatersGonnaVerify.QType_SingleTextResponse;
success = App.QuestionDB.SaveItemAsync(q2).Result;
AssessmentQuestion aq2 = new AssessmentQuestion();
aq2.AssessmentId = assessId;
aq2.QuestionId = q2.QuestionId;
aq2.OrderNum = 2;
App.AssesmentQuestionDB.SaveItemAsync(aq2);
//--------------------------------------------------------------------------------------------------------------
Question q3 = new Question();
q3.DisplayText = EnumHatersGonnaVerify.DisplayText_WhoDoYouLiveWith;
q3.Qtype = EnumHatersGonnaVerify.QType_SingleTextResponse;
success = App.QuestionDB.SaveItemAsync(q3).Result;
AssessmentQuestion aq3 = new AssessmentQuestion();
aq3.AssessmentId = assessId;
aq3.QuestionId = q3.QuestionId;
aq3.OrderNum = 3;
App.AssesmentQuestionDB.SaveItemAsync(aq3);
//--------------------------------------------------------------------------------------------------------------
Question q4 = new Question();
q4.DisplayText = EnumHatersGonnaVerify.DisplayText_DoYouHaveFriends;
q4.Qtype = EnumHatersGonnaVerify.QType_2WayMultipleChoice;
q4.Option1 = EnumHatersGonnaVerify.OptionText_YesNo;
success = App.QuestionDB.SaveItemAsync(q4).Result;
AssessmentQuestion aq4 = new AssessmentQuestion();
aq4.AssessmentId = assessId;
aq4.QuestionId = q4.QuestionId;
aq4.OrderNum = 4;
App.AssesmentQuestionDB.SaveItemAsync(aq4);
//--------------------------------------------------------------------------------------------------------------
Question q5 = new Question();
q5.DisplayText = EnumHatersGonnaVerify.DisplayText_WhoAreThePeopleThatLoveYouAndMakeYouFeelSafe;
q5.Qtype = EnumHatersGonnaVerify.QType_SingleTextResponse;
success = App.QuestionDB.SaveItemAsync(q5).Result;
AssessmentQuestion aq5 = new AssessmentQuestion();
aq5.AssessmentId = assessId;
aq5.QuestionId = q5.QuestionId;
aq5.OrderNum = 5;
App.AssesmentQuestionDB.SaveItemAsync(aq5);
//--------------------------------------------------------------------------------------------------------------
Question q6 = new Question();
q6.DisplayText = EnumHatersGonnaVerify.DisplayText_DoYouFeelSaveWhenYouAreAtHome;
q6.Qtype = EnumHatersGonnaVerify.QType_3WayMultipleChoice;
q6.Option1 = EnumHatersGonnaVerify.OptionText_YesNoKinda;
success = App.QuestionDB.SaveItemAsync(q6).Result;
AssessmentQuestion aq6 = new AssessmentQuestion();
aq6.AssessmentId = assessId;
aq6.QuestionId = q6.QuestionId;
aq6.OrderNum = 6;
App.AssesmentQuestionDB.SaveItemAsync(aq6);
//--------------------------------------------------------------------------------------------------------------
Question q7 = new Question();
q7.DisplayText = EnumHatersGonnaVerify.DisplayText_DoYouHaveEnoughFoodAtHome;
q7.Qtype = EnumHatersGonnaVerify.QType_2WayMultipleChoice;
q7.Option1 = EnumHatersGonnaVerify.OptionText_YesNo;
success = App.QuestionDB.SaveItemAsync(q7).Result;
AssessmentQuestion aq7 = new AssessmentQuestion();
aq7.AssessmentId = assessId;
aq7.QuestionId = q7.QuestionId;
aq7.OrderNum = 7;
App.AssesmentQuestionDB.SaveItemAsync(aq7);
//--------------------------------------------------------------------------------------------------------------
Question q8 = new Question();
q8.DisplayText = EnumHatersGonnaVerify.DisplayText_WhatAreYourThreeBigWishes;
q8.Qtype = EnumHatersGonnaVerify.QType_TripleTextResponse;
success = App.QuestionDB.SaveItemAsync(q8).Result;
AssessmentQuestion aq8 = new AssessmentQuestion();
aq8.AssessmentId = assessId;
aq8.QuestionId = q8.QuestionId;
aq8.OrderNum = 8;
App.AssesmentQuestionDB.SaveItemAsync(aq8);
//--------------------------------------------------------------------------------------------------------------
Question q9 = new Question();
q9.DisplayText = EnumHatersGonnaVerify.DisplayText_HowDoYouGetReadyForBed;
q9.Qtype = EnumHatersGonnaVerify.QType_SingleTextResponse;
success = App.QuestionDB.SaveItemAsync(q9).Result;
AssessmentQuestion aq9 = new AssessmentQuestion();
aq9.AssessmentId = assessId;
aq9.QuestionId = q9.QuestionId;
aq9.OrderNum = 9;
App.AssesmentQuestionDB.SaveItemAsync(aq9);
}
public void UpdateModel(AssessmentQuestion assessmentQuestion, FirmaSession currentFirmaSession)
{
assessmentQuestion.AssessmentQuestionText = AssessmentQuestionText;
assessmentQuestion.ArchiveDate = Archive ? DateTime.Now : (DateTime?)null;
}
public EditQuestionViewModel(AssessmentQuestion assessmentQuestion)
{
AssessmentQuestionText = assessmentQuestion.AssessmentQuestionText;
Archive = assessmentQuestion.ArchiveDate.HasValue;
}
