membershipuserods.cs

通用权限管理平台

        /// <summary>
        /// returns all approved users by specified sort
        /// </summary>
        /// <param name="approvalStatus">if true, return approved users</param>
        /// <param name="sortData">description of sort</param>
        /// <returns>A List of type MembershipUserWrapper</returns>
        /// 
        [DataObjectMethod(DataObjectMethodType.Select, false)]
        static public List<MembershipUserWrapper> GetMembers(bool approvalStatus, string sortData)
        {
            if (approvalStatus == true)
            {
                return GetMembers(true, false, null, sortData, "all");
            }
            else
            {
                return GetMembers(false, true, null, sortData, "all");
            }
        }

        /// <summary>
        /// Return a collection of MembershipUserWrapper's based on criteria passed in as parameters
        /// </summary>
        /// <param name="returnAllApprovedUsers">returns all users with approval set to true</param>
        /// <param name="returnAllNotApproviedUsers">return all users with approval set to false</param>
        /// <param name="usernameToFind">return based on username (overrides approval above)</param>
        /// <param name="sortData">sort parameter</param>
        /// <returns>Returns a Collection of Users (as recommended by FxCop)</returns>
        /// 
        [DataObjectMethod(DataObjectMethodType.Select, false)]
        static public List<MembershipUserWrapper> GetMembers(bool returnAllApprovedUsers, bool returnAllNotApprovedUsers,
            string usernameToFind, string sortData, string searchType)
        {

            List<MembershipUserWrapper> memberList = new List<MembershipUserWrapper>();

            // See if we are looking for just one user
            if (usernameToFind != null)
            {
                MembershipUser mu;
                if (searchType == "E-Mail")
                {
                    usernameToFind = Membership.GetUserNameByEmail(usernameToFind);
                }

                mu = Membership.GetUser(usernameToFind);
                if (mu != null)
                {
                    MembershipUserWrapper md = new MembershipUserWrapper(mu);
                    memberList.Add(md);
                }
            }


            else
            {
                MembershipUserCollection muc = Membership.GetAllUsers();
                foreach (MembershipUser mu in muc)
                {
                    if ((returnAllApprovedUsers == true && mu.IsApproved == true) ||
                         (returnAllNotApprovedUsers == true && mu.IsApproved == false))
                    {
                        //————Wenzy Modify————
                        MembershipUserWrapper md = new MembershipUserWrapper(mu);
                        bool addUser = false;
                        //搜索用户,判断搜索条件
                        switch (searchType)
                        {
                            case "24hLogin":
                                if (mu.LastLoginDate > DateTime.Now.AddHours(-24))
                                {
                                    addUser = true;
                                }
                                break;

                            case "24hReg":
                                if (mu.CreationDate > DateTime.Now.AddHours(-24))
                                {
                                    addUser = true;
                                }
                                break;

                            case "isApproved":
                                if (mu.IsApproved)
                                {
                                    addUser = true;
                                }
                                break;
                            case "isNotApproved":
                                if (!mu.IsApproved)
                                {
                                    addUser = true;
                                }
                                break;

                            case "isLocked":
                                if (mu.IsLockedOut)
                                {
                                    addUser = true;
                                }
                                break;
                            case "isOnline":
                                if (mu.IsOnline)
                                {
                                    addUser = true;
                                }
                                break;
                            case "24hActive":
                                if (mu.LastActivityDate > DateTime.Now.AddHours(-24))
                                {
                                    addUser = true;
                                }
                                break;
                            case "24hChangePassword":
                                if (mu.LastPasswordChangedDate > DateTime.Now.AddHours(-24))
                                {
                                    addUser = true;
                                }
                                break;

                            default:
                                addUser = true;

                                break;
                        }
                        if (addUser) memberList.Add(md);
                        //————Wenzy Modify————

                    }
                }

                if (sortData == null)
                {
                    sortData = "UserName";
                }
                if (sortData.Length == 0)
                {
                    sortData = "UserName";
                }

                // Make a special version of sortData for the switch statement so that whether or not the
                // DESC is appended to the string sortData, it will switch on the base of that string.
                string sortDataBase = sortData; // init and assume there is not DESC appended to sortData
                string descString = " DESC";
                if (sortData.EndsWith(descString))
                {
                    sortDataBase = sortData.Substring(0, sortData.Length - descString.Length);
                }

                Comparison<MembershipUserWrapper> comparison = null;

                switch (sortDataBase)
                {
                    case "UserName":
                        comparison = new Comparison<MembershipUserWrapper>(
                            delegate(MembershipUserWrapper lhs, MembershipUserWrapper rhs)
                            {
                                return lhs.UserName.CompareTo(rhs.UserName);
                            }
                            );
                        break;
                    case "Email":
                        comparison = new Comparison<MembershipUserWrapper>(
                             delegate(MembershipUserWrapper lhs, MembershipUserWrapper rhs)
                             {
                                 if (lhs.Email == null | rhs.Email == null)
                                 {
                                     return 0;
                                 }
                                 else
                                 {
                                     return lhs.Email.CompareTo(rhs.Email);
                                 }
                             }
                             );
                        break;
                    case "CreationDate":
                        comparison = new Comparison<MembershipUserWrapper>(
                             delegate(MembershipUserWrapper lhs, MembershipUserWrapper rhs)
                             {
                                 return lhs.CreationDate.CompareTo(rhs.CreationDate);
                             }
                             );
                        break;
                    case "IsApproved":
                        comparison = new Comparison<MembershipUserWrapper>(
                             delegate(MembershipUserWrapper lhs, MembershipUserWrapper rhs)
                             {
                                 return lhs.IsApproved.CompareTo(rhs.IsApproved);
                             }
                             );
                        break;
                    case "IsOnline":
                        comparison = new Comparison<MembershipUserWrapper>(
                             delegate(MembershipUserWrapper lhs, MembershipUserWrapper rhs)
                             {
                                 return lhs.IsOnline.CompareTo(rhs.IsOnline);
                             }
                             );
                        break;
                    case "LastLoginDate":
                        comparison = new Comparison<MembershipUserWrapper>(
                             delegate(MembershipUserWrapper lhs, MembershipUserWrapper rhs)
                             {
                                 return lhs.LastLoginDate.CompareTo(rhs.LastLoginDate);
                             }
                             );
                        break;
                    default:
                        comparison = new Comparison<MembershipUserWrapper>(
                             delegate(MembershipUserWrapper lhs, MembershipUserWrapper rhs)
                             {
                                 return lhs.UserName.CompareTo(rhs.UserName);
                             }
                             );
                        break;
                }

                if (sortData.EndsWith("DESC"))
                {
                    memberList.Sort(comparison);
                    memberList.Reverse();
                }
                else
                {
                    memberList.Sort(comparison);
                }

            }

            // FxCopy will give us a warning about returning a List rather than a Collection.
            // We could copy the data, but not worth the trouble.
            return memberList;

        }
    }
}