ALFRED/shared/users.go

/*
* @Author: Bartuccio Antoine
* @Date:   2018-07-24 14:41:03
* @Last Modified by:   Bartuccio Antoine
* @Last Modified time: 2019-01-04 10:52:13
 */

package shared

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"sync"

	tb "gopkg.in/tucnak/telebot.v2"
)

type users struct {
	mutex sync.Mutex
	data  map[string]map[string]string
}

type usersFile struct {
	mutex sync.Mutex
	path  string
}

// Users shared user for commands
var Users users
var uf usersFile

// InitUsers inits the User info storage
func InitUsers(users_file_path string) {
	uf = usersFile{}
	uf.path = users_file_path
	Users = users{}
	Users.mutex.Lock()
	defer Users.mutex.Unlock()
	Users.data = make(map[string]map[string]string)
	uf.read()
}

// Get an info about a given user
func (u users) Get(username string, key string) (string, bool) {
	u.mutex.Lock()
	defer u.mutex.Unlock()
	user, exists := u.data[username]
	if !exists {
		return "", false
	}
	if _, exists = user[key]; !exists {
		return "", false
	}
	return user[key], true
}

// Set add an info about a given user
func (u users) Set(username string, key, data string) {
	u.mutex.Lock()
	defer u.mutex.Unlock()
	if _, exists := u.data[username]; !exists {
		u.data[username] = make(map[string]string)
	}
	u.data[username][key] = data
	go uf.write()
}

// GetUsernames get all usernames stored in settings
func (u users) GetUsernames() []string {
	u.mutex.Lock()
	defer u.mutex.Unlock()
	var usernames []string
	for username := range u.data {
		usernames = append(usernames, username)
	}
	return usernames
}

// GetUserChat retrieve the chat of the user if registered
func (u users) GetUserChat(username string) (*tb.Chat, error) {
	serializedChat, exists := u.Get(username, "private_chat")
	if !exists {
		return nil, fmt.Errorf("No private chat registered for %s", username)
	}

	chat := &tb.Chat{}
	if json.Unmarshal([]byte(serializedChat), chat) != nil {
		return nil, fmt.Errorf("Error while parsing chat for %s", username)
	}

	return chat, nil
}

// SetUserChat register a private chat for an user
func (u users) SetUserChat(username string, chat *tb.Chat) {
	serializedChat, err := json.Marshal(chat)
	if err != nil {
		return
	}

	u.Set(username, "private_chat", string(serializedChat))
}

func (u usersFile) read() {
	u.mutex.Lock()
	defer u.mutex.Unlock()
	data, err := ioutil.ReadFile(u.path)
	if err != nil {
		// File doesn't exist, skip import
		return
	}
	json.Unmarshal(data, &Users.data)
}

func (u usersFile) write() {
	u.mutex.Lock()
	defer u.mutex.Unlock()
	Users.mutex.Lock()
	defer Users.mutex.Unlock()
	data, _ := json.Marshal(Users.data)
	ioutil.WriteFile(u.path, data, 0770)
}