tbf/Users/Forms/LoginDlg.cs

///
/// Copyright (c) 2017-2018 Sensus Slovensko a.s.
///
using System;
using System.Windows.Forms;
using log4net;
using Common;
using GemCard;
using Users.Entities;
using Users.Resources;
using System.Drawing;

namespace Users.Forms
{
    /// <summary>
    /// Provides login dialog as well as user authorization using TBF.User.Authorize(...)
    /// (i.e. when DialogResult is OK, user was authorized).
    /// </summary>
    public partial class LoginDlg : Form
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(LoginDlg));

        ///  Public readonly
        public string UserName { get { return user; } }

        /// Private fields
        string user;
        string password;
        GID[] requiredGroupMembership;
		bool noDatabase;
        Color oriBackColor;

        /// Smart card support, card S/N is used as user.Tag
        GemCard.CardNative card;
        string smartCardReader;

		public Common.LoginMethod Method;
		public string VersionString;

        /// <summary>
        /// Constructor.
        /// </summary>
        public LoginDlg()
        {
            InitializeComponent();

            oriBackColor = BackColor;
        }

        /// <summary>
        /// Constructor with a predefined user.
        /// </summary>
        public LoginDlg(string predefinedUser)
            : this()
        {
            user = predefinedUser;
            userNameTextBox.Text = predefinedUser;
        }

		/// <summary>
		/// Constructor with 'no Database' flag.
		/// </summary>
		public LoginDlg(bool noDatabase)
			: this()
		{
			this.noDatabase = noDatabase;
		}

        /// <summary>
        /// Constructor when a specific group membership is required.
        /// </summary>
        public LoginDlg(GID[] requiredGroupMembership)
            : this()
        {
            this.requiredGroupMembership = requiredGroupMembership;
#if DEBUG
            user = "MHA";
            userNameTextBox.Text = "MHA";
            passwordTextBox.Text = "kremik";
#endif
        }

        /// <summary>
        /// Constructor with a predefined user when a specific group membership is required.
        /// </summary>
        public LoginDlg(string predefinedUser, GID[] requiredGroupMembership)
            : this()
        {
            user = predefinedUser;
            userNameTextBox.Text = predefinedUser;
            this.requiredGroupMembership = requiredGroupMembership;
        }

        private void LoginDlg_Load(object sender, EventArgs e)
        {
			Localize();
            
			if (user == null)
				userNameTextBox.Select();
            else
				passwordTextBox.Select();

			///
			/// Smart card reader detection
			///
            smartCardReader = null;             /// null = No smart card reader detected

#if TURA_IPERL || TURA_IPERL_NEW || TURA_SPECIAL
            try
            {
                card = new CardNative();

                /// Find NFC smart card reader
                string[] cardReaders = card.ListReaders();
                if (cardReaders != null)
                {
                    foreach (var crd in cardReaders)
                    {
                        log.WarnFormat("SMART card reader found: {0}", crd);
                    }

                    foreach (var crd in cardReaders)
                    {
                        if (crd.Contains("NFC"))
                        {
                            log.ErrorFormat("SMART card reader selected: {0}", crd);
                            smartCardReader = crd;  /// NFC smart card reader detected
                            break;
                        }
                    }
                }

                if (!string.IsNullOrEmpty(smartCardReader))
                {
                    /// Reader found, initialize NFC smart card reader

                    card.OnCardInserted += delegate(object sndr, CardInsertedEventArgs args)
                    {
                        if (InvokeRequired) { Invoke(new EventHandler<CardInsertedEventArgs>(OnCardInserted), sndr, args); }
                        else OnCardInserted(sndr, args);
                    };

                    card.OnCardRemoved += delegate(object sndr, CardRemovedEventArgs args)
                    {
                        if (InvokeRequired) { Invoke(new EventHandler<CardRemovedEventArgs>(OnCardRemoved), sndr, args); }
                        else OnCardRemoved(sndr, args);
                    };

                    card.StartCardEvents(smartCardReader);

                    Text += " (NFC)";
                }
            }
            catch (Exception)
            {
                smartCardReader = null;
            }
#endif
        }

		void Localize()
		{
			Text = Strings.User_Login + (string.IsNullOrEmpty(VersionString) ? "" : (" " + VersionString));
			aliasLabel.Text = GetAliasLabel();
			passwordLabel.Text = Strings.Password;
			okButton.Text = Strings.OkBtnText;
			cancelButton.Text = Strings.CancelBtnText;
		}

		string GetAliasLabel()
		{
			switch (Method)
			{
				default:
				case LoginMethod.UserName: return Strings.User_name;
				case LoginMethod.FullName: return Strings.Full_name;
				case LoginMethod.Number: return Strings.User_code;
			}
		}

        /// <summary>
        /// Try to authorize the user when OK clicked.
        /// </summary>
        private void okButton_Click(object sender, EventArgs e)
        {
            user = userNameTextBox.Text;
            password = passwordTextBox.Text;

			AuthorizedAs authorizedAs = AuthorizedAs.PowerUser;

			bool authorized = Entities.User.IsPowerUser(user, password);
			if (authorized)
			{
				Users.GlobalData.CurrentUser = new Users.Entities.User(user, 6, true);
			}

			if (!authorized && !noDatabase)
			{
				DBSettings[] dbs = new DBSettings[] { GlobalData.RemoteUsersDB, GlobalData.LocalUsersDB };
				authorizedAs = AuthorizedAs.RemoteUser;

				foreach (var db in dbs)
				{
                    try
                    {
                        switch (Method)
                        {
                            case LoginMethod.UserName:
                            default:
                                var usr1 = Users.Entities.User.LoadUserByName(user, db);
                                if (usr1 != null) { authorized = usr1.Authorize(user, password, requiredGroupMembership); }
                                break;

                            case LoginMethod.FullName:
                                var usr2 = Users.Entities.User.LoadUserByFullName(user, db);
                                if (usr2 != null) { authorized = usr2.AuthorizeFullName(user, password, requiredGroupMembership); }
                                if (authorized) { user = usr2.UserName; }
                                break;

                            case LoginMethod.Number:
                                int number;
                                if (!int.TryParse(user, out number)) break;
                                var usr3 = Users.Entities.User.LoadUserByNumber(number, db);
                                if (usr3 != null) { authorized = usr3.AuthorizeNumber(number, password, requiredGroupMembership); }
                                if (authorized) { user = usr3.UserName; }
                                break;
                        }
                    }
                    catch (Exception) { }

                    if (authorized) break;

					authorizedAs = AuthorizedAs.LocalUser;
				}
			}

			if (authorized)
			{
				Users.GlobalData.AuthorizedAs = authorizedAs;
				DialogResult = DialogResult.OK;
				Close();
				return;
			}

            MessageBox.Show(Strings.Invalid_username_or_password, Strings.Error, MessageBoxButtons.OK);
            DialogResult = DialogResult.None;
            return;
        }

        /// <summary>
        /// Cancel clicked, do not try to authorize.
        /// </summary>
        private void cancelButton_Click(object sender, EventArgs e)
        {
            if (requiredGroupMembership == null)
            {
                Entities.User.Unauthorize();
            }

            DialogResult = DialogResult.Cancel;
            Close();
            return;
        }

		private void aliasLabel_Click(object sender, EventArgs e)
		{
			if (++Method == LoginMethod.Count) Method = 0;

			aliasLabel.Text = GetAliasLabel();
		}

        private void userNameTextBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (Convert.ToInt32(e.KeyChar) == 13)
            {
                passwordTextBox.Focus();
            }
        }

        private void passwordTextBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (Convert.ToInt32(e.KeyChar) == 13)
            {
                okButton_Click(sender, e);
            }
        }


        void OnCardInserted(object sender, CardInsertedEventArgs args)
        {
            string tag = string.Empty;

            try
            {
                BackColor = Color.Green;
                card.Connect(smartCardReader, SHARE.Shared, PROTOCOL.T0orT1);

                /// Read the serial number of the card
                APDUResponse response = card.Transmit(new APDUCommand(0xFF, 0xCA, 0x00, 0x00, null, 7));
                tag = response.ToString();

                card.Disconnect(DISCONNECT.Leave);
            }
            catch
            {
                tag = string.Empty;
            }

            DBSettings[] dbs = new DBSettings[] { GlobalData.RemoteUsersDB, GlobalData.LocalUsersDB };
            bool authorized = false;
            AuthorizedAs authorizedAs = AuthorizedAs.RemoteUser;
            ///
            foreach (var db in dbs)
            {
                try
                {
                    Users.Entities.User loadedUser = Users.Entities.User.LoadUserByTag(tag, db);
                    if (loadedUser != null)
                    {
                        authorized = loadedUser.AuthorizeTag(tag, requiredGroupMembership);

                        if (authorized)
                        {
                            user = loadedUser.UserName;
                            break;
                        }
                    }
                }
                catch (Exception) { }

                authorizedAs = AuthorizedAs.LocalUser;
            }

            if (authorized)
            {
                Users.GlobalData.AuthorizedAs = authorizedAs;
                DialogResult = DialogResult.OK;
                Close();
                return;
            }

            MessageBox.Show(Strings.Invalid_username_or_password, Strings.Error, MessageBoxButtons.OK);
            DialogResult = DialogResult.None;
            return;
        }


        void OnCardRemoved(object sender, CardRemovedEventArgs args)
        {
            BackColor = oriBackColor;
        }

        private void LoginDlg_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (!string.IsNullOrEmpty(smartCardReader))
            {
                try { card.StopCardEvents(); }
                catch { }
            }
        }
    }
}