telegabber/persistence/sessions.go

331 lines
7 KiB
Go
Raw Normal View History

package persistence
import (
"github.com/pkg/errors"
"io/ioutil"
"sync"
2019-12-11 22:48:35 +00:00
"time"
"dev.narayana.im/narayana/telegabber/yamldb"
2019-11-19 20:25:14 +00:00
log "github.com/sirupsen/logrus"
"gopkg.in/yaml.v2"
)
2019-12-11 22:48:35 +00:00
var zeroLocation *time.Location
func init() {
var err error
zeroLocation, err = time.LoadLocation("")
if err != nil {
log.Fatal("Wrong hardcoded timezone")
}
}
// SessionsYamlDB wraps YamlDB with Session
type SessionsYamlDB struct {
yamldb.YamlDB
Data *SessionsMap
}
// SessionsMap is for :sessions: subtree
type SessionsMap struct {
Sessions map[string]Session `yaml:":sessions"`
}
// Session is a key-values subtree
type Session struct {
Login string `yaml:":login"`
Timezone string `yaml:":timezone"`
KeepOnline bool `yaml:":keeponline"`
RawMessages bool `yaml:":rawmessages"`
AsciiArrows bool `yaml:":asciiarrows"`
OOBMode bool `yaml:":oobmode"`
Carbons bool `yaml:":carbons"`
HideIds bool `yaml:":hideids"`
Receipts bool `yaml:":receipts"`
NativeEdits bool `yaml:":nativeedits"`
IgnoredChats []int64 `yaml:":ignoredchats"`
ignoredChatsMap map[int64]bool `yaml:"-"`
2022-01-05 21:04:22 +00:00
}
var configKeys = []string{
"timezone",
"keeponline",
2022-02-08 18:49:49 +00:00
"rawmessages",
"asciiarrows",
2023-01-16 01:35:13 +00:00
"oobmode",
2023-03-18 21:43:11 +00:00
"carbons",
2023-03-19 00:13:00 +00:00
"hideids",
"receipts",
"nativeedits",
}
2019-12-04 15:55:15 +00:00
var sessionDB *SessionsYamlDB
var sessionsLock sync.Mutex
// SessionMarshaller implementation for YamlDB
func SessionMarshaller() ([]byte, error) {
2019-12-18 21:00:23 +00:00
cleanedMap := SessionsMap{}
emptySessionsMap(&cleanedMap)
sessionsLock.Lock()
defer sessionsLock.Unlock()
2019-12-18 21:00:23 +00:00
for jid, session := range sessionDB.Data.Sessions {
if session.Login != "" {
session.IgnoredChats = make([]int64, 0, len(session.ignoredChatsMap))
for chatID := range session.ignoredChatsMap {
session.IgnoredChats = append(session.IgnoredChats, chatID)
}
2019-12-18 21:00:23 +00:00
cleanedMap.Sessions[jid] = session
}
}
return yaml.Marshal(&cleanedMap)
}
// LoadSessions restores TDlib sessions from the previous run
2019-12-04 15:55:15 +00:00
func LoadSessions(path string) (*SessionsYamlDB, error) {
var sessionData SessionsMap
2019-12-04 15:55:15 +00:00
var err error
2019-12-04 15:55:15 +00:00
sessionDB, err = initYamlDB(path, &sessionData)
if err != nil {
return sessionDB, errors.Wrap(err, "Sessions restore error")
}
return sessionDB, nil
}
2019-11-19 20:25:14 +00:00
func emptySessionsMap(dataPtr *SessionsMap) {
dataPtr.Sessions = make(map[string]Session)
}
2019-12-04 15:55:15 +00:00
func initYamlDB(path string, dataPtr *SessionsMap) (*SessionsYamlDB, error) {
file, err := ioutil.ReadFile(path)
if err == nil {
err = yaml.Unmarshal(file, dataPtr)
if err != nil {
2019-12-04 15:55:15 +00:00
return nil, errors.Wrap(err, "YamlDB is corrupted")
}
2019-11-19 20:25:14 +00:00
if dataPtr.Sessions == nil {
emptySessionsMap(dataPtr)
}
log.Debugf("Unmarshalled YAML: %#v", *dataPtr)
} else {
// DB file does not exist, create an empty DB
2019-11-19 20:25:14 +00:00
emptySessionsMap(dataPtr)
}
// convert ignored users slice to map
for jid, session := range dataPtr.Sessions {
session.ignoredChatsMap = make(map[int64]bool)
for _, chatID := range session.IgnoredChats {
session.ignoredChatsMap[chatID] = true
}
session.IgnoredChats = nil
dataPtr.Sessions[jid] = session
}
2019-12-04 15:55:15 +00:00
return &SessionsYamlDB{
YamlDB: yamldb.YamlDB{
Path: path,
PathNew: path + ".new",
},
Data: dataPtr,
}, nil
}
2019-12-05 19:56:12 +00:00
// Get retrieves a session value
func (s *Session) Get(key string) (string, error) {
sessionsLock.Lock()
defer sessionsLock.Unlock()
return s.get(key)
}
func (s *Session) get(key string) (string, error) {
2019-12-05 19:56:12 +00:00
switch key {
case "timezone":
return s.Timezone, nil
2022-01-05 21:04:22 +00:00
case "keeponline":
return fromBool(s.KeepOnline), nil
2022-02-08 18:49:49 +00:00
case "rawmessages":
return fromBool(s.RawMessages), nil
case "asciiarrows":
return fromBool(s.AsciiArrows), nil
2023-01-16 01:35:13 +00:00
case "oobmode":
return fromBool(s.OOBMode), nil
2023-03-18 21:43:11 +00:00
case "carbons":
return fromBool(s.Carbons), nil
2023-03-19 00:13:00 +00:00
case "hideids":
return fromBool(s.HideIds), nil
case "receipts":
return fromBool(s.Receipts), nil
case "nativeedits":
return fromBool(s.NativeEdits), nil
2019-12-05 19:56:12 +00:00
}
return "", errors.New("Unknown session property")
}
// ToMap converts the session to a map
func (s *Session) ToMap() map[string]string {
sessionsLock.Lock()
defer sessionsLock.Unlock()
2019-12-05 19:56:12 +00:00
m := make(map[string]string)
2022-01-05 21:04:22 +00:00
for _, configKey := range configKeys {
value, _ := s.get(configKey)
2019-12-05 19:56:12 +00:00
m[configKey] = value
}
return m
}
// Set sets a session value
func (s *Session) Set(key string, value string) (string, error) {
sessionsLock.Lock()
defer sessionsLock.Unlock()
2019-12-05 19:56:12 +00:00
switch key {
case "timezone":
s.Timezone = value
return value, nil
2022-01-05 21:04:22 +00:00
case "keeponline":
b, err := toBool(value)
if err != nil {
return "", err
}
s.KeepOnline = b
return value, nil
2022-02-08 18:49:49 +00:00
case "rawmessages":
b, err := toBool(value)
if err != nil {
return "", err
}
s.RawMessages = b
return value, nil
case "asciiarrows":
b, err := toBool(value)
if err != nil {
return "", err
}
s.AsciiArrows = b
return value, nil
2023-01-16 01:35:13 +00:00
case "oobmode":
b, err := toBool(value)
if err != nil {
return "", err
}
s.OOBMode = b
return value, nil
2023-03-18 21:43:11 +00:00
case "carbons":
b, err := toBool(value)
if err != nil {
return "", err
}
s.Carbons = b
return value, nil
2023-03-19 00:13:00 +00:00
case "hideids":
b, err := toBool(value)
if err != nil {
return "", err
}
s.HideIds = b
return value, nil
case "receipts":
b, err := toBool(value)
if err != nil {
return "", err
}
s.Receipts = b
return value, nil
case "nativeedits":
b, err := toBool(value)
if err != nil {
return "", err
}
s.NativeEdits = b
return value, nil
2019-12-05 19:56:12 +00:00
}
return "", errors.New("Unknown session property")
}
2019-12-11 22:48:35 +00:00
2019-12-12 00:24:35 +00:00
// TimezoneToLocation tries to convert config timezone to location
2019-12-11 22:48:35 +00:00
func (s *Session) TimezoneToLocation() *time.Location {
time, err := time.Parse("-07:00", s.Timezone)
if err == nil {
return time.Location()
}
// default
return zeroLocation
}
2022-01-05 21:04:22 +00:00
// IgnoreChat adds a chat id to ignore list, returns false if already ignored
func (s *Session) IgnoreChat(chatID int64) bool {
sessionsLock.Lock()
defer sessionsLock.Unlock()
if s.ignoredChatsMap == nil {
s.ignoredChatsMap = make(map[int64]bool)
} else if _, ok := s.ignoredChatsMap[chatID]; ok {
return false
}
s.ignoredChatsMap[chatID] = true
return true
}
// UnignoreChat removes a chat id from ignore list, returns false if not already ignored
func (s *Session) UnignoreChat(chatID int64) bool {
sessionsLock.Lock()
defer sessionsLock.Unlock()
if s.ignoredChatsMap == nil {
return false
}
if _, ok := s.ignoredChatsMap[chatID]; !ok {
return false
}
delete(s.ignoredChatsMap, chatID)
return true
}
// IsChatIgnored checks the chat id against the ignore list
func (s *Session) IsChatIgnored(chatID int64) bool {
sessionsLock.Lock()
defer sessionsLock.Unlock()
if s.ignoredChatsMap == nil {
return false
}
_, ok := s.ignoredChatsMap[chatID]
return ok
}
2022-01-05 21:04:22 +00:00
func fromBool(b bool) string {
if b {
return "true"
} else {
return "false"
}
}
func toBool(s string) (bool, error) {
switch s {
case "true":
return true, nil
case "false":
return false, nil
}
return false, errors.New("Invalid boolean value")
}