Can delete routine

api/actions.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -90,4 +91,23 @@ func declareActionsRoutes(cfg *config.Config, router *gin.RouterGroup) {
 
 		c.JSON(http.StatusOK, nil)
 	})
+
+	actionsRoutes.POST("/run", func(c *gin.Context) {
+		action := c.MustGet("action").(*reveil.Action)
+
+		cmd, err := action.Launch()
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("Unable to run the action: %s", err.Error())})
+			return
+		}
+
+		go func() {
+			err := cmd.Wait()
+			if err != nil {
+				log.Printf("%q: %s", action.Name, err.Error())
+			}
+		}()
+
+		c.JSON(http.StatusOK, true)
+	})
 }

api/alarm.go

@@ -20,7 +20,7 @@ func declareAlarmRoutes(cfg *config.Config, router *gin.RouterGroup) {
 
 	router.POST("/alarm/run", func(c *gin.Context) {
 		if player.CommonPlayer == nil {
-			err := player.WakeUp(cfg)
+			err := player.WakeUp(cfg, nil)
 			if err != nil {
 				c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()})
 				return

api/alarms.go

@@ -13,7 +13,7 @@ import (
 
 func declareAlarmsRoutes(cfg *config.Config, db *reveil.LevelDBStorage, resetTimer func(), router *gin.RouterGroup) {
 	router.GET("/alarms/next", func(c *gin.Context) {
-		alarm, err := reveil.GetNextAlarm(cfg, db)
+		alarm, _, err := reveil.GetNextAlarm(cfg, db)
 		if err != nil {
 			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()})
 			return

api/routines.go

@@ -78,4 +78,12 @@ func declareRoutinesRoutes(cfg *config.Config, router *gin.RouterGroup) {
 
 		c.JSON(http.StatusOK, nil)
 	})
+
+	routinesRoutes.POST("/run", func(c *gin.Context) {
+		routine := c.MustGet("routine").(*reveil.Routine)
+
+		go routine.Launch(cfg)
+
+		c.JSON(http.StatusOK, true)
+	})
 }

app.go

@@ -80,11 +80,11 @@ func (app *App) ResetTimer() {
 		app.nextAlarm = nil
 	}
 
-	if na, err := reveil.GetNextAlarm(app.cfg, app.db); err == nil && na != nil {
+	if na, routines, err := reveil.GetNextAlarm(app.cfg, app.db); err == nil && na != nil {
 		app.nextAlarm = time.AfterFunc(time.Until(*na), func() {
 			app.nextAlarm = nil
 			reveil.RemoveOldAlarmsSingle(app.db)
-			err := player.WakeUp(app.cfg)
+			err := player.WakeUp(app.cfg, routines)
 			if err != nil {
 				log.Println(err.Error())
 				return

model/action.go

@@ -4,9 +4,11 @@ import (
 	"bufio"
 	"crypto/sha512"
 	"errors"
+	"fmt"
 	"io/fs"
 	"log"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 
@@ -19,9 +21,10 @@ type Action struct {
 	Description string     `json:"description,omitempty"`
 	Path        string     `json:"path"`
 	Enabled     bool       `json:"enabled"`
+	fullPath    string
 }
 
-func LoadAction(path string) (string, string, error) {
+func loadAction(path string) (string, string, error) {
 	fd, err := os.Open(path)
 	if err != nil {
 		return "", "", err
@@ -64,6 +67,45 @@ func LoadAction(path string) (string, string, error) {
 	return name, description, nil
 }
 
+func LoadAction(cfg *config.Config, path string) (*Action, error) {
+	actionsDir, err := filepath.Abs(cfg.ActionsDir)
+	if err != nil {
+		return nil, err
+	}
+
+	path = filepath.Join(actionsDir, path)
+
+	d, err := os.Stat(path)
+	if err != nil {
+		return nil, err
+	}
+
+	if !d.Mode().IsRegular() {
+		return nil, fmt.Errorf("%q is not a file, it cannot be an action.", path)
+	}
+
+	hash := sha512.Sum512([]byte(path))
+
+	// Parse content
+	name, description, err := loadAction(path)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid action file (trying to parse %s): %s", path, err.Error())
+	}
+
+	if apath, err := filepath.Abs(path); err == nil {
+		path = apath
+	}
+
+	return &Action{
+		Id:          hash[:],
+		Name:        name,
+		Description: description,
+		Path:        strings.TrimPrefix(path, actionsDir+"/"),
+		Enabled:     d.Mode().Perm()&0111 != 0,
+		fullPath:    path,
+	}, nil
+}
+
 func LoadActions(cfg *config.Config) (actions []*Action, err error) {
 	actionsDir, err := filepath.Abs(cfg.ActionsDir)
 	if err != nil {
@@ -75,7 +117,7 @@ func LoadActions(cfg *config.Config) (actions []*Action, err error) {
 			hash := sha512.Sum512([]byte(path))
 
 			// Parse content
-			name, description, err := LoadAction(path)
+			name, description, err := loadAction(path)
 			if err != nil {
 				log.Printf("Invalid action file (trying to parse %s): %s", path, err.Error())
 				// Ignore invalid files
@@ -96,6 +138,7 @@ func LoadActions(cfg *config.Config) (actions []*Action, err error) {
 				Description: description,
 				Path:        strings.TrimPrefix(path, actionsDir+"/"),
 				Enabled:     d.Mode().Perm()&0111 != 0,
+				fullPath:    path,
 			})
 		}
 
@@ -130,3 +173,9 @@ func (a *Action) Disable() error {
 func (a *Action) Remove() error {
 	return os.Remove(a.Path)
 }
+
+func (a *Action) Launch() (cmd *exec.Cmd, err error) {
+	cmd = exec.Command(a.fullPath)
+	err = cmd.Start()
+	return
+}

model/alarm.go

@@ -40,37 +40,57 @@ func (h *Hour) UnmarshalJSON(src []byte) error {
 	return nil
 }
 
-func GetNextAlarm(cfg *config.Config, db *LevelDBStorage) (*time.Time, error) {
+func GetNextAlarm(cfg *config.Config, db *LevelDBStorage) (*time.Time, []Identifier, error) {
 	alarmsRepeated, err := GetAlarmsRepeated(db)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var closestAlarm *time.Time
+	var closestAlarmRoutines []Identifier
 	for _, alarm := range alarmsRepeated {
 		next := alarm.GetNextOccurence(cfg, db)
 		if next != nil && (closestAlarm == nil || closestAlarm.After(*next)) {
 			closestAlarm = next
+			closestAlarmRoutines = alarm.FollowingRoutines
 		}
 	}
 
 	alarmsSingle, err := GetAlarmsSingle(db)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	now := time.Now()
 	for _, alarm := range alarmsSingle {
 		if closestAlarm == nil || (closestAlarm.After(alarm.Time) && alarm.Time.After(now)) {
 			closestAlarm = &alarm.Time
+			closestAlarmRoutines = alarm.FollowingRoutines
 		}
 	}
 
-	return closestAlarm, nil
+	return closestAlarm, closestAlarmRoutines, nil
+}
+
+func GetNextException(cfg *config.Config, db *LevelDBStorage) (*time.Time, error) {
+	alarmsExceptions, err := GetAlarmExceptions(db)
+	if err != nil {
+		return nil, err
+	}
+
+	var closestException *time.Time
+	for _, except := range alarmsExceptions {
+		if except != nil && time.Time(*except.End).After(time.Now()) && (closestException == nil || closestException.After(time.Time(*except.Start))) {
+			tmp := time.Time(*except.Start)
+			closestException = &tmp
+		}
+	}
+
+	return closestException, nil
 }
 
 func DropNextAlarm(cfg *config.Config, db *LevelDBStorage) error {
-	timenext, err := GetNextAlarm(cfg, db)
+	timenext, _, err := GetNextAlarm(cfg, db)
 	if err != nil {
 		return err
 	}

model/routine.go

@@ -1,7 +1,9 @@
 package reveil
 
 import (
+	"bytes"
 	"crypto/sha512"
+	"fmt"
 	"io/fs"
 	"io/ioutil"
 	"log"
@@ -9,6 +11,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"time"
 
 	"git.nemunai.re/nemunaire/reveil/config"
 )
@@ -19,6 +22,10 @@ type RoutineStep struct {
 	Args   []string `json:"args,omitempty"`
 }
 
+func (s *RoutineStep) GetAction(cfg *config.Config) (*Action, error) {
+	return LoadAction(cfg, s.Action)
+}
+
 type Routine struct {
 	Id    Identifier    `json:"id"`
 	Name  string        `json:"name"`
@@ -72,6 +79,21 @@ func LoadRoutine(path string, cfg *config.Config) ([]RoutineStep, error) {
 	return steps, nil
 }
 
+func LoadRoutineFromId(id Identifier, cfg *config.Config) (*Routine, error) {
+	routines, err := LoadRoutines(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, routine := range routines {
+		if bytes.Equal(routine.Id, id) {
+			return routine, nil
+		}
+	}
+
+	return nil, fmt.Errorf("Unable to find routine %x", id)
+}
+
 func LoadRoutines(cfg *config.Config) (routines []*Routine, err error) {
 	err = filepath.Walk(cfg.RoutinesDir, func(path string, d fs.FileInfo, err error) error {
 		if d.IsDir() && path != cfg.RoutinesDir {
@@ -117,3 +139,28 @@ func (r *Routine) Rename(newName string) error {
 func (a *Routine) Remove() error {
 	return os.Remove(a.Path)
 }
+
+func (a *Routine) Launch(cfg *config.Config) error {
+	for _, s := range a.Steps {
+		act, err := s.GetAction(cfg)
+		if err != nil {
+			log.Printf("Unable to get action: %s: %s", s.Action, err.Error())
+			continue
+		}
+
+		time.Sleep(time.Duration(s.Delay) * time.Second)
+
+		cmd, err := act.Launch()
+		if err != nil {
+			log.Printf("Unable to launch the action %q: %s", s.Action, err.Error())
+			continue
+		}
+
+		err = cmd.Wait()
+		if err != nil {
+			log.Printf("Something goes wrong when waiting for the action %q's end: %s", s.Action, err.Error())
+		}
+	}
+
+	return nil
+}

player/player.go

@@ -25,11 +25,17 @@ type Player struct {
 	currentCmd   *exec.Cmd
 	currentCmdCh chan bool
 
+	weatherTime   time.Duration
+	weatherAction *reveil.Action
+
 	claironTime time.Duration
 	claironFile string
 
+	endRoutines []*reveil.Routine
+
 	ntick            int64
 	hasClaironed     bool
+	hasSpokeWeather  bool
 	launched         time.Time
 	volume           uint16
 	dontUpdateVolume bool
@@ -37,7 +43,7 @@ type Player struct {
 	playedItem       int
 }
 
-func WakeUp(cfg *config.Config) (err error) {
+func WakeUp(cfg *config.Config, routine []reveil.Identifier) (err error) {
 	if CommonPlayer != nil {
 		return fmt.Errorf("Unable to start the player: a player is already running")
 	}
@@ -46,29 +52,48 @@ func WakeUp(cfg *config.Config) (err error) {
 	seed -= seed % 172800
 	rand.Seed(seed)
 
-	CommonPlayer, err = NewPlayer(cfg)
+	CommonPlayer, err = NewPlayer(cfg, routine)
 	if err != nil {
 		return err
 	}
 
-	go CommonPlayer.WakeUp()
+	go CommonPlayer.WakeUp(cfg)
 	return nil
 }
 
-func NewPlayer(cfg *config.Config) (*Player, error) {
+func NewPlayer(cfg *config.Config, routines []reveil.Identifier) (*Player, error) {
 	// Load our settings
 	settings, err := reveil.ReadSettings(cfg.SettingsFile)
 	if err != nil {
 		return nil, fmt.Errorf("Unable to read settings: %w", err)
 	}
 
+	// Load weather action
+	wact, err := reveil.LoadAction(cfg, settings.WeatherAction)
+	if err != nil {
+		log.Println("Unable to load weather action:", err.Error())
+	}
+
 	p := Player{
-		Stopper:      make(chan bool, 1),
+		Stopper:       make(chan bool, 1),
-		currentCmdCh: make(chan bool, 1),
+		currentCmdCh:  make(chan bool, 1),
-		MaxRunTime:   settings.MaxRunTime * time.Minute,
+		MaxRunTime:    settings.MaxRunTime * time.Minute,
-		claironTime:  settings.GongInterval * time.Minute,
+		weatherTime:   settings.WeatherDelay * time.Minute,
-		claironFile:  reveil.CurrentGongPath(cfg),
+		weatherAction: wact,
-		reverseOrder: int(time.Now().Unix()/86400)%2 == 0,
+		claironTime:   settings.GongInterval * time.Minute,
+		claironFile:   reveil.CurrentGongPath(cfg),
+		reverseOrder:  int(time.Now().Unix()/86400)%2 == 0,
+	}
+
+	// Load routines
+	for _, routine := range routines {
+		r, err := reveil.LoadRoutineFromId(routine, cfg)
+		if err != nil {
+			log.Printf("Unable to load routine %x: %s", routine, err.Error())
+			continue
+		}
+
+		p.endRoutines = append(p.endRoutines, r)
 	}
 
 	// Load our track list
@@ -98,6 +123,16 @@ func NewPlayer(cfg *config.Config) (*Player, error) {
 	return &p, nil
 }
 
+func (p *Player) launchAction(a *reveil.Action) (err error) {
+	p.currentCmd, err = a.Launch()
+	log.Println("Running action ", a.Name)
+
+	err = p.currentCmd.Wait()
+	p.currentCmdCh <- true
+
+	return
+}
+
 func (p *Player) playFile(filepath string) (err error) {
 	p.currentCmd = exec.Command("paplay", filepath)
 	if err = p.currentCmd.Start(); err != nil {
@@ -114,7 +149,7 @@ func (p *Player) playFile(filepath string) (err error) {
 	return
 }
 
-func (p *Player) WakeUp() {
+func (p *Player) WakeUp(cfg *config.Config) {
 	log.Println("Playlist in use:", strings.Join(p.Playlist, " ; "))
 
 	// Prepare sound player
@@ -141,6 +176,11 @@ loop:
 				p.SetVolume(65535)
 				p.dontUpdateVolume = true
 				go p.playFile(p.claironFile)
+			} else if p.weatherAction != nil && !p.hasSpokeWeather && time.Since(p.launched) >= p.weatherTime {
+				log.Println("weather time!")
+				p.SetVolume(65535)
+				p.dontUpdateVolume = true
+				go p.launchAction(p.weatherAction)
 			} else {
 				p.dontUpdateVolume = false
 				p.volume = 3500 + uint16(math.Log(1+float64(p.ntick)/8)*9500)
@@ -214,6 +254,11 @@ loopcalm:
 
 		CommonPlayer = nil
 	}
+
+	// TODO: Start Routine if any
+	for _, r := range p.endRoutines {
+		go r.Launch(cfg)
+	}
 }
 
 func (p *Player) NextTrack() {

ui/nojs.go

@@ -24,7 +24,7 @@ func DeclareNoJSRoutes(router *gin.Engine, cfg *config.Config, db *reveil.LevelD
 	router.SetHTMLTemplate(templ)
 
 	router.GET("/nojs.html", func(c *gin.Context) {
-		alarm, err := reveil.GetNextAlarm(cfg, db)
+		alarm, _, err := reveil.GetNextAlarm(cfg, db)
 		if err != nil {
 			c.HTML(http.StatusInternalServerError, "error.tmpl", gin.H{"errmsg": err.Error()})
 			return
@@ -109,7 +109,7 @@ func DeclareNoJSRoutes(router *gin.Engine, cfg *config.Config, db *reveil.LevelD
 
 		case "start":
 			if player.CommonPlayer == nil {
-				err := player.WakeUp(cfg)
+				err := player.WakeUp(cfg, nil)
 				if err != nil {
 					c.HTML(http.StatusInternalServerError, "error.tmpl", gin.H{"errmsg": err.Error()})
 					return

ui/src/lib/action.js

@@ -25,6 +25,18 @@ export class Action {
     }
   }
 
+  async launch() {
+    const res = await fetch(`api/actions/${this.id}/run`, {
+      method: 'POST',
+      headers: {'Accept': 'application/json'}
+    });
+    if (res.status == 200) {
+      return true;
+    } else {
+      throw new Error((await res.json()).errmsg);
+    }
+  }
+
   toggleEnable() {
     this.enabled = !this.enabled;
     this.save();

ui/src/lib/components/CardRoutine.svelte

@@ -27,6 +27,7 @@
             color="outline-danger"
             size="sm"
             class="float-end ms-1"
+            on:click={() => routine.delete()}
         >
             <Icon name="trash" />
         </Button>
@@ -37,6 +38,14 @@
         >
             <Icon name="pencil" />
         </Button>
+        <Button
+            color="outline-success"
+            size="sm"
+            class="float-end ms-1"
+            on:click={() => routine.launch()}
+        >
+            <Icon name="play-fill" />
+        </Button>
         {routine.name}
     </CardHeader>
     {#if routine.steps}

ui/src/lib/routine.js

@@ -26,6 +26,18 @@ export class Routine {
     }
   }
 
+  async launch() {
+    const res = await fetch(`api/routines/${this.id}/run`, {
+      method: 'POST',
+      headers: {'Accept': 'application/json'}
+    });
+    if (res.status == 200) {
+      return true;
+    } else {
+      throw new Error((await res.json()).errmsg);
+    }
+  }
+
   async save() {
     const res = await fetch(this.id?`api/routines/${this.id}`:'api/routines', {
       method: this.id?'PUT':'POST',

ui/src/routes/routines/actions/[aid]/+page.svelte

@@ -3,6 +3,7 @@
 
  import {
      Container,
+     Icon,
      Input,
      ListGroup,
      ListGroupItem,
@@ -10,6 +11,14 @@
  } from 'sveltestrap';
 
  import { getAction } from '$lib/action';
+ import { actions } from '$lib/stores/actions';
+
+ function deleteThis(action) {
+     action.delete().then(() => {
+         actions.refresh();
+         goto('routines/actions/');
+     })
+ }
 </script>
 
 {#await getAction($page.params.aid)}
@@ -34,5 +43,26 @@
                 <Input type="switch" on:change={() => action.toggleEnable()} checked={action.enabled} />
             </ListGroupItem>
         </ListGroup>
+
+        <ListGroup class="my-2 text-center">
+            <ListGroupItem
+                action
+                tag="button"
+                class="text-success fw-bold"
+                on:click={() => action.launch()}
+            >
+                <Icon name="play-fill" />
+                Lancer cette action
+            </ListGroupItem>
+            <ListGroupItem
+                action
+                tag="button"
+                class="text-danger fw-bold"
+                on:click={() => deleteThis(action)}
+            >
+                <Icon name="trash" />
+                Supprimer cette action
+            </ListGroupItem>
+        </ListGroup>
     </Container>
 {/await}