medol-be/app/module/articles/service/articles.service.go

package service

import (
	"context"
	"errors"
	"fmt"
	"github.com/gofiber/fiber/v2"
	"github.com/minio/minio-go/v7"
	"github.com/rs/zerolog"
	"go-humas-be/app/database/entity"
	articleCategoriesRepository "go-humas-be/app/module/article_categories/repository"
	articleCategoryDetailsRepository "go-humas-be/app/module/article_category_details/repository"
	articleCategoryDetailsReq "go-humas-be/app/module/article_category_details/request"
	articleFilesRepository "go-humas-be/app/module/article_files/repository"
	"go-humas-be/app/module/articles/mapper"
	"go-humas-be/app/module/articles/repository"
	"go-humas-be/app/module/articles/request"
	"go-humas-be/app/module/articles/response"
	usersRepository "go-humas-be/app/module/users/repository"
	config "go-humas-be/config/config"
	minioStorage "go-humas-be/config/config"
	"go-humas-be/utils/paginator"
	utilSvc "go-humas-be/utils/service"
	"io"
	"log"
	"math/rand"
	"mime"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

// ArticlesService
type articlesService struct {
	Repo                       repository.ArticlesRepository
	ArticleCategoriesRepo      articleCategoriesRepository.ArticleCategoriesRepository
	ArticleFilesRepo           articleFilesRepository.ArticleFilesRepository
	ArticleCategoryDetailsRepo articleCategoryDetailsRepository.ArticleCategoryDetailsRepository
	Log                        zerolog.Logger
	Cfg                        *config.Config
	UsersRepo                  usersRepository.UsersRepository
	MinioStorage               *minioStorage.MinioStorage
}

// ArticlesService define interface of IArticlesService
type ArticlesService interface {
	All(req request.ArticlesQueryRequest) (articles []*response.ArticlesResponse, paging paginator.Pagination, err error)
	Show(id uint) (articles *response.ArticlesResponse, err error)
	Save(req request.ArticlesCreateRequest, authToken string) (articles *entity.Articles, err error)
	SaveThumbnail(c *fiber.Ctx) (err error)
	Update(id uint, req request.ArticlesUpdateRequest) (err error)
	Delete(id uint) error
	Viewer(c *fiber.Ctx) error
}

// NewArticlesService init ArticlesService
func NewArticlesService(
	repo repository.ArticlesRepository,
	articleCategoriesRepo articleCategoriesRepository.ArticleCategoriesRepository,
	articleCategoryDetailsRepo articleCategoryDetailsRepository.ArticleCategoryDetailsRepository,
	articleFilesRepo articleFilesRepository.ArticleFilesRepository,
	log zerolog.Logger,
	cfg *config.Config,
	usersRepo usersRepository.UsersRepository,
	minioStorage *minioStorage.MinioStorage,
) ArticlesService {

	return &articlesService{
		Repo:                       repo,
		ArticleCategoriesRepo:      articleCategoriesRepo,
		ArticleCategoryDetailsRepo: articleCategoryDetailsRepo,
		ArticleFilesRepo:           articleFilesRepo,
		Log:                        log,
		UsersRepo:                  usersRepo,
		MinioStorage:               minioStorage,
		Cfg:                        cfg,
	}
}

// All implement interface of ArticlesService
func (_i *articlesService) All(req request.ArticlesQueryRequest) (articless []*response.ArticlesResponse, paging paginator.Pagination, err error) {
	results, paging, err := _i.Repo.GetAll(req)
	if err != nil {
		return
	}

	_i.Log.Info().Str("timestamp", time.Now().
		Format(time.RFC3339)).Str("Service:articlesService", "Methods:All").
		Interface("results", results).Msg("")

	host := _i.Cfg.App.Domain

	for _, result := range results {
		articleRes := mapper.ArticlesResponseMapper(_i.Log, host, result, _i.ArticleCategoriesRepo, _i.ArticleCategoryDetailsRepo, _i.ArticleFilesRepo, _i.UsersRepo)
		articless = append(articless, articleRes)
	}

	return
}

func (_i *articlesService) Show(id uint) (articles *response.ArticlesResponse, err error) {
	result, err := _i.Repo.FindOne(id)
	if err != nil {
		return nil, err
	}

	host := _i.Cfg.App.Domain

	return mapper.ArticlesResponseMapper(_i.Log, host, result, _i.ArticleCategoriesRepo, _i.ArticleCategoryDetailsRepo, _i.ArticleFilesRepo, _i.UsersRepo), nil
}

func (_i *articlesService) Save(req request.ArticlesCreateRequest, authToken string) (articles *entity.Articles, err error) {
	_i.Log.Info().Interface("data", req).Msg("")
	newReq := req.ToEntity()

	createdBy := utilSvc.GetUserInfo(_i.Log, _i.UsersRepo, authToken)
	newReq.CreatedById = &createdBy.ID

	isDraft := true
	if req.IsDraft == &isDraft {
		draftedAt := time.Now()
		newReq.IsDraft = &isDraft
		newReq.DraftedAt = &draftedAt
		isPublishFalse := false
		newReq.IsPublish = &isPublishFalse
		newReq.PublishedAt = nil
	}

	isPublish := true
	if req.IsPublish == &isPublish {
		publishedAt := time.Now()
		newReq.IsPublish = &isPublish
		newReq.PublishedAt = &publishedAt
		isDraftFalse := false
		newReq.IsDraft = &isDraftFalse
		newReq.DraftedAt = nil
	}

	if req.CreatedAt != nil {
		layout := "2006-01-02 15:04:05"
		parsedTime, err := time.Parse(layout, *req.CreatedAt)
		if err != nil {
			return nil, fmt.Errorf("Error parsing time:", err)
		}
		newReq.CreatedAt = parsedTime
	}

	saveArticleRes, err := _i.Repo.Create(newReq)
	if err != nil {
		return nil, err
	}

	var categoryIds []string
	if req.CategoryIds != "" {
		categoryIds = strings.Split(req.CategoryIds, ",")
	}

	_i.Log.Info().Interface("categoryIds", categoryIds).Msg("")

	for _, categoryId := range categoryIds {
		categoryIdInt, _ := strconv.Atoi(categoryId)

		_i.Log.Info().Interface("categoryIdUint", uint(categoryIdInt)).Msg("")

		findCategory, err := _i.ArticleCategoriesRepo.FindOne(uint(categoryIdInt))

		_i.Log.Info().Interface("findCategory", findCategory).Msg("")

		if err != nil {
			return nil, err
		}

		if findCategory == nil {
			return nil, errors.New("category not found")
		}

		categoryReq := articleCategoryDetailsReq.ArticleCategoryDetailsCreateRequest{
			ArticleId:  saveArticleRes.ID,
			CategoryId: categoryIdInt,
			IsActive:   true,
		}
		newCategoryReq := categoryReq.ToEntity()

		err = _i.ArticleCategoryDetailsRepo.Create(newCategoryReq)
		if err != nil {
			return nil, err
		}
	}

	return saveArticleRes, nil
}

func (_i *articlesService) SaveThumbnail(c *fiber.Ctx) (err error) {

	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
	if err != nil {
		return err
	}

	_i.Log.Info().Str("timestamp", time.Now().
		Format(time.RFC3339)).Str("Service:articlesService", "Methods:SaveThumbnail").
		Interface("id", id).Msg("")

	bucketName := _i.MinioStorage.Cfg.ObjectStorage.MinioStorage.BucketName

	form, err := c.MultipartForm()
	if err != nil {
		return err
	}
	files := form.File["files"]

	// Create minio connection.
	minioClient, err := _i.MinioStorage.ConnectMinio()
	if err != nil {
		// Return status 500 and minio connection error.
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"error": true,
			"msg":   err.Error(),
		})
	}

	// Iterasi semua file yang diunggah
	for _, file := range files {

		_i.Log.Info().Str("timestamp", time.Now().
			Format(time.RFC3339)).Str("Service:Resource", "Uploader:: loop1").
			Interface("data", file).Msg("")

		src, err := file.Open()
		if err != nil {
			return err
		}
		defer src.Close()

		filename := filepath.Base(file.Filename)
		filename = strings.ReplaceAll(filename, " ", "")
		filenameWithoutExt := filepath.Clean(filename[:len(filename)-len(filepath.Ext(filename))])
		extension := filepath.Ext(file.Filename)[1:]

		rand.New(rand.NewSource(time.Now().UnixNano()))
		randUniqueId := rand.Intn(1000000)

		newFilenameWithoutExt := filenameWithoutExt + "_" + strconv.Itoa(randUniqueId)
		newFilename := newFilenameWithoutExt + "." + extension
		objectName := "articles/thumbnail/" + newFilename

		findCategory, err := _i.Repo.FindOne(uint(id))
		findCategory.ThumbnailName = &newFilename
		findCategory.ThumbnailPath = &objectName
		err = _i.Repo.Update(uint(id), findCategory)
		if err != nil {
			return err
		}

		// Upload file ke MinIO
		_, err = minioClient.PutObject(context.Background(), bucketName, objectName, src, file.Size, minio.PutObjectOptions{})
		if err != nil {
			return err
		}
	}

	return
}

func (_i *articlesService) Update(id uint, req request.ArticlesUpdateRequest) (err error) {
	_i.Log.Info().Interface("data", req).Msg("")
	return _i.Repo.Update(id, req.ToEntity())
}

func (_i *articlesService) Delete(id uint) error {
	result, err := _i.Repo.FindOne(id)
	if err != nil {
		return err
	}

	isActive := false
	result.IsActive = &isActive
	return _i.Repo.Update(id, result)
}

func (_i *articlesService) Viewer(c *fiber.Ctx) (err error) {
	thumbnailName := c.Params("thumbnailName")

	emptyImage := "empty-image.jpg"
	searchThumbnail := emptyImage
	if thumbnailName != emptyImage {
		result, err := _i.Repo.FindByFilename(thumbnailName)
		if err != nil {
			return err
		}
		_i.Log.Info().Str("timestamp", time.Now().
			Format(time.RFC3339)).Str("Service:Resource", "articlesService:Viewer").
			Interface("resultThumbnail", result.ThumbnailPath).Msg("")

		if result.ThumbnailPath != nil {
			searchThumbnail = *result.ThumbnailPath
		} else {
			searchThumbnail = "articles/thumbnail/" + emptyImage
		}
	} else {
		searchThumbnail = "articles/thumbnail/" + emptyImage
	}

	_i.Log.Info().Str("timestamp", time.Now().
		Format(time.RFC3339)).Str("Service:Resource", "articlesService:Viewer").
		Interface("searchThumbnail", searchThumbnail).Msg("")

	ctx := context.Background()
	bucketName := _i.MinioStorage.Cfg.ObjectStorage.MinioStorage.BucketName
	objectName := searchThumbnail

	// Create minio connection.
	minioClient, err := _i.MinioStorage.ConnectMinio()
	if err != nil {
		// Return status 500 and minio connection error.
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"error": true,
			"msg":   err.Error(),
		})
	}

	fileContent, err := minioClient.GetObject(ctx, bucketName, objectName, minio.GetObjectOptions{})
	if err != nil {
		log.Fatalln(err)
	}
	defer fileContent.Close()

	contentType := mime.TypeByExtension("." + getFileExtension(objectName))
	if contentType == "" {
		contentType = "application/octet-stream"
	}

	c.Set("Content-Type", contentType)

	if _, err := io.Copy(c.Response().BodyWriter(), fileContent); err != nil {
		return err
	}

	return
}

func getFileExtension(filename string) string {
	// split file name
	parts := strings.Split(filename, ".")

	// jika tidak ada ekstensi, kembalikan string kosong
	if len(parts) == 1 || (len(parts) == 2 && parts[0] == "") {
		return ""
	}

	// ambil ekstensi terakhir
	return parts[len(parts)-1]
}