Build report generation system with JSON output

internal/analyzer/report.go

@@ -0,0 +1,348 @@
+// This file is part of the happyDeliver (R) project.
+// Copyright (c) 2025 happyDomain
+// Authors: Pierre-Olivier Mercier, et al.
+//
+// This program is offered under a commercial and under the AGPL license.
+// For commercial licensing, contact us at <contact@happydomain.org>.
+//
+// For AGPL licensing:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package analyzer
+
+import (
+	"time"
+
+	"git.happydns.org/happyDeliver/internal/api"
+	"github.com/google/uuid"
+)
+
+// ReportGenerator generates comprehensive deliverability reports
+type ReportGenerator struct {
+	authAnalyzer    *AuthenticationAnalyzer
+	spamAnalyzer    *SpamAssassinAnalyzer
+	dnsAnalyzer     *DNSAnalyzer
+	rblChecker      *RBLChecker
+	contentAnalyzer *ContentAnalyzer
+	scorer          *DeliverabilityScorer
+}
+
+// NewReportGenerator creates a new report generator
+func NewReportGenerator(
+	dnsTimeout time.Duration,
+	httpTimeout time.Duration,
+	rbls []string,
+) *ReportGenerator {
+	return &ReportGenerator{
+		authAnalyzer:    NewAuthenticationAnalyzer(),
+		spamAnalyzer:    NewSpamAssassinAnalyzer(),
+		dnsAnalyzer:     NewDNSAnalyzer(dnsTimeout),
+		rblChecker:      NewRBLChecker(dnsTimeout, rbls),
+		contentAnalyzer: NewContentAnalyzer(httpTimeout),
+		scorer:          NewDeliverabilityScorer(),
+	}
+}
+
+// AnalysisResults contains all intermediate analysis results
+type AnalysisResults struct {
+	Email          *EmailMessage
+	Authentication *api.AuthenticationResults
+	SpamAssassin   *SpamAssassinResult
+	DNS            *DNSResults
+	RBL            *RBLResults
+	Content        *ContentResults
+	Score          *ScoringResult
+}
+
+// AnalyzeEmail performs complete email analysis
+func (r *ReportGenerator) AnalyzeEmail(email *EmailMessage) *AnalysisResults {
+	results := &AnalysisResults{
+		Email: email,
+	}
+
+	// Run all analyzers
+	results.Authentication = r.authAnalyzer.AnalyzeAuthentication(email)
+	results.SpamAssassin = r.spamAnalyzer.AnalyzeSpamAssassin(email)
+	results.DNS = r.dnsAnalyzer.AnalyzeDNS(email, results.Authentication)
+	results.RBL = r.rblChecker.CheckEmail(email)
+	results.Content = r.contentAnalyzer.AnalyzeContent(email)
+
+	// Calculate overall score
+	results.Score = r.scorer.CalculateScore(
+		results.Authentication,
+		results.SpamAssassin,
+		results.RBL,
+		results.Content,
+		email,
+	)
+
+	return results
+}
+
+// GenerateReport creates a complete API report from analysis results
+func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResults) *api.Report {
+	reportID := uuid.New()
+	now := time.Now()
+
+	report := &api.Report{
+		Id:        reportID,
+		TestId:    testID,
+		Score:     results.Score.OverallScore,
+		CreatedAt: now,
+	}
+
+	// Build score summary
+	report.Summary = &api.ScoreSummary{
+		AuthenticationScore: results.Score.AuthScore,
+		SpamScore:           results.Score.SpamScore,
+		BlacklistScore:      results.Score.BlacklistScore,
+		ContentScore:        results.Score.ContentScore,
+		HeaderScore:         results.Score.HeaderScore,
+	}
+
+	// Collect all checks from different analyzers
+	checks := []api.Check{}
+
+	// Authentication checks
+	if results.Authentication != nil {
+		authChecks := r.authAnalyzer.GenerateAuthenticationChecks(results.Authentication)
+		checks = append(checks, authChecks...)
+	}
+
+	// DNS checks
+	if results.DNS != nil {
+		dnsChecks := r.dnsAnalyzer.GenerateDNSChecks(results.DNS)
+		checks = append(checks, dnsChecks...)
+	}
+
+	// RBL checks
+	if results.RBL != nil {
+		rblChecks := r.rblChecker.GenerateRBLChecks(results.RBL)
+		checks = append(checks, rblChecks...)
+	}
+
+	// SpamAssassin checks
+	if results.SpamAssassin != nil {
+		spamChecks := r.spamAnalyzer.GenerateSpamAssassinChecks(results.SpamAssassin)
+		checks = append(checks, spamChecks...)
+	}
+
+	// Content checks
+	if results.Content != nil {
+		contentChecks := r.contentAnalyzer.GenerateContentChecks(results.Content)
+		checks = append(checks, contentChecks...)
+	}
+
+	// Header checks
+	headerChecks := r.scorer.GenerateHeaderChecks(results.Email)
+	checks = append(checks, headerChecks...)
+
+	report.Checks = checks
+
+	// Add authentication results
+	report.Authentication = results.Authentication
+
+	// Add SpamAssassin result
+	if results.SpamAssassin != nil {
+		report.Spamassassin = &api.SpamAssassinResult{
+			Score:         float32(results.SpamAssassin.Score),
+			RequiredScore: float32(results.SpamAssassin.RequiredScore),
+			IsSpam:        results.SpamAssassin.IsSpam,
+		}
+
+		if len(results.SpamAssassin.Tests) > 0 {
+			report.Spamassassin.Tests = &results.SpamAssassin.Tests
+		}
+
+		if results.SpamAssassin.RawReport != "" {
+			report.Spamassassin.Report = &results.SpamAssassin.RawReport
+		}
+	}
+
+	// Add DNS records
+	if results.DNS != nil {
+		dnsRecords := r.buildDNSRecords(results.DNS)
+		if len(dnsRecords) > 0 {
+			report.DnsRecords = &dnsRecords
+		}
+	}
+
+	// Add blacklist checks
+	if results.RBL != nil && len(results.RBL.Checks) > 0 {
+		blacklistChecks := make([]api.BlacklistCheck, 0, len(results.RBL.Checks))
+		for _, check := range results.RBL.Checks {
+			blCheck := api.BlacklistCheck{
+				Ip:     check.IP,
+				Rbl:    check.RBL,
+				Listed: check.Listed,
+			}
+			if check.Response != "" {
+				blCheck.Response = &check.Response
+			}
+			blacklistChecks = append(blacklistChecks, blCheck)
+		}
+		report.Blacklists = &blacklistChecks
+	}
+
+	// Add raw headers
+	if results.Email != nil && results.Email.RawHeaders != "" {
+		report.RawHeaders = &results.Email.RawHeaders
+	}
+
+	return report
+}
+
+// buildDNSRecords converts DNS analysis results to API DNS records
+func (r *ReportGenerator) buildDNSRecords(dns *DNSResults) []api.DNSRecord {
+	records := []api.DNSRecord{}
+
+	if dns == nil {
+		return records
+	}
+
+	// MX records
+	if len(dns.MXRecords) > 0 {
+		for _, mx := range dns.MXRecords {
+			status := api.Found
+			if !mx.Valid {
+				if mx.Error != "" {
+					status = api.Missing
+				} else {
+					status = api.Invalid
+				}
+			}
+
+			record := api.DNSRecord{
+				Domain:     dns.Domain,
+				RecordType: api.MX,
+				Status:     status,
+			}
+
+			if mx.Host != "" {
+				value := mx.Host
+				record.Value = &value
+			}
+
+			records = append(records, record)
+		}
+	}
+
+	// SPF record
+	if dns.SPFRecord != nil {
+		status := api.Found
+		if !dns.SPFRecord.Valid {
+			if dns.SPFRecord.Record == "" {
+				status = api.Missing
+			} else {
+				status = api.Invalid
+			}
+		}
+
+		record := api.DNSRecord{
+			Domain:     dns.Domain,
+			RecordType: api.SPF,
+			Status:     status,
+		}
+
+		if dns.SPFRecord.Record != "" {
+			record.Value = &dns.SPFRecord.Record
+		}
+
+		records = append(records, record)
+	}
+
+	// DKIM records
+	for _, dkim := range dns.DKIMRecords {
+		status := api.Found
+		if !dkim.Valid {
+			if dkim.Record == "" {
+				status = api.Missing
+			} else {
+				status = api.Invalid
+			}
+		}
+
+		record := api.DNSRecord{
+			Domain:     dkim.Domain,
+			RecordType: api.DKIM,
+			Status:     status,
+		}
+
+		if dkim.Record != "" {
+			// Include selector in value for clarity
+			value := dkim.Record
+			record.Value = &value
+		}
+
+		records = append(records, record)
+	}
+
+	// DMARC record
+	if dns.DMARCRecord != nil {
+		status := api.Found
+		if !dns.DMARCRecord.Valid {
+			if dns.DMARCRecord.Record == "" {
+				status = api.Missing
+			} else {
+				status = api.Invalid
+			}
+		}
+
+		record := api.DNSRecord{
+			Domain:     dns.Domain,
+			RecordType: api.DMARC,
+			Status:     status,
+		}
+
+		if dns.DMARCRecord.Record != "" {
+			record.Value = &dns.DMARCRecord.Record
+		}
+
+		records = append(records, record)
+	}
+
+	return records
+}
+
+// GenerateRawEmail returns the raw email message as a string
+func (r *ReportGenerator) GenerateRawEmail(email *EmailMessage) string {
+	if email == nil {
+		return ""
+	}
+
+	raw := email.RawHeaders
+	if email.RawBody != "" {
+		raw += "\n" + email.RawBody
+	}
+
+	return raw
+}
+
+// GetRecommendations returns actionable recommendations based on the score
+func (r *ReportGenerator) GetRecommendations(results *AnalysisResults) []string {
+	if results == nil || results.Score == nil {
+		return []string{}
+	}
+
+	return results.Score.Recommendations
+}
+
+// GetScoreSummaryText returns a human-readable score summary
+func (r *ReportGenerator) GetScoreSummaryText(results *AnalysisResults) string {
+	if results == nil || results.Score == nil {
+		return ""
+	}
+
+	return r.scorer.GetScoreSummary(results.Score)
+}