Zippytal-Node/zoneUsersDBHandler.go

package localserver

import (
	"encoding/json"
	"path/filepath"

	"github.com/dgraph-io/badger/v3"
)

type User struct {
	ID                   string   `json:"id"`
	Name                 string   `json:"name"`
	ChatRights           string   `json:"chatRights"`
	AudioChannelRights   string   `json:"audioChannelRights"`
	VideoChannelRights   string   `json:"videoChannelRights"`
	MediaRights          string   `json:"mediaRights"`
	FileRights           string   `json:"fileRights"`
	KnownChatsId         []string `json:"knownChatsId"`
	KnownAudioChannelsId []string `json:"knownAudioChannelsId"`
	KnownVideoChannelsId []string `json:"knownVideoChannelsId"`
	KnownMediaFolderId   []string `json:"knownMediaFolderId"`
	KnownFileFolderId    []string `json:"knownFileFolderId"`
	Admin                bool     `json:"admin"`
	Owner                bool     `json:"owner"`
}

type ZoneUsersDBHandler struct {
	ZoneID string
	db     func(func(*badger.DB) (err error)) (err error)
}

func NewZoneUsersDBHandler(zoneId string, owner string, authorizedMembers []string, init bool) (zoneChatDBHandler *ZoneUsersDBHandler, err error) {
	db := func(f func(*badger.DB) (err error)) (err error) {
		db, err := badger.Open(badger.DefaultOptions(filepath.Join("data", "zones", zoneId, "users")).WithLogger(dbLogger))
		if err != nil {
			return
		}
		defer db.Close()
		err = f(db)
		return
	}
	if init {
		admin := &User{
			ID:                   owner,
			Name:                 owner,
			ChatRights:           "",
			AudioChannelRights:   "",
			VideoChannelRights:   "",
			MediaRights:          "",
			FileRights:           "",
			KnownChatsId:         []string{},
			KnownAudioChannelsId: []string{},
			KnownVideoChannelsId: []string{},
			KnownMediaFolderId:   make([]string, 0),
			KnownFileFolderId:    make([]string, 0),
			Admin:                true,
			Owner:                true,
		}
		bs, jsonErr := json.Marshal(admin)
		if jsonErr != nil {
			return nil, jsonErr
		}
		if err = db(func(d *badger.DB) (err error) {
			err = d.Update(func(txn *badger.Txn) (err error) {
				err = txn.Set([]byte(owner), bs)
				return
			})
			return
		}); err != nil {
			return
		}
	}
	if err = db(func(d *badger.DB) (err error) {
		err = d.Update(func(txn *badger.Txn) (err error) {
			for _, member := range authorizedMembers {
				if member != owner {
					if _, berr := txn.Get([]byte(member)); berr == badger.ErrKeyNotFound {
						logger.Println("creating new user", member)
						user := &User{
							ID:                   member,
							Name:                 member,
							ChatRights:           "",
							AudioChannelRights:   "",
							VideoChannelRights:   "",
							MediaRights:          "",
							FileRights:           "",
							KnownChatsId:         []string{},
							KnownAudioChannelsId: []string{},
							KnownVideoChannelsId: []string{},
							KnownMediaFolderId:   make([]string, 0),
							KnownFileFolderId:    make([]string, 0),
							Admin:                false,
							Owner:                false,
						}
						bs, jsonErr := json.Marshal(user)
						if jsonErr != nil {
							return jsonErr
						}
						if err = txn.Set([]byte(member), bs); err != nil {
							return
						}
					}
				}
			}
			return nil
		})
		return
	}); err != nil {
		return
	}
	zoneChatDBHandler = &ZoneUsersDBHandler{
		db:     db,
		ZoneID: zoneId,
	}
	return
}

func (zcdbh *ZoneUsersDBHandler) AddNewUser(user *User) (err error) {
	bs, err := json.Marshal(user)
	if err != nil {
		return
	}
	if err = zcdbh.db(func(d *badger.DB) (err error) {
		err = d.Update(func(txn *badger.Txn) error {
			if _, notFoundErr := txn.Get([]byte(user.ID)); notFoundErr == badger.ErrKeyNotFound {
				if updateErr := txn.Set([]byte(user.ID), bs); updateErr != nil {
					return updateErr
				}
			}
			return nil
		})
		return
	}); err != nil {
		return
	}
	return
}

func (zcdbh *ZoneUsersDBHandler) DeleteUser(id string) (err error) {
	err = zcdbh.db(func(d *badger.DB) (err error) {
		err = d.Update(func(txn *badger.Txn) (err error) {
			err = txn.Delete([]byte(id))
			return
		})
		return
	})
	return
}

func (zcdbh *ZoneUsersDBHandler) ListUsers(lastIndex int, limit int) (users []*User, err error) {
	err = zcdbh.db(func(d *badger.DB) (err error) {
		err = d.View(func(txn *badger.Txn) error {
			opt := badger.DefaultIteratorOptions
			opt.Reverse = true
			it := txn.NewIterator(opt)
			defer it.Close()
			users = make([]*User, 0)
			for it.Rewind(); it.Valid(); it.Next() {
				item := it.Item()
				if err = item.Value(func(val []byte) error {
					var user *User
					if jsonErr := json.Unmarshal(val, &user); jsonErr != nil {
						return jsonErr
					}
					users = append(users, user)
					return nil
				}); err != nil {
					return err
				}
			}
			return nil
		})
		return
	})
	return
}

func (zcdbh *ZoneUsersDBHandler) GetUser(id string) (user *User, err error) {
	err = zcdbh.db(func(d *badger.DB) (err error) {
		err = d.View(func(txn *badger.Txn) error {
			item, err := txn.Get([]byte(id))
			if err != nil {
				return err
			}
			err = item.Value(func(val []byte) (err error) {
				err = json.Unmarshal(val, &user)
				return
			})
			return err
		})
		return
	})
	return
}

func (zcdbh *ZoneUsersDBHandler) ModifyUser(id string, user *User) (err error) {
	bs, err := json.Marshal(user)
	if err != nil {
		return
	}
	err = zcdbh.db(func(d *badger.DB) (err error) {
		err = d.Update(func(txn *badger.Txn) (err error) {
			err = txn.Set([]byte(id), bs)
			return
		})
		return
	})
	return
}