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