Merge branch 'develop' of https://gitee.com/fusenpack/fusenapi into feature/auth

server/upload/internal/config/config.go

@@ -21,4 +21,9 @@ type Config struct {
 			}
 		}
 	}
+	BLMService struct {
+		ImageProcess struct {
+			Url string
+		}
+	}
 }

server/upload/internal/handler/routes.go

@@ -32,6 +32,31 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
 				Path:    "/api/upload/qrcode",
 				Handler: UploadQrcodeHandler(serverCtx),
 			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/api/upload/upload-files-backend",
+				Handler: UploadFilesBackendHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/api/upload/upload-files-frontend",
+				Handler: UploadFilesFrontendHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/api/upload/upload-callback",
+				Handler: UploadCallbackHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/api/upload/up-logo",
+				Handler: UploadLogoHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/api/upload/upload-file-base",
+				Handler: UploadFileBaseHandler(serverCtx),
+			},
 		},
 	)
 }

server/upload/internal/handler/uploadcallbackhandler.go

@@ -0,0 +1,35 @@
+package handler
+
+import (
+	"net/http"
+	"reflect"
+
+	"fusenapi/utils/basic"
+
+	"fusenapi/server/upload/internal/logic"
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+)
+
+func UploadCallbackHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		var req types.UploadCallbackReq
+		userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
+		if err != nil {
+			return
+		}
+
+		// 创建一个业务逻辑层实例
+		l := logic.NewUploadCallbackLogic(r.Context(), svcCtx)
+
+		rl := reflect.ValueOf(l)
+		basic.BeforeLogic(w, r, rl)
+
+		resp := l.UploadCallback(&req, userinfo)
+
+		if !basic.AfterLogic(w, r, rl, resp) {
+			basic.NormalAfterLogic(w, r, resp)
+		}
+	}
+}

server/upload/internal/handler/uploadfilebasehandler.go

@@ -0,0 +1,35 @@
+package handler
+
+import (
+	"net/http"
+	"reflect"
+
+	"fusenapi/utils/basic"
+
+	"fusenapi/server/upload/internal/logic"
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+)
+
+func UploadFileBaseHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		var req types.UploadFileBaseReq
+		userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
+		if err != nil {
+			return
+		}
+
+		// 创建一个业务逻辑层实例
+		l := logic.NewUploadFileBaseLogic(r.Context(), svcCtx)
+
+		rl := reflect.ValueOf(l)
+		basic.BeforeLogic(w, r, rl)
+
+		resp := l.UploadFileBase(&req, userinfo)
+
+		if !basic.AfterLogic(w, r, rl, resp) {
+			basic.NormalAfterLogic(w, r, resp)
+		}
+	}
+}

server/upload/internal/handler/uploadfilesbackendhandler.go

@@ -0,0 +1,35 @@
+package handler
+
+import (
+	"net/http"
+	"reflect"
+
+	"fusenapi/utils/basic"
+
+	"fusenapi/server/upload/internal/logic"
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+)
+
+func UploadFilesBackendHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		var req types.UploadFilesReq
+		userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
+		if err != nil {
+			return
+		}
+
+		// 创建一个业务逻辑层实例
+		l := logic.NewUploadFilesBackendLogic(r, svcCtx)
+
+		rl := reflect.ValueOf(l)
+		basic.BeforeLogic(w, r, rl)
+
+		resp := l.UploadFilesBackend(&req, userinfo)
+
+		if !basic.AfterLogic(w, r, rl, resp) {
+			basic.NormalAfterLogic(w, r, resp)
+		}
+	}
+}

server/upload/internal/handler/uploadfilesfrontendhandler.go

@@ -0,0 +1,35 @@
+package handler
+
+import (
+	"net/http"
+	"reflect"
+
+	"fusenapi/utils/basic"
+
+	"fusenapi/server/upload/internal/logic"
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+)
+
+func UploadFilesFrontendHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		var req types.UploadFilesReq
+		userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
+		if err != nil {
+			return
+		}
+
+		// 创建一个业务逻辑层实例
+		l := logic.NewUploadFilesFrontendLogic(r.Context(), svcCtx)
+
+		rl := reflect.ValueOf(l)
+		basic.BeforeLogic(w, r, rl)
+
+		resp := l.UploadFilesFrontend(&req, userinfo)
+
+		if !basic.AfterLogic(w, r, rl, resp) {
+			basic.NormalAfterLogic(w, r, resp)
+		}
+	}
+}

server/upload/internal/handler/uploadlogohandler.go

@@ -0,0 +1,35 @@
+package handler
+
+import (
+	"net/http"
+	"reflect"
+
+	"fusenapi/utils/basic"
+
+	"fusenapi/server/upload/internal/logic"
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+)
+
+func UploadLogoHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		var req types.UploadLogoReq
+		userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
+		if err != nil {
+			return
+		}
+
+		// 创建一个业务逻辑层实例
+		l := logic.NewUploadLogoLogic(r.Context(), svcCtx)
+
+		rl := reflect.ValueOf(l)
+		basic.BeforeLogic(w, r, rl)
+
+		resp := l.UploadLogo(&req, userinfo)
+
+		if !basic.AfterLogic(w, r, rl, resp) {
+			basic.NormalAfterLogic(w, r, resp)
+		}
+	}
+}

server/upload/internal/logic/uploadcallbacklogic.go

@@ -0,0 +1,98 @@
+package logic
+
+import (
+	"fusenapi/model/gmodel"
+	"fusenapi/utils/auth"
+	"fusenapi/utils/basic"
+
+	"context"
+
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+	"gorm.io/gorm"
+)
+
+type UploadCallbackLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUploadCallbackLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UploadCallbackLogic {
+	return &UploadCallbackLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+// 处理进入前逻辑w,r
+// func (l *UploadCallbackLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
+// }
+
+// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
+// func (l *UploadCallbackLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
+// // httpx.OkJsonCtx(r.Context(), w, resp)
+// }
+
+func (l *UploadCallbackLogic) UploadCallback(req *types.UploadCallbackReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
+	// userinfo 传入值时, 一定不为null
+
+	var userId int64
+	var guestId int64
+
+	// 检查用户是否是游客
+	if userinfo.IsGuest() {
+		// 如果是，使用游客ID和游客键名格式
+		guestId = userinfo.GuestId
+	} else {
+		// 否则，使用用户ID和用户键名格式
+		userId = userinfo.UserId
+	}
+
+	// 定义存储桶名称
+	var bucketName *string
+
+	// 根据类别选择存储桶
+	switch req.UploadBucket {
+	case 2:
+		bucketName = basic.TempfileBucketName
+	default:
+		bucketName = basic.StorageBucketName
+	}
+
+	resourceModel := gmodel.NewFsResourceModel(l.svcCtx.MysqlConn)
+	err := resourceModel.Trans(l.ctx, func(ctx context.Context, connGorm *gorm.DB) (err error) {
+		resourceModelTS := gmodel.NewFsResourceModel(l.svcCtx.MysqlConn)
+		resourceInfo, err := resourceModelTS.FindOneById(ctx, req.ResourceId)
+		if err != nil {
+			return err
+		}
+
+		var version string = "0.0.1"
+		var fsResource = &gmodel.FsResource{}
+		fsResource.UserId = &userId
+		fsResource.GuestId = &guestId
+		fsResource.ResourceId = req.ResourceId
+		fsResource.ResourceType = &req.ResourceType
+		fsResource.ResourceUrl = &req.ResourceUrl
+		fsResource.Metadata = &req.Metadata
+		fsResource.ApiType = &req.ApiType
+		fsResource.BucketName = bucketName
+		fsResource.Version = &version
+		if resourceInfo.ResourceId == "" {
+			_, err = resourceModelTS.Create(ctx, fsResource)
+		} else {
+			_, err = resourceModelTS.Update(ctx, fsResource)
+		}
+		return err
+	})
+	if err != nil {
+		logx.Error(err)
+		return resp.SetStatus(basic.CodeFileUploadErr, "file upload err,UploadCallback failed")
+	}
+	return resp.SetStatus(basic.CodeOK)
+}

server/upload/internal/logic/uploadfilebaselogic.go

@@ -0,0 +1,154 @@
+package logic
+
+import (
+	"fusenapi/model/gmodel"
+	"fusenapi/utils/auth"
+	"fusenapi/utils/basic"
+	"fusenapi/utils/file"
+	"fusenapi/utils/hash"
+	"time"
+
+	"context"
+
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type UploadFileBaseLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUploadFileBaseLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UploadFileBaseLogic {
+	return &UploadFileBaseLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+// 处理进入前逻辑w,r
+// func (l *UploadFileBaseLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
+// }
+
+// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
+// func (l *UploadFileBaseLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
+// // httpx.OkJsonCtx(r.Context(), w, resp)
+// }
+
+func (l *UploadFileBaseLogic) UploadFileBase(req *types.UploadFileBaseReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
+	// userinfo 传入值时, 一定不为null
+	// 定义用户ID和S3键名格式
+	var userId int64
+	var guestId int64
+
+	// 检查用户是否是游客
+	if userinfo.IsGuest() {
+		// 如果是，使用游客ID和游客键名格式
+		guestId = userinfo.GuestId
+	} else {
+		// 否则，使用用户ID和用户键名格式
+		userId = userinfo.UserId
+	}
+	if guestId == 0 {
+		guestId = req.GuestId
+	}
+	if userId == 0 {
+		userId = req.UserId
+	}
+
+	// 定义存储桶名称
+	var bucketName *string
+	var apiType int64 = req.ApiType
+
+	// 根据类别选择存储桶
+	switch req.UploadBucket {
+	case 2:
+		bucketName = basic.TempfileBucketName
+	default:
+		bucketName = basic.StorageBucketName
+	}
+
+	// 设置AWS会话的区域
+	l.svcCtx.AwsSession.Config.Region = aws.String("us-west-1")
+
+	// 创建新的S3服务实例
+	svc := s3.New(l.svcCtx.AwsSession)
+
+	// 定义S3请求和当前时间
+	var s3req *request.Request
+
+	var resourceId string = hash.JsonHashKey(req.FileKey)
+
+	var uploadUrl = UploadUrl{}
+	resourceModel := gmodel.NewFsResourceModel(l.svcCtx.MysqlConn)
+	resourceInfo, err := resourceModel.FindOneById(l.ctx, resourceId)
+	if err == nil && resourceInfo.ResourceId != "" {
+		uploadUrl.Status = 1
+		uploadUrl.ResourceId = resourceId
+		uploadUrl.ResourceUrl = *resourceInfo.ResourceUrl
+	} else {
+		dist, contentType, err := file.FileBase64ToByte(req.FileData)
+
+		if err != nil {
+			logx.Error(err)
+			return resp.SetStatus(basic.CodeFileUploadErr, "file upload err,base64tobyte error")
+		}
+
+		// 创建S3对象存储请求
+		s3req, _ = svc.PutObjectRequest(
+			&s3.PutObjectInput{
+				Bucket: bucketName,
+				Key:    &resourceId,
+			},
+		)
+
+		// 设置请求体为文件数据
+		s3req.SetBufferBody(dist)
+
+		// 发送请求
+		err = s3req.Send()
+
+		// 检查是否有错误
+		if err != nil {
+			logx.Error(err)
+			uploadUrl.Status = 0
+		} else {
+			var url = s3req.HTTPRequest.URL.String()
+			// 打印请求URL
+			logx.Info(url)
+			uploadUrl.Status = 1
+			uploadUrl.ResourceId = resourceId
+			uploadUrl.ResourceUrl = url
+			var version string = "0.0.1"
+			var nowTime = time.Now()
+			_, err = resourceModel.Create(l.ctx, &gmodel.FsResource{
+				ResourceId:   resourceId,
+				UserId:       &userId,
+				GuestId:      &guestId,
+				ResourceType: &contentType,
+				ResourceUrl:  &url,
+				Version:      &version,
+				UploadedAt:   &nowTime,
+				Metadata:     &req.Metadata,
+				ApiType:      &apiType,
+				BucketName:   bucketName,
+			})
+			if err != nil {
+				logx.Error(err)
+			}
+		}
+	}
+
+	// 返回成功的响应和上传URL
+	return resp.SetStatus(basic.CodeOK, map[string]interface{}{
+		"upload_data": uploadUrl,
+	})
+}

server/upload/internal/logic/uploadfilesbackendlogic.go

@@ -0,0 +1,259 @@
+package logic
+
+import (
+	"encoding/json"
+	"fusenapi/model/gmodel"
+	"fusenapi/utils/auth"
+	"fusenapi/utils/basic"
+	"fusenapi/utils/hash"
+	"io"
+	"net/http"
+	"time"
+
+	"context"
+
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/mr"
+)
+
+type UploadFilesBackendLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	r      *http.Request
+}
+
+func NewUploadFilesBackendLogic(r *http.Request, svcCtx *svc.ServiceContext) *UploadFilesBackendLogic {
+	return &UploadFilesBackendLogic{
+		Logger: logx.WithContext(r.Context()),
+		ctx:    r.Context(),
+		svcCtx: svcCtx,
+		r:      r,
+	}
+}
+
+// 处理进入前逻辑w,r
+// func (l *UploadFilesBackendLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
+// }
+
+// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
+// func (l *UploadFilesBackendLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
+// // httpx.OkJsonCtx(r.Context(), w, resp)
+// }
+
+func (l *UploadFilesBackendLogic) UploadFilesBackend(req *types.UploadFilesReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
+	// userinfo 传入值时, 一定不为null
+	if userinfo.IsOnlooker() {
+		// 如果是，返回未授权的错误码
+		return resp.SetStatus(basic.CodeUnAuth)
+	}
+
+	// 定义用户ID和S3键名格式
+	var userId int64
+	var guestId int64
+
+	// 检查用户是否是游客
+	if userinfo.IsGuest() {
+		// 如果是，使用游客ID和游客键名格式
+		guestId = userinfo.GuestId
+	} else {
+		// 否则，使用用户ID和用户键名格式
+		userId = userinfo.UserId
+	}
+
+	var uploadInfoList []UploadInfo
+	err := json.Unmarshal([]byte(req.UploadInfo), &uploadInfoList)
+	if err != nil {
+		logx.Error(err)
+		return resp.SetStatus(basic.CodeFileUploadErr, "file upload err,params Unmarshal failed")
+	}
+
+	var fileLen = len(uploadInfoList)
+
+	if fileLen == 0 {
+		return resp.SetStatus(basic.CodeFileUploadErr, "file upload err,no files")
+	}
+	if req.ApiType == 1 && fileLen > 100 {
+		return resp.SetStatus(basic.CodeFileUploadErr, "file upload err, files count is beyond the maximum")
+	}
+
+	// 定义存储桶名称
+	var bucketName *string
+
+	// 根据类别选择存储桶
+	switch req.UploadBucket {
+	case 2:
+		bucketName = basic.TempfileBucketName
+	default:
+		bucketName = basic.StorageBucketName
+	}
+
+	//设置内存大小
+	l.r.ParseMultipartForm(32 << 20)
+
+	//获取上传的文件组
+	files := l.r.MultipartForm.File["file"]
+
+	// 设置AWS会话的区域
+	l.svcCtx.AwsSession.Config.Region = aws.String("us-west-1")
+
+	// 创建新的S3服务实例
+	svc := s3.New(l.svcCtx.AwsSession)
+
+	// 定义S3请求和当前时间
+	var s3req *request.Request
+
+	resourceModel := gmodel.NewFsResourceModel(l.svcCtx.MysqlConn)
+	result, err := mr.MapReduce(func(source chan<- interface{}) {
+		for i, info := range uploadInfoList {
+			fileType := files[i].Header.Get("Content-Type")
+			// 打开文件
+			file, err := files[i].Open()
+			if err != nil {
+				logx.Error(err)
+			}
+			defer file.Close()
+			// 读取数据流
+			ioData, err := io.ReadAll(file)
+			if err != nil {
+				logx.Error(err)
+			}
+
+			// 一系列业务逻辑....验证类型,文件大小
+
+			var hashKey string = hash.JsonHashKey(info.FileKeys)
+			source <- UploadData{
+				FileKey:  info.FileKeys,
+				FileType: fileType,
+				Metadata: info.Metadata,
+				FileData: ioData,
+				ApiType:  req.ApiType,
+				Bucket:   bucketName,
+				HashKey:  hashKey,
+			}
+		}
+	}, func(item interface{}, writer mr.Writer[interface{}], cancel func(error)) {
+		uploadDataInfo := item.(UploadData)
+
+		var uploadUrl = UploadUrl{}
+		uploadUrl.Key = uploadDataInfo.FileKey
+		uploadUrl.ApiType = uploadDataInfo.ApiType
+		uploadUrl.ResourceType = uploadDataInfo.FileType
+
+		var resourceId string = uploadDataInfo.HashKey
+		// 查询数据库
+		resourceInfo, err := resourceModel.FindOneById(l.ctx, resourceId)
+		if err == nil && resourceInfo.ResourceId != "" {
+			uploadUrl.Status = 1
+			uploadUrl.ResourceId = resourceId
+			uploadUrl.ResourceUrl = *resourceInfo.ResourceUrl
+		} else {
+			// 创建S3对象存储请求
+			s3req, _ = svc.PutObjectRequest(
+				&s3.PutObjectInput{
+					Bucket: uploadDataInfo.Bucket,
+					Key:    &uploadDataInfo.HashKey,
+				},
+			)
+
+			// 设置请求体为文件数据
+			s3req.SetBufferBody(uploadDataInfo.FileData)
+
+			// 发送请求
+			err = s3req.Send()
+			// 检查是否有错误
+			if err != nil {
+				logx.Error(err)
+				uploadUrl.Status = 0
+			} else {
+				contentType := http.DetectContentType(uploadDataInfo.FileData)
+				var url = s3req.HTTPRequest.URL.String()
+				// 打印请求URL
+				logx.Info(url)
+				uploadUrl.Status = 1
+				uploadUrl.ResourceId = resourceId
+				uploadUrl.ResourceUrl = url
+				var version string = "0.0.1"
+				var nowTime = time.Now()
+				_, err = resourceModel.Create(l.ctx, &gmodel.FsResource{
+					ResourceId:   resourceId,
+					UserId:       &userId,
+					GuestId:      &guestId,
+					ResourceType: &contentType,
+					ResourceUrl:  &url,
+					Version:      &version,
+					UploadedAt:   &nowTime,
+					Metadata:     &uploadDataInfo.Metadata,
+					ApiType:      &uploadDataInfo.ApiType,
+					BucketName:   bucketName,
+				})
+				if err != nil {
+					logx.Error(err)
+				}
+			}
+		}
+
+		// Notice 这个必须加!
+		writer.Write(uploadUrl)
+	}, func(pipe <-chan interface{}, writer mr.Writer[interface{}], cancel func(error)) {
+		var uploadUrlList = make(map[string][]*UploadUrl)
+		var uploadUrlListFail []*UploadUrl
+		var uploadUrlListSuccess []*UploadUrl
+		for p := range pipe {
+			var uploadUrl = p.(UploadUrl)
+			if uploadUrl.Status == 1 {
+				uploadUrlListSuccess = append(uploadUrlListSuccess, &uploadUrl)
+			} else {
+				uploadUrlListFail = append(uploadUrlListFail, &uploadUrl)
+			}
+		}
+
+		// Notice 这个必须加!
+		uploadUrlList["success"] = uploadUrlListSuccess
+		uploadUrlList["fail"] = uploadUrlListFail
+		writer.Write(uploadUrlList)
+	})
+	if err != nil {
+		logx.Error(err)
+	}
+
+	// 返回成功的响应和上传URL
+	return resp.SetStatus(basic.CodeOK, map[string]interface{}{
+		"upload_data": result,
+	})
+}
+
+type UploadInfo struct {
+	FileSize int64   `json:"file_size"` // 上传文件大小
+	FileKeys string  `json:"file_keys"` // 上传文件唯一标识
+	FileData *string `json:"file_data"` // 上传文件Base64
+	Metadata string  `json:"meta_data"` // 上传文件额外信息
+
+}
+
+type UploadData struct {
+	ApiType  int64   `json:"api_type"`
+	FileSize int64   `json:"file_size"`
+	FileType string  `json:"file_type"`
+	FileKey  string  `json:"file_key"`
+	Metadata string  `json:"metadata"`
+	Bucket   *string `json:"bucket"`
+	HashKey  string  `json:"hash_key"`
+	FileData []byte  `fsfile:"data"`
+}
+
+type UploadUrl struct {
+	Key          string `json:"key"`
+	Status       int64  `json:"status"`
+	ApiType      int64  `json:"api_type"`
+	ResourceId   string `json:"resource_id"`
+	ResourceType string `json:"resource_type"`
+	ResourceUrl  string `json:"resource_url"`
+}

server/upload/internal/logic/uploadfilesfrontendlogic.go

@@ -0,0 +1,149 @@
+package logic
+
+import (
+	"encoding/json"
+	"fusenapi/utils/auth"
+	"fusenapi/utils/basic"
+	"fusenapi/utils/hash"
+	"time"
+
+	"context"
+
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/mr"
+)
+
+type UploadFilesFrontendLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUploadFilesFrontendLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UploadFilesFrontendLogic {
+	return &UploadFilesFrontendLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+// 处理进入前逻辑w,r
+// func (l *UploadFilesFrontendLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
+// }
+
+// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
+// func (l *UploadFilesFrontendLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
+// // httpx.OkJsonCtx(r.Context(), w, resp)
+// }
+
+func (l *UploadFilesFrontendLogic) UploadFilesFrontend(req *types.UploadFilesReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
+	// userinfo 传入值时, 一定不为null
+
+	var uploadInfoList []UploadInfo
+	err := json.Unmarshal([]byte(req.UploadInfo), &uploadInfoList)
+	if err != nil {
+		logx.Error(err)
+		return resp.SetStatus(basic.CodeFileUploadErr, "file upload err,params Unmarshal failed")
+	}
+
+	var fileLen = len(uploadInfoList)
+
+	if fileLen == 0 {
+		return resp.SetStatus(basic.CodeFileUploadErr, "file upload err,no files")
+	}
+	if req.ApiType == 1 && fileLen > 100 {
+		return resp.SetStatus(basic.CodeFileUploadErr, "file upload err, files count is beyond the maximum")
+	}
+
+	// 定义存储桶名称
+	var bucketName *string
+
+	// 根据类别选择存储桶
+	switch req.UploadBucket {
+	case 2:
+		bucketName = basic.TempfileBucketName
+	default:
+		bucketName = basic.StorageBucketName
+	}
+
+	// 设置AWS会话的区域
+	l.svcCtx.AwsSession.Config.Region = aws.String("us-west-1")
+
+	// 创建新的S3服务实例
+	svc := s3.New(l.svcCtx.AwsSession)
+
+	result, err := mr.MapReduce(func(source chan<- interface{}) {
+		for _, info := range uploadInfoList {
+			if info.FileSize <= 1024*1024*500 {
+				// 一系列业务逻辑....验证类型,文件大小
+				var hashKey string = hash.JsonHashKey(info.FileKeys)
+				source <- UploadData{
+					FileKey:  info.FileKeys,
+					FileSize: info.FileSize,
+					Bucket:   bucketName,
+					HashKey:  hashKey,
+				}
+			}
+		}
+	}, func(item interface{}, writer mr.Writer[interface{}], cancel func(error)) {
+		uploadDataInfo := item.(UploadData)
+
+		var uploadUrl = UploadUrl{}
+		uploadUrl.Key = uploadDataInfo.FileKey
+		uploadUrl.ApiType = uploadDataInfo.ApiType
+		uploadUrl.ResourceType = uploadDataInfo.FileType
+
+		s3req, _ := svc.PutObjectRequest(
+			&s3.PutObjectInput{
+				Bucket:        uploadDataInfo.Bucket,
+				Key:           &uploadDataInfo.HashKey,
+				ContentLength: aws.Int64(uploadDataInfo.FileSize),
+			},
+		)
+
+		url, err := s3req.Presign(time.Minute * 5)
+		if err != nil {
+			logx.Error(err)
+			uploadUrl.Status = 0
+		} else {
+			// 打印请求URL
+			logx.Info(url)
+			uploadUrl.Status = 1
+			uploadUrl.ResourceUrl = url
+			uploadUrl.ResourceId = uploadDataInfo.HashKey
+		}
+		// Notice 这个必须加!
+		writer.Write(uploadUrl)
+	}, func(pipe <-chan interface{}, writer mr.Writer[interface{}], cancel func(error)) {
+		var uploadUrlList = make(map[string][]*UploadUrl)
+		var uploadUrlListFail []*UploadUrl
+		var uploadUrlListSuccess []*UploadUrl
+		for p := range pipe {
+			var uploadUrl = p.(UploadUrl)
+			if uploadUrl.Status == 1 {
+				uploadUrlListSuccess = append(uploadUrlListSuccess, &uploadUrl)
+			} else {
+				uploadUrlListFail = append(uploadUrlListFail, &uploadUrl)
+			}
+		}
+
+		// Notice 这个必须加!
+		uploadUrlList["success"] = uploadUrlListSuccess
+		uploadUrlList["fail"] = uploadUrlListFail
+		writer.Write(uploadUrlList)
+	})
+	if err != nil {
+		logx.Error(err)
+	}
+
+	// 返回成功的响应和上传URL
+	return resp.SetStatus(basic.CodeOK, map[string]interface{}{
+		"upload_urls": result,
+	})
+}

server/upload/internal/logic/uploadlogologic.go

@@ -0,0 +1,144 @@
+package logic
+
+import (
+	"fusenapi/model/gmodel"
+	"fusenapi/utils/auth"
+	"fusenapi/utils/basic"
+	"time"
+
+	"context"
+
+	"fusenapi/server/upload/internal/svc"
+	"fusenapi/server/upload/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type UploadLogoLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUploadLogoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UploadLogoLogic {
+	return &UploadLogoLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+// 处理进入前逻辑w,r
+// func (l *UploadLogoLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
+// }
+
+// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
+// func (l *UploadLogoLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
+// // httpx.OkJsonCtx(r.Context(), w, resp)
+// }
+
+func (l *UploadLogoLogic) UploadLogo(req *types.UploadLogoReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
+	// userinfo 传入值时, 一定不为null
+	if userinfo.IsOnlooker() {
+		// 如果是，返回未授权的错误码
+		return resp.SetStatus(basic.CodeUnAuth)
+	}
+
+	var userId int64
+	var guestId int64
+
+	// 检查用户是否是游客
+	if userinfo.IsGuest() {
+		// 如果是，使用游客ID和游客键名格式
+		guestId = userinfo.GuestId
+	} else {
+		// 否则，使用用户ID和用户键名格式
+		userId = userinfo.UserId
+	}
+
+	var logoWidth int64
+	var logoHeight int64
+	// 查看sku是否存在
+	if req.SkuId > 0 {
+		// 查询出产品模板信息
+		productTemplateV2Model := gmodel.NewFsProductTemplateV2Model(l.svcCtx.MysqlConn)
+		productTemplateV2Info, err := productTemplateV2Model.FindOne(l.ctx, req.SkuId)
+		if err != nil {
+			logx.Error(err)
+			return resp.SetStatus(basic.CodeFileUploadLogoErr, "logo upload err,no product template")
+		}
+
+		logoWidth = *productTemplateV2Info.LogoWidth
+		logoHeight = *productTemplateV2Info.LogoHeight
+	}
+	// 设置默认宽高
+	if logoWidth == 0 || logoHeight == 0 {
+		logoWidth = 300
+		logoHeight = 200
+	}
+	var resultStr string
+	var err error
+
+	// apiUrl := l.svcCtx.Config.BLMService.ImageProcess.Url
+	// var onlyScale = true
+	// data := url.Values{}
+	// data.Set("imgurl", req.ResourceUrl)
+	// data.Set("layerwidth", strconv.Itoa(int(logoWidth)))
+	// data.Set("layerheight", strconv.Itoa(int(logoHeight)))
+	// data.Set("is_remove_bg", strconv.Itoa(int(req.IsRemoveBg)))
+	// data.Set("proportion", strconv.Itoa(int(req.Proportion)))
+	// data.Set("only_scale", fmt.Sprintf("%v", onlyScale))
+
+	// u, err := url.ParseRequestURI(apiUrl)
+	// if err != nil {
+	// 	logx.Error(err)
+	// 	return resp.SetStatus(basic.CodeFileUploadLogoErr, "service fail")
+	// }
+	// u.RawQuery = data.Encode() // URL encode
+	// fmt.Println(u.String())
+	// result, err := http.Get(u.String())
+	// if err != nil {
+	// 	logx.Error(err)
+	// 	return resp.SetStatus(basic.CodeFileUploadLogoErr, "service fail")
+	// }
+	// defer result.Body.Close()
+	// b, err := io.ReadAll(result.Body)
+	// if err != nil {
+	// 	logx.Error(err)
+	// 	return resp.SetStatus(basic.CodeFileUploadLogoErr, "service fail")
+	// }
+	// resultStr = string(b)
+
+	// // 上传图片
+	// var reqs types.UploadFileBaseReq
+	// reqs.ApiType = 2
+	// reqs.UploadBucket = 2
+	// reqs.Metadata = ""
+	// reqs.FileData = ""
+	// reqs.FileKey = ""
+
+	// // 创建一个业务逻辑层实例
+	// resUpload := NewUploadFileBaseLogic(l.ctx, l.svcCtx).UploadFileBase(&reqs, userinfo)
+
+	var module = "logo"
+	var nowTime = time.Now().Unix()
+	// 新增记录
+	userMaterialModel := gmodel.NewFsUserMaterialModel(l.svcCtx.MysqlConn)
+	_, err = userMaterialModel.CreateOrUpdate(l.ctx, &gmodel.FsUserMaterial{
+		Module:      &module,
+		UserId:      &userId,
+		GuestId:     &guestId,
+		ResourceId:  &req.ResourceId,
+		ResourceUrl: &req.ResourceUrl,
+		Metadata:    &resultStr,
+		CreateAt:    &nowTime,
+	})
+
+	if err != nil {
+		logx.Error(err)
+		return resp.SetStatus(basic.CodeFileUploadLogoErr, "service fail")
+	}
+
+	return resp.SetStatus(basic.CodeOK)
+}

server/upload/internal/types/types.go

@@ -5,6 +5,45 @@ import (
 	"fusenapi/utils/basic"
 )
 
+type UploadFileBaseReq struct {
+	ApiType      int64  `form:"api_type,options=[1,2],default=1"`      // 调用类型：1=对外，2=对内
+	FileKey      string `form:"file_key"`                              // 上传唯一标识信息
+	FileData     string `form:"file_data"`                             // 上传文件额外信息
+	Metadata     string `form:"meta_data,optional"`                    // 上传文件额外信息
+	UserId       int64  `form:"user_id,optional"`                      // 上传文件额外信息
+	GuestId      int64  `form:"guest_id,optional"`                     // 上传文件额外信息
+	UploadBucket int64  `form:"upload_bucket,options=[1,2],default=1"` // 上传桶名:1=缓存,2=持久
+}
+
+type UploadLogoReq struct {
+	ResourceId  string `form:"resource_id"`           // 资源ID
+	ResourceUrl string `form:"resource_url"`          // 资源URL
+	IsRemoveBg  int64  `form:"is_remove_bg"`          // 是否要去掉背景
+	Proportion  int64  `form:"proportion,default=60"` // 贴图在模型面板上的比例
+	SkuId       int64  `form:"sku_id,default=0"`      // 模板ID
+}
+
+type UploadInfo struct {
+	FileSize int64  `form:"file_size,optional"` // 上传唯一标识信息
+	FileKeys string `form:"file_keys,optional"` // 上传唯一标识信息
+	Metadata string `form:"meta_data,optional"` // 上传文件额外信息
+}
+
+type UploadFilesReq struct {
+	ApiType      int64  `form:"api_type,options=[1,2],default=1"`      // 调用类型：1=对外，2=对内
+	UploadBucket int64  `form:"upload_bucket,options=[1,2],default=1"` // 上传桶名:1=缓存,2=持久
+	UploadInfo   string `form:"upload_info"`                           // 上传信息 json
+}
+
+type UploadCallbackReq struct {
+	UploadBucket int64  `form:"upload_bucket,options=[1,2],default=1"` // 上传桶名:1=缓存,2=持久
+	ResourceId   string `form:"resource_id"`                           // 资源ID
+	ResourceType string `form:"resource_type"`                         // 资源类型
+	ResourceUrl  string `form:"resource_url"`                          // 资源URL
+	Metadata     string `form:"metadata,optional"`                     // 元数据,json格式,存储图像分率
+	ApiType      int64  `form:"api_type,options=[1,2],default=1"`      // 调用类型：1=对外，2=对内
+}
+
 type RequestUpFile struct {
 	UpFile string `form:"upfile"`
 	IsCut  string `form:"is_cut"` // 是否裁剪