initial commit

app/api/events.go

@@ -0,0 +1,20 @@
+package api
+
+import (
+	"git.aiterp.net/lucifer/server3/app/config"
+	"git.aiterp.net/lucifer/server3/models"
+	"github.com/gin-gonic/gin"
+)
+
+func Events(r gin.IRoutes) {
+	r.POST("", handler(func(c *gin.Context) (interface{}, error) {
+		var event models.Event
+		err := parseBody(c, &event)
+		if err != nil {
+			return nil, err
+		}
+
+		config.EventChannel<-event
+		return event, nil
+	}))
+}

app/api/util.go

@@ -0,0 +1,46 @@
+package api
+
+import (
+	"encoding/json"
+	"git.aiterp.net/lucifer/server3/models"
+	"github.com/gin-gonic/gin"
+)
+
+var errorMap = map[error]int{
+	models.ErrInvalidName: 400,
+}
+
+type response struct {
+	Code    int         `json:"code"`
+	Message string      `json:"message"`
+	Data    interface{} `json:"data"`
+}
+
+func handler(fun func(c *gin.Context) (interface{}, error)) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		val, err := fun(c)
+		if err != nil {
+			errCode := errorMap[err]
+			if errCode == 0 {
+				errCode = 500
+			}
+
+			c.JSON(errCode, response{
+				Code: errCode,
+				Message: err.Error(),
+			})
+			return
+		}
+
+		c.JSON(200, val)
+	}
+}
+
+func parseBody(c *gin.Context, target interface{}) error {
+	err := json.NewDecoder(c.Request.Body).Decode(target)
+	if err != nil {
+		return models.ErrBadInput
+	}
+
+	return nil
+}

app/config/channels.go

@@ -0,0 +1,7 @@
+package config
+
+import "git.aiterp.net/lucifer/server3/models"
+
+var EventChannel = make(chan models.Event, 8)
+
+var ChangeChannel = make(chan string, 16)

app/config/driver.go

@@ -0,0 +1,13 @@
+package config
+
+import "git.aiterp.net/lucifer/server3/models"
+
+var dr models.DriverResolver
+
+func DriverResolver() models.DriverResolver {
+	if dr == nil {
+		panic("not implemented yet")
+	}
+
+	return dr
+}

app/config/env.go

@@ -0,0 +1,31 @@
+package config
+
+import (
+	"os"
+	"strconv"
+)
+
+var MySqlHost = strEnv("LUCIFER_MYSQL_HOST")
+var MySqlPort = intEnv("LUCIFER_MYSQL_PORT")
+var MySqlUsername = strEnv("LUCIFER_MYSQL_USERNAME")
+var MySQlPassword = strEnv("LUCIFER_MYSQL_PASSWORD")
+
+var ServerPort = intEnv("LUCIFER_SERVER_PORT")
+
+func strEnv(key string) string {
+	env, ok := os.LookupEnv(key)
+	if !ok {
+		panic("missing environment variable: " + key)
+	}
+
+	return env
+}
+
+func intEnv(key string) int {
+	val, err := strconv.Atoi(strEnv(key))
+	if err != nil {
+		panic("invalid environment variable: " + key)
+	}
+
+	return val
+}

app/config/repo.go

@@ -0,0 +1,24 @@
+package config
+
+import "git.aiterp.net/lucifer/server3/models"
+
+var (
+	dRepo  models.DeviceRepository
+	ehRepo models.EventHandlerRepository
+)
+
+func DeviceRepository() models.DeviceRepository {
+	if dRepo == nil {
+		panic("panik")
+	}
+
+	return dRepo
+}
+
+func EventHandlerRepository() models.EventHandlerRepository {
+	if ehRepo == nil {
+		panic("panik")
+	}
+
+	return ehRepo
+}

app/server.go

@@ -0,0 +1,20 @@
+package app
+
+import (
+	"fmt"
+	"git.aiterp.net/lucifer/server3/app/api"
+	"git.aiterp.net/lucifer/server3/app/config"
+	"git.aiterp.net/lucifer/server3/app/services"
+	"github.com/gin-gonic/gin"
+	"log"
+)
+
+func StartServer() {
+	services.StartEventHandler()
+
+	gin.SetMode(gin.ReleaseMode)
+	ginny := gin.New()
+	api.Events(ginny.Group("/api/events"))
+
+	log.Fatal(ginny.Run(fmt.Sprintf("0.0.0.0:%d", config.ServerPort)))
+}

app/services/events.go

@@ -0,0 +1,59 @@
+package services
+
+import (
+	"context"
+	"git.aiterp.net/lucifer/server3/app/config"
+	"git.aiterp.net/lucifer/server3/models"
+	"log"
+	"time"
+)
+
+func StartEventHandler() {
+	config.EventChannel<-models.Event{Name: "LuciferStarted"}
+
+	go func() {
+		for event := range config.EventChannel {
+			handleEvent(event)
+		}
+	}()
+
+	// Dispatch an HourChanged event at every hour
+	go func() {
+		for {
+			now := time.Now()
+			nextHour := now.Add(time.Hour).Truncate(time.Hour)
+			time.Sleep(nextHour.Sub(now))
+
+			config.EventChannel <- models.Event{Name: "HourChanged"}
+		}
+	}()
+}
+
+var loc, _ = time.LoadLocation("Europe/Oslo")
+var ctx = context.Background()
+
+func handleEvent(event models.Event) {
+	if !event.HasPayload("hour") {
+		event.AddPayload("hour", time.Now().In(loc).Format("15"))
+	}
+
+	handlers, err := config.EventHandlerRepository().FetchAll(ctx)
+	if err != nil {
+		log.Printf("Error fetchin event halders: %d", err)
+		return
+	}
+
+	for _, handler := range handlers {
+		devices, err := config.DeviceRepository().FetchByReference(ctx, handler.TargetKind, handler.TargetValue)
+		if err != nil {
+			log.Printf("Error fetchin event halders: %d", err)
+			return
+		}
+
+		if !handler.MatchesEvent(event, devices) {
+			continue
+		}
+
+		panic("panik")
+	}
+}