personal-website/routes/private.go

package routes

import (
	"log"
	"net/http"
	"path"
	"personalwebsite/apps"
	"personalwebsite/errormessage"
	"personalwebsite/libs"
	"personalwebsite/wde"
	"personalwebsite/webfilesystem"
	"time"

	"github.com/gin-contrib/cors"
	"github.com/gin-contrib/location"
	"github.com/gin-gonic/gin"
	"github.com/thinkerou/favicon"
)

type AppString struct { //TODO temp
	AppPath string
	Args    []string
}

func PrivateRoutes(port string, webfs *webfilesystem.WebFileSystem, webde *wde.WDE, appsStorage *apps.ApplicationsStorage) {
	router := gin.New()
	router.Use(location.Default())
	router.Use(favicon.New("./res/dev-fs/wde/icons/ohno.png"))
	router.LoadHTMLGlob("templates/**/*")
	router.Static("/res", "res")
	// Set a lower memory limit for multipart forms (default is 32 MiB)
	router.MaxMultipartMemory = 8 << 20 // 8 MiB

	router.GET("/", func(ctx *gin.Context) {
		appString := AppString{
			AppPath: "/Applications/Finder.app",
			Args:    []string{"/home/user"},
		}

		aboutMe := AppString{
			AppPath: "/Applications/AboutMe.app",
			Args:    []string{},
		}

		appString2 := AppString{
			AppPath: "/Applications/Finder.app",
			Args:    []string{"/home/user/", "--desktop", "desktop-layer"},
		}

		autostart := []AppString{appString2, appString, aboutMe}
		ctx.HTML(http.StatusOK, "index.tmpl", gin.H{
			"autostart": autostart,
		})
	})
	systemGroup := router.Group("system")
	{
		libsGroup := systemGroup.Group("libs")
		{
			imgLibGroup := libsGroup.Group("img")
			{
				imgLib := libs.NewImgLib(webfs)
				imgLib.PublicRoutes(imgLibGroup)
			}

			catLibGroup := libsGroup.Group("cat")
			{
				catLib := libs.NewCatLib(webfs)
				catLib.PublicRoutes(catLibGroup)
			}

			appsStorageGroup := libsGroup.Group("apps")
			{
				appsStorage.PrivateRoute(appsStorageGroup)
			}
		}

		wdeGroup := systemGroup.Group("wde")
		{
			wde.PublicRoutes(wdeGroup, webde)
		}

		fsGroup := systemGroup.Group("fs")
		{
			webfs.PrivateRoutes(fsGroup)
		}

		systemGroup.GET("/loadApp", func(ctx *gin.Context) {
			appPath := ctx.Query("path")
			if appPath == "" {
				ctx.JSON(http.StatusBadRequest, errormessage.ErrorMessage{
					Message: "Path for the App not provided in request",
				})
				return
			}

			appBundleData := webfilesystem.DirectoryData{}
			appBundle, err := webfs.Read(appPath, &appBundleData)
			if err != nil {
				ctx.JSON(http.StatusInternalServerError, errormessage.ErrorMessage{
					Message: "Error in read App bundle",
				})
				return
			}
			if appBundle.Type != "directory" {
				ctx.JSON(http.StatusBadRequest, errormessage.ErrorMessage{
					Message: "App bundle file is bad",
				})
				return
			}

			appManifestData := apps.ApplicationManifest{}
			appManifestHeader, err := webfs.Read(path.Join(appPath, ".appmanifest"), &appManifestData)
			if err != nil {
				ctx.JSON(http.StatusInternalServerError, errormessage.ErrorMessage{
					Message: "Error in read App manifest",
				})
				return
			}

			if appManifestHeader.Type != "application-manifest" {
				ctx.JSON(http.StatusInternalServerError, errormessage.ErrorMessage{
					Message: "Error in read App manifest",
				})
				return
			}
			ctx.JSON(http.StatusOK, appManifestData)
		})
	}

	appsGroup := router.Group("app")
	{
		for _, app := range appsStorage.Apps {
			appsRoutes := appsGroup.Group(app.GetAppID())
			app.PrivateRoutes(appsRoutes)
		}
	}

	router.Use(cors.New(cors.Config{
		AllowAllOrigins: true,
		// AllowOrigins:     []string{"http://localhost:8080", "http://localhost:9090"},
		// AllowMethods:     []string{"PUT", "PATCH"},
		// AllowHeaders:     []string{"Origin"},
		ExposeHeaders:    []string{"Content-Length"},
		AllowCredentials: true,
		// AllowOriginFunc: func(origin string) bool {
		// 	return origin == "https://github.com"
		// },
		MaxAge: 12 * time.Hour,
	}))

	err := router.Run(":" + port)
	if err != nil {
		log.Panicf("error: %s", err)
	}
}