implement channel API (no use yet)

2025-05-26 14:09:01 -04:00
parent 5782177c35
commit 9426ab2bae
4 changed files with 348 additions and 0 deletions
--- a/api/api.go
+++ b/api/api.go
@@ -70,6 +70,22 @@ func Start() {
 		r.Get("/", Whoami)
 	})

+	r.Route("/channels", func(r chi.Router) {
+		r.Use(SessionAuthMiddleware)
+
+		r.Get("/", ListChannels)
+		r.Route("/{channelID}", func(r chi.Router) {
+			r.Use(ChannelCtx) // Load channel
+			r.Get("/", GetChannel)
+			r.Delete("/", DeleteChannel)
+			r.Post("/edit", EditChannel)
+		})
+		r.Route("/new", func(r chi.Router) {
+			r.Use(LoginCtx)
+			r.Post("/", NewChannel)
+		})
+	})
+
 	r.Route("/messages", func(r chi.Router) {
 		r.Use(SessionAuthMiddleware) // Protect with authentication

--- a/api/channel.go
+++ b/api/channel.go
@@ -0,0 +1,215 @@
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/render"
+	"github.com/google/uuid"
+)
+
+func ChannelCtx(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		slog.Debug("channel: entering ChannelCtx middleware")
+		var channel *Channel
+		var err error
+
+		if channelID := chi.URLParam(r, "channelID"); channelID != "" {
+			slog.Debug("channel: fetching channel", "channelID", channelID)
+			channel, err = dbGetChannel(channelID)
+		} else {
+			slog.Error("channel: channelID not found in URL parameters")
+			render.Render(w, r, ErrNotFound)
+			return
+		}
+		if err != nil {
+			slog.Error("channel: failed to fetch channel", "channelID", chi.URLParam(r, "channelID"), "error", err)
+			render.Render(w, r, ErrNotFound)
+			return
+		}
+
+		slog.Debug("channel: successfully fetched channel", "channelID", channel.ID)
+		ctx := context.WithValue(r.Context(), channelKey{}, channel)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func GetChannel(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("channel: entering GetChannel handler")
+	channel, ok := r.Context().Value(channelKey{}).(*Channel)
+	if !ok || channel == nil {
+		slog.Error("channel: channel not found in context")
+		render.Render(w, r, ErrNotFound)
+		return
+	}
+
+	slog.Debug("channel: rendering channel", "channelID", channel.ID)
+	if err := render.Render(w, r, NewChannelResponse(channel)); err != nil {
+		slog.Error("channel: failed to render channel response", "channelID", channel.ID, "error", err)
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+}
+
+func ListChannels(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("channel: entering ListChannels handler")
+	dbChannels, err := dbGetAllChannels()
+	if err != nil {
+		slog.Error("channel: failed to fetch channels", "error", err)
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+
+	slog.Debug("channel: successfully fetched channels", "count", len(dbChannels))
+	if err := render.RenderList(w, r, NewChannelListResponse(dbChannels)); err != nil {
+		slog.Error("channel: failed to render channel list response", "error", err)
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+}
+
+func EditChannel(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("channel: entering EditChannel handler")
+	channel, ok := r.Context().Value(channelKey{}).(*Channel)
+	if !ok || channel == nil {
+		slog.Error("channel: channel not found in context")
+		render.Render(w, r, ErrNotFound)
+		return
+	}
+	err := r.ParseMultipartForm(64 << 10)
+	if err != nil {
+		slog.Error("channel: failed to parse multipart form", "error", err)
+		http.Error(w, "Unable to parse form", http.StatusBadRequest)
+		return
+	}
+
+	channelName := r.FormValue("name")
+	channeltype := r.FormValue("type")
+	if channelName == "" || channeltype == "" {
+		slog.Error("channel: channel name or type is empty")
+		http.Error(w, "Channel name or type cannot be empty", http.StatusBadRequest)
+		return
+	}
+
+	slog.Debug("channel: updating channel", "channelID", channel.ID)
+
+	channel.Name = channelName
+	channel.Type = channeltype
+
+	err = dbUpdateChannel(channel)
+	if err != nil {
+		slog.Error("channel: failed to update channel", "channelID", channel.ID, "error", err)
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+
+	slog.Debug("channel: successfully updated channel", "channelID", channel.ID)
+	if err := render.Render(w, r, NewChannelResponse(channel)); err != nil {
+		slog.Error("channel: failed to render updated channel response", "channelID", channel.ID, "error", err)
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+}
+
+func DeleteChannel(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("channel: entering DeleteChannel handler")
+	channel, ok := r.Context().Value(channelKey{}).(*Channel)
+	if !ok || channel == nil {
+		slog.Error("channel: channel not found in context")
+		render.Render(w, r, ErrNotFound)
+		return
+	}
+
+	slog.Debug("channel: deleting channel", "channelID", channel.ID)
+	err := dbDeleteChannel(channel.ID.String())
+	if err != nil {
+		slog.Error("channel: failed to delete channel", "channelID", channel.ID, "error", err)
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+
+	slog.Debug("channel: successfully deleted channel", "channelID", channel.ID)
+	if err := render.Render(w, r, NewChannelResponse(channel)); err != nil {
+		slog.Error("channel: failed to render deleted channel response", "channelID", channel.ID, "error", err)
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+}
+
+func newChannelID() uuid.UUID {
+	return uuid.New()
+}
+
+func NewChannel(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("channel: entering NewChannel handler")
+	err := r.ParseMultipartForm(64 << 10)
+	if err != nil {
+		slog.Error("channel: failed to parse multipart form", "error", err)
+		http.Error(w, "Unable to parse form", http.StatusBadRequest)
+		return
+	}
+
+	channelName := r.FormValue("name")
+	channeltype := r.FormValue("type")
+	if channelName == "" || channeltype == "" {
+		slog.Error("channel: channel name or type is empty")
+		http.Error(w, "Channel name or type cannot be empty", http.StatusBadRequest)
+		return
+	}
+
+	channel := Channel{
+		ID:      newChannelID(),
+		Name:    channelName,
+		Type:    channeltype,
+		Created: time.Now(),
+	}
+
+	slog.Debug("channel: creating new channel", "channelID", channel.ID)
+	err = dbAddChannel(&channel)
+	if err != nil {
+		slog.Error("channel: failed to add new channel", "channelID", channel.ID, "error", err)
+		render.Render(w, r, ErrRender(err))
+		return
+	}
+
+	slog.Debug("channel: successfulyl created new channel", "channelID", channel.ID)
+	render.Render(w, r, NewChannelResponse(&channel))
+}
+
+type channelKey struct{}
+
+type Channel struct {
+	ID      uuid.UUID `json:"id"`
+	Name    string    `json:"name"`
+	Type    string    `json:"type"`
+	Created time.Time `json:"created"`
+}
+
+type ChannelRequest struct {
+	*Channel
+}
+
+type ChannelResponse struct {
+	*Channel
+}
+
+func (c ChannelResponse) MarshalJson() ([]byte, error) {
+	type OrderedChannelResponse struct {
+		ID      uuid.UUID `json:"id"`
+		Name    string    `json:"name"`
+		Type    string    `json:"type"`
+		Created string    `json:"created"`
+	}
+
+	ordered := OrderedChannelResponse{
+		ID:      c.Channel.ID,
+		Name:    c.Channel.Name,
+		Type:    c.Channel.Type,
+		Created: c.Channel.Created.Format(time.RFC3339),
+	}
+	return json.Marshal(ordered)
+}
--- a/api/db.go
+++ b/api/db.go
@@ -239,3 +239,102 @@ func dbDeleteMessage(id string) error {
 	slog.Debug("db: message deleted", "messageid", id)
 	return nil
 }
+
+func dbAddChannel(channel *Channel) error {
+	query := `INSERT INTO channels (id, name, type, created) VALUES (?, ?, ?, ?)`
+	err := db.Session.Query(query,
+		channel.ID,
+		channel.Name,
+		channel.Type,
+		channel.Created).Exec()
+	if err != nil {
+		slog.Error("db: failed to add channel", "error", err, "channelid", channel.ID)
+		return fmt.Errorf("failed to add channel")
+	}
+
+	slog.Debug("db: channel added", "channelid", channel.ID)
+	return nil
+}
+
+func dbGetChannel(id string) (*Channel, error) {
+	query := `SELECT id, name, type, created FROM channels WHERE id = ?`
+	var channel Channel
+	err := db.Session.Query(query, id).Scan(
+		&channel.ID,
+		&channel.Name,
+		&channel.Type,
+		&channel.Created)
+	if err == gocql.ErrNotFound {
+		slog.Debug("db: channel not found", "channelid", id)
+		return nil, errors.New("Channel not found")
+	} else if err != nil {
+		slog.Error("db: failed to query channel", "error", err)
+		return nil, fmt.Errorf("failed to query channel")
+	}
+
+	slog.Debug("db: channel found", "channelid", channel.ID)
+	return &channel, nil
+}
+
+func dbGetAllChannels() ([]*Channel, error) {
+	query := `SELECT id, name, type, created FROM channels`
+	iter := db.Session.Query(query).Iter()
+	defer iter.Close()
+
+	var channels []*Channel
+	for {
+		channel := &Channel{}
+		if !iter.Scan(
+			&channel.ID,
+			&channel.Name,
+			&channel.Type,
+			&channel.Created) {
+			break
+		}
+		channels = append(channels, channel)
+	}
+
+	if err := iter.Close(); err != nil {
+		slog.Error("db: failed to iterate channels", "error", err)
+		return nil, fmt.Errorf("failed to iterate channels")
+	}
+
+	if len(channels) == 0 {
+		slog.Debug("db: no channels found")
+		return nil, errors.New("no channels found")
+	}
+
+	slog.Debug("db: channel list returned")
+	return channels, nil
+}
+
+func dbUpdateChannel(updatedChannel *Channel) error {
+	query := `UPDATE channels SET name = ?, type = ?, created = ? WHERE id = ?`
+
+	err := db.Session.Query(query,
+		updatedChannel.Name,
+		updatedChannel.Type,
+		updatedChannel.Created,
+		updatedChannel.ID).Exec()
+
+	if err != nil {
+		slog.Error("db: failed to update channel", "error", err, "channelid", updatedChannel.ID)
+		return fmt.Errorf("failed to update channel")
+	}
+
+	slog.Debug("db: channel updated", "channelid", updatedChannel.ID)
+	return nil
+}
+
+func dbDeleteChannel(id string) error {
+	query := `DELETE FROM channels WHERE id = ?`
+
+	err := db.Session.Query(query, id).Exec()
+	if err != nil {
+		slog.Error("db: failed to delete channel", "error", err)
+		return fmt.Errorf("failed to delete channel")
+	}
+
+	slog.Debug("db: channel deleted")
+	return nil
+}
--- a/api/response.go
+++ b/api/response.go
@@ -41,3 +41,21 @@ func NewUserListResponse(users []*User) []render.Renderer {
 func NewUserPayloadResponse(user *User) *UserPayload {
 	return &UserPayload{User: user}
 }
+
+func NewChannelResponse(channel *Channel) *ChannelResponse {
+	resp := &ChannelResponse{Channel: channel}
+
+	return resp
+}
+
+func (cr *ChannelResponse) Render(w http.ResponseWriter, r *http.Request) error {
+	return nil
+}
+
+func NewChannelListResponse(channels []*Channel) []render.Renderer {
+	list := []render.Renderer{}
+	for _, channel := range channels {
+		list = append(list, NewChannelResponse(channel))
+	}
+	return list
+}