dmitriygnatenko-v2/internal/services/handler/admin/article.go

package admin

import (
	"context"
	"strconv"
	"time"

	"git.dmitriygnatenko.ru/dima/go-common/logger"
	"github.com/go-playground/validator/v10"
	"github.com/gofiber/fiber/v2"
	"github.com/golang-jwt/jwt/v4"

	"git.dmitriygnatenko.ru/dima/dmitriygnatenko-v2/internal/helpers"
	"git.dmitriygnatenko.ru/dima/dmitriygnatenko-v2/internal/mapper"
	"git.dmitriygnatenko.ru/dima/dmitriygnatenko-v2/internal/models"
	"git.dmitriygnatenko.ru/dima/dmitriygnatenko-v2/internal/services/handler"
)

type (
	CacheService interface {
		Delete(key string)
	}

	ArticleRepository interface {
		GetAll(ctx context.Context) ([]models.Article, error)
		GetByURL(ctx context.Context, url string) (*models.Article, error)
		GetByID(ctx context.Context, ID uint64) (*models.Article, error)
		Add(ctx context.Context, m models.Article) (uint64, error)
		Update(ctx context.Context, m models.Article) error
		Delete(ctx context.Context, ID uint64) error
	}

	TagRepository interface {
		GetAll(ctx context.Context) ([]models.Tag, error)
		IsUsed(ctx context.Context, ID uint64) (bool, error)
		GetByArticleID(ctx context.Context, ID uint64) ([]models.Tag, error)
		GetByURL(ctx context.Context, tag string) (*models.Tag, error)
		GetByID(ctx context.Context, ID uint64) (*models.Tag, error)
		Add(ctx context.Context, m models.Tag) error
		Update(ctx context.Context, m models.Tag) error
		Delete(ctx context.Context, ID uint64) error
	}

	ArticleTagRepository interface {
		Add(ctx context.Context, articleID uint64, tagIDs []uint64) error
		Delete(ctx context.Context, articleID uint64, tagIDs []uint64) error
		DeleteByArticleID(ctx context.Context, articleID uint64) error
	}

	AuthService interface {
		GeneratePasswordHash(password string) (string, error)
		IsCorrectPassword(password string, hash string) bool
		GenerateToken(user models.User) (string, error)
		GetClaims(fctx *fiber.Ctx) jwt.MapClaims
	}

	EnvService interface {
		JwtCookie() string
		JwtLifeTime() time.Duration
	}

	UserRepository interface {
		Get(ctx context.Context, username string) (*models.User, error)
		Add(ctx context.Context, username string, password string) (int, error)
		UpdatePassword(ctx context.Context, id uint64, newPassword string) error
	}
)

const errArticleExists = "Статья с данным URL уже существует"

func ArticleHandler(articleRepository ArticleRepository) fiber.Handler {
	return func(ctx *fiber.Ctx) error {
		articles, err := articleRepository.GetAll(ctx.Context())
		if err != nil {
			logger.Error(ctx.Context(), err.Error())
			return err
		}

		return ctx.Render("admin/article", fiber.Map{
			"articles": mapper.ToArticleDTOList(articles),
			"section":  "article",
		}, "admin/_layout")
	}
}

func AddArticleHandler(
	articleRepository ArticleRepository,
	tagRepository TagRepository,
	articleTagRepository ArticleTagRepository,
) fiber.Handler {
	return func(fctx *fiber.Ctx) error {
		ctx := fctx.Context()
		var validate = validator.New()
		validateErrors := make(map[string]string)

		trans, err := helpers.GetDefaultTranslator(validate)
		if err != nil {
			logger.Error(ctx, err.Error())
			return err
		}

		form := models.ArticleForm{
			ActiveTags: make(map[uint64]bool),
		}

		tags, err := tagRepository.GetAll(ctx)
		if err != nil {
			logger.Error(ctx, err.Error())
			return err
		}

		tagsDTO := mapper.ToTagDTOList(tags)

		if fctx.Method() == fiber.MethodPost {
			if err = fctx.BodyParser(&form); err != nil {
				logger.Error(ctx, err.Error())
				return err
			}

			if err = validate.Struct(form); err != nil {
				validateErrors = helpers.FormatValidateErrors(err, trans)
			}

			if res, _ := articleRepository.GetByURL(ctx, form.URL); res != nil {
				validateErrors["ArticleForm.URL"] = errArticleExists
			}

			tagIDs := make([]uint64, 0, len(form.Tags))
			for i := range form.Tags {
				tagID, tagErr := strconv.ParseUint(form.Tags[i], 10, 64)
				if tagErr != nil {
					logger.Error(ctx, tagErr.Error())
					return tagErr
				}

				tagIDs = append(tagIDs, tagID)
			}

			for i := range tagIDs {
				form.ActiveTags[tagIDs[i]] = true
			}

			if len(validateErrors) == 0 {
				articleModel, err := mapper.ToArticle(form)
				if err != nil {
					logger.Error(ctx, err.Error())
					return err
				}

				articleID, articleErr := articleRepository.Add(ctx, *articleModel)
				if articleErr != nil {
					logger.Error(ctx, articleErr.Error())
					return articleErr
				}

				if len(form.Tags) > 0 {
					if err = articleTagRepository.Add(ctx, articleID, tagIDs); err != nil {
						logger.Error(ctx, err.Error())
						return err
					}
				}

				return fctx.Redirect("/admin")
			}
		}

		return fctx.Render("admin/article_edit", fiber.Map{
			"form":       form,
			"errors":     validateErrors,
			"tags":       tagsDTO,
			"section":    "article",
			"title":      "Добавление статьи",
			"show_apply": false,
		}, "admin/_layout")
	}
}

func EditArticleHandler(
	articleRepository ArticleRepository,
	tagRepository TagRepository,
	articleTagRepository ArticleTagRepository,
	cacheService CacheService,
) fiber.Handler {
	return func(fctx *fiber.Ctx) error {
		ctx := fctx.Context()
		var validate = validator.New()
		validateErrors := make(map[string]string)

		trans, err := helpers.GetDefaultTranslator(validate)
		if err != nil {
			return err
		}

		ID, err := strconv.Atoi(fctx.Params("id"))
		if err != nil {
			return err
		}

		article, err := articleRepository.GetByID(ctx, ID)
		if err != nil {
			return err
		}
		if article == nil {
			return fiber.ErrNotFound
		}

		articleTags, err := tagRepository.GetByArticleID(ctx, ID)
		if err != nil {
			return err
		}

		tags, err := tagRepository.GetAll(ctx)
		if err != nil {
			return err
		}

		tagsDTO := mapper.ToTagDTOList(tags)

		var form *models.ArticleForm
		if fctx.Method() == fiber.MethodGet {
			form = mapper.ToArticleForm(*article, articleTags)
		} else if fctx.Method() == fiber.MethodPost {
			form = &models.ArticleForm{
				ID:         ID,
				ActiveTags: make(map[int]bool),
			}

			if err = fctx.BodyParser(form); err != nil {
				return err
			}

			if err = validate.Struct(*form); err != nil {
				validateErrors = helpers.FormatValidateErrors(err, trans)
			}

			if res, _ := articleRepository.GetByURL(ctx, form.URL); res != nil {
				if res.ID != ID {
					validateErrors["ArticleForm.URL"] = errArticleExists
				}
			}

			tagIDs := make([]int, 0, len(form.Tags))
			for i := range form.Tags {
				tagID, tagErr := strconv.Atoi(form.Tags[i])
				if tagErr != nil {
					return tagErr
				}

				tagIDs = append(tagIDs, tagID)
			}

			for i := range tagIDs {
				form.ActiveTags[tagIDs[i]] = true
			}

			if len(validateErrors) == 0 {
				articleModel, err := mapper.ToArticle(*form)
				if err != nil {
					return err
				}

				err = articleRepository.Update(ctx, *articleModel)
				if err != nil {
					return err
				}

				var tagsToAdd, tagsToDelete []int

				oldTagsMap := make(map[int]struct{}, len(articleTags))
				for i := range articleTags {
					oldTagsMap[articleTags[i].ID] = struct{}{}
					if _, ok := form.ActiveTags[articleTags[i].ID]; !ok {
						tagsToDelete = append(tagsToDelete, articleTags[i].ID)
					}
				}

				for i := range tagIDs {
					if _, ok := oldTagsMap[tagIDs[i]]; !ok {
						tagsToAdd = append(tagsToAdd, tagIDs[i])
					}
				}

				if len(tagsToAdd) > 0 {
					if err = articleTagRepository.Add(ctx, ID, tagsToAdd); err != nil {
						return err
					}
				}

				if len(tagsToDelete) > 0 {
					if err = articleTagRepository.Delete(ctx, ID, tagsToDelete); err != nil {
						return err
					}
				}

				cacheService.Delete(handler.ArticleCacheKey + article.URL)

				if fctx.FormValue("action", "save") == "save" {
					return fctx.Redirect("/admin")
				}
			}
		}

		return fctx.Render("admin/article_edit", fiber.Map{
			"form":       form,
			"errors":     validateErrors,
			"tags":       tagsDTO,
			"show_apply": true,
			"section":    "article",
			"title":      "Редактирование статьи",
		}, "admin/_layout")
	}
}

func DeleteArticleHandler(
	articleRepository ArticleRepository,
	articleTagRepository ArticleTagRepository,
	cacheService CacheService,
) fiber.Handler {
	return func(fctx *fiber.Ctx) error {
		ctx := fctx.Context()
		ID, err := strconv.Atoi(fctx.Params("id"))
		if err != nil {
			return err
		}

		article, err := articleRepository.GetByID(ctx, ID)
		if err != nil {
			return err
		}

		if fctx.Method() == fiber.MethodPost {
			err = articleTagRepository.DeleteByArticleID(ctx, ID)
			if err != nil {
				return err
			}

			err = articleRepository.Delete(ctx, ID)
			if err != nil {
				return err
			}

			cacheService.Delete(handler.ArticleCacheKey + article.URL)

			return fctx.Redirect("/admin")
		}

		return fctx.Render("admin/article_delete", fiber.Map{
			"article": article.Title,
			"section": "article",
		}, "admin/_layout")
	}
}