330 lines
8.9 KiB
Go
330 lines
8.9 KiB
Go
package server
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"html/template"
|
|
"log"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"streifling.com/jason/sicherheitsunterweisung/packages/db"
|
|
"streifling.com/jason/sicherheitsunterweisung/packages/types"
|
|
)
|
|
|
|
func displayTable(w http.ResponseWriter, db *db.DB) {
|
|
bs, err := db.GetAllOverviewTableData()
|
|
if err != nil {
|
|
http.Error(w, "displayTable: *DB.GetAllOverviewTableData(): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
}
|
|
template.Must(template.ParseFiles("templates/table.html")).ExecuteTemplate(w, "content", bs)
|
|
}
|
|
|
|
func HandleInternalLogin(ss *[]*types.Session, cs chan<- *types.Session, db *db.DB) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
instructors, err := db.GetInstructors()
|
|
if err != nil {
|
|
http.Error(w, "HandleInternalLogin: db.GetInstructors(): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
log.Panicln(err)
|
|
}
|
|
|
|
for _, i := range instructors {
|
|
if r.PostFormValue("login") == fmt.Sprint(i.ID) {
|
|
session := new(types.Session)
|
|
session.ID = uuid.New()
|
|
session.Briefing = new(types.Briefing)
|
|
session.Briefing.InstructorID = i.ID
|
|
(*ss) = append((*ss), session)
|
|
cs <- session
|
|
|
|
displayTable(w, db)
|
|
return
|
|
}
|
|
}
|
|
template.Must(template.ParseFiles("templates/login.html")).ExecuteTemplate(w, "content", nil)
|
|
}
|
|
}
|
|
|
|
func HandleSearch(db *db.DB) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
bs, err := db.GetOverviewTableDataByName(r.PostFormValue("search"))
|
|
if err != nil {
|
|
http.Error(w, "DisplayResults: db.ReadByName(r.PostFormValue()): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
}
|
|
template.Must(template.ParseFiles("templates/table.html")).ExecuteTemplate(w, "rows", bs)
|
|
}
|
|
}
|
|
|
|
func HandleNewBriefing(s *types.Session) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
type httpData struct {
|
|
SessionID uuid.UUID
|
|
}
|
|
|
|
data := new(httpData)
|
|
data.SessionID = s.ID
|
|
|
|
template.Must(template.ParseFiles("templates/briefing.html")).ExecuteTemplate(w, "content", data)
|
|
}
|
|
}
|
|
|
|
func generateLogin() (string, error) {
|
|
bs := make([]byte, 4)
|
|
|
|
if _, err := rand.Read(bs); err != nil {
|
|
return "", fmt.Errorf("generateLogin: rand.Read(bs): %v\n", err)
|
|
}
|
|
|
|
return hex.EncodeToString(bs), nil
|
|
}
|
|
|
|
func HandleNewParticipant(s *types.Session, cp chan<- *types.Participant) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
type httpData struct {
|
|
SessionID uuid.UUID
|
|
Login string
|
|
}
|
|
|
|
data := new(httpData)
|
|
var err error
|
|
|
|
p := new(types.Participant)
|
|
p.Login, err = generateLogin()
|
|
if err != nil {
|
|
http.Error(w, "AddParticipant: generateLogin(): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
}
|
|
s.Participants = append(s.Participants, p)
|
|
cp <- p
|
|
|
|
data.SessionID = s.ID
|
|
data.Login = p.Login
|
|
if err != nil {
|
|
http.Error(w, "AddParticipant: generateLogin(): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
}
|
|
|
|
template.Must(template.ParseFiles("templates/briefing.html")).ExecuteTemplate(w, "new", data)
|
|
}
|
|
}
|
|
|
|
func HandleBriefingForm(s *types.Session, db *db.DB) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
now := time.Now()
|
|
var err error
|
|
|
|
s.Briefing.Date = now.Format("2006-01-02")
|
|
s.Briefing.Time = now.Format("15:04:05")
|
|
s.Briefing.Location = r.PostFormValue("location")
|
|
s.Briefing.DocumentName = r.PostFormValue("document")
|
|
s.Briefing.AsOf = r.PostFormValue("as-of")
|
|
|
|
err = db.WriteBriefing(s.Briefing)
|
|
if err != nil {
|
|
http.Error(w, "SubmitBriefingForm: db.WriteBriefing(): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
log.Panicln(err)
|
|
}
|
|
|
|
displayTable(w, db)
|
|
}
|
|
}
|
|
|
|
// TODO: Make it only serve one purpose
|
|
func findCorrectLogin(l string, ss *[]*types.Session) (*types.Session, *types.Participant, bool) {
|
|
for _, session := range *ss {
|
|
for _, p := range session.Participants {
|
|
if l == p.Login {
|
|
return session, p, true
|
|
}
|
|
}
|
|
}
|
|
return nil, nil, false
|
|
}
|
|
|
|
func newParticipant(l string) (*types.Participant, error) {
|
|
var err error
|
|
p := new(types.Participant)
|
|
|
|
p.ID, err = strconv.ParseInt(l, 10, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("newParticipant: strconv.Atoi(idString): %v\n", err)
|
|
}
|
|
|
|
return p, nil
|
|
}
|
|
|
|
func HandleExternalLogin(ss *[]*types.Session) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
type httpData struct {
|
|
SessionID uuid.UUID
|
|
Login string
|
|
}
|
|
|
|
session, participant, loginCorrect := findCorrectLogin(r.PostFormValue("login"), ss)
|
|
if loginCorrect {
|
|
data := new(httpData)
|
|
data.SessionID = session.ID
|
|
data.Login = participant.Login
|
|
|
|
template.Must(template.ParseFiles("templates/participant.html")).ExecuteTemplate(w, "content", data)
|
|
} else {
|
|
template.Must(template.ParseFiles("templates/login.html")).ExecuteTemplate(w, "content", nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleGivenAnswer(s *types.Session, p *types.Participant, i int64, r *http.Request, db *db.DB) error {
|
|
answer, err := strconv.Atoi(r.PostFormValue("answer"))
|
|
if err != nil {
|
|
return fmt.Errorf("handleGivenAnswer: strconv.Atoi(): %v\n", err)
|
|
}
|
|
|
|
if err := db.WriteGivenAnswer(s.Briefing, p, &s.Questions[i], answer); err != nil {
|
|
return fmt.Errorf("handleGivenAnswer: db.WriteGivenAnswer(): %v\n", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func HandleParticipant(s *types.Session, p *types.Participant, sq *[]types.Question, db *db.DB) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
type httpData struct {
|
|
SessionID uuid.UUID
|
|
Login string
|
|
Question types.Question
|
|
QuestionID int64
|
|
}
|
|
|
|
p.FirstName = r.PostFormValue("first-" + fmt.Sprint(p.Login))
|
|
p.LastName = r.PostFormValue("last-" + fmt.Sprint(p.Login))
|
|
p.Company = r.PostFormValue("company-" + fmt.Sprint(p.Login))
|
|
|
|
err := db.WriteParticipant(p)
|
|
if err != nil {
|
|
http.Error(w, "DisplayQuestion: db.WriteParticipant(): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
log.Panicln(err)
|
|
}
|
|
|
|
data := new(httpData)
|
|
data.SessionID = s.ID
|
|
data.Login = p.Login
|
|
data.Question = (*sq)[0]
|
|
data.QuestionID = 1
|
|
|
|
template.Must(template.ParseFiles("templates/question.html")).ExecuteTemplate(w, "content", data)
|
|
}
|
|
}
|
|
|
|
func HandleAnswer(s *types.Session, db *db.DB, p *types.Participant, sq *[]types.Question, i int64) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
log.Println(i, len(*sq))
|
|
if i < int64(len(*sq)) {
|
|
type httpData struct {
|
|
SessionID uuid.UUID
|
|
Login string
|
|
Question types.Question
|
|
QuestionID int64
|
|
}
|
|
|
|
if err := handleGivenAnswer(s, p, i-1, r, db); err != nil {
|
|
http.Error(w, "DisplayQuestion: handleGivenAnswer(): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
log.Panicln(err)
|
|
}
|
|
|
|
data := new(httpData)
|
|
data.SessionID = s.ID
|
|
data.Login = p.Login
|
|
data.Question = (*sq)[i]
|
|
data.QuestionID = i + 1
|
|
|
|
template.Must(template.ParseFiles("templates/question.html")).ExecuteTemplate(w, "content", data)
|
|
} else {
|
|
type answer struct {
|
|
Text string
|
|
Correct bool
|
|
Chosen bool
|
|
}
|
|
|
|
type question struct {
|
|
Text string
|
|
Answers []answer
|
|
}
|
|
|
|
type httpData struct {
|
|
SessionID uuid.UUID
|
|
Login string
|
|
Questions []question
|
|
Incorrect int
|
|
}
|
|
|
|
if err := handleGivenAnswer(s, p, i-1, r, db); err != nil {
|
|
http.Error(w, "DisplayTestResults: handleGivenAnswer(): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
log.Panicln(err)
|
|
}
|
|
|
|
givenAnswers, err := db.GetGivenAnswers(s.Briefing.ID, p.ID, s.Questions)
|
|
if err != nil {
|
|
http.Error(w, "DisplayTestResults: db.GetGivenAnswers(): "+fmt.Sprint(err), http.StatusInternalServerError)
|
|
log.Panicln(err)
|
|
}
|
|
|
|
data := new(httpData)
|
|
data.SessionID = s.ID
|
|
data.Login = p.Login
|
|
data.Incorrect = 0
|
|
|
|
data.Questions = make([]question, 0)
|
|
for i, q := range s.Questions {
|
|
question := new(question)
|
|
question.Text = q.Text
|
|
|
|
question.Answers = make([]answer, 0)
|
|
for j, a := range q.Answers {
|
|
answer := new(answer)
|
|
answer.Text = a.Text
|
|
|
|
if j+1 == q.Correct {
|
|
answer.Correct = true
|
|
} else {
|
|
answer.Correct = false
|
|
}
|
|
|
|
if j+1 == givenAnswers[i] {
|
|
answer.Chosen = true
|
|
} else {
|
|
answer.Chosen = false
|
|
}
|
|
question.Answers = append(question.Answers, *answer)
|
|
}
|
|
data.Questions = append(data.Questions, *question)
|
|
|
|
if givenAnswers[i] != q.Correct {
|
|
data.Incorrect++
|
|
}
|
|
}
|
|
|
|
template.Must(template.ParseFiles("templates/results.html")).ExecuteTemplate(w, "content", data)
|
|
}
|
|
}
|
|
}
|
|
|
|
func HandleRetry(s *types.Session, p *types.Participant, sq *[]types.Question) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
type httpData struct {
|
|
SessionID uuid.UUID
|
|
Login string
|
|
Question types.Question
|
|
QuestionID int64
|
|
}
|
|
|
|
data := new(httpData)
|
|
data.SessionID = s.ID
|
|
data.Login = p.Login
|
|
data.Question = (*sq)[0]
|
|
data.QuestionID = 1
|
|
|
|
template.Must(template.ParseFiles("templates/question.html")).ExecuteTemplate(w, "content", data)
|
|
}
|
|
}
|