4b4a337a88
Some checks failed
check / check (push) Failing after 1m5s
- Restore original .golangci.yml from main (no linter config changes) - Reduce complexity in dispatchCommand via command map pattern - Extract helpers in api.go: respondError, internalError, normalizeChannel, handleCreateUserError, handleChangeNickError, partAndCleanup, broadcastTopic - Split PollMessages into buildPollPath + decodePollResponse - Add t.Parallel() to all tests, make subtests independent - Extract test fx providers into named functions to reduce funlen - Use mutex to serialize viper access in parallel tests - Extract PRIVMSG constant, add nolint for gosec false positives - Split long test functions into focused test cases - Add blank lines before expressions per wsl_v5
1058 lines
19 KiB
Go
1058 lines
19 KiB
Go
package handlers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi"
|
|
)
|
|
|
|
var validNickRe = regexp.MustCompile(
|
|
`^[a-zA-Z_][a-zA-Z0-9_\-\[\]\\^{}|` + "`" + `]{0,31}$`,
|
|
)
|
|
|
|
var validChannelRe = regexp.MustCompile(
|
|
`^#[a-zA-Z0-9_\-]{1,63}$`,
|
|
)
|
|
|
|
const (
|
|
maxLongPollTimeout = 30
|
|
pollMessageLimit = 100
|
|
)
|
|
|
|
// authUser extracts the user from the Authorization header.
|
|
func (s *Handlers) authUser(
|
|
r *http.Request,
|
|
) (int64, string, error) {
|
|
auth := r.Header.Get("Authorization")
|
|
if !strings.HasPrefix(auth, "Bearer ") {
|
|
return 0, "", errUnauthorized
|
|
}
|
|
|
|
token := strings.TrimPrefix(auth, "Bearer ")
|
|
if token == "" {
|
|
return 0, "", errUnauthorized
|
|
}
|
|
|
|
return s.params.Database.GetUserByToken(
|
|
r.Context(), token,
|
|
)
|
|
}
|
|
|
|
func (s *Handlers) requireAuth(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
) (int64, string, bool) {
|
|
uid, nick, err := s.authUser(r)
|
|
if err != nil {
|
|
s.respondError(w, r,
|
|
"unauthorized",
|
|
http.StatusUnauthorized)
|
|
|
|
return 0, "", false
|
|
}
|
|
|
|
return uid, nick, true
|
|
}
|
|
|
|
// fanOut stores a message and enqueues it to all specified
|
|
// user IDs, then notifies them.
|
|
func (s *Handlers) fanOut(
|
|
r *http.Request,
|
|
command, from, to string,
|
|
body json.RawMessage,
|
|
userIDs []int64,
|
|
) (string, error) {
|
|
dbID, msgUUID, err := s.params.Database.InsertMessage(
|
|
r.Context(), command, from, to, body, nil,
|
|
)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
for _, uid := range userIDs {
|
|
err = s.params.Database.EnqueueMessage(
|
|
r.Context(), uid, dbID,
|
|
)
|
|
if err != nil {
|
|
s.log.Error("enqueue failed",
|
|
"error", err, "user_id", uid)
|
|
}
|
|
|
|
s.broker.Notify(uid)
|
|
}
|
|
|
|
return msgUUID, nil
|
|
}
|
|
|
|
// fanOutSilent calls fanOut and discards the return values.
|
|
func (s *Handlers) fanOutSilent(
|
|
r *http.Request,
|
|
command, from, to string,
|
|
body json.RawMessage,
|
|
userIDs []int64,
|
|
) error {
|
|
_, err := s.fanOut(
|
|
r, command, from, to, body, userIDs,
|
|
)
|
|
|
|
return err
|
|
}
|
|
|
|
// HandleCreateSession creates a new user session.
|
|
func (s *Handlers) HandleCreateSession() http.HandlerFunc {
|
|
type request struct {
|
|
Nick string `json:"nick"`
|
|
}
|
|
|
|
type response struct {
|
|
ID int64 `json:"id"`
|
|
Nick string `json:"nick"`
|
|
Token string `json:"token"`
|
|
}
|
|
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
var req request
|
|
|
|
err := json.NewDecoder(r.Body).Decode(&req)
|
|
if err != nil {
|
|
s.respondError(w, r,
|
|
"invalid request body",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
req.Nick = strings.TrimSpace(req.Nick)
|
|
|
|
if !validNickRe.MatchString(req.Nick) {
|
|
s.respondError(w, r,
|
|
"invalid nick format",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
id, token, err := s.params.Database.CreateUser(
|
|
r.Context(), req.Nick,
|
|
)
|
|
if err != nil {
|
|
s.handleCreateUserError(w, r, err)
|
|
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, r,
|
|
&response{ID: id, Nick: req.Nick, Token: token},
|
|
http.StatusCreated)
|
|
}
|
|
}
|
|
|
|
func (s *Handlers) respondError(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
msg string,
|
|
code int,
|
|
) {
|
|
s.respondJSON(w, r,
|
|
map[string]string{"error": msg}, code)
|
|
}
|
|
|
|
func (s *Handlers) handleCreateUserError(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
err error,
|
|
) {
|
|
if strings.Contains(err.Error(), "UNIQUE") {
|
|
s.respondError(w, r,
|
|
"nick already taken",
|
|
http.StatusConflict)
|
|
|
|
return
|
|
}
|
|
|
|
s.log.Error("create user failed", "error", err)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
}
|
|
|
|
// HandleState returns the current user's info and channels.
|
|
func (s *Handlers) HandleState() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
uid, nick, ok := s.requireAuth(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
channels, err := s.params.Database.ListChannels(
|
|
r.Context(), uid,
|
|
)
|
|
if err != nil {
|
|
s.log.Error("list channels failed", "error", err)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, r, map[string]any{
|
|
"id": uid,
|
|
"nick": nick,
|
|
"channels": channels,
|
|
}, http.StatusOK)
|
|
}
|
|
}
|
|
|
|
// HandleListAllChannels returns all channels on the server.
|
|
func (s *Handlers) HandleListAllChannels() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
_, _, ok := s.requireAuth(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
channels, err := s.params.Database.ListAllChannels(
|
|
r.Context(),
|
|
)
|
|
if err != nil {
|
|
s.log.Error(
|
|
"list all channels failed", "error", err,
|
|
)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, r, channels, http.StatusOK)
|
|
}
|
|
}
|
|
|
|
// HandleChannelMembers returns members of a channel.
|
|
func (s *Handlers) HandleChannelMembers() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
_, _, ok := s.requireAuth(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
name := "#" + chi.URLParam(r, "channel")
|
|
|
|
chID, err := s.params.Database.GetChannelByName(
|
|
r.Context(), name,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, r,
|
|
"channel not found",
|
|
http.StatusNotFound)
|
|
|
|
return
|
|
}
|
|
|
|
members, err := s.params.Database.ChannelMembers(
|
|
r.Context(), chID,
|
|
)
|
|
if err != nil {
|
|
s.log.Error(
|
|
"channel members failed", "error", err,
|
|
)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, r, members, http.StatusOK)
|
|
}
|
|
}
|
|
|
|
// HandleGetMessages returns messages via long-polling.
|
|
func (s *Handlers) HandleGetMessages() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
uid, _, ok := s.requireAuth(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
afterID, _ := strconv.ParseInt(
|
|
r.URL.Query().Get("after"), 10, 64,
|
|
)
|
|
|
|
timeout, _ := strconv.Atoi(
|
|
r.URL.Query().Get("timeout"),
|
|
)
|
|
if timeout < 0 {
|
|
timeout = 0
|
|
}
|
|
|
|
if timeout > maxLongPollTimeout {
|
|
timeout = maxLongPollTimeout
|
|
}
|
|
|
|
msgs, lastQID, err := s.params.Database.PollMessages(
|
|
r.Context(), uid, afterID, pollMessageLimit,
|
|
)
|
|
if err != nil {
|
|
s.log.Error(
|
|
"poll messages failed", "error", err,
|
|
)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
if len(msgs) > 0 || timeout == 0 {
|
|
s.respondJSON(w, r, map[string]any{
|
|
"messages": msgs,
|
|
"last_id": lastQID,
|
|
}, http.StatusOK)
|
|
|
|
return
|
|
}
|
|
|
|
s.longPoll(w, r, uid, afterID, timeout)
|
|
}
|
|
}
|
|
|
|
func (s *Handlers) longPoll(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
uid, afterID int64,
|
|
timeout int,
|
|
) {
|
|
waitCh := s.broker.Wait(uid)
|
|
|
|
timer := time.NewTimer(
|
|
time.Duration(timeout) * time.Second,
|
|
)
|
|
|
|
defer timer.Stop()
|
|
|
|
select {
|
|
case <-waitCh:
|
|
case <-timer.C:
|
|
case <-r.Context().Done():
|
|
s.broker.Remove(uid, waitCh)
|
|
|
|
return
|
|
}
|
|
|
|
s.broker.Remove(uid, waitCh)
|
|
|
|
msgs, lastQID, err := s.params.Database.PollMessages(
|
|
r.Context(), uid, afterID, pollMessageLimit,
|
|
)
|
|
if err != nil {
|
|
s.log.Error("poll messages failed", "error", err)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, r, map[string]any{
|
|
"messages": msgs,
|
|
"last_id": lastQID,
|
|
}, http.StatusOK)
|
|
}
|
|
|
|
// HandleSendCommand handles all C2S commands.
|
|
func (s *Handlers) HandleSendCommand() http.HandlerFunc {
|
|
type request struct {
|
|
Command string `json:"command"`
|
|
To string `json:"to"`
|
|
Body json.RawMessage `json:"body,omitempty"`
|
|
Meta json.RawMessage `json:"meta,omitempty"`
|
|
}
|
|
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
uid, nick, ok := s.requireAuth(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var req request
|
|
|
|
err := json.NewDecoder(r.Body).Decode(&req)
|
|
if err != nil {
|
|
s.respondError(w, r,
|
|
"invalid request body",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
req.Command = strings.ToUpper(
|
|
strings.TrimSpace(req.Command),
|
|
)
|
|
req.To = strings.TrimSpace(req.To)
|
|
|
|
if req.Command == "" {
|
|
s.respondError(w, r,
|
|
"command required",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
bodyLines := func() []string {
|
|
if req.Body == nil {
|
|
return nil
|
|
}
|
|
|
|
var lines []string
|
|
|
|
err := json.Unmarshal(req.Body, &lines)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
return lines
|
|
}
|
|
|
|
s.dispatchCommand(
|
|
w, r, uid, nick, req.Command,
|
|
req.To, req.Body, bodyLines,
|
|
)
|
|
}
|
|
}
|
|
|
|
func (s *Handlers) dispatchCommand(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
uid int64,
|
|
nick, command, to string,
|
|
body json.RawMessage,
|
|
bodyLines func() []string,
|
|
) {
|
|
switch command {
|
|
case "PRIVMSG", "NOTICE":
|
|
s.handlePrivmsg(
|
|
w, r, uid, nick, command, to, body, bodyLines,
|
|
)
|
|
case "JOIN":
|
|
s.handleJoin(w, r, uid, nick, to)
|
|
case "PART":
|
|
s.handlePart(w, r, uid, nick, to, body)
|
|
case "NICK":
|
|
s.handleNick(w, r, uid, nick, bodyLines)
|
|
case "TOPIC":
|
|
s.handleTopic(w, r, nick, to, body, bodyLines)
|
|
case "QUIT":
|
|
s.handleQuit(w, r, uid, nick, body)
|
|
case "PING":
|
|
s.respondJSON(w, r,
|
|
map[string]string{
|
|
"command": "PONG",
|
|
"from": s.params.Config.ServerName,
|
|
},
|
|
http.StatusOK)
|
|
default:
|
|
s.respondJSON(w, r,
|
|
map[string]string{
|
|
"error": "unknown command: " + command,
|
|
},
|
|
http.StatusBadRequest)
|
|
}
|
|
}
|
|
|
|
func (s *Handlers) handlePrivmsg(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
uid int64,
|
|
nick, command, to string,
|
|
body json.RawMessage,
|
|
bodyLines func() []string,
|
|
) {
|
|
if to == "" {
|
|
s.respondError(w, r,
|
|
"to field required",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
lines := bodyLines()
|
|
if len(lines) == 0 {
|
|
s.respondError(w, r,
|
|
"body required",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
if strings.HasPrefix(to, "#") {
|
|
s.handleChannelMsg(
|
|
w, r, uid, nick, command, to, body,
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
s.handleDirectMsg(w, r, uid, nick, command, to, body)
|
|
}
|
|
|
|
func (s *Handlers) handleChannelMsg(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
_ int64,
|
|
nick, command, to string,
|
|
body json.RawMessage,
|
|
) {
|
|
chID, err := s.params.Database.GetChannelByName(
|
|
r.Context(), to,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, r,
|
|
"channel not found",
|
|
http.StatusNotFound)
|
|
|
|
return
|
|
}
|
|
|
|
memberIDs, err := s.params.Database.GetChannelMemberIDs(
|
|
r.Context(), chID,
|
|
)
|
|
if err != nil {
|
|
s.log.Error(
|
|
"get channel members failed", "error", err,
|
|
)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
msgUUID, err := s.fanOut(
|
|
r, command, nick, to, body, memberIDs,
|
|
)
|
|
if err != nil {
|
|
s.log.Error("send message failed", "error", err)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, r,
|
|
map[string]string{"id": msgUUID, "status": "sent"},
|
|
http.StatusCreated)
|
|
}
|
|
|
|
func (s *Handlers) handleDirectMsg(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
uid int64,
|
|
nick, command, to string,
|
|
body json.RawMessage,
|
|
) {
|
|
targetUID, err := s.params.Database.GetUserByNick(
|
|
r.Context(), to,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, r,
|
|
"user not found",
|
|
http.StatusNotFound)
|
|
|
|
return
|
|
}
|
|
|
|
recipients := []int64{targetUID}
|
|
if targetUID != uid {
|
|
recipients = append(recipients, uid)
|
|
}
|
|
|
|
msgUUID, err := s.fanOut(
|
|
r, command, nick, to, body, recipients,
|
|
)
|
|
if err != nil {
|
|
s.log.Error("send dm failed", "error", err)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, r,
|
|
map[string]string{"id": msgUUID, "status": "sent"},
|
|
http.StatusCreated)
|
|
}
|
|
|
|
func normalizeChannel(name string) string {
|
|
if !strings.HasPrefix(name, "#") {
|
|
return "#" + name
|
|
}
|
|
|
|
return name
|
|
}
|
|
|
|
func (s *Handlers) internalError(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
msg string,
|
|
err error,
|
|
) {
|
|
s.log.Error(msg, "error", err)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
}
|
|
|
|
func (s *Handlers) handleJoin(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
uid int64,
|
|
nick, to string,
|
|
) {
|
|
if to == "" {
|
|
s.respondError(w, r,
|
|
"to field required",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
channel := normalizeChannel(to)
|
|
|
|
if !validChannelRe.MatchString(channel) {
|
|
s.respondError(w, r,
|
|
"invalid channel name",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
chID, err := s.params.Database.GetOrCreateChannel(
|
|
r.Context(), channel,
|
|
)
|
|
if err != nil {
|
|
s.internalError(w, r,
|
|
"get/create channel failed", err)
|
|
|
|
return
|
|
}
|
|
|
|
err = s.params.Database.JoinChannel(
|
|
r.Context(), chID, uid,
|
|
)
|
|
if err != nil {
|
|
s.internalError(w, r,
|
|
"join channel failed", err)
|
|
|
|
return
|
|
}
|
|
|
|
memberIDs, _ := s.params.Database.GetChannelMemberIDs(
|
|
r.Context(), chID,
|
|
)
|
|
|
|
_ = s.fanOutSilent(
|
|
r, "JOIN", nick, channel, nil, memberIDs,
|
|
)
|
|
|
|
s.respondJSON(w, r,
|
|
map[string]string{
|
|
"status": "joined",
|
|
"channel": channel,
|
|
},
|
|
http.StatusOK)
|
|
}
|
|
|
|
func (s *Handlers) handlePart(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
uid int64,
|
|
nick, to string,
|
|
body json.RawMessage,
|
|
) {
|
|
if to == "" {
|
|
s.respondError(w, r,
|
|
"to field required",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
channel := normalizeChannel(to)
|
|
|
|
chID, err := s.params.Database.GetChannelByName(
|
|
r.Context(), channel,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, r,
|
|
"channel not found",
|
|
http.StatusNotFound)
|
|
|
|
return
|
|
}
|
|
|
|
s.partAndCleanup(w, r, chID, uid, nick, channel, body)
|
|
}
|
|
|
|
func (s *Handlers) partAndCleanup(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
chID, uid int64,
|
|
nick, channel string,
|
|
body json.RawMessage,
|
|
) {
|
|
memberIDs, _ := s.params.Database.GetChannelMemberIDs(
|
|
r.Context(), chID,
|
|
)
|
|
|
|
_ = s.fanOutSilent(
|
|
r, "PART", nick, channel, body, memberIDs,
|
|
)
|
|
|
|
err := s.params.Database.PartChannel(
|
|
r.Context(), chID, uid,
|
|
)
|
|
if err != nil {
|
|
s.internalError(w, r,
|
|
"part channel failed", err)
|
|
|
|
return
|
|
}
|
|
|
|
_ = s.params.Database.DeleteChannelIfEmpty(
|
|
r.Context(), chID,
|
|
)
|
|
|
|
s.respondJSON(w, r,
|
|
map[string]string{
|
|
"status": "parted",
|
|
"channel": channel,
|
|
},
|
|
http.StatusOK)
|
|
}
|
|
|
|
func (s *Handlers) handleNick(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
uid int64,
|
|
nick string,
|
|
bodyLines func() []string,
|
|
) {
|
|
lines := bodyLines()
|
|
if len(lines) == 0 {
|
|
s.respondError(w, r,
|
|
"body required (new nick)",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
newNick := strings.TrimSpace(lines[0])
|
|
|
|
if !validNickRe.MatchString(newNick) {
|
|
s.respondError(w, r,
|
|
"invalid nick",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
if newNick == nick {
|
|
s.respondJSON(w, r,
|
|
map[string]string{
|
|
"status": "ok", "nick": newNick,
|
|
},
|
|
http.StatusOK)
|
|
|
|
return
|
|
}
|
|
|
|
err := s.params.Database.ChangeNick(
|
|
r.Context(), uid, newNick,
|
|
)
|
|
if err != nil {
|
|
s.handleChangeNickError(w, r, err)
|
|
|
|
return
|
|
}
|
|
|
|
s.broadcastNick(r, uid, nick, newNick)
|
|
|
|
s.respondJSON(w, r,
|
|
map[string]string{
|
|
"status": "ok", "nick": newNick,
|
|
},
|
|
http.StatusOK)
|
|
}
|
|
|
|
func (s *Handlers) handleChangeNickError(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
err error,
|
|
) {
|
|
if strings.Contains(err.Error(), "UNIQUE") {
|
|
s.respondError(w, r,
|
|
"nick already in use",
|
|
http.StatusConflict)
|
|
|
|
return
|
|
}
|
|
|
|
s.internalError(w, r, "change nick failed", err)
|
|
}
|
|
|
|
func (s *Handlers) broadcastNick(
|
|
r *http.Request,
|
|
uid int64,
|
|
oldNick, newNick string,
|
|
) {
|
|
channels, _ := s.params.Database.
|
|
GetAllChannelMembershipsForUser(r.Context(), uid)
|
|
|
|
notified := map[int64]bool{uid: true}
|
|
|
|
nickBody, err := json.Marshal([]string{newNick})
|
|
if err != nil {
|
|
s.log.Error("marshal nick body", "error", err)
|
|
|
|
return
|
|
}
|
|
|
|
dbID, _, _ := s.params.Database.InsertMessage(
|
|
r.Context(), "NICK", oldNick, "",
|
|
json.RawMessage(nickBody), nil,
|
|
)
|
|
|
|
_ = s.params.Database.EnqueueMessage(
|
|
r.Context(), uid, dbID,
|
|
)
|
|
|
|
s.broker.Notify(uid)
|
|
|
|
for _, ch := range channels {
|
|
memberIDs, _ := s.params.Database.
|
|
GetChannelMemberIDs(r.Context(), ch.ID)
|
|
|
|
for _, mid := range memberIDs {
|
|
if !notified[mid] {
|
|
notified[mid] = true
|
|
|
|
_ = s.params.Database.EnqueueMessage(
|
|
r.Context(), mid, dbID,
|
|
)
|
|
|
|
s.broker.Notify(mid)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Handlers) handleTopic(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
nick, to string,
|
|
body json.RawMessage,
|
|
bodyLines func() []string,
|
|
) {
|
|
if to == "" {
|
|
s.respondError(w, r,
|
|
"to field required",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
lines := bodyLines()
|
|
if len(lines) == 0 {
|
|
s.respondError(w, r,
|
|
"body required (topic text)",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
topic := strings.Join(lines, " ")
|
|
channel := normalizeChannel(to)
|
|
|
|
err := s.params.Database.SetTopic(
|
|
r.Context(), channel, topic,
|
|
)
|
|
if err != nil {
|
|
s.internalError(w, r, "set topic failed", err)
|
|
|
|
return
|
|
}
|
|
|
|
s.broadcastTopic(w, r, nick, channel, topic, body)
|
|
}
|
|
|
|
func (s *Handlers) broadcastTopic(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
nick, channel, topic string,
|
|
body json.RawMessage,
|
|
) {
|
|
chID, err := s.params.Database.GetChannelByName(
|
|
r.Context(), channel,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, r,
|
|
"channel not found",
|
|
http.StatusNotFound)
|
|
|
|
return
|
|
}
|
|
|
|
memberIDs, _ := s.params.Database.GetChannelMemberIDs(
|
|
r.Context(), chID,
|
|
)
|
|
|
|
_ = s.fanOutSilent(
|
|
r, "TOPIC", nick, channel, body, memberIDs,
|
|
)
|
|
|
|
s.respondJSON(w, r,
|
|
map[string]string{
|
|
"status": "ok", "topic": topic,
|
|
},
|
|
http.StatusOK)
|
|
}
|
|
|
|
func (s *Handlers) handleQuit(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
uid int64,
|
|
nick string,
|
|
body json.RawMessage,
|
|
) {
|
|
channels, _ := s.params.Database.
|
|
GetAllChannelMembershipsForUser(r.Context(), uid)
|
|
|
|
notified := map[int64]bool{}
|
|
|
|
var dbID int64
|
|
|
|
if len(channels) > 0 {
|
|
dbID, _, _ = s.params.Database.InsertMessage(
|
|
r.Context(), "QUIT", nick, "", body, nil,
|
|
)
|
|
}
|
|
|
|
for _, ch := range channels {
|
|
memberIDs, _ := s.params.Database.
|
|
GetChannelMemberIDs(r.Context(), ch.ID)
|
|
|
|
for _, mid := range memberIDs {
|
|
if mid != uid && !notified[mid] {
|
|
notified[mid] = true
|
|
|
|
_ = s.params.Database.EnqueueMessage(
|
|
r.Context(), mid, dbID,
|
|
)
|
|
|
|
s.broker.Notify(mid)
|
|
}
|
|
}
|
|
|
|
_ = s.params.Database.PartChannel(
|
|
r.Context(), ch.ID, uid,
|
|
)
|
|
|
|
_ = s.params.Database.DeleteChannelIfEmpty(
|
|
r.Context(), ch.ID,
|
|
)
|
|
}
|
|
|
|
_ = s.params.Database.DeleteUser(r.Context(), uid)
|
|
|
|
s.respondJSON(w, r,
|
|
map[string]string{"status": "quit"},
|
|
http.StatusOK)
|
|
}
|
|
|
|
const (
|
|
defaultHistLimit = 50
|
|
maxHistLimit = 500
|
|
)
|
|
|
|
// HandleGetHistory returns message history for a target.
|
|
func (s *Handlers) HandleGetHistory() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
_, _, ok := s.requireAuth(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
target := r.URL.Query().Get("target")
|
|
if target == "" {
|
|
s.respondError(w, r,
|
|
"target required",
|
|
http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
beforeID, _ := strconv.ParseInt(
|
|
r.URL.Query().Get("before"), 10, 64,
|
|
)
|
|
|
|
limit, _ := strconv.Atoi(
|
|
r.URL.Query().Get("limit"),
|
|
)
|
|
if limit <= 0 || limit > maxHistLimit {
|
|
limit = defaultHistLimit
|
|
}
|
|
|
|
msgs, err := s.params.Database.GetHistory(
|
|
r.Context(), target, beforeID, limit,
|
|
)
|
|
if err != nil {
|
|
s.log.Error(
|
|
"get history failed", "error", err,
|
|
)
|
|
|
|
s.respondError(w, r,
|
|
"internal error",
|
|
http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, r, msgs, http.StatusOK)
|
|
}
|
|
}
|
|
|
|
// HandleServerInfo returns server metadata.
|
|
func (s *Handlers) HandleServerInfo() http.HandlerFunc {
|
|
type response struct {
|
|
Name string `json:"name"`
|
|
MOTD string `json:"motd"`
|
|
}
|
|
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
s.respondJSON(w, r, &response{
|
|
Name: s.params.Config.ServerName,
|
|
MOTD: s.params.Config.MOTD,
|
|
}, http.StatusOK)
|
|
}
|
|
}
|