Get media feature

- Postman update
- Add a cute cate pic
- Test: 200 | OK

Author: [email protected]

docs/Zola.postman_collection.json

@@ -1181,6 +1181,36 @@
 							"body": "{\n    \"code\": 9992,\n    \"message\": \"locked post\",\n    \"data\": null\n}"
 						}
 					]
+				},
+				{
+					"name": "get_media",
+					"request": {
+						"auth": {
+							"type": "bearer",
+							"bearer": [
+								{
+									"key": "token",
+									"value": "{{token}}",
+									"type": "string"
+								}
+							]
+						},
+						"method": "GET",
+						"header": [],
+						"url": {
+							"raw": "{{zola}}/post/{{new_post_id}}/media/117a6982-4242-42e8-b7de-c9106437ae31",
+							"host": [
+								"{{zola}}"
+							],
+							"path": [
+								"post",
+								"{{new_post_id}}",
+								"media",
+								"117a6982-4242-42e8-b7de-c9106437ae31"
+							]
+						}
+					},
+					"response": []
 				}
 			]
 		},

internal/laclongquan/application/posthandler_media.go

@@ -0,0 +1,29 @@
+package application
+
+import (
+	"context"
+
+	"github.com/thanhpp/zola/internal/laclongquan/domain/entity"
+)
+
+func (p PostHandler) GetMedia(ctx context.Context, userID, postID, mediaID string) (*entity.Media, error) {
+	user, err := p.userRepo.GetByID(ctx, userID)
+	if err != nil {
+		return nil, err
+	}
+
+	post, err := p.repo.GetByID(ctx, postID)
+	if err != nil {
+		return nil, err
+	}
+
+	var relation *entity.Relation
+	if userID != post.CreatorUUID().String() {
+		relation, err = p.relationRepo.GetRelationBetween(ctx, userID, post.CreatorUUID().String())
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return post.CanUserGetMedia(user, relation, mediaID)
+}

internal/laclongquan/domain/entity/post.go

@@ -75,6 +75,28 @@ func (p *Post) AddMedia(m Media) error {
 	return nil
 }
 
+func (p Post) CanUserGetMedia(user *User, relation *Relation, mediaID string) (*Media, error) {
+	if user.IsLocked() {
+		return nil, ErrLockedUser
+	}
+
+	if p.IsLocked() {
+		return nil, ErrLockedPost
+	}
+
+	if user.ID().String() != p.Creator() && relation == nil || (relation != nil && relation.IsFriend()) {
+		return nil, ErrPermissionDenied
+	}
+
+	for i := range p.media {
+		if mediaID == p.media[i].ID() {
+			return &p.media[i], nil
+		}
+	}
+
+	return nil, ErrPostNotContainsMedia
+}
+
 func (p *Post) RemoveMedia(ids ...string) ([]*Media, error) {
 	var (
 		deleted    = make([]*Media, 0, len(ids))

internal/laclongquan/domain/repository/postrepo.go

@@ -8,14 +8,16 @@ import (
 )
 
 var (
-	ErrPostNotFound = errors.New("post not found")
+	ErrPostNotFound  = errors.New("post not found")
+	ErrMediaNotFound = errors.New("media not found")
 )
 
 type PostUpdateFn func(ctx context.Context, post *entity.Post) (*entity.Post, error)
 
 type PostRepository interface {
 	// read
 	GetByID(ctx context.Context, id string) (*entity.Post, error)
+	GetMediaByID(ctx context.Context, id string) (*entity.Media, error)
 
 	// write
 	Create(ctx context.Context, post *entity.Post) error

internal/laclongquan/domain/repository/relationrepo.go

@@ -9,6 +9,7 @@ import (
 
 var (
 	ErrRelationNotFound = errors.New("relation not found")
+	ErrSameUser         = errors.New("same user")
 )
 
 type RelationRepository interface {

internal/laclongquan/infrastructure/adapter/gormdb/postdb.go

@@ -116,6 +116,22 @@ func (p postGorm) getByIDTx(ctx context.Context, tx *gorm.DB, id string, expect
 	return nil
 }
 
+func (p postGorm) GetMediaByID(ctx context.Context, id string) (*entity.Media, error) {
+	var (
+		mediaDB = new(MediaDB)
+	)
+
+	err := p.db.WithContext(ctx).Model(p.mediaModel).Where("media_uuid = ?", id).Take(mediaDB).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, repository.ErrMediaNotFound
+		}
+		return nil, err
+	}
+
+	return p.unmarshalMedia(mediaDB)
+}
+
 func (p postGorm) Create(ctx context.Context, post *entity.Post) error {
 	postDB := p.marshalPost(post)
 

internal/laclongquan/infrastructure/adapter/gormdb/relationdb.go

@@ -48,6 +48,10 @@ func (r relationGorm) unmarshal(relationDB *RelationDB) (*entity.Relation, error
 }
 
 func (r relationGorm) GetRelationBetween(ctx context.Context, userIDA, userIDB string) (*entity.Relation, error) {
+	if userIDA == userIDB {
+		return nil, repository.ErrSameUser
+	}
+
 	var relationDB = new(RelationDB)
 
 	if err := r.db.WithContext(ctx).Model(r.model).

internal/laclongquan/infrastructure/port/httpserver/controller/ctrlhelper.go

@@ -22,6 +22,7 @@ var (
 	ErrInvalidPostID    = errors.New("invalid post id")
 	ErrInvalidUserID    = errors.New("invalid user id")
 	ErrInvalidCommentID = errors.New("invalid comment id")
+	ErrInvalidMediaID   = errors.New("invalid media id")
 )
 
 func getClaimsFromCtx(c *gin.Context) (*auth.Claims, error) {
@@ -81,6 +82,16 @@ func getPostID(c *gin.Context) (uuid.UUID, error) {
 	return postUUID, nil
 }
 
+func getMediaID(c *gin.Context) (uuid.UUID, error) {
+	mediaID := c.Param("mediaid")
+	mediaUUID, err := uuid.Parse(mediaID)
+	if err != nil {
+		return uuid.Nil, ErrInvalidMediaID
+	}
+
+	return mediaUUID, nil
+}
+
 func getCommentID(c *gin.Context) (uuid.UUID, error) {
 	commentID := c.Param("commentid")
 	commentUUID, err := uuid.Parse(commentID)

internal/laclongquan/infrastructure/port/httpserver/controller/postctrl_media.go

@@ -0,0 +1,73 @@
+package controller
+
+import (
+	"fmt"
+
+	"github.com/gin-gonic/gin"
+	"github.com/thanhpp/zola/internal/laclongquan/domain/entity"
+	"github.com/thanhpp/zola/internal/laclongquan/domain/repository"
+	"github.com/thanhpp/zola/pkg/logger"
+	"github.com/thanhpp/zola/pkg/responsevalue"
+)
+
+func (ctrl PostController) GetMedia(c *gin.Context) {
+	userID, err := getUserUUIDFromClaims(c)
+	if err != nil {
+		logger.Errorf("get user id from claims error: %v", err)
+		ginAbortNotAcceptable(c, responsevalue.CodeInvalidateUser, "invalid user", nil)
+		return
+	}
+
+	postID, err := getPostID(c)
+	if err != nil {
+		logger.Errorf("get post id error: %v", err)
+		ginAbortNotAcceptable(c, responsevalue.CodeInvalidParameterType, "invalid post id", nil)
+		return
+	}
+
+	mediaID, err := getMediaID(c)
+	if err != nil {
+		logger.Errorf("get media id error: %v", err)
+		ginAbortNotAcceptable(c, responsevalue.CodeInvalidParameterType, "invalid media id", nil)
+		return
+	}
+
+	media, err := ctrl.handler.GetMedia(c, userID.String(), postID.String(), mediaID.String())
+	if err != nil {
+		logger.Errorf("get media error: %v", err)
+		switch err {
+		case repository.ErrUserNotFound:
+			ginAbortNotAcceptable(c, responsevalue.CodeInvalidateUser, "user not found", nil)
+			return
+
+		case repository.ErrPostNotFound:
+			ginAbortInternalError(c, responsevalue.CodePostNotExist, "post not found", nil)
+			return
+
+		case repository.ErrRelationNotFound:
+			ginAbortNotAcceptable(c, responsevalue.CodeInvalidParameterValue, "relation not found", nil)
+			return
+
+		case entity.ErrLockedUser:
+			ginAbortNotAcceptable(c, responsevalue.CodeInvalidateUser, "locked user", nil)
+			return
+
+		case entity.ErrLockedPost:
+			ginAbortNotAcceptable(c, responsevalue.CodeActionHasBeenDone, "locked post", nil)
+			return
+
+		case entity.ErrPermissionDenied:
+			ginAbortNotAcceptable(c, responsevalue.CodeInvalidAccess, "permission denied", nil)
+			return
+
+		case entity.ErrPostNotContainsMedia:
+			ginAbortNotAcceptable(c, responsevalue.CodeInvalidParameterValue, "post not contains media", nil)
+			return
+		}
+
+		ginAbortInternalError(c, responsevalue.CodeUnknownError, responsevalue.MsgUnknownError, nil)
+	}
+
+	fmt.Println(media.Path())
+	c.File(media.Path())
+}

internal/laclongquan/infrastructure/port/httpserver/router.go

@@ -62,6 +62,9 @@ func (s *HTTPServer) newRouter() *gin.Engine {
 		postGr.POST("/:postid/comment", postCtrl.CreateComment)
 		postGr.PUT("/:postid/comment/:commentid", postCtrl.UpdateComment)
 		postGr.DELETE("/:postid/comment/:commentid", postCtrl.DeleteComment)
+
+		// media
+		postGr.GET("/:postid/media/:mediaid", postCtrl.GetMedia)
 	}
 
 	reportGr := r.Group("/report")