public async Task <IActionResult> CreateQuestionsToMarketResearchDirectly([Bind("MarketResearchId,Name,Description,Purpose,MinAge,MaxAge,Gender,Area,CreationDate,StartDate,EndDate,NumberOfResponders, OnGoing")] MarketResearch marketResearch)
{
if (ModelState.IsValid)
{
marketResearch.MarketResearchId = Guid.NewGuid();
ApplicationUser applicationUser = await _userManager.GetUserAsync(HttpContext.User);
var userId = applicationUser.Id;
await _accessQuestions.SetMarketResearchToPersonAndOrganizationAndSave(marketResearch, userId);
await _accessQuestions.GetRespondersToMarketResearch(marketResearch);
await _context.SaveChangesAsync();
}
var questionToMarketResearch = new AddQuestionToMarketResearchVm
{
CurrentMarketResearchId = marketResearch.MarketResearchId
};
return(RedirectToAction("Create", "Questions", questionToMarketResearch));
}
internal async Task SetNumberOnQuestion(AddQuestionToMarketResearchVm questionToMarketResearchVm)
{
var question = _questionContext.Questions.Single(x => x.QuestionId == questionToMarketResearchVm.Question.QuestionId);
question.QuestionNumber = _questionContext.GetQuestionToMarketResearches.Where(x => x.MarketResearchId == questionToMarketResearchVm.CurrentMarketResearchId).Include(x => x.Question).Max(x => x.Question.QuestionNumber) + 1;
_questionContext.Update(question);
await _questionContext.SaveChangesAsync();
}
//internal async Task GetRespondersToMarketResearchFromRegistredUser(Guid id)
//{
// var respondent = _questionContext.Persons.FirstAsync(x => x.PersonId == id);
// var responders = _questionContext.MarketResearches.Include(x=>x.) Where(x =>
// (_questionContext.MarketResearches.Gender == null || marketResearch.Gender == x.Gender) &&
// ( marketResearch.MinAge == null || respondent.Age > x.Age) &&
// ( marketResearch.MaxAge == null || respondent.Age < x.Age) &&
// (marketResearch.OnGoing == true) &&
// (marketResearch.OnGoing == true) &&
// (marketResearch.Area == null || marketResearch.Area == x.City)).ToList();
//}
internal async Task AddQuestionOption(AddQuestionToMarketResearchVm questionToMarketResearchVm, int questionType)
{
var question = _questionContext.Questions.Single(x => x.QuestionId == questionToMarketResearchVm.Question.QuestionId); //Blir det rätt
question.QuestionType = (QuestionTypes)questionType;
_questionContext.Update(question);
await _questionContext.SaveChangesAsync();
}
internal async Task SetQuestionTypeOnQuestion(AddQuestionToMarketResearchVm questionToMarketResearchVm)
{
var question = _questionContext.Questions.Single(x => x.QuestionId == questionToMarketResearchVm.Question.QuestionId);
question.QuestionType = questionToMarketResearchVm.QuestionTypes.First();
_questionContext.Update(question);
await _questionContext.SaveChangesAsync();
}
public IActionResult CreateQuestionsToMarketResearch(Guid id)
{
var questionToMarketResearch = new AddQuestionToMarketResearchVm
{
//QuestionTypes = _context.QuestionTypes.Select(x=>x).ToList(),
CurrentMarketResearchId = id
};
return(RedirectToAction("Create", "Questions", questionToMarketResearch));
}
public async Task <IActionResult> SetOptionsForQuestionType(AddQuestionToMarketResearchVm questionToMarketResearchVm)
{
var vm = new AddQuestionToMarketResearchVm();
questionToMarketResearchVm.GradeChoices = vm.SetGradeChoicesList();
questionToMarketResearchVm.BinaryChoice = vm.SetBinaryChoiceList();
await _dataAccessQuestion.saveQuestion(questionToMarketResearchVm);
questionToMarketResearchVm.Question.ActualQuestion = "";
return(View("Create", questionToMarketResearchVm));
}
// GET: Questions/Create
public IActionResult Create(AddQuestionToMarketResearchVm addQuestionToMarketResearchVm)
{
var listOfChapters = _dataAccessQuestion.GetChapters(addQuestionToMarketResearchVm.CurrentMarketResearchId);
var selectChapters = GetSelectChapters(listOfChapters);
addQuestionToMarketResearchVm.Chapters = selectChapters;
foreach (var chapter in listOfChapters)
{
addQuestionToMarketResearchVm.MarketResearchName = chapter.MarketResearch.Name;
break;
}
return(View(addQuestionToMarketResearchVm));
}
public async Task <IActionResult> UpdateQuestion(AddQuestionToMarketResearchVm addQuestionToMarketResearch)
{
var listQuestionOption = _context.QuestionOptions.Where(x => x.QuestionId == addQuestionToMarketResearch.Question.QuestionId).ToList();
_context.RemoveRange(listQuestionOption);
var vm = new AddQuestionToMarketResearchVm();
addQuestionToMarketResearch.GradeChoices = vm.SetGradeChoicesList();
addQuestionToMarketResearch.BinaryChoice = vm.SetBinaryChoiceList();
addQuestionToMarketResearch.Question.QuestionType = addQuestionToMarketResearch.QuestionTypes[0];
_context.Update(addQuestionToMarketResearch.Question);
await _context.SaveChangesAsync();
return(View("Update", addQuestionToMarketResearch));
}
internal async Task saveQuestion(AddQuestionToMarketResearchVm questionToMarketResearchVm)
{
var marketResearch = _questionContext.MarketResearches.Single(x => x.MarketResearchId == questionToMarketResearchVm.CurrentMarketResearchId);
var question = questionToMarketResearchVm.Question;
question.QuestionType = questionToMarketResearchVm.QuestionTypes[0];
QuestionToMarketResearch questionToMarketResearch = new QuestionToMarketResearch
{
Question = question,
MarketResearch = marketResearch
};
_questionContext.Add(questionToMarketResearch);
await _questionContext.SaveChangesAsync();
}
public async Task <IActionResult> SaveChapter(Guid marketResearchId, Chapters chapters)
{
if (!ModelState.IsValid)
{
return(View("AddChapter"));
}
await _dataAccessQuestion.SaveChapter(marketResearchId, chapters);
AddQuestionToMarketResearchVm viewModel = new AddQuestionToMarketResearchVm();
viewModel.CurrentMarketResearchId = marketResearchId;
var listofchapters = _dataAccessQuestion.GetChapters(marketResearchId);
var selectchapters = GetSelectChapters(listofchapters);
viewModel.Chapters = selectchapters;
return(View("Create", viewModel));
}
// GET: Questions/Edit/5
public async Task <IActionResult> Edit(Guid id)
{
if (id == null)
{
return(NotFound());
}
var question = await _context.Questions.FindAsync(id);
var marketResearch = _context.GetQuestionToMarketResearches.Where(x => x.QuestionId == id).Select(x => x.MarketResearchId).ToList();
if (question == null)
{
return(NotFound());
}
var viewModelEdit = new AddQuestionToMarketResearchVm();
viewModelEdit.Question = question;
viewModelEdit.CurrentMarketResearchId = marketResearch[0];
viewModelEdit.Question.QuestionId = id;
ViewData["ChaptersId"] = new SelectList(_context.Chapters.Where(x => x.MarketResearch.MarketResearchId == marketResearch[0]), "ChaptersId", "Name", question.ChaptersId);
return(View(viewModelEdit));
}
internal async Task AddQuestionOption(QuestionOption questionOption, AddQuestionToMarketResearchVm questionToMarketResearchVm)
{
questionOption.QuestionId = questionToMarketResearchVm.Question.QuestionId;
_questionContext.Add(questionOption);
await _questionContext.SaveChangesAsync();
}
public async Task <IActionResult> UpdateType(AddQuestionToMarketResearchVm questionToMarketResearchVm, bool buttonstate)
{
var listOfChapters = _dataAccessQuestion.GetChapters(questionToMarketResearchVm.CurrentMarketResearchId);
var selectChapters = GetSelectChapters(listOfChapters);
questionToMarketResearchVm.Chapters = selectChapters;
string qType = questionToMarketResearchVm.QuestionTypes.First().ToString();
switch (qType)
{
case "Graderingsfråga":
{
var vm = new AddQuestionToMarketResearchVm();
questionToMarketResearchVm.GradeChoices = vm.SetGradeChoicesList();
for (int i = 0; i < questionToMarketResearchVm.HighGrade; i++)
{
var questionOption = new QuestionOption();
questionOption.Value = (i + 1).ToString();
questionOption.QuestionId = questionToMarketResearchVm.Question.QuestionId;
if (i == 0)
{
var listitem = questionToMarketResearchVm.GradeChoices[questionToMarketResearchVm.TypeChoice];
string[] headingsInArray = listitem.Text.Split('-');
questionOption.QuestionOptionHeading = headingsInArray[0].Trim();
}
else if (i == questionToMarketResearchVm.HighGrade - 1)
{
var listitem = questionToMarketResearchVm.GradeChoices[questionToMarketResearchVm.TypeChoice];
string[] headingsInArray = listitem.Text.Split('-');
questionOption.QuestionOptionHeading = headingsInArray[1].Trim();
}
await _dataAccessQuestion.AddQuestionOption(questionOption, questionToMarketResearchVm);
}
if (string.IsNullOrEmpty(questionToMarketResearchVm.Question.QuestionNumber.ToString()) || questionToMarketResearchVm.Question.QuestionNumber == 0)
{
await _dataAccessQuestion.SetNumberOnQuestion(questionToMarketResearchVm);
}
questionToMarketResearchVm.QuestionTypes = null;
ModelState.Clear();
break;
}
case "Binärfråga":
{
var vm = new AddQuestionToMarketResearchVm();
questionToMarketResearchVm.BinaryChoice = vm.SetBinaryChoiceList();
var questionOption = new QuestionOption();
var bin = questionToMarketResearchVm.BinaryChoice[questionToMarketResearchVm.TypeChoice];
questionOption.QuestionOptionHeading = bin.Text.ToString();
questionOption.Value = bin.Text.ToString();
await _dataAccessQuestion.AddQuestionOption(questionOption, questionToMarketResearchVm);
if (string.IsNullOrEmpty(questionToMarketResearchVm.Question.QuestionNumber.ToString()) || questionToMarketResearchVm.Question.QuestionNumber == 0)
{
await _dataAccessQuestion.SetNumberOnQuestion(questionToMarketResearchVm);
}
questionToMarketResearchVm.QuestionTypes = null;
break;
}
case "Flervalsfråga":
{
string x = questionToMarketResearchVm.Alternative.ToString();
List <string> queOptList = new List <string>();
queOptList.Add(x);
if (buttonstate)
{
questionToMarketResearchVm.QuestionTypes = null;
ModelState.Clear();
if (string.IsNullOrEmpty(questionToMarketResearchVm.Question.QuestionNumber.ToString()) || questionToMarketResearchVm.Question.QuestionNumber == 0)
{
await _dataAccessQuestion.SetNumberOnQuestion(questionToMarketResearchVm);
}
}
else
{
var questionOption = new QuestionOption();
questionOption.QuestionOptionHeading = questionToMarketResearchVm.Alternative.ToString();
questionOption.Value = questionToMarketResearchVm.Alternative.ToString();
await _dataAccessQuestion.AddQuestionOptionForFlerval(questionOption, questionToMarketResearchVm);
ViewData["listOfAlternatives"] = queOptList;
}
return(View("Create", questionToMarketResearchVm));
}
case "Textfråga":
{
if (string.IsNullOrEmpty(questionToMarketResearchVm.Question.QuestionNumber.ToString()) || questionToMarketResearchVm.Question.QuestionNumber == 0)
{
await _dataAccessQuestion.SetNumberOnQuestion(questionToMarketResearchVm);
}
var questionOption = new QuestionOption();
questionOption.QuestionOptionHeading = "Text";
await _dataAccessQuestion.AddQuestionOption(questionOption, questionToMarketResearchVm);
questionToMarketResearchVm.QuestionTypes = null;
questionToMarketResearchVm.Question.ActualQuestion = null;
ModelState.Clear();
return(View("Create", questionToMarketResearchVm));
}
default:
break;
}
//var mrId = questionToMarketResearchVm.CurrentMarketResearchId;
//ShowQuestionsForMarketResearch(questionToMarketResearchVm.CurrentMarketResearchId);
//return RedirectToAction("ShowQuestionsForMarketResearch", questionToMarketResearchVm.CurrentMarketResearchId);
//return Redirect("ShowQuestionsForMarketResearch", "Questions", questionToMarketResearchVm);
//return View("ShowQuestionsForMarketResearch", questionToMarketResearchVm);
return(RedirectToAction("ShowQuestionsForMarketResearch", new { marketResearchId = questionToMarketResearchVm.CurrentMarketResearchId }));
}
