Alex/GoMembership
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

wip

Browse Source
This commit is contained in:
$(pass /github/name)
2024-07-02 00:27:43 +02:00
parent fbb3bdfcb3
commit 9bd8d48243
11 changed files with 251 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
internal/config/config.go
View File

@@ -1,20 +1,38 @@
package config
import (
"os"
"encoding/json"
"log"
"os"
"path/filepath"
)
type DatabaseConfig struct {
DBPath string `json:"DBPath"`
}
type Config struct {
DBUser string
DBPassword string
DBName string
DB DatabaseConfig `json:"db"`
}
func LoadConfig() *Config {
return &Config{
DBUser: os.Getenv("DB_USER"),
DBPassword: os.Getenv("DB_PASSWORD"),
DBName: os.Getenv("DB_NAME"),
}
}
path, err := os.Getwd()
if err != nil {
log.Fatalf("could not get working directory: %v", err)
}
configFile, err := os.Open(filepath.Join(path, "configs", "config.json"))
if err != nil {
log.Fatalf("could not open config file: %v", err)
}
defer configFile.Close()
decoder := json.NewDecoder(configFile)
config := &Config{}
err = decoder.Decode(config)
if err != nil {
log.Fatalf("could not decode config file: %v", err)
}
return config
}

60
internal/controllers/user_controller.go
View File

@@ -1,31 +1,57 @@
package controllers
import (
"encoding/json"
"net/http"
"GoMembership/internal/models"
"GoMembership/internal/services"
"GoMembership/internal/models"
"GoMembership/internal/services"
"encoding/json"
// "github.com/gorilla/mux"
"net/http"
// "strconv"
)
type UserController struct {
service services.UserService
service services.UserService
}
func NewUserController(service services.UserService) *UserController {
return &UserController{service}
return &UserController{service}
}
func (uc *UserController) RegisterUser(w http.ResponseWriter, r *http.Request) {
var user models.User
if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if err := uc.service.RegisterUser(&user); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusCreated)
var user models.User
if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if err := uc.service.RegisterUser(&user); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusCreated)
}
/* func (uc *UserController) LoginUser(w http.ResponseWriter, r *http.Request) {
var credentials struct {
Email string `json:"email"`
Password string `json:"password"`
}
user, err := uc.service.AuthenticateUser(credentials.Email, credentials.Password)
if err != nil {
http.Error(w, err.Error(), http.StatusUnauthorized)
return
}
json.NewEncoder(w).Encode(user)
} */
/* func (uc *UserController) GetUserID(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
id, err := strconv.Atoi(vars["id"])
if err != nil {
http.Error(w, "Invalid user ID", http.StatusBadRequest)
return
}
user, err := uc.service.GetUserByID(id)
if err != nil {
http.Error(w, "User not found: "+err.Error(), http.StatusNotFound)
}
} */

48
internal/database/db.go
View File

@@ -1,23 +1,41 @@
package database
import (
"database/sql"
"log"
"GoMembership/internal/config"
"GoMembership/internal/config"
"database/sql"
"log"
"os"
_ "github.com/go-sql-driver/mysql"
_ "github.com/mattn/go-sqlite3"
)
func Connect() *sql.DB {
cfg := config.LoadConfig()
dsn := cfg.DBUser + ":" + cfg.DBPassword + "@/" + cfg.DBName
db, err := sql.Open("mysql", dsn)
if err != nil {
log.Fatal(err)
}
if err := db.Ping(); err != nil {
log.Fatal(err)
}
return db
func initializeDB(dbPath string, schemaPath string) error {
db, err := sql.Open("sqlite3", dbPath)
if err != nil {
return err
}
defer db.Close()
schema, err := os.ReadFile(schemaPath)
if err != nil {
return err
}
_, err = db.Exec(string(schema))
if err != nil {
return err
}
return nil
}
func Connect() *sql.DB {
cfg := config.LoadConfig()
dsn := cfg.DB.DBPath
db, err := sql.Open("sqlite3", dsn)
if err != nil {
log.Fatal(err)
}
if err := db.Ping(); err != nil {
log.Fatal(err)
}
return db
}

19
internal/models/user.go
View File

@@ -3,12 +3,15 @@ package models
import "time"
type User struct {
ID int `json:"id"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
Email string `json:"email"`
Password string `json:"password"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
MandateDateSigned time.Time `json:"mandate_date_signed"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
Email string `json:"email"`
Password string `json:"password"`
IBAN string `json:"iban"`
BIC string `json:"bic"`
MandateReference string `json:"mandate_reference"`
ID int `json:"id"`
}

31
internal/repositories/user_repository.go
View File

@@ -1,25 +1,40 @@
package repositories
import (
"database/sql"
"GoMembership/internal/models"
"GoMembership/internal/models"
"GoMembership/pkg/errors"
"database/sql"
)
type UserRepository interface {
CreateUser(user *models.User) error
CreateUser(user *models.User) error
FindUserByID(id int) (*models.User, error)
// FindUserByEmail(email string) (*models.User, error)
}
type userRepository struct {
db *sql.DB
db *sql.DB
}
func NewUserRepository(db *sql.DB) UserRepository {
return &userRepository{db}
return &userRepository{db}
}
func (r *userRepository) CreateUser(user *models.User) error {
query := "INSERT INTO users (first_name, last_name, email, password, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
_, err := r.db.Exec(query, user.FirstName, user.LastName, user.Email, user.Password, user.CreatedAt, user.UpdatedAt)
return err
query := "INSERT INTO users (first_name, last_name, email, password, iban, bic, mandate_reference, mandate_date_signed, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
_, err := r.db.Exec(query, user.FirstName, user.LastName, user.Email, user.Password, user.CreatedAt, user.UpdatedAt)
return err
}
func (r *userRepository) FindUserByID(id int) (*models.User, error) {
var user models.User
query := "SELECT id, first_name, last_name, email, iban, bic, mandate_reference FROM users WHERE id = ?"
err := r.db.QueryRow(query, id).Scan(&user.ID, &user.FirstName, &user.LastName, &user.Email, &user.IBAN, &user.BIC, &user.MandateReference)
if err != nil {
if err == sql.ErrNoRows {
return nil, errors.ErrUserNotFound
}
return nil, err
}
return &user, nil
}

42
internal/server/server.go
View File

@@ -1,32 +1,32 @@
package server
import (
"database/sql"
"log"
"GoMembership/internal/controllers"
"GoMembership/internal/repositories"
"GoMembership/internal/routes"
"GoMembership/internal/services"
"net/http"
// "GoMembership/internal/config"
"GoMembership/internal/controllers"
"GoMembership/internal/database"
"GoMembership/internal/repositories"
"GoMembership/internal/routes"
"GoMembership/internal/services"
"log"
"net/http"
"github.com/gorilla/mux"
_ "github.com/go-sql-driver/mysql"
"github.com/gorilla/mux"
)
func Run() {
db, err := sql.Open("mysql", "user:password@/dbname")
if err != nil {
log.Fatal(err)
}
defer db.Close()
// cfg := config.LoadConfig()
db := database.Connect()
defer db.Close()
userRepo := repositories.NewUserRepository(db)
userService := services.NewUserService(userRepo)
userController := controllers.NewUserController(userService)
userRepo := repositories.NewUserRepository(db)
userService := services.NewUserService(userRepo)
userController := controllers.NewUserController(userService)
router := mux.NewRouter()
routes.RegisterRoutes(router, userController)
router := mux.NewRouter()
routes.RegisterRoutes(router, userController)
log.Fatal(http.ListenAndServe(":8080", router))
log.Println("Starting server on :8080")
if err := http.ListenAndServe(":8080", router); err != nil {
log.Fatalf("could not start server: %v", err)
}
}

29
internal/services/user_service.go
View File

@@ -1,29 +1,32 @@
package services
import (
"GoMembership/internal/models"
"GoMembership/internal/repositories"
"golang.org/x/crypto/bcrypt"
"GoMembership/internal/models"
"GoMembership/internal/repositories"
"golang.org/x/crypto/bcrypt"
"time"
)
type UserService interface {
RegisterUser(user *models.User) error
RegisterUser(user *models.User) error
}
type userService struct {
repo repositories.UserRepository
repo repositories.UserRepository
}
func NewUserService(repo repositories.UserRepository) UserService {
return &userService{repo}
return &userService{repo}
}
func (s *userService) RegisterUser(user *models.User) error {
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(user.Password), bcrypt.DefaultCost)
if err != nil {
return err
}
user.Password = string(hashedPassword)
return s.repo.CreateUser(user)
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(user.Password), bcrypt.DefaultCost)
if err != nil {
return err
}
user.Password = string(hashedPassword)
user.CreatedAt = time.Now()
user.UpdatedAt = time.Now()
user.MandateDateSigned = time.Now()
return s.repo.CreateUser(user)
}