walletmanager funcs done, now for wallet funcs

wallet_funcs.go

@@ -1,14 +1,191 @@
 package gokwallet
 
-import (
-	"github.com/godbus/dbus/v5"
-)
+/*
+	NewWallet returns a Wallet. It requires a RecurseOpts
+	(you can use DefaultRecurseOpts, call NewRecurseOpts, or provide your own RecurseOpts struct).
+	It also requires a WalletManager and wallet name.
+*/
+func NewWallet(wm *WalletManager, name string, recursion *RecurseOpts) (wallet *Wallet, err error) {
 
-func NewWallet(wm *WalletManager, path dbus.ObjectPath) (wallet *Wallet, err error) {
+	if !wm.isInit {
+		err = ErrNotInitialized
+		return
+	}
 
-	var open bool
+	wallet = &Wallet{
+		DbusObject: wm.DbusObject,
+		Name:       name,
+		Folders:    nil,
+		Recurse:    recursion,
+		wm:         wm,
+		// handle:     0,
+		isInit: false,
+	}
 
-	_ = open
+	// TODO: remove this and leave to caller, since it might use PamOpen instead? Fail back to it?
+	if err = wallet.walletCheck(); err != nil {
+		return
+	}
+
+	if wallet.Recurse.All || wallet.Recurse.Wallets {
+		if err = wallet.Update(); err != nil {
+			return
+		}
+	}
+
+	wallet.isInit = true
+
+	return
+}
+
+// Close closes a Wallet.
+func (w *Wallet) Close() (err error) {
+
+	var rslt int32
+
+	if !w.isInit {
+		err = ErrNotInitialized
+		return
+	}
+
+	// Using a handler allows us to close access for this particular parent WalletManager.
+	if err = w.Dbus.Call(
+		DbusWMClose, 0, w.handle, false, w.wm.AppID,
+	).Store(&rslt); err != nil {
+		return
+	}
+
+	err = resultCheck(rslt)
+
+	return
+}
+
+/*
+	ForceClose is like Close but will still close a Wallet even if currently in use by the WalletManager.
+	(Despite the insinuation by the name, this should be a relatively safe operation).
+*/
+func (w *Wallet) ForceClose() (err error) {
+
+	var rslt int32
+
+	if !w.isInit {
+		err = ErrNotInitialized
+		return
+	}
+
+	// Using a handler allows us to close access for this particular parent WalletManager.
+	if err = w.Dbus.Call(
+		DbusWMClose, 0, w.handle, true, w.wm.AppID,
+	).Store(&rslt); err != nil {
+		return
+	}
+
+	err = resultCheck(rslt)
+
+	return
+
+	return
+}
+
+// IsOpen returns whether a Wallet is open ("unlocked") or not (as well as updates Wallet.IsOpen).
+func (w *Wallet) IsOpen() (isOpen bool, err error) {
+
+	// We can call the same method with w.handle instead of w.Name. We don't have a handler yet though.
+	if err = w.Dbus.Call(
+		DbusWMIsOpen, 0, w.Name,
+	).Store(&w.IsUnlocked); err != nil {
+		return
+	}
+
+	isOpen = w.IsUnlocked
+
+	return
+}
+
+// ListFolders lists all Folder names in a Wallet.
+func (w *Wallet) ListFolders() (folderList []string, err error) {
+
+	if err = w.walletCheck(); err != nil {
+		return
+	}
+
+	if err = w.Dbus.Call(
+		DbusWMFolderList, 0, w.handle, w.wm.AppID,
+	).Store(&folderList); err != nil {
+		return
+	}
+
+	return
+}
+
+/*
+	Open will open ("unlock") a Wallet.
+	It will no-op if the Wallet is already open.
+*/
+func (w *Wallet) Open() (err error) {
+
+	if _, err = w.IsOpen(); err != nil {
+		return
+	}
+
+	if !w.IsUnlocked {
+		if err = w.Dbus.Call(
+			DbusWMOpen, 0,
+		).Store(&w.handle); err != nil {
+			return
+		}
+	}
+
+	w.IsUnlocked = true
+
+	return
+}
+
+// Update fetches/updates all Folder objects in a Wallet.
+func (w *Wallet) Update() (err error) {
+
+	var folderNames []string
+	var errs []error = make([]error, 0)
+
+	if folderNames, err = w.ListFolders(); err != nil {
+		return
+	}
+
+	w.Folders = make(map[string]*Folder)
+
+	for _, fn := range folderNames {
+		if w.Folders[fn], err = NewFolder(w, fn, w.Recurse); err != nil {
+			errs = append(errs, err)
+			err = nil
+			continue
+		}
+	}
+
+	if errs != nil && len(errs) > 0 {
+		err = NewErrors(errs...)
+		return
+	}
+
+	return
+}
+
+// walletCheck will check if a Wallet is (initialized and) opened and, if not, attempt to open it.
+func (w *Wallet) walletCheck() (err error) {
+
+	if !w.isInit {
+		err = ErrNotInitialized
+		return
+	}
+
+	if _, err = w.IsOpen(); err != nil {
+		return
+	}
+
+	if !w.IsUnlocked {
+		if err = w.Open(); err != nil {
+			return
+		}
+	}
 
 	return
 }