Rework

config/server/config.go

@@ -13,13 +13,12 @@ import (
 	"passKeeper/internal/server/controllers"
 
 	"github.com/caarlos0/env"
-	"github.com/jinzhu/gorm"
 	"github.com/joho/godotenv"
 )
 
 type App struct {
 	config ServerConfig
-	dbConn *gorm.DB
+	repo   db.DatabaseRepository
 }
 
 type ServerConfig struct {
@@ -43,20 +42,21 @@ type ServerLog struct {
 }
 
 func (a *App) NewWebServer(conf App) {
-	controllers.NewHTTPServer(a.config.ServerPort, conf.dbConn)
-	a.dbConn = conf.dbConn
+	controllers.NewHTTPServer(a.config.ServerPort, conf.repo)
+	a.repo = conf.repo
 }
 
 func (a App) CreateTables() {
-	a.dbConn.AutoMigrate(&acc.Account{}, &sec.Secret{})
+	a.repo.AutoMigrate(&acc.Account{}, &sec.Secret{})
 }
 
 func (a App) DefineJWTConfig() {
 	auth.InitJWTPassword(a.config.JWTPassword, a.config.ExpirationTime)
 }
 
 func New(sc ServerConfig) *App {
-	return &App{config: sc, dbConn: db.Get(sc.Database)}
+	repo := db.Get(sc.Database)
+	return &App{config: sc, repo: repo}
 }
 
 func NewServerConfig() *ServerConfig {

internal/models/account/account.go

@@ -2,9 +2,6 @@ package models
 
 import (
 	auth "passKeeper/internal/models/auth"
-	server "passKeeper/internal/models/server"
-
-	"github.com/jinzhu/gorm"
 )
 
 type Account struct {
@@ -14,56 +11,7 @@ type Account struct {
 	Token    string `json:"token" sql:"-"`
 }
 
-func (account *Account) Validate(dbConn *gorm.DB) server.Response {
-
-	if len(account.Login) < 3 {
-		return server.Message("Login is not valid", 400)
-	}
-	if len(account.Password) < 6 {
-		return server.Message("Valid password is required", 400)
-	}
-	existingAccount := &Account{}
-	err := dbConn.Table("accounts").Where("login = ?", account.Login).First(existingAccount).Error
-	if err != nil && err != gorm.ErrRecordNotFound {
-		return server.Message("Connection error. Please retry", 502)
-	}
-	if existingAccount.Login != "" {
-		return server.Message("Email address already in use by another user.", 409)
-	}
-	return server.Message("Requirement passed", 200)
-}
-
-func (account *Account) Create(dbConn *gorm.DB) server.Response {
-	if resp := account.Validate(dbConn); resp.ServerCode != 200 {
-		return resp
-	}
-	account.Password = auth.EncryptPassword(account.Password)
-	dbConn.Create(account)
-	if account.ID == 0 {
-		return server.Message("Failed to create account, connection error.", 501)
-	}
-	account.Token = account.getToken()
-	account.Password = ""
-	return server.Response{Message: account, ServerCode: 200}
-}
-
-func Login(email, password string, dbConn *gorm.DB) server.Response {
-	account := &Account{}
-	err := dbConn.Table("accounts").Where("login = ?", email).First(account).Error
-	if err != nil {
-		if err == gorm.ErrRecordNotFound {
-			return server.Message("Email address not found", 401)
-		}
-		return server.Message("Connection error. Please retry", 500)
-	}
-
-	if !auth.IsPasswordsEqual(account.Password, password) {
-		return server.Message("Invalid login credentials. Please try again", 401)
-	}
-	tokenString := account.getToken()
-	return server.Response{ServerCode: 200, Message: tokenString}
-}
-func (account *Account) getToken() string {
+func (account *Account) GetToken() string {
 
 	return auth.GenerateToken(account.ID)
 }

internal/models/database/database.go

@@ -1,17 +1,132 @@
 package models
 
 import (
+	"errors"
 	"log"
 
+	acc "passKeeper/internal/models/account"
+	auth "passKeeper/internal/models/auth"
+	sec "passKeeper/internal/models/secret"
+	server "passKeeper/internal/models/server"
+
 	"github.com/jinzhu/gorm"
 	_ "github.com/jinzhu/gorm/dialects/postgres"
 )
 
-func Get(connStr string) *gorm.DB {
-
+func Get(connStr string) DatabaseRepository {
 	conn, err := gorm.Open("postgres", connStr)
 	if err != nil {
 		log.Fatalf("Error is %e \n Connection string is %s", err, connStr)
 	}
-	return conn
+	return &GormRepository{db: conn}
+}
+
+type DatabaseRepository interface {
+	AutoMigrate(models ...interface{}) error
+	CreateAccount(account *acc.Account) server.Response
+	ValidateAccount(account *acc.Account) server.Response
+	LoginAccount(email, password string) server.Response
+	GetSecretByID(secretID uint) (*sec.Secret, error)
+	SaveSecret(s *sec.Secret) (*sec.Secret, error)
+	GetSecretsForUser(userID uint) ([]sec.Secret, error)
+	DeleteSecret(s *sec.Secret) error
+}
+
+type GormRepository struct {
+	db *gorm.DB
+}
+
+func (g *GormRepository) AutoMigrate(models ...interface{}) error {
+	g.db = g.db.AutoMigrate(models...)
+	if g.db.Error != nil {
+		return g.db.Error
+	}
+	return nil
+}
+func (g *GormRepository) LoginAccount(email, password string) server.Response {
+	account := &acc.Account{}
+	err := g.db.Table("accounts").Where("login = ?", email).First(account).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return server.Message("Email address not found", 401)
+		}
+		return server.Message("Connection error. Please retry", 500)
+	}
+
+	if !auth.IsPasswordsEqual(account.Password, password) {
+		return server.Message("Invalid login credentials. Please try again", 401)
+	}
+	tokenString := account.GetToken()
+	return server.Response{ServerCode: 200, Message: tokenString}
+}
+
+func (g *GormRepository) CreateAccount(account *acc.Account) server.Response {
+	if resp := g.ValidateAccount(account); resp.ServerCode != 200 {
+		return resp
+	}
+	account.Password = auth.EncryptPassword(account.Password)
+	g.db.Create(account)
+	if account.ID == 0 {
+		return server.Message("Failed to create account, connection error.", 501)
+	}
+	account.Token = account.GetToken()
+	account.Password = ""
+	return server.Response{Message: account, ServerCode: 200}
+}
+func (g *GormRepository) ValidateAccount(account *acc.Account) server.Response {
+	if len(account.Login) < 3 {
+		return server.Message("Login is not valid", 400)
+	}
+	if len(account.Password) < 6 {
+		return server.Message("Valid password is required", 400)
+	}
+	existingAccount := &acc.Account{}
+	err := g.db.Table("accounts").Where("login = ?", account.Login).First(existingAccount).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return server.Message("Connection error. Please retry", 502)
+	}
+	if existingAccount.Login != "" {
+		return server.Message("Email address already in use by another user.", 409)
+	}
+	return server.Message("Requirement passed", 200)
+}
+
+func (g *GormRepository) DeleteSecret(s *sec.Secret) error {
+	sec, err := g.GetSecretByID(s.ID)
+	if err != nil {
+		return err
+	}
+	if sec.UserID == s.UserID {
+		result := g.db.Delete(s)
+		if result.Error != nil {
+			return result.Error
+		}
+	}
+	return nil
+}
+func (g *GormRepository) GetSecretByID(secretID uint) (*sec.Secret, error) {
+	secret := sec.Secret{}
+	err := g.db.Table("secrets").Where("ID = ?", secretID).Find(&secret).Error
+	if err != nil {
+		log.Println(err)
+		return nil, err
+	}
+
+	return &secret, nil
+}
+
+func (g *GormRepository) SaveSecret(s *sec.Secret) (*sec.Secret, error) {
+	result := g.db.Save(s)
+	if result.Error != nil || s.ID == 0 {
+		return nil, errors.New("failed to save secret, connection error")
+	}
+	return s, nil
+}
+func (g *GormRepository) GetSecretsForUser(userID uint) ([]sec.Secret, error) {
+	var secrets []sec.Secret
+	result := g.db.Table("secrets").Where("User_ID = ?", userID).Find(&secrets)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+	return secrets, nil
 }

internal/models/secret/secret.go

@@ -3,12 +3,8 @@ package models
 import (
 	"encoding/base64"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"log"
 	"regexp"
-
-	"github.com/jinzhu/gorm"
 )
 
 type SecretRequest struct {
@@ -42,44 +38,6 @@ func NewSecret(userID uint, secretType string, value ByteConvertible, meta strin
 	return Secret{UserID: userID, Value: bytes, SecretType: secretType, Metadata: meta}, nil
 }
 
-func GetSecret(secretid uint, dbConn *gorm.DB) *Secret {
-	secret := Secret{}
-	err := dbConn.Table("secrets").Where("ID = ?", secretid).Find(&secret).Error
-	if err != nil {
-		log.Println(err)
-		return nil
-	}
-
-	return &secret
-}
-
-func (s *Secret) Save(dbConn *gorm.DB) (*Secret, error) {
-	dbConn.Save(s)
-
-	if s.ID == 0 {
-		return nil, errors.New("failed to create secret, connection error")
-	}
-	return s, nil
-}
-
-func (s *Secret) Delete(dbConn *gorm.DB) {
-
-	sec := GetSecret(s.ID, dbConn)
-	if sec.UserID == s.UserID {
-		dbConn.Delete(s)
-	}
-}
-
-func GetSecretsForUser(userID uint, dbConn *gorm.DB) ([]Secret, error) {
-	secrets := []Secret{}
-	err := dbConn.Table("secrets").Where("User_ID = ?", userID).Find(&secrets).Error
-	if err != nil {
-		log.Println(err)
-		return nil, err
-	}
-
-	return secrets, nil
-}
 func GetSecretFromRequest(req SecretRequest, user uint) (ByteConvertible, error) {
 	var value ByteConvertible
 	switch req.Type {

internal/server/controllers/accountController.go

@@ -4,19 +4,18 @@ import (
 	"encoding/json"
 	"net/http"
 	acc "passKeeper/internal/models/account"
+	db "passKeeper/internal/models/database"
 	server "passKeeper/internal/models/server"
-
-	"github.com/jinzhu/gorm"
 )
 
-func CreateAccount(dbConn *gorm.DB) func(w http.ResponseWriter, r *http.Request) {
+func CreateAccount(repo db.DatabaseRepository) func(w http.ResponseWriter, r *http.Request) {
 	return func(w http.ResponseWriter, r *http.Request) {
 		account := &acc.Account{}
 		err := json.NewDecoder(r.Body).Decode(account)
 		if err != nil {
 			server.RespondWithMessage(w, 400, "Invalid request")
 		}
-		resp := account.Create(dbConn)
+		resp := repo.CreateAccount(account)
 		if resp.ServerCode == 200 {
 			w.Header().Add("Authorization", account.Token)
 		}

internal/server/controllers/authControllers.go

@@ -6,19 +6,18 @@ import (
 	"net/http"
 	account "passKeeper/internal/models/account"
 	auth "passKeeper/internal/models/auth"
+	db "passKeeper/internal/models/database"
 	server "passKeeper/internal/models/server"
-
-	"github.com/jinzhu/gorm"
 )
 
-func Authenticate(dbCon *gorm.DB) func(w http.ResponseWriter, r *http.Request) {
+func Authenticate(repo db.DatabaseRepository) func(w http.ResponseWriter, r *http.Request) {
 	return func(w http.ResponseWriter, r *http.Request) {
 		acc := &account.Account{}
 		err := json.NewDecoder(r.Body).Decode(acc)
 		if err != nil || acc.Login == "" || acc.Password == "" {
 			server.RespondWithMessage(w, 400, "Invalid request")
 		}
-		resp := account.Login(acc.Login, acc.Password, dbCon)
+		resp := repo.LoginAccount(acc.Login, acc.Password)
 		w.Header().Add("Authorization", resp.Message.(string))
 		server.RespondWithMessage(w, resp.ServerCode, resp.Message)
 	}