MapyWeb/pgsql/pg.go

package main

import (
	"errors"
	"os"
	"time"

	pgsql "github.com/fergusstrange/embedded-postgres"
	"github.com/jmoiron/sqlx"
	_ "github.com/lib/pq"
	"github.com/rs/zerolog/log"
)

var (
	db       *sqlx.DB
	postgres *pgsql.EmbeddedPostgres
)

// User represents a mapy user.
type User struct {
	ID        int64     `db:"id"`
	Username  string    `db:"username"`
	Password  string    `db:"password"`
	Creation  time.Time `db:"creation"`
	LastLogin time.Time `db:"last_login"`
	LastIP    string    `db:"last_ip"`
	Ban       int       `db:"ban"`
	Admin     int       `db:"admin"`
	Gender    int       `db:"gender"`
}

func getUser(username string) (u *User, err error) {
	u = new(User)
	if err = db.Get(u, "SELECT * FROM accounts WHERE username=$1", username); err != nil {
		return nil, err
	}
	return u, nil
}

// AttemptWebLogin checks the given credentials for validity and returns a User and an error.
func AttemptWebLogin(username, password, ipaddr, useragent string) (*User, error) {
	var (
		u    *User
		err  error
		good = false
	)
	defer func() {
		// to log invalid users
		if u == nil {
			u = &User{ID: 000}
		}
		if err := authlog.NewAttempt(int(u.ID), ipaddr, useragent, Web, good); err != nil {
			println(err.Error())
			log.Error().Err(err).Msg("failed_login")
		}
	}()
	if u, err = getUser(username); err != nil {
		return u, err
	}
	println("provided: ", password)
	println("hashed: ", u.Password)
	if !CheckPasswordHash(password, u.Password) {
		return nil, errors.New("invalid password")
	}
	good = true
	return u, nil
}

// RegisterNewUser registers a new mapyweb user
func RegisterNewUser(username, password, ipaddr string, gender int, admin bool) error {
	hashed, err := HashPassword(password)
	if err != nil {
		return err
	}
	if !CheckPasswordHash(password, hashed) {
		return errors.New("FAILED PASSWORD HASHING")
	}
	u := &User{
		Username:  username,
		Password:  hashed,
		Creation:  time.Now(),
		LastLogin: time.Now(),
		LastIP:    ipaddr,
		Ban:       0,
		Gender:    gender,
	}
	if admin {
		u.Admin = 1
	} else {
		u.Admin = 0
	}
	_, err = db.NamedExec(`INSERT INTO accounts (username, password, creation, last_login, last_ip, ban, admin, gender)
						VALUES (:username, :password, :creation, :last_login, :last_ip, 0, :admin, :gender);`, u)

	return err
}

func main() {
	var err error
	postgres = pgsql.NewDatabase(pgsql.DefaultConfig().
		DataPath("./data/pgsql").
		BinariesPath("./postgresql").
		Logger(os.Stdout))
	if err := postgres.Start(); err != nil {
		log.Error().Err(err).Msg("postgres_fail")
		return
	}

	defer postgres.Stop()

	if authlog, err = GetUserAuths("./data/authlog"); err != nil {
		log.Error().Caller().Err(err).Msg("!!! GetUserAuths failed !!!")
	}

	db, err = sqlx.Connect("postgres",
		"host=localhost port=5432 user=postgres password=postgres dbname=postgres sslmode=disable")

	if err != nil {
		log.Error().Caller().Err(err).Msg("postgres_fail")
		return
	}

	Banner()

	argParse()

}