memberApp/backend/main.go

package main

import (
	"backend/env"
	"backend/models"
	"backend/server"
	"backend/utils"
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"time"

	AccessHandler "gitea.tecamino.com/paadi/access-handler"
	dbApi "gitea.tecamino.com/paadi/memberDB/api"
	"gitea.tecamino.com/paadi/tecamino-dbm/cert"

	"gitea.tecamino.com/paadi/tecamino-logger/logging"
	"github.com/gin-contrib/cors"
	"github.com/gin-gonic/gin"
)

func main() {
	// set cli flage
	envFile := flag.String("env", ".env", "enviroment file")
	flag.Parse()

	// load enviroment file if exists
	if err := env.Load(*envFile); err != nil {
		fmt.Println("no .env found path: ", *envFile)
	}

	devMode := env.InDevelopmentMode()
	// set gin mode
	if !devMode {
		gin.SetMode(env.GinMode.GetValue())
	}

	workingDir := env.WorkingDir.GetValue()
	spa := env.Spa.GetValue()

	//change working directory only if value is given
	if workingDir != "." && workingDir != "" {
		os.Chdir(workingDir)
	}

	//set allowed origins
	var allowOrigins models.StringSlice

	if strings.Contains(env.DOMAIN.GetValue(), "http") {
		allowOrigins.Set(env.DOMAIN.GetValue())
	}
	if env.AllowOrigin.GetValue() != "" {
		allowOrigins.Set(env.AllowOrigin.GetValue())
	}

	wd, err := os.Getwd()
	if err != nil {
		log.Fatalf("Could not get working directory: %v", err)
	}

	folderName := filepath.Base(wd)
	logFileName := folderName + ".log"

	logger, err := logging.NewLogger(logFileName, &logging.Config{
		MaxSize:     1,
		MaxBackup:   3,
		MaxAge:      28,
		Debug:       env.InDebugMode(),
		TerminalOut: true,
	})
	if err != nil {
		logger.Error("main new logger", err)
		panic(err)
	}

	//new login manager
	accessHandler, err := AccessHandler.NewAccessHandler(".", logger)
	if err != nil {
		logger.Error("main login manager", err)
		panic(err)
	}

	// new server
	s := server.NewServer()

	// initiate Database handler
	dbHandler, err := dbApi.NewAPIHandler(logger)
	if err != nil {
		logger.Error("main login manager", err)
		panic(err)
	}

	//get local ip
	httpString := "http://"
	if env.Https.GetBoolValue() {
		httpString = "https://"

	}
	allowOrigins = append(allowOrigins, httpString+"localhost:9000", httpString+"localhost:9500", httpString+"127.0.0.1:9000", httpString+"0.0.0.0:9500")

	localIP, err := utils.GetLocalIP()
	if err != nil {
		logger.Error("main", fmt.Sprintf("get local ip : %s", err))
	} else {
		allowOrigins = append(allowOrigins, fmt.Sprintf("%s%s:9000", httpString, localIP), fmt.Sprintf("%s%s:9500", httpString, localIP))
	}

	fmt.Println(100, allowOrigins)

	s.Routes.Use(cors.New(cors.Config{
		AllowOrigins: allowOrigins,
		//AllowOrigins:     []string{"*"},
		AllowMethods:     []string{"POST", "GET", "DELETE", "OPTIONS"},
		AllowHeaders:     []string{"Origin", "Content-Type"},
		ExposeHeaders:    []string{"Content-Length"},
		AllowCredentials: true,
		MaxAge:           12 * time.Hour,
	}))

	//set logger for AuthMiddleware
	accessHandler.SetMiddlewareLogger(s.Routes)
	api := s.Routes.Group("/api")
	//set routes

	//public
	api.GET("/logout", accessHandler.Logout)
	api.GET("/login/me", accessHandler.Me)

	api.POST("/login", accessHandler.Login)

	//private
	auth := api.Group("", accessHandler.AuthMiddleware())

	role := auth.Group("", accessHandler.AuthorizeRole("/api"))
	role.GET("/members", dbHandler.GetMember)
	auth.GET("/events", dbHandler.GetEvent)

	auth.GET("/users", accessHandler.GetUser)
	auth.GET("/roles", accessHandler.GetRole)

	auth.POST("database/open", dbHandler.OpenDatabase)
	auth.POST("/members/add", dbHandler.AddNewMember)
	auth.POST("/members/edit", dbHandler.UpdateMember)
	auth.POST("/members/delete", dbHandler.DeleteMember)
	auth.POST("/members/import/csv", dbHandler.ImportCSV)

	auth.POST("/events/add", dbHandler.StartNewEvent)
	auth.POST("/events/edit", dbHandler.UpdateEvent)
	auth.POST("/events/add/attendees", dbHandler.AddNewAttendees)
	auth.POST("/events/delete/attendees", dbHandler.DeleteAttendee)
	auth.POST("/events/delete", dbHandler.DeleteEvent)

	auth.GET("/responsible", dbHandler.GetResponsible)
	auth.POST("/responsible/add", dbHandler.AddNewResponsible)
	auth.POST("/responsible/delete", dbHandler.DeleteResponsible)

	auth.POST("/roles/add", accessHandler.AddRole)
	auth.POST("/roles/update", accessHandler.UpdateRole)
	auth.POST("/roles/delete", accessHandler.DeleteRole)

	auth.POST("/users/add", accessHandler.AddUser)
	auth.POST("/users/update", accessHandler.UpdateUser)
	auth.POST("/users/delete", accessHandler.DeleteUser)

	api.POST("/login/refresh", accessHandler.Refresh)

	// Serve static files
	s.Routes.StaticFS("/assets", gin.Dir(filepath.Join(spa, "assets"), true))
	s.Routes.NoRoute(func(c *gin.Context) {
		// Disallow fallback for /api paths
		if strings.HasPrefix(c.Request.URL.Path, "/api") {
			c.JSON(http.StatusNotFound, models.NewJsonMessageResponse("API endpoint not found"))
			return
		}
		// Try to serve file from SPA directory
		filePath := filepath.Join(spa, c.Request.URL.Path)
		if _, err := os.Stat(filePath); err == nil {
			c.File(filePath)
			return
		}
		// Fallback to index.html for SPA routing
		c.File(filepath.Join(spa, "index.html"))

	})

	go func() {
		time.Sleep(500 * time.Millisecond)
		if err := utils.OpenBrowser(fmt.Sprintf("%slocalhost:%s", httpString, env.HostPort.GetValue()), logger); err != nil {
			logger.Error("main", fmt.Sprintf("starting browser error : %s", err))
		}
	}()

	if env.Https.GetBoolValue() {
		if env.Fullchain.GetValue() == "" {
			logger.Error("ssl certificate", "-cert flag not given for https server")
			log.Fatal("-cert flag not given for https server")
		}
		if env.PrivKey.GetValue() == "" {
			logger.Error("ssl key", "-chain flag not given for https server")
			log.Fatal("-chain flag not given for https server")
		}

		// start https server
		logger.Info("main", fmt.Sprintf("https listen on ip: %s port: %s", env.HostUrl.GetValue(), env.HostPort.GetValue()))
		if err := s.ServeHttps(env.HostUrl.GetValue(), env.HostPort.GetUIntValue(), cert.Cert{Organization: env.Organization.GetValue(), CertFile: env.Fullchain.GetValue(), KeyFile: env.PrivKey.GetValue()}); err != nil {
			logger.Error("main", "error https server "+err.Error())
		}
		return
	}

	// start http server
	logger.Info("main", fmt.Sprintf("http listen on ip: %s port: %s", env.HostUrl.GetValue(), env.HostPort.GetValue()))
	if err := s.ServeHttp(env.HostUrl.GetValue(), env.HostPort.GetUIntValue()); err != nil {
		logger.Error("main", "error http server "+err.Error())
	}
}