source: branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Controllers/UserController.cs @ 13742

using HeuristicLab.Clients.Access.Administration;
using HeuristicLab.Clients.Hive.WebJobManager.Services;
using HeuristicLab.Clients.Hive.WebJobManager.ViewModels.User;
using Microsoft.AspNet.Hosting;
using Microsoft.AspNet.Http;
using Microsoft.AspNet.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel.Security;
using System.Threading.Tasks;

namespace HeuristicLab.Clients.Hive.WebJobManager.Controllers
{
    public class UserController : Controller
    {
        private WebLoginService weblog;
        private HiveServiceLocatorWeb serviceLocator;
        private AccessAdministrationClient accessClient;
        private Guid userId;

        private IHostingEnvironment _environment;

        public UserController(IHostingEnvironment env)
        {
            weblog = WebLoginService.Instance;
            _environment = env;
        }
        private void init()
        {
            var u = HttpContext.Session.GetString("UserId");
            if (u == null || u == "" || Guid.Parse(u) == Guid.Empty)
            {
                userId = Guid.Empty;
                serviceLocator = new HiveServiceLocatorWeb();
            }
            else
            {
                userId = Guid.Parse(u);
                serviceLocator = weblog.getServiceLocator(userId);
                accessClient = weblog.getAccessAdminClient(userId);
            }
        }
        #region Users

        public IActionResult Index()
        {
            init();
            if (serviceLocator.CheckLogin())
            {

                ViewBag.Title = "Users";
                UserViewModel vm = new UserViewModel(accessClient).refreshUsers();
                ViewBag.SessionId = HttpContext.Session.GetString("UserId");
                return View("Index", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }

        public IActionResult SelectUser(string id)
        {
            init();
            if (serviceLocator.CheckLogin())
            {
                Guid curr = Guid.Parse(id);
                
                UserViewModel vm = new UserViewModel(accessClient).refreshUsers();
                if (curr == Guid.Empty)
                {
                    ViewBag.Title = "Add User";
                }
                else
                {
                    vm.SelectedUser = vm.getUserById(curr);
                    vm.SelectedUserSubscriptions = accessClient.getSubscribedGroups(curr);
                    ViewBag.title = vm.SelectedUser.UserName;
                }
                ViewBag.Title += " - Users";
                ViewBag.SessionId = HttpContext.Session.GetString("UserId");
                return View("Index", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        [HttpPost]
        public IActionResult saveUser(string inpusername, string inpfullname, string inpemail, string u)
        {
            init();
            var uid = Guid.Parse(u);
            Access.User user;
            if (uid == Guid.Empty)
                user = new Access.User();
            else
                user = accessClient.Users.Find(x => x.Id == uid);

            
            user.FullName = inpfullname;
            user.Email = inpemail;


            if (uid == Guid.Empty)
            {
                user.UserName = inpusername;
                uid = accessClient.addUser(user);
                ViewBag.Title = user.UserName + " added - User";
            }
            else
            {
                accessClient.updateUser(user);
                ViewBag.Title = user.UserName + " updated - User";
            }

            return RedirectToAction( "SelectUser", new {  id =  uid.ToString()});

        }
        public IActionResult deleteUser(string id)
        {
            init();
            var uid = Guid.Parse(id);
            UserViewModel vm = new UserViewModel(accessClient).refreshUsers();
            
            if (uid == Guid.Empty)
            {
                vm.message = "Something went wrong, user is not deleted";
                return View("Index", vm);
            }
            else
            {
                var user = vm.getUserById(uid);
                vm.message = user.UserName + " ("+user.FullName+") has been deleted";
                accessClient.DeleteUser(user);
                vm.refreshUsers();
                return View("Index", vm);
            }

        }

        #endregion

        #region Groups
        public IActionResult Groups()
        {
            init();
            if (serviceLocator.CheckLogin())
            {

                ViewBag.Title = "Groups";
                UserViewModel vm = new UserViewModel(accessClient).refreshGroups().refreshUsers();
                return View("Groups", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        public IActionResult SelectGroup(string id)
        {
            init();
            if (serviceLocator.CheckLogin())
            {
                Guid curr = Guid.Parse(id);

                UserViewModel vm = new UserViewModel(accessClient)
                    .refreshGroups()
                    .refreshUsers();
                if (curr == Guid.Empty)
                {
                    ViewBag.Title = "Add group";
                }
                else
                {
                    vm.SelectedGroup = vm.getGroupById(curr);
                    vm.SelectedGroupMembers = accessClient.getGroupMembers(curr);
                    ViewBag.title = vm.SelectedGroup.Name;
                }
                ViewBag.Title += " - Group";
                return View("Groups", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        [HttpPost]
        public IActionResult saveGroup(string inpgroupname, string u, string[] userstoadd, string[] groupstoadd)
        {
            init();
            var uid = Guid.Parse(u);
            var vm = new UserViewModel(accessClient).refreshGroups().refreshUsers();

            Access.UserGroup group;
            
            if (uid == Guid.Empty)
                group = new Access.UserGroup();
            else
                group = accessClient.Groups.Find(x => x.Id == uid);

            group.Name = inpgroupname;

            if (uid == Guid.Empty)
            {
                uid = accessClient.addGroup(group);
                ViewBag.Title = group.Name + " added - Group";
            }
            else
            {
                accessClient.updateGroup(group);
                ViewBag.Title = group.Name + " updated - Group";
            }
            vm.refreshGroups();
            group = vm.getGroupById(uid);
            foreach(var s in userstoadd)
            {
                var tempid = Guid.Parse(s);
                var member = vm.getUserById(tempid);
                accessClient.addMember(member, group);
            }
            foreach (var g in groupstoadd)
            {
                var tempid = Guid.Parse(g);
                var member = vm.getGroupById(tempid);
                accessClient.addMember(member, group);
            }

            return RedirectToAction("SelectGroup", new { id = uid.ToString() });

        }
        public IActionResult deleteGroup(string id)
        {
            init();
            var uid = Guid.Parse(id);
            UserViewModel vm = new UserViewModel(accessClient).refreshGroups();

            if (uid == Guid.Empty)
            {
                vm.message = "Something went wrong, group is not deleted";
                return View("Groups", vm);
            }
            else
            {
                var group = vm.getGroupById(uid);
                vm.message = group.Name + " has been deleted";
                accessClient.deleteUserGroup(group);
                vm.refreshGroups();
                return View("Groups", vm);
            }

        }
        public IActionResult deleteMember(string g, string m)
        {
            init();
            var gid = Guid.Parse(g);
            var mid = Guid.Parse(m);
            UserViewModel vm = new UserViewModel(accessClient).refreshGroups().refreshUsers() ;

            if (gid == Guid.Empty || mid == Guid.Empty)
            {
                vm.message = "Something went wrong, member is not deleted";
                return View("Groups", vm);
            }
            else
            {
                var group = vm.getGroupById(gid);
                Access.UserGroupBase member = vm.getUserById(mid);
                if(member == null)
                {
                    member = vm.getGroupById(mid);
                }
                vm.message = " Member deleted";
                accessClient.deleteMember(member,group);
                vm.refreshGroups();
                return RedirectToAction("SelectGroup", new { id = g });
            }

        }
        #endregion

        #region Roles
        public IActionResult Roles()
        {
            init();
            if (serviceLocator.CheckLogin())
            {

                ViewBag.Title = "Roles";
                // accessClient.RefreshUsers();

                return View("Roles");
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        #endregion
    }
}