refactor internal; add more loggers

cmd/ksef/commands/generate.go

@@ -37,16 +37,31 @@ func init() {
 
 	GenerateCmd.FlagSet.StringVar(&generateArgs.FileName, "f", "", "nazwa pliku do przetworzenia")
 	GenerateCmd.FlagSet.StringVar(&generateArgs.Output, "o", "", "nazwa katalogu wyjściowego")
-	GenerateCmd.FlagSet.StringVar(&generateArgs.Delimiter, "d", ",", "łańcuch znaków rozdzielający pola (tylko dla CSV)")
-	GenerateCmd.FlagSet.StringVar(&generateArgs.SheetName, "s", "", "Nazwa skoroszytu do przetworzenia (tylko dla XLSX)")
+	GenerateCmd.FlagSet.StringVar(
+		&generateArgs.Delimiter,
+		"d",
+		",",
+		"łańcuch znaków rozdzielający pola (tylko dla CSV)",
+	)
+	GenerateCmd.FlagSet.StringVar(
+		&generateArgs.SheetName,
+		"s",
+		"",
+		"Nazwa skoroszytu do przetworzenia (tylko dla XLSX)",
+	)
 	GenerateCmd.FlagSet.StringVar(&generateArgs.GeneratorName, "g", "fa-2", "nazwa generatora")
-	GenerateCmd.FlagSet.StringVar(&generateArgs.EncodingConversionFile, "e", "", "użyj pliku z konwersją znaków (tylko dla CSV)")
+	GenerateCmd.FlagSet.StringVar(
+		&generateArgs.EncodingConversionFile,
+		"e",
+		"",
+		"użyj pliku z konwersją znaków (tylko dla CSV)",
+	)
 
 	registerCommand(&GenerateCmd.Command)
 }
 
 func generateRun(c *Command) error {
-	logging.GenerateLogger.Debug("generate")
+	logging.GenerateLogger.Info("generate")
 	if generateArgs.FileName == "" || generateArgs.Output == "" {
 		GenerateCmd.FlagSet.Usage()
 		return nil

cmd/ksef/commands/payment-id.go

@@ -39,11 +39,36 @@ func init() {
 		},
 	}
 
-	GeneratePaymentIdCommand.FlagSet.StringVar(&generatePaymentIdArgs.path, "p", "", "ścieżka do pliku rejestru")
-	GeneratePaymentIdCommand.FlagSet.StringVar(&generatePaymentIdArgs.output, "o", "", "Plik do zapisania wyjścia")
-	GeneratePaymentIdCommand.FlagSet.BoolVar(&generatePaymentIdArgs.yaml, "yaml", false, "Użyj formatu YAML do zapisania wyjścia")
-	GeneratePaymentIdCommand.FlagSet.BoolVar(&generatePaymentIdArgs.json, "json", false, "Użyj formatu JSON do zapisania wyjścia")
-	GeneratePaymentIdCommand.FlagSet.StringVar(&generatePaymentIdArgs.issuerToken, "token", "", "Token sesji interaktywnej lub nazwa zmiennej środowiskowej która go zawiera")
+	GeneratePaymentIdCommand.FlagSet.StringVar(
+		&generatePaymentIdArgs.path,
+		"p",
+		"",
+		"ścieżka do pliku rejestru",
+	)
+	GeneratePaymentIdCommand.FlagSet.StringVar(
+		&generatePaymentIdArgs.output,
+		"o",
+		"",
+		"Plik do zapisania wyjścia",
+	)
+	GeneratePaymentIdCommand.FlagSet.BoolVar(
+		&generatePaymentIdArgs.yaml,
+		"yaml",
+		false,
+		"Użyj formatu YAML do zapisania wyjścia",
+	)
+	GeneratePaymentIdCommand.FlagSet.BoolVar(
+		&generatePaymentIdArgs.json,
+		"json",
+		false,
+		"Użyj formatu JSON do zapisania wyjścia",
+	)
+	GeneratePaymentIdCommand.FlagSet.StringVar(
+		&generatePaymentIdArgs.issuerToken,
+		"token",
+		"",
+		"Token sesji interaktywnej lub nazwa zmiennej środowiskowej która go zawiera",
+	)
 
 	registerCommand(&GeneratePaymentIdCommand.Command)
 }
@@ -100,7 +125,9 @@ func generatePaymentIdRun(c *Command) error {
 
 	// we are in the generation mode.
 	if len(invoiceIds) < 2 {
-		return fmt.Errorf("stworzenie identyfikatora płatności wymaga co najmniej dwóch numerów faktur")
+		return fmt.Errorf(
+			"stworzenie identyfikatora płatności wymaga co najmniej dwóch numerów faktur",
+		)
 	}
 
 	seiRefNumbers, err := _registry.GetSEIRefNoFromArray(invoiceIds)
@@ -119,7 +146,7 @@ func generatePaymentIdRun(c *Command) error {
 		session.SetIssuerToken(generatePaymentIdArgs.issuerToken)
 	}
 
-	if err = session.Login(_registry.Issuer); err != nil {
+	if err = session.Login(_registry.Issuer, true); err != nil {
 		return fmt.Errorf("błąd logowania do KSeF: %v", err)
 	}
 

cmd/ksef/main.go

@@ -17,16 +17,27 @@ func main() {
 	var err error
 
 	flag.Usage = func() {
-		fmt.Printf("Użycie programu: ksef [-c] [-o] [komenda]\n\n")
+		fmt.Printf("Użycie programu: ksef [-c] [-log] [-v] [komenda]\n\n")
 		flag.PrintDefaults()
 		fmt.Printf("\nDostępne komendy:\n")
 		for _, command := range commands.Registry {
 			fmt.Printf("%-*s - %s\n", commands.MaxCommandName, command.Name, command.Description)
 		}
 	}
 
-	flag.StringVar(&loggingOutput, "log", loggingOutput, "wyjście logowania. Wartość `-` oznacza wyjście standardowe (stdout)")
+	flag.StringVar(
+		&loggingOutput,
+		"log",
+		loggingOutput,
+		"wyjście logowania. Wartość `-` oznacza wyjście standardowe (stdout)",
+	)
 	flag.StringVar(&configPath, "c", configPath, "ścieżka pliku konfiguracyjnego")
+	flag.BoolVar(
+		&logging.Verbose,
+		"v",
+		false,
+		"tryb verbose - przełącza wszystkie loggery w tryb debug",
+	)
 
 	flag.Parse()
 
@@ -51,8 +62,8 @@ func main() {
 
 	defer logging.FinishLogging()
 
-	logging.SeiLogger.Debug("start programu")
-	defer logging.SeiLogger.Debug("koniec programu")
+	logging.SeiLogger.Info("start programu")
+	defer logging.SeiLogger.Info("koniec programu")
 
 	command = commands.Registry.GetByName(args[0])
 	if command == nil {

docs/.vitepress/config.mjs

@@ -18,6 +18,13 @@ export default defineConfig({
           { text: 'Instalacja programu', link: '/content/instalacja' },
         ]
       },
+      {
+        text: 'Konfiguracja',
+        items: [
+          {text: 'Konfiguracja', link: '/content/konfiguracja'},
+          {text: 'Komunikaty diagnostyczne', link: '/content/logowanie'},
+        ]
+      },
       {
         text: 'Komendy',
         items: [

docs/content/konfiguracja.md

@@ -0,0 +1,3 @@
+# Konfiguracja programu
+
+W chwili obecnej jedyne co można skonfigurować to poziom loggerów, ale nie wykluczam, że w przyszłości pojawią się kolejne opcje.

docs/content/logowanie.md

@@ -0,0 +1,68 @@
+# Diagnostyka / Logowanie
+
+Aby ułatwić diagnozowanie problemów z programem, przewidziałem logowanie na kilku poziomach. Oznacza to, że możesz włączyć loggery selektywnie, w zależności od tego gdzie program się wywala / działa w sposób niepożądany.
+
+## Jak włączyć logowanie
+
+Stwórz plik konfiguracyjny z poniższą składnią
+
+```yaml
+logging:
+  nazwa-loggera: poziom
+```
+
+dostępne poziomy: `info`, `debug`, `error`
+
+A następnie wywołaj program z przełącznikiem `-c`
+
+::: info
+
+```shell
+./ksef -c config.yaml -log - ...
+```
+
+:::
+
+::: warning
+Przełącznik -log jest bardzo ważny ponieważ odpowiada za przekierowanie wyjścia logów. Domyślnie jest ono wyłączone, nawet jeśli ustawisz poziomy logowania. Przykłady wywołań:
+
+przekierowanie logów do pliku
+
+```shell
+./ksef -c config.yaml -log plik-wyjscia.txt ...
+```
+
+przekierowanie logów na stdout
+
+```shell
+./ksef -c config.yaml -log - ...
+```
+
+:::
+
+## Dostępne loggery
+
+| logger           | znaczenie                                   |
+| ---------------- | ------------------------------------------- |
+| main             | główny logger programu                      |
+| interactive      | logger sesji interaktywnej                  |
+| interactive.http | logger sesji interaktywnej (zapytania HTTP) |
+| batch            | logger sesji wsadowej                       |
+| batch.http       | logger sesji wsadowej (zapytania HTTP)      |
+| download         | logger pobierania faktur                    |
+| download.http    | logger pobierania faktur (zapytania HTTP)   |
+| upload           | logger wysyłki faktur                       |
+| upload.http      | logger wysyłki faktur (zapytania HTTP)      |
+| upo              | logger pobierania UPO                       |
+| upo.http         | logger pobierania UPO (zapytania HTTP)      |
+
+## Tryb verbose
+
+Program obsługuje również tryb `verbose` (flaga `-v`) natomiast przestrzegam przed jej stosowaniem - generuje bardzo obszerne wyjście. Flaga `verbose` oznacza przełączenie wszystkich dostępnych loggerów na poziom `DEBUG` (tak, żebyś nie musiał robić tego ręcznie)
+
+::: info
+Przykład wywołania:
+
+```shell
+./ksef -v -log - ...
+```

internal/logging/loggers.go

@@ -0,0 +1,55 @@
+package logging
+
+import (
+	"io"
+	"log/slog"
+)
+
+// these are the actual loggers that the program can reference
+// initialize the default values of the loggers so that they
+// become valid slog.Logger objects and so that we can use them
+// without exploding the code
+func defaultLogger() *slog.Logger {
+	return slog.New(
+		slog.NewTextHandler(
+			io.Discard,
+			&slog.HandlerOptions{
+				Level: slog.LevelInfo,
+			},
+		),
+	)
+}
+
+var SeiLogger *slog.Logger = defaultLogger()
+var GenerateLogger *slog.Logger = defaultLogger()
+var UploadLogger *slog.Logger = defaultLogger()
+var UploadHTTPLogger *slog.Logger = defaultLogger()
+var InteractiveLogger *slog.Logger = defaultLogger()
+var InteractiveHTTPLogger *slog.Logger = defaultLogger()
+var BatchLogger *slog.Logger = defaultLogger()
+var BatchHTTPLogger *slog.Logger = defaultLogger()
+var DownloadHTTPLogger *slog.Logger = defaultLogger()
+var DownloadLogger *slog.Logger = defaultLogger()
+var UPOLogger *slog.Logger = defaultLogger()
+var UPOHTTPLogger *slog.Logger = defaultLogger()
+var ParserLogger *slog.Logger = defaultLogger()
+
+func init() {
+	// populate the helper map so that we can alter the loggers after config
+	// is read.
+	loggers = map[string]*slog.Logger{
+		"main":             SeiLogger,
+		"generate":         GenerateLogger,
+		"upload":           UploadLogger,
+		"upload.http":      UploadHTTPLogger,
+		"interactive":      InteractiveLogger,
+		"interactive.http": InteractiveHTTPLogger,
+		"batch":            BatchLogger,
+		"batch.http":       BatchHTTPLogger,
+		"download":         DownloadLogger,
+		"download.http":    DownloadHTTPLogger,
+		"upo":              UPOLogger,
+		"upo.http":         UPOHTTPLogger,
+		"parser":           ParserLogger,
+	}
+}

internal/logging/logging.go

@@ -9,10 +9,6 @@ import (
 	"os"
 )
 
-// these are the actual loggers that the program can reference
-var SeiLogger *slog.Logger
-var GenerateLogger *slog.Logger
-
 // this is a utility map that will be used when config file will be read
 // and log level can be applied. Unfortunetely there's no way to change the
 // log level and/or output at runtime therefore we have to re-initialize the
@@ -22,6 +18,7 @@ var loggers = map[string]*slog.Logger{}
 var errUnknownLogger = errors.New("Unknown logger")
 var outputWriter io.Writer
 var outputFile *os.File
+var Verbose bool = false
 
 func parseLevel(logLevel string) slog.Level {
 	switch logLevel {
@@ -39,21 +36,31 @@ func InitLogging(output string) error {
 		return nil
 	}
 
-	config := config.Config
+	var err error
 
-	if config.Logging != nil {
-		var err error
+	if output == "-" {
+		outputWriter = os.Stdout
+	} else {
+		outputFile, err = os.OpenFile(output, os.O_CREATE|os.O_RDWR, 0644)
+		if err != nil {
+			return fmt.Errorf("unable to open log file: %v", err)
+		}
+		outputWriter = outputFile
+	}
 
-		if output == "-" {
-			outputWriter = os.Stdout
-		} else {
-			outputFile, err = os.OpenFile(output, os.O_CREATE|os.O_RDWR, 0644)
-			if err != nil {
-				return fmt.Errorf("unable to open log file: %v", err)
-			}
-			outputWriter = outputFile
+	if Verbose {
+		for _, loggerPtr := range loggers {
+			var logger *slog.Logger = loggerPtr
+			*logger = *slog.New(slog.NewTextHandler(outputWriter, &slog.HandlerOptions{
+				Level: slog.LevelDebug,
+			}))
 		}
+		return nil
+	}
+
+	config := config.Config
 
+	if config.Logging != nil {
 		var logger *slog.Logger
 		var exists bool
 
@@ -74,17 +81,6 @@ func InitLogging(output string) error {
 	return nil
 }
 
-func init() {
-	// initialize some default values of the loggers so that they
-	// become valid slog.Logger objects and so that we can use them
-	// without exploding the code
-	SeiLogger = slog.Default()
-	GenerateLogger = slog.Default()
-
-	loggers["main"] = SeiLogger
-	loggers["generate"] = GenerateLogger
-}
-
 func FinishLogging() {
 	if outputFile != nil {
 		if err := outputFile.Close(); err != nil {

internal/registry/registry_download_pdf.go

@@ -18,7 +18,7 @@ type DownloadPDFArgs struct {
 	Invoice     string
 }
 
-const DownloadInvoicePDF = "https://%s/web/api/invoice/get-invoice-pdf-file?ksefReferenceNumber=%s"
+const DownloadInvoicePDF = "/web/api/invoice/get-invoice-pdf-file?ksefReferenceNumber=%s"
 
 var IsNotXMLInvoice error = errors.New("this is not an XML invoice")
 
@@ -39,11 +39,11 @@ func (r *InvoiceRegistry) DownloadPDF(apiClient *client.APIClient, args *Downloa
 		return fmt.Errorf("unable to read the source file: %v", err)
 	}
 
-	httpSession := client.NewRequestFactory(apiClient)
+	httpSession := client.NewHTTPSession(apiClient.Environment.Host)
 	invoiceXMLReader := bytes.NewReader(sourceInvoiceBytes)
 
 	return httpSession.DownloadPDFFromSourceXML(
-		fmt.Sprintf(DownloadInvoicePDF, apiClient.Environment.Host, seiRefNo),
+		fmt.Sprintf(DownloadInvoicePDF, seiRefNo),
 		seiRefNo+".xml",
 		invoiceXMLReader,
 		path.Join(args.Output, seiRefNo+".pdf"),