ecodash/http.go
MassiveBox 7a1214d492 Added arm builds, improve database
- The program will now be cross-compiled and released for arm as well as x86
- What we previously called "cache" is not actually a cache, as it holds content that can't be always retrieved. Now we're stopping calling it a cache.
- Improved history merging
- Fixed the README to include the database as a volume, and to fix some errors
2023-01-29 21:16:04 +01:00

232 lines
6.4 KiB
Go

package main
import (
"encoding/json"
"errors"
"fmt"
"github.com/gofiber/fiber/v2"
"html/template"
"math"
"os"
"reflect"
"strconv"
"time"
)
type Link struct {
Label string `json:"label"`
Destination string `json:"destination"`
NewTab bool `json:"new_tab"`
Primary bool `json:"primary"`
}
type Warning struct {
Header string
Body string
BodyHTML template.HTML
IsSuccess bool
}
func (config Config) getTemplateDefaults() fiber.Map {
return fiber.Map{
"DashboardName": config.Dashboard.Name,
"HeaderLinks": config.Dashboard.HeaderLinks,
"FooterLinks": config.Dashboard.FooterLinks,
}
}
func (config Config) templateDefaultsMap() fiber.Map {
return fiber.Map{
"Default": config.getTemplateDefaults(),
}
}
func (config Config) adminEndpoint(c *fiber.Ctx) error {
if c.Method() == "POST" {
if config.isAuthorized(c) { // here the user is submitting the form to change configuration
err := config.saveAdminForm(c)
if err != nil {
return config.renderAdminPanel(c, Warning{
Header: "An error occurred!",
Body: err.Error(),
})
}
return config.renderAdminPanel(c, Warning{
Header: "Restart needed",
Body: "In order to apply changes, please <b>restart EcoDash</b>.<br>" +
"If you're running via Docker, click <a href='./restart'>here</a> to restart automatically.",
IsSuccess: true,
})
}
// here the user is trying to authenticate
if c.FormValue("username") == config.Administrator.Username && hash(c.FormValue("password")) == config.Administrator.PasswordHash {
c.Cookie(&fiber.Cookie{Name: "admin_username", Value: c.FormValue("username")})
c.Cookie(&fiber.Cookie{Name: "admin_password_hash", Value: hash(c.FormValue("password"))})
return config.renderAdminPanel(c)
}
return c.Render("login", fiber.Map{"Defaults": config.getTemplateDefaults(), "Failed": true}, "base")
}
if config.isAuthorized(c) {
return config.renderAdminPanel(c)
}
return c.Render("login", config.templateDefaultsMap(), "base")
}
func (config Config) renderAdminPanel(c *fiber.Ctx, warning ...Warning) error {
dirs, err := os.ReadDir("./templates")
if err != nil {
return err
}
if len(warning) > 0 {
warning[0].BodyHTML = template.HTML(warning[0].Body)
return c.Render("admin", fiber.Map{
"Defaults": config.getTemplateDefaults(),
"Themes": dirs,
"Config": config,
"Warning": warning[0],
}, "base")
}
return c.Render("admin", fiber.Map{
"Defaults": config.getTemplateDefaults(),
"Themes": dirs,
"Config": config,
}, "base")
}
func (config Config) saveAdminForm(c *fiber.Ctx) error {
requiredFields := []string{"base_url", "api_key", "polled_smart_energy_summation", "fossil_percentage", "username", "theme", "name", "installation_date"}
for _, requiredField := range requiredFields {
if c.FormValue(requiredField) == "" {
return errors.New("Required field is missing: " + requiredField)
}
}
parsedTime, err := time.Parse("2006-01-02", c.FormValue("installation_date"))
if err != nil {
return err
}
form := Config{
HomeAssistant: HomeAssistant{ /*BaseURL to be filled later*/ ApiKey: c.FormValue("api_key"), InstallationDate: dayStart(parsedTime)},
Sensors: Sensors{PolledSmartEnergySummation: c.FormValue("polled_smart_energy_summation"), FossilPercentage: c.FormValue("fossil_percentage")},
Administrator: Administrator{Username: c.FormValue("username") /*PasswordHash to be filled later*/},
Dashboard: Dashboard{Theme: c.FormValue("theme"), Name: c.FormValue("name"), HeaderLinks: config.Dashboard.HeaderLinks, FooterLinks: config.Dashboard.FooterLinks},
}
if c.FormValue("keep_old_password") == "" {
form.Administrator.PasswordHash = hash(c.FormValue("password"))
} else {
form.Administrator.PasswordHash = config.Administrator.PasswordHash
}
fmtURL, err := formatURL(c.FormValue("base_url"))
if err != nil {
return err
}
form.HomeAssistant.BaseURL = fmtURL
if reflect.DeepEqual(form, config) {
return errors.New("No changes from previous config.")
}
form.db = config.db
err = form.refreshCacheFromInstall()
if err != nil {
return err
}
js, err := json.Marshal(form)
if err != nil {
return err
}
return os.WriteFile("config.json", js, 0666)
}
func averageExcludingCurrentDay(data []float32) float32 {
if len(data) == 0 {
return 0
}
data = data[:len(data)-1]
var sum float32
for _, num := range data {
sum += num
}
var avg = sum / float32(len(data))
return float32(math.Floor(float64(avg)*100)) / 100
}
func (config Config) renderIndex(c *fiber.Ctx) error {
if config.HomeAssistant.InstallationDate.IsZero() {
return c.Render("config-error", fiber.Map{
"Defaults": config.getTemplateDefaults(),
"Error": "The installation date is not set! This is normal if you've just updated from v0.1 to v0.2.",
}, "base")
}
data, err := config.readHistory()
if err != nil {
return err
}
var (
labels []string
greenEnergyConsumptionAbsolute []float32
greenEnergyPercents []float32
energyConsumptions []float32
)
for _, datum := range data {
labels = append(labels, time.Unix(datum.Date, 0).Format("02/01"))
greenEnergyPercents = append(greenEnergyPercents, datum.GreenEnergyPercentage)
greenEnergyConsumptionAbsolute = append(greenEnergyConsumptionAbsolute, datum.GreenEnergyPercentage/100*datum.PolledSmartEnergySummation)
energyConsumptions = append(energyConsumptions, datum.PolledSmartEnergySummation)
}
perDayUsage := averageExcludingCurrentDay(energyConsumptions)
return c.Render("index", fiber.Map{
"Defaults": config.getTemplateDefaults(),
"Labels": labels,
"GreenEnergyPercents": greenEnergyConsumptionAbsolute,
"EnergyConsumptions": energyConsumptions,
"GreenEnergyPercent": averageExcludingCurrentDay(greenEnergyPercents),
"PerDayUsage": perDayUsage,
}, "base")
}
func templateDivide(num1, num2 float32) template.HTML {
division := float64(num1 / num2)
powerOfTen := int(math.Floor(math.Log10(division)))
if powerOfTen >= -2 && powerOfTen <= 2 {
return template.HTML(fmt.Sprintf("%s", strconv.FormatFloat(math.Round(division*100)/100, 'f', -1, 64)))
}
preComma := division / math.Pow10(powerOfTen)
return template.HTML(fmt.Sprintf("%s * 10<sup>%d</sup>", strconv.FormatFloat(math.Round(preComma*100)/100, 'f', -1, 64), powerOfTen))
}
func templateHTMLDateFormat(date time.Time) template.HTML {
if date.IsZero() {
return ""
}
return template.HTML(date.Format("2006-01-02"))
}