Users and Admin Interface Part 1

package utils

import (
	"golang.org/x/crypto/bcrypt"
)

func HashPassword(password []byte) (string, error) {
	// Generate a hash
	hash, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
	if err != nil {
		return "", err
	}

	return string(hash), nil
}

/*
* Returns true if validated.
 */
func CheckPassword(hashedPassword []byte, password []byte) bool {
	return bcrypt.CompareHashAndPassword(hashedPassword, password) == nil
}

type User struct {
	Id       uint64 `orm:"auto"` // this automatically creates an integer primary key
	Name     string `orm:"size(100)"`
	Email    string `orm:"size(255);unique"`
	Password string `orm:"size(255)"`
}

package utils

import (
	"errors"
	"queenbee/models"
)

type LoginReq struct {
	Email    string `form:"email"`
	Password string `form:"password"`
}

func SaveUser(user *models.User) (*models.User, error) {
	hashed, err := HashPassword([]byte(user.Password))
	if err != nil {
		return nil, err
	}
	user.Password = hashed
	id, err := models.O.Insert(user)
	if err != nil {
		return nil, err
	}
	user.Id = uint64(id)
	return user, nil
}

func GetUserByEmail(email string) (*models.User, error) {
	user := models.User{Email: email}
	err := models.O.Read(&user, "Email")
	if err != nil {
		return nil, err
	}
	return &user, nil
}

func Authenticate(login *LoginReq) (*models.User, error) {
	user, err := GetUserByEmail(login.Email)
	if err != nil {
		return nil, err
	}
	if CheckPassword([]byte(user.Password), []byte(login.Password)) {
		return user, nil
	} else {
		err = errors.New("password validation failed.")
		return nil, err
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"queenbee/models"
	"queenbee/utils"
	"regexp"
	"strings"

	"golang.org/x/term"
)

func readName(reader *bufio.Reader) string {
	fmt.Print("Full Name: ")
	name, err := reader.ReadString('\n')
	name = strings.TrimSpace(name)
	if err != nil {
		fmt.Println("Error reading input:", err)
		os.Exit(1)
	}
	return name
}

func readEmail(reader *bufio.Reader) string {
	fmt.Print("Email: ")
	email, err := reader.ReadString('\n')
	email = strings.TrimSpace(email)
	if err != nil {
		fmt.Println("Error reading input:", err)
		os.Exit(1)
	}
	// Define a regex pattern (e.g., to match an email address)
	pattern := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
	// Compile the regex
	regex := regexp.MustCompile(pattern)
	if !regex.MatchString(email) {
		fmt.Println("The input is NOT a valid email address.")
		os.Exit(1)
	}
	return email
}

func readPassword() string {
	const PASSWORD_LENGTH = 8
	fmt.Print("Password: ")
	passbyte, err := term.ReadPassword(int(os.Stdin.Fd()))
	if err != nil {
		fmt.Println("Error reading input:", err)
		os.Exit(1)
	}
	fmt.Print("\nConfirm Password: ")
	passbyte2, err := term.ReadPassword(int(os.Stdin.Fd()))
	if err != nil {
		fmt.Println("Error reading input:", err)
		os.Exit(1)
	}
	password, password2 := string(passbyte), string(passbyte2)
	if password != password2 {
		fmt.Println("Passwords do not match.")
		os.Exit(1)
	}
	if len(password) < PASSWORD_LENGTH {
		fmt.Printf("Password must be %d characters or more in length.\n", PASSWORD_LENGTH)
		os.Exit(1)
	}
	return password
}

func main() {
	models.InitDB()

	fmt.Println("Create User")
	reader := bufio.NewReader(os.Stdin)
	name := readName(reader)
	email := readEmail(reader)
	password := readPassword()

	// Create User
	user := models.User{
		Email:    email,
		Name:     name,
		Password: password,
	}
	_, err := utils.SaveUser(&user)
	if err != nil {
		fmt.Println("Error saving user: " + err.Error())
		os.Exit(1)
	} else {
		fmt.Println("User created successfully!")
	}
}

package controllers

import (
	"queenbee/models"
	"queenbee/utils"

	beego "github.com/beego/beego/v2/server/web"
)

type BaseAdminController struct {
	beego.Controller
}

// Prepare runs before every request
func (c *BaseAdminController) Prepare() {
	// Set common template data
	c.setCommonData()
}

// Set common data for all templates
func (c *BaseAdminController) setCommonData() {
	// Check if user is logged in and set template variables
	if c.IsLoggedIn() {
		user := c.GetCurrentUser()
		c.Data["IsLoggedIn"] = true
		c.Data["User"] = user
	} else {
		c.Data["IsLoggedIn"] = false
		c.Data["User"] = nil
	}
}

// Check if user is logged in
func (c *BaseAdminController) IsLoggedIn() bool {
	user := c.GetSession("user")
	return user != nil
}

// Get current user from session
func (c *BaseAdminController) GetCurrentUser() *models.User {
	userSession := c.GetSession("user")
	if userSession == nil {
		return nil
	}

	// Assuming you store user info in session
	if user, ok := userSession.(models.User); ok {
		return &user
	}
	return nil
}

// RequireAuth middleware - add this to controllers that need authentication
func (c *BaseAdminController) RequireAuth() {
	if !c.IsLoggedIn() {
		// Store the current URL for redirect after login
		c.SetSession("redirect_after_login", c.Ctx.Request.URL.Path)
		c.Redirect("/admin/login", 302)
		return
	}
}

type AdminController struct {
	BaseAdminController
}

func (c *AdminController) Get() {
	c.RequireAuth()
	c.Data["Title"] = "Admin"
	c.TplName = "admin/index.tpl"
}

type LogoutController struct {
	BaseAdminController
}

func (c *LogoutController) Get() {
	c.DestroySession()
	c.Redirect("/admin/login", 302)
}

type LoginController struct {
	BaseAdminController
}

func (c *LoginController) Get() {
	c.Data["Title"] = "Login"
	c.TplName = "admin/login.tpl"
}

func (c *LoginController) Post() {
	c.Data["Title"] = "Login"
	c.TplName = "admin/login.tpl"

	loginreq := utils.LoginReq{}
	err := c.Ctx.BindForm(&loginreq)
	if err != nil {
		c.Data["Result"] = "ERROR: " + err.Error()
	} else if loginreq.Email == "" || loginreq.Password == "" {
		c.Data["Result"] = "ERROR: Please enter all values."
	} else {
		// authenticate
		user, err := utils.Authenticate(&loginreq)
		if err != nil {
			c.Data["Result"] = "ERROR: " + err.Error()
		} else {
			// create session
			c.SetSession("user", *user)

			// redirect
			path := c.GetSession("redirect_after_login")
			if path != nil {
				if path, ok := path.(string); ok {
					c.Redirect(path, 302)
				}
			}
			c.Redirect("/admin", 302)
		}
	}
}

type ProfileController struct {
	BaseAdminController
}

func (c *ProfileController) Get() {
	c.RequireAuth()
	c.Data["Title"] = "Profile"
	c.TplName = "profile.tpl"
}

type EditProfile struct {
	Name  string `form:"name"`
	Email string `form:"email"`
}

func (c *ProfileController) Post() {
	c.RequireAuth()
	c.Data["Title"] = "Profile"
	c.TplName = "profile.tpl"

	ep := EditProfile{}
	err := c.Ctx.BindForm(&ep)
	if err != nil {
		c.Data["Result"] = "ERROR: " + err.Error()
	} else if ep.Email == "" || ep.Name == "" {
		c.Data["Result"] = "ERROR: Please enter all values."
	} else {
		user := c.GetCurrentUser()
		user.Name = ep.Name
		user.Email = ep.Email
		_, err := models.O.Update(user, "Name", "Email")
		if err != nil {
			c.Data["Result"] = "ERROR: " + err.Error()
		} else {
			// update the user in the session
			c.SetSession("user", *user)
			c.Data["Result"] = "Profile updated!"
		}
	}

}

package routers

import (
	"queenbee/controllers"

	beego "github.com/beego/beego/v2/server/web"
)

func init() {
	beego.Router("/", &controllers.MainController{})
	beego.Router("/about", &controllers.AboutController{})
	beego.Router("/contact", &controllers.ContactController{})
	beego.Router("/profile", &controllers.ProfileController{})
	beego.Router("/admin", &controllers.AdminController{})
	beego.Router("/admin/login", &controllers.LoginController{})
	beego.Router("/admin/logout", &controllers.LogoutController{})
}