FISLib_Old/Vinno.FIS.Sonopost/Managers/TerminalClientManager.cs

using FISLib;
using FISLib.Connect;
using System;
using Vinno.FIS.Sonopost.Features.Config;
using Vinno.FIS.Sonopost.Managers.Interfaces;
using Vinno.IUS.Common.Log;

namespace Vinno.FIS.Sonopost.Managers
{
    internal class TerminalClientManager : SonopostManager, ITerminalClientManager
    {
        private readonly IConfigManager _configManager;

        private FISServerInfo _serverInfo;

        private FISAccountInfo _accountInfo;

        private IConnectionService _fisConnectionService;

        private DeviceStatus _deviceStatus;

        private UltrasoundMachineInfo _ultrasoundMachineInfo;
        public bool IsLoginWithAccountAndPassword { get; private set; }

        public bool HasGetFasterServer { get; private set; }

        public string UniqueId { get; private set; } = string.Empty;

        public event EventHandler<DeviceStatus> LoginStatusChanged;

        public TerminalClientManager()
        {
            _configManager = AppManager.Instance.GetManager<IConfigManager>();
            var fisManager = AppManager.Instance.GetManager<IFISManager>();
            _fisConnectionService = fisManager.FISConnectionService;
            _fisConnectionService.FISDeviceStatusChanged += OnStatusChanged;
            _ultrasoundMachineInfo = fisManager.UltrasoundMachineInfo;
            HasGetFasterServer = false;
            IsLoginWithAccountAndPassword = SonopostUserDefinedSettings.Instance.ServerSetting.IsLoginWithAccountAndPassword;
        }

        public DeviceStatus Login(string name, string password, bool loginWithAccountAndPassword, string organizationName = null)
        {
            try
            {
                var host = _configManager.VCloudServerAddress;
                var port = _configManager.VCloudServerPort;
                IsLoginWithAccountAndPassword = loginWithAccountAndPassword;
                if (loginWithAccountAndPassword)
                {
                    _accountInfo = new FISAccountInfo(name, password, true);
                }
                else
                {
                    _accountInfo = new FISAccountInfo(name, password, false);
                }
                _serverInfo = new FISServerInfo(host, port);
                LoginStatusChanged?.Invoke(this, DeviceStatus.Logoning);
                var connectionInfo = new FISConnectionInfo(_serverInfo, _accountInfo, organizationName, new FISFeatureSettings
                {
                    AfterSalesEnabled = true,
                    LiveVideoEnabled = true,
                    RemedicalEnabled = true,
                    TeachingEnabled = false,
                });
                var loginResult = _fisConnectionService.Connect(connectionInfo, false, "", "");
                if (loginResult == null)
                {
                    loginResult = new FISDeviceStatusInfo
                    {
                        Status = DeviceStatus.LoginFailed,
                    };
                }
                OnStatusChanged(this, loginResult);
                _deviceStatus = loginResult.Status;
                UniqueId = loginResult.UniqueId;
                Logger.WriteLineWarn($"Login Result:{_deviceStatus}");
                return loginResult.Status;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Login Error:{ex}");
            }
            return DeviceStatus.LoginFailed;
        }

        public FISServerInfo GetFasterServerInfo()
        {
            try
            {
                var result = _fisConnectionService.GetFasterServer(true);
                if (result != null)
                {
                    HasGetFasterServer = true;
                }
                return result;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetFasterServerInfo Error:{ex}");
            }
            return null;
        }

        public bool LogOff()
        {
            try
            {
                UniqueId = string.Empty;
                _fisConnectionService.Disconnect();
                return true;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Logoff Error:{ex}");
            }
            return false;
        }

        public bool ChangeServer(string address, int port, string vCloudServerName)
        {
            try
            {
                _configManager.SwitchVCloudServer(address, port, vCloudServerName);
                ResetServerAddress($"{address}:{port}");
                return true;
            }
            catch
            {
                return false;
            }
        }

        private void ResetServerAddress(string serverAddress)
        {
            if (string.IsNullOrEmpty(serverAddress))
            {
                return;
            }

            var server = serverAddress.Split(':');
            if (server.Length == 2)
            {
                var host = server[0];
                var port = server[1];
                int.TryParse(port, out var portNumber);
                _serverInfo = new FISServerInfo(host, portNumber);
            }
        }

        private void OnStatusChanged(object sender, FISDeviceStatusInfo e)
        {
            _deviceStatus = e.Status;
            Logger.WriteLineInfo($"Login Status Changed:{e.Status},UniqueId:{e.UniqueId}");
            switch (e.Status)
            {
                case DeviceStatus.Logon:
                    UniqueId = e.UniqueId;
                    var organization = _fisConnectionService.GetOrganizationName();
                    if (organization != _ultrasoundMachineInfo.Organizataion)
                    {
                        _ultrasoundMachineInfo.Organizataion = organization;
                        FISIMPL.FISIMPL.SetUltrasoundMachineInfo(_ultrasoundMachineInfo);
                    }
                    LoginStatusChanged?.Invoke(this, _deviceStatus);
                    break;

                default:
                    UniqueId = string.Empty;
                    LoginStatusChanged?.Invoke(this, _deviceStatus);
                    break;
            }
        }

        public override void DoDispose()
        {
            try
            {
                if (_fisConnectionService != null)
                {
                    _fisConnectionService.FISDeviceStatusChanged -= OnStatusChanged;
                    _fisConnectionService = null;
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"TerminalClientManager DoDispose Error:{ex}");
            }
            base.DoDispose();
        }
    }
}