chore: Removal of note observer

server/src/realtime/board_sessions_requests.go

@@ -17,11 +17,11 @@ const (
 
 func (b *Broker) BroadcastUpdateOnBoardSessionRequest(board, user uuid.UUID, msg BoardSessionRequestEventType) error {
 	logger.Get().Debugw("broadcasting to board session request", "board", board, "user", user, "msg", msg)
-	return b.con.Publish(requestSubject(board, user), msg)
+	return b.Con.Publish(requestSubject(board, user), msg)
 }
 
 func (b *Broker) GetBoardSessionRequestChannel(board, user uuid.UUID) chan *BoardSessionRequestEventType {
-	c, err := b.con.SubscribeToBoardSessionEvents(requestSubject(board, user))
+	c, err := b.Con.SubscribeToBoardSessionEvents(requestSubject(board, user))
 	if err != nil {
 		// TODO: Bubble up this error, so the caller can retry to establish this subscription
 		logger.Get().Errorw("failed to subscribe to BoardSessionRequestChannel", "err", err)

server/src/realtime/boards.go

@@ -41,11 +41,11 @@ type BoardEvent struct {
 
 func (b *Broker) BroadcastToBoard(boardID uuid.UUID, msg BoardEvent) error {
 	logger.Get().Debugw("broadcasting to board", "board", boardID, "msg", msg.Type)
-	return b.con.Publish(boardsSubject(boardID), msg)
+	return b.Con.Publish(boardsSubject(boardID), msg)
 }
 
 func (b *Broker) GetBoardChannel(boardID uuid.UUID) chan *BoardEvent {
-	c, err := b.con.SubscribeToBoardEvents(boardsSubject(boardID))
+	c, err := b.Con.SubscribeToBoardEvents(boardsSubject(boardID))
 	if err != nil {
 		// TODO: Bubble up this error, so the caller can retry to establish this subscription
 		logger.Get().Errorw("failed to subscribe to BoardChannel", "err", err)

server/src/realtime/broker.go

@@ -17,5 +17,5 @@ type Client interface {
 
 // The Broker enables a user to broadcast and receive events
 type Broker struct {
-	con Client
+	Con Client
 }

server/src/realtime/health.go

@@ -2,9 +2,9 @@ package realtime
 
 // IsHealthy returns true if the Broker is in a healthy state
 func (b *Broker) IsHealthy() bool {
-	if b == nil || b.con == nil {
+	if b == nil || b.Con == nil {
 		return false
 	}
-	err := b.con.Publish("health", "test")
+	err := b.Con.Publish("health", "test")
 	return err == nil
 }

server/src/realtime/nats.go

@@ -49,6 +49,6 @@ func NewNats(url string) (*Broker, error) {
 	}
 
 	return &Broker{
-		con: &natsClient{con: c},
+		Con: &natsClient{con: c},
 	}, nil
 }

server/src/realtime/redis.go

@@ -10,7 +10,7 @@ import (
 )
 
 func NewRedis(server RedisServer) (*Broker, error) {
-	return &Broker{con: connectRedis(server)}, nil
+	return &Broker{Con: connectRedis(server)}, nil
 }
 
 type redisClient struct {

server/src/services/notes/notes.go

@@ -3,14 +3,15 @@ package notes
 import (
 	"context"
 	"database/sql"
-	"scrumlr.io/server/identifiers"
 
 	"scrumlr.io/server/common"
+	"scrumlr.io/server/identifiers"
 	"scrumlr.io/server/services"
 
 	"github.com/google/uuid"
 
 	"scrumlr.io/server/common/dto"
+	"scrumlr.io/server/common/filter"
 	"scrumlr.io/server/realtime"
 
 	"scrumlr.io/server/database"
@@ -27,19 +28,18 @@ type Observer interface {
 }
 
 type DB interface {
-	Observer
 	CreateNote(insert database.NoteInsert) (database.Note, error)
 	GetNote(id uuid.UUID) (database.Note, error)
 	GetNotes(board uuid.UUID, columns ...uuid.UUID) ([]database.Note, error)
 	UpdateNote(caller uuid.UUID, update database.NoteUpdate) (database.Note, error)
 	DeleteNote(caller uuid.UUID, board uuid.UUID, id uuid.UUID, deleteStack bool) error
+	GetVotes(f filter.VoteFilter) ([]database.Vote, error)
 }
 
 func NewNoteService(db DB, rt *realtime.Broker) services.Notes {
 	b := new(NoteService)
 	b.database = db
 	b.realtime = rt
-	b.database.AttachObserver((database.NotesObserver)(b))
 	return b
 }
 
@@ -50,6 +50,7 @@ func (s *NoteService) Create(ctx context.Context, body dto.NoteCreateRequest) (*
 		log.Errorw("unable to create note", "board", body.Board, "user", body.User, "error", err)
 		return nil, common.InternalServerError
 	}
+	s.UpdatedNotes(body.Board)
 	return new(dto.Note).From(note), err
 }
 
@@ -98,18 +99,46 @@ func (s *NoteService) Update(ctx context.Context, body dto.NoteUpdateRequest) (*
 		log.Errorw("unable to update note", "error", err, "note", body.ID)
 		return nil, common.InternalServerError
 	}
+	s.UpdatedNotes(body.Board)
 	return new(dto.Note).From(note), err
 }
 
 func (s *NoteService) Delete(ctx context.Context, body dto.NoteDeleteRequest, id uuid.UUID) error {
-	return s.database.DeleteNote(ctx.Value(identifiers.UserIdentifier).(uuid.UUID), ctx.Value(identifiers.BoardIdentifier).(uuid.UUID), id, body.DeleteStack)
+	user := ctx.Value(identifiers.UserIdentifier).(uuid.UUID)
+	board := ctx.Value(identifiers.BoardIdentifier).(uuid.UUID)
+	note := ctx.Value(identifiers.NoteIdentifier).(uuid.UUID)
+	voteFilter := filter.VoteFilter{
+		User:  &user,
+		Board: board,
+		Note:  &note,
+	}
+
+	votes, vErr := s.database.GetVotes(voteFilter)
+	if vErr != nil {
+		logger.Get().Errorw("unable to retrieve votes for a note delete", "err", vErr)
+	}
+
+	err := s.database.DeleteNote(user, board, id, body.DeleteStack)
+	if err != nil {
+		return err
+	}
+
+	s.DeletedNote(user, board, note, votes, body.DeleteStack)
+
+	return err
 }
 
-func (s *NoteService) UpdatedNotes(board uuid.UUID, notes []database.Note) {
+func (s *NoteService) UpdatedNotes(board uuid.UUID) {
+	notes, dbErr := s.database.GetNotes(board)
+	if dbErr != nil {
+		logger.Get().Errorw("unable to retrieve notes in UpdatedNotes call", "err", dbErr)
+	}
+
 	eventNotes := make([]dto.Note, len(notes))
 	for index, note := range notes {
 		eventNotes[index] = *new(dto.Note).From(note)
 	}
+
 	err := s.realtime.BroadcastToBoard(board, realtime.BoardEvent{
 		Type: realtime.BoardEventNotesUpdated,
 		Data: eventNotes,