/// <summary> Add a new item aggregation to this user group's collection of item aggregationPermissions </summary>
        /// <param name="PermissionedAggregation">Fully permissioned aggregation </param>
        public void Add_Aggregation(User_Permissioned_Aggregation PermissionedAggregation)
        {
            if (aggregations == null)
            {
                aggregations = new User_Aggregation_Permissions();
            }

            aggregations.Add(PermissionedAggregation);
        }
        /// <summary> Adds a new aggregation to the list of aggregationPermissions linked here, with detailed permissions </summary>
        /// <param name="Code">Code for this user editable item aggregation</param>
        /// <param name="Name">Name for this user editable item aggregation </param>
        /// <param name="CanSelect">Flag indicates if this user can add items to this item aggregation</param>
        /// <param name="CanEditMetadata">Flag indicates if this user can edit the metadata for any items in this item aggregation</param>
        /// <param name="CanEditBehaviors"> Flag indicated if this user can edit the behavior for any items in this item aggregation </param>
        /// <param name="CanPerformQc"> Flag indicates if this user can perform quality control for any items in this item aggregation </param>
        /// <param name="CanUploadFiles"> Flag indicates if this user can upload new files to any items in this item aggregation </param>
        /// <param name="CanChangeVisibility"> Flag indicates if this user can change the visibility information for any items in this item aggregation </param>
        /// <param name="CanDelete"> Flag indicates if this user can delete any items in this item aggregation </param>
        /// <param name="IsCurator"> Flag indicates if this user is listed as the curator or collection manager for this given digital aggregation </param>
        /// <param name="OnHomePage">Flag indicates if this user has asked to have this aggregation appear on their personalized home page</param>
        /// <param name="IsAdmin"> Flag indicates if this user is listed athe admin for this aggregation </param>
        /// <param name="GroupDefined"> Flag indicates if these permissions are defined at the group level </param>
        public void Add(string Code, string Name, bool CanSelect, bool CanEditMetadata, bool CanEditBehaviors, bool CanPerformQc, bool CanUploadFiles, bool CanChangeVisibility, bool CanDelete, bool IsCurator, bool OnHomePage, bool IsAdmin, bool GroupDefined)
        {
            // Create the aggregation object
            User_Permissioned_Aggregation aggrLink = new User_Permissioned_Aggregation(Code.ToUpper(), Name, CanSelect, false, IsCurator, OnHomePage, IsAdmin);
            aggrLink.CanEditMetadata = CanEditMetadata;
            aggrLink.CanEditBehaviors = CanEditBehaviors;
            aggrLink.CanPerformQc = CanPerformQc;
            aggrLink.CanUploadFiles = CanUploadFiles;
            aggrLink.CanChangeVisibility = CanChangeVisibility;
            aggrLink.CanDelete = CanDelete;
            aggrLink.GroupDefined = GroupDefined;

            // Add this
            Add(aggrLink);
        }
        /// <summary> Adds a new aggregation to the list of aggregationPermissions linked here, with detailed permissions </summary>
        /// <param name="Code">Code for this user editable item aggregation</param>
        /// <param name="Name">Name for this user editable item aggregation </param>
        /// <param name="CanSelect">Flag indicates if this user can add items to this item aggregation</param>
        /// <param name="CanEditMetadata">Flag indicates if this user can edit the metadata for any items in this item aggregation</param>
        /// <param name="CanEditBehaviors"> Flag indicated if this user can edit the behavior for any items in this item aggregation </param>
        /// <param name="CanPerformQc"> Flag indicates if this user can perform quality control for any items in this item aggregation </param>
        /// <param name="CanUploadFiles"> Flag indicates if this user can upload new files to any items in this item aggregation </param>
        /// <param name="CanChangeVisibility"> Flag indicates if this user can change the visibility information for any items in this item aggregation </param>
        /// <param name="CanDelete"> Flag indicates if this user can delete any items in this item aggregation </param>
        /// <param name="IsCurator"> Flag indicates if this user is listed as the curator or collection manager for this given digital aggregation </param>
        /// <param name="OnHomePage">Flag indicates if this user has asked to have this aggregation appear on their personalized home page</param>
        /// <param name="IsAdmin"> Flag indicates if this user is listed athe admin for this aggregation </param>
        /// <param name="GroupDefined"> Flag indicates if these permissions are defined at the group level </param>
        public void Add(string Code, string Name, bool CanSelect, bool CanEditMetadata, bool CanEditBehaviors, bool CanPerformQc, bool CanUploadFiles, bool CanChangeVisibility, bool CanDelete, bool IsCurator, bool OnHomePage, bool IsAdmin, bool GroupDefined)
        {
            // Create the aggregation object
            User_Permissioned_Aggregation aggrLink = new User_Permissioned_Aggregation(Code.ToUpper(), Name, CanSelect, false, IsCurator, OnHomePage, IsAdmin);

            aggrLink.CanEditMetadata     = CanEditMetadata;
            aggrLink.CanEditBehaviors    = CanEditBehaviors;
            aggrLink.CanPerformQc        = CanPerformQc;
            aggrLink.CanUploadFiles      = CanUploadFiles;
            aggrLink.CanChangeVisibility = CanChangeVisibility;
            aggrLink.CanDelete           = CanDelete;
            aggrLink.GroupDefined        = GroupDefined;

            // Add this
            Add(aggrLink);
        }
        /// <summary> Adds a new aggregation to the list of aggregationPermissions linked here, with detailed permissions </summary>
        /// <param name="AggregationInfo"> Information about the detailed permissions for this user over an aggregation </param>
        public void Add(User_Permissioned_Aggregation AggregationInfo)
        {
            // If this was pre-existing, remove the old one from the list
            if (code_to_aggregation.ContainsKey(AggregationInfo.Code.ToUpper()))
            {
                if (Aggregations.Contains(AggregationInfo))
                {
                    Aggregations.Remove(AggregationInfo);
                }
            }

            if (Aggregations == null)
            {
                Aggregations = new List <User_Permissioned_Aggregation>();
            }

            Aggregations.Add(AggregationInfo);
            code_to_aggregation[AggregationInfo.Code.ToUpper()] = AggregationInfo;
        }
        /// <summary> Constructor for a new instance of the User_Group_AdminViewer class </summary>
        /// <param name="RequestSpecificValues"> Mode / navigation information for the current request</param>
        /// <remarks> Postback from a user group edit is handled here in the constructor </remarks>
        public User_Group_AdminViewer(RequestCache RequestSpecificValues)
            : base(RequestSpecificValues)
        {
            RequestSpecificValues.Tracer.Add_Trace("User_Group_AdminViewer.Constructor", String.Empty);

            // Set the action message to clear initially
            actionMessage = String.Empty;

            // Get the user to edit, if there was a user id in the submode
            int edit_usergroupid = -100;
            editGroup = null;
            if ( !String.IsNullOrEmpty(RequestSpecificValues.Current_Mode.My_Sobek_SubMode))
            {
                if (RequestSpecificValues.Current_Mode.My_Sobek_SubMode == "new")
                {
                    edit_usergroupid = -1;

                    // Check this admin's session for this RequestSpecificValues.Current_User object
                    Object sessionEditUser = HttpContext.Current.Session["Edit_UserGroup_" + edit_usergroupid];
                    if (sessionEditUser != null)
                        editGroup = (User_Group)sessionEditUser;
                    else
                        editGroup = new User_Group(String.Empty, String.Empty, -1);
                }
                else
                {

                    if (Int32.TryParse(RequestSpecificValues.Current_Mode.My_Sobek_SubMode.Replace("a", "").Replace("b", "").Replace("c", "").Replace("v", ""), out edit_usergroupid))
                    {
                        Object sessionEditUser = HttpContext.Current.Session["Edit_UserGroup_" + edit_usergroupid];
                        if (sessionEditUser != null)
                            editGroup = (User_Group) sessionEditUser;
                        else
                        {
                            editGroup = SobekCM_Database.Get_User_Group(edit_usergroupid, RequestSpecificValues.Tracer);
                            editGroup.Should_Be_Able_To_Edit_All_Items = false;
                            bool canEditAll = (editGroup.Editable_Regular_Expressions != null) && (editGroup.Editable_Regular_Expressions.Any(ThisRegularExpression => ThisRegularExpression == "[A-Z]{2}[A-Z|0-9]{4}[0-9]{4}"));
                            if (editGroup.Editable_Regular_Expressions != null)
                                canEditAll = editGroup.Editable_Regular_Expressions.Any(ThisRegularExpression => ThisRegularExpression == "[A-Z]{2}[A-Z|0-9]{4}[0-9]{4}");
                            if (canEditAll)
                                editGroup.Should_Be_Able_To_Edit_All_Items = true;
                        }
                    }
                }
            }

            // Determine the mode
            mode = Users_Group_Admin_Mode_Enum.Error;
            if ((editGroup != null) || (edit_usergroupid == -1))
            {
                if ((RequestSpecificValues.Current_Mode.My_Sobek_SubMode.IndexOf("v") > 0) && (edit_usergroupid > 0))
                    mode = Users_Group_Admin_Mode_Enum.View_User_Group;
                else
                    mode = Users_Group_Admin_Mode_Enum.Edit_User_Group;
            }
            else
            {
                RequestSpecificValues.Current_Mode.My_Sobek_SubMode = String.Empty;
                RequestSpecificValues.Current_Mode.Admin_Type = Admin_Type_Enum.Users;
                UrlWriterHelper.Redirect(RequestSpecificValues.Current_Mode);
                return;
            }

            // Perform post back work
            if (RequestSpecificValues.Current_Mode.isPostBack)
            {
                if ((mode == Users_Group_Admin_Mode_Enum.Edit_User_Group) && (editGroup != null))
                {
                    // Determine which page you are on
                    int page = 1;
                    if (RequestSpecificValues.Current_Mode.My_Sobek_SubMode.IndexOf("b") > 0)
                        page = 2;
                    else if (RequestSpecificValues.Current_Mode.My_Sobek_SubMode.IndexOf("c") > 0)
                        page = 3;

                    // Get a reference to this form
                    NameValueCollection form = HttpContext.Current.Request.Form;
                    string[] getKeys = form.AllKeys;

                    // Get the curret action
                    string action = form["admin_user_group_save"];

                    // If this is CANCEL, get rid of the currrent edit object in the session
                    if (action == "cancel")
                    {
                        // Clear the RequestSpecificValues.Current_User from the sessions
                        HttpContext.Current.Session["Edit_UserGroup_" + editGroup.UserGroupID] = null;

                        // Redirect the RequestSpecificValues.Current_User
                        RequestSpecificValues.Current_Mode.My_Sobek_SubMode = String.Empty;
                        UrlWriterHelper.Redirect(RequestSpecificValues.Current_Mode);
                        return;
                    }

                    bool successful_save = true;
                    switch (page)
                    {
                        case 1:
                            if ( editGroup.Templates_Count > 0 ) editGroup.Templates.Clear();
                            if ( editGroup.Default_Metadata_Sets_Count > 0 ) editGroup.Default_Metadata_Sets.Clear();

                            // First, set some flags to FALSE
                            editGroup.CanSubmit = false;
                            editGroup.IsInternalUser = false;
                            editGroup.Should_Be_Able_To_Edit_All_Items = false;
                            editGroup.IsPortalAdmin = false;
                            editGroup.IsSystemAdmin = false;

                            // Step through each key
                            foreach (string thisKey in getKeys)
                            {
                                switch (thisKey)
                                {
                                    case "groupName":
                                        editGroup.Name = form[thisKey].Trim();
                                        break;

                                    case "groupDescription":
                                        editGroup.Description = form[thisKey].Trim();
                                        break;

                                    case "admin_user_submit":
                                        editGroup.CanSubmit = true;
                                        break;

                                    case "admin_user_internal":
                                        editGroup.IsInternalUser = true;
                                        break;

                                    case "admin_user_editall":
                                        editGroup.Should_Be_Able_To_Edit_All_Items = true;
                                        break;

                                    case "admin_user_admin":
                                        editGroup.IsSystemAdmin = true;
                                        break;

                                    case "admin_user_portaladmin":
                                        editGroup.IsPortalAdmin = true;
                                        break;

                                    default:
                                        if (thisKey.IndexOf("admin_user_template_") == 0)
                                        {
                                            editGroup.Add_Template(thisKey.Replace("admin_user_template_", ""));
                                        }
                                        if (thisKey.IndexOf("admin_user_project_") == 0)
                                        {
                                            editGroup.Add_Default_Metadata_Set(thisKey.Replace("admin_user_project_", ""));
                                        }
                                        break;
                                }
                            }
                            break;

                        case 2:
                            Dictionary<string, User_Permissioned_Aggregation> aggregations = new Dictionary<string, User_Permissioned_Aggregation>();

                            // Step through each key
                            foreach (string thisKey in getKeys)
                            {

                                if (thisKey.IndexOf("admin_project_onhome_") == 0)
                                {
                                    string select_project = thisKey.Replace("admin_project_onhome_", "");
                                    if (aggregations.ContainsKey(select_project))
                                    {
                                        aggregations[select_project].OnHomePage = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(select_project, new User_Permissioned_Aggregation(select_project, String.Empty, false, false, false, true, false));
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_select_") == 0)
                                {
                                    string select_project = thisKey.Replace("admin_project_select_", "");
                                    if (aggregations.ContainsKey(select_project))
                                    {
                                        aggregations[select_project].CanSelect = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(select_project, new User_Permissioned_Aggregation(select_project, String.Empty, true, false, false, false, false));
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_editall_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_editall_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanEditItems = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(edit_project, new User_Permissioned_Aggregation(edit_project, String.Empty, false, true, false, false, false));
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_edit_metadata_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_edit_metadata_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanEditMetadata = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false)
                                        {
                                            CanEditMetadata = true
                                        };
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_edit_behavior_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_edit_behavior_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanEditBehaviors = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false)
                                        {
                                            CanEditBehaviors = true
                                        };
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_perform_qc_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_perform_qc_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanPerformQc = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false)
                                        {
                                            CanPerformQc = true
                                        };
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_upload_files_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_upload_files_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanUploadFiles = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false)
                                        {
                                            CanUploadFiles = true
                                        };
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_change_visibility_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_change_visibility_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanChangeVisibility = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false)
                                        {
                                            CanChangeVisibility = true
                                        };
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_can_delete_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_can_delete_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanDelete = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false)
                                        {
                                            CanDelete = true
                                        };
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_curator_") == 0)
                                {
                                    string admin_project = thisKey.Replace("admin_project_curator_", "");
                                    if (aggregations.ContainsKey(admin_project))
                                    {
                                        aggregations[admin_project].IsCurator = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(admin_project, new User_Permissioned_Aggregation(admin_project, String.Empty, false, false, true, false, false));
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_admin_") == 0)
                                {
                                    string admin_project = thisKey.Replace("admin_project_admin_", "");
                                    if (aggregations.ContainsKey(admin_project))
                                    {
                                        aggregations[admin_project].IsAdmin = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(admin_project, new User_Permissioned_Aggregation(admin_project, String.Empty, false, false, false, false, true));
                                    }
                                }
                            }

                            // Copy to the object now
                            if ( editGroup.Aggregations != null ) editGroup.Aggregations.Clear();
                            foreach (User_Permissioned_Aggregation thisPermissionsAggregation in aggregations.Values)
                                editGroup.Add_Aggregation(thisPermissionsAggregation);
                            break;
                    }

                    // Should this be saved to the database?
                    if (action == "save")
                    {
                        // Must have a name to continue
                        if (editGroup.Name.Length > 0)
                        {
                            // Update the basic user information
                            int newid = SobekCM_Database.Save_User_Group(editGroup.UserGroupID, editGroup.Name, editGroup.Description, editGroup.CanSubmit, editGroup.IsInternalUser, editGroup.Should_Be_Able_To_Edit_All_Items, editGroup.IsSystemAdmin, editGroup.IsPortalAdmin, false, true, true, false, editGroup.IsSobekDefault, editGroup.IsShibbolethDefault, editGroup.IsLdapDefault, RequestSpecificValues.Tracer);
                            if (editGroup.UserGroupID < 0)
                            {
                                editGroup.UserGroupID = newid;
                            }

                            if (editGroup.UserGroupID > 0)
                            {
                                // Update projects, if necessary
                                if (editGroup.Default_Metadata_Sets_Count > 0)
                                {
                                    if (!SobekCM_Database.Update_SobekCM_User_Group_DefaultMetadata(editGroup.UserGroupID, editGroup.Default_Metadata_Sets, RequestSpecificValues.Tracer))
                                    {
                                        successful_save = false;
                                    }
                                }

                                // Update templates, if necessary
                                if (editGroup.Templates_Count > 0)
                                {
                                    if (!SobekCM_Database.Update_SobekCM_User_Group_Templates(editGroup.UserGroupID, editGroup.Templates, RequestSpecificValues.Tracer))
                                    {
                                        successful_save = false;
                                    }
                                }
                            }
                            // Update the aggregationPermissions, if requested
                            if (editGroup.Aggregations_Count > 0)
                            {
                                List<User_Permissioned_Aggregation> aggregationList = editGroup.Aggregations;
                                if (!SobekCM_Database.Update_SobekCM_User_Group_Aggregations(editGroup.UserGroupID, aggregationList, RequestSpecificValues.Tracer))
                                {
                                    successful_save = false;
                                }
                            }
                        }
                        else
                        {
                            actionMessage = "User group's name must have a length greater than zero";
                            successful_save = false;
                        }

                        // Forward back to the list of users, if this was successful
                        if (successful_save)
                        {
                            // Clear the RequestSpecificValues.Current_User from the sessions
                            HttpContext.Current.Session["Edit_UserGroup_" + editGroup.UserGroupID] = null;

                            RequestSpecificValues.Current_Mode.My_Sobek_SubMode = String.Empty;
                            UrlWriterHelper.Redirect(RequestSpecificValues.Current_Mode);
                        }
                    }
                    else
                    {
                        // Save to the admins session
                        HttpContext.Current.Session["Edit_UserGroup_" + editGroup.UserGroupID] = editGroup;
                        RequestSpecificValues.Current_Mode.My_Sobek_SubMode = action;
                        UrlWriterHelper.Redirect(RequestSpecificValues.Current_Mode);
                    }
                }
            }
        }
        /// <summary> Constructor for a new instance of the Users_AdminViewer class </summary>
        /// <param name="RequestSpecificValues"> All the necessary, non-global data specific to the current request </param>
        /// <remarks> Postback from a RequestSpecificValues.Current_User edit or from reseting a RequestSpecificValues.Current_User's password is handled here in the constructor </remarks>
        public Users_AdminViewer(RequestCache RequestSpecificValues)
            : base(RequestSpecificValues)
        {
            RequestSpecificValues.Tracer.Add_Trace("Users_AdminViewer.Constructor", String.Empty);

            // Ensure the user is the system admin
            if ((RequestSpecificValues.Current_User == null) || (!RequestSpecificValues.Current_User.Is_System_Admin))
            {
                RequestSpecificValues.Current_Mode.Mode = Display_Mode_Enum.My_Sobek;
                RequestSpecificValues.Current_Mode.My_Sobek_Type = My_Sobek_Type_Enum.Home;
                UrlWriterHelper.Redirect(RequestSpecificValues.Current_Mode);
                return;
            }

            // Set the action message to clear initially
            actionMessage = String.Empty;

            // Get the user to edit, if there was a user id in the submode
            editUser = null;
            if ( !String.IsNullOrEmpty(RequestSpecificValues.Current_Mode.My_Sobek_SubMode))
            {
                try
                {
                    int edit_userid = Convert.ToInt32(RequestSpecificValues.Current_Mode.My_Sobek_SubMode.Replace("a", "").Replace("b", "").Replace("c", "").Replace("v", ""));

                    // Check this admin's session for this RequestSpecificValues.Current_User object
                    Object sessionEditUser = HttpContext.Current.Session["Edit_User_" + edit_userid];
                    if (sessionEditUser != null)
                        editUser = (User_Object)sessionEditUser;
                    else
                    {
                        editUser = SobekCM_Database.Get_User(edit_userid, RequestSpecificValues.Tracer);
                        editUser.Should_Be_Able_To_Edit_All_Items = false;
                        if (editUser.Editable_Regular_Expressions.Any(ThisRegularExpression => ThisRegularExpression == "[A-Z]{2}[A-Z|0-9]{4}[0-9]{4}"))
                        {
                            editUser.Should_Be_Able_To_Edit_All_Items = true;
                        }
                    }
                }
                catch (Exception)
                {
                    actionMessage = "Error while handing your request";
                }
            }

            // Determine the mode
            mode = Users_Admin_Mode_Enum.List_Users_And_Groups;
            if (editUser != null)
            {
                mode = RequestSpecificValues.Current_Mode.My_Sobek_SubMode.IndexOf("v") > 0 ? Users_Admin_Mode_Enum.View_User : Users_Admin_Mode_Enum.Edit_User;
            }
            else
            {
                RequestSpecificValues.Current_Mode.My_Sobek_SubMode = String.Empty;
            }

            // Perform post back work
            if (RequestSpecificValues.Current_Mode.isPostBack)
            {
                if (mode == Users_Admin_Mode_Enum.List_Users_And_Groups)
                {
                    try
                    {
                        string reset_value = HttpContext.Current.Request.Form["admin_user_reset"];
                        if (reset_value.Length > 0)
                        {
                            int userid = Convert.ToInt32(reset_value);
                            User_Object reset_user = SobekCM_Database.Get_User(userid, RequestSpecificValues.Tracer);

                            // Create the random password
                            StringBuilder passwordBuilder = new StringBuilder();
                            Random randomGenerator = new Random(DateTime.Now.Millisecond);
                            while (passwordBuilder.Length < 12)
                            {
                                switch (randomGenerator.Next(0, 3))
                                {
                                    case 0:
                                        int randomNumber = randomGenerator.Next(65, 91);
                                        if ((randomNumber != 79) && (randomNumber != 75)) // Omit the 'O' and the 'K', confusing
                                            passwordBuilder.Append((char)randomNumber);
                                        break;

                                    case 1:
                                        int randomNumber2 = randomGenerator.Next(97, 123);
                                        if ((randomNumber2 != 111) && (randomNumber2 != 108) && (randomNumber2 != 107))  // Omit the 'o' and the 'l' and the 'k', confusing
                                            passwordBuilder.Append((char)randomNumber2);
                                        break;

                                    case 2:
                                        // Zero and one is omitted in this range, confusing
                                        int randomNumber3 = randomGenerator.Next(50, 58);
                                        passwordBuilder.Append((char)randomNumber3);
                                        break;
                                }
                            }
                            string password = passwordBuilder.ToString();

                            // Reset this password
                            if (!SobekCM_Database.Reset_User_Password(userid, password, true, RequestSpecificValues.Tracer))
                            {
                                actionMessage = "ERROR reseting password";
                            }
                            else
                            {
                                if ( Email_Helper.SendEmail(reset_user.Email, "my" + RequestSpecificValues.Current_Mode.Instance_Abbreviation.ToUpper() + " Password Reset", reset_user.Full_Name + ",\n\nYour my" + RequestSpecificValues.Current_Mode.Instance_Abbreviation.ToUpper() + " password has been reset to a temporary password.  The first time you logon, you will be required to change it.\n\n\tUsername: "******"\n\tPassword: "******"\n\nYour password is case-sensitive and must be entered exactly as it appears above when logging on.\n\nIf you have any questions or problems logging on, feel free to contact us at " + UI_ApplicationCache_Gateway.Settings.Email.System_Email + ", or reply to this email.\n\n" + RequestSpecificValues.Current_Mode.Base_URL + "my/home\n", false, RequestSpecificValues.Current_Mode.Instance_Name))
                                {
                                    if ((RequestSpecificValues.Current_User.UserID == 1) || (RequestSpecificValues.Current_User.UserID == 2))
                                        actionMessage = "Reset of password (" + password + ") for '" + reset_user.Full_Name + "' complete";
                                    else
                                        actionMessage = "Reset of password for '" + reset_user.Full_Name + "' complete";
                                }
                                else
                                {
                                    if ((RequestSpecificValues.Current_User.UserID == 1) || (RequestSpecificValues.Current_User.UserID == 2))
                                        actionMessage = "ERROR while sending new password (" + password + ") to '" + reset_user.Full_Name + "'!";
                                    else
                                        actionMessage = "ERROR while sending new password to '" + reset_user.Full_Name + "'!";
                                }
                            }
                        }

                        string delete_value = HttpContext.Current.Request.Form["admin_user_group_delete"];
                        if (delete_value.Length > 0)
                        {
                            int deleteId = Convert.ToInt32(delete_value);
                            int result = SobekCM_Database.Delete_User_Group(deleteId, null);
                            switch (result)
                            {
                                case 1:
                                    actionMessage = "Succesfully deleted user group";
                                    break;

                                case -1:
                                    actionMessage = "ERROR while deleting user group - Cannot delete a user group which is still linked to users";
                                    break;

                                case -2:
                                    actionMessage = "ERROR - You cannot delete a special user group";
                                    break;

                                case -3:
                                    actionMessage = "ERROR while deleting user group - unknown exception caught";
                                    break;

                            }
                            return;
                        }
                    }
                    catch
                    {
                        actionMessage = "ERROR while checking postback";
                    }
                }

                if ((mode == Users_Admin_Mode_Enum.Edit_User) && (editUser != null))
                {
                    // Determine which page you are on
                    int page = 1;
                    if (RequestSpecificValues.Current_Mode.My_Sobek_SubMode.IndexOf("b") > 0)
                        page = 2;
                    else if (RequestSpecificValues.Current_Mode.My_Sobek_SubMode.IndexOf("c") > 0)
                        page = 3;

                    // Get a reference to this form
                    NameValueCollection form = HttpContext.Current.Request.Form;
                    string[] getKeys = form.AllKeys;

                    // Get the curret action
                    string action = form["admin_user_save"];

                    // If this is CANCEL, get rid of the currrent edit object in the session
                    if (action == "cancel")
                    {
                        // Clear the RequestSpecificValues.Current_User from the sessions
                        HttpContext.Current.Session["Edit_User_" + editUser.UserID] = null;

                        // Redirect the RequestSpecificValues.Current_User
                        RequestSpecificValues.Current_Mode.My_Sobek_SubMode = String.Empty;
                        UrlWriterHelper.Redirect(RequestSpecificValues.Current_Mode);
                        return;
                    }

                    bool successful_save = true;
                    switch (page)
                    {
                        case 1:
                            string editTemplate = "Standard";
                            List<string> projects = new List<string>();
                            List<string> templates = new List<string>();

                            // First, set some flags to FALSE
                            editUser.Can_Submit = false;
                            editUser.Is_Internal_User = false;
                            editUser.Should_Be_Able_To_Edit_All_Items = false;
                            editUser.Is_System_Admin = false;
                            editUser.Is_Portal_Admin = false;
                            editUser.Include_Tracking_In_Standard_Forms = false;
                            editUser.Can_Delete_All = false;

                            if ((UI_ApplicationCache_Gateway.Settings.isHosted) && (RequestSpecificValues.Current_User.Is_Host_Admin))
                            {
                                editUser.Is_Host_Admin = false;
                            }

                            // Step through each key
                            foreach (string thisKey in getKeys)
                            {
                                switch (thisKey)
                                {
                                    case "admin_user_submit":
                                        editUser.Can_Submit = true;
                                        break;

                                    case "admin_user_internal":
                                        editUser.Is_Internal_User = true;
                                        break;

                                    case "admin_user_editall":
                                        editUser.Should_Be_Able_To_Edit_All_Items = true;
                                        break;

                                    case "admin_user_deleteall":
                                        editUser.Can_Delete_All = true;
                                        break;

                                    case "admin_user_host":
                                        editUser.Is_Host_Admin = true;
                                        break;

                                    case "admin_user_sysadmin":
                                        editUser.Is_System_Admin = true;
                                        break;

                                    case "admin_user_portaladmin":
                                        editUser.Is_Portal_Admin = true;
                                        break;

                                    case "admin_user_includetracking":
                                        editUser.Include_Tracking_In_Standard_Forms = true;
                                        break;

                                    case "admin_user_edittemplate":
                                        editTemplate = form["admin_user_edittemplate"];
                                        break;

                                    case "admin_user_organization":
                                        editUser.Organization = form["admin_user_organization"];
                                        break;

                                    case "admin_user_college":
                                        editUser.College = form["admin_user_college"];
                                        break;

                                    case "admin_user_department":
                                        editUser.Department = form["admin_user_department"];
                                        break;

                                    case "admin_user_unit":
                                        editUser.Unit = form["admin_user_unit"];
                                        break;

                                    case "admin_user_org_code":
                                        editUser.Organization_Code = form["admin_user_org_code"];
                                        break;

                                    default:
                                        if (thisKey.IndexOf("admin_user_template_") == 0)
                                        {
                                            templates.Add(thisKey.Replace("admin_user_template_", ""));
                                        }
                                        if (thisKey.IndexOf("admin_user_project_") == 0)
                                        {
                                            projects.Add(thisKey.Replace("admin_user_project_", ""));
                                        }
                                        break;
                                }
                            }

                            // Determine the name for the actual edit templates from the combo box selection
                            editUser.Edit_Template_Code_Simple = "edit";
                            editUser.Edit_Template_Code_Complex = "editmarc";
                            if (editTemplate == "internal")
                            {
                                editUser.Edit_Template_Code_Simple = "edit_internal";
                                editUser.Edit_Template_Code_Complex = "editmarc_internal";
                            }

                            // Determine if the projects and templates need to be updated
                            bool update_templates_projects = false;
                            if ((templates.Count != editUser.Templates.Count) || (projects.Count != editUser.Default_Metadata_Sets.Count))
                            {
                                update_templates_projects = true;
                            }
                            else
                            {
                                // Check all of the templates
                                if (templates.Any(template => !editUser.Templates.Contains(template)))
                                {
                                    update_templates_projects = true;
                                }

                                // Check all the projects
                                if (!update_templates_projects)
                                {
                                    if (projects.Any(project => !editUser.Default_Metadata_Sets.Contains(project)))
                                    {
                                        update_templates_projects = true;
                                    }
                                }
                            }

                            // Update the templates and projects, if requested
                            if (update_templates_projects)
                            {
                                // Get the last defaults
                                string default_project = String.Empty;
                                string default_template = String.Empty;
                                if (editUser.Default_Metadata_Sets.Count > 0)
                                    default_project = editUser.Default_Metadata_Sets[0];
                                if (editUser.Templates.Count > 0)
                                    default_template = editUser.Templates[0];

                                // Now, set the RequestSpecificValues.Current_User's template and projects
                                editUser.Clear_Default_Metadata_Sets();
                                editUser.Clear_Templates();
                                foreach (string thisProject in projects)
                                {
                                    editUser.Add_Default_Metadata_Set(thisProject, false);
                                }
                                foreach (string thisTemplate in templates)
                                {
                                    editUser.Add_Template(thisTemplate, false);
                                }

                                // Try to add back the defaults, which won't do anything if
                                // the old defaults aren't in the new list
                                editUser.Set_Current_Default_Metadata(default_project);
                                editUser.Set_Default_Template(default_template);
                            }
                            break;

                        case 2:
                            // Check the RequestSpecificValues.Current_User groups for update
                            bool update_user_groups = false;
                            List<User_Group> userGroup = Engine_Database.Get_All_User_Groups(RequestSpecificValues.Tracer);
                            List<string> newGroups = new List<string>();
                            foreach (User_Group thisRow in userGroup)
                            {
                                if (form["group_" + thisRow.UserGroupID] != null)
                                {
                                    newGroups.Add(thisRow.Name);
                                }
                            }

                            // Should we add the new RequestSpecificValues.Current_User groups?  Did it change?
                            if (newGroups.Count != editUser.User_Groups.Count)
                            {
                                update_user_groups = true;
                            }
                            else
                            {
                                foreach (string thisGroup in newGroups)
                                {
                                    if (!editUser.User_Groups.Contains(thisGroup))
                                    {
                                        update_user_groups = true;
                                        break;
                                    }
                                }
                            }
                            if (update_user_groups)
                            {
                                editUser.Clear_UserGroup_Membership();
                                foreach (string thisUserGroup in newGroups)
                                    editUser.Add_User_Group(thisUserGroup);
                            }
                            break;

                        case 3:
                            Dictionary<string, User_Permissioned_Aggregation> aggregations = new Dictionary<string, User_Permissioned_Aggregation>();

                            // Step through each key
                            foreach (string thisKey in getKeys)
                            {
                                if (thisKey.IndexOf("admin_project_onhome_") == 0)
                                {
                                    string select_project = thisKey.Replace("admin_project_onhome_", "");
                                    if (aggregations.ContainsKey(select_project))
                                    {
                                        aggregations[select_project].OnHomePage = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(select_project, new User_Permissioned_Aggregation(select_project, String.Empty, false, false, false, true, false));
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_select_") == 0)
                                {
                                    string select_project = thisKey.Replace("admin_project_select_", "");
                                    if (aggregations.ContainsKey(select_project))
                                    {
                                        aggregations[select_project].CanSelect = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(select_project, new User_Permissioned_Aggregation(select_project, String.Empty, true, false, false, false, false));
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_editall_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_edit_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanEditItems = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(edit_project, new User_Permissioned_Aggregation(edit_project, String.Empty, false, true, false, false, false));
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_edit_metadata_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_edit_metadata_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanEditMetadata = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false) {CanEditMetadata = true};
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_edit_behavior_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_edit_behavior_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanEditBehaviors = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false) {CanEditBehaviors = true};
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_perform_qc_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_perform_qc_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanPerformQc = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false) {CanPerformQc = true};
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_upload_files_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_upload_files_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanUploadFiles = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false) {CanUploadFiles = true};
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_change_visibility_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_change_visibility_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanChangeVisibility = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false) {CanChangeVisibility = true};
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_can_delete_") == 0)
                                {
                                    string edit_project = thisKey.Replace("admin_project_can_delete_", "");
                                    if (aggregations.ContainsKey(edit_project))
                                    {
                                        aggregations[edit_project].CanDelete = true;
                                    }
                                    else
                                    {
                                        User_Permissioned_Aggregation thisAggrLink = new User_Permissioned_Aggregation(edit_project, String.Empty, false, false, false, false, false) {CanDelete = true};
                                        aggregations.Add(edit_project, thisAggrLink);
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_curator_") == 0)
                                {
                                    string admin_project = thisKey.Replace("admin_project_curator_", "");
                                    if (aggregations.ContainsKey(admin_project))
                                    {
                                        aggregations[admin_project].IsCurator = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(admin_project, new User_Permissioned_Aggregation(admin_project, String.Empty, false, false, true, false, false));
                                    }
                                }
                                if (thisKey.IndexOf("admin_project_admin_") == 0)
                                {
                                    string admin_project = thisKey.Replace("admin_project_admin_", "");
                                    if (aggregations.ContainsKey(admin_project))
                                    {
                                        aggregations[admin_project].IsAdmin = true;
                                    }
                                    else
                                    {
                                        aggregations.Add(admin_project, new User_Permissioned_Aggregation(admin_project, String.Empty, false, false, false, false, true));
                                    }
                                }
                            }

                            // Determine if the aggregationPermissions need to be edited
                            bool update_aggregations = false;
                            if (editUser.PermissionedAggregations == null || (aggregations.Count != editUser.PermissionedAggregations.Count))
                            {
                                update_aggregations = true;
                            }
                            else
                            {
                                // Build a dictionary of the RequestSpecificValues.Current_User aggregationPermissions as well
                                Dictionary<string, User_Permissioned_Aggregation> existingAggr = editUser.PermissionedAggregations.ToDictionary(ThisAggr => ThisAggr.Code);

                                // Check all the aggregationPermissions
                                foreach (User_Permissioned_Aggregation adminAggr in aggregations.Values)
                                {
                                    if (existingAggr.ContainsKey(adminAggr.Code))
                                    {
                                        if ((adminAggr.CanSelect != existingAggr[adminAggr.Code].CanSelect) || (adminAggr.CanEditMetadata != existingAggr[adminAggr.Code].CanEditMetadata) ||
                                            (adminAggr.CanEditBehaviors != existingAggr[adminAggr.Code].CanEditBehaviors) || (adminAggr.CanPerformQc != existingAggr[adminAggr.Code].CanPerformQc) ||
                                            (adminAggr.CanUploadFiles != existingAggr[adminAggr.Code].CanUploadFiles) || (adminAggr.CanChangeVisibility != existingAggr[adminAggr.Code].CanChangeVisibility) ||
                                            (adminAggr.CanDelete != existingAggr[adminAggr.Code].CanDelete) || (adminAggr.IsCurator != existingAggr[adminAggr.Code].IsCurator) ||
                                            (adminAggr.OnHomePage != existingAggr[adminAggr.Code].OnHomePage) || (adminAggr.IsAdmin != existingAggr[adminAggr.Code].IsAdmin))
                                        {
                                            update_aggregations = true;
                                            break;
                                        }
                                    }
                                    else
                                    {
                                        update_aggregations = true;
                                        break;
                                    }
                                }
                            }

                            // Update the aggregationPermissions, if requested
                            if (update_aggregations)
                            {
                                editUser.Clear_Aggregations();
                                if (aggregations.Count > 0)
                                {
                                    foreach (User_Permissioned_Aggregation dictionaryAggregation in aggregations.Values)
                                    {
                                        editUser.Add_Aggregation(dictionaryAggregation.Code, dictionaryAggregation.Name, dictionaryAggregation.CanSelect, dictionaryAggregation.CanEditMetadata, dictionaryAggregation.CanEditBehaviors, dictionaryAggregation.CanPerformQc, dictionaryAggregation.CanUploadFiles, dictionaryAggregation.CanChangeVisibility, dictionaryAggregation.CanDelete, dictionaryAggregation.IsCurator, dictionaryAggregation.OnHomePage, dictionaryAggregation.IsAdmin, false);
                                    }
                                }
                            }
                            break;
                    }

                    // Should this be saved to the database?
                    if (action == "save")
                    {
                        // Save this user
                        SobekCM_Database.Save_User(editUser, String.Empty, RequestSpecificValues.Current_User.Authentication_Type, RequestSpecificValues.Tracer);

                        // Update the basic user information
                        SobekCM_Database.Update_SobekCM_User(editUser.UserID, editUser.Can_Submit, editUser.Is_Internal_User, editUser.Should_Be_Able_To_Edit_All_Items, editUser.Can_Delete_All, editUser.Is_System_Admin, editUser.Is_Host_Admin, editUser.Is_Portal_Admin, editUser.Include_Tracking_In_Standard_Forms, editUser.Edit_Template_Code_Simple, editUser.Edit_Template_Code_Complex, true, true, true, RequestSpecificValues.Tracer);

                        // Update projects, if necessary
                        if (editUser.Default_Metadata_Sets.Count > 0)
                        {
                            if (!SobekCM_Database.Update_SobekCM_User_DefaultMetadata(editUser.UserID, editUser.Default_Metadata_Sets, RequestSpecificValues.Tracer))
                            {
                                successful_save = false;
                            }
                        }

                        // Update templates, if necessary
                        if (editUser.Templates_Count > 0)
                        {
                            if (!SobekCM_Database.Update_SobekCM_User_Templates(editUser.UserID, editUser.Templates, RequestSpecificValues.Tracer))
                            {
                                successful_save = false;
                            }
                        }

                        // Save the aggregationPermissions linked to this user
                        if (editUser.PermissionedAggregations_Count > 0)
                        {
                            if (!SobekCM_Database.Update_SobekCM_User_Aggregations(editUser.UserID, editUser.PermissionedAggregations, RequestSpecificValues.Tracer))
                            {
                                successful_save = false;
                            }
                        }

                        // Save the user group links
                        List<User_Group> userGroup = Engine_Database.Get_All_User_Groups(RequestSpecificValues.Tracer);
                        Dictionary<string, int> groupnames_to_id = new Dictionary<string, int>();
                        foreach (User_Group thisRow in userGroup)
                        {
                            groupnames_to_id[thisRow.Name] = Convert.ToInt32(thisRow.UserGroupID);
                        }
                        foreach (string userGroupName in editUser.User_Groups)
                        {
                            SobekCM_Database.Link_User_To_User_Group(editUser.UserID, groupnames_to_id[userGroupName]);
                        }

                        // Forward back to the list of users, if this was successful
                        if (successful_save)
                        {
                            // Clear the RequestSpecificValues.Current_User from the sessions
                            HttpContext.Current.Session["Edit_User_" + editUser.UserID] = null;

                            // Redirect the RequestSpecificValues.Current_User
                            RequestSpecificValues.Current_Mode.My_Sobek_SubMode = String.Empty;
                            UrlWriterHelper.Redirect(RequestSpecificValues.Current_Mode);
                        }
                    }
                    else
                    {
                        // Save to the admins session
                        HttpContext.Current.Session["Edit_User_" + editUser.UserID] = editUser;
                        RequestSpecificValues.Current_Mode.My_Sobek_SubMode = action;
                        UrlWriterHelper.Redirect(RequestSpecificValues.Current_Mode);
                    }
                }
            }
        }
        /// <summary> Adds a new aggregation to the list of aggregationPermissions linked here, with detailed permissions </summary>
        /// <param name="AggregationInfo"> Information about the detailed permissions for this user over an aggregation </param>
        public void Add(User_Permissioned_Aggregation AggregationInfo )
        {
            // If this was pre-existing, remove the old one from the list
            if ( code_to_aggregation.ContainsKey(AggregationInfo.Code.ToUpper()) )
            {
                if (Aggregations.Contains(AggregationInfo))
                    Aggregations.Remove(AggregationInfo);
            }

            if (Aggregations == null)
                Aggregations = new List<User_Permissioned_Aggregation>();

            Aggregations.Add(AggregationInfo);
            code_to_aggregation[AggregationInfo.Code.ToUpper()] = AggregationInfo;
        }
        /// <summary> Add a new item aggregation to this user group's collection of item aggregationPermissions </summary>
        /// <param name="PermissionedAggregation">Fully permissioned aggregation </param>
        public void Add_Aggregation(User_Permissioned_Aggregation PermissionedAggregation )
        {
            if (aggregations == null) aggregations = new User_Aggregation_Permissions();

            aggregations.Add(PermissionedAggregation);
        }