initial commit

2026-01-11 17:16:59 -07:00
parent c5d00dc9a9
commit 24ecddd034
18 changed files with 4506 additions and 4 deletions
--- a/server/kml.go
+++ b/server/kml.go
@@ -0,0 +1,595 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"math"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+// KML structure for parsing
+type KML struct {
+	XMLName  xml.Name    `xml:"kml"`
+	Document KMLDocument `xml:"Document"`
+}
+
+type KMLDocument struct {
+	Placemarks []KMLPlacemark `xml:"Placemark"`
+}
+
+type KMLPlacemark struct {
+	LineString KMLLineString `xml:"LineString"`
+}
+
+type KMLLineString struct {
+	Coordinates string `xml:"coordinates"`
+}
+
+// KML Metadata
+type KMLMetadata struct {
+	Filename    string    `json:"filename"`
+	UserID      string    `json:"user_id"`
+	DisplayName string    `json:"display_name"` // User's display name
+	Distance    float64   `json:"distance"`     // in kilometers
+	IsPublic    bool      `json:"is_public"`
+	UploadedAt  time.Time `json:"uploaded_at"`
+	Votes       int       `json:"votes"` // Net votes (calculated from voting system)
+}
+
+// Global vote tracking: kmlID -> userID -> vote (+1, -1, or 0)
+type VoteRegistry struct {
+	Votes map[string]map[string]int `json:"votes"` // kmlID -> (userID -> vote)
+	mu    sync.RWMutex
+}
+
+var voteRegistry *VoteRegistry
+
+// InitVoteRegistry loads the vote registry from disk
+func InitVoteRegistry() {
+	voteRegistry = &VoteRegistry{
+		Votes: make(map[string]map[string]int),
+	}
+	voteRegistry.Load()
+}
+
+func (vr *VoteRegistry) Load() error {
+	vr.mu.Lock()
+	defer vr.mu.Unlock()
+
+	data, err := os.ReadFile("data/kml_votes.json")
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+
+	return json.Unmarshal(data, vr)
+}
+
+func (vr *VoteRegistry) Save() error {
+	vr.mu.RLock()
+	defer vr.mu.RUnlock()
+	return vr.saveUnlocked()
+}
+
+func (vr *VoteRegistry) saveUnlocked() error {
+	if err := os.MkdirAll("data", 0755); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(vr, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile("data/kml_votes.json", data, 0644)
+}
+
+// GetVote return the vote of a user for a KML file (-1, 0, +1)
+func (vr *VoteRegistry) GetVote(kmlID, userID string) int {
+	vr.mu.RLock()
+	defer vr.mu.RUnlock()
+
+	if userVotes, exists := vr.Votes[kmlID]; exists {
+		return userVotes[userID]
+	}
+	return 0
+}
+
+// SetVote sets a user's vote for a KML file
+func (vr *VoteRegistry) SetVote(kmlID, userID string, vote int) error {
+	vr.mu.Lock()
+	defer vr.mu.Unlock()
+
+	if vr.Votes[kmlID] == nil {
+		vr.Votes[kmlID] = make(map[string]int)
+	}
+
+	if vote == 0 {
+		delete(vr.Votes[kmlID], userID)
+	} else {
+		vr.Votes[kmlID][userID] = vote
+	}
+
+	return vr.saveUnlocked()
+}
+
+// CalculateNetVotes calculates net votes for a KML file
+func (vr *VoteRegistry) CalculateNetVotes(kmlID string) int {
+	vr.mu.RLock()
+	defer vr.mu.RUnlock()
+
+	total := 0
+	if userVotes, exists := vr.Votes[kmlID]; exists {
+		for _, vote := range userVotes {
+			total += vote
+		}
+	}
+	return total
+}
+
+// Haversine formula to calculate distance between two lat/lng points
+func haversineDistance(lat1, lon1, lat2, lon2 float64) float64 {
+	const earthRadiusKm = 6371.0
+
+	dLat := (lat2 - lat1) * math.Pi / 180.0
+	dLon := (lon2 - lon1) * math.Pi / 180.0
+
+	a := math.Sin(dLat/2)*math.Sin(dLat/2) +
+		math.Cos(lat1*math.Pi/180.0)*math.Cos(lat2*math.Pi/180.0)*
+			math.Sin(dLon/2)*math.Sin(dLon/2)
+
+	c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
+
+	return earthRadiusKm * c
+}
+
+// ParseKMLDistance parses a KML file and calculates the total distance
+func ParseKMLDistance(kmlData []byte) (float64, error) {
+	decoder := xml.NewDecoder(bytes.NewReader(kmlData))
+	totalDistance := 0.0
+
+	for {
+		token, err := decoder.Token()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return 0, err
+		}
+
+		switch se := token.(type) {
+		case xml.StartElement:
+			// We only care about coordinates within a LineString context.
+			// However, since Points have only one coordinate and result in 0 anyway,
+			// searching for any <coordinates> tag is both easier and robust enough.
+			if se.Name.Local == "coordinates" {
+				var coords string
+				if err := decoder.DecodeElement(&coords, &se); err != nil {
+					continue
+				}
+
+				// Sum up distance from this LineString
+				items := strings.Fields(coords)
+				var prevLat, prevLon float64
+				first := true
+
+				for _, item := range items {
+					parts := strings.Split(strings.TrimSpace(item), ",")
+					if len(parts) < 2 {
+						continue
+					}
+
+					var lon, lat float64
+					_, err1 := fmt.Sscanf(parts[0], "%f", &lon)
+					_, err2 := fmt.Sscanf(parts[1], "%f", &lat)
+					if err1 != nil || err2 != nil {
+						continue
+					}
+
+					if !first {
+						totalDistance += haversineDistance(prevLat, prevLon, lat, lon)
+					}
+
+					prevLat = lat
+					prevLon = lon
+					first = false
+				}
+			}
+		}
+	}
+
+	return totalDistance, nil
+}
+
+// HandleKMLUpload handles KML file uploads
+func HandleKMLUpload(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	userID, ok := getUserID(r.Context())
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	// Parse multipart form
+	if err := r.ParseMultipartForm(10 << 20); err != nil { // 10 MB limit
+		http.Error(w, "Failed to parse form", http.StatusBadRequest)
+		return
+	}
+
+	file, handler, err := r.FormFile("kml")
+	if err != nil {
+		http.Error(w, "No file uploaded", http.StatusBadRequest)
+		return
+	}
+	defer file.Close()
+
+	// Read file data
+	data, err := io.ReadAll(file)
+	if err != nil {
+		http.Error(w, "Failed to read file", http.StatusInternalServerError)
+		return
+	}
+
+	// Calculate distance
+	distance, err := ParseKMLDistance(data)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("Failed to parse KML: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	// Save KML file
+	kmlDir := fmt.Sprintf("data/users/%s/kml", userID)
+	if err := os.MkdirAll(kmlDir, 0755); err != nil {
+		http.Error(w, "Failed to create directory", http.StatusInternalServerError)
+		return
+	}
+
+	kmlPath := filepath.Join(kmlDir, handler.Filename)
+	if err := os.WriteFile(kmlPath, data, 0644); err != nil {
+		http.Error(w, "Failed to save file", http.StatusInternalServerError)
+		return
+	}
+
+	// Get user info
+	user, _ := userRegistry.GetUser(userID)
+	displayName := userID
+	if user != nil {
+		displayName = user.DisplayName
+	}
+
+	// Create metadata
+	metadata := KMLMetadata{
+		Filename:    handler.Filename,
+		UserID:      userID,
+		DisplayName: displayName,
+		Distance:    distance,
+		IsPublic:    false, // Private by default
+		UploadedAt:  time.Now(),
+		Votes:       0,
+	}
+
+	metaPath := filepath.Join(kmlDir, handler.Filename+".meta.json")
+	metaData, _ := json.MarshalIndent(metadata, "", "  ")
+	if err := os.WriteFile(metaPath, metaData, 0644); err != nil {
+		http.Error(w, "Failed to save metadata", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success":  true,
+		"filename": handler.Filename,
+		"distance": distance,
+	})
+}
+
+// HandleKMLList lists KML files (user's own + public files)
+func HandleKMLList(w http.ResponseWriter, r *http.Request) {
+	userID, ok := getUserID(r.Context())
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	var allFiles []KMLMetadata
+
+	// Walk through all user directories
+	usersDir := "data/users"
+	entries, err := os.ReadDir(usersDir)
+	if err != nil {
+		// No users yet
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"my_files":     []KMLMetadata{},
+			"public_files": []KMLMetadata{},
+		})
+		return
+	}
+
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+
+		ownerID := entry.Name()
+		kmlDir := filepath.Join(usersDir, ownerID, "kml")
+
+		kmlFiles, err := os.ReadDir(kmlDir)
+		if err != nil {
+			continue
+		}
+
+		for _, kmlFile := range kmlFiles {
+			if !strings.HasSuffix(kmlFile.Name(), ".meta.json") {
+				continue
+			}
+
+			metaPath := filepath.Join(kmlDir, kmlFile.Name())
+			data, err := os.ReadFile(metaPath)
+			if err != nil {
+				continue
+			}
+
+			var meta KMLMetadata
+			if err := json.Unmarshal(data, &meta); err != nil {
+				continue
+			}
+
+			// Calculate current votes
+			kmlID := fmt.Sprintf("%s/%s", ownerID, meta.Filename)
+			meta.Votes = voteRegistry.CalculateNetVotes(kmlID)
+
+			// Include if:  1) owned by current user, OR 2) public
+			if ownerID == userID || meta.IsPublic {
+				allFiles = append(allFiles, meta)
+			}
+		}
+	}
+
+	// Separate into own files and public files
+	var myFiles, publicFiles []KMLMetadata
+	for _, file := range allFiles {
+		if file.UserID == userID {
+			myFiles = append(myFiles, file)
+		}
+		if file.IsPublic {
+			publicFiles = append(publicFiles, file)
+		}
+	}
+
+	// Sort public files by votes (highest first)
+	sort.Slice(publicFiles, func(i, j int) bool {
+		return publicFiles[i].Votes > publicFiles[j].Votes
+	})
+
+	// Sort my files by upload date (newest first)
+	sort.Slice(myFiles, func(i, j int) bool {
+		return myFiles[i].UploadedAt.After(myFiles[j].UploadedAt)
+	})
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"my_files":     myFiles,
+		"public_files": publicFiles,
+	})
+}
+
+// HandleKMLPrivacyToggle toggles the privacy setting of a KML file
+func HandleKMLPrivacyToggle(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	userID, ok := getUserID(r.Context())
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	var req struct {
+		Filename string `json:"filename"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
+	}
+
+	metaPath := fmt.Sprintf("data/users/%s/kml/%s.meta.json", userID, req.Filename)
+	data, err := os.ReadFile(metaPath)
+	if err != nil {
+		http.Error(w, "File not found", http.StatusNotFound)
+		return
+	}
+
+	var meta KMLMetadata
+	if err := json.Unmarshal(data, &meta); err != nil {
+		http.Error(w, "Failed to parse metadata", http.StatusInternalServerError)
+		return
+	}
+
+	// Verify ownership
+	if meta.UserID != userID {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	// Toggle privacy
+	meta.IsPublic = !meta.IsPublic
+
+	// Save updated metadata
+	newData, _ := json.MarshalIndent(meta, "", "  ")
+	if err := os.WriteFile(metaPath, newData, 0644); err != nil {
+		http.Error(w, "Failed to update metadata", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success":   true,
+		"is_public": meta.IsPublic,
+	})
+}
+
+// HandleKMLVote handles voting on KML files (toggle upvote/downvote/none)
+func HandleKMLVote(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	userID, ok := getUserID(r.Context())
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	var req struct {
+		OwnerID  string `json:"owner_id"`
+		Filename string `json:"filename"`
+		Vote     int    `json:"vote"` // +1, -1, or 0 to remove vote
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
+	}
+
+	// Validate vote value
+	if req.Vote != -1 && req.Vote != 0 && req.Vote != 1 {
+		http.Error(w, "Invalid vote value (must be -1, 0, or 1)", http.StatusBadRequest)
+		return
+	}
+
+	kmlID := fmt.Sprintf("%s/%s", req.OwnerID, req.Filename)
+
+	// Set the vote
+	if err := voteRegistry.SetVote(kmlID, userID, req.Vote); err != nil {
+		http.Error(w, "Failed to save vote", http.StatusInternalServerError)
+		return
+	}
+
+	// Calculate new net votes
+	netVotes := voteRegistry.CalculateNetVotes(kmlID)
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success":   true,
+		"net_votes": netVotes,
+	})
+}
+
+// HandleKMLDelete deletes a KML file with ownership verification
+func HandleKMLDelete(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodDelete && r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	userID, ok := getUserID(r.Context())
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	var req struct {
+		Filename string `json:"filename"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
+	}
+
+	// Verify ownership by reading metadata
+	metaPath := fmt.Sprintf("data/users/%s/kml/%s.meta.json", userID, req.Filename)
+	data, err := os.ReadFile(metaPath)
+	if err != nil {
+		http.Error(w, "File not found", http.StatusNotFound)
+		return
+	}
+
+	var meta KMLMetadata
+	if err := json.Unmarshal(data, &meta); err != nil {
+		http.Error(w, "Failed to parse metadata", http.StatusInternalServerError)
+		return
+	}
+
+	// Verify ownership
+	if meta.UserID != userID {
+		http.Error(w, "Forbidden - you can only delete your own files", http.StatusForbidden)
+		return
+	}
+
+	// Delete KML file and metadata
+	kmlPath := fmt.Sprintf("data/users/%s/kml/%s", userID, req.Filename)
+	os.Remove(kmlPath)
+	os.Remove(metaPath)
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success": true,
+	})
+}
+
+// HandleKMLDownload serves a KML file for downloading/viewing
+func HandleKMLDownload(w http.ResponseWriter, r *http.Request) {
+	userID, ok := getUserID(r.Context())
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	ownerID := r.URL.Query().Get("owner_id")
+	filename := r.URL.Query().Get("filename")
+
+	if ownerID == "" || filename == "" {
+		http.Error(w, "Missing owner_id or filename", http.StatusBadRequest)
+		return
+	}
+
+	// Verify permission: ownerID == userID OR file is public
+	if ownerID != userID {
+		metaPath := fmt.Sprintf("data/users/%s/kml/%s.meta.json", ownerID, filename)
+		data, err := os.ReadFile(metaPath)
+		if err != nil {
+			http.Error(w, "File not found", http.StatusNotFound)
+			return
+		}
+
+		var meta KMLMetadata
+		if err := json.Unmarshal(data, &meta); err != nil {
+			http.Error(w, "Error reading metadata", http.StatusInternalServerError)
+			return
+		}
+
+		if !meta.IsPublic {
+			http.Error(w, "Forbidden", http.StatusForbidden)
+			return
+		}
+	}
+
+	kmlPath := fmt.Sprintf("data/users/%s/kml/%s", ownerID, filename)
+	data, err := os.ReadFile(kmlPath)
+	if err != nil {
+		http.Error(w, "File not found", http.StatusNotFound)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/vnd.google-earth.kml+xml")
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	w.Write(data)
+}