[Backend] Show a confirmation message on the frontend when an order is sent

backend/cmd/main.go

@@ -181,11 +181,8 @@ func main() {
 	connectionTopic := connection_topic.NewUpdateTopic()
 	orderTopic := order_topic.NewSendTopic()
 	loggerTopic := logger_topic.NewEnableTopic()
-	boardIdToBoard := make(map[abstraction.BoardId]string)
-	for name, id := range adj.Info.BoardIds {
-		boardIdToBoard[abstraction.BoardId(id)] = name
-	}
-	messageTopic := message_topic.NewUpdateTopic(boardIdToBoard)
+
+	messageTopic := message_topic.NewUpdateTopic()
 	stateOrderTopic := order_topic.NewState(idToBoard, trace.Logger)
 
 	broker.AddTopic(data_topic.UpdateName, dataTopic)

backend/pkg/broker/topics/message/message_test.go

@@ -34,12 +34,12 @@ func TestMessageTopic_Push(t *testing.T) {
 	client := websocket.NewClient(c)
 	clientChan <- client
 
-	messageTopic := data.NewUpdateTopic(map[abstraction.BoardId]string{})
+	messageTopic := data.NewUpdateTopic()
 	messageTopic.SetAPI(api)
 	messageTopic.SetPool(pool)
 
 	// Simulate sending a download request
-	request := data.Push("test", 0)
+	request := data.Push("test", "test_board")
 	err = messageTopic.Push(request)
 	if err != nil {
 		t.Fatal("Error pushing download request:", err)
@@ -80,11 +80,11 @@ func TestMessageTopic_ClientMessage(t *testing.T) {
 	logger := zerolog.New(os.Stdout).With().Timestamp().Logger()
 	api := broker.New(logger)
 
-	messageTopic := data.NewUpdateTopic(map[abstraction.BoardId]string{})
+	messageTopic := data.NewUpdateTopic()
 	messageTopic.SetAPI(api)
 
 	packet := protection.NewPacket(0, protection.OkSeverity)
-	payload := data.Push(packet, 0)
+	payload := data.Push(packet, "test_board")
 	payloadBytes, _ := json.Marshal(payload)
 	messageTopic.ClientMessage(websocket.ClientId{0}, &websocket.Message{
 		Topic:   data.SubscribeName,

backend/pkg/broker/topics/message/update.go

@@ -7,28 +7,29 @@ import (
 
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/abstraction"
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/broker/topics"
+	"github.com/HyperloopUPV-H8/h9-backend/pkg/transport/packet/data"
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/transport/packet/protection"
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/websocket"
 	"github.com/google/uuid"
 	ws "github.com/gorilla/websocket"
 )
 
+var _ = data.Packet{}
+
 const UpdateName abstraction.BrokerTopic = "message/update"
 const SubscribeName abstraction.BrokerTopic = "message/update"
 
 type Update struct {
 	subscribersMx *sync.Mutex
 	subscribers   map[websocket.ClientId]struct{}
-	idToBoard     map[abstraction.BoardId]string
 	pool          *websocket.Pool
 	api           abstraction.BrokerAPI
 }
 
-func NewUpdateTopic(idToBoard map[abstraction.BoardId]string) *Update {
+func NewUpdateTopic() *Update {
 	return &Update{
 		subscribersMx: &sync.Mutex{},
 		subscribers:   make(map[websocket.ClientId]struct{}),
-		idToBoard:     idToBoard,
 	}
 }
 
@@ -42,7 +43,7 @@ func (update *Update) Push(p abstraction.BrokerPush) error {
 		return topics.ErrUnexpectedPush{Push: p}
 	}
 
-	raw, err := json.Marshal(push.Data(push.boardId, update.idToBoard))
+	raw, err := json.Marshal(push.Data(push.boardName))
 	if err != nil {
 		return err
 	}
@@ -100,19 +101,19 @@ func (update *Update) SetAPI(api abstraction.BrokerAPI) {
 }
 
 type pushStruct struct {
-	data    any
-	boardId abstraction.BoardId
+	data      any
+	boardName string
 }
 
-func Push(data any, boardId abstraction.BoardId) *pushStruct {
-	return &pushStruct{data: data, boardId: boardId}
+func Push(data any, boardName string) *pushStruct {
+	return &pushStruct{data: data, boardName: boardName}
 }
 
 func (push *pushStruct) Topic() abstraction.BrokerTopic {
 	return UpdateName
 }
 
-func (push *pushStruct) Data(boardID abstraction.BoardId, idToBoard map[abstraction.BoardId]string) wrapper {
+func (push *pushStruct) Data(boardName string) wrapper {
 	switch data := push.data.(type) {
 	case *protection.Packet:
 		return wrapper{
@@ -124,12 +125,21 @@ func (push *pushStruct) Data(boardID abstraction.BoardId, idToBoard map[abstract
 				Kind: string(data.Data.Name()),
 				Data: data.Data,
 			},
-			Board:     string(idToBoard[boardID]),
+			Board:     boardName,
 			Name:      string(data.Name),
 			Timestamp: data.Timestamp,
 		}
+	case *data.Packet:
+		return wrapper{
+			Kind:      "info",
+			Payload:   "Order Sent",
+			Board:     boardName,
+			Name:      string(data.Id()),
+			Timestamp: protection.NowTimestamp(),
+		}
 	}
 	return wrapper{}
+
 }
 
 type wrapper struct {

backend/pkg/vehicle/notification.go

@@ -84,7 +84,7 @@ func (vehicle *Vehicle) handlePacketNotification(notification transport.PacketNo
 
 	case *protection.Packet:
 		boardId := vehicle.ipToBoardId[strings.Split(notification.From, ":")[0]]
-		err := vehicle.broker.Push(message_topic.Push(p, boardId))
+		err := vehicle.broker.Push(message_topic.Push(p, vehicle.idToBoardName[uint16(p.Id())]))
 		if err != nil {
 			vehicle.trace.Error().Stack().Err(err).Msg("broker push")
 			return errors.Join(fmt.Errorf("update protection to frontend (%s protection with id %d and kind %d from %s to %s)", p.Severity(), p.Id(), p.Kind, notification.From, notification.To), err)

backend/pkg/vehicle/vehicle.go

@@ -60,13 +60,18 @@ func (vehicle *Vehicle) UserPush(push abstraction.BrokerPush) error {
 			return err
 		}
 
+		err = vehicle.broker.Push(message_topic.Push(packet, vehicle.idToBoardName[uint16(packet.Id())]))
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "error sending info packet to the frontend: %v\n", err)
+			return err
+		}
+
 		err = vehicle.logger.PushRecord(&order_logger.Record{
 			Packet:    packet,
 			From:      "backend",
 			To:        vehicle.idToBoardName[uint16(packet.Id())],
 			Timestamp: packet.Timestamp(),
 		})
-
 		if err != nil && !errors.Is(err, logger.ErrLoggerNotRunning{}) {
 			fmt.Fprintln(os.Stderr, "Error pushing record to logger: ", err)
 		}
@@ -178,5 +183,5 @@ func (vehicle *Vehicle) notifyError(name string, err error) {
 	packet.Data = &protection.ErrorHandler{
 		Error: err.Error(),
 	}
-	vehicle.broker.Push(message_topic.Push(packet, 255))
+	vehicle.broker.Push(message_topic.Push(packet, "Error"))
 }