gokwallet/walletmanager_funcs.go

package gokwallet

import (
	"github.com/godbus/dbus/v5"
)

/*
	NewWalletManager returns a WalletManager. It requires a RecurseOpts
	(you can use DefaultRecurseOpts, call NewRecurseOpts, or provide your own RecurseOpts struct).
	If appId is empty/nil, DefaultAppID will be used as the app ID.
	If appId is specified, only the first string is used.
*/
func NewWalletManager(recursion *RecurseOpts, appID ...string) (wm *WalletManager, err error) {

	var realAppID string

	if appID != nil && len(appID) > 0 {
		realAppID = appID[0]
	} else {
		realAppID = DefaultAppID
	}

	if wm, err = newWM(realAppID, recursion); err != nil {
		return
	}

	return
}

/*
	NewWalletManagerFiles returns a WalletManager from one or more filePaths (*.kwl, *.tar, or *.xml exports).
	Note that if the wallet file was created via an "encrypted export", it will be a .kwl file
	inside a .tar.
	err will contain a MultiError if any filepaths specified do not exist or cannot be opened.
	It requires a RecurseOpts (you can use DefaultRecurseOpts, call NewRecurseOpts,
	or provide your own RecurseOpts struct).
	If appId is empty, DefaultAppID will be used as the app ID.
*/
/* TODO: POC this before exposing. I have NO idea if it'll work.
func NewWalletManagerFiles(recursion *RecurseOpts, appId string, filePaths ...string) (wm *WalletManager, err error) {

	var exist bool
	var errs []error = make([]error, 0)
	var realFilePaths []string = make([]string, 0)

	if appId == "" {
		appId = DefaultAppID
	}

	for _, f := range filePaths {
		if f == "" {
			continue
		}
		if exist, err = paths.RealPathExists(&f); err != nil {
			errs = append(errs, err)
			err = nil
			continue
		}
		if !exist {
			err = errors.New(fmt.Sprintf("%v does not exist", f))
			err = nil
			continue
		}
		realFilePaths = append(realFilePaths, f)
	}

	// TODO: do the actual newWM here.

	if errs != nil && len(errs) > 0 {
		err = NewErrors(errs...)
	}

	return
}
*/

/*
	CloseWallet closes a Wallet.
	Unlike Wallet.Close, this closes access for ALL applications/WalletManagers
	for the specified Wallet - not just this WalletManager.
*/
func (wm *WalletManager) CloseWallet(walletName string) (err error) {
	var rslt int32

	if !wm.isInit {
		err = ErrNotInitialized
		return
	}

	// Using a handler allows us to close access for this particular parent WalletManager.
	if err = wm.Dbus.Call(
		DbusWMClose, 0, walletName, false,
	).Store(&rslt); err != nil {
		return
	}

	err = resultCheck(rslt)

	return
}

/*
	ForceCloseWallet is like WalletManager.CloseWallet but will still close a Wallet even if currently in use.
	Unlike Wallet.ForceClose, this closes access for ALL applications/WalletManagers
	for the specified Wallet - not just this WalletManager.
*/
func (wm *WalletManager) FprceCloseWallet(walletName string) (err error) {

	var rslt int32

	if !wm.isInit {
		err = ErrNotInitialized
		return
	}

	// Using a handler allows us to close access for this particular parent WalletManager.
	if err = wm.Dbus.Call(
		DbusWMClose, 0, walletName, false,
	).Store(&rslt); err != nil {
		return
	}

	err = resultCheck(rslt)

	return
}

// CloseAllWallets closes all Wallet objects. They do *not* need to be part of WalletManager.Wallets.
func (wm *WalletManager) CloseAllWallets() (err error) {

	var call *dbus.Call

	if !wm.isInit {
		err = ErrNotInitialized
		return
	}

	call = wm.Dbus.Call(
		DbusWMCloseAllWallets, 0,
	)
	err = call.Err

	return
}

// IsEnabled returns whether KWallet is enabled or not (and also updates WalletManager.Enabled).
func (wm *WalletManager) IsEnabled() (enabled bool, err error) {

	if !wm.isInit {
		err = ErrNotInitialized
		return
	}

	if err = wm.Dbus.Call(
		DbusWMIsEnabled, 0,
	).Store(&wm.Enabled); err != nil {
		return
	}

	enabled = wm.Enabled

	return
}

// LocalWallet returns the "local" wallet (and updates WalletManager.Local).
func (wm *WalletManager) LocalWallet() (w *Wallet, err error) {

	var wn string

	if err = wm.Dbus.Call(
		DbusWMLocalWallet, 0,
	).Store(&wn); err != nil {
		return
	}

	if w, err = NewWallet(wm, wn, wm.Recurse); err != nil {
		return
	}

	wm.Local = w

	return
}

// NetworkWallet returns the "network" wallet (and updates WalletManager.Network).
func (wm *WalletManager) NetworkWallet() (w *Wallet, err error) {

	var wn string

	if err = wm.Dbus.Call(
		DbusWMNetWallet, 0,
	).Store(&wn); err != nil {
		return
	}

	if w, err = NewWallet(wm, wn, wm.Recurse); err != nil {
		return
	}

	wm.Network = w

	return
}

// WalletNames returns a list of available Wallet names.
func (wm *WalletManager) WalletNames() (wallets []string, err error) {

	if err = wm.Dbus.Call(
		DbusWMWallets, 0,
	).Store(&wallets); err != nil {
		return
	}

	return
}

// Update fetches/updates all Wallet objects in a WalletManager.
func (wm *WalletManager) Update() (err error) {

	var walletNames []string
	var errs []error = make([]error, 0)

	if !wm.isInit {
		err = ErrNotInitialized
		return
	}

	if walletNames, err = wm.WalletNames(); err != nil {
		return
	}

	wm.Wallets = make(map[string]*Wallet)

	for _, wn := range walletNames {

		if wm.Wallets[wn], err = NewWallet(wm, wn, wm.Recurse); err != nil {
			errs = append(errs, err)
			err = nil
			continue
		}
	}

	if errs != nil && len(errs) > 0 {
		err = NewErrors(errs...)
		return
	}

	return
}

// newWM is what does the heavy lifting behind NewWalletManager and NewWalletManagerFiles.
func newWM(appId string, recursion *RecurseOpts, filePaths ...string) (wm *WalletManager, err error) {

	wm = &WalletManager{
		DbusObject: &DbusObject{
			Conn: nil,
			Dbus: nil,
		},
		AppID:   appId,
		Wallets: nil,
		Recurse: recursion,
	}

	if wm.DbusObject.Conn, err = dbus.SessionBus(); err != nil {
		return
	}
	wm.DbusObject.Dbus = wm.DbusObject.Conn.Object(DbusService, dbus.ObjectPath(DbusPath))

	if wm.Recurse.All || wm.Recurse.Wallets {
		if err = wm.Update(); err != nil {
			return
		}
		if _, err = wm.LocalWallet(); err != nil {
			return
		}
		if _, err = wm.NetworkWallet(); err != nil {
			return
		}
	}

	wm.isInit = true

	return
}