server: implement messages and gRPC support for creating messages

2026-05-24 17:50:39 +00:00
parent b0bcb3460b
commit e5eb48057f
12 changed files with 732 additions and 0 deletions
@@ -35,6 +35,13 @@ func Start() {
 		r.Route("/{channelID}", func(r chi.Router) {
 			r.Get("/", GetChannel)
 			r.Delete("/", DeleteChannel)
+
+			r.Route("/messages", func(r chi.Router) {
+				r.Get("/", ListMessages)
+				r.Route("/{messageID}", func(r chi.Router) {
+					r.Get("/", GetMessage)
+				})
+			})
 		})
 	})

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"time"

 	"git.dubyatp.xyz/dubyatp/scannerbot/server/db"
 	"github.com/jackc/pgx/v5"
@@ -14,6 +15,7 @@ var ErrUserNotFound = errors.New("db: user not found")
 var ErrSessionNotFound = errors.New("db: session not found")
 var ErrChannelNotFound = errors.New("db: channel not found")
 var ErrFileNotFound = errors.New("db: file not found")
+var ErrMessageNotFound = errors.New("db: message not found")

 func dbGetUser(id string) (*User, error) {
 	query := `SELECT id, name, password FROM users WHERE id = $1`
@@ -233,3 +235,112 @@ func dbGetFile(id string) (*File, error) {
 	slog.Debug("db: file found", "fileid", file.ID, "filename", file.Name)
 	return &file, nil
 }
+
+func DBGetChannel(id string) (*Channel, error) { return dbGetChannel(id) }
+func DBAddFile(file *File) error               { return dbAddFile(file) }
+
+func DBAddMessage(msg *Message) error {
+	query := `INSERT INTO messages (id, channel, created, content, audio) VALUES ($1, $2, $3, $4, $5)`
+	_, err := db.Pool.Exec(context.Background(), query, msg.ID, msg.Channel.ID, msg.Created, msg.Content, msg.Audio.ID)
+	if err != nil {
+		slog.Error("db: failed to add message", "error", err, "messageid", msg.ID)
+		return fmt.Errorf("failed to add message")
+	}
+	slog.Debug("db: message added", "messageid", msg.ID)
+	return nil
+}
+
+func dbGetMessage(id string) (*Message, error) {
+	query := `SELECT id, channel, created, content, audio FROM messages WHERE id = $1`
+	var channelID, audioID string
+	var msg Message
+	err := db.Pool.QueryRow(context.Background(), query, id).Scan(&msg.ID, &channelID, &msg.Created, &msg.Content, &audioID)
+	if errors.Is(err, pgx.ErrNoRows) {
+		slog.Debug("db: message not found", "messageid", id)
+		return nil, ErrMessageNotFound
+	} else if err != nil {
+		slog.Error("db: failed to query message", "error", err)
+		return nil, fmt.Errorf("failed to query message")
+	}
+
+	channel, err := dbGetChannel(channelID)
+	if err != nil {
+		slog.Error("db: failed to fetch channel for message", "messageid", id, "channelid", channelID, "error", err)
+		return nil, fmt.Errorf("failed to fetch channel for message")
+	}
+	audio, err := dbGetFile(audioID)
+	if err != nil {
+		slog.Error("db: failed to fetch audio for message", "messageid", id, "audioid", audioID, "error", err)
+		return nil, fmt.Errorf("failed to fetch audio for message")
+	}
+
+	msg.Channel = *channel
+	msg.Audio = *audio
+	slog.Debug("db: message found", "messageid", msg.ID)
+	return &msg, nil
+}
+
+func dbGetMessagesByChannel(channelID string, from, to *time.Time) ([]*Message, error) {
+	query := `SELECT id, channel, created, content, audio FROM messages WHERE channel = $1`
+	args := []any{channelID}
+	if from != nil {
+		args = append(args, *from)
+		query += fmt.Sprintf(" AND created >= $%d", len(args))
+	}
+	if to != nil {
+		args = append(args, *to)
+		query += fmt.Sprintf(" AND created <= $%d", len(args))
+	}
+	query += " ORDER BY created DESC"
+	rows, err := db.Pool.Query(context.Background(), query, args...)
+	if err != nil {
+		slog.Error("db: failed to query messages", "error", err)
+		return nil, fmt.Errorf("failed to query messages")
+	}
+	defer rows.Close()
+
+	type messageRow struct {
+		msg       Message
+		channelID string
+		audioID   string
+	}
+
+	var rows_ []messageRow
+	for rows.Next() {
+		var mr messageRow
+		if err := rows.Scan(&mr.msg.ID, &mr.channelID, &mr.msg.Created, &mr.msg.Content, &mr.audioID); err != nil {
+			slog.Error("db: failed to scan message", "error", err)
+			return nil, fmt.Errorf("failed to scan message")
+		}
+		rows_ = append(rows_, mr)
+	}
+	if err := rows.Err(); err != nil {
+		slog.Error("db: row iteration error", "error", err)
+		return nil, fmt.Errorf("failed to iterate messages")
+	}
+	if len(rows_) == 0 {
+		slog.Debug("db: no messages found", "channelid", channelID)
+		return nil, ErrMessageNotFound
+	}
+
+	channel, err := dbGetChannel(channelID)
+	if err != nil {
+		slog.Error("db: failed to fetch channel for messages", "channelid", channelID, "error", err)
+		return nil, fmt.Errorf("failed to fetch channel for messages")
+	}
+
+	var messages []*Message
+	for _, mr := range rows_ {
+		audio, err := dbGetFile(mr.audioID)
+		if err != nil {
+			slog.Error("db: failed to fetch audio for message", "messageid", mr.msg.ID, "audioid", mr.audioID, "error", err)
+			return nil, fmt.Errorf("failed to fetch audio for message")
+		}
+		mr.msg.Channel = *channel
+		mr.msg.Audio = *audio
+		messages = append(messages, &mr.msg)
+	}
+
+	slog.Debug("db: message list returned", "channelid", channelID, "count", len(messages))
+	return messages, nil
+}
@@ -0,0 +1,99 @@
+package api
+
+import (
+	"errors"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/render"
+	"github.com/google/uuid"
+)
+
+type Message struct {
+	ID      uuid.UUID
+	Channel Channel
+	Created time.Time
+	Content string
+	Audio   File
+}
+
+type MessagePayload struct {
+	*Message
+}
+
+func GetMessage(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("message: entering GetMessage handler")
+
+	messageID := chi.URLParam(r, "messageID")
+	parsed, err := uuid.Parse(messageID)
+	if err != nil {
+		render.Render(w, r, ErrInvalidRequest(err))
+		return
+	}
+
+	msg, err := dbGetMessage(parsed.String())
+	if err != nil {
+		if errors.Is(err, ErrMessageNotFound) {
+			render.Render(w, r, ErrNotFound)
+		} else {
+			slog.Error("message: failed to fetch message", "messageid", parsed.String(), "error", err)
+			render.Render(w, r, ErrInternal(err))
+		}
+		return
+	}
+
+	slog.Debug("message: rendering message", "messageid", msg.ID)
+	if err := render.Render(w, r, NewMessagePayloadResponse(msg)); err != nil {
+		slog.Error("message: failed to render message", "messageid", parsed.String(), "error", err)
+		render.Render(w, r, ErrInternal(err))
+	}
+}
+
+func ListMessages(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("message: entering ListMessages handler")
+
+	channelID := chi.URLParam(r, "channelID")
+	parsed, err := uuid.Parse(channelID)
+	if err != nil {
+		render.Render(w, r, ErrInvalidRequest(err))
+		return
+	}
+
+	var from, to *time.Time
+	if v := r.URL.Query().Get("from"); v != "" {
+		t, err := time.Parse(time.RFC3339, v)
+		if err != nil {
+			render.Render(w, r, ErrInvalidRequest(fmt.Errorf("invalid 'from' timestamp: %w", err)))
+			return
+		}
+		from = &t
+	}
+	if v := r.URL.Query().Get("to"); v != "" {
+		t, err := time.Parse(time.RFC3339, v)
+		if err != nil {
+			render.Render(w, r, ErrInvalidRequest(fmt.Errorf("invalid 'to' timestamp: %w", err)))
+			return
+		}
+		to = &t
+	}
+
+	messages, err := dbGetMessagesByChannel(parsed.String(), from, to)
+	if err != nil {
+		if errors.Is(err, ErrMessageNotFound) {
+			render.Render(w, r, ErrNotFound)
+		} else {
+			slog.Error("message: failed to fetch messages", "channelid", parsed.String(), "error", err)
+			render.Render(w, r, ErrInternal(err))
+		}
+		return
+	}
+
+	slog.Debug("message: successfully fetched messages", "channelid", parsed.String(), "count", len(messages))
+	if err := render.RenderList(w, r, NewMessageListResponse(messages)); err != nil {
+		slog.Error("message: failed to render message list", "channelid", parsed.String(), "error", err)
+		render.Render(w, r, ErrInternal(err))
+	}
+}
@@ -49,3 +49,19 @@ func NewFilePayloadResponse(file *File) *FilePayload {
 func (f *FilePayload) Render(w http.ResponseWriter, r *http.Request) error {
 	return nil
 }
+
+func NewMessagePayloadResponse(msg *Message) *MessagePayload {
+	return &MessagePayload{Message: msg}
+}
+
+func NewMessageListResponse(messages []*Message) []render.Renderer {
+	list := []render.Renderer{}
+	for _, msg := range messages {
+		list = append(list, NewMessagePayloadResponse(msg))
+	}
+	return list
+}
+
+func (m *MessagePayload) Render(w http.ResponseWriter, r *http.Request) error {
+	return nil
+}