feat: add image upload functionality for articles

- Implemented image upload API in the article service, allowing users to upload images associated with articles. - Added validation for image size and type, ensuring only supported formats (PNG, JPG, GIF, WebP) are accepted. - Created a new Aliyun object storage client to handle image storage and retrieval. - Updated the article handler to include an endpoint for image uploads. - Enhanced error handling for image upload failures and added relevant error messages. - Introduced public URL generation for stored images, allowing access via signed tokens. - Updated localization files to include new messages related to image upload functionality. - Added tests for image upload and retrieval processes.
2026-04-05 22:10:05 +08:00
parent 1401b50556
commit 94f7186cce
19 changed files with 1033 additions and 14 deletions
@@ -0,0 +1,213 @@
+package objectstorage
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/aliyun/aliyun-oss-go-sdk/oss"
+	"go.uber.org/zap"
+
+	"github.com/geo-platform/tenant-api/internal/shared/config"
+	"github.com/geo-platform/tenant-api/internal/shared/middleware"
+)
+
+type aliyunClient struct {
+	client *oss.Client
+	bucket string
+	logger *zap.Logger
+	cfg    config.ObjectStorageConfig
+}
+
+func NewAliyunClient(cfg config.ObjectStorageConfig, logger *zap.Logger) Client {
+	endpoint := strings.TrimSpace(cfg.Endpoint)
+	accessKey := strings.TrimSpace(cfg.AccessKey)
+	secretKey := strings.TrimSpace(cfg.SecretKey)
+	bucket := strings.TrimSpace(cfg.Bucket)
+	region := strings.TrimSpace(cfg.Region)
+	if endpoint == "" || accessKey == "" || secretKey == "" || bucket == "" || region == "" {
+		return disabledClient{reason: "missing object_storage aliyun endpoint/access_key/secret_key/bucket/region"}
+	}
+
+	endpointURL, err := parseURLWithScheme(endpoint, boolScheme(cfg.UseSSL))
+	if err != nil {
+		return disabledClient{reason: fmt.Sprintf("parse aliyun endpoint failed: %v", err)}
+	}
+
+	client, err := oss.New(
+		endpointURL.String(),
+		accessKey,
+		secretKey,
+		oss.AuthVersion(oss.AuthV4),
+		oss.Region(region),
+	)
+	if err != nil {
+		return disabledClient{reason: fmt.Sprintf("init aliyun oss client failed: %v", err)}
+	}
+
+	return &aliyunClient{
+		client: client,
+		bucket: bucket,
+		logger: logger,
+		cfg:    cfg,
+	}
+}
+
+func (c *aliyunClient) Validate() error {
+	if c == nil || c.client == nil {
+		return fmt.Errorf("%w: aliyun oss client is not initialized", ErrNotConfigured)
+	}
+	if strings.TrimSpace(c.bucket) == "" {
+		return fmt.Errorf("%w: aliyun bucket is empty", ErrNotConfigured)
+	}
+	if strings.TrimSpace(c.cfg.Region) == "" {
+		return fmt.Errorf("%w: aliyun region is empty", ErrNotConfigured)
+	}
+	return nil
+}
+
+func (c *aliyunClient) PutBytes(ctx context.Context, objectKey string, content []byte, contentType string) error {
+	if err := c.Validate(); err != nil {
+		return err
+	}
+	if strings.TrimSpace(objectKey) == "" {
+		return fmt.Errorf("object key is required")
+	}
+
+	exists, err := c.client.IsBucketExist(c.bucket)
+	if err != nil {
+		c.logError(ctx, "aliyun bucket exists check failed",
+			zap.String("bucket", c.bucket),
+			zap.String("object_key", objectKey),
+			zap.Error(err),
+		)
+		return fmt.Errorf("check aliyun bucket: %w", err)
+	}
+	if !exists {
+		if err := c.client.CreateBucket(c.bucket); err != nil {
+			c.logError(ctx, "aliyun create bucket failed",
+				zap.String("bucket", c.bucket),
+				zap.String("object_key", objectKey),
+				zap.Error(err),
+			)
+			return fmt.Errorf("create aliyun bucket: %w", err)
+		}
+	}
+
+	bucket, err := c.client.Bucket(c.bucket)
+	if err != nil {
+		c.logError(ctx, "aliyun get bucket failed",
+			zap.String("bucket", c.bucket),
+			zap.String("object_key", objectKey),
+			zap.Error(err),
+		)
+		return fmt.Errorf("get aliyun bucket: %w", err)
+	}
+
+	if err := bucket.PutObject(objectKey, bytes.NewReader(content), oss.ContentType(contentType)); err != nil {
+		c.logError(ctx, "aliyun put object failed",
+			zap.String("bucket", c.bucket),
+			zap.String("object_key", objectKey),
+			zap.Int("content_size", len(content)),
+			zap.Error(err),
+		)
+		return fmt.Errorf("put aliyun object: %w", err)
+	}
+
+	return nil
+}
+
+func (c *aliyunClient) GetBytes(ctx context.Context, objectKey string) ([]byte, error) {
+	if err := c.Validate(); err != nil {
+		return nil, err
+	}
+
+	bucket, err := c.client.Bucket(c.bucket)
+	if err != nil {
+		c.logError(ctx, "aliyun get bucket failed",
+			zap.String("bucket", c.bucket),
+			zap.String("object_key", objectKey),
+			zap.Error(err),
+		)
+		return nil, fmt.Errorf("get aliyun bucket: %w", err)
+	}
+
+	reader, err := bucket.GetObject(objectKey)
+	if err != nil {
+		c.logError(ctx, "aliyun get object failed",
+			zap.String("bucket", c.bucket),
+			zap.String("object_key", objectKey),
+			zap.Error(err),
+		)
+		return nil, fmt.Errorf("get aliyun object: %w", err)
+	}
+	defer reader.Close()
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		c.logError(ctx, "aliyun read object failed",
+			zap.String("bucket", c.bucket),
+			zap.String("object_key", objectKey),
+			zap.Error(err),
+		)
+		return nil, fmt.Errorf("read aliyun object: %w", err)
+	}
+
+	return data, nil
+}
+
+func (c *aliyunClient) Delete(ctx context.Context, objectKey string) error {
+	if err := c.Validate(); err != nil {
+		return err
+	}
+	if strings.TrimSpace(objectKey) == "" {
+		return nil
+	}
+
+	bucket, err := c.client.Bucket(c.bucket)
+	if err != nil {
+		c.logError(ctx, "aliyun get bucket failed",
+			zap.String("bucket", c.bucket),
+			zap.String("object_key", objectKey),
+			zap.Error(err),
+		)
+		return fmt.Errorf("get aliyun bucket: %w", err)
+	}
+
+	if err := bucket.DeleteObject(objectKey); err != nil {
+		c.logError(ctx, "aliyun delete object failed",
+			zap.String("bucket", c.bucket),
+			zap.String("object_key", objectKey),
+			zap.Error(err),
+		)
+		return fmt.Errorf("delete aliyun object: %w", err)
+	}
+
+	return nil
+}
+
+func (c *aliyunClient) PublicURL(objectKey string) (string, error) {
+	if err := c.Validate(); err != nil {
+		return "", err
+	}
+	return buildPublicURL(c.cfg, objectKey, true)
+}
+
+func (c *aliyunClient) logError(ctx context.Context, msg string, fields ...zap.Field) {
+	if c == nil || c.logger == nil {
+		return
+	}
+	if requestID := middleware.RequestIDFromContext(ctx); requestID != "" {
+		fields = append(fields, zap.String("request_id", requestID))
+	}
+	c.logger.Error(msg, fields...)
+}
+
+func boolScheme(useSSL bool) string {
+	if useSSL {
+		return "https"
+	}
+	return "http"
+}
@@ -18,6 +18,7 @@ type Client interface {
 	PutBytes(ctx context.Context, objectKey string, content []byte, contentType string) error
 	GetBytes(ctx context.Context, objectKey string) ([]byte, error)
 	Delete(ctx context.Context, objectKey string) error
+	PublicURL(objectKey string) (string, error)
 }

 func New(cfg config.ObjectStorageConfig, logger *zap.Logger) Client {
@@ -27,6 +28,8 @@ func New(cfg config.ObjectStorageConfig, logger *zap.Logger) Client {
 		return disabledClient{reason: "object storage is disabled"}
 	case "minio":
 		return NewMinIOClient(cfg, logger)
+	case "aliyun", "aliyun_oss", "aliyun-oss", "oss":
+		return NewAliyunClient(cfg, logger)
 	default:
 		return disabledClient{reason: fmt.Sprintf("unsupported object storage provider %q", cfg.Provider)}
 	}
@@ -54,3 +57,7 @@ func (c disabledClient) GetBytes(context.Context, string) ([]byte, error) {
 func (c disabledClient) Delete(context.Context, string) error {
 	return c.Validate()
 }
+
+func (c disabledClient) PublicURL(string) (string, error) {
+	return "", c.Validate()
+}
@@ -20,6 +20,7 @@ type minioClient struct {
 	bucket string
 	region string
 	logger *zap.Logger
+	cfg    config.ObjectStorageConfig
 }

 func NewMinIOClient(cfg config.ObjectStorageConfig, logger *zap.Logger) Client {
@@ -45,6 +46,7 @@ func NewMinIOClient(cfg config.ObjectStorageConfig, logger *zap.Logger) Client {
 		bucket: bucket,
 		region: strings.TrimSpace(cfg.Region),
 		logger: logger,
+		cfg:    cfg,
 	}
 }

@@ -153,6 +155,13 @@ func (c *minioClient) Delete(ctx context.Context, objectKey string) error {
 	return nil
 }

+func (c *minioClient) PublicURL(objectKey string) (string, error) {
+	if err := c.Validate(); err != nil {
+		return "", err
+	}
+	return buildPublicURL(c.cfg, objectKey, false)
+}
+
 func (c *minioClient) logError(ctx context.Context, msg string, fields ...zap.Field) {
 	if c == nil || c.logger == nil {
 		return
@@ -0,0 +1,116 @@
+package objectstorage
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/geo-platform/tenant-api/internal/shared/config"
+)
+
+func buildPublicURL(cfg config.ObjectStorageConfig, objectKey string, bucketInHost bool) (string, error) {
+	objectKey = strings.TrimSpace(objectKey)
+	if objectKey == "" {
+		return "", fmt.Errorf("object key is required")
+	}
+
+	defaultScheme := "http"
+	if cfg.UseSSL {
+		defaultScheme = "https"
+	}
+
+	if publicBaseURL := strings.TrimSpace(cfg.PublicBaseURL); publicBaseURL != "" {
+		baseURL, err := parseURLWithScheme(publicBaseURL, defaultScheme)
+		if err != nil {
+			return "", fmt.Errorf("parse public_base_url: %w", err)
+		}
+		baseURL.Path = joinEscapedPath(baseURL.Path, objectKey)
+		baseURL.RawPath = ""
+		return baseURL.String(), nil
+	}
+
+	endpoint := strings.TrimSpace(cfg.Endpoint)
+	bucket := strings.TrimSpace(cfg.Bucket)
+	if endpoint == "" || bucket == "" {
+		return "", fmt.Errorf("%w: object storage endpoint or bucket is missing", ErrNotConfigured)
+	}
+
+	endpointURL, err := parseURLWithScheme(endpoint, defaultScheme)
+	if err != nil {
+		return "", fmt.Errorf("parse object storage endpoint: %w", err)
+	}
+
+	if bucketInHost {
+		hostname := endpointURL.Hostname()
+		if hostname == "" {
+			return "", fmt.Errorf("invalid object storage endpoint host")
+		}
+
+		host := hostname
+		if !strings.HasPrefix(host, bucket+".") {
+			host = bucket + "." + host
+		}
+		if port := endpointURL.Port(); port != "" {
+			host += ":" + port
+		}
+
+		endpointURL.Host = host
+		endpointURL.Path = joinEscapedPath("", objectKey)
+		endpointURL.RawPath = ""
+		return endpointURL.String(), nil
+	}
+
+	endpointURL.Path = joinEscapedPath(endpointURL.Path, bucket, objectKey)
+	endpointURL.RawPath = ""
+	return endpointURL.String(), nil
+}
+
+func parseURLWithScheme(raw string, defaultScheme string) (*url.URL, error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return nil, fmt.Errorf("url is empty")
+	}
+
+	if !strings.Contains(raw, "://") {
+		raw = defaultScheme + "://" + raw
+	}
+
+	parsed, err := url.Parse(raw)
+	if err != nil {
+		return nil, err
+	}
+	if parsed.Host == "" {
+		return nil, fmt.Errorf("url host is empty")
+	}
+	return parsed, nil
+}
+
+func joinEscapedPath(basePath string, extra ...string) string {
+	segments := make([]string, 0)
+
+	appendPath := func(value string) {
+		value = strings.TrimSpace(value)
+		value = strings.Trim(value, "/")
+		if value == "" {
+			return
+		}
+
+		for _, segment := range strings.Split(value, "/") {
+			segment = strings.TrimSpace(segment)
+			if segment == "" {
+				continue
+			}
+			segments = append(segments, url.PathEscape(segment))
+		}
+	}
+
+	appendPath(basePath)
+	for _, value := range extra {
+		appendPath(value)
+	}
+
+	if len(segments) == 0 {
+		return "/"
+	}
+	return "/" + strings.Join(segments, "/")
+}