package main

import (
	"database/sql"
	"fmt"
	"strconv"
	"strings"

	"io/ioutil"

	_ "github.com/lib/pq"
)

var (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = ""
	dbname   = "postgres"
)

var db *sql.DB

func checkErr(err error) {
	if err != nil {
		panic(err)
	}
}
func getDbInfo() {
	var userHost string
	fmt.Print("Server[localhost]: ")
	fmt.Scanln(&userHost)
	if strings.TrimSpace(userHost) != "" {
		host = userHost
	}

	var userDB string
	fmt.Print("Database[postgres]: ")
	fmt.Scanln(&userDB)
	if strings.TrimSpace(userDB) != "" {
		dbname = userDB
	}

	var userPort string
	fmt.Print("Port[5432]: ")
	fmt.Scanln(&userPort)
	if strings.TrimSpace(userPort) != "" {
		intPort, err := strconv.Atoi(userPort)
		checkErr(err)
		port = intPort
	}

	var userName string
	fmt.Print("Username[postgres]: ")
	fmt.Scanln(&userName)
	if strings.TrimSpace(userName) != "" {
		user = userName
	}

	fmt.Print("Password for user postgres: ")
	fmt.Scanln(&password)
}

func insert(givenAcc string, givenPass string) {
	psqlInfo := fmt.Sprintf("INSERT INTO users(account, password) VALUES('%s','%s');", givenAcc, givenPass)
	_, err := db.Exec(psqlInfo)
	checkErr(err)
}

func query(givenAcc string) (hasAccount bool, pass string) {
	hasAccount = false
	pass = ""
	psqlInfo := fmt.Sprintf("SELECT password FROM users WHERE account='%s';", givenAcc)
	info, err := db.Query(psqlInfo)
	checkErr(err)
	// fmt.Printf("info has type %T\n", info)
	for info.Next() {
		err = info.Scan(&pass)
		checkErr(err)
		hasAccount = true
	}
	return
} // query

func initDB() {
	getDbInfo()
	openDBSQL := fmt.Sprintf("host=%s port=%d user=%s "+
		"password=%s dbname=%s sslmode=disable",
		host, port, user, password, dbname)

	sqlBytes, err := ioutil.ReadFile("createTable.sql")
	checkErr(err)
	sqlCommand := string(sqlBytes)

	var errOpenDB error
	db, errOpenDB = sql.Open("postgres", openDBSQL)
	// fmt.Printf("db has type of %T\n", db)
	checkErr(errOpenDB)
	_, err = db.Exec(sqlCommand)
	checkErr(err)
}

func closeDB() {
	db.Close()
}

package main

import (
	"fmt"
	"os"

	"github.com/gomodule/redigo/redis"
)

var c redis.Conn

func errCheck(info string, err error) {
	if err != nil {
		fmt.Printf("%s %v\n", info, err)
		os.Exit(-1)
	}
}

func connectRedis() {
	var err error
	c, err = redis.Dial("tcp", "127.0.0.1:6379")
	errCheck("Connect to redis error:", err)
}

func closeRedis() {
	c.Close()
}

func addInRedis(sessionIDGiven string, account string) {
	_, err := c.Do("SET", sessionIDGiven, account)
	errCheck("redis set failed:", err)
}

func isLoggedInRedis(sessionIDGiven string) bool {
	is_key_exit, err := redis.Bool(c.Do("EXISTS", sessionIDGiven))
	errCheck("error:", err)
	return is_key_exit
}

func getInRedis(sessionIDGiven string) string {
	account, err := redis.String(c.Do("GET", sessionIDGiven))
	errCheck("redis get failed:", err)
	return account
}

func removedInRedis(sessionIDGiven string) {
	_, err := c.Do("DEL", sessionIDGiven)
	errCheck("redis delete failed:", err)
}

// main.go

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

var router *gin.Engine

func main() {
	// init the database
	initDB()
	defer closeDB()
	// init the redis Server
	connectRedis()
	defer closeRedis()

	// Set the router as the default one provided by Gin
	router = gin.Default()

	// Process the templates at the start so that they don't have to be loaded
	// from the disk again. This makes serving HTML pages very fast.
	router.LoadHTMLGlob("templates/*")

	// initialize the routes
	initializeRoutes()

	// Start serving the application
	router.Run(":3000")
}

// Render one of HTML, JSON or CSV based on the 'Accept' header of the request
// If the header doesn't specify this, HTML is rendered, provided that
// the template name is present
func render(c *gin.Context, data gin.H, templateName string) {
	token, _ := c.Cookie("token")

	// 设置html中的is_logged_in
	data["is_logged_in"] = isLoggedInRedis(token)
	// fmt.Println(data["is_logged_in"])

	switch c.Request.Header.Get("Accept") {
	case "application/json":
		// Respond with JSON
		c.JSON(http.StatusOK, data["payload"])
	case "application/xml":
		// Respond with XML
		c.XML(http.StatusOK, data["payload"])
	default:
		// Respond with HTML
		c.HTML(http.StatusOK, templateName, data)
	}
}

// routes.go

package main

import (
	"github.com/gin-gonic/gin"
)

func initializeRoutes() {
	// Handle the index route
	router.GET("/", showIndexPage)

	// Group user related routes together
	userRoutes := router.Group("/")
	{
		// Handle the GET requests at /signin
		// Show the login page
		// Ensure that the user is not logged in by using the middleware
		userRoutes.GET("signin", ensureNotLoggedIn(), showLoginPage)

		// Handle POST requests at /profile
		// Ensure that the user is not logged in by using the middleware
		userRoutes.POST("profile", ensureNotLoggedIn(), performLogin)

		// Handle GET requests at /logout
		// Ensure that the user is logged in by using the middleware
		userRoutes.GET("logout", ensureLoggedIn(), logout)

		// Handle GET request at /profile
		userRoutes.GET("profile", viewProfile)

		// Handle the GET requests at /signup
		// Show the registration page
		// Ensure that the user is not logged in by using the middleware
		userRoutes.GET("signup", ensureNotLoggedIn(), showRegistrationPage)

		// Handle POST requests at /signup
		// Ensure that the user is not logged in by using the middleware
		userRoutes.POST("signup", ensureNotLoggedIn(), register)
	}
}

func showIndexPage(c *gin.Context) {
	// Call the render function with the name of the template to render
	render(c, gin.H{
		"title": "Home Page",
	}, "index.html")
}

// handlers.user.go

package main

import (
	"fmt"
	"math/rand"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
)

func showLoginPage(c *gin.Context) {
	// Call the render function with the name of the template to render
	render(c, gin.H{
		"title": "Login",
	}, "login.html")
}

func performLogin(c *gin.Context) {
	// Obtain the POSTed username and password values
	username := c.PostForm("username")
	password := c.PostForm("password")

	// Check if the username/password combination is valid
	if isUserValid(username, password) {
		// If the username/password is valid set the token in a cookie
		token := generateSessionToken()
		fmt.Println(token)
		c.SetCookie("token", token, 3600, "", "", false, true)
		addInRedis(token, username)
		// redirect to profile page
		c.Redirect(http.StatusMovedPermanently, "/profile")
	} else {
		// If the username/password combination is invalid,
		// show the error message on the login page
		c.HTML(http.StatusBadRequest, "login.html", gin.H{
			"ErrorTitle":   "Login Failed",
			"ErrorMessage": "Invalid credentials provided"})
	}
}

func generateSessionToken() string {
	// We're using a random 16 character string as the session token
	// This is NOT a secure way of generating session tokens
	// DO NOT USE THIS IN PRODUCTION
	return strconv.FormatInt(rand.Int63(), 16)
}

func viewProfile(c *gin.Context) {
	token, _ := c.Cookie("token")
	loggedIn := isLoggedInRedis(token)
	if loggedIn {
		username := getInRedis(token)
		render(c, gin.H{
			"title":   "Successful Login",
			"payload": username}, "logged.html")
	} else {
		c.Redirect(http.StatusTemporaryRedirect, "/signin")
	}
}

func logout(c *gin.Context) {
	token, _ := c.Cookie("token")
	removedInRedis(token)
	// Clear the cookie
	c.SetCookie("token", "", -1, "", "", false, true)

	// Redirect to the home page
	c.Redirect(http.StatusTemporaryRedirect, "/")
}

func showRegistrationPage(c *gin.Context) {
	// Call the render function with the name of the template to render
	render(c, gin.H{
		"title": "Register"}, "register.html")
}

func register(c *gin.Context) {
	// Obtain the POSTed username and password values
	username := c.PostForm("username")
	password := c.PostForm("password")

	if _, err := registerNewUser(username, password); err == nil {
		// If the user is created, set the token in a cookie and log the user in
		token := generateSessionToken()
		c.SetCookie("token", token, 3600, "", "", false, true)
		addInRedis(token, username)
		// redirect to profile page
		c.Redirect(http.StatusMovedPermanently, "/profile")
	} else {
		// If the username/password combination is invalid,
		// show the error message on the login page
		c.HTML(http.StatusBadRequest, "register.html", gin.H{
			"ErrorTitle":   "Registration Failed",
			"ErrorMessage": err.Error()})
	}
}

// models.user.go

package main

import (
	"errors"
	"regexp"
	"strings"
	"unicode"
)

// Check if the username and password combination is valid
func isUserValid(username, password string) bool {
	hasAcc, passwordInDB := query(username)
	if hasAcc {
		if passwordInDB == password {
			return true
		}
	}
	return false
}

// Register a new user with the given username and password
func registerNewUser(username, password string) (string, error) {
	if strings.TrimSpace(password) == "" {
		return "", errors.New("The password can't be empty")
	} else if !isUsernameAvailable(username) {
		return "", errors.New("The username isn't available")
	}
	//pattern := `\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*` //匹配电子邮箱
	pattern := `^[0-9a-z][_.0-9a-z-]{0,31}@([0-9a-z][0-9a-z-]{0,30}[0-9a-z]\.){1,4}[a-z]{2,4}$`
	reg := regexp.MustCompile(pattern)
	isEmail := reg.MatchString(username)
	// 匹配手机
	regular := "^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$"
	reg2 := regexp.MustCompile(regular)
	isMobile := reg2.MatchString(username)
	// 验证用户名
	if (isEmail || isMobile) != true {
		return "", errors.New("Your user name should either be phone number or email address!")
	}
	// 验证密码长度
	if len(password) < 8 {
		return "", errors.New("Your password is too short!")
	}
	// 验证密码是否有大小写
	var hasUpperCase, hasLowercase bool
	for _, c := range password {
		switch {
		case unicode.IsUpper(c):
			hasUpperCase = true
			if hasLowercase {
				break
			}
		case unicode.IsLower(c):
			hasLowercase = true
			if hasUpperCase {
				break
			}
		}
	}
	if (hasLowercase && hasUpperCase) != true {
		return "", errors.New("Your password should contain both upper and lower cases!")
	}

  insert(username, password)

	return username, nil
}

// Check if the supplied username is available
func isUsernameAvailable(username string) bool {
  hasAcc,_ := query(username)
	if hasAcc {
		return false
	}
	return true
}

// middleware.auth.go

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

// This middleware ensures that a request will be aborted with an error
// if the user is not logged in
func ensureLoggedIn() gin.HandlerFunc {
	return func(c *gin.Context) {
		// If the token is not in redis
		// the user is not logged in
		token, _ := c.Cookie("token")
		loggedIn := isLoggedInRedis(token)
		if !loggedIn {
			//if token, err := c.Cookie("token"); err != nil || token == "" {
			c.AbortWithStatus(http.StatusUnauthorized)
		}
	}
}

// This middleware ensures that a request will be aborted with an error
// if the user is already logged in
func ensureNotLoggedIn() gin.HandlerFunc {
	return func(c *gin.Context) {
		//If the token is in the redis
		// the user is already logged in
		token, _ := c.Cookie("token")
		loggedIn := isLoggedInRedis(token)
		if loggedIn {
			// if token, err := c.Cookie("token"); err == nil || token != "" {
			c.AbortWithStatus(http.StatusUnauthorized)
		}
	}
}