reveil/model/alarm.go
Pierre-Olivier Mercier a1582e3819
All checks were successful
continuous-integration/drone/tag Build is passing
continuous-integration/drone/push Build is passing
Consider today's exceptions
2023-01-09 14:19:22 +01:00

395 lines
9.0 KiB
Go

package reveil
import (
"fmt"
"sort"
"time"
"git.nemunai.re/nemunaire/reveil/config"
)
type Date time.Time
func (d *Date) MarshalJSON() (dst []byte, err error) {
return []byte(fmt.Sprintf("\"%04d-%02d-%02d\"", time.Time(*d).Year(), time.Time(*d).Month(), time.Time(*d).Day())), nil
}
func (d *Date) UnmarshalJSON(src []byte) error {
tmp, err := time.Parse("\"2006-01-02\"", string(src))
if err != nil {
return err
}
*d = Date(tmp)
return nil
}
type Hour time.Time
func (h *Hour) MarshalJSON() (dst []byte, err error) {
return []byte(fmt.Sprintf("\"%02d:%02d\"", time.Time(*h).Hour(), time.Time(*h).Minute())), nil
}
func (h *Hour) UnmarshalJSON(src []byte) error {
tmp, err := time.Parse("\"15:04\"", string(src))
if err != nil {
return err
}
*h = Hour(tmp)
return nil
}
func GetNextAlarm(cfg *config.Config, db *LevelDBStorage) (*time.Time, []Identifier, error) {
alarmsRepeated, err := GetAlarmsRepeated(db)
if err != nil {
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, 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, 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)
if err != nil {
return err
}
alarmsRepeated, err := GetAlarmsRepeated(db)
if err != nil {
return err
}
for _, alarm := range alarmsRepeated {
next := alarm.GetNextOccurence(cfg, db)
if next != nil && *next == *timenext {
start := Date(*next)
stop := Date((*next).Add(time.Second))
return PutAlarmException(db, &AlarmException{
Start: &start,
End: &stop,
Comment: fmt.Sprintf("Automatic exception to cancel recurrent alarm %s", next.Format("Mon at 15:04")),
})
}
}
alarmsSingle, err := GetAlarmsSingle(db)
if err != nil {
return err
}
for _, alarm := range alarmsSingle {
if alarm.Time == *timenext {
return DeleteAlarmSingle(db, alarm)
}
}
return fmt.Errorf("Unable to find the next alarm")
}
type Exceptions []time.Time
func (e Exceptions) Len() int {
return len(e)
}
func (e Exceptions) Less(i, j int) bool {
return e[i].Before(e[j])
}
func (e Exceptions) Swap(i, j int) {
e[i], e[j] = e[j], e[i]
}
type AlarmRepeated struct {
Id Identifier `json:"id"`
Weekday time.Weekday `json:"weekday"`
StartTime *Hour `json:"time"`
FollowingRoutines []Identifier `json:"routines"`
IgnoreExceptions bool `json:"ignore_exceptions"`
Comment string `json:"comment,omitempty"`
Disabled bool `json:"disabled,omitempty"`
Excepts Exceptions `json:"excepts,omitempty"`
NextTime *time.Time `json:"next_time,omitempty"`
}
func (a *AlarmRepeated) FillExcepts(cfg *config.Config, db *LevelDBStorage) error {
if a.IgnoreExceptions {
return nil
}
exceptions, err := GetAlarmExceptions(db)
if err != nil {
return err
}
now := time.Now()
for _, exception := range exceptions {
end := time.Time(*exception.End).AddDate(0, 0, 1)
if now.After(end) {
continue
}
for t := time.Time(*exception.Start); end.After(t); t = t.AddDate(0, 0, 1) {
if t.Weekday() == a.Weekday {
a.Excepts = append(a.Excepts, time.Date(t.Year(), t.Month(), t.Day(), time.Time(*a.StartTime).Hour(), time.Time(*a.StartTime).Minute(), time.Time(*a.StartTime).Second(), 0, time.Local))
t = t.AddDate(0, 0, 6)
}
}
}
sort.Sort(a.Excepts)
return nil
}
func (a *AlarmRepeated) GetNextOccurence(cfg *config.Config, db *LevelDBStorage) *time.Time {
if a.Disabled {
return nil
}
if len(a.Excepts) == 0 {
a.FillExcepts(cfg, db)
}
now := time.Now()
today := time.Date(now.Year(), now.Month(), now.Day(), time.Time(*a.StartTime).Hour(), time.Time(*a.StartTime).Minute(), time.Time(*a.StartTime).Second(), 0, time.Local)
if now.After(today) {
today = today.AddDate(0, 0, 1)
}
end := today.AddDate(0, 0, 7)
var nextOccurence time.Time
for nextOccurence = today; end.After(nextOccurence); nextOccurence = nextOccurence.AddDate(0, 0, 1) {
if nextOccurence.Weekday() == a.Weekday {
break
}
}
for _, except := range a.Excepts {
if except.Equal(nextOccurence) {
nextOccurence = nextOccurence.AddDate(0, 0, 7)
}
}
return &nextOccurence
}
func GetAlarmRepeated(db *LevelDBStorage, id Identifier) (alarm *AlarmRepeated, err error) {
alarm = &AlarmRepeated{}
err = db.get(fmt.Sprintf("alarm-repeated-%s", id.ToString()), alarm)
return
}
func GetAlarmsRepeated(db *LevelDBStorage) (alarms []*AlarmRepeated, err error) {
iter := db.search("alarm-repeated-")
defer iter.Release()
for iter.Next() {
var a AlarmRepeated
err = decodeData(iter.Value(), &a)
if err != nil {
return
}
alarms = append(alarms, &a)
}
return
}
func PutAlarmRepeated(db *LevelDBStorage, alarm *AlarmRepeated) (err error) {
var key string
if alarm.Id.IsEmpty() {
var id Identifier
key, id, err = db.findBytesKey("alarm-repeated-", IDENTIFIER_LEN)
if err != nil {
return err
}
alarm.Id = id
} else {
key = fmt.Sprintf("alarm-repeated-%s", alarm.Id.ToString())
}
// Don't store this, this is autocalculated
alarm.Excepts = nil
alarm.NextTime = nil
return db.put(key, alarm)
}
func DeleteAlarmRepeated(db *LevelDBStorage, alarm *AlarmRepeated) (err error) {
return db.delete(fmt.Sprintf("alarm-repeated-%s", alarm.Id.ToString()))
}
type AlarmSingle struct {
Id Identifier `json:"id"`
Time time.Time `json:"time"`
FollowingRoutines []Identifier `json:"routines"`
Comment string `json:"comment,omitempty"`
}
func GetAlarmSingle(db *LevelDBStorage, id Identifier) (alarm *AlarmSingle, err error) {
alarm = &AlarmSingle{}
err = db.get(fmt.Sprintf("alarm-single-%s", id.ToString()), alarm)
return
}
func GetAlarmsSingle(db *LevelDBStorage) (alarms []*AlarmSingle, err error) {
iter := db.search("alarm-single-")
defer iter.Release()
for iter.Next() {
var a AlarmSingle
err = decodeData(iter.Value(), &a)
if err != nil {
return
}
alarms = append(alarms, &a)
}
return
}
func PutAlarmSingle(db *LevelDBStorage, alarm *AlarmSingle) (err error) {
var key string
if alarm.Id.IsEmpty() {
var id Identifier
key, id, err = db.findBytesKey("alarm-single-", IDENTIFIER_LEN)
if err != nil {
return err
}
alarm.Id = id
} else {
key = fmt.Sprintf("alarm-single-%s", alarm.Id.ToString())
}
return db.put(key, alarm)
}
func DeleteAlarmSingle(db *LevelDBStorage, alarm *AlarmSingle) (err error) {
return db.delete(fmt.Sprintf("alarm-single-%s", alarm.Id.ToString()))
}
func RemoveOldAlarmsSingle(db *LevelDBStorage) error {
alarms, err := GetAlarmsSingle(db)
if err != nil {
return err
}
now := time.Now()
for _, alarm := range alarms {
if now.After(time.Time(alarm.Time)) {
err = DeleteAlarmSingle(db, alarm)
if err != nil {
return err
}
}
}
return nil
}
type AlarmException struct {
Id Identifier `json:"id"`
Start *Date `json:"start"`
End *Date `json:"end"`
Comment string `json:"comment,omitempty"`
}
func GetAlarmException(db *LevelDBStorage, id Identifier) (alarm *AlarmException, err error) {
alarm = &AlarmException{}
err = db.get(fmt.Sprintf("alarm-exception-%s", id.ToString()), alarm)
return
}
func GetAlarmExceptions(db *LevelDBStorage) (alarms []*AlarmException, err error) {
iter := db.search("alarm-exception-")
defer iter.Release()
for iter.Next() {
var a AlarmException
err = decodeData(iter.Value(), &a)
if err != nil {
return
}
alarms = append(alarms, &a)
}
return
}
func PutAlarmException(db *LevelDBStorage, alarm *AlarmException) (err error) {
var key string
if alarm.Id.IsEmpty() {
var id Identifier
key, id, err = db.findBytesKey("alarm-exception-", IDENTIFIER_LEN)
if err != nil {
return err
}
alarm.Id = id
} else {
key = fmt.Sprintf("alarm-exception-%s", alarm.Id.ToString())
}
return db.put(key, alarm)
}
func DeleteAlarmException(db *LevelDBStorage, alarm *AlarmException) (err error) {
return db.delete(fmt.Sprintf("alarm-exception-%s", alarm.Id.ToString()))
}