github
/
statping
mirror of https://github.com/statping/statping
1
0
Fork 0
Code Issues Releases Wiki Activity

service fix - source assets - fixes

pull/41/head^2
Hunter Long 2018-08-11 10:24:32 -06:00
parent 09f094312e
commit 7db705d43a
11 changed files with 203 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/cli.go
View File

@ -29,9 +29,9 @@ func CatchCLI(args []string) {
fmt.Printf("Statup v%v\n", VERSION)
case "assets":
source.Assets()
core.CreateAllAssets(dir)
source.CreateAllAssets(dir)
case "sass":
core.CompileSASS(dir)
source.CompileSASS(dir)
case "update":
gitCurrent, err := CheckGithubUpdates()
if err != nil {

2
cmd/main.go
View File

@ -35,7 +35,7 @@ func main() {
}
utils.Log(1, fmt.Sprintf("Starting Statup v%v", VERSION))
source.Assets()
core.HasAssets(directory)
source.HasAssets(directory)
core.Configs, err = core.LoadConfig()
if err != nil {

3
cmd/main_test.go
View File

@ -42,7 +42,8 @@ func RunInit(t *testing.T) {
func TestRunAll(t *testing.T) {
//t.Parallel()
databases := []string{"sqlite", "postgres", "mysql"}
//databases := []string{"sqlite", "postgres", "mysql"}
databases := []string{"sqlite"}
for _, dbt := range databases {

127
core/assets.go
View File

@ -1,127 +0,0 @@
package core
import (
"fmt"
"github.com/GeertJohan/go.rice"
"github.com/hunterlong/statup/source"
"github.com/hunterlong/statup/utils"
"io/ioutil"
"os"
"os/exec"
)
func CopyToPublic(box *rice.Box, folder, file string) {
assetFolder := fmt.Sprintf("%v/%v", folder, file)
utils.Log(1, fmt.Sprintf("Copying %v to %v", file, assetFolder))
base, err := box.String(file)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to copy %v to %v, %v.", file, assetFolder, err))
}
err = ioutil.WriteFile(assetFolder, []byte(base), 0644)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to write file %v to %v, %v.", file, assetFolder, err))
}
}
func MakePublicFolder(folder string) {
utils.Log(1, fmt.Sprintf("Creating folder '%v'", folder))
if _, err := os.Stat(folder); os.IsNotExist(err) {
err = os.MkdirAll(folder, 0755)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to created %v directory, %v", folder, err))
}
}
}
func CompileSASS(folder string) error {
sassBin := os.Getenv("SASS")
shell := os.Getenv("CMD_FILE")
scssFile := fmt.Sprintf("%v/%v", folder, "assets/scss/base.scss")
baseFile := fmt.Sprintf("%v/%v", folder, "assets/css/base.css")
utils.Log(1, fmt.Sprintf("Compiling SASS %v into %v", scssFile, baseFile))
command := fmt.Sprintf("%v %v %v", sassBin, scssFile, baseFile)
testCmd := exec.Command(shell, command)
_, err := testCmd.Output()
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to compile assets with SASS %v", err))
utils.Log(3, fmt.Sprintf("%v %v %v", sassBin, scssFile, baseFile))
return err
}
utils.Log(1, "SASS Compiling is complete!")
return err
}
func HasAssets(folder string) bool {
if _, err := os.Stat(folder + "/assets"); err == nil {
utils.Log(1, "Assets folder was found!")
UsingAssets = true
return true
} else {
assetEnv := os.Getenv("USE_ASSETS")
if assetEnv == "true" {
utils.Log(1, "Environment variable USE_ASSETS was found.")
CreateAllAssets(folder)
err := CompileSASS(folder)
if err != nil {
CopyToPublic(source.CssBox, folder+"/css", "base.css")
utils.Log(2, "Default 'base.css' was insert because SASS did not work.")
return true
}
UsingAssets = true
return true
}
}
return false
}
func SaveAsset(data, folder, file string) {
utils.Log(1, fmt.Sprintf("Saving %v/%v into assets folder", folder, file))
err := ioutil.WriteFile(folder+"/assets/"+file, []byte(data), 0644)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to save %v/%v, %v", folder, file, err))
}
}
func OpenAsset(folder, file string) string {
dat, err := ioutil.ReadFile(folder + "/assets/" + file)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to open %v, %v", file, err))
return ""
}
return string(dat)
}
func CreateAllAssets(folder string) error {
utils.Log(1, fmt.Sprintf("Dump Statup assets into %v/assets", folder))
MakePublicFolder(folder + "/assets")
MakePublicFolder(folder + "/assets/js")
MakePublicFolder(folder + "/assets/css")
MakePublicFolder(folder + "/assets/scss")
utils.Log(1, "Inserting scss, css, and javascript files into assets folder")
CopyToPublic(source.ScssBox, folder+"/assets/scss", "base.scss")
CopyToPublic(source.ScssBox, folder+"/assets/scss", "variables.scss")
CopyToPublic(source.CssBox, folder+"/assets/css", "bootstrap.min.css")
CopyToPublic(source.CssBox, folder+"/assets/css", "base.css")
CopyToPublic(source.JsBox, folder+"/assets/js", "bootstrap.min.js")
CopyToPublic(source.JsBox, folder+"/assets/js", "Chart.bundle.min.js")
CopyToPublic(source.JsBox, folder+"/assets/js", "jquery-3.3.1.slim.min.js")
CopyToPublic(source.JsBox, folder+"/assets/js", "main.js")
CopyToPublic(source.JsBox, folder+"/assets/js", "setup.js")
CopyToPublic(source.TmplBox, folder+"/assets", "robots.txt")
CopyToPublic(source.TmplBox, folder+"/assets", "statup.png")
utils.Log(1, "Compiling CSS from SCSS style...")
err := utils.Log(1, "Statup assets have been inserted")
return err
}
func DeleteAllAssets(folder string) error {
err := os.RemoveAll(folder + "/assets")
if err != nil {
utils.Log(1, fmt.Sprintf("There was an issue deleting Statup Assets, %v", err))
return err
}
utils.Log(1, "Statup assets have been deleted")
return err
}

24
core/core.go
View File

@ -2,6 +2,7 @@ package core
import (
"github.com/hunterlong/statup/notifiers"
"github.com/hunterlong/statup/source"
"github.com/hunterlong/statup/types"
"github.com/pkg/errors"
"os"
@ -17,11 +18,10 @@ type Core struct {
}
var (
Configs *types.Config
CoreApp *Core
SetupMode bool
UsingAssets bool
VERSION string
Configs *types.Config
CoreApp *Core
SetupMode bool
VERSION string
)
func init() {
@ -72,28 +72,28 @@ func UpdateCore(c *Core) (*Core, error) {
}
func (c Core) UsingAssets() bool {
return UsingAssets
return source.UsingAssets
}
func (c Core) SassVars() string {
if !UsingAssets {
if !source.UsingAssets {
return ""
}
return OpenAsset(".", "scss/variables.scss")
return source.OpenAsset(".", "scss/variables.scss")
}
func (c Core) BaseSASS() string {
if !UsingAssets {
if !source.UsingAssets {
return ""
}
return OpenAsset(".", "scss/base.scss")
return source.OpenAsset(".", "scss/base.scss")
}
func (c Core) MobileSASS() string {
if !UsingAssets {
if !source.UsingAssets {
return ""
}
return OpenAsset(".", "scss/mobile.scss")
return source.OpenAsset(".", "scss/mobile.scss")
}
func (c Core) AllOnline() bool {

27
core/core_test.go
View File

@ -4,7 +4,6 @@ import (
"github.com/hunterlong/statup/source"
"github.com/hunterlong/statup/utils"
"github.com/stretchr/testify/assert"
"os"
"testing"
)
@ -68,32 +67,6 @@ func TestSelectLastMigration(t *testing.T) {
assert.NotZero(t, id)
}
func TestCore_UsingAssets(t *testing.T) {
assert.False(t, testCore.UsingAssets())
}
func TestHasAssets(t *testing.T) {
assert.False(t, HasAssets(dir))
}
func TestCreateAssets(t *testing.T) {
assert.Nil(t, CreateAllAssets(dir))
assert.True(t, HasAssets(dir))
}
func TestCompileSASS(t *testing.T) {
t.SkipNow()
os.Setenv("SASS", "sass")
os.Setenv("CMD_FILE", dir+"/cmd.sh")
assert.Nil(t, CompileSASS(dir))
assert.True(t, HasAssets(dir))
}
func TestDeleteAssets(t *testing.T) {
assert.Nil(t, DeleteAllAssets(dir))
assert.False(t, HasAssets(dir))
}
func TestInsertNotifierDB(t *testing.T) {
err := InsertNotifierDB()
assert.Nil(t, err)

4
handlers/handlers_test.go
View File

@ -412,7 +412,7 @@ func TestSaveAssetsHandler(t *testing.T) {
assert.FileExists(t, utils.Directory+"/assets/css/base.css")
assert.FileExists(t, utils.Directory+"/assets/js/main.js")
assert.DirExists(t, utils.Directory+"/assets")
assert.True(t, core.UsingAssets)
assert.True(t, source.UsingAssets)
}
func TestDeleteAssetsHandler(t *testing.T) {
@ -421,7 +421,7 @@ func TestDeleteAssetsHandler(t *testing.T) {
rr := httptest.NewRecorder()
Router().ServeHTTP(rr, req)
assert.Equal(t, 303, rr.Code)
assert.False(t, core.UsingAssets)
assert.False(t, source.UsingAssets)
}
func TestPrometheusHandler(t *testing.T) {

2
handlers/routes.go
View File

@ -69,7 +69,7 @@ func Router() *mux.Router {
}
func LocalizedAssets(r *mux.Router) *mux.Router {
if core.UsingAssets {
if source.UsingAssets {
cssHandler := http.FileServer(http.Dir("./assets/css"))
jsHandler := http.FileServer(http.Dir("./assets/js"))
indexHandler := http.FileServer(http.Dir("./assets/"))

18
handlers/settings.go
View File

@ -58,9 +58,9 @@ func SaveSASSHandler(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
theme := r.PostForm.Get("theme")
variables := r.PostForm.Get("variables")
core.SaveAsset(theme, ".", "scss/base.scss")
core.SaveAsset(variables, ".", "scss/variables.scss")
core.CompileSASS(".")
source.SaveAsset(theme, ".", "scss/base.scss")
source.SaveAsset(variables, ".", "scss/variables.scss")
source.CompileSASS(".")
http.Redirect(w, r, "/settings", http.StatusSeeOther)
}
@ -70,13 +70,13 @@ func SaveAssetsHandler(w http.ResponseWriter, r *http.Request) {
return
}
dir := utils.Directory
core.CreateAllAssets(dir)
err := core.CompileSASS(dir)
source.CreateAllAssets(dir)
err := source.CompileSASS(dir)
if err != nil {
core.CopyToPublic(source.CssBox, dir+"/assets/css", "base.css")
source.CopyToPublic(source.CssBox, dir+"/assets/css", "base.css")
utils.Log(2, "Default 'base.css' was insert because SASS did not work.")
}
core.UsingAssets = true
source.UsingAssets = true
http.Redirect(w, r, "/settings", http.StatusSeeOther)
}
@ -85,8 +85,8 @@ func DeleteAssetsHandler(w http.ResponseWriter, req *http.Request) {
http.Redirect(w, req, "/", http.StatusSeeOther)
return
}
core.DeleteAllAssets(".")
core.UsingAssets = false
source.DeleteAllAssets(".")
source.UsingAssets = false
LocalizedAssets(r)
http.Redirect(w, req, "/settings", http.StatusSeeOther)
}

136
source/source.go
View File

@ -1,13 +1,21 @@
package source
import "github.com/GeertJohan/go.rice"
import (
"fmt"
"github.com/GeertJohan/go.rice"
"github.com/hunterlong/statup/utils"
"io/ioutil"
"os"
"os/exec"
)
var (
SqlBox *rice.Box
CssBox *rice.Box
ScssBox *rice.Box
JsBox *rice.Box
TmplBox *rice.Box
SqlBox *rice.Box
CssBox *rice.Box
ScssBox *rice.Box
JsBox *rice.Box
TmplBox *rice.Box
UsingAssets bool
)
func Assets() {
@ -17,3 +25,119 @@ func Assets() {
JsBox = rice.MustFindBox("js")
TmplBox = rice.MustFindBox("tmpl")
}
func CompileSASS(folder string) error {
sassBin := os.Getenv("SASS")
shell := os.Getenv("CMD_FILE")
scssFile := fmt.Sprintf("%v/%v", folder, "assets/scss/base.scss")
baseFile := fmt.Sprintf("%v/%v", folder, "assets/css/base.css")
utils.Log(1, fmt.Sprintf("Compiling SASS %v into %v", scssFile, baseFile))
command := fmt.Sprintf("%v %v %v", sassBin, scssFile, baseFile)
testCmd := exec.Command(shell, command)
_, err := testCmd.Output()
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to compile assets with SASS %v", err))
utils.Log(3, fmt.Sprintf("%v %v %v", sassBin, scssFile, baseFile))
return err
}
utils.Log(1, "SASS Compiling is complete!")
return err
}
func HasAssets(folder string) bool {
if _, err := os.Stat(folder + "/assets"); err == nil {
utils.Log(1, "Assets folder was found!")
UsingAssets = true
return true
} else {
assetEnv := os.Getenv("USE_ASSETS")
if assetEnv == "true" {
utils.Log(1, "Environment variable USE_ASSETS was found.")
CreateAllAssets(folder)
err := CompileSASS(folder)
if err != nil {
CopyToPublic(CssBox, folder+"/css", "base.css")
utils.Log(2, "Default 'base.css' was insert because SASS did not work.")
return true
}
UsingAssets = true
return true
}
}
return false
}
func SaveAsset(data, folder, file string) {
utils.Log(1, fmt.Sprintf("Saving %v/%v into assets folder", folder, file))
err := ioutil.WriteFile(folder+"/assets/"+file, []byte(data), 0644)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to save %v/%v, %v", folder, file, err))
}
}
func OpenAsset(folder, file string) string {
dat, err := ioutil.ReadFile(folder + "/assets/" + file)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to open %v, %v", file, err))
return ""
}
return string(dat)
}
func CreateAllAssets(folder string) error {
utils.Log(1, fmt.Sprintf("Dump Statup assets into %v/assets", folder))
MakePublicFolder(folder + "/assets")
MakePublicFolder(folder + "/assets/js")
MakePublicFolder(folder + "/assets/css")
MakePublicFolder(folder + "/assets/scss")
utils.Log(1, "Inserting scss, css, and javascript files into assets folder")
CopyToPublic(ScssBox, folder+"/assets/scss", "base.scss")
CopyToPublic(ScssBox, folder+"/assets/scss", "variables.scss")
CopyToPublic(CssBox, folder+"/assets/css", "bootstrap.min.css")
CopyToPublic(CssBox, folder+"/assets/css", "base.css")
CopyToPublic(JsBox, folder+"/assets/js", "bootstrap.min.js")
CopyToPublic(JsBox, folder+"/assets/js", "Chart.bundle.min.js")
CopyToPublic(JsBox, folder+"/assets/js", "jquery-3.3.1.slim.min.js")
CopyToPublic(JsBox, folder+"/assets/js", "main.js")
CopyToPublic(JsBox, folder+"/assets/js", "setup.js")
CopyToPublic(TmplBox, folder+"/assets", "robots.txt")
CopyToPublic(TmplBox, folder+"/assets", "statup.png")
utils.Log(1, "Compiling CSS from SCSS style...")
err := utils.Log(1, "Statup assets have been inserted")
return err
}
func DeleteAllAssets(folder string) error {
err := os.RemoveAll(folder + "/assets")
if err != nil {
utils.Log(1, fmt.Sprintf("There was an issue deleting Statup Assets, %v", err))
return err
}
utils.Log(1, "Statup assets have been deleted")
return err
}
func CopyToPublic(box *rice.Box, folder, file string) {
assetFolder := fmt.Sprintf("%v/%v", folder, file)
utils.Log(1, fmt.Sprintf("Copying %v to %v", file, assetFolder))
base, err := box.String(file)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to copy %v to %v, %v.", file, assetFolder, err))
}
err = ioutil.WriteFile(assetFolder, []byte(base), 0644)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to write file %v to %v, %v.", file, assetFolder, err))
}
}
func MakePublicFolder(folder string) {
utils.Log(1, fmt.Sprintf("Creating folder '%v'", folder))
if _, err := os.Stat(folder); os.IsNotExist(err) {
err = os.MkdirAll(folder, 0755)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to created %v directory, %v", folder, err))
}
}
}

44
source/source_test.go Normal file
View File

@ -0,0 +1,44 @@
package source
import (
"github.com/hunterlong/statup/utils"
"github.com/stretchr/testify/assert"
"os"
"testing"
)
var (
dir string
)
func init() {
dir = utils.Directory
utils.InitLogs()
Assets()
}
func TestCore_UsingAssets(t *testing.T) {
assert.False(t, UsingAssets)
}
func TestHasAssets(t *testing.T) {
assert.False(t, HasAssets(dir))
}
func TestCreateAssets(t *testing.T) {
assert.Nil(t, CreateAllAssets(dir))
assert.True(t, HasAssets(dir))
}
func TestCompileSASS(t *testing.T) {
t.SkipNow()
os.Setenv("SASS", "sass")
os.Setenv("CMD_FILE", dir+"/cmd.sh")
assert.Nil(t, CompileSASS(dir))
assert.True(t, HasAssets(dir))
}
func TestDeleteAssets(t *testing.T) {
assert.Nil(t, DeleteAllAssets(dir))
assert.False(t, HasAssets(dir))
}