Display_D_HP/TeamAAS-VM/ViewModels/User/CardLoginWindowViewModel.cs

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using OpenCvSharp;
using Prism.Commands;
using Prism.Events;
using Prism.Ioc;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using TeamAAS_VP.Core;
using TeamAAS_VP.Core.Lights;
using TeamAAS_VP.Data;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Events;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Resources.Languages;
using TeamAAS_VP.Views;
using TeamAAS_VP.Views.User;

namespace TeamAAS_VP.ViewModels.User
{
    public class CardLoginWindowViewModel : BindableBase
    {
        #region 字段
        IConfigService _configService;
        private readonly ISystemDatabaseService _systemDatabaseService;
        private List<TeamAAS_VP.Models.User> Users;
        #endregion

        #region 属性

        private ObservableCollection<string> _UserNameList = new ObservableCollection<string>();

        /// <summary>
        /// 用户列表
        /// </summary>
        public ObservableCollection<string> UserNameList
        {
            get { return _UserNameList; }
            set { _UserNameList = value; }
        }

        private string _SelectedUserName;
        public string SelectedUserName
        {
            get { return _SelectedUserName; }
            set { SetProperty(ref _SelectedUserName, value); }
        }

        private string _Password;
        public string Password
        {
            get { return _Password; }
            set { SetProperty(ref _Password, value); }
        }

        public bool IsRemember { get; set; }

        public bool IsLocal { get; private set; }
        public CardLoginWindow View { get; set; }

        //正在登录中
        private bool _IsLogining;
        public bool IsLogining
        {
            get { return _IsLogining; }
            set { SetProperty(ref _IsLogining, value); }
        }

        private int _PageIndex;
        public int PageIndex
        {
            get { return _PageIndex; }
            set { SetProperty(ref _PageIndex, value); }
        }

        private Visibility _CardBtnVisibility = Visibility.Visible;
        public Visibility CardBtnVisibility
        {
            get { return _CardBtnVisibility; }
            set { SetProperty(ref _CardBtnVisibility, value); }
        }

        public SerialPortProtocol serialPortProtocol { get; set; }
        #endregion

        #region 命令
        private DelegateCommand _LoginCommand;
        public DelegateCommand LoginCommand =>
            _LoginCommand ?? (_LoginCommand = new DelegateCommand(ExecuteLoginCommand, CanExecuteLoginCommand).ObservesProperty(() => SelectedUserName).ObservesProperty(() => Password).ObservesProperty(() => IsLogining));

        private DelegateCommand _CloseCommand;
        public DelegateCommand CloseCommand =>
            _CloseCommand ?? (_CloseCommand = new DelegateCommand(ExecuteCloseCommand));

        private DelegateCommand<string> _TransitionerCommand;
        public DelegateCommand<string> TransitionerCommand =>
            _TransitionerCommand ?? (_TransitionerCommand = new DelegateCommand<string>(ExecuteTransitionerCommand));

        private DelegateCommand _LoadedCommand;
        public DelegateCommand LoadedCommand =>
            _LoadedCommand ?? (_LoadedCommand = new DelegateCommand(ExecuteLoadedCommand));
        #endregion

        #region 事件

        #endregion

        public CardLoginWindowViewModel(IConfigService configService, ISystemDatabaseService systemDatabaseService)
        {
            _configService = configService;
            _systemDatabaseService = systemDatabaseService;
        }


        #region 方法
        /// <summary>
        /// 加载
        /// </summary>
        async void ExecuteLoadedCommand()
        {
            //获取刷卡器配置
            var cardConfig = _configService.GetCardReaderConfig();
            try
            {
                Users = _systemDatabaseService.GetAllUsersAsync().GetAwaiter().GetResult()?.ToList();
            }
            catch
            {
                Users = new List<TeamAAS_VP.Models.User>();
            }
            TeamAAS_VP.Models.User rememberUser = null;
            if (Users != null)
            {
                UserNameList.Clear();
                foreach (var user in Users)
                {
                    UserNameList.Add(user.UserName);
                    if (user.IsRemember)
                    {
                        rememberUser = user;
                    }
                }
            }

            //对记住的用户界面绑定
            if (rememberUser != null)
            {
                SelectedUserName = UserNameList.FirstOrDefault(p => p == rememberUser.UserName);
                Password = rememberUser.UserPassword;
                IsRemember = true;
            }

            //创建刷卡器通讯
            serialPortProtocol = new SerialPortProtocol(cardConfig);
            serialPortProtocol.DataReceived += CardSerial_DataReceived;
            bool isConnected = await serialPortProtocol.ConnectAsync();
            if (!isConnected)
            {
                MessageBox.Show("刷卡器连接失败，请检查连接！");
            }
        }

        private async void CardSerial_DataReceived(object sender, string code)
        {
            if (PageIndex == 0)
            {
                if (string.IsNullOrEmpty(code))
                {
                    return;
                }
                Models.User user = new Models.User();
                user.UserName = code;
                user.userPart = UserPart.Engineer;
                user.UserPassword = code; //刷卡密码默认为卡号
                user.CreateTime = DateTime.Now;
                user.Id = -1;

                await _systemDatabaseService.SetCurrentUserAsync(user);

                View.DialogResult = true;
            }
        }

        public async void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            if (serialPortProtocol!=null)
            {
                serialPortProtocol.DataReceived -= CardSerial_DataReceived;
            }
            await serialPortProtocol?.DisconnectAsync();
            
            serialPortProtocol?.Dispose();
            serialPortProtocol = null;
        }

        async void ExecuteLoginCommand()
        {
            if (Users == null || string.IsNullOrEmpty(SelectedUserName))
                return;

            IsLogining = true;
            try
            {
                if (_systemDatabaseService.GetCurrentUser() != null)
                {
                    if (_systemDatabaseService.GetCurrentUser().UserName == SelectedUserName)
                    {
                        View.DialogResult = true;
                        return;
                    }
                }

                // authenticate via system database service
                var user = await _systemDatabaseService.AuthenticateUserAsync(SelectedUserName, Password);
                if (user != null)
                {
                    // set remember flag via system database service
                    try
                    {
                        if (IsRemember)
                            await _systemDatabaseService.SetRememberUserAsync(SelectedUserName);
                        else
                            await _systemDatabaseService.ClearRememberUserAsync();
                    }
                    catch
                    {

                    }

                    // mark current user in system DB and record login
                    await _systemDatabaseService.SetCurrentUserAsync(user.Id);
                    await _systemDatabaseService.RecordUserLoginAsync(new UserLoginRecord { UserId = user.Id, Success = true, Time = DateTime.UtcNow, Message = "Login success" });
                    View.DialogResult = true;
                }

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                IsLogining = false;
            }
        }

        bool CanExecuteLoginCommand()
        {
            return !string.IsNullOrEmpty(SelectedUserName) && !IsLogining;
        }

        void ExecuteCloseCommand()
        {
            View.DialogResult = false;
        }

        void ExecuteTransitionerCommand(string parameter)
        {
            PageIndex = int.Parse(parameter);
        }

        public void SetModel(bool isAdmin)
        {
            PageIndex = isAdmin ? 1 : 0;
            CardBtnVisibility = isAdmin ? Visibility.Collapsed : Visibility.Visible;
        }
        #endregion
    }
}