.env

@@ -1,4 +1,3 @@
-LOGLEVEL=debug
 PORT=3000
 PRODUCION=false
 APIKEY=lfk

handlers/barcode.go

@@ -20,8 +20,6 @@ import (
 //	@Router			/v1/barcodes/{type}/{content} [get]
 func (h *DefaultHandler) GenerateBarcode(c *fiber.Ctx) error {
 
-	logger := h.Logger.Named("GenerateBarcode")
-
 	// Get the type and content from the URL
 	barcodeType := c.Params("type")
 	barcodeContent := c.Params("content")
@@ -34,7 +32,6 @@ func (h *DefaultHandler) GenerateBarcode(c *fiber.Ctx) error {
 	// Convert width and height to integers
 	width, err := strconv.Atoi(widthStr)
 	if err != nil {
-		logger.Errorw("Invalid width parameter", "width", widthStr, "error", err)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": "Invalid width parameter",
 		})
@@ -42,7 +39,6 @@ func (h *DefaultHandler) GenerateBarcode(c *fiber.Ctx) error {
 
 	height, err := strconv.Atoi(heightStr)
 	if err != nil {
-		logger.Errorw("Invalid height parameter", "height", heightStr, "error", err)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": "Invalid height parameter",
 		})
@@ -50,23 +46,18 @@ func (h *DefaultHandler) GenerateBarcode(c *fiber.Ctx) error {
 
 	padding, err := strconv.Atoi(paddingStr)
 	if err != nil {
-		logger.Errorw("Invalid padding parameter", "padding", paddingStr, "error", err)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": "Invalid padding parameter",
 		})
 	}
-	logger = logger.With("type", barcodeType, "content", barcodeContent, "width", width, "height", height, "padding", padding)
 
 	// Generate the barcode
-	logger.Info("Generating barcode")
 	barcode, err := h.BarcodeService.GenerateBarcode(barcodeType, barcodeContent, width, height, padding)
 	if err != nil {
-		logger.Errorw("Failed to generate barcode", "error", err)
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
-	logger.Info("Barcode generated")
 
 	c.Set(fiber.HeaderContentType, "image/png")
 	return c.Send(barcode.Bytes())

handlers/card.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"log"
 	"slices"
 
 	"git.odit.services/lfk/document-server/models"
@@ -18,35 +19,27 @@ import (
 //	@Security		ApiKeyAuth
 //	@Router			/v1/pdfs/cards [post]
 func (h *DefaultHandler) GenerateCard(c *fiber.Ctx) error {
-
-	logger := h.Logger.Named("GenerateCard")
-
 	cardRequest := new(models.CardRequest)
 	if err := c.BodyParser(cardRequest); err != nil {
-		logger.Errorw("Invalid request", "error", err)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
 	if !slices.Contains([]string{"en", "de"}, cardRequest.Locale) {
-		logger.Errorw("Invalid locale", "locale", cardRequest.Locale)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": "Invalid locale",
 		})
 	}
 
-	logger = logger.With("locale", cardRequest.Locale)
-
 	templateString, err := h.StaticService.GetTemplate(cardRequest.Locale, "card")
 	if err != nil {
-		logger.Errorw("Template not found", "error", err)
+		log.Println(err)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": "Template not found",
 		})
 	}
 	template, err := h.Templater.StringToTemplate(templateString)
 	if err != nil {
-		logger.Errorw("Error parsing template", "error", err)
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
@@ -60,26 +53,20 @@ func (h *DefaultHandler) GenerateCard(c *fiber.Ctx) error {
 		BarcodePrefix: h.Config.CardBarcodePrefix,
 	}
 
-	logger.Info("Generating card html")
 	result, err := h.Templater.Execute(template, genConfig)
 	if err != nil {
-		logger.Errorw("Error executing template", "error", err)
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
-	logger.Info("Generated card html")
 	c.Set(fiber.HeaderContentType, "text/html")
 
-	logger.Info("Converting html to pdf")
 	pdf, err := h.Converter.ToPdf(result, "a4", false)
 	if err != nil {
-		logger.Errorw("Error converting html to pdf", "error", err)
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
-	logger.Info("Converted html to pdf")
 
 	c.Set(fiber.HeaderContentType, "application/pdf")
 	c.Set(fiber.HeaderContentDisposition, "attachment; filename=runner-cards.pdf")

handlers/certificate.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"log"
 	"slices"
 
 	"git.odit.services/lfk/document-server/models"
@@ -18,35 +19,27 @@ import (
 //	@Security		ApiKeyAuth
 //	@Router			/v1/pdfs/certificates [post]
 func (h *DefaultHandler) GenerateCertificate(c *fiber.Ctx) error {
-
-	logger := h.Logger.Named("GenerateCertificate")
-
 	certificateRequest := new(models.CertificateRequest)
 	if err := c.BodyParser(certificateRequest); err != nil {
-		logger.Errorw("Invalid request", "error", err)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
 	if !slices.Contains([]string{"en", "de"}, certificateRequest.Locale) {
-		logger.Errorw("Invalid locale", "locale", certificateRequest.Locale)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": "Invalid locale",
 		})
 	}
 
-	logger = logger.With("locale", certificateRequest.Locale)
-
 	templateString, err := h.StaticService.GetTemplate(certificateRequest.Locale, "certificate")
 	if err != nil {
-		logger.Errorw("Template not found", "error", err)
+		log.Println(err)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": "Template not found",
 		})
 	}
 	template, err := h.Templater.StringToTemplate(templateString)
 	if err != nil {
-		logger.Errorw("Error parsing template", "error", err)
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
@@ -60,24 +53,20 @@ func (h *DefaultHandler) GenerateCertificate(c *fiber.Ctx) error {
 		Locale:         certificateRequest.Locale,
 	}
 
-	logger.Info("Generating certificate html")
 	result, err := h.Templater.Execute(template, genConfig)
 	if err != nil {
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
-	logger.Info("Generated card html")
 	c.Set(fiber.HeaderContentType, "text/html")
 
-	logger.Info("Converting html to pdf")
 	pdf, err := h.Converter.ToPdf(result, "a4", false)
 	if err != nil {
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
-	logger.Info("Converted html to pdf")
 
 	c.Set(fiber.HeaderContentType, "application/pdf")
 	c.Set(fiber.HeaderContentDisposition, "attachment; filename=certificate.pdf")

handlers/contract.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"log"
 	"slices"
 
 	"git.odit.services/lfk/document-server/models"
@@ -18,42 +19,36 @@ import (
 //	@Security		ApiKeyAuth
 //	@Router			/v1/pdfs/contracts [post]
 func (h *DefaultHandler) GenerateContract(c *fiber.Ctx) error {
-
-	logger := h.Logger.Named("GenerateContract")
-
 	contract := new(models.ContractRequest)
 	if err := c.BodyParser(contract); err != nil {
-		logger.Errorw("Invalid request", "error", err)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
 	if !slices.Contains([]string{"en", "de"}, contract.Locale) {
-		logger.Errorw("Invalid locale", "locale", contract.Locale)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": "Invalid locale",
 		})
 	}
 
-	logger = logger.With("locale", contract.Locale)
+	contract.Runners = repeatRunnerArrayItems(contract.Runners, 2)
 
 	templateString, err := h.StaticService.GetTemplate(contract.Locale, "contract")
 	if err != nil {
-		logger.Errorw("Template not found", "error", err)
+		log.Println(err)
 		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"error": "Template not found",
 		})
 	}
 	template, err := h.Templater.StringToTemplate(templateString)
 	if err != nil {
-		logger.Errorw("Error parsing template", "error", err)
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
 
 	genConfig := &models.ContractTemplateOptions{
-		Runners:              repeatRunnerArrayItems(contract.Runners, 2),
+		Runners:              contract.Runners,
 		CurrencySymbol:       h.Config.CurrencySymbol,
 		Disclaimer:           h.Config.SponosringDisclaimer,
 		ReceiptMinimumAmount: h.Config.SponsoringReceiptMinimum,
@@ -62,23 +57,19 @@ func (h *DefaultHandler) GenerateContract(c *fiber.Ctx) error {
 		BarcodePrefix:        h.Config.SponsoringBarcodePrefix,
 	}
 
-	logger.Info("Generating contract html")
 	result, err := h.Templater.Execute(template, genConfig)
 	if err != nil {
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
-	logger.Info("Generated contract html")
 
-	logger.Info("Converting html to pdf")
 	pdf, err := h.Converter.ToPdf(result, "a5", true)
 	if err != nil {
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
-	logger.Info("Converted html to pdf")
 
 	c.Set(fiber.HeaderContentType, "application/pdf")
 	c.Set(fiber.HeaderContentDisposition, "attachment; filename=runner-contracts.pdf")

handlers/handlers.go

@@ -4,7 +4,6 @@ import (
 	"git.odit.services/lfk/document-server/models"
 	"git.odit.services/lfk/document-server/services"
 	"github.com/gofiber/fiber/v2"
-	"go.uber.org/zap"
 )
 
 type Handler interface {
@@ -20,5 +19,4 @@ type DefaultHandler struct {
 	Templater      services.Templater
 	Converter      services.Converter
 	StaticService  services.StaticService
-	Logger         *zap.SugaredLogger
 }

main.go

@@ -3,8 +3,6 @@ package main
 import (
 	"crypto/sha256"
 	"crypto/subtle"
-	"os"
-	"strings"
 
 	"git.odit.services/lfk/document-server/docs" // Correct import path for docs
 	"git.odit.services/lfk/document-server/handlers"
@@ -18,7 +16,6 @@ import (
 	"github.com/redis/go-redis/v9"
 	"github.com/spf13/viper"
 	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
 )
 
 var (
@@ -38,8 +35,7 @@ func validateAPIKey(c *fiber.Ctx, key string) (bool, error) {
 
 func loadEnv() error {
 
-	viper.SetDefault("LOGLEVEL", "INFO")
+	viper.SetDefault("PRODUCION", true)
-	viper.SetDefault("PRODUCION", false)
 	viper.SetDefault("PORT", "3000")
 	viper.SetDefault("APIKEY", "lfk")
 	viper.SetDefault("EVENTNAME", "Demo Event")
@@ -71,34 +67,7 @@ func loadEnv() error {
 		return err
 	}
 
-	logger.Infow("Loaded config", "config", &config)
+	logger.Infow("Loaded config", config)
-
-	return nil
-}
-
-func initLogger() error {
-	logLevel := os.Getenv("LOGLEVEL")
-	if logLevel == "" {
-		logLevel = "INFO"
-	}
-
-	var zapLogLevel zapcore.Level
-	err := zapLogLevel.UnmarshalText([]byte(strings.ToLower(logLevel)))
-	if err != nil {
-		zapLogLevel = zapcore.InfoLevel
-	}
-
-	zapConfig := zap.NewProductionConfig()
-	zapConfig.Level = zap.NewAtomicLevelAt(zapLogLevel)
-	zapLogger, err := zapConfig.Build()
-	if err != nil {
-		return err
-	}
-
-	defer zapLogger.Sync()
-	logger = zapLogger.Sugar()
-
-	logger.Debug("Initialized logger")
 
 	return nil
 }
@@ -116,12 +85,12 @@ func initLogger() error {
 func main() {
 
 	// Init the logger
-	err := initLogger()
+	zapLogger, _ := zap.NewProduction()
-	if err != nil {
+	defer zapLogger.Sync()
-		return
+	logger = zapLogger.Sugar()
-	}
+	logger.Info("Logger initialized")
 
-	err = loadEnv()
+	err := loadEnv()
 	if err != nil {
 		logger.Error(err)
 		return
@@ -129,7 +98,7 @@ func main() {
 
 	var redisClient *redis.Client
 	if config.RedisAddr != "" {
-		logger.Infow("Using redis", "redisAddr", config.RedisAddr)
+		logger.Infow("Using redis", config.RedisAddr)
 		redisClient = redis.NewClient(&redis.Options{
 			Addr: config.RedisAddr,
 		})
@@ -152,9 +121,7 @@ func main() {
 		Converter: &services.GotenbergConverter{
 			BaseUrl: config.GotenbergBaseUrl,
 		},
-		Logger: logger,
 	}
-	logger.Debug("Initialized services")
 
 	// Create a new Fiber instance
 	app := fiber.New(fiber.Config{
@@ -180,11 +147,9 @@ func main() {
 	pdfv1.Post("/certificates", handler.GenerateCertificate)
 
 	v1.Get("/barcodes/:type/:content", handler.GenerateBarcode)
-	logger.Debug("Initialized routes")
 
 	app.Use(handler.NotFoundHandler)
 	docs.SwaggerInfo.BasePath = "/"
 
-	logger.Infow("Starting server", "port", config.Port)
 	logger.Error(app.Listen("0.0.0.0:" + config.Port))
 }

models/config.go

@@ -1,7 +1,6 @@
 package models
 
 type Config struct {
-	LogLevel                 string `mapstructure:"LOGLEVEL"`
 	Prod                     bool   `mapstructure:"PRODUCION"`
 	Port                     string `mapstructure:"PORT"`
 	APIKey                   string `mapstructure:"APIKEY"`