Added MessageStruct to describe outgoing messages

Replaced all maps in the handleMessage method with the MessageStruct,
except for the final result, as this one uses the key 'values', where
the rest use the key 'value'. Once this has been changed in the frontend
it will be updated in the backend as well.

internal/entity/messageStruct.go

+package entity
+
+// MessageStruct describes outgoing messages from the query service
+type MessageStruct struct {
+	Type  string      `json:"type"`
+	Value interface{} `json:"value"`
+}

internal/usecases/consume/handlemessage.go

@@ -2,6 +2,7 @@ package consume
 
 import (
 	"encoding/json"
+	"query-service/internal/entity"
 	"query-service/pkg/errorhandler"
 	"strings"
 
@@ -21,12 +22,26 @@ func (s *Service) HandleMessage(msg *broker.Message) {
 		return
 	}
 
+	// Marshall the incoming message into an IncomingJSONQuery object
+	var JSONQuery entity.IncomingQueryJSON
+	err := json.Unmarshal(msg.Body, &JSONQuery)
+	if err != nil {
+		errorMsg := entity.MessageStruct{
+			Type:  "query_translation_error",
+			Value: "failed to unmarshall the incoming JSON query",
+		}
+		errorMsgBytes, _ := json.Marshal(errorMsg)
+		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
+		return
+	}
+
 	// Convert the json byte msg to a query string
 	query, databaseName, err := s.queryConverter.ConvertQuery(&msg.Body)
 	if err != nil {
-		errorMsg := make(map[string]string)
-		errorMsg["type"] = "query_translation_error"
-		errorMsg["value"] = err.Error()
+		errorMsg := entity.MessageStruct{
+			Type:  "query_translation_error",
+			Value: err.Error(),
+		}
 		errorMsgBytes, _ := json.Marshal(errorMsg)
 		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
 		return
@@ -34,35 +49,39 @@ func (s *Service) HandleMessage(msg *broker.Message) {
 
 	// Check if there was a database name
 	if *databaseName == "" {
-		errorMsg := make(map[string]string)
-		errorMsg["type"] = "query_malformed_request_error"
-		errorMsg["value"] = "no database name supplied"
+		errorMsg := entity.MessageStruct{
+			Type:  "query_malformed_request_error",
+			Value: "no database name supplied",
+		}
 		errorMsgBytes, _ := json.Marshal(errorMsg)
 		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
 		return
 	}
 
+	// TODO: Figure out a way to do this in the integration tests instead
 	// Remove newlines and tabs from string
 	queryNoNewlines := strings.ReplaceAll(*query, "\n", "")
 	queryNoTabs := strings.ReplaceAll(queryNoNewlines, "\t", "")
 
 	// Send the resulting query back to the client
-	msgmap := make(map[string]interface{})
-	msgmap["type"] = "query_translation_result"
-	msgmap["values"] = queryNoTabs
-	msgbyte, err := json.Marshal(msgmap)
+	translationMsg := entity.MessageStruct{
+		Type:  "query_translation_result",
+		Value: queryNoTabs,
+	}
+	translationMsgBytes, err := json.Marshal(translationMsg)
 	if err != nil {
 		errorhandler.LogError(err, "Marshalling query_translation_result went wrong!") // TODO: send error message to client instead
 		return
 	}
-	s.producer.PublishMessage(&msgbyte, &sessionID) // TODO: should this be a go routine?
+	s.producer.PublishMessage(&translationMsgBytes, &sessionID) // TODO: should this be a go routine?
 
 	// Fetch database credentials from the user service
 	databaseInfo, err := s.databaseInfoService.GetDatabaseInfo(&clientID, databaseName)
 	if err != nil {
-		errorMsg := make(map[string]string)
-		errorMsg["type"] = "query_database_not_found"
-		errorMsg["value"] = err.Error()
+		errorMsg := entity.MessageStruct{
+			Type:  "query_database_not_found",
+			Value: err.Error(),
+		}
 		errorMsgBytes, _ := json.Marshal(errorMsg)
 		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
 		return
@@ -72,15 +91,17 @@ func (s *Service) HandleMessage(msg *broker.Message) {
 	// convert result to general (node-link) format
 	result, err := s.requestSender.SendAQLQuery(*query, databaseInfo.Username, databaseInfo.Password, databaseInfo.URL, databaseInfo.Port, databaseInfo.InternalDatabaseName)
 	if err != nil {
-		errorMsg := make(map[string]string)
-		errorMsg["type"] = "query_database_error"
-		errorMsg["value"] = err.Error()
+		errorMsg := entity.MessageStruct{
+			Type:  "query_database_error",
+			Value: err.Error(),
+		}
 		errorMsgBytes, _ := json.Marshal(errorMsg)
 		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
 		return
 	}
 
 	// Add type indicator to result from database
+	// TODO: Change key 'values' to key 'value'
 	var res interface{}
 	json.Unmarshal(*result, &res)
 	resultMsgMap := make(map[string]interface{})