WIP: Export Kontor DB

kontor-gin/internal/handlers/admin.go

@@ -9,14 +9,20 @@ import (
 
 type AdminHandler struct {
 	AuthHandler       *AuthHandler
+	ProfileHandler    *ProfileHandler
 	PermissionHandler *PermissionHandler
+	AssignmentHandler *AssignmentHandler
+	TokenHandler      *TokenHandler
 	Secret            []byte
 }
 
 func NewAdminHandler(db *gorm.DB, secret []byte) *AdminHandler {
 	adminHandler := &AdminHandler{
 		AuthHandler:       &AuthHandler{Service: service.NewAuthService(repository.NewProfileRepository(db), secret)},
+		ProfileHandler:    NewProfileHandler(db),
 		PermissionHandler: &PermissionHandler{Service: service.NewPermissionService(repository.NewPermissionRepository(db))},
+		AssignmentHandler: NewAssignmentHandler(db),
+		TokenHandler:      NewTokenHandler(db),
 		Secret:            secret,
 	}
 	return adminHandler

kontor-gin/internal/handlers/assignment.go

@@ -0,0 +1,30 @@
+package handlers
+
+import (
+	"kontor-api-gin/internal/models"
+	"kontor-api-gin/internal/repository"
+	"kontor-api-gin/internal/service"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type AssignmentHandler struct {
+	Service *service.AssignmentService
+}
+
+func NewAssignmentHandler(db *gorm.DB) *AssignmentHandler {
+	handler := &AssignmentHandler{Service: service.NewAssignmentService(repository.NewAssignmentRepository(db))}
+	return handler
+}
+
+func (handler *AssignmentHandler) List(c *gin.Context) {
+	assignments, err := handler.Service.List(c.Request.Context())
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	dtos := models.ConvertAssignmentsToDtos(assignments)
+	c.JSON(http.StatusOK, dtos)
+}

kontor-gin/internal/handlers/comic.go

@@ -13,28 +13,30 @@ import (
 )
 
 type ComicsHandler struct {
-	ComicHandler     *ComicHandler
-	PublisherHandler *PublisherHandler
-	ArtistHandler    *ArtistHandler
-	IssueHandler     *IssueHandler
-	WorkTypeHandler  *WorkTypeHandler
-	VolumeHandler    *VolumeHandler
-	StoryArcHandler  *StoryArcHandler
-	ComicworkHandler *ComicworkHandler
-	IssueworkHandler *IssueworkHandler
+	ComicHandler          *ComicHandler
+	PublisherHandler      *PublisherHandler
+	ArtistHandler         *ArtistHandler
+	IssueHandler          *IssueHandler
+	WorkTypeHandler       *WorkTypeHandler
+	VolumeHandler         *VolumeHandler
+	StoryArcHandler       *StoryArcHandler
+	ComicworkHandler      *ComicworkHandler
+	IssueworkHandler      *IssueworkHandler
+	TradePaperbackHandler *TradePaperbackHandler
 }
 
 func NewComicsHandler(db *gorm.DB) *ComicsHandler {
 	comicsHandler := &ComicsHandler{
-		ComicHandler:     NewComicHandler(db),
-		PublisherHandler: NewPublisherHandler(db),
-		ArtistHandler:    NewArtistHandler(db),
-		IssueHandler:     NewIssueHandler(db),
-		WorkTypeHandler:  NewWorkTypeHandler(db),
-		VolumeHandler:    NewVolumeHandler(db),
-		StoryArcHandler:  NewStoryArcHandler(db),
-		ComicworkHandler: NewComicworkHandler(db),
-		IssueworkHandler: NewIssueworkHandler(db),
+		ComicHandler:          NewComicHandler(db),
+		PublisherHandler:      NewPublisherHandler(db),
+		ArtistHandler:         NewArtistHandler(db),
+		IssueHandler:          NewIssueHandler(db),
+		WorkTypeHandler:       NewWorkTypeHandler(db),
+		VolumeHandler:         NewVolumeHandler(db),
+		StoryArcHandler:       NewStoryArcHandler(db),
+		ComicworkHandler:      NewComicworkHandler(db),
+		IssueworkHandler:      NewIssueworkHandler(db),
+		TradePaperbackHandler: NewTradePaperbackHandler(db),
 	}
 	return comicsHandler
 }

kontor-gin/internal/handlers/media.go

@@ -1,9 +1,6 @@
 package handlers
 
 import (
-	"kontor-api-gin/internal/repository"
-	"kontor-api-gin/internal/service"
-
 	"gorm.io/gorm"
 )
 
@@ -11,13 +8,15 @@ type MediaHandler struct {
 	MediaActorHandler *MediaActorHandler
 	MediaFileHandler  *MediaFileHandler
 	MediaLoFiHandler  *MediaLoFiHandler
+	MediaVideoHandler *MediaVideoHandler
 }
 
 func NewMediaHandler(db *gorm.DB) *MediaHandler {
 	mediaHandler := &MediaHandler{
-		MediaActorHandler: &MediaActorHandler{Service: service.NewMediaActorService(repository.NewMediaActorRepository(db))},
-		MediaFileHandler:  &MediaFileHandler{Service: service.NewMediaFileService(repository.NewMediaFileRepository(db))},
-		MediaLoFiHandler:  &MediaLoFiHandler{Service: service.NewMediaLoFiService(repository.NewMediaLoFiRepository(db))},
+		MediaActorHandler: NewMediaActorHandler(db),
+		MediaFileHandler:  NewMediaFileHandler(db),
+		MediaLoFiHandler:  NewMediaLoFiHandler(db),
+		MediaVideoHandler: NewMediaVideoHandler(db),
 	}
 	return mediaHandler
 }

kontor-gin/internal/handlers/mediavideo.go

@@ -0,0 +1,52 @@
+package handlers
+
+import (
+	"kontor-api-gin/internal/globals"
+	"kontor-api-gin/internal/models"
+	"kontor-api-gin/internal/repository"
+	"kontor-api-gin/internal/service"
+	"net/http"
+
+	"github.com/gin-contrib/sessions"
+	"github.com/gin-contrib/slog"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type MediaVideoHandler struct {
+	Service *service.MediaVideoService
+}
+
+func NewMediaVideoHandler(db *gorm.DB) *MediaVideoHandler {
+	handler := &MediaVideoHandler{Service: service.NewMediaVideoService(repository.NewMediaVideoRepository(db))}
+	return handler
+}
+
+func (handler *MediaVideoHandler) List(c *gin.Context) {
+	logger := slog.Get(c)
+	logger.Info("MediaVideoHandler#List")
+	videos, err := handler.Service.List(c.Request.Context())
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	dtos := models.ConvertMediaVideosToDtos(videos)
+	c.JSON(http.StatusOK, dtos)
+}
+
+func (handler *MediaVideoHandler) ListPage(c *gin.Context) {
+	session := sessions.Default(c)
+	user := session.Get(globals.UserKey)
+	videos, err := handler.Service.List(c.Request.Context())
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.HTML(http.StatusOK, "mediavideos", gin.H{
+		"title":       "Kontor MediaFiles",
+		"version":     "0.4.0",
+		"message":     "MediaFiles...",
+		"mediavideos": videos,
+		"user":        user,
+	})
+}

kontor-gin/internal/handlers/profile.go

@@ -0,0 +1,30 @@
+package handlers
+
+import (
+	"kontor-api-gin/internal/models"
+	"kontor-api-gin/internal/repository"
+	"kontor-api-gin/internal/service"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ProfileHandler struct {
+	Service *service.ProfileService
+}
+
+func NewProfileHandler(db *gorm.DB) *ProfileHandler {
+	handler := &ProfileHandler{Service: service.NewProfileService(repository.NewProfileRepository(db))}
+	return handler
+}
+
+func (handler *ProfileHandler) List(c *gin.Context) {
+	profiles, err := handler.Service.List(c.Request.Context())
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	dtos := models.ConvertProfilesToDtos(profiles)
+	c.JSON(http.StatusOK, dtos)
+}

kontor-gin/internal/handlers/token.go

@@ -0,0 +1,30 @@
+package handlers
+
+import (
+	"kontor-api-gin/internal/models"
+	"kontor-api-gin/internal/repository"
+	"kontor-api-gin/internal/service"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type TokenHandler struct {
+	Service *service.TokenService
+}
+
+func NewTokenHandler(db *gorm.DB) *TokenHandler {
+	handler := &TokenHandler{Service: service.NewTokenService(repository.NewTokenRepository(db))}
+	return handler
+}
+
+func (handler *TokenHandler) List(c *gin.Context) {
+	tokens, err := handler.Service.List(c.Request.Context())
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	dtos := models.ConvertTokensToDtos(tokens)
+	c.JSON(http.StatusOK, dtos)
+}

kontor-gin/internal/handlers/tradepaperback.go

@@ -0,0 +1,49 @@
+package handlers
+
+import (
+	"kontor-api-gin/internal/globals"
+	"kontor-api-gin/internal/models"
+	"kontor-api-gin/internal/repository"
+	"kontor-api-gin/internal/service"
+	"net/http"
+
+	"github.com/gin-contrib/sessions"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type TradePaperbackHandler struct {
+	Service *service.TradePaperbackService
+}
+
+func NewTradePaperbackHandler(db *gorm.DB) *TradePaperbackHandler {
+	handler := &TradePaperbackHandler{Service: service.NewTradePaperbackService(repository.NewTradePaperbackRepository(db))}
+	return handler
+}
+
+func (handler *TradePaperbackHandler) List(c *gin.Context) {
+	tradepaperbacks, err := handler.Service.List(c.Request.Context())
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	dtos := models.ConvertTradePaperbacksToDtos(tradepaperbacks)
+	c.JSON(http.StatusOK, dtos)
+}
+
+func (handler *TradePaperbackHandler) ListPage(c *gin.Context) {
+	session := sessions.Default(c)
+	user := session.Get(globals.UserKey)
+	tradepaperbacks, err := handler.Service.List(c.Request.Context())
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.HTML(http.StatusOK, "comics", gin.H{
+		"title":           "Kontor Comics",
+		"version":         "0.4.0",
+		"message":         "Comics...",
+		"tradepaperbacks": tradepaperbacks,
+		"user":            user,
+	})
+}