Fix .js mime issues in windows

server/router/middleware.go

@@ -0,0 +1,84 @@
+package router
+
+import (
+    "encoding/base64"
+    "github.com/0xJacky/Nginx-UI/frontend"
+    "github.com/0xJacky/Nginx-UI/server/model"
+    "github.com/gin-contrib/static"
+    "github.com/gin-gonic/gin"
+    "io/fs"
+    "log"
+    "net/http"
+    "path"
+    "strings"
+)
+
+func authRequired() gin.HandlerFunc {
+    return func(c *gin.Context) {
+        token := c.GetHeader("Authorization")
+        if token == "" {
+            tmp, _ := base64.StdEncoding.DecodeString(c.Query("token"))
+            token = string(tmp)
+            if token == "" {
+                c.JSON(http.StatusForbidden, gin.H{
+                    "message": "auth fail",
+                })
+                c.Abort()
+                return
+            }
+        }
+
+        n := model.CheckToken(token)
+
+        if n < 1 {
+            c.JSON(http.StatusForbidden, gin.H{
+                "message": "auth fail",
+            })
+            c.Abort()
+            return
+        }
+        c.Next()
+    }
+}
+
+type serverFileSystemType struct {
+    http.FileSystem
+}
+
+func (f serverFileSystemType) Exists(prefix string, _path string) bool {
+    _, err := f.Open(path.Join(prefix, _path))
+    return err == nil
+}
+
+func mustFS(dir string) (serverFileSystem static.ServeFileSystem) {
+
+    sub, err := fs.Sub(frontend.DistFS, path.Join("dist", dir))
+
+    if err != nil {
+        log.Println(err)
+        return
+    }
+
+    serverFileSystem = serverFileSystemType{
+        http.FS(sub),
+    }
+
+    return
+}
+
+// tryStatic Static returns a middleware handler that serves static files in the given directory.
+func tryStatic(urlPrefix string, fs static.ServeFileSystem) gin.HandlerFunc {
+    fileserver := http.FileServer(fs)
+    if urlPrefix != "" {
+        fileserver = http.StripPrefix(urlPrefix, fileserver)
+    }
+    return func(c *gin.Context) {
+        if fs.Exists(urlPrefix, c.Request.URL.Path) {
+            fileserver.ServeHTTP(c.Writer, c.Request)
+            if strings.Contains(c.Request.URL.Path, ".js") {
+                c.Writer.Header().Set("content-type", "application/javascript")
+            }
+            c.Abort()
+        }
+    }
+}

server/router/routers.go

@@ -2,78 +2,19 @@ package router
 
 import (
 	"bufio"
-	"encoding/base64"
-	"github.com/0xJacky/Nginx-UI/frontend"
 	api2 "github.com/0xJacky/Nginx-UI/server/api"
-	"github.com/0xJacky/Nginx-UI/server/model"
-	"github.com/gin-contrib/static"
 	"github.com/gin-gonic/gin"
-	"io/fs"
-	"log"
 	"net/http"
-	"path/filepath"
 	"strings"
 )
 
-func authRequired() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		token := c.GetHeader("Authorization")
-		if token == "" {
-			tmp, _ := base64.StdEncoding.DecodeString(c.Query("token"))
-			token = string(tmp)
-			if token == "" {
-				c.JSON(http.StatusForbidden, gin.H{
-					"message": "auth fail",
-				})
-				c.Abort()
-				return
-			}
-		}
-
-		n := model.CheckToken(token)
-
-		if n < 1 {
-			c.JSON(http.StatusForbidden, gin.H{
-				"message": "auth fail",
-			})
-			c.Abort()
-			return
-		}
-		c.Next()
-	}
-}
-
-type serverFileSystemType struct {
-	http.FileSystem
-}
-
-func (f serverFileSystemType) Exists(prefix string, path string) bool {
-	_, err := f.Open(filepath.Join(prefix, path))
-	return err == nil
-}
-
-func mustFS(dir string) (serverFileSystem static.ServeFileSystem) {
-
-	sub, err := fs.Sub(frontend.DistFS, filepath.Join("dist", dir))
-
-	if err != nil {
-		log.Println(err)
-	}
-
-	serverFileSystem = serverFileSystemType{
-		http.FS(sub),
-	}
-
-	return
-}
-
 func InitRouter() *gin.Engine {
 	r := gin.New()
 	r.Use(gin.Logger())
 
 	r.Use(gin.Recovery())
 
-	r.Use(static.Serve("/", mustFS("")))
+	r.Use(tryStatic("/", mustFS("")))
 
 	r.NoRoute(func(c *gin.Context) {
 		accept := c.Request.Header.Get("Accept")

server/tool/nginx.go

@@ -1,52 +1,53 @@
 package tool
 
 import (
-    "errors"
-    "log"
-    "os/exec"
-    "path/filepath"
-    "regexp"
-    "strings"
+	"errors"
+	"log"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
 )
 
 func TestNginxConf(filePath string) error {
-    out, err := exec.Command("nginx", "-t").CombinedOutput()
-    if err != nil {
-        log.Println(err)
-    }
-    output := string(out)
-    log.Println(output)
-    if strings.Contains(output, "failed") {
-        return errors.New(output)
-    }
-    return nil
+	out, err := exec.Command("nginx", "-t").CombinedOutput()
+	if err != nil {
+		log.Println(err)
+	}
+	output := string(out)
+	log.Println(output)
+	if strings.Contains(output, "failed") {
+		return errors.New(output)
+	}
+	return nil
 }
 
 func ReloadNginx() string {
-    out, err := exec.Command("nginx", "-s", "reload").CombinedOutput()
+	out, err := exec.Command("nginx", "-s", "reload").CombinedOutput()
 
-    if err != nil {
-        log.Println(err)
-    }
+	if err != nil {
+		log.Println(err)
+	}
 
-    output := string(out)
-    log.Println(output)
+	output := string(out)
+	log.Println(output)
 
-    return output
+	return output
 }
 
 func GetNginxConfPath(dir string) string {
-    out, err := exec.Command("nginx", "-V").CombinedOutput()
-    if err != nil {
-        log.Fatal(err)
-    }
-    // fmt.Printf("%s\n", out)
+	out, err := exec.Command("nginx", "-V").CombinedOutput()
+	if err != nil {
+		log.Println(err)
+		return ""
+	}
+	// fmt.Printf("%s\n", out)
 
-    r, _ := regexp.Compile("--conf-path=(.*)/(.*.conf)")
+	r, _ := regexp.Compile("--conf-path=(.*)/(.*.conf)")
 
-    confPath := r.FindStringSubmatch(string(out))[1]
+	confPath := r.FindStringSubmatch(string(out))[1]
 
-    // fmt.Println(confPath)
+	// fmt.Println(confPath)
 
-    return filepath.Join(confPath, dir)
+	return filepath.Join(confPath, dir)
 }