Refactor application structure to implement service-oriented architecture

- Moved template management functions to TemplateService for better separation of concerns.
- Created BatchImportService for handling log file imports.
- Introduced ConnectionService for managing connection-related operations.
- Added ProfileService to manage connection profiles.
- Implemented StressTestService for continuous message sending operations.
- Developed SyslogService for syslog message formatting and transmission.
- Updated main application to initialize and inject services properly.
- Enhanced context management for services to ensure proper lifecycle handling.
- Added CRUD operations for log templates and connection profiles.
- Improved error handling and logging throughout the services.

Author: yllada

app.go

@@ -0,0 +1,109 @@
+package main
+
+import (
+	"context"
+
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// Version information - injected at build time via ldflags
+// Use: go build -ldflags "-X main.Version=1.4.2"
+var Version = "dev"
+
+// ================================================================================
+// APP CORE - Main application struct with lifecycle management
+// Follows Single Responsibility Principle: handles only app lifecycle and metadata
+// ================================================================================
+
+// App struct is the main application controller
+// It manages lifecycle hooks and coordinates between services
+type App struct {
+	ctx context.Context
+
+	// Service references for coordination
+	connectionService *ConnectionService
+	syslogService     *SyslogService
+	stressTestService *StressTestService
+}
+
+// NewApp creates a new App instance
+func NewApp() *App {
+	return &App{}
+}
+
+// SetServices injects service dependencies (called from main.go)
+func (a *App) SetServices(conn *ConnectionService, syslog *SyslogService, stress *StressTestService) {
+	a.connectionService = conn
+	a.syslogService = syslog
+	a.stressTestService = stress
+}
+
+// startup is called at application startup
+func (a *App) startup(ctx context.Context) {
+	a.ctx = ctx
+}
+
+// domReady is called after front-end resources have been loaded
+func (a *App) domReady(ctx context.Context) {
+	// Center the window on the screen
+	runtime.WindowCenter(a.ctx)
+}
+
+// beforeClose is called when the application is about to quit
+func (a *App) beforeClose(ctx context.Context) (prevent bool) {
+	// Check if connection service has active connection
+	if a.connectionService != nil && a.connectionService.IsConnected() {
+		result, err := runtime.MessageDialog(a.ctx, runtime.MessageDialogOptions{
+			Type:          runtime.QuestionDialog,
+			Title:         "Confirm Exit",
+			Message:       "There is an active connection. Are you sure you want to exit?",
+			Buttons:       []string{"Yes", "No"},
+			DefaultButton: "No",
+			CancelButton:  "No",
+		})
+		if err != nil || result != "Yes" {
+			return true // Prevent close
+		}
+	}
+
+	// Clean up connections
+	if a.connectionService != nil {
+		a.connectionService.Disconnect()
+	}
+
+	// Stop stress test if running
+	if a.stressTestService != nil {
+		a.stressTestService.StopContinuousSend()
+	}
+
+	return false
+}
+
+// shutdown is called at application termination
+func (a *App) shutdown(ctx context.Context) {
+	// Ensure all connections are closed
+	if a.connectionService != nil {
+		a.connectionService.Disconnect()
+	}
+}
+
+// ================================================================================
+// APP METADATA API
+// ================================================================================
+
+// GetVersion returns the application version
+// The version is injected at build time via ldflags
+func (a *App) GetVersion() string {
+	return Version
+}
+
+// OpenURL opens a URL in the default system browser
+func (a *App) OpenURL(url string) {
+	runtime.BrowserOpenURL(a.ctx, url)
+	runtime.LogDebug(a.ctx, "Opened URL in browser: "+url)
+}
+
+// OpenGitHub opens the project's GitHub repository in the default browser
+func (a *App) OpenGitHub() {
+	runtime.BrowserOpenURL(a.ctx, "https://github.com/yllada/Send-Log-TCP")
+}

app_core.go

@@ -0,0 +1,244 @@
+package main
+
+import (
+	"context"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// ================================================================================
+// BATCH IMPORT SERVICE - Handles log file imports (Enterprise Feature)
+// Follows Single Responsibility Principle: handles only batch import operations
+// ================================================================================
+
+// BatchImportResult represents the result of a batch import operation
+type BatchImportResult struct {
+	Messages   []string `json:"messages"`
+	TotalLines int      `json:"totalLines"`
+	Errors     []string `json:"errors"`
+}
+
+// BatchImportService handles batch log import operations
+type BatchImportService struct {
+	ctx context.Context
+}
+
+// NewBatchImportService creates a new BatchImportService instance
+func NewBatchImportService() *BatchImportService {
+	return &BatchImportService{}
+}
+
+// SetContext sets the Wails runtime context
+func (b *BatchImportService) SetContext(ctx context.Context) {
+	b.ctx = ctx
+}
+
+// SelectLogFile opens a file dialog to select a log file for batch import
+func (b *BatchImportService) SelectLogFile() (string, error) {
+	filePath, err := runtime.OpenFileDialog(b.ctx, runtime.OpenDialogOptions{
+		Title: "Select Log File for Import",
+		Filters: []runtime.FileFilter{
+			{
+				DisplayName: "Log Files (*.csv, *.json, *.txt, *.log)",
+				Pattern:     "*.csv;*.json;*.txt;*.log",
+			},
+			{
+				DisplayName: "CSV Files (*.csv)",
+				Pattern:     "*.csv",
+			},
+			{
+				DisplayName: "JSON Files (*.json)",
+				Pattern:     "*.json",
+			},
+			{
+				DisplayName: "Text Files (*.txt, *.log)",
+				Pattern:     "*.txt;*.log",
+			},
+			{
+				DisplayName: "All Files (*.*)",
+				Pattern:     "*.*",
+			},
+		},
+	})
+	if err != nil {
+		return "", fmt.Errorf("failed to open file dialog: %w", err)
+	}
+	return filePath, nil
+}
+
+// ImportLogFile reads and parses a log file, returning the messages
+func (b *BatchImportService) ImportLogFile(filePath string) (BatchImportResult, error) {
+	result := BatchImportResult{
+		Messages: []string{},
+		Errors:   []string{},
+	}
+
+	// Read file content
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return result, fmt.Errorf("failed to read file: %w", err)
+	}
+
+	// Detect format based on extension
+	ext := strings.ToLower(filepath.Ext(filePath))
+
+	switch ext {
+	case ".json":
+		return b.parseJSONLogs(content)
+	case ".csv":
+		return b.parseCSVLogs(content)
+	default:
+		// Try JSON first, then fallback to plain text
+		if len(content) > 0 && (content[0] == '[' || content[0] == '{') {
+			jsonResult, err := b.parseJSONLogs(content)
+			if err == nil && len(jsonResult.Messages) > 0 {
+				return jsonResult, nil
+			}
+		}
+		return b.parseTextLogs(content)
+	}
+}
+
+// parseJSONLogs parses JSON format logs
+func (b *BatchImportService) parseJSONLogs(content []byte) (BatchImportResult, error) {
+	result := BatchImportResult{
+		Messages: []string{},
+		Errors:   []string{},
+	}
+
+	// Try parsing as array of strings
+	var stringArray []string
+	if err := json.Unmarshal(content, &stringArray); err == nil {
+		for _, msg := range stringArray {
+			if trimmed := strings.TrimSpace(msg); trimmed != "" {
+				result.Messages = append(result.Messages, trimmed)
+			}
+		}
+		result.TotalLines = len(stringArray)
+		return result, nil
+	}
+
+	// Try parsing as array of objects with "message" field
+	var objArray []map[string]interface{}
+	if err := json.Unmarshal(content, &objArray); err == nil {
+		result.TotalLines = len(objArray)
+		for i, obj := range objArray {
+			if msg, ok := obj["message"].(string); ok && strings.TrimSpace(msg) != "" {
+				result.Messages = append(result.Messages, strings.TrimSpace(msg))
+			} else if msg, ok := obj["msg"].(string); ok && strings.TrimSpace(msg) != "" {
+				result.Messages = append(result.Messages, strings.TrimSpace(msg))
+			} else if msg, ok := obj["log"].(string); ok && strings.TrimSpace(msg) != "" {
+				result.Messages = append(result.Messages, strings.TrimSpace(msg))
+			} else {
+				result.Errors = append(result.Errors, fmt.Sprintf("Line %d: no 'message', 'msg', or 'log' field found", i+1))
+			}
+		}
+		return result, nil
+	}
+
+	// Try parsing as newline-delimited JSON (NDJSON)
+	lines := strings.Split(string(content), "\n")
+	result.TotalLines = len(lines)
+	for i, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		var obj map[string]interface{}
+		if err := json.Unmarshal([]byte(line), &obj); err == nil {
+			if msg, ok := obj["message"].(string); ok && strings.TrimSpace(msg) != "" {
+				result.Messages = append(result.Messages, strings.TrimSpace(msg))
+			} else if msg, ok := obj["msg"].(string); ok && strings.TrimSpace(msg) != "" {
+				result.Messages = append(result.Messages, strings.TrimSpace(msg))
+			} else {
+				result.Errors = append(result.Errors, fmt.Sprintf("Line %d: no message field found", i+1))
+			}
+		} else {
+			result.Errors = append(result.Errors, fmt.Sprintf("Line %d: invalid JSON", i+1))
+		}
+	}
+
+	return result, nil
+}
+
+// parseCSVLogs parses CSV format logs
+func (b *BatchImportService) parseCSVLogs(content []byte) (BatchImportResult, error) {
+	result := BatchImportResult{
+		Messages: []string{},
+		Errors:   []string{},
+	}
+
+	reader := csv.NewReader(strings.NewReader(string(content)))
+	reader.TrimLeadingSpace = true
+	reader.LazyQuotes = true
+
+	records, err := reader.ReadAll()
+	if err != nil {
+		return result, fmt.Errorf("failed to parse CSV: %w", err)
+	}
+
+	if len(records) == 0 {
+		return result, nil
+	}
+
+	result.TotalLines = len(records)
+
+	// Check for header row
+	messageColIdx := 0
+	hasHeader := false
+	header := records[0]
+
+	for i, col := range header {
+		colLower := strings.ToLower(strings.TrimSpace(col))
+		if colLower == "message" || colLower == "msg" || colLower == "log" {
+			messageColIdx = i
+			hasHeader = true
+			break
+		}
+	}
+
+	startRow := 0
+	if hasHeader {
+		startRow = 1
+	}
+
+	for i := startRow; i < len(records); i++ {
+		record := records[i]
+		if len(record) > messageColIdx {
+			msg := strings.TrimSpace(record[messageColIdx])
+			if msg != "" {
+				result.Messages = append(result.Messages, msg)
+			}
+		} else {
+			result.Errors = append(result.Errors, fmt.Sprintf("Line %d: insufficient columns", i+1))
+		}
+	}
+
+	return result, nil
+}
+
+// parseTextLogs parses plain text logs (one message per line)
+func (b *BatchImportService) parseTextLogs(content []byte) (BatchImportResult, error) {
+	result := BatchImportResult{
+		Messages: []string{},
+		Errors:   []string{},
+	}
+
+	lines := strings.Split(string(content), "\n")
+	result.TotalLines = len(lines)
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if trimmed != "" {
+			result.Messages = append(result.Messages, trimmed)
+		}
+	}
+
+	return result, nil
+}