361 lines
9.1 KiB
Go
361 lines
9.1 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
|
|
"personalwebsite/routewde"
|
|
"personalwebsite/wde"
|
|
"personalwebsite/webfilesystem"
|
|
"personalwebsite/websiteapp"
|
|
"personalwebsite/websiteapp/blogviewer"
|
|
"personalwebsite/websiteapp/finder"
|
|
imgviewer "personalwebsite/websiteapp/img-viewer"
|
|
"personalwebsite/websiteapp/personalprops"
|
|
|
|
"github.com/gin-contrib/location"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/joho/godotenv"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"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 := websiteapp.ApplicationsStorage{
|
|
Apps: map[string]websiteapp.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")
|
|
// 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")
|
|
{
|
|
imgLibGroup.GET("get", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
file, err := webfs.Read(path)
|
|
if err != nil {
|
|
ctx.String(http.StatusInternalServerError, "TODO") //TODO
|
|
}
|
|
|
|
ctx.Data(200, "image/jpeg", file.Data.(primitive.Binary).Data)
|
|
})
|
|
}
|
|
}
|
|
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)
|
|
}
|
|
})
|
|
}
|
|
|
|
websiteapp.Route(apps.Group("/storage"), &appsStorage)
|
|
}
|
|
|
|
fs := router.Group("fs")
|
|
{
|
|
fs.GET("writeFile", func(ctx *gin.Context) {
|
|
parentPath := ctx.Query("parentPath")
|
|
if parentPath == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
file := webfilesystem.WebFSFile{
|
|
MongoId: primitive.NewObjectID(),
|
|
Name: "pp",
|
|
Type: "test",
|
|
Data: nil,
|
|
}
|
|
err := webfs.CreateFile(&file, parentPath)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, "OK")
|
|
})
|
|
fs.GET("createDir", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
err := webfs.CreateDirectory(path)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, "OK")
|
|
})
|
|
|
|
fs.GET("list", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
files, err := webfs.List(path)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, &files)
|
|
})
|
|
|
|
fs.GET("read", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
file, err := webfs.Read(path)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, &file)
|
|
})
|
|
}
|
|
app := router.Group("application")
|
|
{
|
|
persPropApp := app.Group("personal-properties")
|
|
{
|
|
persPropApp.GET("render", func(ctx *gin.Context) {
|
|
isMobileParam := ctx.Query("isMobile")
|
|
isMobile := isMobileParam == "true"
|
|
ginH, err := persPropsApp.Render()
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO") //TODO
|
|
}
|
|
if isMobile {
|
|
ctx.HTML(http.StatusOK, "personal-properties/mobile-app.tmpl", ginH)
|
|
} else {
|
|
ctx.HTML(http.StatusOK, "personal-properties/app.tmpl", ginH)
|
|
}
|
|
})
|
|
}
|
|
finderAppRoute := app.Group("finder")
|
|
{
|
|
finderAppRoute.GET("render", func(ctx *gin.Context) {
|
|
isMobileParam := ctx.Query("isMobile")
|
|
isMobile := isMobileParam == "true"
|
|
if isMobile {
|
|
ctx.HTML(http.StatusOK, "finder/mobile-app.tmpl", finderApp.Render(isMobile))
|
|
} else {
|
|
ctx.HTML(http.StatusOK, "finder/app.tmpl", finderApp.Render(isMobile))
|
|
}
|
|
|
|
})
|
|
finderAppRoute.GET("renderMobileDesktop", func(ctx *gin.Context) {
|
|
ctx.HTML(http.StatusOK, "finder/mobile-desktop.tmpl", gin.H{})
|
|
})
|
|
finderAppRoute.GET("renderDesktop", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "no path provided")
|
|
return
|
|
}
|
|
ctx.HTML(http.StatusOK, "finder/desktop.tmpl", gin.H{})
|
|
})
|
|
}
|
|
imgViewerRoute := app.Group("img-viewer")
|
|
{
|
|
imgViewerRoute.GET("render", func(ctx *gin.Context) {
|
|
isMobileParam := ctx.Query("isMobile")
|
|
isMobile := isMobileParam == "true"
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "no path provided")
|
|
return
|
|
}
|
|
ginH, err := imgViewerApp.Render(path, isMobile)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO")
|
|
return
|
|
}
|
|
if isMobile {
|
|
ctx.HTML(http.StatusOK, "img-viewer/mobile-app.tmpl", ginH)
|
|
} else {
|
|
ctx.HTML(http.StatusOK, "img-viewer/app.tmpl", ginH)
|
|
}
|
|
|
|
})
|
|
}
|
|
blogViewerRoute := app.Group("blog-viewer")
|
|
{
|
|
blogViewerRoute.GET("writeMockBlog", func(ctx *gin.Context) {
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "no path provided")
|
|
return
|
|
}
|
|
blogViewerApp.WriteMock(path)
|
|
ctx.JSON(http.StatusOK, "OK")
|
|
})
|
|
|
|
blogViewerRoute.GET("render", func(ctx *gin.Context) {
|
|
isMobileParam := ctx.Query("isMobile")
|
|
path := ctx.Query("path")
|
|
if path == "" {
|
|
ctx.JSON(http.StatusBadRequest, "no path provided")
|
|
return
|
|
}
|
|
|
|
isMobile := isMobileParam == "true"
|
|
ginH, err := blogViewerApp.Render(path, isMobile)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, "TODO")
|
|
return
|
|
}
|
|
|
|
if isMobile {
|
|
ctx.HTML(http.StatusOK, "blog-viewer/mobile-app.tmpl", ginH)
|
|
} else {
|
|
ctx.HTML(http.StatusOK, "blog-viewer/app.tmpl", ginH)
|
|
}
|
|
|
|
})
|
|
}
|
|
}
|
|
router.GET("/test", func(ctx *gin.Context) {
|
|
ctx.HTML(200, "kek/kek.tmpl", gin.H{})
|
|
})
|
|
|
|
if err := router.Run(":8080"); 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")
|
|
}
|
|
}
|