Add custom static links (#234)

internal/config/config.go

@@ -63,8 +63,14 @@ type config struct {
 	OIDCSecret       string `yaml:"oidc.secret" env:"OG_OIDC_SECRET"`
 	OIDCDiscoveryUrl string `yaml:"oidc.discovery-url" env:"OG_OIDC_DISCOVERY_URL"`
 
-	CustomLogo    string `yaml:"custom.logo" env:"OG_CUSTOM_LOGO"`
-	CustomFavicon string `yaml:"custom.favicon" env:"OG_CUSTOM_FAVICON"`
+	CustomLogo    string       `yaml:"custom.logo" env:"OG_CUSTOM_LOGO"`
+	CustomFavicon string       `yaml:"custom.favicon" env:"OG_CUSTOM_FAVICON"`
+	StaticLinks   []StaticLink `yaml:"custom.static-links" env:"OG_CUSTOM_STATIC_LINK"`
+}
+
+type StaticLink struct {
+	Name string `yaml:"name" env:"OG_CUSTOM_STATIC_LINK_#_NAME"`
+	Path string `yaml:"path" env:"OG_CUSTOM_STATIC_LINK_#_PATH"`
 }
 
 func configWithDefaults() (*config, error) {
@@ -129,7 +135,6 @@ func InitConfig(configPath string, out io.Writer) error {
 	if err = os.Setenv("OG_OPENGIST_HOME_INTERNAL", GetHomeDir()); err != nil {
 		return err
 	}
-
 	return nil
 }
 
@@ -246,22 +251,63 @@ func loadConfigFromEnv(c *config, out io.Writer) error {
 		}
 
 		envValue := os.Getenv(strings.ToUpper(tag))
-		if envValue == "" {
+		if envValue == "" && v.Field(i).Kind() != reflect.Slice {
 			continue
 		}
 
 		switch v.Field(i).Kind() {
 		case reflect.String:
 			v.Field(i).SetString(envValue)
+			envVars = append(envVars, tag)
 		case reflect.Bool:
 			boolVal, err := strconv.ParseBool(envValue)
 			if err != nil {
 				return err
 			}
 			v.Field(i).SetBool(boolVal)
+			envVars = append(envVars, tag)
+		case reflect.Slice:
+			if v.Type().Field(i).Type.Elem().Kind() == reflect.Struct {
+				prefix := strings.ToUpper(tag) + "_"
+				var sliceValue reflect.Value
+				elemType := v.Type().Field(i).Type.Elem()
+
+				for index := 0; ; index++ {
+					allFieldsPresent := true
+					elemValue := reflect.New(elemType).Elem()
+
+					for j := 0; j < elemValue.NumField() && allFieldsPresent; j++ {
+						elemField := elemValue.Type().Field(j)
+						envName := fmt.Sprintf("%s%d_%s", prefix, index, strings.ToUpper(elemField.Name))
+						envValue, present := os.LookupEnv(envName)
+
+						if !present {
+							allFieldsPresent = false
+							break
+						}
+
+						envVars = append(envVars, envName)
+						elemValue.Field(j).SetString(envValue)
+					}
+
+					if !allFieldsPresent {
+						break
+					}
+
+					if sliceValue.Kind() != reflect.Slice {
+						sliceValue = reflect.MakeSlice(v.Type().Field(i).Type, 0, index+1)
+					}
+					sliceValue = reflect.Append(sliceValue, elemValue)
+				}
+
+				if sliceValue.IsValid() {
+					v.Field(i).Set(sliceValue)
+				}
+			}
+		default:
+			return fmt.Errorf("unsupported type: %s", v.Field(i).Kind())
 		}
 
-		envVars = append(envVars, tag)
 	}
 
 	if len(envVars) > 0 {

internal/web/server.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"github.com/thomiceli/opengist/internal/index"
 	"github.com/thomiceli/opengist/internal/utils"
+	"github.com/thomiceli/opengist/templates"
 	htmlpkg "html"
 	"html/template"
 	"io"
@@ -30,7 +31,6 @@ import (
 	"github.com/thomiceli/opengist/internal/git"
 	"github.com/thomiceli/opengist/internal/i18n"
 	"github.com/thomiceli/opengist/public"
-	"github.com/thomiceli/opengist/templates"
 	"golang.org/x/text/language"
 )
 
@@ -138,6 +138,10 @@ var (
 		},
 		"addMetadataToSearchQuery": addMetadataToSearchQuery,
 		"indexEnabled":             index.Enabled,
+		"isUrl": func(s string) bool {
+			_, err := url.ParseRequestURI(s)
+			return err == nil
+		},
 	}
 )
 
@@ -186,9 +190,22 @@ func NewServer(isDev bool) *Server {
 	e.Use(middleware.Recover())
 	e.Use(middleware.Secure())
 
-	e.Renderer = &Template{
-		templates: template.Must(template.New("t").Funcs(fm).ParseFS(templates.Files, "*/*.html")),
+	t := template.Must(template.New("t").Funcs(fm).ParseFS(templates.Files, "*/*.html"))
+	customPattern := filepath.Join(config.GetHomeDir(), "custom", "*.html")
+	matches, err := filepath.Glob(customPattern)
+	if err != nil {
+		log.Fatal().Err(err).Msg("Failed to check for custom templates")
 	}
+	if len(matches) > 0 {
+		t, err = t.ParseGlob(customPattern)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Failed to parse custom templates")
+		}
+	}
+	e.Renderer = &Template{
+		templates: t,
+	}
+
 	e.HTTPErrorHandler = func(er error, ctx echo.Context) {
 		if err, ok := er.(*echo.HTTPError); ok {
 			if err.Code >= 500 {
@@ -211,14 +228,6 @@ func NewServer(isDev bool) *Server {
 	if !dev {
 		parseManifestEntries()
 	}
-	customFs := os.DirFS(filepath.Join(config.GetHomeDir(), "custom"))
-	e.GET("/assets/*", func(c echo.Context) error {
-		if _, err := public.Files.Open(path.Join("assets", c.Param("*"))); !dev && err == nil {
-			return echo.WrapHandler(http.FileServer(http.FS(public.Files)))(c)
-		}
-
-		return echo.WrapHandler(http.StripPrefix("/assets/", http.FileServer(http.FS(customFs))))(c)
-	})
 
 	// Web based routes
 	g1 := e.Group("")
@@ -309,6 +318,23 @@ func NewServer(isDev bool) *Server {
 		}
 	}
 
+	customFs := os.DirFS(filepath.Join(config.GetHomeDir(), "custom"))
+	e.GET("/assets/*", func(ctx echo.Context) error {
+		if _, err := public.Files.Open(path.Join("assets", ctx.Param("*"))); !dev && err == nil {
+			return echo.WrapHandler(http.FileServer(http.FS(public.Files)))(ctx)
+		}
+
+		// if the custom file is an .html template, render it
+		if strings.HasSuffix(ctx.Param("*"), ".html") {
+			if err := html(ctx, ctx.Param("*")); err != nil {
+				return notFound("Page not found")
+			}
+			return nil
+		}
+
+		return echo.WrapHandler(http.StripPrefix("/assets/", http.FileServer(http.FS(customFs))))(ctx)
+	})
+
 	// Git HTTP routes
 	if config.C.HttpGit {
 		e.Any("/:user/:gistname/*", gitHttp, gistSoftInit)