forked from mtusi2026/mtusi2026lab2
262 lines
6.2 KiB
Go
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
|
|
}
|