aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Technician/TechItems/TextItem.cs
blob: 939809504b219e218544bc0f5fc8bc4670060365 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;
using Tango.SharedUI.Helpers;

namespace Tango.MachineStudio.Technician.TechItems
{
    [TechItem(25)]
    public class TextItem : TechItem
    {
        private String _text;
        public String Text
        {
            get { return _text; }
            set { _text = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MeterItem"/> class.
        /// </summary>
        public TextItem() : base()
        {
            Name = "Static Text";
            Description = "Static Text";
            Text = "Static Text";
            Image = ResourceHelper.GetImageFromResources("Images/text.png");
            Color = Colors.DodgerBlue;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="TextItem"/> class.
        /// </summary>
        /// <param name="obj">The object.</param>
        public TextItem(Object obj) : this()
        {

        }

        public override TechItem Clone()
        {
            TextItem cloned = base.Clone() as TextItem;
            cloned.Text = Text;
            return cloned;
        }
    }
}
t .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Authentication;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using Tango.BL;
using Tango.BL.Builders;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core;
using Tango.Core.DI;
using Tango.Core.ExtensionMethods;
using Tango.FSE.BL;
using Tango.FSE.BL.Web;
using Tango.FSE.Common;
using Tango.FSE.Common.Authentication;
using Tango.FSE.Common.FSEApplication;
using Tango.FSE.Common.Navigation;
using Tango.FSE.Common.Notifications;
using Tango.FSE.UI.ViewModels;
using Tango.FSE.Web.Messages;
using Tango.MachineService.Gateway;
using Tango.Settings;

namespace Tango.FSE.UI.Authentication
{
    /// <summary>
    /// Represents the default FSE authentication provider.
    /// </summary>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.FSE.Common.Authentication.IAuthenticationProvider" />
    public class DefaultAuthenticationProvider : ExtendedObject, IAuthenticationProvider
    {
        private const string WEB_DEBUG_ADDRESS = "http://localhost:1111";
        private Timer _tokenRefreshTimer;

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private IFSEApplicationManager ApplicationManager { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private INavigationManager NavigationManager { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private INotificationProvider NotificationProvider { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private FSEServicesContainer Services { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private FSEWebClient WebClient { get; set; }

        /// <summary>
        /// Occurs when the current logged-in user has changed.
        /// </summary>
        public event EventHandler<User> CurrentUserChanged;

        private User _currentUser;
        /// <summary>
        /// Gets the current logged-in user.
        /// </summary>
        public User CurrentUser
        {
            get { return _currentUser; }
            private set
            {
                _currentUser = value;
                RaisePropertyChangedAuto();
            }
        }

        /// <summary>
        /// Gets the current environment configuration.
        /// </summary>
        public EnvironmentConfiguration CurrentEnvironment { get; private set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultAuthenticationProvider"/> class.
        /// </summary>
        public DefaultAuthenticationProvider()
        {
            _tokenRefreshTimer = new Timer(TimeSpan.FromMinutes(30).TotalMilliseconds);
            _tokenRefreshTimer.Elapsed += OnRefreshTokenTimer;
            _tokenRefreshTimer.Stop();
        }

        /// <summary>
        /// Logins the specified email.
        /// </summary>
        /// <param name="email">The email.</param>
        /// <param name="password">The password.</param>
        /// <param name="environment">The environment.</param>
        /// <returns></returns>
        public Task<AuthenticationResult> Login(String email, String password, EnvironmentConfiguration environment, Action<String> onStatusChanged = null)
        {
            return Task.Factory.StartNew<AuthenticationResult>(() =>
            {
                _tokenRefreshTimer.Stop();

                LogManager.Log($"Authenticating user '{email}'...");

                onStatusChanged?.Invoke($"Authenticating user {email}...");

                var settings = SettingsManager.Default.GetOrCreate<FSESettings>();

                if (ApplicationManager.IsWebDebugMode)
                {
                    LogManager.Log($"Application is currently in web debug mode. Authenticating through '{WEB_DEBUG_ADDRESS}'.");
                    WebClient.Address = WEB_DEBUG_ADDRESS;
                }
                else
                {
                    LogManager.Log($"Authenticating through machine service at '{environment.MachineServiceAddress}'...");
                    WebClient.Address = environment.MachineServiceAddress;
                }

                var appVersion = ApplicationManager.Version.ToString();

                if (settings.ForceVersionUpdate)
                {
                    LogManager.Log("Application settings are set to force version update. Setting reported application version to '1.0.0.0'.");
                    appVersion = "1.0.0.0";
                }

                LoginResponse response = null;

                try
                {
                    onStatusChanged?.Invoke($"Contacting machine service at '{WebClient.Address}'...");

                    CurrentEnvironment = environment;

                    response = Services.AuthenticationService.Authenticate(new LoginRequest()
                    {

                        Email = email,
                        Password = password,
                        Version = appVersion,

                    }).Result;

                    LogManager.Log($"Authentication response received:\n{response.ToJsonString()}");

                    settings.Save();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error authenticating user.");
                    throw new AggregateException(new AuthenticationException("Error logging in to machine service."), ex);
                }

                if (settings.Environment == FSESettings.WorkingEnvironment.Remote)
                {
                    ObservablesContext.OverrideSettingsDataSource(response.DataSource);
                }

                if (response.PasswordChangeRequired)
                {
                    LogManager.Log("User password change required.");
                    Services.AuthenticationService.DropCachedResponse(email);
                    return new AuthenticationResult() { Response = response };
                }

                LogManager.Log("Retrieving full user details...");
                User user = Services.UsersService.GetUserFull(email.ToLower()).Result;

                if (user != null)
                {
                    LogManager.Log($"Current user is now: {user.Contact.FullName}.");
                }
                else
                {
                    throw LogManager.Log(new AuthenticationException("Login failed for some strange reason."));
                }

                if (!user.HasPermission(Tango.BL.Enumerations.Permissions.FSE_RunFSE))
                {
                    throw LogManager.Log(new AuthenticationException("You do not have the permissions to access Tango FSE."));
                }

                _tokenRefreshTimer.Start();

                CurrentUser = user;

                settings.Save();

                InvokeUI(() =>
                {
                    CurrentUserChanged?.Invoke(this, CurrentUser);
                });

                return new AuthenticationResult()
                {
                    Response = response,
                    User = CurrentUser,
                };
            });
        }

        /// <summary>
        /// Logs-out the current logged-in user.
        /// </summary>
        public async void LogOut()
        {
            LogManager.Log("Logging out current user...");

            using (NotificationProvider.PushTaskItem("Logging out..."))
            {
                await Task.Delay(1000);

                LogManager.Log($"Invoking {nameof(FSEViewModel.OnApplicationLogout)} on all FSE view models...");

                foreach (var vm in TangoIOC.Default.GetAllInstancesByBase<FSEViewModel>())
                {
                    try
                    {
                        if (!await vm.OnApplicationLogout())
                        {
                            return;
                        }
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, $"An error occurred on ApplicationLogOut on {vm.GetType().FullName}.");
                    }
                }

                await Task.Delay(1000);
            }

            LogManager.Log("Logging out current user.");
            CurrentUser = null;
            CurrentUserChanged?.Invoke(this, CurrentUser);

            LogManager.Log($"Navigating to {nameof(NavigationView.LoginView)}...");

            _tokenRefreshTimer.Stop();

            MemoryCacheManager.Default.ClearAll();

            await NavigationManager.NavigateWithObject<LoginViewVM.NavigationObject>(NavigationView.LoginView, new LoginViewVM.NavigationObject()
            {
                IsLoggingOut = true,
            }, false);
        }

        /// <summary>
        /// Throws an exception if the current user does not have the specified permission.
        /// </summary>
        /// <param name="permission">The permission.</param>
        /// <param name="message">Optional message.</param>
        /// <exception cref="AuthorizationException">
        /// </exception>
        public void ThrowIfNoPermission(Permissions permission, String message = null)
        {
            if (CurrentUser == null || !CurrentUser.HasPermission(permission))
            {
                if (message == null)
                {
                    throw new AuthorizationException();
                }
                else
                {
                    throw new AuthorizationException(message);
                }
            }
        }

        /// <summary>
        /// Changes the specified user password.
        /// </summary>
        /// <param name="email">The email.</param>
        /// <param name="oldPassword">The old password.</param>
        /// <param name="newPassword">The new password.</param>
        /// <returns></returns>
        public Task ChangePassword(string email, string oldPassword, string newPassword)
        {
            return Services.AuthenticationService.ChangePassword(email, oldPassword, newPassword);
        }

        private async void OnRefreshTokenTimer(object sender, ElapsedEventArgs e)
        {
            _tokenRefreshTimer.Stop();

            if (ObservablesContext.GetActualDataSource().Type == DataSourceType.AccessToken)
            {
                try
                {
                    LogManager.Log("Refreshing database access token...");
                    var response = await WebClient.RefreshToken(new RefreshTokenRequest());
                    ObservablesContext.UpdateAccessToken(response.AccessToken, response.Expiration);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred while trying to refresh the database access token.");
                }
            }

            _tokenRefreshTimer.Start();
        }
    }
}