refac: remove frontend & clearer DDD

internal/domain/article/article.go

@@ -0,0 +1,58 @@
+package article
+
+import (
+	domain "RenewCMS/internal/domain/image"
+	entity "RenewCMS/internal/infrastructure/persistence/models"
+	"time"
+)
+
+type Article struct {
+	ID        uint32          `json:"id"`
+	Title     string          `json:"title"`
+	Body      string          `json:"body"`
+	Images    []*domain.Image `json:"images"`
+	IsOnline  bool            `json:"is_online"`
+	CreatedAt time.Time       `json:"created_at"`
+	UpdatedAt time.Time       `json:"updated_at"`
+}
+
+func FromApi(
+	title string,
+	body string,
+) Article {
+	return Article{
+		Title: title,
+		Body:  body,
+	}
+}
+
+func FromDb(
+	id uint32,
+	title string,
+	body string,
+	images []*entity.Image,
+	isOnline bool,
+	createdAt time.Time,
+	updatedAt time.Time,
+) Article {
+	domainImages := make([]*domain.Image, len(images))
+	for i, img := range images {
+		domainImage := domain.FromDB(
+			img.ID,
+			img.Path,
+			img.ArticleID,
+			img.CreatedAt,
+			img.UpdatedAt,
+		)
+		domainImages[i] = &domainImage
+	}
+	return Article{
+		ID:        id,
+		Title:     title,
+		Body:      body,
+		Images:    domainImages,
+		IsOnline:  isOnline,
+		CreatedAt: createdAt,
+		UpdatedAt: updatedAt,
+	}
+}

internal/domain/article/repository.go

@@ -0,0 +1,12 @@
+package article
+
+type Repository interface {
+	Get(id uint32) (Article, error)
+	GetByName(name string) (Article, error)
+	GetAll() []Article
+	Create(post Article) (Article, error)
+	UpdateBody(id uint32, body string) (Article, error)
+	UpdateIsOnline(id uint32, isOnline bool) (Article, error)
+	Delete(id uint32) error
+	AddImage(postId uint32, imageId uint32) error
+}

internal/domain/image/image.go

@@ -0,0 +1,23 @@
+package image
+
+import (
+	"time"
+)
+
+type Image struct {
+	ID        uint32    `json:"id"`
+	Path      string    `json:"path"`
+	ArticleID uint32    `json:"article_id"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+func FromDB(id uint32, path string, articleId uint32, createdAt time.Time, updatedAt time.Time) Image {
+	return Image{
+		ID:        id,
+		Path:      path,
+		ArticleID: articleId,
+		CreatedAt: createdAt,
+		UpdatedAt: updatedAt,
+	}
+}

internal/domain/image/repository.go

@@ -0,0 +1,10 @@
+package image
+
+import (
+	"mime/multipart"
+)
+
+type Repository interface {
+	Create(file multipart.File, fileHeader multipart.FileHeader) (Image, error)
+	Delete(id uint32) error
+}

internal/domain/mail/repository.go

@@ -0,0 +1,5 @@
+package mail
+
+type Repository interface {
+	Send(receiverAddress string, templateName string, data any) error
+}

internal/domain/user/repository.go

@@ -0,0 +1,13 @@
+package user
+
+type Repository interface {
+	Get(id uint32) (User, error)
+	GetByUsername(username string) (User, error)
+	GetByEmail(email string) (User, error)
+	GetAll() []User
+	Create(user User) (User, error)
+	Delete(id uint32) error
+	UpdateVerificationStatus(userId uint32, isVerified bool) (User, error)
+	UpdatePassword(userId uint32, password string) (User, error)
+	UpdatePasswordResetCode(userId uint32, code string) (User, error)
+}

internal/domain/user/user.go

@@ -0,0 +1,63 @@
+package user
+
+import (
+	"time"
+)
+
+type User struct {
+	ID                     uint32    `json:"id"`
+	Username               string    `json:"username"`
+	Password               string    `json:"password"`
+	PasswordResetCode      string    `json:"password_reset_code"`
+	Email                  string    `json:"email"`
+	IsVerified             bool      `json:"is_verified"`
+	VerificationCode       string    `json:"verification_code"`
+	VerificationExpiration time.Time `json:"verification_expiration"`
+	CreatedAt              time.Time `json:"created_at"`
+	UpdatedAt              time.Time `json:"updated_at"`
+}
+
+func FromApi(
+	username string,
+	password string,
+	passwordResetCode string,
+	email string,
+	verificationCode string,
+) User {
+	expiration := time.Now().Add(2 * time.Hour)
+	return User{
+		Username:               username,
+		Password:               password,
+		PasswordResetCode:      passwordResetCode,
+		Email:                  email,
+		IsVerified:             false,
+		VerificationCode:       verificationCode,
+		VerificationExpiration: expiration,
+	}
+}
+
+func FromDb(
+	id uint32,
+	username string,
+	password string,
+	passwordResetCode string,
+	email string,
+	isVerified bool,
+	verificationCode string,
+	verificationExpiration time.Time,
+	createdAt time.Time,
+	updatedAt time.Time,
+) User {
+	return User{
+		ID:                     id,
+		Username:               username,
+		Password:               password,
+		PasswordResetCode:      passwordResetCode,
+		Email:                  email,
+		IsVerified:             isVerified,
+		VerificationCode:       verificationCode,
+		VerificationExpiration: verificationExpiration,
+		CreatedAt:              createdAt,
+		UpdatedAt:              updatedAt,
+	}
+}

internal/infrastructure/mailer/mailRepository.go

@@ -0,0 +1,64 @@
+package mailer
+
+import (
+	domain "RenewCMS/internal/domain/mail"
+	"bytes"
+	"embed"
+	"html/template"
+	"log"
+	"os"
+	"strconv"
+
+	"gopkg.in/gomail.v2"
+)
+
+type MailRepository struct{}
+
+//go:embed templates/*
+var mailTemplateFiles embed.FS
+
+func NewMailRepository() *MailRepository {
+	return &MailRepository{}
+}
+
+func (m MailRepository) Send(receiverAddress string, templateName string, data any) error {
+	from := os.Getenv("SMTP_EMAIL")
+	password := os.Getenv("SMTP_PASSWORD")
+	smtpHost := os.Getenv("SMTP_HOST")
+	smtpPort, _ := strconv.Atoi(os.Getenv("SMTP_PORT"))
+
+	d := gomail.NewDialer(smtpHost, smtpPort, from, password)
+
+	tmpl, err := template.ParseFS(mailTemplateFiles, "mail/templates/"+templateName+".html")
+	if err != nil {
+		log.Println("error when template.ParseFS:", err)
+		return err
+	}
+
+	var body bytes.Buffer
+	err = tmpl.Execute(&body, data)
+	if err != nil {
+		log.Println("error when tmpl.Execute:", err)
+		return err
+	}
+
+	msg := gomail.NewMessage()
+	msg.SetHeaders(map[string][]string{
+		"From":         {"RenewCMS <" + from + ">"},
+		"To":           {receiverAddress},
+		"MIME-version": {"1.0"},
+		"Content-Type": {"text/html"},
+		"charset":      {"UTF-8"},
+		"Subject":      {"RenewCMS | Action required"},
+	})
+	msg.SetBody("text/html", body.String())
+
+	if err := d.DialAndSend(msg); err != nil {
+		log.Println("error when sending email:", err)
+		return err
+	}
+
+	return nil
+}
+
+var _ domain.Repository = &MailRepository{}

internal/infrastructure/mailer/templates/mailValidation.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<body>
+<h1>
+    <img src="{{.Host}}/static/renewcms-favicon-64.png" alt="G" style="width: 2.5rem"/>
+    RenewCMS
+</h1>
+<main>
+    <p>You or someone tried to create a RenewCMS admin account with this e-mail address. If you are not responsible for
+        this, please do not validate the account creation.</p>
+    <p><b>If you want to validate the account creation, please <a
+            href="{{.Host}}/register/validate?c={{.VerificationCode}}" target="_blank">click HERE</a>.</b>
+    </p>
+    <p>If you can't click the link:</p>
+    <p>{{.Host}}/register/validate?c={{.VerificationCode}}</p>
+</main>
+</body>
+</html>

internal/infrastructure/mailer/templates/passwordReset.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<body>
+<h1>
+    <img src="{{.Host}}/static/renewcms-favicon-64.png" alt="G" style="width: 2.5rem"/>
+    RenewCMS
+</h1>
+<main>
+    <p>You or someone tried to create reset your RenewCMS account with this e-mail address. If you are not responsible for
+        this, please do not validate the password reset.</p>
+    <p><b>If you want to reset your password, please <a
+            href="{{.Host}}/register/reset/validate?c={{.VerificationCode}}&email={{.Email}}" target="_blank">click HERE</a>.</b>
+    </p>
+    <p>If you can't click the link:</p>
+    <p>{{.Host}}/register/reset/validate?c={{.VerificationCode}}&email={{.Email}}</p>
+</main>
+</body>
+</html>

internal/infrastructure/persistence/articleRepository.go

@@ -0,0 +1,139 @@
+package persistence
+
+import (
+	domain "RenewCMS/internal/domain/article"
+	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 mapArticleToDomain(article entity.Article) domain.Article {
+	return domain.FromDb(article.ID, article.Title, article.Body, article.Images, article.IsOnline, article.CreatedAt, article.UpdatedAt)
+}
+
+func (a *ArticleRepository) Get(id uint32) (domain.Article, error) {
+	var article entity.Article
+	err := a.db.Model(&entity.Article{}).Preload("Images").First(&article, id).Error
+	if err != nil {
+		return domain.Article{}, err
+	}
+
+	return mapArticleToDomain(article), nil
+}
+
+func (a *ArticleRepository) GetByName(name string) (domain.Article, error) {
+	var article entity.Article
+	err := a.db.Model(&entity.Article{}).Where("title = ?", name).First(&article).Error
+	if err != nil {
+		return domain.Article{}, err
+	}
+
+	return mapArticleToDomain(article), nil
+}
+
+func (a *ArticleRepository) Create(article domain.Article) (domain.Article, error) {
+	creationResult := a.db.Create(&entity.Article{
+		Title: article.Title,
+		Body:  article.Body,
+	})
+	if creationResult.Error != nil {
+		return domain.Article{}, creationResult.Error
+	}
+
+	var createdArticle entity.Article
+	creationResult.Scan(&createdArticle)
+
+	return mapArticleToDomain(createdArticle), nil
+}
+
+func (a *ArticleRepository) GetAll() []domain.Article {
+	var articles []entity.Article
+	err := a.db.Model(&entity.Article{}).Find(&articles).Error
+	if err != nil {
+		return []domain.Article{}
+	}
+
+	var domainArticles = make([]domain.Article, 0)
+	for _, article := range articles {
+		domainArticles = append(domainArticles, mapArticleToDomain(article))
+	}
+
+	return domainArticles
+}
+
+func (a *ArticleRepository) UpdateBody(id uint32, body string) (domain.Article, error) {
+	var localArticle entity.Article
+	err := a.db.Model(&entity.Article{}).First(&localArticle, id).Error
+	if err != nil {
+		return domain.Article{}, err
+	}
+
+	localArticle.Body = body
+	err = a.db.Save(&localArticle).Error
+	if err != nil {
+		return domain.Article{}, err
+	}
+
+	newArticle := domain.FromDb(
+		localArticle.ID,
+		localArticle.Title,
+		localArticle.Body,
+		localArticle.Images,
+		localArticle.IsOnline,
+		localArticle.CreatedAt,
+		localArticle.UpdatedAt,
+	)
+
+	return newArticle, nil
+}
+
+func (a *ArticleRepository) UpdateIsOnline(id uint32, isOnline bool) (domain.Article, error) {
+	var localArticle entity.Article
+	err := a.db.Model(&entity.Article{}).First(&localArticle, id).Error
+	if err != nil {
+		return domain.Article{}, err
+	}
+
+	localArticle.IsOnline = isOnline
+	err = a.db.Save(&localArticle).Error
+	if err != nil {
+		return domain.Article{}, err
+	}
+
+	return mapArticleToDomain(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 _ domain.Repository = &ArticleRepository{}

internal/infrastructure/persistence/imageRepository.go

@@ -0,0 +1,91 @@
+package persistence
+
+import (
+	domain "RenewCMS/internal/domain/image"
+	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 mapImageToDomain(image entity.Image) domain.Image {
+	return domain.FromDB(
+		image.ID,
+		image.Path,
+		image.ArticleID,
+		image.CreatedAt,
+		image.UpdatedAt,
+	)
+}
+
+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 mapImageToDomain(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{}

internal/infrastructure/persistence/models/article.go

@@ -0,0 +1,18 @@
+package models
+
+import (
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type Article struct {
+	gorm.Model
+	ID        uint32 `gorm:"primary_key;auto_increment;not_null"`
+	Title     string
+	Body      string
+	Images    []*Image  `gorm:"many2many:article_images;"`
+	IsOnline  bool      `gorm:"not_null;default:false"`
+	CreatedAt time.Time `gorm:"autoCreateTime"`
+	UpdatedAt time.Time `gorm:"autoUpdateTime"`
+}

internal/infrastructure/persistence/models/image.go

@@ -0,0 +1,16 @@
+package models
+
+import (
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type Image struct {
+	gorm.Model
+	ID        uint32 `gorm:"primary_key;auto_increment;not_null"`
+	Path      string
+	ArticleID uint32
+	CreatedAt time.Time `gorm:"autoCreateTime"`
+	UpdatedAt time.Time `gorm:"autoUpdateTime"`
+}

internal/infrastructure/persistence/models/user.go

@@ -0,0 +1,20 @@
+package models
+
+import (
+	"gorm.io/gorm"
+	"time"
+)
+
+type User struct {
+	gorm.Model
+	ID                     uint32 `gorm:"primaryKey;autoIncrement"`
+	Username               string `gorm:"unique;not null"`
+	Password               string `gorm:"not null"`
+	PasswordResetCode      string `gorm:"unique"`
+	Email                  string `gorm:"unique;not null"`
+	IsVerified             bool   `gorm:"default=false;not null"`
+	VerificationCode       string `gorm:"unique"`
+	VerificationExpiration time.Time
+	CreatedAt              time.Time `gorm:"autoCreateTime"`
+	UpdatedAt              time.Time `gorm:"autoUpdateTime"`
+}

internal/infrastructure/persistence/userRepository.go

@@ -0,0 +1,151 @@
+package persistence
+
+import (
+	domainUser "RenewCMS/internal/domain/user"
+	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 mapUserToDomain(user entity.User) domainUser.User {
+	return domainUser.FromDb(
+		user.ID,
+		user.Username,
+		user.Password,
+		user.PasswordResetCode,
+		user.Email,
+		user.IsVerified,
+		user.VerificationCode,
+		user.VerificationExpiration,
+		user.CreatedAt, user.UpdatedAt,
+	)
+}
+
+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 mapUserToDomain(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 mapUserToDomain(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, mapUserToDomain(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 mapUserToDomain(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 mapUserToDomain(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 mapUserToDomain(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 mapUserToDomain(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 mapUserToDomain(localUser), nil
+}
+
+var _ domainUser.Repository = &UserRepository{}

internal/infrastructure/useCases/CreateArticle.go

@@ -0,0 +1,25 @@
+package useCases
+
+import (
+	"RenewCMS/internal/domain/article"
+)
+
+type CreateArticleUseCase struct {
+	articleRepository article.Repository
+}
+
+type CreateArticleCommand struct {
+	Title string
+	Body  string
+}
+
+func NewCreateArticleUseCase(articleRepository article.Repository) *CreateArticleUseCase {
+	return &CreateArticleUseCase{articleRepository}
+}
+
+func (g *CreateArticleUseCase) CreateArticle(createArticle CreateArticleCommand) (article.Article, error) {
+	return g.articleRepository.Create(article.FromApi(
+		createArticle.Title,
+		createArticle.Body,
+	))
+}

internal/infrastructure/useCases/CreateImage.go

@@ -0,0 +1,18 @@
+package useCases
+
+import (
+	"RenewCMS/internal/domain/image"
+	"mime/multipart"
+)
+
+type CreateImageUseCase struct {
+	imageRepository image.Repository
+}
+
+func NewCreateImageUseCase(imageRepository image.Repository) *CreateImageUseCase {
+	return &CreateImageUseCase{imageRepository}
+}
+
+func (g *CreateImageUseCase) CreateImage(file multipart.File, fileHeader multipart.FileHeader) (image.Image, error) {
+	return g.imageRepository.Create(file, fileHeader)
+}

internal/infrastructure/useCases/CreateUser.go

@@ -0,0 +1,39 @@
+package useCases
+
+import (
+	"RenewCMS/internal/domain/user"
+
+	"github.com/google/uuid"
+)
+
+type CreateUserUseCase struct {
+	userRepository user.Repository
+}
+
+type CreateUserCommand struct {
+	Username string
+	Password string
+	Email    string
+}
+
+func NewCreateUserUseCase(userRepository user.Repository) *CreateUserUseCase {
+	return &CreateUserUseCase{userRepository}
+}
+
+func (g *CreateUserUseCase) CreateUser(createUser CreateUserCommand) (user.User, error) {
+	rawUuid := uuid.NewString()
+
+	createdUser, err := g.userRepository.Create(user.FromApi(
+		createUser.Username,
+		createUser.Password,
+		"",
+		createUser.Email,
+		rawUuid,
+	))
+	if err != nil {
+		return user.User{}, err
+	}
+
+	createdUser.VerificationCode = rawUuid
+	return createdUser, nil
+}

internal/infrastructure/useCases/DeleteArticle.go

@@ -0,0 +1,15 @@
+package useCases
+
+import "RenewCMS/internal/domain/article"
+
+type DeleteArticleUseCase struct {
+	articleRepository article.Repository
+}
+
+func NewDeleteArticleUseCase(articleRepository article.Repository) *DeleteArticleUseCase {
+	return &DeleteArticleUseCase{articleRepository}
+}
+
+func (g *DeleteArticleUseCase) DeleteArticle(userId uint32) error {
+	return g.articleRepository.Delete(userId)
+}

internal/infrastructure/useCases/DeleteImage.go

@@ -0,0 +1,15 @@
+package useCases
+
+import "RenewCMS/internal/domain/image"
+
+type DeleteImageUseCase struct {
+	imageRepository image.Repository
+}
+
+func NewDeleteImageUseCase(imageRepository image.Repository) *DeleteImageUseCase {
+	return &DeleteImageUseCase{imageRepository}
+}
+
+func (g *DeleteImageUseCase) DeleteImage(imageId uint32) error {
+	return g.imageRepository.Delete(imageId)
+}

internal/infrastructure/useCases/DeleteUser.go

@@ -0,0 +1,15 @@
+package useCases
+
+import "RenewCMS/internal/domain/user"
+
+type DeleteUserUseCase struct {
+	userRepository user.Repository
+}
+
+func NewDeleteUserUseCase(userRepository user.Repository) *DeleteUserUseCase {
+	return &DeleteUserUseCase{userRepository}
+}
+
+func (g *DeleteUserUseCase) DeleteUser(userId uint32) error {
+	return g.userRepository.Delete(userId)
+}

internal/infrastructure/useCases/GetArticle.go

@@ -0,0 +1,19 @@
+package useCases
+
+import "RenewCMS/internal/domain/article"
+
+type GetArticleUseCase struct {
+	articleRepository article.Repository
+}
+
+func NewGetArticleUseCase(articleRepository article.Repository) *GetArticleUseCase {
+	return &GetArticleUseCase{articleRepository}
+}
+
+func (g *GetArticleUseCase) GetArticle(id uint32) (article.Article, error) {
+	return g.articleRepository.Get(id)
+}
+
+func (g *GetArticleUseCase) GetArticleByName(name string) (article.Article, error) {
+	return g.articleRepository.GetByName(name)
+}

internal/infrastructure/useCases/GetUser.go

@@ -0,0 +1,23 @@
+package useCases
+
+import "RenewCMS/internal/domain/user"
+
+type GetUserUseCase struct {
+	userRepository user.Repository
+}
+
+func NewGetUserUseCase(userRepository user.Repository) *GetUserUseCase {
+	return &GetUserUseCase{userRepository}
+}
+
+func (g *GetUserUseCase) GetUser(id uint32) (user.User, error) {
+	return g.userRepository.Get(id)
+}
+
+func (g *GetUserUseCase) GetUserByUsername(username string) (user.User, error) {
+	return g.userRepository.GetByUsername(username)
+}
+
+func (g *GetUserUseCase) GetUserByEmail(email string) (user.User, error) {
+	return g.userRepository.GetByEmail(email)
+}

internal/infrastructure/useCases/ListArticles.go

@@ -0,0 +1,15 @@
+package useCases
+
+import "RenewCMS/internal/domain/article"
+
+type ListArticlesUseCase struct {
+	articleRepository article.Repository
+}
+
+func NewListArticlesUseCase(articleRepository article.Repository) *ListArticlesUseCase {
+	return &ListArticlesUseCase{articleRepository}
+}
+
+func (g *ListArticlesUseCase) ListArticles() []article.Article {
+	return g.articleRepository.GetAll()
+}

internal/infrastructure/useCases/ListUsers.go

@@ -0,0 +1,15 @@
+package useCases
+
+import "RenewCMS/internal/domain/user"
+
+type ListUsersUseCase struct {
+	userRepository user.Repository
+}
+
+func NewListUsersUseCase(userRepository user.Repository) *ListUsersUseCase {
+	return &ListUsersUseCase{userRepository}
+}
+
+func (g *ListUsersUseCase) ListUsers() []user.User {
+	return g.userRepository.GetAll()
+}

internal/infrastructure/useCases/SendMail.go

@@ -0,0 +1,15 @@
+package useCases
+
+import "RenewCMS/internal/domain/mail"
+
+type SendMailUseCase struct {
+	mailRepository mail.Repository
+}
+
+func NewSendMailUseCase(mailRepository mail.Repository) *SendMailUseCase {
+	return &SendMailUseCase{mailRepository}
+}
+
+func (g *SendMailUseCase) SendMail(receiverAddress string, templateName string, data any) error {
+	return g.mailRepository.Send(receiverAddress, templateName, data)
+}

internal/infrastructure/useCases/UpdateArticle.go

@@ -0,0 +1,23 @@
+package useCases
+
+import "RenewCMS/internal/domain/article"
+
+type UpdateArticleUseCase struct {
+	articleRepository article.Repository
+}
+
+func NewUpdateArticleUseCase(articleRepository article.Repository) *UpdateArticleUseCase {
+	return &UpdateArticleUseCase{articleRepository}
+}
+
+func (g *UpdateArticleUseCase) UpdateBody(id uint32, body string) (article.Article, error) {
+	return g.articleRepository.UpdateBody(id, body)
+}
+
+func (g *UpdateArticleUseCase) AddImage(articleId uint32, imageId uint32) error {
+	return g.articleRepository.AddImage(articleId, imageId)
+}
+
+func (g *UpdateArticleUseCase) UpdateIsOnline(id uint32, isOnline bool) (article.Article, error) {
+	return g.articleRepository.UpdateIsOnline(id, isOnline)
+}

internal/infrastructure/useCases/UpdateUser.go

@@ -0,0 +1,23 @@
+package useCases
+
+import "RenewCMS/internal/domain/user"
+
+type UpdateUserUseCase struct {
+	userRepository user.Repository
+}
+
+func NewUpdateUserUseCase(userRepository user.Repository) *UpdateUserUseCase {
+	return &UpdateUserUseCase{userRepository}
+}
+
+func (g *UpdateUserUseCase) UpdateVerificationStatus(userId uint32, isVerified bool) (user.User, error) {
+	return g.userRepository.UpdateVerificationStatus(userId, isVerified)
+}
+
+func (g *UpdateUserUseCase) UpdatePasswordResetCode(userId uint32, code string) (user.User, error) {
+	return g.userRepository.UpdatePasswordResetCode(userId, code)
+}
+
+func (g *UpdateUserUseCase) UpdatePassword(userId uint32, password string) (user.User, error) {
+	return g.userRepository.UpdatePassword(userId, password)
+}