Files
mtusi2026lab2/service/internal/adapter/controller/http/chatHandler.go
T
2026-11-05 14:24:40 +03:00

262 lines
6.2 KiB
Go

package http
import (
"net/http"
"strings"
"unicode/utf8"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
"gitea.privcloud.tech/mtusi2026/internal/service/chat"
)
type ChatHandler struct {
router router.Router
provider jwtprovider.Provider
validator *validator.ValidatorImpl
chat chat.API
}
func NewChatHandler(r router.Router, provider jwtprovider.Provider, v *validator.ValidatorImpl, api chat.API) Handler {
return &ChatHandler{
router: r,
provider: provider,
validator: v,
chat: api,
}
}
func (h *ChatHandler) RegisterRoutes() {
h.router.Private(http.MethodPost, "/api/v1/chats", h.Create)
h.router.Private(http.MethodGet, "/api/v1/chats", h.Get)
h.router.Private(http.MethodGet, "/api/v1/chats/{chat_id}", h.GetByID)
h.router.Private(http.MethodPost, "/api/v1/chats/{chat_id}/messages", h.SendMessage)
h.router.Private(http.MethodGet, "/api/v1/chats/{chat_id}/messages", h.GetMessages)
}
func (h *ChatHandler) Create(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
var req contracts.CreateChat
if !framework.Decode(w, r, &req) || !framework.Validate(w, r, h.validator, &req) {
return
}
if userData.UserID == uuid.Nil ||
!validText(req.Title, 100) ||
len(req.MemberIds) < 1 ||
len(req.MemberIds) > 100 {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid chat fields"))
return
}
resp, err := h.chat.CreateChat(ctx, dto.CreateChat{
CreatorID: userData.UserID,
Title: req.Title,
MemberIDs: req.MemberIds,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.Chat{
Id: resp.ID,
Title: resp.Title,
MemberIds: resp.MemberIDs,
CreatedAt: resp.CreatedAt,
})
}
func (h *ChatHandler) Get(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
limit, afterID, ok := framework.PageParams(w, r)
if !ok {
return
}
if userData.UserID == uuid.Nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid user id"))
return
}
if afterID != nil && *afterID == uuid.Nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid cursor"))
return
}
page, err := h.chat.ListForMember(ctx, dto.ChatFilters{
UserID: userData.UserID,
Limit: limit,
AfterID: afterID,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
items := make([]contracts.Chat, 0, len(page.Items))
for _, item := range page.Items {
items = append(items, contracts.Chat{
CreatedAt: item.CreatedAt,
Id: item.ID,
MemberIds: item.MemberIDs,
Title: item.Title,
})
}
framework.JSONResponse(w, http.StatusOK, contracts.ChatPage{
Items: items,
NextCursor: cursorString(page.NextCursorID),
})
}
func (h *ChatHandler) GetByID(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
chatID, err := framework.ParseIDFromPathParam(ctx, w, r, "chat_id")
if err != nil {
return
}
resp, err := h.chat.GetForMember(ctx, dto.ChatMember{
UserID: userData.UserID,
ChatID: chatID,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusOK, contracts.Chat{
CreatedAt: resp.CreatedAt,
Id: resp.ID,
MemberIds: resp.MemberIDs,
Title: resp.Title,
})
}
func (h *ChatHandler) SendMessage(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
chatID, err := framework.ParseIDFromPathParam(ctx, w, r, "chat_id")
if err != nil {
return
}
var req contracts.CreateMessage
if !framework.Decode(w, r, &req) || !framework.Validate(w, r, h.validator, &req) {
return
}
if !validText(req.Text, 4000) {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid message text"))
return
}
message, err := h.chat.CreateMessage(ctx, dto.CreateMessage{
ChatID: chatID,
SenderID: userData.UserID,
Text: req.Text,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.Message{
Id: message.ID,
ChatId: message.ChatID,
SenderId: message.SenderID,
Text: message.Text,
CreatedAt: message.CreatedAt,
})
}
func (h *ChatHandler) GetMessages(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
chatID, err := framework.ParseIDFromPathParam(ctx, w, r, "chat_id")
if err != nil {
return
}
limit, afterID, ok := framework.PageParams(w, r)
if !ok {
return
}
page, err := h.chat.ListForChat(ctx, dto.MessageFilters{
ChatID: chatID,
UserID: userData.UserID,
Limit: limit,
AfterID: afterID,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
items := make([]contracts.Message, 0, len(page.Items))
for _, message := range page.Items {
items = append(items, contracts.Message{
Id: message.ID,
ChatId: message.ChatID,
SenderId: message.SenderID,
Text: message.Text,
CreatedAt: message.CreatedAt,
})
}
framework.JSONResponse(w, http.StatusOK, contracts.MessagePage{Items: items, NextCursor: cursorString(page.NextCursorID)})
}
func cursorString(id *uuid.UUID) *string {
if id == nil {
return nil
}
value := id.String()
return &value
}
func validText(value string, maxLength int) bool {
return utf8.ValidString(value) && strings.TrimSpace(value) != "" && utf8.RuneCountInString(value) <= maxLength
}