Add login

storage/dao/database.go

@@ -0,0 +1,18 @@
+package dao
+
+import (
+	"hamster-tycoon/storage/model"
+)
+
+type Database interface {
+
+	// start: user dao funcs
+	GetAllUsers() ([]*model.User, error)
+	GetUsersByID(string) (*model.User, error)
+	GetUsersByGoogleID(string) (*model.User, error)
+	CreateUser(*model.User) error
+	DeleteUser(string) error
+	UpdateUser(*model.User) error
+	// end: user dao funcs
+
+}

storage/dao/database_error.go

@@ -0,0 +1,32 @@
+package dao
+
+import (
+	"fmt"
+)
+
+type Type int
+
+const (
+	ErrTypeNotFound Type = iota
+	ErrTypeDuplicate
+	ErrTypeForeignKeyViolation
+)
+
+type DAOError struct {
+	Cause error
+	Type  Type
+}
+
+func NewDAOError(t Type, cause error) error {
+	return &DAOError{
+		Type:  t,
+		Cause: cause,
+	}
+}
+
+func (e *DAOError) Error() string {
+	if e.Cause != nil {
+		return fmt.Sprintf("Type %d: %s", e.Type, e.Cause.Error())
+	}
+	return fmt.Sprintf("Type %d: no cause given", e.Type)
+}

storage/dao/fake/database_fake.go

@@ -0,0 +1,37 @@
+package fake
+
+import (
+	"encoding/json"
+	"hamster-tycoon/storage/dao"
+	"hamster-tycoon/utils"
+	"time"
+
+	"github.com/allegro/bigcache"
+)
+
+type DatabaseFake struct {
+	Cache *bigcache.BigCache
+}
+
+func NewDatabaseFake() dao.Database {
+	cache, err := bigcache.NewBigCache(bigcache.DefaultConfig(time.Minute))
+	if err != nil {
+		utils.GetLogger().WithError(err).Fatal("Error while instantiate cache")
+	}
+	return &DatabaseFake{
+		Cache: cache,
+	}
+}
+
+func (db *DatabaseFake) save(key string, data []interface{}) {
+	b, err := json.Marshal(data)
+	if err != nil {
+		utils.GetLogger().WithError(err).Errorf("Error while marshal fake %s", key)
+		db.Cache.Set(key, []byte("[]"))
+		return
+	}
+	err = db.Cache.Set(key, b)
+	if err != nil {
+		utils.GetLogger().WithError(err).Errorf("Error while saving fake %s", key)
+	}
+}

storage/dao/fake/database_fake_users.go

@@ -0,0 +1,106 @@
+package fake
+
+import (
+	"encoding/json"
+	"errors"
+	"hamster-tycoon/storage/dao"
+	"hamster-tycoon/storage/model"
+	"hamster-tycoon/utils"
+	"time"
+
+	"github.com/satori/go.uuid"
+)
+
+const (
+	cacheKeyUsers = "users"
+)
+
+func (db *DatabaseFake) saveUsers(users []*model.User) {
+	data := make([]interface{}, 0)
+	for _, v := range users {
+		data = append(data, v)
+	}
+	db.save(cacheKeyUsers, data)
+}
+
+func (db *DatabaseFake) loadUsers() []*model.User {
+	users := make([]*model.User, 0)
+	b, err := db.Cache.Get(cacheKeyUsers)
+	if err != nil {
+		return users
+	}
+	err = json.Unmarshal(b, &users)
+	if err != nil {
+		utils.GetLogger().WithError(err).Error("Error while unmarshal fake users")
+	}
+	return users
+}
+
+func (db *DatabaseFake) GetAllUsers() ([]*model.User, error) {
+	return db.loadUsers(), nil
+}
+
+func (db *DatabaseFake) GetUsersByID(userID string) (*model.User, error) {
+	users := db.loadUsers()
+	for _, u := range users {
+		if u.ID == userID {
+			return u, nil
+		}
+	}
+	return nil, dao.NewDAOError(dao.ErrTypeNotFound, errors.New("user not found"))
+}
+
+func (db *DatabaseFake) CreateUser(user *model.User) error {
+	user.ID = uuid.NewV4().String()
+	user.CreatedAt = time.Now()
+
+	users := db.loadUsers()
+	users = append(users, user)
+	db.saveUsers(users)
+	return nil
+}
+
+func (db *DatabaseFake) DeleteUser(userID string) error {
+	users := db.loadUsers()
+	newUsers := make([]*model.User, 0)
+	for _, u := range users {
+		if u.ID != userID {
+			newUsers = append(newUsers, u)
+		}
+	}
+	db.saveUsers(newUsers)
+	return nil
+}
+
+func (db *DatabaseFake) UpdateUser(user *model.User) error {
+	users := db.loadUsers()
+	var foundUser *model.User
+	for _, u := range users {
+		if u.ID == user.ID {
+			foundUser = u
+			break
+		}
+	}
+
+	if foundUser == nil {
+		return dao.NewDAOError(dao.ErrTypeNotFound, errors.New("user not found"))
+	}
+
+	foundUser.UserEditable = user.UserEditable
+	now := time.Now()
+	foundUser.UpdatedAt = &now
+	db.saveUsers(users)
+
+	*user = *foundUser
+	return nil
+}
+
+func (db *DatabaseFake) GetUsersByGoogleID(userID string) (*model.User, error) {
+	users := db.loadUsers()
+	for _, u := range users {
+		if u.GoogleId == userID {
+			return u, nil
+		}
+	}
+	return nil, dao.NewDAOError(dao.ErrTypeNotFound, errors.New("user not found"))
+}

storage/dao/postgresql/database_postgresql.go

@@ -0,0 +1,43 @@
+package postgresql
+
+import (
+	"database/sql"
+	"fmt"
+	"hamster-tycoon/storage/dao"
+	"hamster-tycoon/utils"
+
+	"github.com/lib/pq"
+)
+
+const (
+	pgCodeUniqueViolation     = "23505"
+	pgCodeForeingKeyViolation = "23503"
+)
+
+func handlePgError(e *pq.Error) error {
+	if e.Code == pgCodeUniqueViolation {
+		return dao.NewDAOError(dao.ErrTypeDuplicate, e)
+	}
+
+	if e.Code == pgCodeForeingKeyViolation {
+		return dao.NewDAOError(dao.ErrTypeForeignKeyViolation, e)
+	}
+	return e
+}
+
+type DatabasePostgreSQL struct {
+	session *sql.DB
+}
+
+func NewDatabasePostgreSQL(connectionURI string) dao.Database {
+	db, err := sql.Open("postgres", connectionURI)
+	if err != nil {
+		utils.GetLogger().WithError(err).Fatal("Unable to get a connection to the postgres db")
+	}
+	err = db.Ping()
+	if err != nil {
+		fmt.Println(err)
+		utils.GetLogger().WithError(err).Fatal("Unable to ping the postgres db")
+	}
+	return &DatabasePostgreSQL{session: db}
+}

storage/dao/postgresql/database_postgresql_user.go

@@ -0,0 +1,119 @@
+package postgresql
+
+import (
+	"database/sql"
+	"hamster-tycoon/storage/dao"
+	"hamster-tycoon/storage/model"
+
+	"github.com/lib/pq"
+)
+
+func (db *DatabasePostgreSQL) GetAllUsers() ([]*model.User, error) {
+	q := `
+		SELECT u.id, u.email, u.created_at, u.updated_at, u.nickname
+		FROM public.user u
+	`
+	rows, err := db.session.Query(q)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	us := make([]*model.User, 0)
+	for rows.Next() {
+		u := model.User{}
+		err := rows.Scan(&u.ID, &u.Email, &u.CreatedAt, &u.UpdatedAt, &u.Nickname)
+		if err != nil {
+			return nil, err
+		}
+		us = append(us, &u)
+	}
+	return us, nil
+}
+
+func (db *DatabasePostgreSQL) GetUsersByID(id string) (*model.User, error) {
+	q := `
+		SELECT u.id, u.email, u.created_at, u.updated_at, u.nickname
+		FROM public.user u
+		WHERE u.id = $1
+	`
+	row := db.session.QueryRow(q, id)
+
+	u := model.User{}
+	err := row.Scan(&u.ID, &u.Email, &u.CreatedAt, &u.UpdatedAt, &u.Nickname)
+	if errPq, ok := err.(*pq.Error); ok {
+		return nil, handlePgError(errPq)
+	}
+	if err == sql.ErrNoRows {
+		return nil, dao.NewDAOError(dao.ErrTypeNotFound, err)
+	}
+	return &u, err
+}
+
+func (db *DatabasePostgreSQL) CreateUser(user *model.User) error {
+	q := `
+		INSERT INTO public.user
+			(email, nickname, google_id)
+		VALUES
+			($1, $2, $3)
+		RETURNING id, created_at
+	`
+
+	err := db.session.
+		QueryRow(q, user.Email, user.Nickname, user.GoogleId).
+		Scan(&user.ID, &user.CreatedAt)
+	if errPq, ok := err.(*pq.Error); ok {
+		return handlePgError(errPq)
+	}
+	return err
+}
+
+func (db *DatabasePostgreSQL) DeleteUser(id string) error {
+	q := `
+		DELETE FROM public.user
+		WHERE id = $1
+	`
+
+	_, err := db.session.Exec(q, id)
+	if errPq, ok := err.(*pq.Error); ok {
+		return handlePgError(errPq)
+	}
+	return err
+}
+
+func (db *DatabasePostgreSQL) UpdateUser(user *model.User) error {
+	q := `
+		UPDATE public.user
+		SET
+			email = $2
+		WHERE id = $1
+		RETURNING updated_at
+	`
+
+	err := db.session.
+		QueryRow(q, user.ID, user.Email).
+		Scan(&user.UpdatedAt)
+	if errPq, ok := err.(*pq.Error); ok {
+		return handlePgError(errPq)
+	}
+	return err
+}
+
+func (db *DatabasePostgreSQL) GetUsersByGoogleID(id string) (*model.User, error) {
+	q := `
+		SELECT u.id, u.email, u.created_at, u.updated_at, u.nickname, u.google_id
+		FROM public.user u
+		WHERE u.google_id = $1
+	`
+	row := db.session.QueryRow(q, id)
+
+	u := model.User{}
+	err := row.Scan(&u.ID, &u.Email, &u.CreatedAt, &u.UpdatedAt, &u.Nickname, &u.GoogleId)
+	if errPq, ok := err.(*pq.Error); ok {
+		return nil, handlePgError(errPq)
+	}
+	if err == sql.ErrNoRows {
+		return nil, dao.NewDAOError(dao.ErrTypeNotFound, err)
+	}
+	return &u, err
+}

storage/model/error.go

@@ -0,0 +1,67 @@
+package model
+
+import (
+	"fmt"
+	"github.com/lib/pq"
+	"net/http"
+)
+
+var (
+	// 400
+	ErrBadRequestFormat = APIError{
+		Type:        "bad_format",
+		HTTPCode:    http.StatusBadRequest,
+		Description: "unable to read request body, please check that the json is valid",
+	}
+	ErrDataValidation = APIError{
+		Type:        "data_validation",
+		HTTPCode:    http.StatusBadRequest,
+		Description: "the data are not valid",
+	}
+
+	// 404
+	ErrNotFound = APIError{
+		Type:     "not_found",
+		HTTPCode: http.StatusNotFound,
+	}
+
+	// 40x
+	ErrAlreadyExists = APIError{
+		Type:     "already_exists",
+		HTTPCode: http.StatusConflict,
+	}
+
+	// 50x
+	ErrInternalServer = APIError{
+		Type:     "internal_server_error",
+		HTTPCode: http.StatusInternalServerError,
+	}
+)
+
+type APIError struct {
+	HTTPCode    int                 `json:"-"`
+	Type        string              `json:"error"`
+	Description string              `json:"error_description"`
+	Details     []FieldError        `json:"error_details,omitempty"`
+	Headers     map[string][]string `json:"-"`
+}
+
+type FieldError struct {
+	Field       string `json:"field"`
+	Constraint  string `json:"constraint"`
+	Description string `json:"description"`
+}
+
+func (e *APIError) Error() string {
+	return fmt.Sprintf("error : %d, %s, %s, %v", e.HTTPCode, e.Type, e.Description, e.Details)
+}
+
+func FromPostgresError(err *pq.Error) *APIError {
+	return &APIError{
+		HTTPCode:    0,
+		Type:        "",
+		Description: "",
+		Details:     nil,
+		Headers:     nil,
+	}
+}

storage/model/user.go

@@ -0,0 +1,16 @@
+package model
+
+import "time"
+
+type User struct {
+	UserEditable
+	ID        string     `json:"id"`
+	CreatedAt time.Time  `json:"createdAt"`
+	UpdatedAt *time.Time `json:"updatedAt"`
+	GoogleId  string     `json:"-"`
+}
+
+type UserEditable struct {
+	Email    string `json:"email" validate:"required"`
+	Nickname string `json:"nickname" validate:"required"`
+}

storage/model/user_data.go

@@ -0,0 +1,17 @@
+package model
+
+import "time"
+
+type UserData struct {
+	UserEditable
+	ID        string     `json:"id"`
+	CreatedAt time.Time  `json:"createdAt"`
+	UpdatedAt *time.Time `json:"updatedAt"`
+}
+
+type UserDataEditable struct {
+	UserId  string `json:'userId'`
+	Type    string `json:"type"`
+	Name    string `json:"name"`
+	Content string `json:"content"`
+}

storage/validators/error.go

@@ -0,0 +1,44 @@
+package validators
+
+import (
+	"fmt"
+	"hamster-tycoon/storage/model"
+	"hamster-tycoon/utils"
+	"regexp"
+	"strings"
+
+	"gopkg.in/go-playground/validator.v9"
+)
+
+var regexpValidatorNamespacePrefix = regexp.MustCompile(`^\w+\.`)
+
+func NewDataValidationAPIError(err error) model.APIError {
+	apiErr := model.ErrDataValidation
+	if err != nil {
+		if _, ok := err.(*validator.InvalidValidationError); ok {
+			utils.GetLogger().WithError(err).WithField("templateAPIErr", apiErr).Error("InvalidValidationError")
+		} else {
+			for _, e := range err.(validator.ValidationErrors) {
+				reason := e.Tag()
+				if _, ok := CustomValidators[e.Tag()]; ok {
+					reason = truncatingSprintf(CustomValidators[e.Tag()].Message, e.Param())
+				}
+
+				namespaceWithoutStructName := regexpValidatorNamespacePrefix.ReplaceAllString(e.Namespace(), "")
+				fe := model.FieldError{
+					Field:       namespaceWithoutStructName,
+					Constraint:  e.Tag(),
+					Description: reason,
+				}
+				apiErr.Details = append(apiErr.Details, fe)
+			}
+		}
+	}
+	return apiErr
+}
+
+// truncatingSprintf is used as fmt.Sprintf but allow to truncate the additional parameters given when there is more parameters than %v in str
+func truncatingSprintf(str string, args ...interface{}) string {
+	n := strings.Count(str, "%v")
+	return fmt.Sprintf(str, args[:n]...)
+}

storage/validators/validators.go

@@ -0,0 +1,34 @@
+package validators
+
+import (
+	"context"
+	"strings"
+
+	"gopkg.in/go-playground/validator.v9"
+)
+
+var (
+	CustomValidators = map[string]customValidator{
+		"enum": {
+			Message:   "This field should be in: %v",
+			Validator: validateEnum,
+		},
+		"required": {
+			Message: "This field is required and cannot be empty",
+		},
+	}
+)
+
+type customValidator struct {
+	Message   string
+	Validator validator.FuncCtx
+}
+
+func validateEnum(ctx context.Context, fl validator.FieldLevel) bool {
+	for _, v := range strings.Split(fl.Param(), " ") {
+		if v == fl.Field().String() {
+			return true
+		}
+	}
+	return false
+}