C# PwGroup.SetParent方法代码示例

        /// <summary>
        /// The function creates a new PwGroup that represents an export path.
        /// All userProxies that will be placed in that group means taht this
        /// user will use this export path too.
        /// </summary>
        /// <param name="folderName">The path to the folder in your filesystem that should be used
        /// as export destination.</param>
        /// <returns><c>ChangeFlags.CommonChange</c> if the function has made any changes to the 
        /// actual database structure (means if we added the expPath). 0 if the expPath allready exists
        /// and we don't have to make any changes anymore.</returns>
        public Changes AddExportPath(string folderName)
        {
            //is it a valid path?
            if (!Directory.Exists(folderName))
            {
                return Changes.None;
            }
            //check if allready exists
            PwGroup exportGroup = m_database.GetExportGroup();
            foreach ( PwGroup exp in exportGroup.GetGroups( false ) )
            {
                if( exp.Name == folderName )
                {
                    return Changes.None;
                }
            }

            //create new export path
            PwGroup newExport = new PwGroup( true, true, folderName, PwIcon.NetworkServer );
            newExport.SetParent(exportGroup);
            return Changes.GroupCreated;
        }

 /// <summary>
 /// The <c>GetUsersHome</c> function looks for the home folder of a user.
 /// If it doesn't exist, a new one will be created.
 /// The createIfNotFound parameter is optional.
 /// </summary>
 /// <param name="userRoot">UserRootNode which we want to find the home folder of.</param>
 /// <param name="createIfNotFound">If not set the default value is true. That
 /// means that a home will be created if not found!</param>
 /// <returns>PwGroup homefolder of a user</returns>
 public static PwGroup GetUserHomeFor(this PwDatabase database, PwEntry userRoot, bool createIfNotFound = true)
 {
     Debug.Assert(database != null);
     PwGroup usersGroup = GetUsersGroup(database);
     PwObjectList<PwGroup> usersHomes = usersGroup.GetGroups(false);
     foreach (PwGroup pg in usersHomes)
     {
         if (pg.Notes.Contains(userRoot.Uuid.ToHexString()))
         {
             return pg;
         }
     }
     //if home was not found then create it
     if (createIfNotFound)
     {
         string name = userRoot.Strings.ReadSafe("Title");
         PwGroup newUserGroup = new PwGroup(true, true, name, PwIcon.UserKey);
         newUserGroup.Notes += userRoot.Uuid.ToHexString();
         newUserGroup.SetParent(usersGroup);
         return newUserGroup;
     }
     return null;
 }

        /// <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;
        }

 public static PwGroup FindCreateGroup(this PwDatabase database, string tag, string name, PwIcon icon = PwIcon.Folder)
 {
     foreach (PwGroup rootGroup in database.RootGroup.GetGroups(true))
     {
         if (rootGroup.Notes.Contains(tag))
         {
             return rootGroup;
         }
     }
     //if we cant find the group yet, we create a new one and add it to the rootGroup
     PwGroup group = new PwGroup(true, true, name, icon);
     group.Notes = tag;
     group.SetParent(database.RootGroup);
     Debug.Assert(null != group, "group for " + tag + " - " + name + " is 'null' but should not!");
     return group;
 }