Skip to content

A Q&A platform software for teams at any scales. Whether it's a community forum, help center, or knowledge management platform, you can always count on Apache Answer.

refactor(uploader): refactor AvatarThumbFile service

LinkinStars42c08fe56663
diff --git a/internal/base/middleware/avatar.go b/internal/base/middleware/avatar.go
index 82e6ceab..dadb93c3 100644
--- a/internal/base/middleware/avatar.go
+++ b/internal/base/middleware/avatar.go
@@ -32,31 +32,28 @@ func NewAvatarMiddleware(serviceConfig *service_config.ServiceConfig,
func (am *AvatarMiddleware) AvatarThumb() gin.HandlerFunc {
return func(ctx *gin.Context) {
- u := ctx.Request.RequestURI
- if strings.Contains(u, "/uploads/avatar/") {
- sizeStr := ctx.Query("s")
- size := converter.StringToInt(sizeStr)
- uUrl, err := url.Parse(u)
- if err != nil {
- ctx.Next()
- return
- }
- _, urlfileName := filepath.Split(uUrl.Path)
- uploadPath := am.serviceConfig.UploadPath
- filePath := fmt.Sprintf("%s/avatar/%s", uploadPath, urlfileName)
- var avatarfile []byte
- if size == 0 {
- avatarfile, err = os.ReadFile(filePath)
- } else {
- avatarfile, err = am.uploaderService.AvatarThumbFile(ctx, uploadPath, urlfileName, size)
+ uri := ctx.Request.RequestURI
+ if strings.Contains(uri, "/uploads/avatar/") {
+ size := converter.StringToInt(ctx.Query("s"))
+ uriWithoutQuery, _ := url.Parse(uri)
+ filename := filepath.Base(uriWithoutQuery.Path)
+ filePath := fmt.Sprintf("%s/avatar/%s", am.serviceConfig.UploadPath, filename)
+ var err error
+ if size != 0 {
+ filePath, err = am.uploaderService.AvatarThumbFile(ctx, filename, size)
+ if err != nil {
+ log.Error(err)
+ ctx.Abort()
+ }
}
+ avatarFile, err := os.ReadFile(filePath)
if err != nil {
- ctx.Next()
+ log.Error(err)
+ ctx.Abort()
return
}
- ext := strings.ToLower(path.Ext(filePath)[1:])
- ctx.Header("content-type", fmt.Sprintf("image/%s", ext))
- _, err = ctx.Writer.WriteString(string(avatarfile))
+ ctx.Header("content-type", fmt.Sprintf("image/%s", strings.TrimLeft(path.Ext(filePath), ".")))
+ _, err = ctx.Writer.Write(avatarFile)
if err != nil {
log.Error(err)
}
@@ -64,7 +61,7 @@ func (am *AvatarMiddleware) AvatarThumb() gin.HandlerFunc {
return
} else {
- uUrl, err := url.Parse(u)
+ uUrl, err := url.Parse(uri)
if err != nil {
ctx.Next()
return
diff --git a/internal/service/uploader/upload.go b/internal/service/uploader/upload.go
index e354d925..f6c14686 100644
--- a/internal/service/uploader/upload.go
+++ b/internal/service/uploader/upload.go
@@ -53,9 +53,9 @@ var (
type UploaderService interface {
UploadAvatarFile(ctx *gin.Context) (url string, err error)
- AvatarThumbFile(ctx *gin.Context, uploadPath, fileName string, size int) (avatarFile []byte, err error)
UploadPostFile(ctx *gin.Context) (url string, err error)
UploadBrandingFile(ctx *gin.Context) (url string, err error)
+ AvatarThumbFile(ctx *gin.Context, fileName string, size int) (url string, err error)
}
// uploaderService uploader service
@@ -105,26 +105,26 @@ func (us *uploaderService) UploadAvatarFile(ctx *gin.Context) (url string, err e
return us.uploadFile(ctx, file, avatarFilePath)
}
-func (us *uploaderService) AvatarThumbFile(ctx *gin.Context, uploadPath, fileName string, size int) (
- avatarfile []byte, err error) {
+func (us *uploaderService) AvatarThumbFile(ctx *gin.Context, fileName string, size int) (url string, err error) {
if size > 1024 {
size = 1024
}
+
thumbFileName := fmt.Sprintf("%d_%d@%s", size, size, fileName)
- thumbfilePath := fmt.Sprintf("%s/%s/%s", uploadPath, avatarThumbSubPath, thumbFileName)
- avatarfile, err = os.ReadFile(thumbfilePath)
+ thumbFilePath := fmt.Sprintf("%s/%s/%s", us.serviceConfig.UploadPath, avatarThumbSubPath, thumbFileName)
+ avatarfile, err := os.ReadFile(thumbFilePath)
if err == nil {
- return avatarfile, nil
+ return thumbFilePath, nil
}
- filePath := fmt.Sprintf("%s/avatar/%s", uploadPath, fileName)
+ filePath := fmt.Sprintf("%s/avatar/%s", us.serviceConfig.UploadPath, fileName)
avatarfile, err = os.ReadFile(filePath)
if err != nil {
- return avatarfile, errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
+ return "", errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
}
reader := bytes.NewReader(avatarfile)
img, err := imaging.Decode(reader)
if err != nil {
- return avatarfile, errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
+ return "", errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
}
new_image := imaging.Fill(img, size, size, imaging.Center, imaging.Linear)
var buf bytes.Buffer
@@ -133,29 +133,29 @@ func (us *uploaderService) AvatarThumbFile(ctx *gin.Context, uploadPath, fileNam
_, ok := FormatExts[fileSuffix]
if !ok {
- return avatarfile, fmt.Errorf("img extension not exist")
+ return "", fmt.Errorf("img extension not exist")
}
err = imaging.Encode(&buf, new_image, FormatExts[fileSuffix])
if err != nil {
- return avatarfile, errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
+ return "", errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
}
thumbReader := bytes.NewReader(buf.Bytes())
err = dir.CreateDirIfNotExist(path.Join(us.serviceConfig.UploadPath, avatarThumbSubPath))
if err != nil {
- return nil, errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
+ return "", errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
}
avatarFilePath := path.Join(avatarThumbSubPath, thumbFileName)
savefilePath := path.Join(us.serviceConfig.UploadPath, avatarFilePath)
out, err := os.Create(savefilePath)
if err != nil {
- return avatarfile, errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
+ return "", errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
}
defer out.Close()
_, err = io.Copy(out, thumbReader)
if err != nil {
- return avatarfile, errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
+ return "", errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
}
- return buf.Bytes(), nil
+ return savefilePath, nil
}
func (us *uploaderService) UploadPostFile(ctx *gin.Context) (