windy/go-caatsm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: Add AFTN message parsing functionality

Browse Source 
This commit adds functionality to parse AFTN messages in the `aftn_parser.go` file. The `Parse` method now correctly parses the message based on its type and extracts the relevant data. Additionally, the `FindPatterns` and `ParseBody` functions have been updated to remove the dependency on the `config` package and instead use the `config.GetBodyPatterns` function to retrieve the body patterns. This change improves the modularity and maintainability of the code.

Note: This commit message assumes that the `config` package has been refactored to use the `GetBodyPatterns` function.
This commit is contained in:
windyboy
2024-07-20 00:01:04 +08:00
parent dbbf6133be
commit 969bb57902
7 changed files with 150 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/parsers/aftn_parser.go
+1 -3
View File
@@ -22,9 +22,7 @@ type AFTNParser struct {
// Parse parses a generic AFTN message based on its type.
func (p AFTNParser) Parse(text string) (interface{}, error) {
config := config.GetMyConfig()
data := ParseBody(text, config)
data := ParseBody(text)
switch data["type"] {
case "ARR":
internal/parsers/aftn_parser_test.go
+6 -36
View File
@@ -1,43 +1,13 @@
package parsers
import (
"caatsm/internal/config"
"caatsm/internal/domain"
"regexp"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
var _ = Describe("AFTN Parser", func() {
var testConfig *config.Config
BeforeEach(func() {
testConfig = &config.Config{
Body: []config.BodyConfig{
{
Name: "ARR",
Patterns: []config.PatternConfig{
{
Pattern: `^\((?P<type>[A-Z]{3})\-(?P<number>[A-Z0-9]+)\-(?P<ssr>[A-Z0-9]+)\-(?P<departure>[A-Z]{4})\-(?P<arrival>[A-Z]{4})\)$`,
Expression: regexp.MustCompile(`^\((?P<type>[A-Z]{3})\-(?P<number>[A-Z0-9]+)\-(?P<ssr>[A-Z0-9]+)\-(?P<departure>[A-Z]{4})\-(?P<arrival>[A-Z]{4})\)$`),
},
},
},
{
Name: "DEP",
Patterns: []config.PatternConfig{
{
Pattern: `^\((?P<type>[A-Z]{3})\-(?P<number>[A-Z0-9]+)\-(?P<ssr>[A-Z0-9]+)\-(?P<departure>[A-Z]{4})\-(?P<departure_time>\d{4})\-(?P<arrival>[A-Z]{4})\)$`,
Expression: regexp.MustCompile(`^\((?P<type>[A-Z]{3})\-(?P<number>[A-Z0-9]+)\-(?P<ssr>[A-Z0-9]+)\-(?P<departure>[A-Z]{4})\-(?P<departure_time>\d{4})\-(?P<arrival>[A-Z]{4})\)$`),
},
},
},
},
}
config.SetMyConfig(testConfig)
})
Describe("Parse", func() {
It("should parse ARR messages correctly", func() {
message := "(ARR-AB123-SSR1234-KJFK-KLAX)"
@@ -80,7 +50,7 @@ var _ = Describe("AFTN Parser", func() {
It("should parse a valid AFTN message", func() {
rawMessage := `ZCZC TMQ2611 151524
FF SENDERAA
151524 RECEIVER
151524 RECEIVERAA
(ARR-AB123-SSR1234-KJFK-KLAX)`
aftnMessage, err := ParseAFTN(rawMessage)
@@ -117,7 +87,7 @@ TMQ2611
},
TimeAndReceiver: domain.TimeAndReceiver{
Time: "151524",
Receiver: "RECEIVER",
Receiver: "RECEIVAA",
},
Category: "ARR",
}
@@ -134,11 +104,11 @@ TMQ2611
},
PriorityAndSender: domain.PriorityAndSender{
Priority: "FF",
Sender: "",
Sender: "SENDERAA",
},
TimeAndReceiver: domain.TimeAndReceiver{
Time: "151524",
Receiver: "RECEIVER",
Receiver: "RECEIVAA",
},
Category: "ARR",
}
@@ -160,7 +130,7 @@ TMQ2611
},
TimeAndReceiver: domain.TimeAndReceiver{
Time: "151524",
Receiver: "RECEIVER",
Receiver: "RECEIVAA",
},
Category: "ARR",
}
@@ -182,7 +152,7 @@ TMQ2611
},
TimeAndReceiver: domain.TimeAndReceiver{
Time: "151524",
Receiver: "RECEIVERAA",
Receiver: "INVALID",
},
Category: "ARR",
}
internal/parsers/pattern.go
+9 -10
View File
@@ -5,24 +5,23 @@ import (
"regexp"
)
var bodyTypePattern = regexp.MustCompile(`^\(([A-Z]{3})(.*\n?)+\)$`)
var (
bodyTypePattern = regexp.MustCompile(`^\(([A-Z]{3})(.*\n?)+\)$`)
)
// FindPatterns detects the message body type based on the configuration.
func FindPatterns(messageBody string, config *config.Config) *config.BodyConfig {
func FindPatterns(messageBody string) *config.BodyConfig {
if match := bodyTypePattern.FindStringSubmatch(messageBody); len(match) > 1 {
name := match[1]
for _, body := range config.Body {
if body.Name == name {
return &body
}
patters := config.GetBodyPatterns()
if body, found := patters[name]; found {
return &body
}
}
return nil
}
// ParseBody parses the message body and extracts the data based on the patterns defined in the configuration.
func ParseBody(messageBody string, config *config.Config) map[string]string {
if body := FindPatterns(messageBody, config); body != nil {
func ParseBody(messageBody string) map[string]string {
if body := FindPatterns(messageBody); body != nil {
for _, pattern := range body.Patterns {
if matches := pattern.Expression.FindStringSubmatch(messageBody); matches != nil {
result := make(map[string]string)
internal/parsers/pattern_test.go
+14 -34
View File
@@ -1,65 +1,45 @@
package parsers
import (
"caatsm/internal/config"
"regexp"
"testing"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
func TestParsers(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Parsers Suite")
}
var _ = Describe("Pattern Parser", func() {
var testConfig *config.Config
BeforeEach(func() {
testConfig = &config.Config{
Body: []config.BodyConfig{
{
Name: "FPL",
Patterns: []config.PatternConfig{
{
Pattern: `^\((?P<type>[A-Z]{3})-(?P<number>[A-Z0-9]+)\)$`,
Expression: regexp.MustCompile(`^\((?P<type>[A-Z]{3})-(?P<number>[A-Z0-9]+)\)$`),
},
},
},
},
}
})
// BeforeEach(func() {
// config.SetMyConfig(config.GetMyConfig())
// })
Describe("FindPatterns", func() {
It("should return the correct BodyConfig based on the message body", func() {
message := "(FPL-AB123)"
bodyConfig := FindPatterns(message, testConfig)
message := "(ARR-AB123-SSR1234-KJFK-KLAX)"
bodyConfig := FindPatterns(message)
Expect(bodyConfig).NotTo(BeNil())
Expect(bodyConfig.Name).To(Equal("FPL"))
// Expect(bodyConfig.Name).To(Equal("ARR"))
})
It("should return nil if no pattern matches", func() {
message := "(XYZ-123)"
bodyConfig := FindPatterns(message, testConfig)
bodyConfig := FindPatterns(message)
Expect(bodyConfig).To(BeNil())
})
})
Describe("ParseBody", func() {
It("should parse the message body and extract data based on patterns", func() {
message := "(FPL-AB123)"
parsedData := ParseBody(message, testConfig)
message := "(ARR-AB123-SSR1234-KJFK-KLAX)"
parsedData := ParseBody(message)
Expect(parsedData).NotTo(BeNil())
Expect(parsedData["type"]).To(Equal("FPL"))
Expect(parsedData["type"]).To(Equal("ARR"))
Expect(parsedData["number"]).To(Equal("AB123"))
Expect(parsedData["ssr"]).To(Equal("SSR1234"))
Expect(parsedData["departure"]).To(Equal("KJFK"))
Expect(parsedData["arrival"]).To(Equal("KLAX"))
})
It("should return nil if no patterns match", func() {
message := "(XYZ-123)"
parsedData := ParseBody(message, testConfig)
parsedData := ParseBody(message)
Expect(parsedData).To(BeNil())
})
})
internal/parsers/suite_test.go
+13
View File
@@ -0,0 +1,13 @@
package parsers
import (
"testing"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
func TestParsers(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Parsers Suite")
}