239 lines
6.9 KiB
Go
239 lines
6.9 KiB
Go
package services
|
||
|
||
import (
|
||
configs "ares/config"
|
||
"bytes"
|
||
"encoding/json"
|
||
"fmt"
|
||
"io"
|
||
"mime/multipart"
|
||
"net/http"
|
||
"net/textproto"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"github.com/gofiber/fiber/v3"
|
||
"go.uber.org/zap"
|
||
)
|
||
|
||
// ImageOptions defines the parameters for image processing
|
||
type ImageOptions struct {
|
||
Width int
|
||
Height int
|
||
Quality int
|
||
Format string // "avif", "webp", "png", "jpg"
|
||
Folder string // e.g. "settings", "heroes"
|
||
}
|
||
|
||
// --- Token cache for external image API ---
|
||
var (
|
||
imageAPIToken string
|
||
imageAPITokenExp time.Time
|
||
imageAPITokenMu sync.Mutex
|
||
)
|
||
|
||
func getImageAPIToken() (string, error) {
|
||
if apiKey := strings.TrimSpace(configs.AppConfig.ImageAPIKey); apiKey != "" {
|
||
configs.Logger.Debug("using image API key from config")
|
||
return apiKey, nil
|
||
}
|
||
|
||
imageAPITokenMu.Lock()
|
||
defer imageAPITokenMu.Unlock()
|
||
|
||
if imageAPIToken != "" && time.Now().Before(imageAPITokenExp) {
|
||
configs.Logger.Debug("using cached image API token", zap.Time("expires_at", imageAPITokenExp))
|
||
return imageAPIToken, nil
|
||
}
|
||
|
||
payload, _ := json.Marshal(map[string]string{
|
||
"email": configs.AppConfig.ImageAPIEmail,
|
||
"password": configs.AppConfig.ImageAPIPassword,
|
||
})
|
||
|
||
resp, err := http.Post(
|
||
configs.AppConfig.ImageAPIURL+"/api/v1/auth/login",
|
||
"application/json",
|
||
bytes.NewReader(payload),
|
||
)
|
||
if err != nil {
|
||
return "", fmt.Errorf("image API login failed: %v", err)
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
respBody, err := io.ReadAll(resp.Body)
|
||
if err != nil {
|
||
return "", fmt.Errorf("image API login body read error: %v", err)
|
||
}
|
||
configs.Logger.Info(
|
||
"image API login response",
|
||
zap.Int("status_code", resp.StatusCode),
|
||
zap.String("body", string(respBody)),
|
||
)
|
||
|
||
var result struct {
|
||
Data struct {
|
||
AccessToken string `json:"accessToken"`
|
||
} `json:"data"`
|
||
}
|
||
if err := json.Unmarshal(respBody, &result); err != nil {
|
||
return "", fmt.Errorf("image API login decode error: %v", err)
|
||
}
|
||
if result.Data.AccessToken == "" {
|
||
return "", fmt.Errorf("image API returned empty token")
|
||
}
|
||
|
||
imageAPIToken = result.Data.AccessToken
|
||
imageAPITokenExp = time.Now().Add(6 * 24 * time.Hour) // 6 days (token valid for 7)
|
||
return imageAPIToken, nil
|
||
}
|
||
|
||
func callImageAPI(buffer []byte, filename string, opts ImageOptions) (string, error) {
|
||
token, err := getImageAPIToken()
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
configs.Logger.Debug(
|
||
"callImageAPI started",
|
||
zap.String("filename", filename),
|
||
zap.Int("bytes", len(buffer)),
|
||
zap.Int("width", opts.Width),
|
||
zap.Int("height", opts.Height),
|
||
zap.Int("quality", opts.Quality),
|
||
zap.String("format", opts.Format),
|
||
)
|
||
|
||
var body bytes.Buffer
|
||
w := multipart.NewWriter(&body)
|
||
|
||
mimeType := http.DetectContentType(buffer)
|
||
h := make(textproto.MIMEHeader)
|
||
h.Set("Content-Disposition", fmt.Sprintf(`form-data; name="file"; filename="%s"`, filename))
|
||
h.Set("Content-Type", mimeType)
|
||
part, err := w.CreatePart(h)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if _, err := part.Write(buffer); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
if opts.Width > 0 {
|
||
_ = w.WriteField("width", strconv.Itoa(opts.Width))
|
||
}
|
||
if opts.Height > 0 {
|
||
_ = w.WriteField("height", strconv.Itoa(opts.Height))
|
||
}
|
||
if opts.Quality > 0 {
|
||
_ = w.WriteField("quality", strconv.Itoa(opts.Quality))
|
||
}
|
||
format := strings.ToLower(strings.TrimSpace(opts.Format))
|
||
if format == "" {
|
||
format = "avif"
|
||
}
|
||
_ = w.WriteField("format", format)
|
||
w.Close()
|
||
|
||
req, err := http.NewRequest("POST", configs.AppConfig.ImageAPIURL+"/api/v1/images/upload", &body)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
req.Header.Set("Content-Type", w.FormDataContentType())
|
||
req.Header.Set("Authorization", "Bearer "+token)
|
||
|
||
client := &http.Client{Timeout: 60 * time.Second}
|
||
resp, err := client.Do(req)
|
||
if err != nil {
|
||
return "", fmt.Errorf("image API upload failed: %v", err)
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
respBody, err := io.ReadAll(resp.Body)
|
||
if err != nil {
|
||
return "", fmt.Errorf("image API upload body read error: %v", err)
|
||
}
|
||
configs.Logger.Info(
|
||
"image API upload response",
|
||
zap.Int("status_code", resp.StatusCode),
|
||
zap.String("body", string(respBody)),
|
||
)
|
||
if resp.StatusCode == http.StatusUnauthorized {
|
||
return "", fmt.Errorf("image API key gecersiz veya suresi dolmus (HTTP 401)")
|
||
}
|
||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||
return "", fmt.Errorf("image API upload basarisiz (HTTP %d): %s", resp.StatusCode, strings.TrimSpace(string(respBody)))
|
||
}
|
||
|
||
var result struct {
|
||
Data struct {
|
||
Image struct {
|
||
URL string `json:"url"`
|
||
} `json:"image"`
|
||
} `json:"data"`
|
||
}
|
||
if err := json.Unmarshal(respBody, &result); err != nil {
|
||
return "", fmt.Errorf("image API response decode error: %v", err)
|
||
}
|
||
if result.Data.Image.URL == "" {
|
||
return "", fmt.Errorf("image API returned empty URL (HTTP %d)", resp.StatusCode)
|
||
}
|
||
return result.Data.Image.URL, nil
|
||
}
|
||
|
||
// ProcessAndSaveImage handles the file upload, processing, and saving
|
||
func ProcessAndSaveImage(c fiber.Ctx, fieldName string, opts ImageOptions) (string, error) {
|
||
configs.Logger.Info(
|
||
"ProcessAndSaveImage called",
|
||
zap.String("field", fieldName),
|
||
zap.Int("width", opts.Width),
|
||
zap.Int("height", opts.Height),
|
||
zap.Int("quality", opts.Quality),
|
||
zap.String("format", opts.Format),
|
||
)
|
||
|
||
file, err := c.FormFile(fieldName)
|
||
if err != nil {
|
||
configs.Logger.Warn("no file uploaded for field", zap.Error(err), zap.String("field", fieldName))
|
||
return "", nil
|
||
}
|
||
|
||
f, err := file.Open()
|
||
if err != nil {
|
||
configs.Logger.Error("failed to open uploaded file", zap.Error(err), zap.String("filename", file.Filename))
|
||
return "", err
|
||
}
|
||
defer f.Close()
|
||
|
||
buffer, err := io.ReadAll(f)
|
||
if err != nil {
|
||
configs.Logger.Error("failed to read uploaded file bytes", zap.Error(err), zap.String("filename", file.Filename))
|
||
return "", err
|
||
}
|
||
configs.Logger.Debug("read uploaded file bytes", zap.String("filename", file.Filename), zap.Int("bytes", len(buffer)))
|
||
|
||
remoteURL, err := callImageAPI(buffer, file.Filename, opts)
|
||
if err != nil {
|
||
configs.Logger.Error("image API call failed", zap.Error(err))
|
||
return "", fmt.Errorf("resim işleme hatası: %v", err)
|
||
}
|
||
|
||
configs.Logger.Info("image saved", zap.String("url", remoteURL), zap.Int("width", opts.Width), zap.Int("height", opts.Height), zap.String("format", opts.Format), zap.Int("quality", opts.Quality))
|
||
return remoteURL, nil
|
||
}
|
||
|
||
// ProcessAndSaveImageFromBytes processes raw image bytes and saves the file
|
||
func ProcessAndSaveImageFromBytes(buffer []byte, opts ImageOptions) (string, error) {
|
||
configs.Logger.Debug("ProcessAndSaveImageFromBytes called", zap.Int("input_bytes", len(buffer)), zap.Any("options", opts))
|
||
|
||
remoteURL, err := callImageAPI(buffer, "image.jpg", opts)
|
||
if err != nil {
|
||
configs.Logger.Error("image API call failed (from bytes)", zap.Error(err))
|
||
return "", fmt.Errorf("resim işleme hatası: %v", err)
|
||
}
|
||
|
||
configs.Logger.Info("image saved from bytes", zap.String("url", remoteURL), zap.Int("width", opts.Width), zap.Int("height", opts.Height), zap.String("format", opts.Format), zap.Int("quality", opts.Quality))
|
||
return remoteURL, nil
|
||
}
|