private void initCombos()
{
if (this.hasFactor)
{
this.questionCombos = QuestionTypes.evaluationTypes();
}
else
{
this.questionCombos = QuestionTypes.questionTypes();
}
}
void Init()
{
this.Height = PAGE_SIZE_WITHOUT_QUESTIONS;
viewModel = new FactorSugesstionViewModel();
this.comboBoxQuestionTypes.ValueType = typeof(string);
this.comboBoxQuestionTypes.DataSource = QuestionTypes.evaluationTypesStrings();
textBoxTechnologyName.DataBindings.Add("Text", viewModel.requestObject, "technologyName", true, DataSourceUpdateMode.OnPropertyChanged);
textBoxTechnologyField.DataBindings.Add("Text", viewModel.requestObject, "technologyField", true, DataSourceUpdateMode.OnPropertyChanged);
textBoxEvaluationContext.DataBindings.Add("Text", viewModel.requestObject, "evalutionContext", true, DataSourceUpdateMode.OnPropertyChanged);
textBoxFacor.DataBindings.Add("Text", viewModel.requestObject, "factor", true, DataSourceUpdateMode.OnPropertyChanged);
}
public AddQuestionnaireViewModel(IQuestionFactory questionFactory, IAddableList <Questionnaire> list,
IMapper mapper, IEditViewModel <EventViewModel> editVm, IFestiClient client) : base(list, mapper, client)
{
DeleteSelectedCommand = new RelayCommand <QuestionViewModel>(DeleteSelected);
_questionFactory = questionFactory;
SelectedType = QuestionTypes.First();
AddQuestionCommand = new RelayCommand(AddQuestionAsync);
ShowDescriptionCommand = new RelayCommand(ShowDescription);
_questionnaire = new Questionnaire()
{
EventId = editVm.Entity.Id
};
}
public static QuestionTypes FromControlTypeID(long ControlTypeID)
{
QuestionTypes type = QuestionTypes.Text;
switch (ControlTypeID)
{
case 1:
type = QuestionTypes.Text;
break;
case 2:
type = QuestionTypes.MultiLineText;
break;
case 3:
type = QuestionTypes.Combo;
break;
case 4:
type = QuestionTypes.MultiSelect;
break;
case 5:
type = QuestionTypes.Radio;
break;
case 6:
type = QuestionTypes.CheckBox;
break;
case 7:
type = QuestionTypes.DateMask;
break;
case 8:
type = QuestionTypes.PhoneMask;
break;
case 9:
type = QuestionTypes.Text;
break;
case 10:
type = QuestionTypes.Text;
break;
}
return(type);
}
private void buttonOk_Click(object sender, EventArgs e)
{
if (checkFields())
{
if (this.viewModel.question.type == QuestionTypes.CHECK_BOX || this.viewModel.question.type == QuestionTypes.RADIO)
{
this.viewModel.question.choices = QuestionTypes.getDefaultChoices();
}
this.DialogResult = DialogResult.OK;
this.Close();
}
else
{
MessageBox.Show("Question text field cant be empty", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public EditQuestionnaireViewModel(QuestionFactory questionFactory, IQuestionRepository client, IEditViewModel <QuestionnaireViewModel> editVm)
{
_client = client;
_editVm = editVm;
_questionFactory = questionFactory;
_editVm.AddPredicate(CanExecute);
SelectedType = QuestionTypes.First();
Deleted = new List <QuestionViewModel>();
DeleteSelectedCommand = new RelayCommand <QuestionViewModel>(DeleteVM);
AddQuestionCommand = new RelayCommand(AddQuestion);
ShowDescriptionCommand = new RelayCommand(ShowDescription);
AddEntityCommand = new RelayCommand <IClosable>(SaveEntities, (el) => CanExecute());
QuestionViewModels = new ObservableCollection <QuestionViewModel>();
editVm.EntityViewModel.QuestionViewModels = new ObservableCollection <QuestionViewModel>();
GetQuestions();
}
/// <summary>
/// Creates and adds a new Dynamic Question to the area
/// based on information about the question.
/// </summary>
/// <param name="iQuestionID"></param>
/// <param name="QuestionText"></param>
/// <param name="Type"></param>
/// <param name="Sequence"></param>
/// <returns></returns>
public Question AddQuestion(int iQuestionID,
string QuestionText,
QuestionTypes Type,
int Sequence)
{
Question question = null;
question = QuestionFactory.CreateQuestion(Type,
Sequence,
iQuestionID,
QuestionText,
_parent);
_questions.Add(question);
question.Changed += new System.EventHandler(this.HandleQuestionChange);
return(question);
}
public async Task <JsonResult> Add(
[Required][FromRoute] FormType form,
[FromRoute] QuestionType parent,
[FromForm] string text,
[FromForm] int?order,
[FromForm] QuestionTypes type = QuestionTypes.Text)
{
if (form.OwnerId != User.Id)
{
throw new UnauthorizedAccessException();
}
QuestionType instance = null;
Database.Questions.Add(instance = new QuestionType());
instance.FormId = form.Id;
instance.Type = type;
instance.Text = text;
if (parent != null)
{
instance.ParentId = parent.Id;
}
if (order.HasValue)
{
instance.Order = order.Value;
}
else
{
if (instance.ParentId.HasValue)
{
instance.Order = instance.Parent.Children.Count();
}
else
{
instance.Order = Database.Questions.Count(x => x.FormId.Equals(form.Id));
}
}
await Database.SaveChangesAsync();
return(new ApiResult()
{
Result = instance
});
}
public QuestionFilter(string firstName, string middleName, string lastName,
DateTime? dateFrom, DateTime? dateTo, QuestionTypes type,int userId,bool canAnswer,
string sortExpression, bool sortAscending, int maxResults, int firstResult)
{
_firstName = firstName;
_middleName = middleName;
_lastName = lastName;
this.dateFrom = dateFrom;
this.dateTo = dateTo;
this.type = type;
this.userId = userId;
SortExpression = sortExpression;
SortAscending = sortAscending;
MaxResults = maxResults;
FirstResult = firstResult;
this.canAnswer = canAnswer;
}
public Candidate(string candidateId, string questionId, string questionRequirement, QuestionTypes questionType,
string solution, string testQuery, bool requireSort, bool checkColumnName, bool checkDistinct,
bool relatedSchema, List <string> illustration, double point)
{
CandidateId = candidateId;
QuestionId = questionId;
QuestionRequirement = questionRequirement;
QuestionType = questionType;
Solution = solution;
TestQuery = testQuery;
RequireSort = requireSort;
CheckColumnName = checkColumnName;
CheckDistinct = checkDistinct;
RelatedSchema = relatedSchema;
Illustration = illustration;
Point = point;
}
public static Question CreateQuestion(QuestionTypes type, int Sequence, int iQuestionID, string Text, Control parent)
{
Question question = null;
switch (type)
{
case (QuestionTypes.CheckBox):
{
question = new CheckBoxQuestion(iQuestionID, Sequence, Text, parent);
break;
}
case (QuestionTypes.Combo):
{
question = new ComboQuestion(iQuestionID, Sequence, Text, parent);
break;
}
case (QuestionTypes.MultiLineText):
{
question = new MultiLineTextQuestion(iQuestionID, Sequence, Text, parent);
break;
}
case (QuestionTypes.MultiSelect):
{
question = new MultiSelectQuestion(iQuestionID, Sequence, Text, parent);
break;
}
case (QuestionTypes.Radio):
{
question = new RadioQuestion(iQuestionID, Sequence, Text, parent);
break;
}
case (QuestionTypes.Text):
{
question = new TextQuestion(iQuestionID, Sequence, Text, parent);
break;
}
}
return(question);
}
public frmQuestion(Panel parent, int sequence, QuestionTypes questionType)
{
_panel = parent;
_seq = sequence;
//
// Required for Windows Form Designer support
//
InitializeComponent();
switch (questionType)
{
case QuestionTypes.CheckBox:
_cboQuestionType.Text = "CheckBox";
break;
case QuestionTypes.Combo:
_cboQuestionType.Text = "Combobox";
break;
case QuestionTypes.DateMask:
_cboQuestionType.Text = "Date";
break;
case QuestionTypes.MultiLineText:
_cboQuestionType.Text = "Multiline Text";
break;
case QuestionTypes.MultiSelect:
_cboQuestionType.Text = "Multi-Select";
break;
case QuestionTypes.PhoneMask:
_cboQuestionType.Text = "Phone";
break;
case QuestionTypes.Radio:
_cboQuestionType.Text = "Radio";
break;
case QuestionTypes.Text:
_cboQuestionType.Text = "Text";
break;
}
}
public async Task GetQuestionTypeAsync_QuestionTypeIsReturned()
{
// Arrange
var recId = 5;
var expectedQuestionType = new QuestionTypes()
{
QuestionTypeId = recId, QuestionTypeName = "Type 5"
};
await db.AddRangeAsync(expectedQuestionType);
await db.SaveChangesAsync();
// Act
await service.Get(recId);
// Assert
var actualQuestionType = await db.QuestionTypes.FindAsync(recId);
Assert.Equal(expectedQuestionType, actualQuestionType);
}
public static Question CreateQuestion(DCAnalyticsObject parent, QuestionTypes qtype)
{
Question question = null;
switch (qtype)
{
case QuestionTypes.Closed:
question = new ClosedQuestion(parent);
break;
case QuestionTypes.MultipleChoice:
question = new MultipleChoiceQuestion(parent);
break;
case QuestionTypes.Open:
question = new OpenQuestion(parent);
break;
case QuestionTypes.Map:
question = new MapQuestion(parent);
break;
case QuestionTypes.Location:
question = new LocationQuestion(parent);
break;
case QuestionTypes.Other:
question = new OtherQuestion(parent);
break;
}
if (question != null)
{
question.QuestionType = qtype;
}
return(question);
}
public override void ReadJson(JObject obj)
{
base.ReadJson(obj);
if (obj["Name"] != null && ((JValue)obj["Name"]).Value != null)
{
Name = ((JValue)obj["Name"]).Value.ToString();
}
if (obj["Deleted"] != null && ((JValue)obj["Deleted"]).Value != null)
{
Deleted = bool.Parse(((JValue)obj["Deleted"]).Value.ToString());
}
if (obj["Questions"] != null)
{
JArray questionsObjs = JArray.FromObject(obj["Questions"]);
if (questionsObjs != null)
{
this.Questions.Clear();
foreach (JObject cobj in questionsObjs)
{
QuestionTypes questionType = QuestionTypes.None;
if (cobj["QuestionType"] != null && ((JValue)cobj["QuestionType"]).Value != null)
{
questionType = (QuestionTypes)Enum.Parse(typeof(QuestionTypes), ((JValue)cobj["QuestionType"]).Value.ToString());
}
Question question = Questions.Add(questionType);
question.ReadJson(cobj);
}
}
}
ObjectState = ObjectStates.None;
SetOriginal();
}
private void QuestionListBox_SelectedValueChanged(object sender, EventArgs e)
{
foreach (var ctrl in Controls.OfType <UserControl>().ToList())
{
Controls.Remove(ctrl);
}
if (QuestionListBox.SelectedIndex != -1)
{
using (ForumContainer container = new ForumContainer())
{
var selectedValue = Convert.ToInt32(QuestionListBox.SelectedValue.ToString());
QuestionSet = container.QuestionSet.FirstOrDefault(x => x.QuestionId == selectedValue);
QuestionLabel.Text = QuestionSet.QuestionText;
QuestType = QuestionTypes.GetQuestionType(QuestionSet);
var question = QuestType.getUserControl();
QuestionTypes.SetQuest(question, QuestionSet, false);
Controls.Add(question);
}
}
}
/// <summary>
/// Set type of the question
/// </summary>
/// <param name="type">Type.</param>
public void SetQuestionType(QuestionTypes type)
{
QuestionType = type;
}
public static Question CreateDomainQuestion(string text, int stage, int points, QuestionTypes questionType, int testId)
{
return(new Question
{
Text = text,
Stage = stage,
Points = points,
QuestionType = questionType,
TestId = testId,
});
}
private void Init(Question question)
{
switch (question.type)
{
case QuestionTypes.CHECK_BOX:
counts = new int[question.choices.Count()];
choices = question.choices.ToList();
foreach (Answer answer in question.answers)
{
int j = 0;
foreach (String choice in question.choices)
{
if (answer.chValues.Contains(j))
{
counts[j]++;
}
j++;
}
}
break;
case QuestionTypes.RADIO:
counts = new int[question.choices.Count()];
choices = question.choices.ToList();
foreach (Answer answer in question.answers)
{
counts[answer.value - 1]++;
}
break;
case QuestionTypes.LIKERT_3:
counts = new int[3];
choices = QuestionTypes.likertStrings_3();
foreach (Answer answer in question.answers)
{
counts[answer.value - 1]++;
}
break;
case QuestionTypes.LIKERT_5:
counts = new int[5];
choices = QuestionTypes.likertStrings_5();
foreach (Answer answer in question.answers)
{
counts[answer.value - 1]++;
}
break;
case QuestionTypes.LIKERT_7:
counts = new int[7];
choices = QuestionTypes.likertStrings_7();
foreach (Answer answer in question.answers)
{
counts[answer.value - 1]++;
}
break;
}
labelQuestion.DataBindings.Add("Text", question, "text", true, DataSourceUpdateMode.OnPropertyChanged);
SeriesCollection series = new SeriesCollection();
int i = 0;
foreach (String choice in choices)
{
series.Add(new PieSeries {
Title = choices.ElementAt(i), Values = new ChartValues <int> {
counts[i]
}, LabelPoint = labelPoint, DataLabels = false
});
i++;
}
pieChart.Series = series;
pieChart.Visible = true;
pieChart.LegendLocation = LegendLocation.Right;
}
public string GetQTypeValue(QuestionTypes QuestionTyp)
{
int qTypeValue = (int)QuestionTyp;
return(qTypeValue.ToString());
}
public override string ToString()
{
return(QuestionTypes.getStringValue(value));
}
public void SetQuestionType(QuestionTypes qt)
{
questionType = qt;
}
public Question(QuestionTypes type, string correctAnswer)
{
Type = type;
CorrectAnswer = correctAnswer;
}
public Question(QuestionTypes type, List <string> correctAnswerList)
{
Type = type;
CorrectAnswerList = new List <string>();
}
public static DataCollectionObject Create(DataCollectionObectTypes type, DCAnalyticsObject parent, QuestionTypes questionType = QuestionTypes.None)
{
DataCollectionObject dataCollectionObject = null;
switch (type)
{
case DataCollectionObectTypes.Questionaire:
dataCollectionObject = new Questionaire(parent);
dataCollectionObject.CollectionObjectType = DataCollectionObectTypes.Questionaire;
break;
case DataCollectionObectTypes.Section:
dataCollectionObject = new Section(parent);
dataCollectionObject.CollectionObjectType = DataCollectionObectTypes.Section;
break;
case DataCollectionObectTypes.Question:
dataCollectionObject = CreateQuestion(parent, questionType);
dataCollectionObject.CollectionObjectType = DataCollectionObectTypes.Question;
break;
}
return(dataCollectionObject);
}
public QuestionBank(QuestionTypes questionType)
{
_questionType = questionType;
}
public ITextStudyMaterial GetQuestionBank(int Id, QuestionTypes questionType)
{
return(new QuestionBank(questionType));
}
public async Task <IActionResult> StartTest()
{
Dictionary <string, string> dictReq = Request.Form.ToDictionary(x => x.Key, x => x.Value.ToString());
string submitButtonKey = dictReq.Keys.Single(x => x.Contains("SubmitButton"));
string submitButtonValue = dictReq[submitButtonKey];
int topicId = int.Parse(dictReq["TopicId"]);
int testId = int.Parse(dictReq["TestId"]);
int userId = int.Parse(dictReq["UserId"]);
DomainTest test = await _testManager.GetTestByIdAsync(testId);
DomainUserTest userTest = await _testManager.GetUserTestAsync(userId, testId);
if (userTest.Status == TestStatus.Finished)
{
return(PartialView("_EndTest", new EndTestModel {
TopicId = topicId
})); // to redirect from ajax post
}
int stagesCount = int.Parse(dictReq["StagesCount"]);
int currQuestionId = int.Parse(dictReq["CurrQuestionId"]);
int currQuestionStage = int.Parse(dictReq["CurrQuestionStage"]);
QuestionTypes currQuestionType = (QuestionTypes)Enum.Parse(typeof(QuestionTypes), dictReq["CurrQuestionType"]);
List <int> userQuestionIds = dictReq["UserQuestionIds"].Split(",").Select(x => int.Parse(x)).ToList();
var answerKeySubStr = "AnswerId";
var currQuestionImageLocation = string.Empty;
ViewData["TopicId"] = topicId;
int secondsLeft = test.Minutes * 60 - Convert.ToInt32(Math.Abs((userTest.StartTime - DateTime.Now).TotalSeconds));
if (secondsLeft <= 0)
{
await FinishTest(userId, testId);
await TryFinishTopicAndIfTopicIsFinishedSendEmail(userId, topicId);
return(PartialView("_EndTest", new EndTestModel {
TopicId = topicId
})); // to redirect from ajax post
}
if (currQuestionType == QuestionTypes.Option)
{
List <string> answersKeys = dictReq.Keys.Where(x => x.Contains(answerKeySubStr)).ToList();
foreach (string answerKey in answersKeys)
{
int answerId = int.Parse(answerKey.Substring(answerKeySubStr.Length));
bool isValid = dictReq[answerKey].Contains("true") ? true : false;
await _answersManager.UpdateUserAnswerValidAsync(userId, answerId, isValid);
}
}
else if (currQuestionType == QuestionTypes.Text)
{
string answerKey = dictReq.Keys.First(x => x.Contains(answerKeySubStr));
int answerId = int.Parse(answerKey.Substring(answerKeySubStr.Length));
string userAnswerText = dictReq[answerKey];
await _answersManager.UpdateUserAnswerTextAsync(userId, answerId, userAnswerText);
}
ViewData["SubmitButton_1"] = "Next";
ViewData["SubmitButton_2"] = "Back";
SetSubmitButtonsTextAndChangeCurrQuestionStage(submitButtonValue, stagesCount, ref currQuestionStage);
if (submitButtonValue == "Finish" && currQuestionStage == stagesCount)
{
await FinishTest(userId, testId);
await TryFinishTopicAndIfTopicIsFinishedSendEmail(userId, topicId);
return(PartialView("_EndTest", new EndTestModel {
TopicId = topicId
}));
}
DomainQuestion currQuestion = await _questionManager.GetQuestionByIdAsync(userQuestionIds[currQuestionStage - 1]);
List <UserAnswerModel> currQuestionUserAnswers = (await _answersManager.GetUserAnswersByQuestionIdAsync(userId, currQuestion.Id))
.Select(x => _mapper.Map <UserAnswerModel>(x))
.ToList();
if (!string.IsNullOrWhiteSpace(currQuestion.ImageFullName))
{
currQuestionImageLocation = $"/{WebExtensions.ImagesFolderName}/" + Path.GetFileName(currQuestion.ImageFullName);
}
var startTest = new StartTestModel()
{
TopicId = topicId,
TestId = testId,
UserId = userId,
StagesCount = stagesCount,
SecondsLeft = secondsLeft,
UserQuestionIds = dictReq["UserQuestionIds"],
CurrQuestionId = currQuestion.Id,
CurrQuestionText = currQuestion.Text,
CurrQuestionStage = currQuestion.Stage,
CurrQuestionType = currQuestion.QuestionType,
CurrQuestionUserAnswers = currQuestionUserAnswers,
CurrQuestionImageLocation = currQuestionImageLocation
};
return(PartialView("_StartTest", startTest));
}
public virtual int Update(QuestionTypes dataSet)
{
return(this.Adapter.Update(dataSet, "QuestionTypes"));
}
