refactor: remove empty services (#116)

* remove empty services

* remove old factory

* remove old static files

* cleanup more duplicate service code

* file/folder reorg

backend/internal/sys/config/conf.go

@@ -0,0 +1,76 @@
+package config
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/ardanlabs/conf/v2"
+
+	"os"
+)
+
+const (
+	ModeDevelopment = "development"
+	ModeProduction  = "production"
+)
+
+type Config struct {
+	Mode              string      `yaml:"mode" conf:"default:development"` // development or production
+	Web               WebConfig   `yaml:"web"`
+	Storage           Storage     `yaml:"storage"`
+	Log               LoggerConf  `yaml:"logger"`
+	Mailer            MailerConf  `yaml:"mailer"`
+	Swagger           SwaggerConf `yaml:"swagger"`
+	Demo              bool        `yaml:"demo"`
+	AllowRegistration bool        `yaml:"disable_registration" conf:"default:true"`
+	Debug             DebugConf   `yaml:"debug"`
+}
+
+type DebugConf struct {
+	Enabled bool   `yaml:"enabled" conf:"default:false"`
+	Port    string `yaml:"port" conf:"default:4000"`
+}
+
+type SwaggerConf struct {
+	Host   string `yaml:"host" conf:"default:localhost:7745"`
+	Scheme string `yaml:"scheme" conf:"default:http"`
+}
+
+type WebConfig struct {
+	Port          string `yaml:"port" conf:"default:7745"`
+	Host          string `yaml:"host"`
+	MaxUploadSize int64  `yaml:"max_file_upload" conf:"default:10"`
+}
+
+// New parses the CLI/Config file and returns a Config struct. If the file argument is an empty string, the
+// file is not read. If the file is not empty, the file is read and the Config struct is returned.
+func New() (*Config, error) {
+	var cfg Config
+	const prefix = "HBOX"
+
+	help, err := conf.Parse(prefix, &cfg)
+
+	if err != nil {
+		if errors.Is(err, conf.ErrHelpWanted) {
+			fmt.Println(help)
+			os.Exit(0)
+		}
+		return &cfg, fmt.Errorf("parsing config: %w", err)
+	}
+
+	return &cfg, nil
+}
+
+// Print prints the configuration to stdout as a json indented string
+// This is useful for debugging. If the marshaller errors out, it will panic.
+func (c *Config) Print() {
+	res, err := json.MarshalIndent(c, "", "  ")
+
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(string(res))
+
+}

backend/internal/sys/config/conf_database.go

@@ -0,0 +1,11 @@
+package config
+
+const (
+	DriverSqlite3 = "sqlite3"
+)
+
+type Storage struct {
+	// Data is the path to the root directory
+	Data      string `yaml:"data" conf:"default:./.data"`
+	SqliteUrl string `yaml:"sqlite-url" conf:"default:./.data/homebox.db?_fk=1"`
+}

backend/internal/sys/config/conf_logger.go

@@ -0,0 +1,11 @@
+package config
+
+const (
+	LogFormatJSON = "json"
+	LogFormatText = "text"
+)
+
+type LoggerConf struct {
+	Level  string `conf:"default:info"`
+	Format string `conf:"default:text"`
+}

backend/internal/sys/config/conf_mailer.go

@@ -0,0 +1,15 @@
+package config
+
+type MailerConf struct {
+	Host     string `conf:""`
+	Port     int    `conf:""`
+	Username string `conf:""`
+	Password string `conf:""`
+	From     string `conf:""`
+}
+
+// Ready is a simple check to ensure that the configuration is not empty.
+// or with it's default state.
+func (mc *MailerConf) Ready() bool {
+	return mc.Host != "" && mc.Port != 0 && mc.Username != "" && mc.Password != "" && mc.From != ""
+}

backend/internal/sys/config/conf_mailer_test.go

@@ -0,0 +1,40 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_MailerReady_Success(t *testing.T) {
+	mc := &MailerConf{
+		Host:     "host",
+		Port:     1,
+		Username: "username",
+		Password: "password",
+		From:     "from",
+	}
+
+	assert.True(t, mc.Ready())
+}
+
+func Test_MailerReady_Failure(t *testing.T) {
+	mc := &MailerConf{}
+	assert.False(t, mc.Ready())
+
+	mc.Host = "host"
+	assert.False(t, mc.Ready())
+
+	mc.Port = 1
+	assert.False(t, mc.Ready())
+
+	mc.Username = "username"
+	assert.False(t, mc.Ready())
+
+	mc.Password = "password"
+	assert.False(t, mc.Ready())
+
+	mc.From = "from"
+	assert.True(t, mc.Ready())
+
+}

backend/internal/sys/validate/validate.go

@@ -0,0 +1,37 @@
+package validate
+
+import "github.com/go-playground/validator/v10"
+
+var validate *validator.Validate
+
+func init() {
+	validate = validator.New()
+}
+
+// Checks a struct for validation errors and returns any errors the occur. This
+// wraps the validate.Struct() function and provides some error wrapping. When
+// a validator.ValidationErrors is returned, it is wrapped transformed into a
+// FieldErrors array and returned.
+func Check(val any) error {
+	err := validate.Struct(val)
+
+	if err != nil {
+		verrors, ok := err.(validator.ValidationErrors)
+		if !ok {
+			return err
+		}
+
+		fields := make(FieldErrors, 0, len(verrors))
+		for _, verr := range verrors {
+			field := FieldError{
+				Field: verr.Field(),
+				Error: verr.Error(),
+			}
+
+			fields = append(fields, field)
+		}
+		return fields
+	}
+
+	return nil
+}