refactor: Improve CNL message parsing in BodyParser

The code changes in `aviation_parser.go` and `aviation_parser_test.go` enhance the CNL message parsing logic in the `BodyParser` module. This ensures accurate extraction of data from CNL messages, including the category, aircraft ID, departure airport, and destination airport. The improvements improve the overall functionality and accuracy of the code.

internal/domain/aviation.go

@@ -103,11 +103,15 @@ type ParsedMessage struct {
 	ParsedAt           time.Time   `json:"parsedAt,omitempty"`           // 解析时间: The time when the message was parsed.
 	DispatchedAt       time.Time   `json:"dispatchedAt,omitempty"`       // 分发时间: The time when the message was dispatched.
 	NeedDispatch       bool        `json:"needDispatch"`                 // 需要分发: Indicates if the message needs to be dispatched.
+	Parsed             bool        `json:"parsed"`                       // 解析: Indicates if the message has been parsed.
+	Comments           string      `json:"comments,omitempty"`           // 备注: Additional comments.
+
 }
 
 // NewParsedMessage initializes a ParsedMessage with default values
 func NewParsedMessage() *ParsedMessage {
 	return &ParsedMessage{
 		SecondaryAddresses: []string{},
+		Parsed:             false,
 	}
 }

internal/nats/sub.go

@@ -69,31 +69,29 @@ func (n *NatsHandler) handleMessage(msg *message.Message) error {
 	defer n.mu.Unlock()
 	log := utils.GetSugaredLogger()
 	if msg.Payload == nil {
-		// fmt.Println("empty message")
 		log.Error("empty message")
 		return fmt.Errorf("empty message")
 	}
 	payload := string(msg.Payload)
-	var err error
 	var parsed *domain.ParsedMessage
-	if parsed, err = parsers.Parse(payload); err != nil {
+	if parsed = parsers.Parse(payload); !parsed.Parsed {
-
+		log.Infof("not parsed: [%s] : {%s} \n", msg.UUID, msg.Payload)
-		// fmt.Printf("not parsed: [%s] : {%s} - %v\n", msg.UUID, msg.Payload, err)
-		log.Infof("not parsed: [%s] : {%s} - %v\n", msg.UUID, msg.Payload, err)
-		// return err
 	} else {
-
-		// fmt.Printf("parsed [%s]: %v\n", msg.UUID, parsed)
 		log.Infof("parsed [%s]: %v\n", msg.UUID, parsed)
 
 	}
+	n.SaveMessage(parsed, msg.UUID)
+	return nil
+}
+
+func (n *NatsHandler) SaveMessage(parsed *domain.ParsedMessage, uuid string) {
+	logger := watermill.NewStdLogger(false, false)
 	if parsed != nil {
-		parsed.Uuid = msg.UUID
+		parsed.Uuid = uuid
-		if err = n.hasuraRepo.CreateNew(parsed); err != nil {
+		if err := n.hasuraRepo.CreateNew(parsed); err != nil {
-			fmt.Print("error inserting message", err)
+			logger.Error("error inserting message", err, map[string]interface{}{"message": parsed})
 		}
 	}
-	return err
 }
 
 type PlainTextMarshaler struct{}

internal/parsers/aviation_parser.go

@@ -203,10 +203,12 @@ func (bp *BodyParser) createBodyData(data map[string]string) (string, interface{
 	}
 }
 
-func Parse(rawText string) (*domain.ParsedMessage, error) {
+func Parse(rawText string) *domain.ParsedMessage {
 	message, err := ParseHeader(rawText)
 	if err != nil {
-		return nil, err
+		msg := domain.NewParsedMessage()
+		msg.Text = rawText
+		return msg
 	}
 
 	bodyParser := NewBodyParser(message.Body)
@@ -215,11 +217,12 @@ func Parse(rawText string) (*domain.ParsedMessage, error) {
 	message.ParsedAt = time.Now()
 
 	if err != nil {
-		return &message, err
+		message.Comments = err.Error()
+		return &message
 	}
-
+	message.Parsed = true
 	message.BodyData = bodyData
-	return &message, nil
+	return &message
 }
 
 func cleanMessage(text string) string {

internal/parsers/aviation_parser_test.go

@@ -263,9 +263,9 @@ FF ZBTJZPZX
 NNNN
 `
 			It("should parse the whole message correctly", func() {
-				parsedMessage, err := Parse(message)
+				parsedMessage := Parse(message)
-				Expect(err).ToNot(HaveOccurred())
 				Expect(parsedMessage).ToNot(BeNil())
+				Expect(parsedMessage.Parsed).To(BeTrue())
 				Expect(parsedMessage.MessageID).To(Equal("TMQ2526"))
 				Expect(parsedMessage.DateTime).To(Equal("141605"))
 				Expect(parsedMessage.PrimaryAddress).To(Equal("ZBTJZPZX"))
@@ -314,9 +314,9 @@ GG ZBTJZPZX
 NNNN
 `
 			It("should parse the whole message correctly", func() {
-				parsedMessage, err := Parse(message)
+				parsedMessage := Parse(message)
-				Expect(err).ToNot(HaveOccurred())
 				Expect(parsedMessage).ToNot(BeNil())
+				Expect(parsedMessage.Parsed).To(BeTrue())
 				Expect(parsedMessage.MessageID).To(Equal("TMQ2617"))
 				Expect(parsedMessage.DateTime).To(Equal("142150"))
 				Expect(parsedMessage.PrimaryAddress).To(Equal("ZBTJZPZX"))