mirror of
https://github.com/Dvorinka/PPve.git
synced 2026-06-04 04:22:58 +00:00
Tomas Dvorak
1024 lines
31 KiB
Go
1024 lines
31 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/tls"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"net/http/httputil"
|
|
"net/url"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gorilla/mux"
|
|
"gopkg.in/gomail.v2"
|
|
)
|
|
|
|
type App struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
URL string `json:"url"`
|
|
Description string `json:"description,omitempty"`
|
|
Icon string `json:"icon,omitempty"`
|
|
CreatedAt string `json:"created_at"`
|
|
UpdatedAt string `json:"updated_at"`
|
|
}
|
|
|
|
type TripEntry struct {
|
|
Name string `json:"name"`
|
|
Vehicle string `json:"vehicle"`
|
|
Destination string `json:"destination"`
|
|
DateStart string `json:"date_start"`
|
|
TimeStart string `json:"time_start"`
|
|
DateEnd string `json:"date_end"`
|
|
TimeEnd string `json:"time_end"`
|
|
Purpose string `json:"purpose"`
|
|
KmStart int `json:"km_start"`
|
|
KmEnd int `json:"km_end"`
|
|
Coordinates *GeoCoords `json:"coordinates,omitempty"`
|
|
}
|
|
|
|
type GeoCoords struct {
|
|
Lat string `json:"lat"`
|
|
Lng string `json:"lng"`
|
|
}
|
|
|
|
func main() {
|
|
log.SetFlags(log.LstdFlags | log.Lshortfile)
|
|
|
|
// Create necessary directories
|
|
if err := os.MkdirAll("data", 0755); err != nil {
|
|
log.Fatalf("Failed to create data directory: %v", err)
|
|
}
|
|
if err := os.MkdirAll("uploads", 0755); err != nil {
|
|
log.Fatalf("Failed to create uploads directory: %v", err)
|
|
}
|
|
|
|
r := mux.NewRouter()
|
|
|
|
// Set up reverse proxy to kontakt service
|
|
kontaktURL, _ := url.Parse("http://webportal:8080")
|
|
kontaktProxy := httputil.NewSingleHostReverseProxy(kontaktURL)
|
|
|
|
// Public routes
|
|
r.PathPrefix("/kontakt/").Handler(http.StripPrefix("/kontakt", kontaktProxy))
|
|
r.PathPrefix("/uploads/").Handler(http.StripPrefix("/uploads/", http.FileServer(http.Dir("./uploads"))))
|
|
r.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write([]byte(`{"status":"ok"}`))
|
|
}).Methods("GET", "OPTIONS")
|
|
|
|
// Authentication routes
|
|
r.HandleFunc("/api/login", LoginHandler).Methods("POST", "OPTIONS")
|
|
|
|
// Protected API routes
|
|
api := r.PathPrefix("/api").Subrouter()
|
|
api.Use(AuthMiddleware)
|
|
api.HandleFunc("/submit", handleSubmit).Methods("POST")
|
|
api.HandleFunc("/banner/update", UpdateBannerHandler).Methods("POST", "OPTIONS")
|
|
|
|
// App management routes
|
|
api.HandleFunc("/apps", GetAppsHandler).Methods("GET")
|
|
api.HandleFunc("/apps", CreateAppHandler).Methods("POST")
|
|
api.HandleFunc("/apps/{id}", GetAppHandler).Methods("GET")
|
|
api.HandleFunc("/apps/{id}", UpdateAppHandler).Methods("PUT")
|
|
api.HandleFunc("/apps/{id}", DeleteAppHandler).Methods("DELETE")
|
|
|
|
// Public endpoints
|
|
r.HandleFunc("/api/banner", GetBannerHandler).Methods("GET", "OPTIONS")
|
|
|
|
// Important: This public submit endpoint must be defined BEFORE the static file server
|
|
r.HandleFunc("/submit", handleSubmit).Methods("POST", "OPTIONS") // Public submit endpoint for evidence-aut.html
|
|
|
|
// Add CORS middleware for API
|
|
r.Use(func(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
|
|
|
|
if r.Method == "OPTIONS" {
|
|
w.WriteHeader(http.StatusOK)
|
|
return
|
|
}
|
|
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
})
|
|
|
|
// Admin routes
|
|
r.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) {
|
|
http.ServeFile(w, r, "admin.html")
|
|
}).Methods("GET")
|
|
|
|
r.HandleFunc("/admin/dashboard", func(w http.ResponseWriter, r *http.Request) {
|
|
http.ServeFile(w, r, "admin-dashboard.html")
|
|
}).Methods("GET")
|
|
|
|
// Redirect root to index.html
|
|
r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path == "/" {
|
|
http.ServeFile(w, r, "index.html")
|
|
}
|
|
}).Methods("GET")
|
|
|
|
// Public route for evidence-aut.html
|
|
r.HandleFunc("/evidence-aut", func(w http.ResponseWriter, r *http.Request) {
|
|
http.ServeFile(w, r, "evidence-aut.html")
|
|
}).Methods("GET")
|
|
|
|
// Static file server for public files - must be the last route defined
|
|
fs := http.FileServer(http.Dir("."))
|
|
r.PathPrefix("/").Handler(fs)
|
|
|
|
r.HandleFunc("/kontakt", func(w http.ResponseWriter, r *http.Request) {
|
|
// Check if kontakt service is already running
|
|
resp, err := http.Get("http://webportal:8080/health")
|
|
if err == nil && resp.StatusCode == 200 {
|
|
http.Redirect(w, r, "http://webportal:8080/", http.StatusFound)
|
|
return
|
|
}
|
|
|
|
// Start the service if not running
|
|
cmd := exec.Command("make", "dev")
|
|
cmd.Dir = "kontakt"
|
|
err = cmd.Start()
|
|
if err != nil {
|
|
http.Error(w, "Failed to start kontakt service", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Wait briefly for service to start
|
|
time.Sleep(2 * time.Second)
|
|
http.Redirect(w, r, "http://webportal:8080/", http.StatusFound)
|
|
}).Methods("GET")
|
|
|
|
// Apply CORS middleware to all routes
|
|
handler := enableCORS(r)
|
|
|
|
port := os.Getenv("PORT")
|
|
if port == "" {
|
|
port = "80"
|
|
}
|
|
|
|
log.Printf("Server běží na portu %s", port)
|
|
err := http.ListenAndServe(":"+port, handler)
|
|
if err != nil {
|
|
log.Fatalf("Chyba při spuštění serveru: %v", err)
|
|
}
|
|
}
|
|
|
|
func enableCORS(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
|
|
|
|
if r.Method == "OPTIONS" {
|
|
w.WriteHeader(http.StatusOK)
|
|
return
|
|
}
|
|
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
|
|
// File path for storing apps
|
|
const appsFile = "data/apps.json"
|
|
|
|
// loadApps loads apps from the JSON file
|
|
func loadApps() ([]App, error) {
|
|
var apps []App
|
|
|
|
// Check if file exists
|
|
if _, err := os.Stat(appsFile); os.IsNotExist(err) {
|
|
// Return empty slice if file doesn't exist
|
|
return []App{}, nil
|
|
}
|
|
|
|
// Read file
|
|
data, err := os.ReadFile(appsFile)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading apps file: %v", err)
|
|
}
|
|
|
|
// Unmarshal JSON
|
|
if err := json.Unmarshal(data, &apps); err != nil {
|
|
return nil, fmt.Errorf("error parsing apps JSON: %v", err)
|
|
}
|
|
|
|
return apps, nil
|
|
}
|
|
|
|
// saveApps saves apps to the JSON file
|
|
func saveApps(apps []App) error {
|
|
// Create data directory if it doesn't exist
|
|
if err := os.MkdirAll(filepath.Dir(appsFile), 0755); err != nil {
|
|
return fmt.Errorf("error creating data directory: %v", err)
|
|
}
|
|
|
|
// Marshal to pretty-printed JSON
|
|
data, err := json.MarshalIndent(apps, "", " ")
|
|
if err != nil {
|
|
return fmt.Errorf("error marshaling apps to JSON: %v", err)
|
|
}
|
|
|
|
// Write to file
|
|
if err := os.WriteFile(appsFile, data, 0644); err != nil {
|
|
return fmt.Errorf("error writing apps file: %v", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// App Handlers
|
|
func GetAppsHandler(w http.ResponseWriter, r *http.Request) {
|
|
apps, err := loadApps()
|
|
if err != nil {
|
|
log.Printf("Error loading apps: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Return empty array if no apps
|
|
if apps == nil {
|
|
apps = []App{}
|
|
}
|
|
|
|
// Add hardcoded apps
|
|
hardcodedApps := []App{
|
|
{
|
|
ID: "hardcoded-car",
|
|
Name: "Záznam služebních jízd",
|
|
URL: "/evidence-aut",
|
|
Description: "Jednoduchý systém pro evidenci a správu jízd služebními vozidly.",
|
|
Icon: "fa-car-side",
|
|
CreatedAt: time.Now().Format(time.RFC3339),
|
|
UpdatedAt: time.Now().Format(time.RFC3339),
|
|
},
|
|
{
|
|
ID: "hardcoded-lunch",
|
|
Name: "Objednávka obědů",
|
|
URL: "http://ppc-app/pwkweb2/",
|
|
Description: "Portál pro objednávku a přehled firemních obědů",
|
|
Icon: "fa-utensils",
|
|
CreatedAt: time.Now().Format(time.RFC3339),
|
|
UpdatedAt: time.Now().Format(time.RFC3339),
|
|
},
|
|
{
|
|
ID: "hardcoded-osticket",
|
|
Name: "OSTicket",
|
|
URL: "http://osticket/",
|
|
Description: "Systém technické podpory a hlášení problémů",
|
|
Icon: "fa-headset",
|
|
CreatedAt: time.Now().Format(time.RFC3339),
|
|
UpdatedAt: time.Now().Format(time.RFC3339),
|
|
},
|
|
{
|
|
ID: "hardcoded-kanboard",
|
|
Name: "Kanboard",
|
|
URL: "http://kanboard/",
|
|
Description: "Správa úkolů a projektů v přehledném kanban stylu",
|
|
Icon: "fa-tasks",
|
|
CreatedAt: time.Now().Format(time.RFC3339),
|
|
UpdatedAt: time.Now().Format(time.RFC3339),
|
|
},
|
|
}
|
|
|
|
// Combine hardcoded and dynamic apps
|
|
allApps := append(hardcodedApps, apps...)
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if err := json.NewEncoder(w).Encode(allApps); err != nil {
|
|
log.Printf("Error encoding apps to JSON: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
func GetAppHandler(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
appID := vars["id"]
|
|
|
|
// Check if it's a hardcoded app
|
|
if strings.HasPrefix(appID, "hardcoded-") {
|
|
// Return 404 for non-existent hardcoded apps
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
// Load apps from file
|
|
apps, err := loadApps()
|
|
if err != nil {
|
|
log.Printf("Error loading apps: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Find the app by ID
|
|
var foundApp *App
|
|
for i, app := range apps {
|
|
if app.ID == appID {
|
|
foundApp = &apps[i]
|
|
break
|
|
}
|
|
}
|
|
|
|
if foundApp == nil {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if err := json.NewEncoder(w).Encode(foundApp); err != nil {
|
|
log.Printf("Error encoding app to JSON: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
func CreateAppHandler(w http.ResponseWriter, r *http.Request) {
|
|
// Parse form data
|
|
if err := r.ParseMultipartForm(10 << 20); err != nil { // 10 MB max file size
|
|
http.Error(w, "Error parsing form data", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Get form values
|
|
name := r.FormValue("name")
|
|
url := r.FormValue("url")
|
|
description := r.FormValue("description")
|
|
|
|
// Validate required fields
|
|
if name == "" || url == "" {
|
|
http.Error(w, "Name and URL are required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Handle file upload
|
|
var iconPath string
|
|
file, handler, err := r.FormFile("icon")
|
|
if err == nil {
|
|
defer file.Close()
|
|
|
|
// Create uploads directory if it doesn't exist
|
|
if err := os.MkdirAll("uploads", 0755); err != nil {
|
|
log.Printf("Error creating uploads directory: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Generate a unique filename with original extension
|
|
ext := filepath.Ext(handler.Filename)
|
|
iconPath = fmt.Sprintf("icon_%d%s", time.Now().UnixNano(), ext)
|
|
|
|
// Create the file
|
|
f, err := os.Create(filepath.Join("uploads", iconPath))
|
|
if err != nil {
|
|
log.Printf("Error creating file: %v", err)
|
|
http.Error(w, "Error saving file", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer f.Close()
|
|
|
|
// Copy the uploaded file to the created file
|
|
if _, err = io.Copy(f, file); err != nil {
|
|
log.Printf("Error copying file: %v", err)
|
|
http.Error(w, "Error saving file", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
} else if err != http.ErrMissingFile {
|
|
log.Printf("Error getting uploaded file: %v", err)
|
|
http.Error(w, "Error processing file upload", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Create a new app
|
|
app := App{
|
|
ID: fmt.Sprintf("%d", time.Now().UnixNano()),
|
|
Name: strings.TrimSpace(name),
|
|
URL: strings.TrimSpace(url),
|
|
Description: strings.TrimSpace(description),
|
|
Icon: iconPath,
|
|
CreatedAt: time.Now().Format(time.RFC3339),
|
|
UpdatedAt: time.Now().Format(time.RFC3339),
|
|
}
|
|
|
|
// Load existing apps
|
|
apps, err := loadApps()
|
|
if err != nil {
|
|
log.Printf("Error loading apps: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Add the new app to the list
|
|
apps = append(apps, app)
|
|
|
|
// Save the updated list of apps
|
|
if err := saveApps(apps); err != nil {
|
|
log.Printf("Error saving apps: %v", err)
|
|
// Try to clean up the uploaded file if saving failed
|
|
if iconPath != "" {
|
|
if err := os.Remove(filepath.Join("uploads", iconPath)); err != nil {
|
|
log.Printf("Error cleaning up icon file: %v", err)
|
|
}
|
|
}
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusCreated)
|
|
if err := json.NewEncoder(w).Encode(app); err != nil {
|
|
log.Printf("Error encoding app to JSON: %v", err)
|
|
}
|
|
}
|
|
|
|
func UpdateAppHandler(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
appID := vars["id"]
|
|
|
|
// Prevent updating hardcoded apps
|
|
if strings.HasPrefix(appID, "hardcoded-") {
|
|
http.Error(w, "Cannot update hardcoded app", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
// Parse form data
|
|
if err := r.ParseMultipartForm(10 << 20); err != nil { // 10 MB max file size
|
|
http.Error(w, "Error parsing form data", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Load existing apps
|
|
apps, err := loadApps()
|
|
if err != nil {
|
|
log.Printf("Error loading apps: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Find the app to update
|
|
var appIndex = -1
|
|
var existingApp *App
|
|
for i := range apps {
|
|
if apps[i].ID == appID {
|
|
appIndex = i
|
|
existingApp = &apps[i]
|
|
break
|
|
}
|
|
}
|
|
|
|
if appIndex == -1 {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
// Get form values
|
|
name := r.FormValue("name")
|
|
url := r.FormValue("url")
|
|
description := r.FormValue("description")
|
|
|
|
// Handle file upload if a new file is provided
|
|
var iconPath string
|
|
file, handler, err := r.FormFile("icon")
|
|
if err == nil {
|
|
defer file.Close()
|
|
|
|
// Create uploads directory if it doesn't exist
|
|
if err := os.MkdirAll("uploads", 0755); err != nil {
|
|
log.Printf("Error creating uploads directory: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Generate a unique filename
|
|
ext := filepath.Ext(handler.Filename)
|
|
iconPath = fmt.Sprintf("icon_%d%s", time.Now().UnixNano(), ext)
|
|
|
|
// Create the file
|
|
f, err := os.Create(filepath.Join("uploads", iconPath))
|
|
if err != nil {
|
|
log.Printf("Error creating file: %v", err)
|
|
http.Error(w, "Error saving file", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer f.Close()
|
|
|
|
// Copy the uploaded file to the created file
|
|
if _, err = io.Copy(f, file); err != nil {
|
|
log.Printf("Error copying file: %v", err)
|
|
http.Error(w, "Error saving file", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Remove old icon file if it exists and is not used by other apps
|
|
if existingApp.Icon != "" {
|
|
oldIconPath := filepath.Join("uploads", existingApp.Icon)
|
|
if _, err := os.Stat(oldIconPath); err == nil {
|
|
// Check if any other app is using this icon
|
|
iconInUse := false
|
|
for _, a := range apps {
|
|
if a.ID != appID && a.Icon == existingApp.Icon {
|
|
iconInUse = true
|
|
break
|
|
}
|
|
}
|
|
|
|
// Delete the old icon if not in use
|
|
if !iconInUse {
|
|
if err := os.Remove(oldIconPath); err != nil {
|
|
log.Printf("Error removing old icon: %v", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if err != http.ErrMissingFile {
|
|
log.Printf("Error getting uploaded file: %v", err)
|
|
http.Error(w, "Error processing file upload", http.StatusBadRequest)
|
|
return
|
|
} else {
|
|
// Keep the existing icon if no new file was uploaded
|
|
iconPath = existingApp.Icon
|
|
}
|
|
|
|
// Update the app
|
|
updatedApp := App{
|
|
ID: appID,
|
|
Name: name,
|
|
URL: url,
|
|
Description: description,
|
|
Icon: iconPath,
|
|
CreatedAt: existingApp.CreatedAt, // Keep the original creation time
|
|
UpdatedAt: time.Now().Format(time.RFC3339),
|
|
}
|
|
|
|
// Update the app in the slice
|
|
apps[appIndex] = updatedApp
|
|
|
|
// Save the updated apps
|
|
if err := saveApps(apps); err != nil {
|
|
log.Printf("Error saving apps: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if err := json.NewEncoder(w).Encode(updatedApp); err != nil {
|
|
log.Printf("Error encoding app to JSON: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
func DeleteAppHandler(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
appID := vars["id"]
|
|
|
|
// Prevent deleting hardcoded apps
|
|
if strings.HasPrefix(appID, "hardcoded-") {
|
|
http.Error(w, "Cannot delete hardcoded app", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
// Load existing apps
|
|
apps, err := loadApps()
|
|
if err != nil {
|
|
log.Printf("Error loading apps: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Find the app to delete
|
|
var appIndex = -1
|
|
var iconToDelete string
|
|
for i, app := range apps {
|
|
if app.ID == appID {
|
|
appIndex = i
|
|
iconToDelete = app.Icon
|
|
break
|
|
}
|
|
}
|
|
|
|
if appIndex == -1 {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
// Remove the app from the slice
|
|
updatedApps := append(apps[:appIndex], apps[appIndex+1:]...)
|
|
|
|
// Save the updated apps
|
|
if err := saveApps(updatedApps); err != nil {
|
|
log.Printf("Error saving apps: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// If the app had an icon, check if it's used by any other app before deleting
|
|
if iconToDelete != "" {
|
|
// Check if any other app is using this icon
|
|
iconInUse := false
|
|
for _, app := range updatedApps {
|
|
if app.Icon == iconToDelete {
|
|
iconInUse = true
|
|
break
|
|
}
|
|
}
|
|
|
|
// Delete the icon file if it's not in use
|
|
if !iconInUse {
|
|
iconPath := filepath.Join("uploads", iconToDelete)
|
|
if _, err := os.Stat(iconPath); err == nil {
|
|
if err := os.Remove(iconPath); err != nil {
|
|
log.Printf("Error deleting icon file: %v", err)
|
|
// Continue even if we can't delete the file
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func handleSubmit(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
if r.Method != http.MethodPost {
|
|
if r.Method == http.MethodOptions {
|
|
w.WriteHeader(http.StatusOK)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusMethodNotAllowed)
|
|
w.Write([]byte(`{"error":"Only POST method is allowed"}`))
|
|
return
|
|
}
|
|
|
|
body, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
log.Printf("Chyba při čtení těla požadavku: %v", err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte(`{"error":"Failed to read request body"}`))
|
|
return
|
|
}
|
|
defer r.Body.Close()
|
|
|
|
log.Printf("Přijatá data: %s", string(body))
|
|
|
|
var entry TripEntry
|
|
err = json.Unmarshal(body, &entry)
|
|
if err != nil {
|
|
log.Printf("Chyba při parsování JSON: %v", err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte(fmt.Sprintf(`{"error":"Failed to parse JSON: %v"}`, err)))
|
|
return
|
|
}
|
|
|
|
if entry.Name == "" || entry.Destination == "" || entry.DateStart == "" || entry.DateEnd == "" || entry.Purpose == "" {
|
|
log.Printf("Chybějící povinná pole: %+v", entry)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte(`{"error":"Missing required fields"}`))
|
|
return
|
|
}
|
|
|
|
if entry.KmEnd < entry.KmStart {
|
|
log.Printf("Neplatný stav tachometru: %d -> %d", entry.KmStart, entry.KmEnd)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte(`{"error":"End kilometers must be greater than or equal to start kilometers"}`))
|
|
return
|
|
}
|
|
|
|
// Formátování dat do českého formátu
|
|
czechMonths := []string{
|
|
"ledna", "února", "března", "dubna", "května", "června",
|
|
"července", "srpna", "září", "října", "listopadu", "prosince",
|
|
}
|
|
|
|
// Zpracování začátku cesty
|
|
parsedDateStart, err := time.Parse("2006-01-02", entry.DateStart)
|
|
if err != nil {
|
|
log.Printf("Chyba při parsování data začátku: %v", err)
|
|
}
|
|
|
|
// Zpracování konce cesty
|
|
parsedDateEnd, err := time.Parse("2006-01-02", entry.DateEnd)
|
|
if err != nil {
|
|
log.Printf("Chyba při parsování data konce: %v", err)
|
|
}
|
|
|
|
err = sendEmail(entry, parsedDateStart, parsedDateEnd, czechMonths)
|
|
if err != nil {
|
|
log.Printf("Chyba při odesílání emailu: %v", err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte(fmt.Sprintf(`{"error":"Failed to send email: %v"}`, err)))
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte(`{"message":"Záznam byl úspěšně uložen a email odeslán"}`))
|
|
}
|
|
|
|
func sendEmail(entry TripEntry, parsedDateStart, parsedDateEnd time.Time, czechMonths []string) error {
|
|
smtpHost := "mail.pp-kunovice.cz"
|
|
smtpPort := 465
|
|
sender := "sluzebnicek@pp-kunovice.cz"
|
|
password := "7g}qznB5bj"
|
|
recipient := "sluzebnicek@pp-kunovice.cz"
|
|
|
|
m := gomail.NewMessage()
|
|
m.SetHeader("From", sender)
|
|
m.SetHeader("To", recipient)
|
|
m.SetHeader("Subject", "Nový záznam o jízdě služebním autem")
|
|
|
|
var htmlContent strings.Builder
|
|
|
|
htmlContent.WriteString(`
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta charset="UTF-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
|
<title>Záznam o jízdě služebním autem</title>
|
|
<style>
|
|
@media only screen and (max-width: 620px) {
|
|
.container {
|
|
width: 100% !important;
|
|
padding: 10px !important;
|
|
}
|
|
.content {
|
|
padding: 15px !important;
|
|
}
|
|
.header {
|
|
padding: 15px !important;
|
|
}
|
|
.info-row {
|
|
display: block !important;
|
|
width: 100% !important;
|
|
}
|
|
.info-item {
|
|
width: 100% !important;
|
|
margin-bottom: 10px !important;
|
|
}
|
|
}
|
|
|
|
body {
|
|
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
|
|
background-color: #f0f2f5;
|
|
margin: 0;
|
|
padding: 0;
|
|
-webkit-font-smoothing: antialiased;
|
|
-moz-osx-font-smoothing: grayscale;
|
|
}
|
|
|
|
.container {
|
|
max-width: 600px;
|
|
margin: 20px auto;
|
|
background-color: #ffffff;
|
|
border-radius: 8px;
|
|
overflow: hidden;
|
|
box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
|
|
}
|
|
|
|
.header {
|
|
background-color: #004990;
|
|
color: white;
|
|
padding: 20px 25px;
|
|
text-align: center;
|
|
}
|
|
|
|
.header h1 {
|
|
margin: 0;
|
|
font-size: 24px;
|
|
font-weight: 600;
|
|
}
|
|
|
|
.content {
|
|
padding: 25px;
|
|
}
|
|
|
|
.section {
|
|
margin-bottom: 25px;
|
|
border-bottom: 1px solid #eaeaea;
|
|
padding-bottom: 15px;
|
|
}
|
|
|
|
.section:last-child {
|
|
border-bottom: none;
|
|
margin-bottom: 0;
|
|
padding-bottom: 0;
|
|
}
|
|
|
|
.section-title {
|
|
font-size: 18px;
|
|
color: #004990;
|
|
margin-bottom: 15px;
|
|
font-weight: 600;
|
|
}
|
|
|
|
.info-row {
|
|
display: flex;
|
|
flex-wrap: wrap;
|
|
margin-bottom: 10px;
|
|
}
|
|
|
|
.info-item {
|
|
width: 48%;
|
|
margin-bottom: 15px;
|
|
}
|
|
|
|
.label {
|
|
font-weight: 600;
|
|
color: #555;
|
|
font-size: 14px;
|
|
display: block;
|
|
margin-bottom: 5px;
|
|
}
|
|
|
|
.value {
|
|
color: #333;
|
|
font-size: 16px;
|
|
}
|
|
|
|
.highlight {
|
|
background-color: #f8f9fa;
|
|
border-left: 3px solid #0072b0;
|
|
padding: 10px 15px;
|
|
margin: 15px 0;
|
|
}
|
|
|
|
.map-link {
|
|
display: inline-block;
|
|
margin-top: 10px;
|
|
color: #0072b0;
|
|
text-decoration: none;
|
|
font-weight: 500;
|
|
}
|
|
|
|
.map-link:hover {
|
|
text-decoration: underline;
|
|
}
|
|
|
|
.footer {
|
|
text-align: center;
|
|
padding: 15px;
|
|
font-size: 12px;
|
|
color: #777;
|
|
background-color: #f8f9fa;
|
|
}
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div class="container">
|
|
<div class="header">
|
|
<h1>Záznam o jízdě služebním autem</h1>
|
|
</div>
|
|
<div class="content">
|
|
`)
|
|
|
|
// Formátování dat a časů pro zobrazení
|
|
formattedDateStart := ""
|
|
if parsedDateStart.IsZero() == false {
|
|
monthNameStart := czechMonths[parsedDateStart.Month()-1]
|
|
formattedDateStart = fmt.Sprintf("%d. %s %d", parsedDateStart.Day(), monthNameStart, parsedDateStart.Year())
|
|
} else {
|
|
formattedDateStart = entry.DateStart
|
|
}
|
|
|
|
formattedDateEnd := ""
|
|
if !parsedDateEnd.IsZero() {
|
|
monthNameEnd := czechMonths[parsedDateEnd.Month()-1]
|
|
formattedDateEnd = fmt.Sprintf("%d. %s %d", parsedDateEnd.Day(), monthNameEnd, parsedDateEnd.Year())
|
|
} else {
|
|
formattedDateEnd = entry.DateEnd
|
|
}
|
|
|
|
// Výpočet celkové doby jízdy
|
|
startDateTime, startErr := time.Parse("2006-01-02T15:04", fmt.Sprintf("%sT%s", entry.DateStart, entry.TimeStart))
|
|
endDateTime, endErr := time.Parse("2006-01-02T15:04", fmt.Sprintf("%sT%s", entry.DateEnd, entry.TimeEnd))
|
|
|
|
totalDurationStr := "Neznámá"
|
|
if startErr == nil && endErr == nil {
|
|
diffMs := endDateTime.Sub(startDateTime)
|
|
if diffMs >= 0 {
|
|
diffDays := int(diffMs.Hours() / 24)
|
|
diffHours := int(diffMs.Hours()) % 24
|
|
diffMinutes := int(diffMs.Minutes()) % 60
|
|
|
|
if diffDays > 0 {
|
|
dayWord := "dní"
|
|
if diffDays == 1 {
|
|
dayWord = "den"
|
|
} else if diffDays >= 2 && diffDays <= 4 {
|
|
dayWord = "dny"
|
|
}
|
|
totalDurationStr = fmt.Sprintf("%d %s, %d h %d min", diffDays, dayWord, diffHours, diffMinutes)
|
|
} else {
|
|
totalDurationStr = fmt.Sprintf("%d h %d min", diffHours, diffMinutes)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Vypsání informací o řidiči a vozidle
|
|
htmlContent.WriteString(`<div class="section">
|
|
<div class="section-title">Informace o řidiči a vozidle</div>
|
|
<div class="info-row">
|
|
<div class="info-item">
|
|
<span class="label">Řidič</span>
|
|
<span class="value">` + entry.Name + `</span>
|
|
</div>
|
|
<div class="info-item">
|
|
<span class="label">Vozidlo</span>
|
|
<span class="value">` + entry.Vehicle + `</span>
|
|
</div>
|
|
</div>
|
|
</div>`)
|
|
|
|
// Vypsání informací o trase
|
|
htmlContent.WriteString(`<div class="section">
|
|
<div class="section-title">Informace o trase</div>
|
|
<div class="info-row">
|
|
<div class="info-item">
|
|
<span class="label">Cíl cesty</span>
|
|
<span class="value">` + entry.Destination + `</span>
|
|
</div>
|
|
<div class="info-item">
|
|
<span class="label">Účel jízdy</span>
|
|
<span class="value">` + entry.Purpose + `</span>
|
|
</div>
|
|
</div>
|
|
</div>`)
|
|
|
|
// Vypsání informací o času
|
|
htmlContent.WriteString(`<div class="section">
|
|
<div class="section-title">Časové údaje</div>
|
|
<div class="info-row">
|
|
<div class="info-item">
|
|
<span class="label">Datum a čas odjezdu</span>
|
|
<span class="value">` + formattedDateStart + `, ` + entry.TimeStart + `</span>
|
|
</div>
|
|
<div class="info-item">
|
|
<span class="label">Datum a čas příjezdu</span>
|
|
<span class="value">` + formattedDateEnd + `, ` + entry.TimeEnd + `</span>
|
|
</div>
|
|
</div>
|
|
<div class="highlight">
|
|
<span class="label">Celková doba jízdy</span>
|
|
<span class="value">` + totalDurationStr + `</span>
|
|
</div>
|
|
</div>`)
|
|
|
|
// Vypsání informací o kilometrech
|
|
htmlContent.WriteString(`<div class="section">
|
|
<div class="section-title">Stav tachometru</div>
|
|
<div class="info-row">
|
|
<div class="info-item">
|
|
<span class="label">Stav na začátku</span>
|
|
<span class="value">` + fmt.Sprintf("%d km", entry.KmStart) + `</span>
|
|
</div>
|
|
<div class="info-item">
|
|
<span class="label">Stav na konci</span>
|
|
<span class="value">` + fmt.Sprintf("%d km", entry.KmEnd) + `</span>
|
|
</div>
|
|
</div>
|
|
<div class="highlight">
|
|
<span class="label">Celkem ujeto</span>
|
|
<span class="value">` + fmt.Sprintf("%d km", entry.KmEnd-entry.KmStart) + `</span>
|
|
</div>
|
|
</div>`)
|
|
|
|
if entry.Coordinates != nil {
|
|
htmlContent.WriteString(`<div class="section">
|
|
<div class="section-title">GPS Souřadnice</div>
|
|
<div class="info-row">
|
|
<div class="info-item">
|
|
<span class="label">Souřadnice</span>
|
|
<span class="value">` + entry.Coordinates.Lat + `, ` + entry.Coordinates.Lng + `</span>
|
|
</div>
|
|
</div>
|
|
<a href="https://mapy.cz/zakladni?x=` + entry.Coordinates.Lng + `&y=` + entry.Coordinates.Lat + `&z=15" target="_blank" class="map-link">
|
|
<i class="fas fa-map-marker-alt"></i> Zobrazit na mapě
|
|
</a>
|
|
</div>`)
|
|
}
|
|
|
|
htmlContent.WriteString(`
|
|
</div>
|
|
<div class="footer">
|
|
© 2025 Poppe + Potthoff - Automaticky generovaný email
|
|
</div>
|
|
</div>
|
|
</body>
|
|
</html>
|
|
`)
|
|
|
|
m.SetBody("text/html", htmlContent.String())
|
|
|
|
d := gomail.NewDialer(smtpHost, smtpPort, sender, password)
|
|
d.TLSConfig = &tls.Config{InsecureSkipVerify: true}
|
|
|
|
return d.DialAndSend(m)
|
|
}
|