Dashboard layout

docker-compose.yml

@@ -10,10 +10,13 @@ services:
       - "${DB_PORT}:5432"
     volumes:
       - psql_volume_bp:/var/lib/postgresql/data
+    networks:
+      - dev_network
 
   minio:
     image: minio/minio:latest
     environment:
+      MINIO_SERVER_URL: http://localhost:${MINIO_PORT:-9000}
       MINIO_ROOT_USER: ${MINIO_ROOT_USER}
       MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD}
     command: server /data
@@ -22,13 +25,17 @@ services:
     volumes:
       - minio_data:/data
     restart: unless-stopped
+    networks:
+      - dev_network
 
   mailhog:
     image: mailhog/mailhog:latest
     ports:
       - "1025:1025" # SMTP server
       - "8025:8025" # Web UI for email testing
     restart: unless-stopped
+    networks:
+      - dev_network
 
   redis:
     image: redis:latest
@@ -37,6 +44,11 @@ services:
     volumes:
       - redis_data:/data
     restart: unless-stopped
+    networks:
+      - dev_network
+
+networks:
+  dev_network:
 
 volumes:
   psql_volume_bp:

internal/app/container.go

@@ -1,18 +1,19 @@
 package app
 
 import (
-	"sync"
-
 	"keizer-auth/internal/database"
 	"keizer-auth/internal/repositories"
 	"keizer-auth/internal/services"
+	"sync"
 )
 
 type Container struct {
-	DB             database.Service
-	AuthService    *services.AuthService
-	SessionService *services.SessionService
-	EmailService   *services.EmailService
+	DB                 database.Service
+	AuthService        *services.AuthService
+	SessionService     *services.SessionService
+	EmailService       *services.EmailService
+	AccountService     *services.AccountService
+	ApplicationService *services.ApplicationService
 }
 
 var (
@@ -27,14 +28,22 @@ func GetContainer() *Container {
 		rds := database.NewRedisClient()
 
 		userRepo := repositories.NewUserRepository(gormDB)
+		accountRepo := repositories.NewAccountRepository(gormDB)
+		applicationRepo := repositories.NewApplicationRepository(gormDB)
+		userAccountRepo := repositories.NewUserAccountRepository(gormDB)
 		redisRepo := repositories.NewRedisRepository(rds)
+
 		authService := services.NewAuthService(userRepo, redisRepo)
 		sessionService := services.NewSessionService(redisRepo, userRepo)
+		accountService := services.NewAccountService(accountRepo, userAccountRepo)
+		applicationService := services.NewApplicationService(applicationRepo, accountRepo)
 
 		container = &Container{
-			DB:             db,
-			AuthService:    authService,
-			SessionService: sessionService,
+			DB:                 db,
+			AuthService:        authService,
+			SessionService:     sessionService,
+			AccountService:     accountService,
+			ApplicationService: applicationService,
 		}
 	})
 	return container

internal/app/controllers.go

@@ -3,11 +3,15 @@ package app
 import "keizer-auth/internal/controllers"
 
 type ServerControllers struct {
-	Auth *controllers.AuthController
+	Auth        *controllers.AuthController
+	Account     *controllers.AccountController
+	Application *controllers.ApplicationController
 }
 
 func GetControllers(container *Container) *ServerControllers {
 	return &ServerControllers{
-		Auth: controllers.NewAuthController(container.AuthService, container.SessionService),
+		Auth:        controllers.NewAuthController(container.AuthService, container.SessionService),
+		Account:     controllers.NewAccountController(container.AccountService),
+		Application: controllers.NewApplicationController(container.ApplicationService),
 	}
 }

internal/app/middlewares.go

@@ -0,0 +1,15 @@
+package app
+
+import (
+	"keizer-auth/internal/middlewares"
+)
+
+type ServerMiddlewares struct {
+	Auth *middlewares.AuthMiddleware
+}
+
+func GetMiddlewares(container *Container) *ServerMiddlewares {
+	return &ServerMiddlewares{
+		Auth: middlewares.NewAuthMiddleware(container.SessionService),
+	}
+}

internal/constants/constants.go

@@ -0,0 +1,3 @@
+package constants
+
+const UserContextKey = "currentUser"

internal/controllers/account_controller.go

@@ -0,0 +1,55 @@
+package controllers
+
+import (
+	"keizer-auth/internal/models"
+	"keizer-auth/internal/services"
+	"keizer-auth/internal/utils"
+	"keizer-auth/internal/validators"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+type AccountController struct {
+	accountService *services.AccountService
+}
+
+func NewAccountController(
+	accountService *services.AccountService,
+) *AccountController {
+	return &AccountController{accountService: accountService}
+}
+
+func (self *AccountController) Get(c *fiber.Ctx) error {
+	user := utils.GetCurrentUser(c)
+	accounts, err := self.accountService.GetAccountsByUser(user.ID)
+	if err != nil {
+		return c.SendStatus(fiber.StatusInternalServerError)
+	}
+	return c.JSON(accounts)
+}
+
+func (self *AccountController) Create(c *fiber.Ctx) error {
+	var err error
+	user := utils.GetCurrentUser(c)
+	body := new(validators.CreateAccount)
+
+	if err := c.BodyParser(body); err != nil {
+		return c.
+			Status(fiber.StatusBadRequest).
+			JSON(fiber.Map{"error": "Invalid request body"})
+	}
+
+	if err := body.ValidateFile(); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": err.Error(),
+		})
+	}
+
+	account := new(models.Account)
+	account, err = self.accountService.Create(body.Name, user.ID)
+	if err != nil {
+		return c.SendStatus(fiber.StatusInternalServerError)
+	}
+
+	return c.JSON(account)
+}

internal/controllers/applicaton_controller.go

@@ -0,0 +1,57 @@
+package controllers
+
+import (
+	"keizer-auth/internal/models"
+	"keizer-auth/internal/services"
+	"keizer-auth/internal/utils"
+	"keizer-auth/internal/validators"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+type ApplicationController struct {
+	applicationService *services.ApplicationService
+}
+
+func NewApplicationController(
+	applicationService *services.ApplicationService,
+) *ApplicationController {
+	return &ApplicationController{
+		applicationService: applicationService,
+	}
+}
+
+func (self *ApplicationController) Get(c *fiber.Ctx) error {
+	user := utils.GetCurrentUser(c)
+	applications, err := self.applicationService.Get(user.ID, user.ID)
+	if err != nil {
+		return c.SendStatus(fiber.StatusInternalServerError)
+	}
+	return c.JSON(applications)
+}
+
+func (self *ApplicationController) Create(c *fiber.Ctx) error {
+	var err error
+	user := utils.GetCurrentUser(c)
+	body := new(validators.CreateApplication)
+
+	if err := c.BodyParser(body); err != nil {
+		return c.
+			Status(fiber.StatusBadRequest).
+			JSON(fiber.Map{"error": "Invalid request body"})
+	}
+
+	if err := body.ValidateFile(); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": err.Error(),
+		})
+	}
+
+	account := new(models.Account)
+	account, err = self.applicationService.Create(body.Name, account.ID user.ID)
+	if err != nil {
+		return c.SendStatus(fiber.StatusInternalServerError)
+	}
+
+	return c.JSON(account)
+}

internal/controllers/auth_controller.go

@@ -3,7 +3,6 @@ package controllers
 import (
 	"errors"
 	"fmt"
-
 	"keizer-auth/internal/models"
 	"keizer-auth/internal/services"
 	"keizer-auth/internal/utils"
@@ -53,6 +52,9 @@ func (ac *AuthController) SignIn(c *fiber.Ctx) error {
 				"error": "User is not verified. Please verify your account before signing in.",
 			})
 	}
+	if user.Type != models.Dashboard {
+		return c.SendStatus(fiber.StatusBadRequest)
+	}
 
 	isValid, err := ac.authService.VerifyPassword(
 		body.Password,
@@ -65,7 +67,7 @@ func (ac *AuthController) SignIn(c *fiber.Ctx) error {
 	}
 	if !isValid {
 		return c.
-			Status(fiber.StatusUnauthorized).
+			Status(fiber.StatusBadRequest).
 			JSON(fiber.Map{"error": "Invalid email or password. Please try again."})
 	}
 
@@ -76,8 +78,10 @@ func (ac *AuthController) SignIn(c *fiber.Ctx) error {
 			JSON(fiber.Map{"error": "Something went wrong, Failed to create session"})
 	}
 
+	fmt.Printf("%v", sessionId)
+	fmt.Print(sessionId)
 	utils.SetSessionCookie(c, sessionId)
-	return c.JSON(fiber.Map{"message": "signed in successfully"})
+	return c.JSON(user)
 }
 
 func (ac *AuthController) SignUp(c *fiber.Ctx) error {
@@ -149,23 +153,10 @@ func (ac *AuthController) VerifyOTP(c *fiber.Ctx) error {
 	}
 
 	utils.SetSessionCookie(c, sessionID)
-	return c.JSON(fiber.Map{"message": "OTP Verified!"})
+	return c.JSON(user)
 }
 
-func (ac *AuthController) VerifyTokenHandler(c *fiber.Ctx) error {
-	sessionID := utils.GetSessionCookie(c)
-	if sessionID == "" {
-		return c.
-			Status(fiber.StatusUnauthorized).
-			JSON(fiber.Map{"error": "Unauthorized"})
-	}
-
-	user := new(models.User)
-	if err := ac.sessionService.GetSession(sessionID, user); err != nil {
-		return c.
-			Status(fiber.StatusUnauthorized).
-			JSON(fiber.Map{"error": "Unauthorized"})
-	}
-
+func (ac *AuthController) Profile(c *fiber.Ctx) error {
+	user := utils.GetCurrentUser(c)
 	return c.JSON(user)
 }

internal/database/database.go

@@ -3,13 +3,12 @@ package database
 import (
 	"context"
 	"fmt"
+	"keizer-auth/internal/models"
 	"log"
 	"os"
 	"strconv"
 	"time"
 
-	"keizer-auth/internal/models"
-
 	_ "github.com/joho/godotenv/autoload"
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
@@ -42,7 +41,6 @@ var (
 )
 
 func New() Service {
-	// Reuse Connection
 	if dbInstance != nil {
 		return dbInstance
 	}
@@ -83,10 +81,39 @@ func GetDB() *gorm.DB {
 }
 
 func autoMigrate(db *gorm.DB) error {
-	return db.AutoMigrate(
-		&models.User{},
+	user := &models.User{}
+	if err := user.BeforeMigrate(db); err != nil {
+		return err
+	}
+
+	if err := db.AutoMigrate(
+		user,
 		&models.Domain{},
-	)
+		&models.Account{},
+		&models.UserAccount{},
+	); err != nil {
+		return err
+	}
+
+	if err := db.Exec(`
+    DO $$
+    BEGIN
+        IF NOT EXISTS (
+            SELECT 1 
+            FROM information_schema.constraint_column_usage 
+            WHERE table_name = 'user_accounts' 
+              AND constraint_name = 'check_role'
+        ) THEN
+            ALTER TABLE user_accounts 
+            ADD CONSTRAINT check_role 
+            CHECK (role IN ('admin', 'member'));
+        END IF;
+    END $$;
+  `).Error; err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // Health checks the health of the database connection by pinging the database.