activerecordmembershipprovider.cs

来自「如果不使用IIS,请先运行 XSP.exe,待提示已侦听 8080端口后」· CS 代码 · 共 1,728 行 · 第 1/4 页

using System.Web.Security;
using System.Configuration.Provider;
using System.Collections.Specialized;
using System;
using System.Data;
using System.Data.Odbc;
using System.Configuration;
using System.Diagnostics;
using System.Web;
using System.Globalization;
using System.Security.Cryptography;
using System.Text;
using System.Web.Configuration;
using Castle.ActiveRecord;
using Castle.ActiveRecord.Framework;
using NHibernate.Expression;
using Castle.ActiveRecord.Queries;

/// <summary>
///使用ActiveRecord实现的成员管理提供程序
/// </summary>
public class ActiveRecordMemberShipProvider : MembershipProvider
{
    private int newPasswordLength = 6;
    private string eventSource = "DNNLiteMembershipProvider";
    private string eventLog = "Application";
    private string exceptionMessage = "发生了一个错误，请检查错误日志.";

    private static aspnet_Applications app = null;

    //
    // Used when determining encryption key values.
    //

    public ActiveRecordMemberShipProvider()
    {
        DNNLite.GlobalApplication.initActiveRecord();
    }

    private string  machineKey;

    //
    // If false, exceptions are thrown to the caller. If true,
    // exceptions are written to the event log.
    //

    private bool pWriteExceptionsToEventLog;

    public bool WriteExceptionsToEventLog
    {
        get { return pWriteExceptionsToEventLog; }
        set { pWriteExceptionsToEventLog = value; }
    }


    //
    // System.Configuration.Provider.ProviderBase.Initialize Method
    //

    public override void Initialize(string name, NameValueCollection config)
    {
        //
        // Initialize values from web.config.
        //

        if (config == null)
            throw new ArgumentNullException("config");

        if (name == null || name.Length == 0)
            name = "OdbcMembershipProvider";

        if (String.IsNullOrEmpty(config["description"]))
        {
            config.Remove("description");
            config.Add("description", "ActiveRecord Membership provider");
        }

        // Initialize the abstract base class.
        base.Initialize(name, config);

        pApplicationName = GetConfigValue(config["applicationName"],
                                        System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath);
        pMaxInvalidPasswordAttempts = Convert.ToInt32(GetConfigValue(config["maxInvalidPasswordAttempts"], "5"));
        pPasswordAttemptWindow = Convert.ToInt32(GetConfigValue(config["passwordAttemptWindow"], "10"));
        pMinRequiredNonAlphanumericCharacters = Convert.ToInt32(GetConfigValue(config["minRequiredNonAlphanumericCharacters"], "1"));
        pMinRequiredPasswordLength = Convert.ToInt32(GetConfigValue(config["minRequiredPasswordLength"], "7"));
        pPasswordStrengthRegularExpression = Convert.ToString(GetConfigValue(config["passwordStrengthRegularExpression"], ""));
        pEnablePasswordReset = Convert.ToBoolean(GetConfigValue(config["enablePasswordReset"], "true"));
        pEnablePasswordRetrieval = Convert.ToBoolean(GetConfigValue(config["enablePasswordRetrieval"], "true"));
        pRequiresQuestionAndAnswer = Convert.ToBoolean(GetConfigValue(config["requiresQuestionAndAnswer"], "false"));
        pRequiresUniqueEmail = Convert.ToBoolean(GetConfigValue(config["requiresUniqueEmail"], "true"));
        pWriteExceptionsToEventLog = Convert.ToBoolean(GetConfigValue(config["writeExceptionsToEventLog"], "true"));

        string temp_format = config["passwordFormat"];
        if (temp_format == null)
        {
            temp_format = "Hashed";
        }

        switch (temp_format)
        {
            case "Hashed":
                pPasswordFormat = MembershipPasswordFormat.Hashed;
                break;
            case "Encrypted":
                pPasswordFormat = MembershipPasswordFormat.Encrypted;
                break;
            case "Clear":
                pPasswordFormat = MembershipPasswordFormat.Clear;
                break;
            default:
                throw new ProviderException("Password format not supported.");
        }

        // Get encryption and decryption key information from the configuration.

        machineKey = ConfigurationManager.AppSettings["machinekey"];

        app = ActiveRecordMediator<aspnet_Applications>.FindFirst(
             new EqExpression("ApplicationName", pApplicationName)
            );
        if (app == null)
        {
            app = new aspnet_Applications();
            app.ApplicationName = pApplicationName;
            app.Description = Description;
            app.LoweredApplicationName = pApplicationName;
            ActiveRecordMediator<aspnet_Applications>.CreateAndFlush(app);
        }
    }


    //
    // A helper function to retrieve config values from the configuration file.
    //

    private string GetConfigValue(string configValue, string defaultValue)
    {
        if (String.IsNullOrEmpty(configValue))
            return defaultValue;

        return configValue;
    }


    //
    // System.Web.Security.MembershipProvider properties.
    //


    private string pApplicationName;
    private bool pEnablePasswordReset;
    private bool pEnablePasswordRetrieval;
    private bool pRequiresQuestionAndAnswer;
    private bool pRequiresUniqueEmail;
    private int pMaxInvalidPasswordAttempts;
    private int pPasswordAttemptWindow;
    private MembershipPasswordFormat pPasswordFormat;

    public override string ApplicationName
    {
        get { return pApplicationName; }
        set { pApplicationName = value; }
    }

    public override bool EnablePasswordReset
    {
        get { return pEnablePasswordReset; }
    }


    public override bool EnablePasswordRetrieval
    {
        get { return pEnablePasswordRetrieval; }
    }


    public override bool RequiresQuestionAndAnswer
    {
        get { return pRequiresQuestionAndAnswer; }
    }


    public override bool RequiresUniqueEmail
    {
        get { return pRequiresUniqueEmail; }
    }


    public override int MaxInvalidPasswordAttempts
    {
        get { return pMaxInvalidPasswordAttempts; }
    }


    public override int PasswordAttemptWindow
    {
        get { return pPasswordAttemptWindow; }
    }


    public override MembershipPasswordFormat PasswordFormat
    {
        get { return pPasswordFormat; }
    }

    private int pMinRequiredNonAlphanumericCharacters;

    public override int MinRequiredNonAlphanumericCharacters
    {
        get { return pMinRequiredNonAlphanumericCharacters; }
    }

    private int pMinRequiredPasswordLength;

    public override int MinRequiredPasswordLength
    {
        get { return pMinRequiredPasswordLength; }
    }

    private string pPasswordStrengthRegularExpression;

    public override string PasswordStrengthRegularExpression
    {
        get { return pPasswordStrengthRegularExpression; }
    }

    //
    // System.Web.Security.MembershipProvider methods.
    //

    //
    // MembershipProvider.ChangePassword
    //

    #region 私有方法

    private aspnet_Membership GetAspNetMemberShip(string username)
    {
        aspnet_Membership membership = ActiveRecordMediator<aspnet_Membership>.FindFirst(
               new EqExpression("UserName", username),
               new EqExpression("Application", app)
              );
        
        return membership;
    }

    private aspnet_Membership GetAspNetMemberShip(aspnet_Users user)
    {
        aspnet_Membership membership = ActiveRecordMediator<aspnet_Membership>.FindByPrimaryKey(
            user.UserId
            );
        return membership;
    }

    private aspnet_Users GetAspNetUser(string username)
    {
        aspnet_Users user = ActiveRecordMediator<aspnet_Users>.FindFirst(
               new EqExpression("UserName", username),
               new EqExpression("Application", app)
              );
        return user;
    }

    private MembershipUser GetUserFromAspMemberShip(aspnet_Membership membership)
    {

        MembershipUser u = new MembershipUser(this.Name,
                                              membership.UserName ,
                                               membership.UserId ,
                                              membership.Email ,
                                              membership.PasswordQuestion ,
                                              membership.Comment ,
                                              membership.IsApproved ,
                                              membership.IsLockedOut ,
                                              membership.CreateDate ,
                                              membership.LastLoginDate ,
                                              membership.LastActivityDate ,
                                              membership.LastPasswordChangedDate ,
                                              membership.LastLockoutDate );

        return u;
    }

    #endregion


    public override bool ChangePassword(string username, string oldPwd, string newPwd)
    {
        if (!ValidateUser(username, oldPwd))
            return false;

        if (newPwd.Length < MinRequiredPasswordLength)
        {
            throw new MembershipPasswordException();
        }

        ValidatePasswordEventArgs args =
          new ValidatePasswordEventArgs(username, newPwd, true);

        OnValidatingPassword(args);

        if (args.Cancel)
        {
            if (args.FailureInformation != null)
            {
                throw args.FailureInformation;
            }
            else
            {
                throw new MembershipPasswordException("取消修改密码 引发了一个新的密码检查异常.");
            }
        }
        
        aspnet_Membership membership = GetAspNetMemberShip(username);
        if (membership == null)
            return false;

        membership.Password = EncodePassword(newPwd);
        membership.LastPasswordChangedDate = DateTime.Now;

        ActiveRecordMediator<aspnet_Membership>.UpdateAndFlush(membership);
        return true;
        

    }



    //
    // MembershipProvider.ChangePasswordQuestionAndAnswer
    //

    public override bool ChangePasswordQuestionAndAnswer(string username,
                  string password,
                  string newPwdQuestion,
                  string newPwdAnswer)
    {
        if (!ValidateUser(username, password))
            return false;

        aspnet_Membership membership = GetAspNetMemberShip(username);
        if (membership == null)
            return false;

        membership.PasswordQuestion = newPwdQuestion;
        membership.PasswordAnswer = EncodePassword(newPwdAnswer);
        ActiveRecordMediator<aspnet_Membership>.UpdateAndFlush(membership);
        return true;

    }



    //
    // MembershipProvider.CreateUser
    //

    public override MembershipUser CreateUser(string username,
             string password,
             string email,
             string passwordQuestion,
             string passwordAnswer,
             bool isApproved,
             object providerUserKey,
             out MembershipCreateStatus status)
    {
        ValidatePasswordEventArgs args =
          new ValidatePasswordEventArgs(username, password, true);

        OnValidatingPassword(args);

        if (args.Cancel)
        {
            status = MembershipCreateStatus.InvalidPassword;
            return null;
        }

        if (password.Length < MinRequiredPasswordLength)
        {
            status = MembershipCreateStatus.InvalidPassword;
            return null;
        }

        if (RequiresUniqueEmail && GetUserNameByEmail(email) != "")
        {
            status = MembershipCreateStatus.DuplicateEmail;
            return null;
        }

        MembershipUser u = GetUser(username, false);

        if (u == null)
        {
            DateTime createDate = DateTime.Now;

            if (providerUserKey == null)
            {
                providerUserKey = Guid.NewGuid();
            }
            else
            {
                if (!(providerUserKey is Guid))
                {
                    status = MembershipCreateStatus.InvalidProviderUserKey;
                    return null;
                }
            }

            aspnet_Membership membership = new aspnet_Membership();
            aspnet_Users user = new aspnet_Users();

            membership.UserId = (Guid)providerUserKey;
            user.UserId = (Guid)providerUserKey;
            membership.Password = EncodePassword(password);
            membership.Email = email;
            membership.PasswordQuestion = passwordQuestion;
            membership.PasswordAnswer = EncodePassword( passwordAnswer);
            membership.IsApproved = isApproved;
            membership.Comment = "";
            membership.CreateDate = createDate;
            membership.LastPasswordChangedDate = createDate;
            user.LastActivityDate = createDate;
            membership.Application = app;
            user.Application = app;
            membership.IsLockedOut = false;
            membership.LastLockoutDate = createDate;
            membership.FailedPasswordAnswerAttemptCount = 0;
            membership.FailedPasswordAnswerAttemptWindowStart = createDate;
            membership.FailedPasswordAttemptCount = 0;
            membership.FailedPasswordAttemptWindowStart = createDate;