personal-website/main.go

package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"net/http"
	"os"

	"personalwebsite/apps"
	"personalwebsite/apps/blogviewer"
	"personalwebsite/apps/finder"
	imgviewer "personalwebsite/apps/img-viewer"
	"personalwebsite/apps/personalprops"
	"personalwebsite/libs"
	"personalwebsite/routewde"
	"personalwebsite/wde"
	"personalwebsite/webfilesystem"

	"github.com/gin-contrib/location"
	"github.com/gin-gonic/gin"
	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

func main() {
	if err := godotenv.Load(); err != nil {
		println("No .env file found")
	}

	mongoConnect, err := FindEnv("MONGO_CONNECT")
	if err != nil {
		panic(err.Error())
	}

	dBName, err := FindEnv("DATABASE")
	if err != nil {
		panic(err.Error())
	}

	webFsCollection, err := FindEnv("COLLECTION_WEBFS")
	if err != nil {
		panic(err.Error())
	}

	clientOptions := options.Client().ApplyURI(mongoConnect)
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = client.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}

	router := gin.New()
	router.Use(location.Default())
	router.LoadHTMLGlob("templates/**/*")
	router.Static("/res", "resources")
	// Set a lower memory limit for multipart forms (default is 32 MiB)
	router.MaxMultipartMemory = 8 << 20 // 8 MiB

	router.GET("/", func(ctx *gin.Context) {
		ctx.HTML(http.StatusOK, "index.tmpl", gin.H{})
	})

	webfs := webfilesystem.NewWebFileSystem(client, dBName, webFsCollection)
	webde := wde.NewWDE(webfs)

	persPropsApp := personalprops.NewPersPropsApp(webfs)
	// finderApp := finder.FinderApplication{}
	finderApp := finder.NewFinderApplication(webfs)
	imgViewerApp := imgviewer.NewImgViewerApp(webfs)
	blogViewerApp := blogviewer.NewBlogViewerApp(webfs)
	appsStorage := apps.ApplicationsStorage{
		Apps: map[string]apps.WebDEApplication{},
	}
	appsStorage.Apps["personal-properties"] = &persPropsApp
	appsStorage.Apps["finder"] = finderApp
	appsStorage.Apps["img-viewer"] = &imgViewerApp
	appsStorage.Apps["blog-viewer"] = blogViewerApp

	router.POST("/upload", func(ctx *gin.Context) {
		path := ctx.Query("path")
		if path == "" {
			ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
			return
		}
		// single file
		file, _ := ctx.FormFile("file")
		if file == nil {
			ctx.String(http.StatusBadRequest, "file is nil")
		}
		// generateMins := c.Param("generateMins")
		// log.Println(file.Filename)

		// Upload the file to specific dst.
		dst := "./test-img/" + file.Filename
		ctx.SaveUploadedFile(file, dst)

		err := webfs.UploadFile(dst, path)
		if err != nil {
			ctx.String(http.StatusInternalServerError, "TODO") //TODO
			return
		}

		// webFsCollection.CreateMiniatures("./test-img/", file.Filename)

		// webfs.CreateFile(&img, "/home/user/")

		ctx.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
	})

	system := router.Group("system")
	{
		libsGroup := system.Group("libs")
		{
			imgLibGroup := libsGroup.Group("img")
			{
				imgLib := libs.NewImgLib(webfs)
				imgLib.Route(imgLibGroup)
			}
		}
		wdeGroup := system.Group("wde")
		{
			routewde.Route(wdeGroup, webde)
		}
		apps := system.Group("applications")
		{
			apps.GET("/:appid/:method", func(ctx *gin.Context) {
				appId := ctx.Param("appid")
				method := ctx.Param("method")

				app, isExist := appsStorage.Apps[appId]
				if !isExist {
					ctx.Status(http.StatusNoContent)
					return
				}
				switch method {
				case "getmanifest":
					ctx.JSON(http.StatusOK, app.GetManifest())
				case "app.js":
					ctx.File("resources/sys/" + appId + "/" + appId + ".js")
				case "app.css":
					ctx.File("resources/sys/" + appId + "/" + appId + ".css")
				default:
					ctx.Status(http.StatusBadRequest)
				}
			})
		}
	}

	fs := router.Group("fs")
	{
		webfs.Route(fs)
	}
	app := router.Group("application")
	{
		persPropApp := app.Group("personal-properties")
		{
			persPropsApp.Route(persPropApp)
		}
		finderAppRoute := app.Group("finder")
		{
			finderApp.Routes(finderAppRoute)
		}
		imgViewerRoute := app.Group("img-viewer")
		{
			imgViewerApp.Route(imgViewerRoute)
		}
		blogViewerRoute := app.Group("blog-viewer")
		{
			blogViewerApp.Route(blogViewerRoute)
		}

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

// func index(c *gin.Context) {
// 	c.HTML(http.StatusOK, "base.html", nil)
// }

func FindEnv(parameter string) (string, error) {
	path, exists := os.LookupEnv(parameter)

	if exists {
		println("[ENV] Requsted " + parameter + " = " + path) //FIXME Only in Debug log
		return path, nil
	} else {
		panic("[ENV] Requsted " + parameter + " not found")
		return "", errors.New("env parameter not found")
	}
}