refac: mappers, file names

2026-08-19 19:53:21 +02:00 · 2025-12-22 00:06:17 +01:00
parent e0a6706d4e
commit b50efae8a8
24 changed files with 171 additions and 190 deletions
@@ -0,0 +1,128 @@
+package persistence
+
+import (
+	domainArticle "RenewCMS/internal/domain/article"
+	"RenewCMS/internal/infrastructure/persistence/mappers"
+	entity "RenewCMS/internal/infrastructure/persistence/models"
+
+	"gorm.io/gorm"
+)
+
+type ArticleRepository struct {
+	db *gorm.DB
+}
+
+func NewArticleRepository(db *gorm.DB) *ArticleRepository {
+	return &ArticleRepository{db}
+}
+
+func (a *ArticleRepository) Get(id uint32) (domainArticle.Article, error) {
+	var article entity.Article
+	err := a.db.Model(&entity.Article{}).Preload("Images").First(&article, id).Error
+	if err != nil {
+		return domainArticle.Article{}, err
+	}
+
+	return mappers.ArticleToDomain(article), nil
+}
+
+func (a *ArticleRepository) GetByName(name string) (domainArticle.Article, error) {
+	var article entity.Article
+	err := a.db.Model(&entity.Article{}).Where("title = ?", name).First(&article).Error
+	if err != nil {
+		return domainArticle.Article{}, err
+	}
+
+	return mappers.ArticleToDomain(article), nil
+}
+
+func (a *ArticleRepository) Create(article domainArticle.Article) (domainArticle.Article, error) {
+	creationResult := a.db.Create(&entity.Article{
+		Title: article.Title,
+		Body:  article.Body,
+	})
+	if creationResult.Error != nil {
+		return domainArticle.Article{}, creationResult.Error
+	}
+
+	var createdArticle entity.Article
+	creationResult.Scan(&createdArticle)
+
+	return mappers.ArticleToDomain(createdArticle), nil
+}
+
+func (a *ArticleRepository) GetAll() []domainArticle.Article {
+	var articles []entity.Article
+	err := a.db.Model(&entity.Article{}).Find(&articles).Error
+	if err != nil {
+		return []domainArticle.Article{}
+	}
+
+	var domainArticles = make([]domainArticle.Article, 0)
+	for _, article := range articles {
+		domainArticles = append(domainArticles, mappers.ArticleToDomain(article))
+	}
+
+	return domainArticles
+}
+
+func (a *ArticleRepository) UpdateBody(id uint32, body string) (domainArticle.Article, error) {
+	var localArticle entity.Article
+	err := a.db.Model(&entity.Article{}).First(&localArticle, id).Error
+	if err != nil {
+		return domainArticle.Article{}, err
+	}
+
+	localArticle.Body = body
+	err = a.db.Save(&localArticle).Error
+	if err != nil {
+		return domainArticle.Article{}, err
+	}
+
+	newArticle := mappers.ArticleToDomain(localArticle)
+
+	return newArticle, nil
+}
+
+func (a *ArticleRepository) UpdateIsOnline(id uint32, isOnline bool) (domainArticle.Article, error) {
+	var localArticle entity.Article
+	err := a.db.Model(&entity.Article{}).First(&localArticle, id).Error
+	if err != nil {
+		return domainArticle.Article{}, err
+	}
+
+	localArticle.IsOnline = isOnline
+	err = a.db.Save(&localArticle).Error
+	if err != nil {
+		return domainArticle.Article{}, err
+	}
+
+	return mappers.ArticleToDomain(localArticle), nil
+}
+
+func (a *ArticleRepository) Delete(id uint32) error {
+	return a.db.Delete(&entity.Article{}, id).Error
+}
+
+func (a *ArticleRepository) AddImage(articleId uint32, imageId uint32) error {
+	var localArticle entity.Article
+	err := a.db.Model(&entity.Article{}).First(&localArticle, articleId).Error
+	if err != nil {
+		return err
+	}
+
+	var localImage entity.Image
+	err = a.db.Model(&entity.Image{}).First(&localImage, imageId).Error
+	if err != nil {
+		return err
+	}
+
+	err = a.db.Model(&localArticle).Association("Images").Append(&localImage)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+var _ domainArticle.Repository = &ArticleRepository{}
@@ -0,0 +1,82 @@
+package persistence
+
+import (
+	domain "RenewCMS/internal/domain/image"
+	"RenewCMS/internal/infrastructure/persistence/mappers"
+	entity "RenewCMS/internal/infrastructure/persistence/models"
+	"errors"
+	"mime/multipart"
+	"os"
+	"path/filepath"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type ImageRepository struct {
+	db *gorm.DB
+}
+
+func NewImageRepository(db *gorm.DB) *ImageRepository {
+	return &ImageRepository{db}
+}
+
+var contentTypeExtensions = map[string]string{
+	"image/png":     ".png",
+	"image/jpeg":    ".jpeg",
+	"image/webp":    ".webp",
+	"image/svg+xml": ".svg",
+}
+
+func (i ImageRepository) Create(file multipart.File, fileHeader multipart.FileHeader) (domain.Image, error) {
+	uploadDir := os.Getenv("UPLOAD_DIR")
+
+	fileBytes := make([]byte, fileHeader.Size)
+	_, err := file.Read(fileBytes)
+	if err != nil {
+		return domain.Image{}, err
+	}
+
+	err = os.MkdirAll(uploadDir, 0755)
+	if err != nil {
+		return domain.Image{}, err
+	}
+
+	contentType := fileHeader.Header.Get("Content-Type")
+	extension := contentTypeExtensions[contentType]
+	if extension == "" {
+		return domain.Image{}, errors.New("the file must be a PNG, JPEG, WEBP, or SVG image")
+	}
+
+	newName := uuid.NewString() + extension
+	finalPath := filepath.Join(uploadDir, newName)
+	err = os.WriteFile(finalPath, fileBytes, 0666)
+	if err != nil {
+		return domain.Image{}, err
+	}
+
+	newImage := i.db.Create(&domain.Image{Path: "/static/uploadedImages/" + newName})
+	var createdImage entity.Image
+	newImage.Scan(&createdImage)
+
+	return mappers.ImageToDomain(createdImage), nil
+}
+
+func (i ImageRepository) Delete(id uint32) error {
+	uploadDir := os.Getenv("UPLOAD_DIR")
+	var image entity.Image
+	err := i.db.Model(&entity.Image{}).First(&image, id).Error
+	if err != nil {
+		return err
+	}
+
+	fileName := filepath.Base(image.Path)
+	err = os.Remove(filepath.Join(uploadDir, fileName))
+	if err != nil {
+		return err
+	}
+
+	return i.db.Delete(&entity.Image{}, id).Error
+}
+
+var _ domain.Repository = &ImageRepository{}
@@ -0,0 +1,138 @@
+package persistence
+
+import (
+	domainUser "RenewCMS/internal/domain/user"
+	"RenewCMS/internal/infrastructure/persistence/mappers"
+	entity "RenewCMS/internal/infrastructure/persistence/models"
+
+	"golang.org/x/crypto/bcrypt"
+	"gorm.io/gorm"
+)
+
+type UserRepository struct {
+	db *gorm.DB
+}
+
+func NewUserRepository(db *gorm.DB) *UserRepository {
+	return &UserRepository{db}
+}
+
+func (u *UserRepository) Get(id uint32) (domainUser.User, error) {
+	var localUser entity.User
+	err := u.db.Model(&entity.User{}).First(&localUser, id).Error
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	return mappers.UserToDomain(localUser), nil
+}
+
+func (u *UserRepository) Create(user domainUser.User) (domainUser.User, error) {
+	hashedPassword, _ := bcrypt.GenerateFromPassword([]byte(user.Password), 12)
+	hashedVerificationCode, _ := bcrypt.GenerateFromPassword([]byte(user.VerificationCode), 12)
+
+	creationResult := u.db.Create(&entity.User{
+		Username:               user.Username,
+		Password:               string(hashedPassword),
+		Email:                  user.Email,
+		VerificationCode:       string(hashedVerificationCode),
+		VerificationExpiration: user.VerificationExpiration,
+	})
+	if creationResult.Error != nil {
+		return domainUser.User{}, creationResult.Error
+	}
+
+	var createdUser entity.User
+	creationResult.Scan(&createdUser)
+
+	return mappers.UserToDomain(createdUser),
+		nil
+}
+
+func (u *UserRepository) Delete(id uint32) error {
+	return u.db.Delete(&domainUser.User{}, id).Error
+}
+
+func (u *UserRepository) GetAll() []domainUser.User {
+	var users []entity.User
+	u.db.Model(&entity.User{}).Find(&users)
+
+	var domainUsers []domainUser.User
+	for _, localUser := range users {
+		domainUsers = append(domainUsers, mappers.UserToDomain(localUser))
+	}
+
+	return domainUsers
+}
+
+func (u *UserRepository) GetByUsername(username string) (domainUser.User, error) {
+	var localUser entity.User
+	err := u.db.Model(&entity.User{}).Where("username = ?", username).First(&localUser).Error
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	return mappers.UserToDomain(localUser), nil
+}
+
+func (u *UserRepository) GetByEmail(email string) (domainUser.User, error) {
+	var localUser entity.User
+	err := u.db.Model(&entity.User{}).Where("email = ?", email).First(&localUser).Error
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	return mappers.UserToDomain(localUser), nil
+}
+
+func (u *UserRepository) UpdateVerificationStatus(userId uint32, isVerified bool) (domainUser.User, error) {
+	var localUser entity.User
+	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	localUser.IsVerified = isVerified
+	err = u.db.Save(&localUser).Error
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	return mappers.UserToDomain(localUser), nil
+}
+
+func (u *UserRepository) UpdatePassword(userId uint32, password string) (domainUser.User, error) {
+	var localUser entity.User
+	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	hashedPassword, _ := bcrypt.GenerateFromPassword([]byte(password), 12)
+	localUser.Password = string(hashedPassword)
+	err = u.db.Save(&localUser).Error
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	return mappers.UserToDomain(localUser), nil
+}
+
+func (u *UserRepository) UpdatePasswordResetCode(userId uint32, code string) (domainUser.User, error) {
+	var localUser entity.User
+	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	hashedCode, _ := bcrypt.GenerateFromPassword([]byte(code), 12)
+	localUser.PasswordResetCode = string(hashedCode)
+	err = u.db.Save(&localUser).Error
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	return mappers.UserToDomain(localUser), nil
+}
+
+var _ domainUser.Repository = &UserRepository{}