479 lines
13 KiB
Go
479 lines
13 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"math/rand"
|
|
"mime/multipart"
|
|
"narasi-ahli-be/app/module/ai_chat_files/mapper"
|
|
"narasi-ahli-be/app/module/ai_chat_files/repository"
|
|
"narasi-ahli-be/app/module/ai_chat_files/request"
|
|
"narasi-ahli-be/app/module/ai_chat_files/response"
|
|
config "narasi-ahli-be/config/config"
|
|
minioStorage "narasi-ahli-be/config/config"
|
|
"narasi-ahli-be/utils/paginator"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
"github.com/minio/minio-go/v7"
|
|
"github.com/rs/zerolog"
|
|
)
|
|
|
|
// AiChatFilesService
|
|
type aiChatFilesService struct {
|
|
Repo repository.AiChatFilesRepository
|
|
Log zerolog.Logger
|
|
Cfg *config.Config
|
|
MinioStorage *minioStorage.MinioStorage
|
|
}
|
|
|
|
// AiChatFilesService define interface of IAiChatFilesService
|
|
type AiChatFilesService interface {
|
|
All(req request.AiChatFilesQueryRequest) (aiChatFiles []*response.AiChatFilesResponse, paging paginator.Pagination, err error)
|
|
Show(id uint) (aiChatFiles *response.AiChatFilesResponse, err error)
|
|
Save(c *fiber.Ctx, id uint) error
|
|
SaveAsync(c *fiber.Ctx, id uint) error
|
|
Update(id uint, req request.AiChatFilesUpdateRequest) (err error)
|
|
GetUploadStatus(c *fiber.Ctx) (progress int, err error)
|
|
Delete(id uint) error
|
|
Viewer(c *fiber.Ctx) error
|
|
GetByMessageId(req request.AiChatFilesQueryRequest) (
|
|
aiChatFiles []*response.AiChatFilesResponse,
|
|
paging paginator.Pagination,
|
|
err error,
|
|
)
|
|
}
|
|
|
|
// NewAiChatFilesService init AiChatFilesService
|
|
func NewAiChatFilesService(repo repository.AiChatFilesRepository, log zerolog.Logger, cfg *config.Config, minioStorage *minioStorage.MinioStorage) AiChatFilesService {
|
|
|
|
return &aiChatFilesService{
|
|
Repo: repo,
|
|
Log: log,
|
|
Cfg: cfg,
|
|
MinioStorage: minioStorage,
|
|
}
|
|
}
|
|
|
|
var (
|
|
progressMap = make(map[string]int) // Menyimpan progress upload per UploadID
|
|
progressLock = sync.Mutex{}
|
|
)
|
|
|
|
type progressWriter struct {
|
|
uploadID string
|
|
totalSize int64
|
|
uploadedSize *int64
|
|
}
|
|
|
|
// All implement interface of AiChatFilesService
|
|
func (_i *aiChatFilesService) All(req request.AiChatFilesQueryRequest) (aiChatFiless []*response.AiChatFilesResponse, paging paginator.Pagination, err error) {
|
|
results, paging, err := _i.Repo.GetAll(req)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
host := _i.Cfg.App.Domain
|
|
|
|
for _, result := range results {
|
|
aiChatFiless = append(aiChatFiless, mapper.AiChatFilesResponseMapper(result, host))
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (_i *aiChatFilesService) Show(id uint) (aiChatFiles *response.AiChatFilesResponse, err error) {
|
|
result, err := _i.Repo.FindOne(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
host := _i.Cfg.App.Domain
|
|
|
|
return mapper.AiChatFilesResponseMapper(result, host), nil
|
|
}
|
|
|
|
func (_i *aiChatFilesService) SaveAsync(c *fiber.Ctx, id uint) (err error) {
|
|
bucketName := _i.MinioStorage.Cfg.ObjectStorage.MinioStorage.BucketName
|
|
|
|
ctx := context.Background()
|
|
|
|
form, err := c.MultipartForm()
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
//filess := 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(),
|
|
})
|
|
}
|
|
|
|
for _, files := range form.File {
|
|
|
|
_i.Log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "Uploader:: top").
|
|
Interface("files", files).Msg("")
|
|
|
|
for _, fileHeader := range files {
|
|
_i.Log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "Uploader:: loop").
|
|
Interface("data", fileHeader).Msg("")
|
|
|
|
filename := filepath.Base(fileHeader.Filename)
|
|
filenameAlt := filepath.Clean(filename[:len(filename)-len(filepath.Ext(filename))])
|
|
filename = strings.ReplaceAll(filename, " ", "")
|
|
filenameWithoutExt := filepath.Clean(filename[:len(filename)-len(filepath.Ext(filename))])
|
|
extension := filepath.Ext(fileHeader.Filename)[1:]
|
|
|
|
now := time.Now()
|
|
rand.New(rand.NewSource(now.UnixNano()))
|
|
randUniqueId := rand.Intn(1000000)
|
|
uploadID := strconv.Itoa(randUniqueId)
|
|
|
|
newFilenameWithoutExt := filenameWithoutExt + "_" + strconv.Itoa(randUniqueId)
|
|
newFilename := newFilenameWithoutExt + "." + extension
|
|
|
|
objectName := fmt.Sprintf("aiChats/upload/%d/%d/%s", now.Year(), now.Month(), newFilename)
|
|
fileSize := strconv.FormatInt(fileHeader.Size, 10)
|
|
fileSizeInt := fileHeader.Size
|
|
|
|
_i.Log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "Uploader:: top").
|
|
Interface("Start upload", uploadID).Msg("")
|
|
|
|
req := request.AiChatFilesCreateRequest{
|
|
MessageId: id,
|
|
UploadId: &uploadID,
|
|
FilePath: &objectName,
|
|
FileName: &newFilename,
|
|
FileAlt: &filenameAlt,
|
|
Size: &fileSize,
|
|
}
|
|
|
|
err = _i.Repo.Create(req.ToEntity())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
src, err := fileHeader.Open()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer src.Close()
|
|
|
|
tempFilePath := fmt.Sprintf("/tmp/%s", newFilename)
|
|
tempFile, err := os.Create(tempFilePath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tempFile.Close()
|
|
|
|
// Copy file ke direktori sementara
|
|
_, err = io.Copy(tempFile, src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
go uploadToMinIO(ctx, _i.Log, minioClient, uploadID, tempFilePath, bucketName, objectName, fileSizeInt)
|
|
}
|
|
}
|
|
|
|
_i.Log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "User:All").
|
|
Interface("data", "Successfully uploaded").Msg("")
|
|
|
|
return
|
|
}
|
|
|
|
func (_i *aiChatFilesService) Save(c *fiber.Ctx, id uint) (err error) {
|
|
bucketName := _i.MinioStorage.Cfg.ObjectStorage.MinioStorage.BucketName
|
|
|
|
form, err := c.MultipartForm()
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
//filess := 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(),
|
|
})
|
|
}
|
|
|
|
for _, files := range form.File {
|
|
|
|
_i.Log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "Uploader:: top").
|
|
Interface("files", files).Msg("")
|
|
|
|
for _, fileHeader := range files {
|
|
_i.Log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "Uploader:: loop").
|
|
Interface("data", fileHeader).Msg("")
|
|
|
|
src, err := fileHeader.Open()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer src.Close()
|
|
|
|
filename := filepath.Base(fileHeader.Filename)
|
|
filenameAlt := filepath.Clean(filename[:len(filename)-len(filepath.Ext(filename))])
|
|
filename = strings.ReplaceAll(filename, " ", "")
|
|
filenameWithoutExt := filepath.Clean(filename[:len(filename)-len(filepath.Ext(filename))])
|
|
extension := filepath.Ext(fileHeader.Filename)[1:]
|
|
|
|
now := time.Now()
|
|
rand.New(rand.NewSource(now.UnixNano()))
|
|
randUniqueId := rand.Intn(1000000)
|
|
|
|
newFilenameWithoutExt := filenameWithoutExt + "_" + strconv.Itoa(randUniqueId)
|
|
newFilename := newFilenameWithoutExt + "." + extension
|
|
|
|
objectName := fmt.Sprintf("aiChats/upload/%d/%d/%s", now.Year(), now.Month(), newFilename)
|
|
fileSize := strconv.FormatInt(fileHeader.Size, 10)
|
|
|
|
req := request.AiChatFilesCreateRequest{
|
|
MessageId: id,
|
|
FilePath: &objectName,
|
|
FileName: &newFilename,
|
|
FileAlt: &filenameAlt,
|
|
Size: &fileSize,
|
|
}
|
|
|
|
err = _i.Repo.Create(req.ToEntity())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Upload file ke MinIO
|
|
_, err = minioClient.PutObject(context.Background(), bucketName, objectName, src, fileHeader.Size, minio.PutObjectOptions{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
_i.Log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "User:All").
|
|
Interface("data", "Successfully uploaded").Msg("")
|
|
|
|
return
|
|
}
|
|
|
|
func (_i *aiChatFilesService) Update(id uint, req request.AiChatFilesUpdateRequest) (err error) {
|
|
_i.Log.Info().Interface("data", req).Msg("")
|
|
return _i.Repo.Update(id, req.ToEntity())
|
|
}
|
|
|
|
func (_i *aiChatFilesService) Delete(id uint) error {
|
|
result, err := _i.Repo.FindOne(id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
result.IsActive = false
|
|
return _i.Repo.Update(id, result)
|
|
}
|
|
|
|
func (_i *aiChatFilesService) Viewer(c *fiber.Ctx) error {
|
|
filename := c.Params("filename")
|
|
|
|
result, err := _i.Repo.FindByFilename(filename)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
ctx := context.Background()
|
|
bucketName := _i.MinioStorage.Cfg.ObjectStorage.MinioStorage.BucketName
|
|
objectName := *result.FilePath
|
|
|
|
minioClient, err := _i.MinioStorage.ConnectMinio()
|
|
if err != nil {
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"error": true,
|
|
"msg": err.Error(),
|
|
})
|
|
}
|
|
|
|
object, err := minioClient.GetObject(
|
|
ctx,
|
|
bucketName,
|
|
objectName,
|
|
minio.GetObjectOptions{},
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer object.Close()
|
|
|
|
// 🔥 Ambil metadata object (INI PENTING)
|
|
stat, err := object.Stat()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// 🔥 Content-Type yang BENAR
|
|
if stat.ContentType != "" {
|
|
c.Set("Content-Type", stat.ContentType)
|
|
} else {
|
|
// fallback kalau metadata kosong
|
|
c.Type(filepath.Ext(objectName))
|
|
}
|
|
|
|
// 🔥 WAJIB untuk preview media
|
|
c.Set("Content-Disposition", "inline")
|
|
c.Set("Accept-Ranges", "bytes")
|
|
|
|
// 🔥 BIARKAN FIBER HANDLE STREAMING
|
|
return c.SendStream(object)
|
|
}
|
|
|
|
|
|
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]
|
|
}
|
|
|
|
func uploadTempFile(log zerolog.Logger, fileHeader *multipart.FileHeader, filePath string) {
|
|
src, err := fileHeader.Open()
|
|
if err != nil {
|
|
log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "AiChat:uploadToMinIO-0").
|
|
Interface("err", err).Msg("")
|
|
}
|
|
defer src.Close()
|
|
|
|
tempFile, err := os.Create(filePath)
|
|
if err != nil {
|
|
log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "AiChat:uploadToMinIO-1").
|
|
Interface("err", err).Msg("")
|
|
}
|
|
defer tempFile.Close()
|
|
|
|
// Copy file ke direktori sementara
|
|
_, err = io.Copy(tempFile, src)
|
|
if err != nil {
|
|
log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "AiChat:uploadToMinIO-2").
|
|
Interface("err", err).Msg("")
|
|
}
|
|
}
|
|
|
|
func uploadToMinIO(ctx context.Context, log zerolog.Logger, minioClient *minio.Client, uploadID, filePath, bucketName string, objectName string, fileSize int64) {
|
|
file, err := os.Open(filePath)
|
|
if err != nil {
|
|
log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "AiChat:uploadToMinIO-3").
|
|
Interface("err", err).Msg("")
|
|
return
|
|
}
|
|
defer file.Close()
|
|
|
|
// Upload file ke MinIO dengan progress tracking
|
|
uploadProgress := int64(0)
|
|
reader := io.TeeReader(file, &progressWriter{uploadID: uploadID, totalSize: fileSize, uploadedSize: &uploadProgress})
|
|
|
|
_, err = minioClient.PutObject(ctx, bucketName, objectName, reader, fileSize, minio.PutObjectOptions{})
|
|
if err != nil {
|
|
|
|
log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "AiChat:uploadToMinIO-4").
|
|
Interface("err", err).Msg("")
|
|
return
|
|
}
|
|
|
|
// Upload selesai, update progress menjadi 100
|
|
progressLock.Lock()
|
|
progressMap[uploadID] = 100
|
|
progressLock.Unlock()
|
|
|
|
go removeFileTemp(log, filePath)
|
|
}
|
|
|
|
func removeFileTemp(log zerolog.Logger, filePath string) {
|
|
err := os.Remove(filePath)
|
|
if err != nil {
|
|
log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "AiChat:uploadToMinIO-5").
|
|
Interface("Failed to remove temporary file", err).Msg("")
|
|
} else {
|
|
log.Info().Str("timestamp", time.Now().
|
|
Format(time.RFC3339)).Str("Service:Resource", "AiChat:uploadToMinIO-6").
|
|
Interface("err", "Temporary file removed").Msg("")
|
|
}
|
|
}
|
|
|
|
func (p *progressWriter) Write(data []byte) (int, error) {
|
|
n := len(data)
|
|
progressLock.Lock()
|
|
defer progressLock.Unlock()
|
|
|
|
*p.uploadedSize += int64(n)
|
|
progress := int(float64(*p.uploadedSize) / float64(p.totalSize) * 100)
|
|
|
|
// Update progress di map
|
|
progressMap[p.uploadID] = progress
|
|
|
|
return n, nil
|
|
}
|
|
|
|
func (_i *aiChatFilesService) GetUploadStatus(c *fiber.Ctx) (progress int, err error) {
|
|
uploadID := c.Params("uploadId")
|
|
|
|
// Ambil progress dari map
|
|
progressLock.Lock()
|
|
progress, _ = progressMap[uploadID]
|
|
progressLock.Unlock()
|
|
|
|
return progress, nil
|
|
}
|
|
|
|
func (_i *aiChatFilesService) GetByMessageId(
|
|
req request.AiChatFilesQueryRequest,
|
|
) (aiChatFiles []*response.AiChatFilesResponse, paging paginator.Pagination, err error) {
|
|
|
|
results, paging, err := _i.Repo.GetAll(req)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
host := _i.Cfg.App.Domain
|
|
|
|
for _, result := range results {
|
|
aiChatFiles = append(
|
|
aiChatFiles,
|
|
mapper.AiChatFilesResponseMapper(result, host),
|
|
)
|
|
}
|
|
|
|
return
|
|
}
|