sundynix-pets/pets-be/internal/handler/community.go

package handler

import (
	"github.com/gin-gonic/gin"
	"gorm.io/datatypes"

	"github.com/sundynix/pets-be/internal/middleware"
	"github.com/sundynix/pets-be/internal/service"
	"github.com/sundynix/pets-be/pkg/response"
)

type postListReq struct {
	response.PageQuery
	Tab string `form:"tab"`
}

// ListPosts GET /api/posts?tab=&page=&page_size=
func (h *Handler) ListPosts(c *gin.Context) {
	var req postListReq
	_ = c.ShouldBindQuery(&req)
	req.Normalize()

	posts, total, err := h.svc.ListPosts(middleware.UserID(c), req.Tab, req.Offset(), req.Limit())
	if err != nil {
		response.FailErr(c, err)
		return
	}
	response.OK(c, response.NewPage(posts, total, req.PageQuery))
}

// GetPost GET /api/posts/:id
func (h *Handler) GetPost(c *gin.Context) {
	post, err := h.svc.GetPost(idParam(c, "id"))
	if err != nil {
		respondErr(c, err)
		return
	}
	response.OK(c, post)
}

type postReq struct {
	PetID        *string  `json:"pet_id"`
	Identity     string   `json:"identity"`
	Content      string   `json:"content"`
	Tags         []string `json:"tags"`
	Images       []string `json:"images"`
	ImageFileIDs []string `json:"image_file_ids"`
}

// CreatePost POST /api/posts
func (h *Handler) CreatePost(c *gin.Context) {
	var req postReq
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailParams(c, err.Error())
		return
	}
	in := service.PostInput{PetID: req.PetID, Identity: req.Identity, Content: req.Content}
	if b, err := jsonMarshal(req.Tags); err == nil {
		in.Tags = datatypes.JSON(b)
	}
	if b, err := jsonMarshal(req.Images); err == nil {
		in.Images = datatypes.JSON(b)
	}
	if len(req.ImageFileIDs) > 0 {
		if b, err := jsonMarshal(req.ImageFileIDs); err == nil {
			in.ImageFileIDs = datatypes.JSON(b)
		}
	}
	post, err := h.svc.CreatePost(middleware.UserID(c), in)
	if err != nil {
		response.FailErr(c, err)
		return
	}
	response.OK(c, post)
}

// LikePost POST /api/posts/:id/like
func (h *Handler) LikePost(c *gin.Context) {
	count, err := h.svc.LikePost(middleware.UserID(c), idParam(c, "id"))
	if err != nil {
		respondErr(c, err)
		return
	}
	response.OK(c, gin.H{"like_count": count})
}

// UnlikePost DELETE /api/posts/:id/like
func (h *Handler) UnlikePost(c *gin.Context) {
	count, err := h.svc.UnlikePost(middleware.UserID(c), idParam(c, "id"))
	if err != nil {
		respondErr(c, err)
		return
	}
	response.OK(c, gin.H{"like_count": count})
}

type commentListReq struct {
	response.PageQuery
}

// ListComments GET /api/posts/:id/comments
func (h *Handler) ListComments(c *gin.Context) {
	var req commentListReq
	_ = c.ShouldBindQuery(&req)
	req.Normalize()

	comments, total, err := h.svc.ListComments(idParam(c, "id"), req.Offset(), req.Limit())
	if err != nil {
		response.FailErr(c, err)
		return
	}
	response.OK(c, response.NewPage(comments, total, req.PageQuery))
}

type commentReq struct {
	Content string `json:"content"`
}

// CreateComment POST /api/posts/:id/comments
func (h *Handler) CreateComment(c *gin.Context) {
	var req commentReq
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailParams(c, err.Error())
		return
	}
	if req.Content == "" {
		response.FailParams(c, "评论内容不能为空")
		return
	}
	comment, err := h.svc.CreateComment(middleware.UserID(c), idParam(c, "id"), req.Content)
	if err != nil {
		respondErr(c, err)
		return
	}
	response.OK(c, comment)
}

// FollowUser POST /api/users/:id/follow
func (h *Handler) FollowUser(c *gin.Context) {
	if err := h.svc.FollowUser(middleware.UserID(c), idParam(c, "id")); err != nil {
		respondErr(c, err)
		return
	}
	response.OK(c, gin.H{"followed": true})
}

// UnfollowUser DELETE /api/users/:id/follow
func (h *Handler) UnfollowUser(c *gin.Context) {
	if err := h.svc.UnfollowUser(middleware.UserID(c), idParam(c, "id")); err != nil {
		response.FailErr(c, err)
		return
	}
	response.OK(c, gin.H{"followed": false})
}