hikan.ru/main.go

package main

import (
	"html/template"
	"log"
	"main/config"
	"main/mvc/controllers"
	"main/mvc/models"
	"main/tools"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"strings"

	"git.hikan.ru/serr/candycache"
	"github.com/gin-gonic/gin"
	"github.com/yosssi/gcss"
)

/*
	For server start:

sudo systemctl stop server.service
go build main.go
sudo systemctl start server.service

*/

func main() {
	// load config
	if err := config.LoadConfig("config/config.json"); err != nil {
		log.Fatal("config.LoadConfig error: ", err)
	}

	inUse, err := tools.IsIPInUse(config.Cfg.ServerIP)
	if err != nil {
		log.Fatal(err)
	} else if inUse {
		// server start
		gin.SetMode(gin.ReleaseMode)
		startSiteProcess(config.Cfg.ServerIP)
	} else {
		// localhost start
		startSiteProcess("localhost")
	}
}

func startSiteProcess(ip string) {
	// CSS render
	_, err := gcss.CompileFile(config.Cfg.GcssPath)
	if err != nil {
		log.Fatal("gcss.CompileFile error: ", err)
	}

	// Get empty site ctx
	s := models.NewSiteCtx()

	// Create connection with db
	s.DB, err = models.DBConnect(config.Cfg.DBPath)
	if err != nil {
		log.Fatal(err)
	}
	// Get posts list from DB
	s.Posts, err = models.PostsListFromDB(s.DB)
	if err != nil {
		log.Fatal(err)
	}
	// Get tags map
	s.Tags = s.Posts.TagsMap()

	// TG worker
	s.Bot = models.TGNew(config.Cfg.TgBotToken, config.Cfg.TgChatID)
	// LFM worker
	s.LFM = models.LFMNew(config.Cfg.LastFmUsername, config.Cfg.LastfmAPIKey)
	// Get last track LFM
	if track, err := s.LFM.LastTrack(); err != nil {
		log.Fatal(err)
	} else {
		s.LastTrackAjaxBlock = s.LFM.TrackAjax(track)
	}

	// Create cache storage
	s.Cache = candycache.Cacher(-1)
	// Create gin instance
	s.GinEngine = gin.New()
	s.GinEngine.Use(controllers.Logger(s))
	controllers.CreateSessionsStore(s.GinEngine)
	// Set up routes
	if err = setupRoutes(s); err != nil {
		log.Fatal(err)
	}
	// Start tickers
	s.RunTickers()
	// Start server
	if err := s.Run(ip + ":80"); err != nil {
		log.Fatal(err)
	}
	// DB close
	models.DBClose(s.DB)
}

var funcMap = template.FuncMap{
	"add":                func(number, value int) int { return number + value },
	"SplitString":        strings.Split,
	"DaysSinceStartSite": tools.DaysSinceStartSite,
	"getCurTime":         tools.GetCurTime,
	"urlQueryEscape":     url.QueryEscape,
}

func initRoutes(s *models.Site) {
	// Root
	s.GinEngine.GET("/", func(c *gin.Context) {
		c.Redirect(http.StatusFound, "/index/1")
	})

	// API routes
	s.GinEngine.GET("/api/get_last_track", func(c *gin.Context) {
		c.Header("Content-Type", "text/html")
		c.String(http.StatusOK, s.LastTrackAjaxBlock)
	})

	// Static (js, css, pic)
	s.GinEngine.Static("/assets", "./assets")
	// No route
	s.GinEngine.NoRoute(func(c *gin.Context) {
		c.Redirect(http.StatusFound, "/index/1?Нет доступа")
	})

	// Routes without authorize check
	unauthorized := s.GinEngine.Group("")
	{
		controllers.PageByName("mobile", unauthorized, s)
		controllers.PageByName("login", unauthorized, s)
		controllers.PageByName("AJAXlogin", unauthorized, s)
		controllers.Login("login", unauthorized, s)
		controllers.PageByName("index", unauthorized, s)
		controllers.PageByName("AJAXindex", unauthorized, s)
		controllers.PageByName("post", unauthorized, s)
		controllers.PageByName("AJAXpost", unauthorized, s)
		controllers.PageByName("tags", unauthorized, s)
		controllers.PageByName("AJAXtags", unauthorized, s)
		controllers.PageByName("404", unauthorized, s)
		controllers.SearchPage("search", unauthorized, s)
		controllers.SearchPage("AJAXsearch", unauthorized, s)
		controllers.SendMesssage("send", unauthorized, s)
	}

	// Need authorize check
	authorized := s.GinEngine.Group("", controllers.AuthMiddleware())
	{
		controllers.PageByName("editpage", authorized, s)
		controllers.PageByName("AJAXeditpage", authorized, s)
		controllers.Logout("logout", authorized, s) //
		controllers.PageByName("logout", authorized, s)
		controllers.PageByName("AJAXlogout", authorized, s)
		controllers.PageByName("adm", authorized, s)
		controllers.PageByName("AJAXadm", authorized, s)
		controllers.DownloadCache(authorized, s)
		controllers.CacheClear("cacheclear", authorized, s)
		controllers.DeleteFromCache("deletefromcache", authorized, s)
		controllers.UploadCache("uploadcachedump", authorized, s)
		controllers.EditPost("editpost", authorized, s)
		controllers.AddPost("addpost", authorized, s)
		controllers.DeletePost("delpost", authorized, s)
		controllers.Backup("knock", authorized, s)
	}
}

func setupRoutes(s *models.Site) error {
	// load templates from TemplatesPath
	tmpl := template.New("").Funcs(funcMap)
	fn := func(path string, f os.FileInfo, err error) error {
		if !f.IsDir() && strings.HasSuffix(f.Name(), ".gohtml") {
			var err error
			tmpl, err = tmpl.ParseFiles(path)
			if err != nil {
				return err
			}
		}
		return nil
	}

	if err := filepath.Walk(config.Cfg.TemplatesPath, fn); err != nil {
		return err
	}
	s.Tmpl = tmpl
	initRoutes(s)
	return nil
}