Files

276 lines
7.9 KiB
Go

package main
import (
"encoding/json"
"fmt"
"io"
"log/slog"
"net/http"
"os"
"os/exec"
"path/filepath"
"regexp"
"sort"
"strconv"
"strings"
"time"
"unified-dashboard/internal/common"
mymiddleware "unified-dashboard/internal/middleware"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
"github.com/go-chi/cors"
)
var (
baseDir string
uploadFolder string
processedFolder string
resultsFolder string
coordinatesFile string
)
func initPaths() {
cwd, _ := os.Getwd()
baseDir = filepath.Join(cwd, "data", "png-frame-detector")
uploadFolder = filepath.Join(baseDir, "uploads")
processedFolder = filepath.Join(baseDir, "processed")
resultsFolder = filepath.Join(baseDir, "results")
coordinatesFile = filepath.Join(resultsFolder, "coordinates.txt")
os.MkdirAll(uploadFolder, 0755)
os.MkdirAll(processedFolder, 0755)
os.MkdirAll(resultsFolder, 0755)
}
func main() {
common.InitLogger("png-frame-detector")
initPaths()
port := os.Getenv("PORT")
if port == "" {
port = "5003"
}
r := chi.NewRouter()
r.Use(middleware.RealIP)
r.Use(middleware.RequestID)
r.Use(mymiddleware.RequestLogger)
r.Use(middleware.Recoverer)
r.Use(cors.Handler(cors.Options{
AllowedOrigins: []string{"*"},
AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
}))
if scriptName := os.Getenv("SCRIPT_NAME"); scriptName != "" {
r.Use(common.PrefixMiddleware(scriptName))
}
// Static Files
workDir, _ := os.Getwd()
webDir := filepath.Join(workDir, "web", "png-frame-detector")
r.Handle("/css/*", http.StripPrefix("/css/", http.FileServer(http.Dir(filepath.Join(webDir, "css")))))
r.Handle("/js/*", http.StripPrefix("/js/", http.FileServer(http.Dir(filepath.Join(webDir, "js")))))
r.Get("/", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, filepath.Join(webDir, "index.html"))
})
r.Handle("/uploads/*", http.StripPrefix("/uploads/", http.FileServer(http.Dir(uploadFolder))))
r.Handle("/processed/*", http.StripPrefix("/processed/", http.FileServer(http.Dir(processedFolder))))
r.Get("/health", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
})
r.Post("/upload", handleUpload)
r.Post("/save_coordinates", handleSaveCoordinates)
r.Post("/save_all_coordinates", handleSaveAllCoordinates)
r.Get("/get_coordinates", handleGetCoordinates)
r.Post("/clear_coordinates", handleClearCoordinates)
slog.Info("starting png-frame-detector", "port", port, "pid", os.Getpid())
if err := http.ListenAndServe(":"+port, r); err != nil {
slog.Error("server failed", "error", err)
}
}
func handleUpload(w http.ResponseWriter, r *http.Request) {
r.ParseMultipartForm(16 << 20) // 16MB max
file, header, err := r.FormFile("file")
if err != nil {
writeJSON(w, 400, map[string]any{"success": false, "error": "No file uploaded"})
return
}
defer file.Close()
ext := strings.ToLower(filepath.Ext(header.Filename))
if ext == "" {
ext = ".png"
}
timestamp := time.Now().Unix()
baseName := strings.TrimSuffix(header.Filename, filepath.Ext(header.Filename))
filename := fmt.Sprintf("%s_%d%s", baseName, timestamp, ext)
uploadPath := filepath.Join(uploadFolder, filename)
out, err := os.Create(uploadPath)
if err != nil {
writeJSON(w, 500, map[string]any{"success": false, "error": "Failed to save file"})
return
}
io.Copy(out, file)
out.Close()
processedFilename := fmt.Sprintf("processed_%s", filename)
processedPath := filepath.Join(processedFolder, processedFilename)
// Call Python wrapper
workDir, _ := os.Getwd()
cliPath := filepath.Join(workDir, "cmd", "png-frame-detector", "cli.py")
pythonBin := "/home/creserver/extras/local_venv/bin/python3"
if _, err := os.Stat(pythonBin); os.IsNotExist(err) {
pythonBin = "python3"
}
cmd := exec.Command(pythonBin, cliPath, "--input", uploadPath, "--output", processedPath)
output, err := cmd.CombinedOutput()
if err != nil {
writeJSON(w, 500, map[string]any{"success": false, "error": string(output)})
return
}
var result map[string]any
// Search for JSON object in output lines in case external libraries print messages
lines := strings.Split(string(output), "\n")
for _, line := range lines {
trimmed := strings.TrimSpace(line)
if strings.HasPrefix(trimmed, "{") && strings.HasSuffix(trimmed, "}") {
if err := json.Unmarshal([]byte(trimmed), &result); err == nil {
break
}
}
}
if result == nil {
writeJSON(w, 500, map[string]any{"success": false, "error": "Invalid output from processor: " + string(output)})
return
}
if success, ok := result["success"].(bool); ok && success {
prefix := r.Header.Get("X-Forwarded-Prefix")
result["image_url"] = fmt.Sprintf("%s/processed/%s", prefix, processedFilename)
result["original_url"] = fmt.Sprintf("%s/uploads/%s", prefix, filename)
}
writeJSON(w, 200, result)
}
func handleSaveCoordinates(w http.ResponseWriter, r *http.Request) {
var data struct {
ImageName string `json:"image_name"`
CoordinateString string `json:"coordinate_string"`
}
json.NewDecoder(r.Body).Decode(&data)
if data.ImageName == "" || data.CoordinateString == "" {
writeJSON(w, 400, map[string]any{"success": false, "error": "Invalid data"})
return
}
timestamp := time.Now().Format("2006-01-02 15:04:05")
entry := fmt.Sprintf("%s | %s | %s\n", timestamp, data.ImageName, data.CoordinateString)
f, err := os.OpenFile(coordinatesFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
writeJSON(w, 500, map[string]any{"success": false, "error": err.Error()})
return
}
defer f.Close()
f.WriteString(entry)
writeJSON(w, 200, map[string]any{"success": true})
}
func handleSaveAllCoordinates(w http.ResponseWriter, r *http.Request) {
var data struct {
Results []struct {
Filename string `json:"filename"`
Coordinates string `json:"coordinates"`
} `json:"results"`
}
json.NewDecoder(r.Body).Decode(&data)
if len(data.Results) == 0 {
writeJSON(w, 400, map[string]any{"success": false, "error": "Invalid data"})
return
}
sort.Slice(data.Results, func(i, j int) bool {
return naturalLess(data.Results[i].Filename, data.Results[j].Filename)
})
timestamp := time.Now().Format("2006-01-02 15:04:05")
f, err := os.OpenFile(coordinatesFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
writeJSON(w, 500, map[string]any{"success": false, "error": err.Error()})
return
}
defer f.Close()
sep := strings.Repeat("=", 60)
f.WriteString(fmt.Sprintf("\n%s\nBATCH PROCESSING RESULTS - %s\nTotal Images: %d\n%s\n\n", sep, timestamp, len(data.Results), sep))
for _, item := range data.Results {
f.WriteString(fmt.Sprintf("%s | %s | %s\n", timestamp, item.Filename, item.Coordinates))
}
writeJSON(w, 200, map[string]any{"success": true})
}
func handleGetCoordinates(w http.ResponseWriter, r *http.Request) {
content, err := os.ReadFile(coordinatesFile)
if err != nil {
writeJSON(w, 200, map[string]any{"content": ""})
return
}
writeJSON(w, 200, map[string]any{"content": string(content)})
}
func handleClearCoordinates(w http.ResponseWriter, r *http.Request) {
os.WriteFile(coordinatesFile, []byte(""), 0644)
writeJSON(w, 200, map[string]any{"success": true})
}
func writeJSON(w http.ResponseWriter, status int, data any) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
json.NewEncoder(w).Encode(data)
}
// naturalLess implements natural string sorting (e.g. img2 < img10)
func naturalLess(a, b string) bool {
re := regexp.MustCompile(`\d+|\D+`)
aParts := re.FindAllString(a, -1)
bParts := re.FindAllString(b, -1)
for i := 0; i < len(aParts) && i < len(bParts); i++ {
if aParts[i] != bParts[i] {
aInt, aErr := strconv.Atoi(aParts[i])
bInt, bErr := strconv.Atoi(bParts[i])
if aErr == nil && bErr == nil {
return aInt < bInt
}
return aParts[i] < bParts[i]
}
}
return len(aParts) < len(bParts)
}