public void OnPost()
{
Vraag vraag = new Vraag();
string temp = Request.Form[nameof(Choice)];
int inttemp = Convert.ToInt32(temp);
vraag.SelectOne(inttemp);
string isChecked = Request.Form[nameof(IsChecked)];
string selected = Request.Form[nameof(Vak)];
string antwoord = Request.Form[nameof(Antwoord)];
if (vraag.isInProgress)
{
if (isChecked != "false")
{
vraag.AndwoordText = antwoord;
vraag.InsertFaq(selected);
vraag.Delete();
}
else
{
vraag.Delete();
}
}
else
{
vraag.isInProgress = true;
vraag.Update();
}
OnGet();
//TODO:: Peercoach nummer aan toevoegen
}
public QuestionViewModel(Vraag v, Inspectieformulier inspec)
{
_question = v;
InspectionFormID = inspec.InspectieformulierID;
Changed = false;
if (_question.VraagMogelijkAntwoord.Count() > 0)
{
AddPossibleAnwsersCreate();
}
else
{
AddPossibleAnwsers();
}
if (_question.AfbeeldingURL != null)
{
WebRequest webRequest = WebRequest.CreateDefault(new Uri("http://" + _question.AfbeeldingURL, UriKind.Absolute));
webRequest.ContentType = "image/jpeg";
WebResponse webResponse = webRequest.GetResponse();
BitmapImage image = new BitmapImage();
image.CreateOptions = BitmapCreateOptions.None;
image.CacheOption = BitmapCacheOption.OnLoad;
image.BeginInit();
image.StreamSource = webResponse.GetResponseStream();
image.EndInit();
Image = image;
}
ImageButton = new RelayCommand(SelectImage);
}
public void FindVraagCorrect()
{
var vraag = new Vraag
{
Id = 1,
MaxScoreVraag = 10,
//TypeVraag = TypeVraag.Meerkeuze,
TypeVraagId = 1,
VraagStelling = "Dit is de stelling van de vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden"
};
//Arrange
var unitOfWork = new Mock <IRondeVraagUnitOfWork>();
unitOfWork.Setup(x => x.VraagRepository.GetById(1)).Returns(vraag);
var vraagService = new VraagService(unitOfWork.Object);
//Assert
var response = vraagService.FindVraag(1);
Assert.That(response.DTO.Id, Is.EqualTo(vraag.Id));
Assert.That(response.DTO.JsonCorrecteAntwoord, Is.EqualTo(vraag.JsonCorrecteAntwoord));
Assert.That(response.DTO.JsonMogelijkeAntwoorden, Is.EqualTo(vraag.JsonMogelijkeAntwoorden));
Assert.That(response.DTO.MaxScoreVraag, Is.EqualTo(vraag.MaxScoreVraag));
Assert.That(response.DTO.TypeVraagId, Is.EqualTo(vraag.TypeVraagId));
Assert.That(response.DTO.VraagStelling, Is.EqualTo(vraag.VraagStelling));
}
public void UpdateVraagNull()
{
var vraag = new Vraag
{
Id = 1,
MaxScoreVraag = 10,
//TypeVraag = TypeVraag.Meerkeuze,
TypeVraagId = 1,
VraagStelling = "Dit is de stelling van de vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden"
};
//Arrange
var unitOfWork = new Mock <IRondeVraagUnitOfWork>();
unitOfWork.Setup(x => x.VraagRepository.Update(It.IsAny <Vraag>())).Returns(vraag);
var vraagService = new VraagService(unitOfWork.Object);
//Assert
var response = vraagService.Update(null);
Assert.IsTrue(response.DidError);
Assert.IsNull(response.DTO);
}
public bool addQuest(Vraag newVraag, int id)
{
//id is de id van de doellocatie
DoelLocatie doel = context.DoelLocaties.Include(r => r.Vragen).ThenInclude(y => y.Antwoorden).Where(r => r.Id == id).Single <DoelLocatie>();
if (doel != null && newVraag != null)
{
if (doel.Vragen != null)
{
//nieuwe vraag opslaan
doel.Vragen.Add(newVraag);
}
else
{
doel.Vragen = new List <Vraag>();
doel.Vragen.Add(newVraag);
}
context.SaveChanges();
return(true);
}
else
{
//geen vraag
return(false);
}
}
public void AddQuestion()
{
if (Valid())
{
ErrorMessage = null;
int lijstId = 0;
if (_oldPage.NewVragenlijst.Id != 0)
{
lijstId = _oldPage.NewVragenlijst.Id;
}
var tmp = new Vraag()
{
TypeNaam = SelectedQuestionType.Naam,
VragenlijstId = lijstId,
Vragenlijst = _oldPage.NewVragenlijst.VragenlijstModel,
Omschrijving = QuestionName,
Vraagtype = SelectedQuestionType,
Vraag1 = GenerateVraagJSON()
};
_oldPage.NewVragenlijst.Vragen.Add(tmp);
SelectedQuestionType = null;
QuestionName = null;
Antwoord1 = null;
Antwoord2 = null;
Antwoord3 = null;
Antwoord4 = null;
Antwoord5 = null;
Antwoord6 = null;
Antwoord7 = null;
Antwoord8 = null;
Antwoorden.Clear();
}
}
public bool delQuest(int id, int vid)
{
//id is de id van de doellocatie
DoelLocatie doel = null;
Vraag vraag = null;
List <Antwoord> antwoorden = null;
try
{
doel = context.DoelLocaties.Include(vr => vr.Vragen).ThenInclude(antw => antw.Antwoorden).Where(whr => whr.Id == id).Single <DoelLocatie>();
vraag = doel.Vragen.Where(r => r.Id == vid).Single <Vraag>();
antwoorden = vraag.Antwoorden;
}
catch
{
Console.WriteLine("Geen Content");
}
if (vraag != null)
{
context.Antwoorden.RemoveRange(antwoorden);
context.Vragen.Remove(vraag);
context.SaveChanges();
return(true);
}
else
{
return(false);
}
}
public QueryFeedback AddVraagBijStudentenhuis(int studentenhuisID, Vraag devraag)
{
QueryFeedback feedback = new QueryFeedback();
try
{
using (SqlConnection conn = new SqlConnection(sqlcon.connectionstring()))
{
using (SqlCommand cmd = new SqlCommand())
{
string qry = $"INSERT INTO Table_Vraag Values(@niewenaamhuis,@devraag,@hetantwoord)";
cmd.CommandText = qry;
cmd.Parameters.AddWithValue("@niewenaamhuis", studentenhuisID);
cmd.Parameters.AddWithValue("@devraag", devraag.DeVraag);
cmd.Parameters.AddWithValue("@hetantwoord", devraag.Antwoord);
cmd.Connection = conn;
conn.Open();
cmd.ExecuteNonQuery();
feedback.Gelukt = true;
return(feedback);
}
}
}
catch (Exception ex)
{
feedback.Gelukt = false;
feedback.Message = ex.Message;
return(feedback);
};
}
public Vraag getALocQuest(int id)
{
//id is de doellocatie id
//vragen ophalen
DoelLocatie doel = context.DoelLocaties.Include(r => r.Vragen).ThenInclude(y => y.Antwoorden).Where(r => r.Id == id).Single <DoelLocatie>();
List <Vraag> vragen = doel.Vragen;
//aantal vragen
int vragenAmount = vragen.Count;
//random vraag positie bepalen
Random rand = new Random();
int randomVraagPos = rand.Next(0, vragenAmount);
Vraag vraag = vragen[randomVraagPos];
if (vraag != null)
{
return(vraag);
}
else
{
return(null);
}
}
public async Task <IActionResult> Faq(string vraag, string email)
{
if (!string.IsNullOrEmpty(email) && !string.IsNullOrEmpty(vraag))
{
email = email.ToLower();
var contact = await _context.Contacten
.FirstOrDefaultAsync(c => c.EmailAdres == email);
if (contact == null)
{
contact = new Contact
{
EmailAdres = email
};
_context.Add(contact);
await _context.SaveChangesAsync();
}
var nieuweVraag = new Vraag {
Tekst = vraag, VraagstellerId = contact.Id
};
_context.Add(nieuweVraag);
await _context.SaveChangesAsync();
ViewData["Message"] = "Dank je wel voor je vraag. We beantwoorden hem zo snel mogelijk.";
return(await Faq());
}
return(RedirectToAction(nameof(Faq)));
}
public IActionResult MakeNewStudentenhuis(string naamstudentenhuis, string devraag, string hetantwoord)
{
QueryFeedback feedback = studentenhuislogic.MakeNewStudentenhuis(naamstudentenhuis);
Vraag niewevraagvoorhuis = new Vraag {
DeVraag = devraag, Antwoord = hetantwoord
};
if (feedback.Gelukt)
{
StudentenHuis niewaangemaaktstudentenhuis = studentenhuislogic.GetStudentenhuisIdByStudentenhuisName(naamstudentenhuis);
QueryFeedback feedback2 = studentenhuislogic.AddVraagBijStudentenhuis(niewaangemaaktstudentenhuis.StudentenhuisID, niewevraagvoorhuis);
if (feedback2.Gelukt)
{
return(RedirectToAction("index", "Studentenhuis"));
}
else
{
return(Content($"het toevoegen van de vraag is niet gelukt omdat {feedback2.Message}"));
}
}
else
{
return(Content($"Het is niet gelukt omdat: {feedback.Message}"));
}
}
public ActionResult DeleteConfirmed(int id)
{
Vraag vraag = db.vragen.Find(id);
db.vragen.Remove(vraag);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void AddQuestionToInspectionForm(Vraag question)
{
using (FestispecContext context = new FestispecContext())
{
context.Vraag.Add(question);
context.SaveChanges();
}
}
public void DeleteQuestion(Vraag question)
{
using (FestispecContext context = new FestispecContext())
{
context.Vraag.Remove(question);
context.SaveChanges();
}
}
public ActionResult VerwijderVraag(int nummertje)
{
Vraag vraag = db.vragen.Find(nummertje);
db.vragen.Remove(vraag);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void AddVraag(int id, Vraag vragen)
{
Vraag vraag = new Vraag();
vraag.Naam = vragen.Naam;
vraag.OpdrachtId = id;
vraag.AntwoordCollection = vragen.AntwoordCollection;
db.Vraag.Add(vraag);
}
public int AddQuestion(Vraag question)
{
using (FestispecContext context = new FestispecContext())
{
context.Vraag.Add(question);
context.SaveChanges();
return(context.Vraag.Max(q => q.VraagID));
}
}
public ActionResult VerwijderVraagExamen(int examenid, int vraagid)
{
Vraag vraag = db.vragen.Find(vraagid);
Examen examen = db.examens.Find(examenid);
examen.questions.Remove(vraag);
db.SaveChanges();
return(RedirectToAction("ManageExamen", new { nummertje = examen.ExamenId }));
}
public static void RemoveVraagById(int id)
{
Vraag vraag = new Vraag()
{
Id = id
};
RemoveVraag(vraag);
}
public ActionResult Edit([Bind(Include = "Id,naam,voornaam,adres,gemeente,type,content,date")] Vraag vraag)
{
if (ModelState.IsValid)
{
db.Entry(vraag).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vraag));
}
public Vraag GetVraagBijStudentenhuis(int studentenID)
{
Vraag devraag = new Vraag
{
DeVraag = "wat is de hoofdstad van nederland",
Antwoord = "Amsterdam"
};
return(devraag);
}
public static void AddVraag(Vraag vraag)
{
using (var context = new FestiSpecDBEntities())
{
context.Vraagtype.Attach(vraag.Vraagtype);
context.Vragenlijst.Attach(vraag.Vragenlijst);
context.Vraag.Add(vraag);
context.SaveChanges();
}
}
public int UpdateQuestion(Vraag question)
{
using (FestispecContext context = new FestispecContext())
{
Vraag target = context.Vraag.Where(v => v.VraagID == question.VraagID).FirstOrDefault();
context.Entry(target).CurrentValues.SetValues(question);
context.SaveChanges();
return(1);
}
}
public ActionResult Edit([Bind(Include = "VraagID,VraagTekst,Antwoord,Toelichting")] Vraag vraag)
{
if (ModelState.IsValid)
{
db.Entry(vraag).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vraag));
}
public ActionResult Create([Bind(Include = "Id,naam,voornaam,adres,gemeente,type,content,date")] Vraag vraag)
{
if (ModelState.IsValid)
{
db.Vraags.Add(vraag);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vraag));
}
private int AddPage(PdfDocument document, RapportageRepository repo, Account account, int jobId, List <Vraag> questions, int latestQuestion)
{
PdfPage page = document.AddPage();
XGraphics gfx = XGraphics.FromPdfPage(page);
XTextFormatter txtFormatter = new XTextFormatter(gfx);
// Fonts
XFont normalFont = new XFont("Arial", 14, XFontStyle.Regular);
XFont boldFont = new XFont("Arial", 14, XFontStyle.Bold);
XFont titleFont = new XFont("Arial", 20, XFontStyle.Bold);
XFont italicFont = new XFont("Arial", 14, XFontStyle.Italic);
// Inspecteur
txtFormatter.DrawString($"Inspecteur: {account.Voornaam} {account.Tussenvoegsel} {account.Achternaam}", titleFont, XBrushes.Black, new XRect(20, 20, page.Width, page.Height), XStringFormats.TopLeft);
// Vragen
int currentY = 60;
int currentQuestion = latestQuestion;
int sizeLeft = 2000;
while ((currentQuestion < questions.Count && sizeLeft > 200))
{
Vraag question = questions[currentQuestion];
int textHeight = txtFormatter.DrawString($"Vraag {currentQuestion + 1}: {question.Vraagstelling}", boldFont, XBrushes.Black, new XRect(20, currentY, page.Width, page.Height), XStringFormats.TopLeft);
currentY += textHeight;
List <Antwoorden> answers = question.Antwoorden.Where(x => x.InspecteurID == account.AccountID).ToList();
switch (question.Vraagtype)
{
case "tv":
currentY = DrawTableQuestionAnswer(gfx, page, answers, question.VraagMogelijkAntwoord.Count, italicFont, currentY);
break;
case "av":
currentY = DrawImageQuestionAnswer(gfx, page, answers, currentY);
break;
default:
currentY = DrawQuestionAnswer(txtFormatter, page, answers, italicFont, currentY);
break;
}
sizeLeft -= currentY;
currentQuestion++;
}
return(currentQuestion);
}
public void Update()
{
//Act
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "Testing_InMemoryDatabase7")
.Options;
Vraag responseVraagUpdated = null;
var vraag = new Vraag
{
MaxScoreVraag = 10,
TypeVraagId = 1,
VraagStelling = "Dit is de stelling van de vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden"
};
var updateVraag = new Vraag
{
Id = 1,
MaxScoreVraag = 15,
TypeVraagId = 2,
VraagStelling = "Dit is de stelling van een andere vraag",
JsonCorrecteAntwoord = "JsonCorrecteAntwoord2",
JsonMogelijkeAntwoorden = "JsonMogelijkeAntwoorden2"
};
//Arrange
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Vraag>(context);
var responseAdd = repository.Add(vraag);
repository.SaveChanges();
}
using (var context = new DataContext(options))
{
var repository = new SQLRepository <Vraag>(context);
responseVraagUpdated = repository.Update(updateVraag);
repository.SaveChanges();
}
//Assert
using (var context = new DataContext(options))
{
Assert.That(updateVraag.Id, Is.EqualTo(responseVraagUpdated.Id));
Assert.That(updateVraag.JsonCorrecteAntwoord, Is.EqualTo(responseVraagUpdated.JsonCorrecteAntwoord));
Assert.That(updateVraag.JsonMogelijkeAntwoorden, Is.EqualTo(responseVraagUpdated.JsonMogelijkeAntwoorden));
Assert.That(updateVraag.MaxScoreVraag, Is.EqualTo(responseVraagUpdated.MaxScoreVraag));
Assert.That(updateVraag.TypeVraagId, Is.EqualTo(responseVraagUpdated.TypeVraagId));
Assert.That(updateVraag.VraagStelling, Is.EqualTo(responseVraagUpdated.VraagStelling));
}
}
public ActionResult Create([Bind(Include = "VraagID,VraagTekst,Antwoord,Toelichting")] Vraag vraag)
{
if (ModelState.IsValid)
{
db.vragen.Add(vraag);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vraag));
}
private void CreateNewQuestion()
{
Vraag V = new Vraag();
V.Name = _VraagNaam;
V.QuizId = _QuizId;
V.Category = "Leeg";
try
{
DbContext.Vragen.Add(V);
DbContext.SaveChanges();
QuestionsViewModel QVM = new QuestionsViewModel(V);
this.Questions.Add(QVM);
RaisePropertyChanged("Questions");
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
// throw raise;
}
}
this.VraagName = "";
var QuestionList = DbContext.Vragen.ToList().Select(Q => new QuestionsViewModel(Q));
QuestionList = new ObservableCollection<QuestionsViewModel>(QuestionList);
}
public QuestionsViewModel()
{
this._Question = new Vraag();
}
public QuestionsViewModel(Vraag _Question)
{
this._Question = _Question;
}
