/// <summary>
/// The function creates a new PwEntry that represents an import source.
/// </summary>
/// <param name="fileName">The path to the file in your filesystem that should be used
/// as import source.</param>
/// <returns><c>ChangeFlags.CommonChange</c> if the function has made any changes to the
/// actual database structure (means if we added he impSrc). 0 if the impSrc allready exists
/// and we don't have to make any changes anymore.</returns>
public Changes AddImportPath(string fileName)
{
//is it a valid path to a file?
if (!File.Exists(fileName))
{
return(Changes.None);
}
//check if allready exists
PwGroup importGroup = m_database.GetImportGroup();
foreach (PwEntry src in importGroup.GetEntries(true))
{
if (src.Strings.ReadSafe(KeeShare.SourcePathField) == fileName)
{
return(Changes.None);
}
}
PwGroup newImportGroup = new PwGroup(true, true, fileName, PwIcon.NetworkServer);
newImportGroup.SetParent(importGroup);
PwEntry newImportSource = new PwEntry(true, true);
newImportSource.Strings.Set(KeeShare.TitleField, new ProtectedString(false, fileName));
newImportSource.Strings.Set(KeeShare.SourcePathField, new ProtectedString(false, fileName));
newImportSource.SetParent(newImportGroup);
return(Changes.GroupCreated);
}
/// <summary>
/// Propagates possible changes of a rootNode to all of his proxyNodes
/// </summary>
/// <param name="root">The rootNode we want to propagate</param>
/// <returns>True if the function has made changes to the database.</returns>
private Changes UpdateProxyInformation(PwEntry root)
{
Changes changeFlag = Changes.None;
//get all relevant proxies
//copy new information from root to proxies
PwObjectList <PwEntry> allProxies = m_database.GetAllProxyNodes();
foreach (PwEntry proxy in allProxies)
{
//check if the proxy matches to the root and has changes! if not we are done here
if (proxy.IsProxyOf(root) && !proxy.IsSimilarTo(root, true))
{
PwGroup parent = proxy.ParentGroup;
bool success = parent.Entries.Remove(proxy);
Debug.Assert(success);
PwEntry duplicate = root.CloneDeep();
duplicate.Uuid = proxy.Uuid;
//if the rootNode was a userRoot, the StringFiledUidLink is set automatically in a clone
//but if not we have to set it manually
if (!root.IsUserRootNode())
{
duplicate.MakeToProxyOf(root);
}
duplicate.SetParent(parent);
changeFlag |= Changes.EntryCreated;
}
}
return(changeFlag);
}
public static PwEntry DuplicateTo(this PwEntry entry, PwGroup parent)
{
PwEntry copy = new PwEntry(false, false);
copy.Uuid = entry.Uuid;
copy.AssignProperties(entry, false, false, true);
//TODO MST: clear this comment and it's ramifications!
//HACK: CloneDeep introduces the copy into the parent node, therefore SetParent triggers a change of the parent
// which shouldn't be - the extended ProtectionSection in KeeShare should prevent interference, but a
// a clean way to clone a node without cloning children and without hooking it into a tree would be nice
copy.SetParent(parent);
return(copy);
}
/// <summary>
/// The function checks if thelast made change has to be propageted to
/// some referenced PwEntries
/// </summary>
/// <returns>True if the function has made changes to the database.</returns>
private Changes CheckReferences()
{
PwEntry lastModifiedEntry = GetLastModifiedEntry();
//if there are no changes, then we have nothing to do
if (lastModifiedEntry == null)
{
return(Changes.None);
}
//was it a proxy or not?
Changes changeFlag = Changes.None;
if (lastModifiedEntry.IsProxyNode())
{
//lets update the root so we later can update all proxies
PwEntry root = m_database.GetProxyTargetFor(lastModifiedEntry);
//check if there are real changes! if not we are done here
if (lastModifiedEntry.IsSimilarTo(root, true))
{
return(Changes.None);
}
PwGroup parent = root.ParentGroup;
root.CreateBackup(m_database); //rootNode_X should save all modifications in history
parent.Entries.Remove(root);
PwEntry updatedRoot = lastModifiedEntry.CloneDeep();
updatedRoot.Uuid = root.Uuid;
updatedRoot.SetParent(parent);
//special handling for userRootNodes because they have a homefolder
if (root.IsUserRootNode())
{
//maybe the oldUserName has changed to => the homefolder should have the new name also
//we also want to have the same icons everywhere
parent.Name = updatedRoot.GetTitle();
parent.IconId = updatedRoot.IconId;
}
else
{
updatedRoot.Strings.Remove(KeeShare.UuidLinkField);
}
changeFlag |= UpdateProxyInformation(updatedRoot);
changeFlag |= Changes.GroupDeleted;
}
else
{
changeFlag |= UpdateProxyInformation(lastModifiedEntry);
}
pe_lastModedEntry = GetLastModifiedEntry();
return(changeFlag);
}
private Changes RestoreMovedUserNode(PwEntry userNode, PwGroup userHome, PwGroup usersGroup)
{
//only the userNode was moved..
//are we located anywhere in the "users"group => here we have to be careful!
if (userNode.IsInsideParent(usersGroup))
{
//do we have a applicable homeFolder?
if (null != userHome)
{
//then we should only move back!
userNode.ParentGroup.Entries.Remove(userNode);
userNode.SetParent(userHome);
//and we are done here...
return(Changes.EntryMoved);
}
}
else
{
//else userNode was moved intentionally to share a folder, so move the rootNode back
//and create a proxy at the new location
PwGroup parentGroup = userNode.ParentGroup;
parentGroup.Entries.Remove(userNode);
//ensure that the original rootNode is located in his homefolder
//move the original userRootNode back to his homefolder
userNode.SetParent(m_database.GetUserHomeFor(userNode));
//create proxyNode in the folder
if (!GroupIsSharedToUser(parentGroup, userNode))
{
PwEntry proxy = userNode.CreateProxyNode();
proxy.SetParent(parentGroup);
return(Changes.EntryMoved | Changes.EntryCreated);
}
return(Changes.EntryMoved);
}
return(Changes.None);
}
/// <summary>
/// The <c>ShareGroupWithUser</c> function adds an user-proxy to the group group.
/// This userentry specifies the user how should become access to the group group.
/// </summary>
/// <param name="group">The group we want to share.</param>
/// <param name="root">userRootNode of the user we want to share the group with.</param>
private void ShareGroupWithUser(PwGroup group, PwEntry root)
{
//if (!UserExists(name)) return;
//check if group is shared allready
if (GroupIsSharedToUser(group, root))
{
return;
}
PwEntry proxyNode = root.CreateProxyNode();
if (proxyNode != null)
{
proxyNode.SetParent(group);
}
}
/// <summary>
/// The <c>CreateNewUser</c> function creates a new user you
/// later can share passwords with.
/// This includes a proxy in the UsersGroupName group and also
/// creates a new user-specific group in the tree UsersGroupName
/// </summary>
/// <param name="name">oldUserName of the new user</param>
/// <returns>True if all is done properly! False otherwise!</returns>
protected Changes CreateNewUser(string name, PwGroup useAsHome = null)
{
PwEntry newUser = CreateUserNode(name);
PwGroup newUserGroup = useAsHome;
if (newUserGroup == null) //create a new home for that user
{
newUserGroup = m_database.GetUserHomeFor(newUser, true);
}
else
{
newUserGroup.IconId = PwIcon.UserKey;
newUserGroup.Notes += newUser.Uuid.ToHexString();
}
//put the userRootNode into his homefolder
newUser.SetParent(newUserGroup);
//due to better userHandling while dragNdrop we create a proxyNode in the usersGroup
PwEntry proxy = newUser.CreateProxyNode();
proxy.SetParent(m_database.GetUsersGroup());
return(Changes.GroupCreated | Changes.EntryCreated);
}
private Changes EnsureUsersProxiesInUsersGroup()
{
PwGroup usersGroup = m_database.GetUsersGroup();
PwObjectList <PwEntry> allUsers = m_database.GetAllUserNodes();
PwObjectList <PwEntry> allUserGroupProxies = new PwObjectList <PwEntry>();
HashSet <string> proxyIds = new HashSet <string>();
//fill the allUserGroupProxyList with relevant entries
foreach (PwEntry entry in usersGroup.GetEntries(false))
{
if (entry.IsProxyNode())
{
allUserGroupProxies.Add(entry);
proxyIds.Add(entry.Strings.ReadSafe(KeeShare.UuidLinkField));
}
}
//compare the numbers of proxyNodes in the usersGroup and the entries in the allUsers list
//if they are equal all relevant proxies exist because we checked there consistence before
// and we are done here
Changes changeFlag = Changes.None;
if (allUsers.UCount != allUserGroupProxies.UCount)
{
foreach (PwEntry rootNode in allUsers)
{
if (!proxyIds.Contains(rootNode.Uuid.ToHexString()))
{
PwEntry proxy = rootNode.CreateProxyNode();
proxy.SetParent(usersGroup);
changeFlag |= Changes.EntryCreated;
}
}
}
return(changeFlag);
}
/// <summary>
/// The function creates a new PwEntry that represents an import source.
/// </summary>
/// <param name="fileName">The path to the file in your filesystem that should be used
/// as import source.</param>
/// <returns><c>ChangeFlags.CommonChange</c> if the function has made any changes to the
/// actual database structure (means if we added he impSrc). 0 if the impSrc allready exists
/// and we don't have to make any changes anymore.</returns>
public Changes AddImportPath(string fileName)
{
//is it a valid path to a file?
if (!File.Exists(fileName))
{
return Changes.None;
}
//check if allready exists
PwGroup importGroup = m_database.GetImportGroup();
foreach ( PwEntry src in importGroup.GetEntries( true ) )
{
if( src.Strings.ReadSafe(KeeShare.SourcePathField ) == fileName )
{
return Changes.None;
}
}
PwGroup newImportGroup = new PwGroup( true, true, fileName, PwIcon.NetworkServer );
newImportGroup.SetParent(importGroup );
PwEntry newImportSource = new PwEntry( true, true );
newImportSource.Strings.Set(KeeShare.TitleField, new ProtectedString( false, fileName ) );
newImportSource.Strings.Set(KeeShare.SourcePathField, new ProtectedString( false, fileName ) );
newImportSource.SetParent(newImportGroup);
return Changes.GroupCreated;
}
