Files
mtusi2026lab2/internal/httpapi/handlers.go
2026-10-23 16:31:42 +03:00

254 lines
7.1 KiB
Go

package httpapi
import (
"errors"
"net/http"
"strings"
"mtusi.local/messenger/internal/authpw"
"mtusi.local/messenger/internal/model"
)
func (a *API) createUser(w http.ResponseWriter, r *http.Request) {
var body struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
if err := readJSON(w, r, &body); err != nil {
a.writeReadError(w, r, err)
return
}
if !model.ValidUsername(body.Username) || !model.ValidLabel(body.DisplayName, 100) || !model.ValidPassword(body.Password) {
writeError(w, http.StatusBadRequest, "invalid_request", "Недопустимое имя или отображаемое имя", requestID(r))
return
}
hash, err := authpw.Hash(body.Password)
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", requestID(r))
return
}
user, err := a.db.CreateUser(r.Context(), body.Username, body.DisplayName, hash)
if err != nil {
writeStoreError(w, r, err, "Недопустимое имя или отображаемое имя")
return
}
writeJSON(w, http.StatusCreated, userToJSON(user))
}
func (a *API) createSession(w http.ResponseWriter, r *http.Request) {
if !bodyEmpty(r) {
writeError(w, http.StatusBadRequest, "invalid_request", "Неверный JSON", requestID(r))
return
}
username, password, ok := basicCredentials(r)
if !ok {
writeUnauthorized(w, r, true)
return
}
user, hash, err := a.db.UserByUsername(r.Context(), username)
if errors.Is(err, model.ErrUnavailable) {
writeStoreError(w, r, err, "")
return
}
if err != nil {
user = model.User{}
hash = ""
}
if !model.ValidPassword(password) || !a.checkPassword(password, hash) || user.ID == "" {
writeUnauthorized(w, r, true)
return
}
token, expires, err := a.session.Create(r.Context(), user.ID)
if err != nil {
writeStoreError(w, r, err, "")
return
}
writeJSON(w, http.StatusCreated, sessionJSON{
Token: token,
TokenType: "Bearer",
ExpiresAt: apiTime(expires),
User: userToJSON(user),
})
}
func (a *API) revokeSession(w http.ResponseWriter, r *http.Request) {
token, ok := bearerToken(r)
if !ok {
writeUnauthorized(w, r, false)
return
}
if _, err := a.session.Lookup(r.Context(), token); err != nil {
if errors.Is(err, model.ErrUnavailable) {
writeStoreError(w, r, err, "")
return
}
writeUnauthorized(w, r, false)
return
}
if err := a.session.Revoke(r.Context(), token); err != nil {
writeStoreError(w, r, err, "")
return
}
w.WriteHeader(http.StatusNoContent)
}
func (a *API) currentUser(w http.ResponseWriter, r *http.Request) {
user, ok := a.requireUser(w, r)
if !ok {
return
}
writeJSON(w, http.StatusOK, userToJSON(user))
}
func (a *API) createChat(w http.ResponseWriter, r *http.Request) {
user, ok := a.requireUser(w, r)
if !ok {
return
}
var body struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
if err := readJSON(w, r, &body); err != nil {
a.writeReadError(w, r, err)
return
}
chat, err := a.db.CreateChat(r.Context(), user.ID, body.Title, body.MemberIDs)
if err != nil {
writeStoreError(w, r, err, "Неверный список участников или название чата")
return
}
writeJSON(w, http.StatusCreated, chatToJSON(chat))
}
func (a *API) listChats(w http.ResponseWriter, r *http.Request) {
user, ok := a.requireUser(w, r)
if !ok {
return
}
limit, cursor, ok := a.pageQuery(w, r)
if !ok {
return
}
if cursor != nil && cursor.Resource != model.ResourceChats {
writeError(w, http.StatusBadRequest, "invalid_request", "Неверный cursor или limit", requestID(r))
return
}
items, next, err := a.db.ListChats(r.Context(), user.ID, limit, cursor)
if err != nil {
writeStoreError(w, r, err, "Неверный cursor или limit")
return
}
page := chatPageJSON{Items: make([]chatJSON, 0, len(items)), NextCursor: next}
for _, item := range items {
page.Items = append(page.Items, chatToJSON(item))
}
writeJSON(w, http.StatusOK, page)
}
func (a *API) getChat(w http.ResponseWriter, r *http.Request) {
user, ok := a.requireUser(w, r)
if !ok {
return
}
chatID, ok := pathChatID(w, r)
if !ok {
return
}
chat, err := a.db.Chat(r.Context(), chatID, user.ID)
if err != nil {
writeStoreError(w, r, err, "Неверный идентификатор чата")
return
}
writeJSON(w, http.StatusOK, chatToJSON(chat))
}
func (a *API) createMessage(w http.ResponseWriter, r *http.Request) {
user, ok := a.requireUser(w, r)
if !ok {
return
}
chatID, ok := pathChatID(w, r)
if !ok {
return
}
if _, err := a.db.Chat(r.Context(), chatID, user.ID); err != nil {
writeStoreError(w, r, err, "Неверный идентификатор чата")
return
}
var body struct {
Text string `json:"text"`
}
if err := readJSON(w, r, &body); err != nil {
a.writeReadError(w, r, err)
return
}
msg, err := a.db.AddMessage(r.Context(), chatID, user.ID, body.Text)
if err != nil {
writeStoreError(w, r, err, "Недопустимый текст сообщения")
return
}
writeJSON(w, http.StatusCreated, messageToJSON(msg))
}
func (a *API) listMessages(w http.ResponseWriter, r *http.Request) {
user, ok := a.requireUser(w, r)
if !ok {
return
}
chatID, ok := pathChatID(w, r)
if !ok {
return
}
limit, cursor, ok := a.pageQuery(w, r)
if !ok {
return
}
if cursor != nil && (cursor.Resource != model.ResourceMessages || cursor.ChatID != chatID) {
writeError(w, http.StatusBadRequest, "invalid_request", "Неверный cursor или limit", requestID(r))
return
}
items, next, err := a.db.ListMessages(r.Context(), chatID, user.ID, limit, cursor)
if err != nil {
writeStoreError(w, r, err, "Неверный cursor или limit")
return
}
page := messagePageJSON{Items: make([]messageJSON, 0, len(items)), NextCursor: next}
for _, item := range items {
page.Items = append(page.Items, messageToJSON(item))
}
writeJSON(w, http.StatusOK, page)
}
func (a *API) pageQuery(w http.ResponseWriter, r *http.Request) (int, *model.Cursor, bool) {
limit, err := parseLimit(r)
if err != nil {
writeError(w, http.StatusBadRequest, "invalid_request", "Неверный cursor или limit", requestID(r))
return 0, nil, false
}
cursor, err := parseCursor(r)
if err != nil {
writeError(w, http.StatusBadRequest, "invalid_request", "Неверный cursor или limit", requestID(r))
return 0, nil, false
}
return limit, cursor, true
}
func (a *API) writeReadError(w http.ResponseWriter, r *http.Request, err error) {
if errors.Is(err, errTooLarge) {
writeError(w, http.StatusRequestEntityTooLarge, "payload_too_large", "Слишком большой запрос", requestID(r))
return
}
writeError(w, http.StatusBadRequest, "invalid_request", "Неверный JSON", requestID(r))
}
func pathChatID(w http.ResponseWriter, r *http.Request) (string, bool) {
chatID := strings.ToLower(r.PathValue("chat_id"))
if !model.ValidUUID(chatID) {
writeError(w, http.StatusBadRequest, "invalid_request", "Неверный идентификатор чата", requestID(r))
return "", false
}
return chatID, true
}