package chat import ( "net/http" "github.com/gin-gonic/gin" "github.com/google/uuid" "messenger/internal/platform/apperr" "messenger/internal/platform/httpx" "messenger/internal/platform/ident" "messenger/internal/platform/pagination" ) type Handler struct { chats *Service } func NewHandler(chats *Service) *Handler { return &Handler{chats: chats} } // Register mounts the chat endpoints on a router guarded by the authentication middleware. func (h *Handler) Register(protected gin.IRouter) { protected.POST("/chats", httpx.WithUser(h.create)) protected.GET("/chats", httpx.WithUser(h.list)) protected.GET("/chats/:chat_id", httpx.WithUser(h.get)) protected.POST("/chats/:chat_id/messages", httpx.WithUser(h.send)) protected.GET("/chats/:chat_id/messages", httpx.WithUser(h.history)) } type createChatRequest struct { Title string `json:"title"` MemberIDs []string `json:"member_ids"` } type createMessageRequest struct { Text string `json:"text"` } type ChatResponse struct { ID string `json:"id"` Title string `json:"title"` MemberIDs []string `json:"member_ids"` CreatedAt string `json:"created_at"` } type MessageResponse struct { ID string `json:"id"` ChatID string `json:"chat_id"` SenderID string `json:"sender_id"` Text string `json:"text"` CreatedAt string `json:"created_at"` } func toChatResponse(c ChatWithMembers) ChatResponse { members := make([]string, 0, len(c.MemberIDs)) for _, m := range c.MemberIDs { members = append(members, m.String()) } return ChatResponse{ ID: c.ID.String(), Title: c.Title, MemberIDs: members, CreatedAt: httpx.Timestamp(c.CreatedAt), } } func toMessageResponse(m Message) MessageResponse { return MessageResponse{ ID: m.ID.String(), ChatID: m.ChatID.String(), SenderID: m.SenderID.String(), Text: m.Text, CreatedAt: httpx.Timestamp(m.CreatedAt), } } func (h *Handler) create(c *gin.Context, actor uuid.UUID) { var req createChatRequest if err := httpx.DecodeJSON(c, &req); err != nil { httpx.Error(c, err) return } members := make([]uuid.UUID, 0, len(req.MemberIDs)) for _, raw := range req.MemberIDs { id, err := ident.Parse(raw) if err != nil { httpx.Error(c, apperr.Invalid("member_ids must contain valid UUIDs")) return } members = append(members, id) } chat, err := h.chats.Create(c.Request.Context(), actor, req.Title, members) if err != nil { httpx.Error(c, err) return } httpx.JSON(c, http.StatusCreated, toChatResponse(chat)) } func (h *Handler) list(c *gin.Context, actor uuid.UUID) { limit, after, err := listing(c, actor) if err != nil { httpx.Error(c, err) return } page, err := h.chats.List(c.Request.Context(), actor, after, limit) if err != nil { httpx.Error(c, err) return } httpx.JSON(c, http.StatusOK, pagination.ToResponse(page, actor, toChatResponse)) } func (h *Handler) get(c *gin.Context, actor uuid.UUID) { chatID, err := chatParam(c) if err != nil { httpx.Error(c, err) return } chat, err := h.chats.Get(c.Request.Context(), actor, chatID) if err != nil { httpx.Error(c, err) return } httpx.JSON(c, http.StatusOK, toChatResponse(chat)) } func (h *Handler) send(c *gin.Context, actor uuid.UUID) { chatID, err := chatParam(c) if err != nil { httpx.Error(c, err) return } var req createMessageRequest if err := httpx.DecodeJSON(c, &req); err != nil { httpx.Error(c, err) return } message, err := h.chats.Send(c.Request.Context(), actor, chatID, req.Text) if err != nil { httpx.Error(c, err) return } httpx.JSON(c, http.StatusCreated, toMessageResponse(message)) } func (h *Handler) history(c *gin.Context, actor uuid.UUID) { chatID, err := chatParam(c) if err != nil { httpx.Error(c, err) return } limit, after, err := listing(c, chatID) if err != nil { httpx.Error(c, err) return } page, err := h.chats.History(c.Request.Context(), actor, chatID, after, limit) if err != nil { httpx.Error(c, err) return } httpx.JSON(c, http.StatusOK, pagination.ToResponse(page, chatID, toMessageResponse)) } func chatParam(c *gin.Context) (uuid.UUID, error) { id, err := ident.Parse(c.Param("chat_id")) if err != nil { return uuid.Nil, apperr.Invalid("chat_id must be a UUID") } return id, nil } // listing parses limit and cursor; the cursor must belong to scope, and a // present but empty cursor is rejected like a malformed one. func listing(c *gin.Context, scope uuid.UUID) (int, *uuid.UUID, error) { limit, err := pagination.ParseLimit(c.Query("limit")) if err != nil { return 0, nil, apperr.Wrap(apperr.KindInvalid, err.Error(), err) } token, present := c.GetQuery("cursor") if !present { return limit, nil, nil } last, err := pagination.DecodeCursor(token, scope) if err != nil { return 0, nil, apperr.Wrap(apperr.KindInvalid, "cursor is invalid for this resource", err) } return limit, &last, nil }