chore(deps): lock file maintenance

api/alarm.go

@@ -62,7 +62,7 @@ func declareAlarmRoutes(cfg *config.Config, router *gin.RouterGroup) {
 			}
 
 			for k, srv := range settings.Federation {
-				err = player.FederatedStop(srv)
+				err = srv.WakeStop()
 				if err != nil {
 					log.Printf("Unable to do federated wakeup on %s: %s", k, err.Error())
 				} else {

api/federation.go

@@ -1,12 +1,15 @@
 package api
 
 import (
+	"bytes"
+	"fmt"
 	"net/http"
 	"time"
 
 	"github.com/gin-gonic/gin"
 
 	"git.nemunai.re/nemunaire/reveil/config"
+	"git.nemunai.re/nemunaire/reveil/model"
 	"git.nemunai.re/nemunaire/reveil/player"
 )
 
@@ -47,4 +50,127 @@ func declareFederationRoutes(cfg *config.Config, router *gin.RouterGroup) {
 
 		c.JSON(http.StatusOK, true)
 	})
+
+	router.GET("/federation", func(c *gin.Context) {
+		settings, err := reveil.ReadSettings(cfg.SettingsFile)
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()})
+			return
+		}
+
+		c.JSON(http.StatusOK, settings.Federation)
+	})
+
+	federationsRoutes := router.Group("/federation/:fid")
+	federationsRoutes.Use(func(c *gin.Context) {
+		settings, err := reveil.ReadSettings(cfg.SettingsFile)
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()})
+			return
+		}
+
+		f, ok := settings.Federation[string(c.Param("fid"))]
+		if !ok {
+			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Action not found"})
+			return
+		}
+
+		c.Set("federation", &f)
+		c.Next()
+	})
+	federationsRoutes.GET("", func(c *gin.Context) {
+		c.JSON(http.StatusOK, c.MustGet("federation"))
+	})
+	federationsRoutes.POST("sync", func(c *gin.Context) {
+		srv := c.MustGet("federation").(*reveil.FederationServer)
+
+		// Retrieve music list on remote
+		remoteMusics, err := srv.GetMusics()
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("Unable to retrieve remote tracks lists: %s", err.Error())})
+			return
+		}
+
+		// Retrieve local music list
+		localMusics, err := reveil.LoadTracks(cfg)
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("Unable to retrieve local tracks: %s", err.Error())})
+			return
+		}
+
+		// Compute diff
+		var newMusics []reveil.Track
+		var oldMusics []reveil.Track
+		var musicsToEnable []reveil.Track
+
+		for _, rTrack := range remoteMusics {
+			found := false
+			for _, lTrack := range localMusics {
+				if bytes.Compare(lTrack.Id, rTrack.Id) == 0 || lTrack.Name == rTrack.Name {
+					if lTrack.Enabled != rTrack.Enabled {
+						if lTrack.Enabled {
+							musicsToEnable = append(musicsToEnable, rTrack)
+						} else {
+							oldMusics = append(oldMusics, *lTrack)
+						}
+					}
+
+					found = true
+					break
+				}
+			}
+
+			if !found && rTrack.Enabled {
+				oldMusics = append(oldMusics, rTrack)
+			}
+		}
+
+		for _, lTrack := range localMusics {
+			found := false
+			for _, rTrack := range remoteMusics {
+				if bytes.Compare(lTrack.Id, rTrack.Id) == 0 || lTrack.Name == rTrack.Name {
+					found = true
+					break
+				}
+			}
+
+			if !found && lTrack.Enabled {
+				newMusics = append(newMusics, *lTrack)
+			}
+		}
+
+		// Disable unexistant musics on local
+		for _, t := range oldMusics {
+			t.Enabled = false
+			err = srv.UpdateTrack(&t)
+			if err != nil {
+				c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("An error occurs when disabling remote tracks (unexistant on local): %s: %s", t.Id.ToString(), err.Error())})
+				return
+
+			}
+		}
+
+		// Enable existant musics on remote
+		for _, t := range musicsToEnable {
+			t.Enabled = true
+			err = srv.UpdateTrack(&t)
+			if err != nil {
+				c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()})
+				return
+
+			}
+		}
+
+		// Send new musics
+		for _, t := range newMusics {
+			err = srv.SendTrack(&t)
+			if err != nil {
+				c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()})
+				return
+
+			}
+		}
+
+		c.JSON(http.StatusOK, true)
+	})
 }

app.go

@@ -21,6 +21,7 @@ type App struct {
 	router       *gin.Engine
 	srv          *http.Server
 	nextAlarm    *time.Timer
+	nextPreAlarm *time.Timer
 }
 
 func NewApp(cfg *config.Config) *App {
@@ -76,11 +77,45 @@ func (app *App) Start() {
 func (app *App) ResetTimer() {
 	if app.nextAlarm != nil {
 		app.nextAlarm.Stop()
+		app.nextPreAlarm = nil
 		app.nextAlarm = nil
 	}
 
+	settings, _ := reveil.ReadSettings(app.cfg.SettingsFile)
+
 	if na, routines, federated, err := reveil.GetNextAlarm(app.cfg, app.db); err == nil && na != nil {
+		if settings != nil && settings.PreAlarmAction != "" {
+			app.nextPreAlarm = time.AfterFunc(time.Until(*na)-settings.PreAlarmActionDelay*time.Minute, func() {
+				app.nextPreAlarm = nil
+
+				settings, err := reveil.ReadSettings(app.cfg.SettingsFile)
+				if err != nil {
+					log.Println("Unable to read settings:", err.Error())
+					return
+				}
+
+				action, err := reveil.LoadAction(app.cfg, settings.PreAlarmAction)
+				if err != nil {
+					log.Println("Unable to load pre-alarm action:", err.Error())
+				}
+
+				cmd, err := action.Launch(settings)
+				if err != nil {
+					log.Println(err.Error())
+					return
+				}
+
+				go func() {
+					err := cmd.Wait()
+					if err != nil {
+						log.Printf("%q: %s", action.Name, err.Error())
+					}
+				}()
+			})
+			log.Println("Next pre-alarm programmed for", time.Time(*na).Add(settings.PreAlarmActionDelay*-1*time.Minute))
+		}
 		app.nextAlarm = time.AfterFunc(time.Until(*na), func() {
+			app.nextPreAlarm = nil
 			app.nextAlarm = nil
 			reveil.RemoveOldAlarmsSingle(app.db)
 

model/federation.go

@@ -0,0 +1,137 @@
+package reveil
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+)
+
+type FederationServer struct {
+	URL   string `json:"url"`
+	Delay uint   `json:"delay"`
+}
+
+func (srv *FederationServer) WakeUp(seed int64) error {
+	req := map[string]interface{}{"seed": seed}
+	req_enc, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+
+	res, err := http.Post(srv.URL+"/api/federation/wakeup", "application/json", bytes.NewBuffer(req_enc))
+	if err != nil {
+		return err
+	}
+	res.Body.Close()
+
+	return nil
+}
+
+func (srv *FederationServer) WakeStop() error {
+	res, err := http.Post(srv.URL+"/api/federation/wakeok", "application/json", nil)
+	if err != nil {
+		return err
+	}
+	res.Body.Close()
+
+	return nil
+}
+
+func (srv *FederationServer) GetMusics() ([]Track, error) {
+	res, err := http.Get(srv.URL + "/api/tracks")
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	var tracks []Track
+	err = json.NewDecoder(res.Body).Decode(&tracks)
+	if err != nil {
+		return nil, err
+	}
+
+	return tracks, nil
+}
+
+func (srv *FederationServer) UpdateTrack(t *Track) error {
+	req_enc, err := json.Marshal(t)
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequest("PUT", srv.URL+"/api/tracks/"+t.Id.ToString(), bytes.NewBuffer(req_enc))
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode == http.StatusOK {
+		var track Track
+		err = json.NewDecoder(res.Body).Decode(&track)
+		if err != nil {
+			return err
+		}
+	} else {
+		var errmsg map[string]string
+		err = json.NewDecoder(res.Body).Decode(&errmsg)
+		if err != nil {
+			return err
+		} else {
+			return fmt.Errorf("%s", errmsg["errmsg"])
+		}
+	}
+
+	return nil
+}
+
+func (srv *FederationServer) SendTrack(track *Track) error {
+	// Retrieve file
+	fd, err := track.Open()
+	if err != nil {
+		return err
+	}
+	defer fd.Close()
+
+	var b bytes.Buffer
+	w := multipart.NewWriter(&b)
+
+	var fw io.Writer
+	// Add an image file
+	if fw, err = w.CreateFormFile("trackfile", fd.Name()); err != nil {
+		return err
+	}
+	if _, err = io.Copy(fw, fd); err != nil {
+		return err
+	}
+
+	w.Close()
+
+	//
+	req, err := http.NewRequest("POST", srv.URL+"/api/tracks", &b)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", w.FormDataContentType())
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return fmt.Errorf("bad status: %s", res.Status)
+	}
+
+	return nil
+}

model/settings.go

@@ -6,19 +6,17 @@ import (
 	"time"
 )
 
-type FederationSettings struct {
-	URL string `json:"url"`
-}
-
 // Settings represents the settings panel.
 type Settings struct {
 	Language            string                      `json:"language"`
 	GongInterval        time.Duration               `json:"gong_interval"`
 	WeatherDelay        time.Duration               `json:"weather_delay"`
 	WeatherAction       string                      `json:"weather_action"`
+	PreAlarmActionDelay time.Duration               `json:"pre_alarm_delay"`
+	PreAlarmAction      string                      `json:"pre_alarm_action"`
 	MaxRunTime          time.Duration               `json:"max_run_time"`
 	MaxVolume           uint16                      `json:"max_volume"`
-	Federation    map[string]FederationSettings `json:"federation"`
+	Federation          map[string]FederationServer `json:"federation"`
 }
 
 // ExistsSettings checks if the settings file can by found at the given path.

player/federation.go

@@ -1,35 +1,29 @@
 package player
 
 import (
-	"bytes"
-	"encoding/json"
-	"net/http"
+	"log"
+	"time"
 
 	"git.nemunai.re/nemunaire/reveil/model"
 )
 
-func FederatedWakeUp(srv reveil.FederationSettings, seed int64) error {
-	req := map[string]interface{}{"seed": seed}
-	req_enc, err := json.Marshal(req)
+func FederatedWakeUp(k string, srv reveil.FederationServer, seed int64) {
+	if srv.Delay == 0 {
+		err := srv.WakeUp(seed)
 		if err != nil {
-		return err
+			log.Printf("Unable to do federated wakeup on %s: %s", k, err.Error())
+		} else {
+			log.Printf("Federated wakeup on %s: launched!", k)
 		}
-
-	res, err := http.Post(srv.URL+"/api/federation/wakeup", "application/json", bytes.NewBuffer(req_enc))
+	} else {
+		go func() {
+			time.Sleep(time.Duration(srv.Delay) * time.Millisecond)
+			err := srv.WakeUp(seed)
 			if err != nil {
-		return err
+				log.Printf("Unable to do federated wakeup on %s: %s", k, err.Error())
+			} else {
+				log.Printf("Federated wakeup on %s: launched!", k)
+			}
+		}()
 	}
-	res.Body.Close()
-
-	return nil
-}
-
-func FederatedStop(srv reveil.FederationSettings) error {
-	res, err := http.Post(srv.URL+"/api/federation/wakeok", "application/json", nil)
-	if err != nil {
-		return err
-	}
-	res.Body.Close()
-
-	return nil
 }

player/player.go

@@ -58,12 +58,7 @@ func WakeUp(cfg *config.Config, routine []reveil.Identifier, federated bool) (er
 		}
 
 		for k, srv := range settings.Federation {
-			err = FederatedWakeUp(srv, seed)
-			if err != nil {
-				log.Printf("Unable to do federated wakeup on %s: %s", k, err.Error())
-			} else {
-				log.Printf("Federated wakeup on %s: launched!", k)
-			}
+			FederatedWakeUp(k, srv, seed)
 		}
 	}
 

ui/package.json

@@ -15,18 +15,18 @@
     "@sveltejs/adapter-static": "^3.0.0",
     "@sveltejs/kit": "^2.0.0",
     "@sveltejs/vite-plugin-svelte": "^3.0.0",
-    "@typescript-eslint/eslint-plugin": "^7.0.0",
-    "@typescript-eslint/parser": "^7.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
     "bootstrap": "^5.1.3",
     "bootstrap-icons": "^1.8.0",
     "bootswatch": "^5.1.3",
-    "eslint": "^8.0.0",
+    "eslint": "^9.0.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-svelte": "^2.33.0",
     "prettier": "^3.1.1",
     "prettier-plugin-svelte": "^3.1.2",
-    "svelte": "^4.0.0",
-    "svelte-check": "^3.4.3",
+    "svelte": "^5.0.0",
+    "svelte-check": "^4.0.0",
     "svelte-preprocess": "^6.0.0",
     "tslib": "^2.3.1",
     "typescript": "^5.0.0"
@@ -35,7 +35,7 @@
   "dependencies": {
     "dayjs": "^1.11.5",
     "sass": "^1.49.7",
-    "sass-loader": "^14.0.0",
+    "sass-loader": "^16.0.0",
     "@sveltestrap/sveltestrap": "^6.0.0",
     "vite": "^5.0.0"
   }

ui/src/lib/components/FederationSettings.svelte

@@ -2,9 +2,14 @@
  import { createEventDispatcher } from 'svelte';
 
  import {
+     Button,
      Col,
+     Icon,
      Input,
+     InputGroup,
+     InputGroupText,
      Row,
+     Spinner,
  } from '@sveltestrap/sveltestrap';
 
  const dispatch = createEventDispatcher();
@@ -23,11 +28,26 @@
          delete value[bak];
      }
  }
+
+ const syncInProgress = { };
+ async function syncMusic(srv) {
+     syncInProgress[srv] = true;
+
+     const res = await fetch(`api/federation/${srv}/sync`, {
+         method: 'POST',
+         headers: {'Accept': 'application/json'}
+     });
+     if (res.status != 200) {
+         throw new Error((await res.json()).errmsg);
+     }
+
+     syncInProgress[srv] = false;
+ }
 </script>
 
 {#if value}
 {#each Object.keys(value) as key}
-    <Row>
+    <Row class="mb-3">
         <Col>
             <Input
                 type="string"
@@ -37,12 +57,50 @@
             />
         </Col>
         <Col>
+            <InputGroup>
                 <Input
                     type="string"
                     placeholder="https://reveil.fr/"
                     bind:value={value[key].url}
                     on:change={() => dispatch("input")}
                 />
+                <Button
+                    href={value[key].url}
+                    target="_blank"
+                >
+                    <Icon name="globe" />
+                </Button>
+            </InputGroup>
+        </Col>
+        <Col>
+            <Row>
+                <Col>
+                    <InputGroup>
+                        <Input
+                            type="number"
+                            placeholder="60"
+                            bind:value={value[key].delay}
+                            on:change={() => dispatch("input")}
+                        />
+                        <InputGroupText>ms</InputGroupText>
+                    </InputGroup>
+                </Col>
+                <Col xs="auto">
+                    <Button
+                        color="info"
+                        disabled={syncInProgress[key]}
+                        title="Synchroniser les musiques"
+                        type="button"
+                        on:click={() => syncMusic(key)}
+                    >
+                        {#if syncInProgress[key]}
+                            <Spinner size="sm" />
+                        {:else}
+                            <Icon name="music-note-list" />
+                        {/if}
+                    </Button>
+                </Col>
+            </Row>
         </Col>
     </Row>
 {/each}
@@ -65,4 +123,12 @@
             value=""
         />
     </Col>
+    <Col>
+        <Input
+            type="number"
+            placeholder="60"
+            disabled
+            value=""
+        />
+    </Col>
 </Row>

ui/src/lib/settings.js

@@ -5,11 +5,13 @@ export class Settings {
     }
   }
 
-  update({ language, gong_interval, weather_delay, weather_action, max_run_time, max_volume, federation }) {
+  update({ language, gong_interval, weather_delay, weather_action, pre_alarm_delay, pre_alarm_action, max_run_time, max_volume, federation }) {
     this.language = language;
     this.gong_interval = gong_interval;
     this.weather_delay = weather_delay;
     this.weather_action = weather_action;
+    this.pre_alarm_delay = pre_alarm_delay;
+    this.pre_alarm_action = pre_alarm_action;
     this.max_run_time = max_run_time;
     this.max_volume = max_volume;
     this.federation = federation;

ui/src/lib/stores/tracks.js

@@ -2,6 +2,18 @@ import { writable } from 'svelte/store';
 
 import { getTracks } from '$lib/track'
 
+function cmpTracks(a, b) {
+  if (a.enabled && !b.enabled) return -1;
+  if (!a.enabled && b.enabled) return 1;
+
+  if (a.path.toLowerCase() > b.path.toLowerCase())
+    return 1;
+  if (a.path.toLowerCase() < b.path.toLowerCase())
+    return -1;
+
+  return 0;
+}
+
 function createTracksStore() {
   const { subscribe, set, update } = writable({list: null});
 
@@ -14,6 +26,7 @@ function createTracksStore() {
 
     refresh: async () => {
       const list = await getTracks();
+      list.sort(cmpTracks);
       update((m) => Object.assign(m, {list}));
       return list;
     },

ui/src/routes/settings/+page.svelte

@@ -89,6 +89,40 @@
                 {/if}
             </FormGroup>
 
+            <FormGroup>
+                <Label for="preAlarmDelay">Lancement action pré-alarme</Label>
+                <InputGroup>
+                    <Input
+                        type="number"
+                        id="preAlarmDelay"
+                        placeholder="5"
+                        bind:value={settings.pre_alarm_delay}
+                        on:input={submitSettings}
+                    />
+                    <InputGroupText>min</InputGroupText>
+                </InputGroup>
+            </FormGroup>
+
+            <FormGroup>
+                <Label for="preAlarmRituel">Action pour l'action pré-alarme</Label>
+                {#if $actions.list}
+                    <Input
+                        type="select"
+                        id="preAlarmRituel"
+                        bind:value={settings.pre_alarm_action}
+                        on:input={submitSettings}
+                    >
+                    {#each $actions.list as action (action.id)}
+                        <option value="{action.path}">{action.name}</option>
+                    {/each}
+                    </Input>
+                {:else}
+                    <div class="d-flex justify-content-center align-items-center gap-2">
+                        <Spinner color="primary" /> Chargement en cours&hellip;
+                    </div>
+                {/if}
+            </FormGroup>
+
             <FormGroup>
                 <Label for="greetingLanguage">Langue de salutation</Label>
                 <Input