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

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 bool init()
        {
            var u = HttpContext.Session.GetString("UserId");
            if (u == null || u == "" || Guid.Parse(u) == Guid.Empty)
            {
                return false;
            }
            else
            {
                userId = Guid.Parse(u);
                serviceLocator = weblog.getServiceLocator(userId);
                accessClient = weblog.getAccessAdminClient(userId);
                return serviceLocator.CheckLogin();
                 
            }
        }
        #region Users

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

        public IActionResult SelectUser(string id)
        {
            ;
            if (init())
            {
                Guid curr = Guid.Parse(id);

                UserViewModel vm = new UserViewModel(accessClient).refreshAll();
                if (curr == Guid.Empty)
                {
                    ViewBag.Title = "Add User";
                }
                else
                {
                    vm.SelectedUser = vm.getUserById(curr);
                    vm.SelectedUserSubscriptions = accessClient.getSubscribedGroups(curr);
                    vm.SelectedUserRoles = accessClient.getRoles(vm.SelectedUser);
                    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, string[] rolestoadd, string[] groupstoadd)
        {

            if (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";
                }
                accessClient.RefreshUsers();
                user = accessClient.Users.Find(x => x.Id == uid);
                foreach (var s in rolestoadd)
                {
                    var role = accessClient.Roles.Find(x => x.Name == s);

                    accessClient.addRoleToUser(user, role);
                }
                accessClient.RefreshUserGroups();
                foreach(var g in groupstoadd)
                {
                    var gid = Guid.Parse(g);
                    var group = accessClient.Groups.Find(x => x.Id == gid);
                    accessClient.addMember(user, group);
                }
                return RedirectToAction("SelectUser", new { id = uid.ToString() });
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }

        }
        public IActionResult deleteUser(string id)
        {
            if (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.refreshAll();
                    ViewBag.Title = "Users";
                    return View("Index", vm);
                }
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }

        }

        public IActionResult deleteUserRole(string id, string role)
        {
            if (init())
            {
                var uid = Guid.Parse(id);
                UserViewModel vm = new UserViewModel(accessClient).refreshAll();

                var user = vm.getUserById(uid);
                var r = vm.getRoleByName(role);
                accessClient.deleteUserRole(user, r);
                return RedirectToAction("SelectUser", new { id = id });
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        public IActionResult deleteUserGroup(string id, string group)
        {
            if (init())
            {
                var gid = Guid.Parse(group);
                var mid = Guid.Parse(id);
                UserViewModel vm = new UserViewModel(accessClient).refreshGroups().refreshUsers();

                var user = vm.getUserById(mid);
                var gr = vm.getGroupById(gid);
                accessClient.deleteMember(user, gr);
                return RedirectToAction("SelectUser", new { id = id});
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }

        }
        #endregion

        #region Groups
        public IActionResult Groups()
        {
            if (init())
            {

                ViewBag.Title = "Groups";
                UserViewModel vm = new UserViewModel(accessClient).refreshGroups().refreshUsers();
                return View("Groups", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        public IActionResult SelectGroup(string id)
        {
            if (init())
            {
                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)
        {
            if (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() });
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        public IActionResult deleteGroup(string id)
        {
            if (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);
                }
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }

        }
        public IActionResult deleteMember(string g, string m)
        {
            if (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 });
                }
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }

        }
        #endregion

        #region Roles
        public IActionResult Roles()
        {
            if (init())
            {

                ViewBag.Title = "Roles";
                UserViewModel vm = new UserViewModel(accessClient).refreshRoles();

                return View("Roles", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        public IActionResult SelectRole(string name)
        {
            if (init())
            {

                UserViewModel vm = new UserViewModel(accessClient).refreshRoles();
                if (name == "" || name == null)
                {
                    ViewBag.Title = "Add Role";
                }
                else
                {
                    vm.SelectedRole = vm.getRoleByName(name);
                    vm.SelectedRoleEnrolled = accessClient.getEnrolled(vm.SelectedRole);

                    ViewBag.title = vm.SelectedRole.Name;
                }
                ViewBag.Title += " - Roles";
                return View("Roles", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        [HttpPost]
        public IActionResult saveRole(string inprolename)
        {
            if (init())
            {
                Access.Role role = accessClient.Roles.Find(x => x.Name == inprolename);
                if (role == null)
                {
                    role = new Access.Role();
                    role.Name = inprolename;
                    accessClient.addRole(role);
                }

                accessClient.RefreshRoles();
                return RedirectToAction("SelectRole", new { name = inprolename });
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        public IActionResult deleteRole(string name)
        {
            if (init())
            {
                accessClient.deleteRole(name);
                return RedirectToAction("Roles");
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        public IActionResult deleteRoleUser(string id, string role)
        {
            if (init())
            {
                var uid = Guid.Parse(id);
                UserViewModel vm = new UserViewModel(accessClient).refreshAll();

                var user = vm.getUserById(uid);
                var r = vm.getRoleByName(role);
                vm.message = role + " role has been deleted from " + user.FullName;
                accessClient.deleteUserRole(user, r);
                return RedirectToAction("SelectRole", new { name = role });
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        #endregion
    }
}