personal-website/routes/private.go

package routes

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

	mobile "github.com/floresj/go-contrib-mobile"
	"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(mobile.Resolver())
	router.Use(favicon.New("./res/dev-fs/wde/icons/ohno.png"))
	router.LoadHTMLGlob("templates/**/*")
	router.Static("/res", "res")
	router.Static("/front", "./front/")
	// router.Use(cors.New(cors.Config{
	// 	AllowOrigins:     []string{"http://localhost:1234"},
	// 	AllowMethods:     []string{"PUT", "PATCH"},
	// 	AllowHeaders:     []string{"Origin"},
	// 	ExposeHeaders:    []string{"Content-Length"},
	// 	AllowCredentials: true,
	// 	AllowOriginFunc: func(origin string) bool {
	// 		return origin == "http://localhost:1234"
	// 	},
	// 	MaxAge: 12 * time.Hour,
	// }))
	// 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"},
		// }

		appString := AppString{
			AppPath: "/Applications/BlogViewer.app",
			Args:    []string{"/home/user/Blogs/blog1.blog"},
		}
		_ = appString
		aboutMe := AppString{
			AppPath: "/Applications/AboutMe.app",
			Args:    []string{},
		}
		_ = aboutMe
		desktop := AppString{
			AppPath: "/Applications/Finder.app",
			Args:    []string{"/", "--desktop", "desktop-layer"},
		}

		autostart := []AppString{desktop}
		d := mobile.GetDevice(ctx)
		switch {
		// Hey I'm a desktop!... or laptop but not a mobile or tablet!
		case d.Normal():
			ctx.HTML(http.StatusOK, "index.html", gin.H{
				"autostart": autostart,
			})
		// Hey I'm a mobile device!
		case d.Mobile():
			ctx.HTML(http.StatusOK, "mobile-desktop.html", gin.H{
				// "autostart": autostart,
			})
		// Woa I'm a tablet!
		case d.Tablet():
			ctx.JSON(http.StatusOK, "Hello I'm a tablet device")
		}

	})
	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)
	}
}