forked from mtusi2026/mtusi2026lab3
299 lines
9.5 KiB
Go
299 lines
9.5 KiB
Go
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)
|
||
}
|