source: branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/WebLoginService.cs @ 13847

using HeuristicLab.Clients.Access.Administration;
using HeuristicLab.Clients.Hive.WebJobManager.Models;
using HeuristicLab.Clients.Hive.WebJobManager.ViewModels;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace HeuristicLab.Clients.Hive.WebJobManager.Services
{
    /// <summary>
    /// A service that will handle all the logins and will serve as a singleton that controls
    /// all the necessary Services used by Hive. (HiveServiceLocatorWeb and HiveClientWeb instances per user). 
    /// Users are identified with a seperate Guid made by the web version to ensure login security.
    /// </summary>
    public class WebLoginService
    {
        private static WebLoginService instance;
        private List<LoginViewModel> loggedIn;
        private List<HiveServiceLocatorWeb> locators;
        private List<HiveClientWeb> webclients;
        private List<FileOpeningService> jobopeners;
        private List<FileOpeningService> fileopeners;
        private List<AccessAdministrationClient> accessclients;
        private List<HiveAdminClientWeb> adminclients;
        private List<HiveWebUser> loggedinUsers;
        /// <summary>
        /// Service instance that keeps all the information per user seperated. Data is in  different lists so 
        /// only the necessary things can be called. 
        /// </summary>
        public static WebLoginService Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new WebLoginService();
                }
                return instance;
            }
        }
        /// <summary>
        /// Initialize the LoginService
        /// </summary>
        public WebLoginService()
        {

            loggedIn = new List<LoginViewModel>();
            locators = new List<HiveServiceLocatorWeb>();
            webclients = new List<HiveClientWeb>();
            jobopeners = new List<FileOpeningService>();
            fileopeners = new List<FileOpeningService>();
            accessclients = new List<AccessAdministrationClient>();
            adminclients = new List<HiveAdminClientWeb>();
            loggedinUsers = new List<HiveWebUser>();
        }
        /// <summary>
        /// Creates a new entry for a user. Services will be kept running here untill the user logs out or times out. 
        /// </summary>
        /// <param name="log">LoginViewModel from new user</param>
        /// <param name="loc">HiveServiceLocatorWeb created during login</param>
        public void newLogin(LoginViewModel log, HiveServiceLocatorWeb loc)
        {
            destroyPossiblePreviousSessions(log.loginName);
            var ind = loggedIn.Find(x => x.loginName == log.loginName);
            if (ind != null)
            {
                logout(ind.userId);
            }
            loggedIn.Add(log);
            locators.Add(loc);
            webclients.Add(new HiveClientWeb(loc, log.userId));
            fileopeners.Add(new FileOpeningService(log.userId));
            jobopeners.Add(new FileOpeningService(log.userId));
            accessclients.Add(new AccessAdministrationClient(log.userId));
            adminclients.Add(new HiveAdminClientWeb(log.userId));
            loggedinUsers.Add(new HiveWebUser(log.userId, log.loginName).updateUserInfo());
        }
        /// <summary>
        /// Checks if the client has a previous session stored. Destroys all info of that session
        /// </summary>
        /// <param name="client">Client login name</param>
        private void destroyPossiblePreviousSessions(string client)
        {
            var ind = loggedIn.FindAll(x => x.loginName == client);
            foreach (var i in ind)
            {
                logout(i.userId);
            }

        }
        /// <summary>
        /// Returns the service locator for a user
        /// </summary>
        /// <param name="id">User id</param>
        /// <returns></returns>
        public HiveServiceLocatorWeb getServiceLocator(Guid id)
        {
            return locators.Find(x => x.UserId == id);
        }
        /// <summary>
        /// Returns HiveClientWeb for a user
        /// </summary>
        /// <param name="id">User id</param>
        /// <returns></returns>
        public HiveClientWeb getClientWeb(Guid id)
        {
            return webclients.Find(x => x.UserId == id);
        }
        /// <summary>
        /// Returns the LoginViewModel for a user
        /// </summary>
        /// <param name="id">User id</param>
        /// <returns></returns>
        public LoginViewModel getLoginViewModel(Guid id)
        {
            return loggedIn.Find(x => x.userId == id);
        }
        /// <summary>
        /// Returns the FileOpenerService for the user
        /// </summary>
        /// <param name="id">User id</param>
        /// <returns></returns>
        public FileOpeningService getFileOpener(Guid id)
        {
            return fileopeners.Find(x => x.UserId == id);
        }

        public FileOpeningService getJobOpener(Guid id)
        {
            return jobopeners.Find(x => x.UserId == id);
        }
        /// <summary>
        /// Returns the AccessAdministrationClient used for User/Group/Role management 
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public AccessAdministrationClient getAccessAdminClient(Guid id)
        {
            return accessclients.Find(x => x.userId == id);
        }
        /// <summary>
        /// Returns HiveAdminClient used for Resource management
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public HiveAdminClientWeb getAdminClient(Guid id)
        {
            return adminclients.Find(x => x.userId == id);
        }
        public HiveWebUser getCurrentUser(Guid id)
        {
            return loggedinUsers.Find(x => x.webIdToken == id);
        }
        /// <summary>
        /// Removes all traces from the logged in user.
        /// </summary>
        /// <param name="id">User id</param>
        public void logout(Guid id)
        {
            
            webclients.RemoveAll(x => x.UserId == id);
            locators.RemoveAll(x => x.UserId == id);
            fileopeners.RemoveAll(x => x.UserId == id);
            jobopeners.RemoveAll(x => x.UserId == id);
            accessclients.RemoveAll(x => x.userId == id);
            adminclients.RemoveAll(x => x.userId == id);
            loggedIn.RemoveAll(x => x.userId == id);
            loggedinUsers.RemoveAll(x => x.webIdToken == id);
        }
    }
}