first commit

internal/routers/auth.go

@@ -0,0 +1,53 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/controllers"
+	"learnsteam/cslms-api/internal/repositories"
+	"learnsteam/cslms-api/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func InitAuthRouter(db *gorm.DB, router *gin.Engine) {
+	r := NewAuthRouter(db, router)
+	r.SetAuthRouter()
+}
+
+type AuthRouter interface {
+	SetRouter(db *gorm.DB, router *gin.Engine)
+}
+
+type authRouter struct {
+	db              *gorm.DB
+	userRepository  repositories.UserRepository
+	tokenRepository repositories.TokenRepository
+	service         services.AuthService
+	tokenService    services.TokenService
+	controller      controllers.AuthController
+	router          *gin.Engine
+}
+
+func NewAuthRouter(db *gorm.DB, router *gin.Engine) *authRouter {
+	userRepository := repositories.NewUserRepository(db)
+	tokenRepository := repositories.NewTokenRepository(db)
+	service := services.NewAuthService(userRepository, tokenRepository)
+	tokenService := services.NewTokenService(tokenRepository)
+	controller := controllers.NewAuthController(service, tokenService)
+
+	return &authRouter{
+		db:              db,
+		userRepository:  userRepository,
+		tokenRepository: tokenRepository,
+		service:         service,
+		tokenService:    tokenService,
+		controller:      controller,
+		router:          router,
+	}
+}
+
+func (r *authRouter) SetAuthRouter() {
+	group := r.router.Group("/auth")
+	group.POST("login", r.controller.Login)
+	group.POST("register", r.controller.Register)
+}

internal/routers/center.go

@@ -0,0 +1,53 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/controllers"
+	"learnsteam/cslms-api/internal/middleware"
+	"learnsteam/cslms-api/internal/repositories"
+	"learnsteam/cslms-api/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func InitCenterRouter(db *gorm.DB, router *gin.Engine) {
+	r := NewCenterRouter(db, router)
+	r.SetCenterRouter()
+}
+
+type CenterRouter interface {
+	SetRouter(db *gorm.DB, router *gin.Engine)
+}
+
+type centerRouter struct {
+	db         *gorm.DB
+	repository repositories.CenterRepository
+	service    services.CenterService
+	controller controllers.CenterController
+	router     *gin.Engine
+}
+
+func NewCenterRouter(db *gorm.DB, router *gin.Engine) *centerRouter {
+	repository := repositories.NewCenterRepository(db)
+	tokenRepository := repositories.NewTokenRepository(db)
+	service := services.NewCenterService(repository, tokenRepository)
+
+	tokenService := services.NewTokenService(tokenRepository)
+	controller := controllers.NewCenterController(service, tokenService)
+
+	return &centerRouter{
+		db:         db,
+		repository: repository,
+		service:    service,
+		controller: controller,
+		router:     router,
+	}
+}
+
+func (r *centerRouter) SetCenterRouter() {
+	group := r.router.Group("/center")
+	group.GET("", middleware.Auth("admin"), r.controller.List)
+	group.GET("/:id", middleware.Auth("admin"), r.controller.Find)
+	group.POST("", middleware.Auth("admin"), r.controller.Create)
+	group.PUT("/:id", middleware.Auth("admin"), r.controller.Update)
+}

internal/routers/quiz.go

@@ -0,0 +1,50 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/controllers"
+	"learnsteam/cslms-api/internal/middleware"
+	"learnsteam/cslms-api/internal/repositories"
+	"learnsteam/cslms-api/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func InitQuizRouter(db *gorm.DB, router *gin.Engine) {
+	r := NewQuizRouter(db, router)
+	r.SetQuizRouter()
+}
+
+type QuizRouter interface {
+	SetRouter(db *gorm.DB, router *gin.Engine)
+}
+
+type quizRouter struct {
+	db         *gorm.DB
+	repository repositories.QuizRepository
+	service    services.QuizService
+	controller controllers.QuizController
+	router     *gin.Engine
+}
+
+func NewQuizRouter(db *gorm.DB, router *gin.Engine) *quizRouter {
+	repository := repositories.NewQuizRepository(db)
+	service := services.NewQuizService(repository)
+	controller := controllers.NewQuizController(service)
+
+	return &quizRouter{
+		db:         db,
+		repository: repository,
+		service:    service,
+		controller: controller,
+		router:     router,
+	}
+}
+
+func (r *quizRouter) SetQuizRouter() {
+	group := r.router.Group("/quiz")
+	group.GET("", middleware.Auth("admin"), r.controller.List)
+	group.GET("/:id", middleware.Auth("admin"), r.controller.Find)
+	group.POST("", middleware.Auth("admin"), r.controller.Create)
+	group.PUT("/:id", middleware.Auth("admin"), r.controller.Update)
+}

internal/routers/quizpaper.go

@@ -0,0 +1,57 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/controllers"
+	"learnsteam/cslms-api/internal/middleware"
+	"learnsteam/cslms-api/internal/repositories"
+	"learnsteam/cslms-api/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func InitQuizPaperRouter(db *gorm.DB, router *gin.Engine) {
+	r := NewQuizPaperRouter(db, router)
+	r.SetQuizPaperRouter()
+}
+
+type QuizPaperRouter interface {
+	SetRouter(db *gorm.DB, router *gin.Engine)
+}
+
+type quizPaperRouter struct {
+	db             *gorm.DB
+	repository     repositories.QuizPaperRepository
+	quizRepository repositories.QuizRepository
+	service        services.QuizPaperService
+	quizService    services.QuizService
+	controller     controllers.QuizPaperController
+	router         *gin.Engine
+}
+
+func NewQuizPaperRouter(db *gorm.DB, router *gin.Engine) *quizPaperRouter {
+	repository := repositories.NewQuizPaperRepository(db)
+	quizRepository := repositories.NewQuizRepository(db)
+	service := services.NewQuizPaperService(repository)
+	quizService := services.NewQuizService(quizRepository)
+	controller := controllers.NewQuizPaperController(service, quizService)
+
+	return &quizPaperRouter{
+		db:             db,
+		repository:     repository,
+		quizRepository: quizRepository,
+		service:        service,
+		quizService:    quizService,
+		controller:     controller,
+		router:         router,
+	}
+}
+
+func (r *quizPaperRouter) SetQuizPaperRouter() {
+	group := r.router.Group("/quizpaper")
+	group.GET("", middleware.Auth("admin"), r.controller.List)
+	group.GET("/:id", middleware.Auth("admin"), r.controller.Find)
+	group.POST("", middleware.Auth("admin"), r.controller.Create)
+	group.PUT("/:id", middleware.Auth("admin"), r.controller.Update)
+	group.POST("/:id/copy", middleware.Auth("admin"), r.controller.Copy)
+}

internal/routers/router.go

@@ -0,0 +1,33 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/database"
+
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+)
+
+var Router *gin.Engine
+
+func Init() {
+	gin.SetMode(gin.ReleaseMode)
+	Router = gin.Default()
+	config := cors.DefaultConfig()
+	config.AllowOrigins = []string{"http://127.0.0.1:3000", "http://localhost:3000", "http://localhost:3030", "https://learnsteam-quiz.jongyeob.com"}
+	config.AllowMethods = []string{"GET", "POST", "PUT", "DELETE", "PATCH"}
+	config.AllowHeaders = []string{"Origin", "Content-Length", "Content-Type"}
+	Router.Use(cors.New(config))
+
+	maindb := database.GetDB()
+
+	InitAuthRouter(maindb, Router)
+	InitCenterRouter(maindb, Router)
+	InitQuizPaperRouter(maindb, Router)
+	InitQuizRouter(maindb, Router)
+	InitTokenRouter(maindb, Router)
+	InitUserQuizPaperRouter(maindb, Router)
+	InitUserQuizRouter(maindb, Router)
+	InitUserRouter(maindb, Router)
+
+	InitSwaggerRouter(Router)
+}

internal/routers/swagger.go

@@ -0,0 +1,37 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/controllers"
+
+	"github.com/gin-gonic/gin"
+
+	swaggerFiles "github.com/swaggo/files"
+	ginSwagger "github.com/swaggo/gin-swagger"
+)
+
+func InitSwaggerRouter(router *gin.Engine) {
+	r := NewSwaggerRouter(router)
+	r.SetSwaggerRouter()
+}
+
+type SwaggerRouter interface {
+	SetRouter(router *gin.Engine)
+}
+
+type swaggerRouter struct {
+	router     *gin.Engine
+	controller controllers.SwaggerController
+}
+
+func NewSwaggerRouter(router *gin.Engine) *swaggerRouter {
+	controller := controllers.NewSwaggerController()
+	return &swaggerRouter{
+		router:     router,
+		controller: controller,
+	}
+}
+
+func (r *swaggerRouter) SetSwaggerRouter() {
+	group := r.router.Group("/swagger")
+	group.GET("*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
+}

internal/routers/token.go

@@ -0,0 +1,46 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/controllers"
+	"learnsteam/cslms-api/internal/repositories"
+	"learnsteam/cslms-api/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func InitTokenRouter(db *gorm.DB, router *gin.Engine) {
+	r := NewTokenRouter(db, router)
+	r.SetTokenRouter()
+}
+
+type TokenRouter interface {
+	SetRouter(db *gorm.DB, router *gin.Engine)
+}
+
+type tokenRouter struct {
+	db         *gorm.DB
+	repository repositories.TokenRepository
+	service    services.TokenService
+	controller controllers.TokenController
+	router     *gin.Engine
+}
+
+func NewTokenRouter(db *gorm.DB, router *gin.Engine) *tokenRouter {
+	repository := repositories.NewTokenRepository(db)
+	service := services.NewTokenService(repository)
+	controller := controllers.NewTokenController(service)
+
+	return &tokenRouter{
+		db:         db,
+		repository: repository,
+		service:    service,
+		controller: controller,
+		router:     router,
+	}
+}
+
+func (r *tokenRouter) SetTokenRouter() {
+	group := r.router.Group("/token")
+	group.POST("refresh", r.controller.Refresh)
+}

internal/routers/user.go

@@ -0,0 +1,51 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/controllers"
+	"learnsteam/cslms-api/internal/middleware"
+	"learnsteam/cslms-api/internal/repositories"
+	"learnsteam/cslms-api/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func InitUserRouter(db *gorm.DB, router *gin.Engine) {
+	r := NewUserRouter(db, router)
+	r.SetUserRouter()
+}
+
+type UserRouter interface {
+	SetRouter(db *gorm.DB, router *gin.Engine)
+}
+
+type userRouter struct {
+	db         *gorm.DB
+	repository repositories.UserRepository
+	service    services.UserService
+	controller controllers.UserController
+	router     *gin.Engine
+}
+
+func NewUserRouter(db *gorm.DB, router *gin.Engine) *userRouter {
+	repository := repositories.NewUserRepository(db)
+	tokenRepository := repositories.NewTokenRepository(db)
+	service := services.NewUserService(repository, tokenRepository)
+
+	tokenService := services.NewTokenService(tokenRepository)
+	controller := controllers.NewUserController(service, tokenService)
+
+	return &userRouter{
+		db:         db,
+		repository: repository,
+		service:    service,
+		controller: controller,
+		router:     router,
+	}
+}
+
+func (r *userRouter) SetUserRouter() {
+	group := r.router.Group("/user")
+	group.GET("", middleware.Auth("admin"), r.controller.List)
+	group.GET("/:id", middleware.Auth("admin"), r.controller.Find)
+}

internal/routers/userquiz.go

@@ -0,0 +1,53 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/controllers"
+	"learnsteam/cslms-api/internal/middleware"
+	"learnsteam/cslms-api/internal/repositories"
+	"learnsteam/cslms-api/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func InitUserQuizRouter(db *gorm.DB, router *gin.Engine) {
+	r := NewUserQuizRouter(db, router)
+	r.SetUserQuizRouter()
+}
+
+type UserQuizRouter interface {
+	SetRouter(db *gorm.DB, router *gin.Engine)
+}
+
+type userQuizRouter struct {
+	db             *gorm.DB
+	repository     repositories.UserQuizRepository
+	quizRepository repositories.QuizRepository
+	service        services.UserQuizService
+	controller     controllers.UserQuizController
+	router         *gin.Engine
+}
+
+func NewUserQuizRouter(db *gorm.DB, router *gin.Engine) *userQuizRouter {
+	repository := repositories.NewUserQuizRepository(db)
+	quizRepostory := repositories.NewQuizRepository(db)
+	service := services.NewUserQuizService(repository, quizRepostory)
+	controller := controllers.NewUserQuizController(service)
+
+	return &userQuizRouter{
+		db:             db,
+		repository:     repository,
+		quizRepository: quizRepostory,
+		service:        service,
+		controller:     controller,
+		router:         router,
+	}
+}
+
+func (r *userQuizRouter) SetUserQuizRouter() {
+	group := r.router.Group("/userquiz")
+	group.GET("", middleware.Auth("admin"), r.controller.List)
+	group.GET("/:id", middleware.Auth("admin"), r.controller.Find)
+	group.POST("", middleware.Auth("admin"), r.controller.Create)
+	group.PUT("/:id", middleware.Auth("admin"), r.controller.Update)
+}

internal/routers/userquizpaper.go

@@ -0,0 +1,67 @@
+package routers
+
+import (
+	"learnsteam/cslms-api/internal/controllers"
+	"learnsteam/cslms-api/internal/middleware"
+	"learnsteam/cslms-api/internal/repositories"
+	"learnsteam/cslms-api/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func InitUserQuizPaperRouter(db *gorm.DB, router *gin.Engine) {
+	r := NewUserQuizPaperRouter(db, router)
+	r.SetUserQuizPaperRouter()
+}
+
+type UserQuizPaperRouter interface {
+	SetRouter(db *gorm.DB, router *gin.Engine)
+}
+
+type userQuizPaperRouter struct {
+	db         *gorm.DB
+	repository repositories.UserQuizPaperRepository
+	service    services.UserQuizPaperService
+	controller controllers.UserQuizPaperController
+	// quizPaperRepository repositories.QuizPaperRepository
+	// userRepository      repositories.UserRepository
+
+	// quizPaperService services.QuizPaperService
+	// userService      services.UserService
+
+	router *gin.Engine
+}
+
+func NewUserQuizPaperRouter(db *gorm.DB, router *gin.Engine) *userQuizPaperRouter {
+	repository := repositories.NewUserQuizPaperRepository(db)
+	quizRepository := repositories.NewQuizRepository(db)
+	quizPaperRepository := repositories.NewQuizPaperRepository(db)
+	tokenRepository := repositories.NewTokenRepository(db)
+	userRepository := repositories.NewUserRepository(db)
+	userQuizRepository := repositories.NewUserQuizRepository(db)
+
+	service := services.NewUserQuizPaperService(repository)
+	quizPaperService := services.NewQuizPaperService(quizPaperRepository)
+	userService := services.NewUserService(userRepository, tokenRepository)
+	userQuizService := services.NewUserQuizService(userQuizRepository, quizRepository)
+
+	controller := controllers.NewUserQuizPaperController(service, userService, quizPaperService, userQuizService)
+
+	return &userQuizPaperRouter{
+		db:         db,
+		repository: repository,
+		service:    service,
+		controller: controller,
+		router:     router,
+	}
+}
+
+func (r *userQuizPaperRouter) SetUserQuizPaperRouter() {
+	group := r.router.Group("/userquizpaper")
+	group.GET("", middleware.Auth("admin"), r.controller.List)
+	group.GET("/:id", middleware.Auth("admin"), r.controller.Find)
+	group.POST("", middleware.Auth("admin"), r.controller.Create)
+	group.PUT("/:id", middleware.Auth("admin"), r.controller.Update)
+	group.PATCH("/:id", middleware.Auth("admin"), r.controller.Patch)
+}