honeydany/app/web.go

package app

import (
    "embed"
    "encoding/json"
    "fmt"
    "html/template"
    "log"
    "net/http"
    "os"
    "strings"
    "time"
)

//go:embed templates/*.html
var templatesFS embed.FS

var templates *template.Template

func initTemplates() error {
    funcMap := template.FuncMap{
        "toJSON": func(v any) string {
            b, _ := json.Marshal(v)
            return string(b)
        },
    }
    // Parse layout first, then pages
    t, err := template.New("layout.html").Funcs(funcMap).ParseFS(templatesFS, "templates/layout.html", "templates/index.html", "templates/logs.html")
    if err != nil { return err }
    templates = t
    return nil
}

func (a *App) startWeb() {
    bind := a.cfg.Web.Bind
    port := a.cfg.Web.Port
    addr := fmt.Sprintf("%s:%d", bind, port)
    mux := http.NewServeMux()
    if templates == nil {
        if err := initTemplates(); err != nil {
            log.Printf("template init error: %v", err)
        }
    }
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        stats := map[string]any{}
        if a.threatIntel != nil {
            stats = a.threatIntel.GetStats()
        }
        data := map[string]any{
            "Now":  time.Now().Format("2006-01-02 15:04:05 MST"),
            "Stats": stats,
        }
        if templates != nil {
            _ = templates.ExecuteTemplate(w, "index", data)
            return
        }
        http.Error(w, "templates not loaded", 500)
    })
    mux.HandleFunc("/logs", func(w http.ResponseWriter, r *http.Request) {
        // display last 200 logs
        var rows []Record
        if a.logger != nil && a.logger.mode == "sqlite" && a.logger.db != nil {
            // query sqlite
            q := `SELECT timestamp, remote_addr, remote_port, service, details, raw_payload FROM logs ORDER BY id DESC LIMIT 200`
            rs, err := a.logger.db.Query(q)
            if err != nil {
                http.Error(w, "db query failed", 500)
                return
            }
            defer rs.Close()
            for rs.Next() {
                var ts, ra, rp, svc, detailsS, raw string
                if err := rs.Scan(&ts, &ra, &rp, &svc, &detailsS, &raw); err != nil {
                    continue
                }
                var det map[string]string
                if err := json.Unmarshal([]byte(detailsS), &det); err != nil {
                    continue
                }
                rows = append(rows, Record{Timestamp: parseTime(ts), RemoteAddr: ra, RemotePort: rp, Service: svc, Details: det, RawPayload: raw})
            }
        } else {
            // try to read file based JSON-lines
            path := a.cfg.LogPath
            b, err := os.ReadFile(path)
            if err == nil {
                lines := strings.Split(string(b), "\n")
                for i := len(lines) - 1; i >= 0 && len(rows) < 200; i-- {
                    line := strings.TrimSpace(lines[i])
                    if line == "" {
                        continue
                    }
                    var rec Record
                    if err := json.Unmarshal([]byte(line), &rec); err != nil {
                        continue
                    }
                    rows = append(rows, rec)
                }
            }
        }

        data := map[string]any{
            "Now":  time.Now().Format("2006-01-02 15:04:05 MST"),
            "Rows": rows,
        }
        if templates != nil {
            _ = templates.ExecuteTemplate(w, "logs", data)
            return
        }
        http.Error(w, "templates not loaded", 500)
    })

	srv := &http.Server{Addr: addr, Handler: mux}
	a.addHTTPServer(srv)
	log.Printf("Dashboard listening on http://%s", addr)
	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		log.Printf("dashboard error: %v", err)
	}
}
func parseTime(s string) (t time.Time) {
    t, _ = time.Parse(time.RFC3339Nano, s)
    if t.IsZero() {
        // fallback current time
        t = time.Now()
    }
    return
}