all Dbus methods covered.

Now to add some niceties and add tests.

folder_funcs.go

@@ -44,6 +44,78 @@ func NewFolder(w *Wallet, name string, recursion *RecurseOpts) (folder *Folder,
 	return
 }
 
+// HasEntry specifies if a Folder has an entry (WalletItem item) by the give entryName.
+func (f *Folder) HasEntry(entryName string) (hasEntry bool, err error) {
+
+	if err = f.Dbus.Call(
+		DbusWMHasEntry, 0, f.wallet.handle, f.Name, entryName, f.wallet.wm.AppID,
+	).Store(&hasEntry); err != nil {
+		return
+	}
+
+	return
+}
+
+/*
+	KeyNotExist returns true if a key/entry name entryName does *not* exist.
+	Essentially the same as Folder.HasEntry, but whereas Folder.HasEntry requires the parent wallet
+	to be open/unlocked, Folder.KeyNotExist does not require this.
+*/
+func (f *Folder) KeyNotExist(entryName string) (doesNotExist bool, err error) {
+
+	if err = f.Dbus.Call(
+		DbusWMKeyNotExist, 0, f.wallet.Name, f.Name, entryName,
+	).Store(&doesNotExist); err != nil {
+		return
+	}
+
+	return
+}
+
+// ListEntries lists all entries (WalletItem items) in a Folder (regardless of type) by name.
+func (f *Folder) ListEntries() (entryNames []string, err error) {
+
+	if err = f.Dbus.Call(
+		DbusWMEntryList, 0, f.wallet.handle, f.Name, f.wallet.wm.AppID,
+	).Store(&entryNames); err != nil {
+		return
+	}
+
+	return
+}
+
+// RemoveEntry removes a WalletItem from a Folder given its entryName (key).
+func (f *Folder) RemoveEntry(entryName string) (err error) {
+
+	var rslt int32
+
+	if err = f.Dbus.Call(
+		DbusWMRemoveEntry, 0, f.wallet.handle, f.Name, entryName, f.wallet.wm.AppID,
+	).Store(&rslt); err != nil {
+		return
+	}
+
+	err = resultCheck(rslt)
+
+	return
+}
+
+// RenameEntry renames a WalletItem in a Folder from entryName to newEntryName.
+func (f *Folder) RenameEntry(entryName, newEntryName string) (err error) {
+
+	var rslt int32
+
+	if err = f.Dbus.Call(
+		DbusWMRenameEntry, 0, f.wallet.handle, f.Name, entryName, newEntryName, f.wallet.wm.AppID,
+	).Store(&rslt); err != nil {
+		return
+	}
+
+	err = resultCheck(rslt)
+
+	return
+}
+
 // Update runs all of the configured Update[type] methods for a Folder, depending on Folder.Recurse configuration.
 func (f *Folder) Update() (err error) {
 
@@ -172,7 +244,7 @@ func (f *Folder) UpdateBlobs() (err error) {
 	f.BinaryData = make(map[string]*Blob, len(mapKeys))
 
 	for _, k := range mapKeys {
-		if isBlob, err = f.isType(k, kwalletdEnumTypeStream); err != nil {
+		if isBlob, err = f.isType(k, KwalletdEnumTypeStream); err != nil {
 			errs = append(errs, err)
 			err = nil
 			continue
@@ -218,7 +290,7 @@ func (f *Folder) UpdateUnknowns() (err error) {
 	f.Unknown = make(map[string]*UnknownItem, len(mapKeys))
 
 	for _, k := range mapKeys {
-		if isUnknown, err = f.isType(k, kwalletdEnumTypeUnknown); err != nil {
+		if isUnknown, err = f.isType(k, KwalletdEnumTypeUnknown); err != nil {
 			errs = append(errs, err)
 			err = nil
 			continue
@@ -240,8 +312,90 @@ func (f *Folder) UpdateUnknowns() (err error) {
 	return
 }
 
-// isType checks if a certain key keyName is of type typeCheck (via kwalletdEnumType*).
-func (f *Folder) isType(keyName string, typeCheck int32) (isOfType bool, err error) {
+// WriteBlob adds or replaces a Blob to/in a Folder.
+func (f *Folder) WriteBlob(entryName string, entryValue []byte) (err error) {
+
+	if err = f.WriteEntry(entryName, KwalletdEnumTypeStream, entryValue); err != nil {
+		return
+	}
+
+	return
+}
+
+/*
+	WriteEntry is used for adding/replacing a WalletItem as a general interface.
+	If possible, you'll want to use a item-type-specific method (e.g. Folder.WritePassword) as this one is a little unwieldy to use.
+	entryType must be the relevant KwalletdEnumType* constant (do not use KwalletdEnumTypeUnused).
+*/
+func (f *Folder) WriteEntry(entryName string, entryType kwalletdEnumType, entryValue []byte) (err error) {
+
+	var rslt int32
+
+	if entryType == KwalletdEnumTypeUnused {
+		err = ErrNoCreate
+		return
+	}
+
+	if err = f.Dbus.Call(
+		DbusWMWriteEntry, 0, f.wallet.handle, f.Name, entryName, entryValue, int32(entryType), f.wallet.wm.AppID,
+	).Store(&rslt); err != nil {
+		return
+	}
+
+	err = resultCheck(rslt)
+
+	return
+}
+
+// WriteMap adds or replaces a Map to/in a Folder.
+func (f *Folder) WriteMap(entryName string, entryValue map[string]string) (err error) {
+
+	var rslt int32
+	var b []byte
+
+	if b, err = mapToBytes(entryValue); err != nil {
+		return
+	}
+
+	if err = f.Dbus.Call(
+		DbusWMWriteMap, 0, f.wallet.handle, f.Name, entryName, b, f.wallet.wm.AppID,
+	).Store(&rslt); err != nil {
+		return
+	}
+
+	err = resultCheck(rslt)
+
+	return
+}
+
+// WritePassword adds or replaces a Password to/in a Folder.
+func (f *Folder) WritePassword(entryName, entryValue string) (err error) {
+
+	var rslt int32
+
+	if err = f.Dbus.Call(
+		DbusWMWritePassword, 0, f.wallet.handle, f.Name, entryName, entryValue, f.wallet.wm.AppID,
+	).Store(&rslt); err != nil {
+		return
+	}
+
+	err = resultCheck(rslt)
+
+	return
+}
+
+// WriteUnknown adds or replaces an UnknownItem to/in a Folder.
+func (f *Folder) WriteUnknown(entryName string, entryValue []byte) (err error) {
+
+	if err = f.WriteEntry(entryName, KwalletdEnumTypeUnknown, entryValue); err != nil {
+		return
+	}
+
+	return
+}
+
+// isType checks if a certain key keyName is of type typeCheck (via KwalletdEnumType*).
+func (f *Folder) isType(keyName string, typeCheck kwalletdEnumType) (isOfType bool, err error) {
 
 	var entryType int32
 
@@ -251,5 +405,9 @@ func (f *Folder) isType(keyName string, typeCheck int32) (isOfType bool, err err
 		return
 	}
 
+	if int32(typeCheck) == entryType {
+		isOfType = true
+	}
+
 	return
 }