Files
mtusi2026lab3-fork/src/api/handlers.go
T
2026-10-20 16:47:37 +03:00

299 lines
9.5 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package api
import (
"encoding/json"
"errors"
"net/http"
"regexp"
"strconv"
"strings"
"mtusi-messenger/src/domain"
)
var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
type Handler struct {
Store *domain.Store
Sessions *domain.SessionStore
}
// --- Health ---
func (h *Handler) Live(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
// Ready проверяет БД (обязательная зависимость). Redis — кэш, его недоступность
// не должна ронять readiness: API может работать, обходя кэш.
func (h *Handler) Ready(w http.ResponseWriter, r *http.Request) {
if err := h.Store.Ping(r.Context()); err != nil {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
// --- Users ---
type createUserReq struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
var req createUserReq
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON")
return
}
if !usernameRe.MatchString(req.Username) {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid username")
return
}
if n := len([]rune(req.DisplayName)); n < 1 || n > 100 || strings.TrimSpace(req.DisplayName) == "" {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid display_name")
return
}
// Пароль: 12–128 code points, не состоит только из пробелов.
if n := len([]rune(req.Password)); n < 12 || n > 128 || strings.TrimSpace(req.Password) == "" {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid password")
return
}
u, err := h.Store.CreateUser(r.Context(), req.Username, req.DisplayName, req.Password)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrConflict):
writeError(w, r, http.StatusConflict, "conflict", "username taken")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusCreated, u)
}
func (h *Handler) CurrentUser(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
u, _ := userFrom(r)
writeJSON(w, http.StatusOK, u)
})(w, r)
}
// --- Auth ---
func (h *Handler) CreateSession(w http.ResponseWriter, r *http.Request) {
username, password, err := parseBasicCredentials(r.Header.Get("Authorization"))
if err != nil {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
writeError(w, r, http.StatusUnauthorized, "unauthorized", "invalid credentials")
return
}
u, err := h.Store.VerifyPassword(r.Context(), username, password)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrUnauthorized):
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
writeError(w, r, http.StatusUnauthorized, "unauthorized", "invalid credentials")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
s, err := h.Sessions.Create(r.Context(), *u)
if err != nil {
if errors.Is(err, domain.ErrTimeout) {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store timeout")
return
}
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store unavailable")
return
}
writeJSON(w, http.StatusCreated, s)
}
func (h *Handler) RevokeSession(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
token := tokenFrom(r)
if err := h.Sessions.Revoke(r.Context(), token); err != nil {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store unavailable")
return
}
w.WriteHeader(http.StatusNoContent)
})(w, r)
}
// --- Chats ---
type createChatReq struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
var req createChatReq
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON")
return
}
if strings.TrimSpace(req.Title) == "" || len([]rune(req.Title)) > 100 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid title")
return
}
if len(req.MemberIDs) < 1 || len(req.MemberIDs) > 100 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member_ids")
return
}
c, err := h.Store.CreateChat(r.Context(), req.Title, req.MemberIDs, me.ID)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrInvalid):
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid members")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusCreated, c)
})(w, r)
}
func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
chats, err := h.Store.ListChats(r.Context(), me.ID)
if err != nil {
if errors.Is(err, domain.ErrTimeout) {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
}
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusOK, domain.ChatPage{Items: chats, NextCursor: nil})
})(w, r)
}
func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
c, err := h.Store.GetChat(r.Context(), r.PathValue("chat_id"), me.ID)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrNotFound):
writeError(w, r, http.StatusNotFound, "not_found", "chat not found")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusOK, c)
})(w, r)
}
// --- Messages ---
type createMessageReq struct {
Text string `json:"text"`
}
func (h *Handler) CreateMessage(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
chatID := r.PathValue("chat_id")
if _, err := h.Store.GetChat(r.Context(), chatID, me.ID); err != nil {
writeError(w, r, http.StatusNotFound, "not_found", "chat not found")
return
}
var req createMessageReq
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON")
return
}
if len([]rune(req.Text)) > 4000 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "message too long")
return
}
if strings.TrimSpace(req.Text) == "" {
writeError(w, r, http.StatusBadRequest, "invalid_request", "empty message")
return
}
m, err := h.Store.AddMessage(r.Context(), chatID, me.ID, req.Text)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrNotFound):
writeError(w, r, http.StatusNotFound, "not_found", "chat not found")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusCreated, m)
})(w, r)
}
func (h *Handler) ListMessages(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
chatID := r.PathValue("chat_id")
if _, err := h.Store.GetChat(r.Context(), chatID, me.ID); err != nil {
writeError(w, r, http.StatusNotFound, "not_found", "chat not found")
return
}
limit := 50
if v := r.URL.Query().Get("limit"); v != "" {
n, err := strconv.Atoi(v)
if err != nil || n < 1 || n > 100 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid limit")
return
}
limit = n
}
cursor := r.URL.Query().Get("cursor")
items, next, err := h.Store.ListMessages(r.Context(), chatID, limit, cursor)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrInvalid):
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "query timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusOK, domain.MessagePage{Items: items, NextCursor: next})
})(w, r)
}