Jannex
/
admin-dashboard-backend
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

creating server structure and env config on server startup if not exists

main
alex 2023-06-28 13:19:42 +02:00
parent 30c57a679a
commit d5b7b59fc0
11 changed files with 178 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
example.env
View File

@ -1,10 +0,0 @@
DEBUG=false
COLORIZED_OUTPUT=false
HOST=127.0.0.1
PORT=3000
# MariaDB
MARIADB_HOSTNAME=localhost
MARIADB_PORT=8080
MARIADB_USERNAME=test
MARIADB_PASSWORD=test

9
grouptasks_lang_log_messages.json
View File

@ -52,5 +52,14 @@
"message": "Step %taskStepId% of %groupTaskId% status set to %status%"
}
]
},
{
"id": 6,
"languages": [
{
"lang": "en",
"message": "--------- SERVER has started ---------"
}
]
}
]

112
main.go
View File

@ -1,6 +1,9 @@
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"janex/admin-dashboard-backend/modules/config"
"janex/admin-dashboard-backend/modules/database"
"janex/admin-dashboard-backend/modules/grouptasks"
@ -10,16 +13,24 @@ import (
"janex/admin-dashboard-backend/modules/utils"
"janex/admin-dashboard-backend/routers/router"
"janex/admin-dashboard-backend/socketserver"
"os"
"github.com/gofiber/fiber/v2"
"github.com/gofiber/fiber/v2/middleware/cors"
flogger "github.com/gofiber/fiber/v2/middleware/logger"
"github.com/gofiber/websocket/v2"
"github.com/rs/zerolog/log"
)
func init() {
createEnvConfigFileIfotExists()
config.LoadConfig()
logger.InitLogger()
createServerDirectoriesIfotExists()
createLogLanguageFilesIfNotExist()
utils.ValidatorInit()
logger.InitLanguageLogMessages()
systempermissions.InitSystemPermissions()
@ -79,3 +90,104 @@ func main() {
app.Listen(config.Cfg.Host + ":" + config.Cfg.Port)
}
func createEnvConfigFileIfotExists() {
content := `DEBUG=false
COLORIZED_OUTPUT=true
HOST=127.0.0.1
PORT=8080
# Folder paths
FOLDER_GROUPTASKS_GROUPS=./groupTasks/groups/
FOLDER_GROUPTASKS_RUNNINGTASKS=./groupTasks/runningTasks/
FOLDER_LOGS_GROUPTASKS=./logs/grouptasks/
FOLDER_LOGS_SYSTEM=./logs/system/
FOLDER_PUBLIC_STATIC=./public/
# Log language configurations
LOG_LANGUAGE_GROUPTASKS=./grouptasks_lang_log_messages.json
LOG_LANGUAGE_SYSTEM=./system_lang_log_messages.json
# MariaDB
MARIADB_HOSTNAME=127.0.0.1
MARIADB_PORT=3306
MARIADB_USERNAME=db_user
MARIADB_PASSWORD=db_password
MARIADB_DATABASE_NAME=db_database_name`
if _, err := os.Stat(".env"); os.IsNotExist(err) {
err := ioutil.WriteFile(".env", []byte(content), 0644)
if err != nil {
panic("Failed to create .env file, err: " + err.Error())
}
fmt.Println("Config .env was created. Please configure and start the server again.")
os.Exit(1)
}
}
func createServerDirectoriesIfotExists() {
cfg := config.Cfg.FolderPaths
paths := []string{
cfg.GroupTasksGroups,
cfg.GroupTasksRunningTasks,
cfg.LogsGroupTasks,
cfg.LogsSystem,
cfg.PublicStatic + "avatars/",
cfg.PublicStatic + "grouptasks/",
cfg.PublicStatic + "sounds/"}
for _, path := range paths {
_, err := os.Stat(path)
if os.IsNotExist(err) {
if err := os.MkdirAll(path, os.ModePerm); err != nil {
log.Error().Msgf("Failed to create server directory: %s", err.Error())
continue
}
log.Info().Msgf("Created server directory: %s", path)
}
}
}
func createLogLanguageFilesIfNotExist() {
cfg := config.Cfg
files := []string{cfg.LogLanguageGroupTasks, cfg.LogLanguageSystem}
for _, filename := range files {
_, err := os.Stat(filename)
if os.IsNotExist(err) {
file, err := os.Create(filename)
if err != nil {
log.Error().Msgf("Failed to create log language file %s", err.Error())
continue
}
defer file.Close()
encoder := json.NewEncoder(file)
encoder.SetIndent("", " ")
data := []structs.LanguageLogMessages{{
Id: 0,
Languages: []structs.LanguageLogMessagesLanguage{
{Lang: "en", Message: "Your message"},
}}}
if err := encoder.Encode(data); err != nil {
log.Error().Msgf("Failed to write default language log messages into file %s", filename)
continue
}
log.Info().Msgf("Create log language file %s", filename)
}
}
}

20
modules/config/config.go
View File

@ -13,7 +13,18 @@ type Config struct {
ColorizedOutput bool
Host string
Port string
FolderPaths FolderPaths
MariaDB MariaDB
LogLanguageGroupTasks string
LogLanguageSystem string
}
type FolderPaths struct {
GroupTasksGroups string
GroupTasksRunningTasks string
LogsGroupTasks string
LogsSystem string
PublicStatic string
}
type MariaDB struct {
@ -32,6 +43,15 @@ func LoadConfig() {
ColorizedOutput: os.Getenv("COLORIZED_OUTPUT") == "true",
Host: os.Getenv("HOST"),
Port: os.Getenv("PORT"),
FolderPaths: FolderPaths{
GroupTasksGroups: os.Getenv("FOLDER_GROUPTASKS_GROUPS"),
GroupTasksRunningTasks: os.Getenv("FOLDER_GROUPTASKS_RUNNINGTASKS"),
LogsGroupTasks: os.Getenv("FOLDER_LOGS_GROUPTASKS"),
LogsSystem: os.Getenv("FOLDER_LOGS_SYSTEM"),
PublicStatic: os.Getenv("FOLDER_PUBLIC_STATIC"),
},
LogLanguageGroupTasks: os.Getenv("LOG_LANGUAGE_GROUPTASKS"),
LogLanguageSystem: os.Getenv("LOG_LANGUAGE_SYSTEM"),
MariaDB: MariaDB{
Hostname: os.Getenv("MARIADB_HOSTNAME"),
Port: os.Getenv("MARIADB_PORT"),

42
modules/grouptasks/grouptasks.go
View File

@ -6,6 +6,7 @@ import (
"fmt"
"io/ioutil"
"janex/admin-dashboard-backend/modules/cache"
"janex/admin-dashboard-backend/modules/config"
"janex/admin-dashboard-backend/modules/database"
"janex/admin-dashboard-backend/modules/logger"
"janex/admin-dashboard-backend/modules/structs"
@ -23,15 +24,8 @@ import (
"github.com/rs/zerolog/log"
)
var (
rootPath = "./groupTasks/"
groupsPath = rootPath + "groups/"
runningTasksPath = rootPath + "runningTasks/"
publicPath = "./public/grouptasks/"
)
func LoadGroups(category string) {
entries, err := os.ReadDir(groupsPath)
entries, err := os.ReadDir(config.Cfg.FolderPaths.GroupTasksGroups)
if err != nil {
llog.Fatal(err)
@ -45,7 +39,7 @@ func LoadGroups(category string) {
var updatedGroups []structs.Group
for _, entry := range entries {
files, err := os.ReadDir(groupsPath + entry.Name())
files, err := os.ReadDir(config.Cfg.FolderPaths.GroupTasksGroups + entry.Name())
if err != nil {
log.Error().Msg("Failed to read groups directory files, error: " + err.Error())
@ -54,7 +48,7 @@ func LoadGroups(category string) {
for _, file := range files {
if file.Name() == "index.json" {
content, err := os.ReadFile(groupsPath + entry.Name() + "/index.json")
content, err := os.ReadFile(config.Cfg.FolderPaths.GroupTasksGroups + entry.Name() + "/index.json")
if err != nil {
log.Error().Msg("Failed to read file content, error: " + err.Error())
@ -202,13 +196,13 @@ func RunGroupTask(args RunGroupTaskArgs) {
}
// create running task folder
if _, err := os.Stat(runningTasksPath + groupTaskStep.GroupTasksId); errors.Is(err, os.ErrNotExist) {
if err := os.Mkdir(runningTasksPath+groupTaskStep.GroupTasksId, os.ModePerm); err != nil {
if _, err := os.Stat(config.Cfg.FolderPaths.GroupTasksRunningTasks + groupTaskStep.GroupTasksId); errors.Is(err, os.ErrNotExist) {
if err := os.Mkdir(config.Cfg.FolderPaths.GroupTasksRunningTasks+groupTaskStep.GroupTasksId, os.ModePerm); err != nil {
log.Error().Msgf("Error creating running tasks folder %s", err.Error())
}
// copy scripts to group tasks folder
err := filepath.Walk(groupsPath+categoryGroup.Id, func(path string, info os.FileInfo, err error) error {
err := filepath.Walk(config.Cfg.FolderPaths.GroupTasksGroups+categoryGroup.Id, func(path string, info os.FileInfo, err error) error {
if err != nil {
log.Error().Msgf("Error walk %s", err.Error())
return err
@ -221,7 +215,7 @@ func RunGroupTask(args RunGroupTaskArgs) {
log.Error().Msgf("Error reading file %s", err.Error())
}
err = ioutil.WriteFile(runningTasksPath+groupTaskStep.GroupTasksId+"/"+info.Name(), bytesRead, 0644)
err = ioutil.WriteFile(config.Cfg.FolderPaths.GroupTasksRunningTasks+groupTaskStep.GroupTasksId+"/"+info.Name(), bytesRead, 0644)
if err != nil {
log.Error().Msgf("Error writing file %s", err.Error())
@ -240,7 +234,7 @@ func RunGroupTask(args RunGroupTaskArgs) {
cmd := exec.Command("python3", commandArgs...)
//cmd.Dir = "/home/alex/Documents/coding/projects/janex/admin-dashboard/backend/groupTasks/groups/production1/"
// path needs to be set here as the python scripts will use the path as base path to create files for example
cmd.Dir = runningTasksPath + groupTaskStep.GroupTasksId + "/"
cmd.Dir = config.Cfg.FolderPaths.GroupTasksRunningTasks + groupTaskStep.GroupTasksId + "/"
out, err := cmd.CombinedOutput()
// execute script
@ -290,7 +284,7 @@ func RunGroupTask(args RunGroupTaskArgs) {
// looking for files which are created by the scripts
var foundFiles []FoundFile
if err = filepath.Walk(runningTasksPath+groupTaskStep.GroupTasksId+"/", func(path string, info os.FileInfo, err error) error {
if err = filepath.Walk(config.Cfg.FolderPaths.GroupTasksRunningTasks+groupTaskStep.GroupTasksId+"/", func(path string, info os.FileInfo, err error) error {
if err != nil {
log.Error().Msgf("Error walk %s", err.Error())
return err
@ -307,15 +301,15 @@ func RunGroupTask(args RunGroupTaskArgs) {
if len(foundFiles) > 0 {
// creating folder for the old files which can be used by the python scripts for the next steps
if _, err := os.Stat(runningTasksPath + groupTaskStep.GroupTasksId + "/oldFiles"); errors.Is(err, os.ErrNotExist) {
if err := os.Mkdir(runningTasksPath+groupTaskStep.GroupTasksId+"/oldFiles", os.ModePerm); err != nil {
if _, err := os.Stat(config.Cfg.FolderPaths.GroupTasksRunningTasks + groupTaskStep.GroupTasksId + "/oldFiles"); errors.Is(err, os.ErrNotExist) {
if err := os.Mkdir(config.Cfg.FolderPaths.GroupTasksRunningTasks+groupTaskStep.GroupTasksId+"/oldFiles", os.ModePerm); err != nil {
log.Error().Msgf("Error creating old files folder %s", err.Error())
}
}
// copy files to public directory to access it via web ui
if _, err := os.Stat(publicPath + groupTaskStep.GroupTasksId); errors.Is(err, os.ErrNotExist) {
if err := os.Mkdir(publicPath+groupTaskStep.GroupTasksId, os.ModePerm); err != nil {
if _, err := os.Stat(config.Cfg.FolderPaths.PublicStatic + "grouptasks/" + groupTaskStep.GroupTasksId); errors.Is(err, os.ErrNotExist) {
if err := os.Mkdir(config.Cfg.FolderPaths.PublicStatic+"grouptasks/"+groupTaskStep.GroupTasksId, os.ModePerm); err != nil {
log.Error().Msgf("Error creating task public folder %s", err.Error())
}
}
@ -329,7 +323,7 @@ func RunGroupTask(args RunGroupTaskArgs) {
log.Error().Msgf("Error reading file %s", err.Error())
}
err = ioutil.WriteFile(runningTasksPath+groupTaskStep.GroupTasksId+"/oldFiles/"+foundFile.FileName, bytesRead, 0644)
err = ioutil.WriteFile(config.Cfg.FolderPaths.GroupTasksRunningTasks+groupTaskStep.GroupTasksId+"/oldFiles/"+foundFile.FileName, bytesRead, 0644)
if err != nil {
log.Error().Msgf("Error writing file %s", err.Error())
@ -337,13 +331,13 @@ func RunGroupTask(args RunGroupTaskArgs) {
systemFileName := uuid.New().String() + filepath.Ext(foundFile.FileName)
err = ioutil.WriteFile(publicPath+groupTaskStep.GroupTasksId+"/"+systemFileName, bytesRead, 0644)
err = ioutil.WriteFile(config.Cfg.FolderPaths.PublicStatic+"grouptasks/"+groupTaskStep.GroupTasksId+"/"+systemFileName, bytesRead, 0644)
if err != nil {
log.Error().Msgf("Error writing file %s", err.Error())
}
err = os.Remove(runningTasksPath + groupTaskStep.GroupTasksId + "/" + foundFile.FileName)
err = os.Remove(config.Cfg.FolderPaths.GroupTasksRunningTasks + groupTaskStep.GroupTasksId + "/" + foundFile.FileName)
if err != nil {
log.Error().Msgf("Failed to delete created file by task %s", err.Error())
@ -403,7 +397,7 @@ func RunGroupTask(args RunGroupTaskArgs) {
EndedAt: time.Now(),
})
if err = os.RemoveAll(runningTasksPath + groupTaskStep.GroupTasksId + "/"); err != nil {
if err = os.RemoveAll(config.Cfg.FolderPaths.GroupTasksRunningTasks + groupTaskStep.GroupTasksId + "/"); err != nil {
log.Error().Msgf("Failed to delete running task folder %s", err.Error())
}

5
modules/logger/logger.go
View File

@ -188,6 +188,11 @@ func InitLanguageLogMessages() {
Id: 8,
Type: utils.LogTypeInfo,
})
AddGroupTasksLog(structs.LogMessage{
Id: 6,
Type: utils.LogTypeInfo,
})
}
func readLanguageLogMessages(systemLogs bool) {

15
routers/router/api/v1/logger/logger.go
View File

@ -31,18 +31,9 @@ func GetSystemLog(c *fiber.Ctx) error {
Id: 17,
Type: utils.LogTypeInfo,
Messages: []structs.LogData{
{
Type: "userId",
Value: c.Locals("userId").(string),
},
{
Type: "logType",
Value: logType,
},
{
Type: "logDate",
Value: date,
},
{Type: "userId", Value: c.Locals("userId").(string)},
{Type: "logType", Value: logType},
{Type: "logDate", Value: date},
},
})

6
routers/router/api/v1/user/avatar.go
View File

@ -24,7 +24,6 @@ func UpdateAvatar(c *fiber.Ctx) error {
}
if fileHeader.Size > utils.MaxAvatarSize {
log.Error().Msg("User Avatar file size limit exceeded")
return c.SendStatus(fiber.StatusRequestEntityTooLarge)
}
@ -55,10 +54,7 @@ func UpdateAvatar(c *fiber.Ctx) error {
Id: 21,
Type: utils.LogTypeInfo,
Messages: []structs.LogData{
{
Type: "userId",
Value: user.Id,
},
{Type: "userId", Value: user.Id},
},
})

3
routers/router/router.go
View File

@ -1,6 +1,7 @@
package router
import (
"janex/admin-dashboard-backend/modules/config"
"janex/admin-dashboard-backend/modules/database"
"janex/admin-dashboard-backend/modules/structs"
"janex/admin-dashboard-backend/modules/utils"
@ -28,7 +29,7 @@ func SetupRoutes(app *fiber.App) {
l := v1.Group("/log")
l.Get("/", userSessionValidation, log.GetSystemLog)
app.Static("/", "./public")
app.Static("/", config.Cfg.FolderPaths.PublicStatic)
}
func userSessionValidation(c *fiber.Ctx) error {

2
socketserver/hub.go
View File

@ -101,7 +101,7 @@ func RunHub() {
continue
}
log.Info().Msgf("Received message: %v %v", receivedMessage, receivedMessage.Cmd)
log.Debug().Msgf("Received message: %v %v", receivedMessage, receivedMessage.Cmd)
switch receivedMessage.Cmd {
case utils.ReceivedCmdStartGroupTasks:

2
system_lang_log_messages.json
View File

@ -76,7 +76,7 @@
"languages": [
{
"lang": "en",
"message": "SERVER has started"
"message": "--------- SERVER has started ---------"
}
]
},