func RegisterPost(w http.ResponseWriter, r *http.Request) { // /register POST method handler. // Validates the form, // check's if username is availible, // and then creates a user and redirects to // /login . db := database.GetConnection() var user models.User // Model out of form data. user.Email = r.FormValue("email") user.Email = strings.ToLower(user.Email) user.Password = r.FormValue("password") user.Firstname = r.FormValue("firstname") if len(user.Firstname) > 0 { user.Firstname = strings.ToUpper(user.Firstname[0:1]) + strings.ToLower(user.Firstname[1:]) } user.Lastname = r.FormValue("lastname") if len(user.Lastname) > 0 { user.Lastname = strings.ToUpper(user.Lastname[0:1]) + strings.ToLower(user.Lastname[1:]) } repeat := r.FormValue("repeat") var old models.RegisterContext // Model for return form. // In case there the data wasn't valid old.Firstname = user.Firstname old.Lastname = user.Lastname old.Email = user.Email old.Flag = user.UserValidate(repeat) if old.Flag != "" { templates.Render(w, "register", old) return } pass, _ := database.GetPassword(db, user.Email) // Checks if user exists. if pass != "" { old.Flag = "Vartotojas su šiuo el. pašto adresu jau egzistuoja." templates.Render(w, "register", old) return } user.Password = password.NewPassword(user.Password) database.CreateUser(db, &user) // Creates a user in the db. http.Redirect(w, r, "/login", http.StatusFound) log.Printf("USER CREATED (%s)\n", user.Email) }
func ForgotGet(w http.ResponseWriter, r *http.Request) { forgotKey := r.URL.RawQuery db := database.GetConnection() if forgotKey == "" { // A simple GET for the form. templates.Render(w, "forgot", nil) } else if database.CheckRecovery(db, forgotKey) { // Render recover page. templates.Render(w, "recover", forgotKey) } else { // Redirect to login. http.Redirect(w, r, "/login/", http.StatusFound) } }
func GuessesGet(w http.ResponseWriter, r *http.Request) { // /guesses handler for GET method request. // Renders a page only for users with valid sessionid cookie. // All the rest are redirected to /login . db := database.GetConnection() sessionid := cookies.GetCookieVal(r, "sessionid") username := cookies.UsernameFromCookie(sessionid) pk, is_admin := database.GetPkAdmin(db, username) if username == "" || pk == -1 { // Gorilla failed to decode it. // Or encoded username does not exist in db. http.Redirect(w, r, "/login/", http.StatusFound) } else if is_admin { http.Redirect(w, r, "/admin/", http.StatusFound) } else { // Fetches users guesses from the db and gets data for // result submit dropbox. var F models.GuessContext F.OpenGames = database.GamesList(db, "open") F.Guesses = database.UsersGuesses(db, pk) F.Error = false templates.Render(w, "guesses", F) } }
func LoginPost(w http.ResponseWriter, r *http.Request) { // /login handler for POST request. // Tries to validate user. // If email / password is OK, // new sessionid cookie is set and user is redirected to / . db := database.GetConnection() username := r.FormValue("username") username = strings.ToLower(username) pass := r.FormValue("password") remember := r.FormValue("remember") == "1" hashed, _ := database.GetPassword(db, username) if password.Authenticate(pass, hashed) { // Valid password. sessionid := cookies.GenerateSessionId(username) cookies.SetSessionId(w, sessionid, remember) http.Redirect(w, r, "/", http.StatusFound) log.Printf("LOGGED IN (%s)\n", username) } else { context := loginContext{username, config.Config.Register, true} templates.Render(w, "login", context) } }
func drawFull(w http.ResponseWriter, db *sql.DB, pk int) { var context models.HomeContext context.Games = database.GetGames(db) lastGame := models.LastGame(context.Games) context.Users = database.GetUsers(db, pk) context.GamesNr = len(context.Games) context.UsersNr = len(context.Users) context.Guesses = database.GetGuesses(db, pk, context.GamesNr, context.UsersNr, lastGame) templates.Render(w, "home", context) }
func GuessesPost(w http.ResponseWriter, r *http.Request) { // /guesses POST method. // Checks if user trying to submit is in valid. db := database.GetConnection() sessionid := cookies.GetCookieVal(r, "sessionid") username := cookies.UsernameFromCookie(sessionid) var guess models.Guess guess.Userpk, _ = database.GetPkAdmin(db, username) var F models.GuessContext F.OpenGames = database.GamesList(db, "open") F.Guesses = database.UsersGuesses(db, guess.Userpk) F.Error = false if username == "" || guess.Userpk < 0 { // Gorilla failed to decode it. http.Redirect(w, r, "/login/", http.StatusFound) } else { var nr int var err error //Extract data from request and check if form is valid. if utils.ExtractResult(r.FormValue("result_2"), &guess.Result1, &guess.Result2) || utils.ExtractResult(r.FormValue("result_1"), &guess.Result1, &guess.Result2) { if guess.Result1 < 0 || guess.Result2 < 0 { F.Error = true } } else { nr, err = fmt.Sscanf(r.FormValue("result_1"), "%d", &guess.Result1) if nr != 1 || err != nil || guess.Result1 < 0 { F.Error = true } nr, err = fmt.Sscanf(r.FormValue("result_2"), "%d", &guess.Result2) if nr != 1 || err != nil || guess.Result2 < 0 { F.Error = true } } nr, err = fmt.Sscanf(r.FormValue("game-id"), "%d", &guess.Gamepk) if nr != 1 || err != nil { F.Error = true } if F.Error { templates.Render(w, "guesses", F) } else { // Submit a guess. database.GiveResult(db, &guess) http.Redirect(w, r, "/guesses/", http.StatusFound) log.Printf("GUESS BY (%d). GAME (%d)\n", guess.Userpk, guess.Gamepk) } } }
func drawSmall(w http.ResponseWriter, db *sql.DB, pk int) { var context models.HomeContext context.Users = database.GetUsers(db, pk) context.UsersNr = len(context.Users) allGames := database.GetGames(db) lastGame := models.LastGame(allGames) s, e := getSlice(len(allGames), lastGame) context.Games = allGames[s:e] context.Guesses = database.GetSmall(db, pk, context.UsersNr, s, e-s, lastGame) templates.Render(w, "small", context) }
func ForgotPost(w http.ResponseWriter, r *http.Request) { forgotKey := r.URL.RawQuery db := database.GetConnection() if forgotKey == "" { // Initial forgot submit. email := r.FormValue("email") pk, _ := database.GetPkAdmin(db, email) if pk != -1 { if !database.RecoveryExists(db, pk) { // Send out an email. key := utils.GenRecoveryKey() msg := utils.Message{email, "Slaptažodio atkūrimas", fmt.Sprintf("Norėdami atkurti slaptažodį eikite į:\n\nhttp://futbolas.aivaras.in/forgot/?%s\n\nŠi nuoroda galios dvi dienas.", key)} go recovery(db, msg, pk, key) log.Printf("An email was sent to %s\n", email) templates.Render(w, "forgot", nil) } else { // The recovery already exists. templates.Render(w, "forgot", nil) } } else { // User non existing. templates.Render(w, "forgot", nil) } } else { // Actual recovery. newPassword := r.FormValue("new") repeat := r.FormValue("repeat") if len(newPassword) < 6 || newPassword != repeat { // Bad password templates.Render(w, "recover", forgotKey) } else { hashed := password.NewPassword(newPassword) database.DoRecover(db, forgotKey, hashed) http.Redirect(w, r, "/login", http.StatusFound) log.Printf("KEY (%s) RESET PASSWORD\n", forgotKey) } } }
func AdminGet(w http.ResponseWriter, r *http.Request) { // /admin GET method handler. // Just render's the form. db := database.GetConnection() sessionid := cookies.GetCookieVal(r, "sessionid") username := cookies.UsernameFromCookie(sessionid) _, is_admin := database.GetPassword(db, username) if !is_admin { http.Redirect(w, r, "/login/", http.StatusFound) } else { var F models.AdminContext F.OpenGames = database.GamesList(db, "open") F.NotFinish = database.GamesList(db, "finish") templates.Render(w, "admin", F) } }
func ErrorGet(w http.ResponseWriter) { // Static error page templates.Render(w, "error", nil) log.Println("ERROR WAS RENDERED") }
func RegisterGet(w http.ResponseWriter) { // /register GET method handler. // Just render's the form. templates.Render(w, "register", nil) }
func LoginGet(w http.ResponseWriter) { // /login handler for GET request. // Just renders blank form. context := loginContext{"", config.Config.Register, false} templates.Render(w, "login", context) }