lala.go

package routing

import (
	"fmt"
	"github.com/pkg/errors"
	"gitlab.com/K-AI/it4me/cmd/server/services"
	"gitlab.com/K-AI/it4me/pkg/dto"
	"html/template"
	"log"
	"net/http"
	"time"
)

func parseTemplate(name string, filename ...string) *template.Template {

	if name == "ticket" {
		funcs := map[string]interface{}{
			"GetEditors": services.GetEditors,
		}
		tmpl, err := template.New(name).Funcs(funcs).ParseFiles(filename...)
		if err != nil {
			log.Fatal(err)
		}
		return tmpl
	}

	tmpl, err := template.New(name).ParseFiles(filename...)

	if err != nil {
		log.Fatal(err)
	}

	return tmpl
}

func generateHandler(data interface{}) extendedHandlerFunc {
	return func(t *template.Template, w http.ResponseWriter, r *http.Request) {
		err := t.Execute(w, data)

		if err != nil {
			log.Fatal(err)
		}
	}
}

var Routes = [...]Route{
	{
		path: "/",
		get: handler{
			template: parseTemplate("home", "template/home.html"),
			handler:  generateHandler(nil),
		},
	},
	{
		path: "/kunde",
		get: handler{
			template: parseTemplate("customer", "template/customer.html"),
			handler:  generateHandler(nil),
		},
	},
	{
		path: "/bearbeiter",
		get: handler{
			template: parseTemplate("editor", "template/editor.html"),
			handler: func(t *template.Template, w http.ResponseWriter, r *http.Request) {
				_, err := services.IsUserAuthenticated(r)
				if err != nil {
					fmt.Println(err)
				}

				data := struct {
					Authenticated bool
				}{
					err == nil,
				}

				err = t.Execute(w, data)
				if err != nil {
					log.Fatal(err)
				}
			},
		},
	},
	{
		path: "/ticket/",
		get: handler{
			template: parseTemplate("ticket", "template/ticket.html"),
			handler: func(t *template.Template, w http.ResponseWriter, r *http.Request) {
				id := r.URL.Path[len("/ticket/"):]
				ticket := services.GetTicket(id)

				if ticket.Id == "" {
					render404(w)
					return
				}

				_, err := services.IsUserAuthenticated(r)
				if err != nil {
					fmt.Println(err)
				}

				data := services.TicketBundle{
					Ticket:        ticket,
					Authenticated: err == nil,
					RedirectURL:   "",
				}

				err = t.Execute(w, data)
				if err != nil {
					log.Fatal(err)
				}
			},
		},
		post: handler{
			template: parseTemplate("ticket", "template/ticket.html"),
			handler: func(t *template.Template, w http.ResponseWriter, r *http.Request) {

				err, ticketId := createTicketWithForm(r)
				if err != nil {
					fmt.Println(err)
					render404(w)
					return
				}

				// To redirect to the new ticket's URL, this variable is used in the template
				data := services.TicketBundle{
					RedirectURL: ticketId,
				}

				err = t.Execute(w, data)
				if err != nil {
					log.Fatal(err)
				}
			},
		},
	},
	{
		path: "/dashboard",
		get: handler{
			template: parseTemplate("dashboard", "template/dashboard.html"),
			handler: func(t *template.Template, w http.ResponseWriter, r *http.Request) {

				type ticketsDashboard struct {
					AssignedTickets []dto.Ticket
					OpenTickets     []dto.Ticket
					Authenticated   bool
				}

				auth, err := services.IsUserAuthenticated(r)
				if err != nil {
					fmt.Println(err)
					render404(w)
					return
				}

				assignedTickets := services.GetTicketsForEditor(auth.EditorId)
				openTickets := services.GetOpenTickets()

				data := ticketsDashboard{
					AssignedTickets: assignedTickets,
					OpenTickets:     openTickets,
					Authenticated:   auth.EditorId != "",
				}

				err = t.Execute(w, data)

				if err != nil {
					log.Fatal(err)
				}
			},
		},
	},
	{
		path: "/login",
		get: handler{
			handler: func(t *template.Template, w http.ResponseWriter, r *http.Request) {
				render404(w)
			},
		},
		post: handler{
			template: parseTemplate("404", "template/404.html"),
			handler: func(t *template.Template, w http.ResponseWriter, r *http.Request) {
				tmpl, err := template.New("login").ParseFiles("template/login.html")
				if err != nil {
					log.Fatal(err)
				}

				err = r.ParseForm()
				if err != nil {
					log.Fatal(err)
				}
				email := r.Form.Get("email")
				password := r.Form.Get("password")
				if len(email) == 0 || len(password) == 0 {
					fmt.Println("Submitted Password or Mail is/are empty")
				}

				auth, err := services.EmailPasswordMatching(email, password)
				if err != nil {
					fmt.Println(err, "User could not be authed")
					return // not good here, we cant just abort everything
					// Handle this further
				}

				sessionId, err := services.GenerateSessionId()
				services.AddSession(sessionId, auth.EditorId)

				err = services.SaveTickets()
				if err != nil {
					fmt.Println("Was unable to save tickets: ", err)
				}
				err = services.SaveSessions()
				if err != nil {
					fmt.Println("Was unable to save sessions: ", err)
				}

				expiration := time.Now().Add(365 * 24 * time.Hour)
				cookie := http.Cookie{Name: services.SessionCookieString, Value: sessionId, Expires: expiration}
				http.SetCookie(w, &cookie)

				err = tmpl.Execute(w, nil)
				if err != nil {
					log.Fatal(err)
				}

			},
		},
	},
	{
		path: "/api/v1/ticket",
		get: handler{
			handler: func(t *template.Template, w http.ResponseWriter, r *http.Request) {
				render404(w)
			},
		},
		post: handler{
			handler: func(t *template.Template, w http.ResponseWriter, r *http.Request) {

				// TODO: Create struct for api answer and use JSON marshalling
				errorMessage := "{'ticketid': '','error': '%s'}"
				successMessage := "{'ticketid: '%s', 'error': ''}"

				err, ticketId := createTicketWithForm(r)
				if err != nil {
					fmt.Println(err)
					w.Write([]byte(fmt.Sprintf(errorMessage, err)))
					return
				}

				w.Write([]byte(fmt.Sprintf(successMessage, ticketId)))
			},
		},
	},
}

func render404(w http.ResponseWriter) {
	tmpl, err := template.New("404").ParseFiles("template/404.html")

	if err != nil {
		log.Fatal(err)
	}

	err = tmpl.Execute(w, nil)

	if err != nil {
		log.Fatal(err)
	}
}

func createTicketWithForm(r *http.Request) (err error, ticketId string) {
	// Works fine, but this isn't a JSON API i think
	err = r.ParseForm()
	if err != nil {
		return errors.New("parsing form failed while creating ticket"), ""
	}

	ticket := dto.Ticket{
		Subject:     r.Form.Get("subject"),
		CreatorMail: r.Form.Get("email"),
		Date:        time.Now(),
		Text:        r.Form.Get("tickettext"),
	}

	if ticket.Subject == "" || ticket.CreatorMail == "" || ticket.Text == "" {
		return errors.New("some of the necessary arguments are empty"), ""
	}

	err, ticket = services.CreateTicket(ticket)
	if err != nil {
		return errors.New("creating ticket failed in the service"), ""
	}

	services.SaveTickets()
	return nil, ticket.Id
}