Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
04/12/16 15:28:19 (8 years ago)
Author:
jlodewyc
Message:

#2582 User management done, start resource calendar

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Controllers/UserController.cs

    r13742 r13754  
    2727            _environment = env;
    2828        }
    29         private void init()
     29        private bool init()
    3030        {
    3131            var u = HttpContext.Session.GetString("UserId");
    3232            if (u == null || u == "" || Guid.Parse(u) == Guid.Empty)
    3333            {
    34                 userId = Guid.Empty;
    35                 serviceLocator = new HiveServiceLocatorWeb();
     34                return false;
    3635            }
    3736            else
    … …  
    4039                serviceLocator = weblog.getServiceLocator(userId);
    4140                accessClient = weblog.getAccessAdminClient(userId);
     41                return serviceLocator.CheckLogin();
     42                 
    4243            }
    4344        }
    … …  
    4647        public IActionResult Index()
    4748        {
    48             init();
    49             if (serviceLocator.CheckLogin())
    50             {
    51 
     49            if (init())
     50            {
    5251                ViewBag.Title = "Users";
    53                 UserViewModel vm = new UserViewModel(accessClient).refreshUsers();
     52                UserViewModel vm = new UserViewModel(accessClient).refreshAll() ;
    5453                ViewBag.SessionId = HttpContext.Session.GetString("UserId");
    5554                return View("Index", vm);
    … …  
    6362        public IActionResult SelectUser(string id)
    6463        {
    65             init();
    66             if (serviceLocator.CheckLogin())
     64            ;
     65            if (init())
    6766            {
    6867                Guid curr = Guid.Parse(id);
    69                
    70                 UserViewModel vm = new UserViewModel(accessClient).refreshUsers();
     68
     69                UserViewModel vm = new UserViewModel(accessClient).refreshAll();
    7170                if (curr == Guid.Empty)
    7271                {
    … …  
    7776                    vm.SelectedUser = vm.getUserById(curr);
    7877                    vm.SelectedUserSubscriptions = accessClient.getSubscribedGroups(curr);
     78                    vm.SelectedUserRoles = accessClient.getRoles(vm.SelectedUser);
    7979                    ViewBag.title = vm.SelectedUser.UserName;
    8080                }
    … …  
    8989        }
    9090        [HttpPost]
    91         public IActionResult saveUser(string inpusername, string inpfullname, string inpemail, string u)
    92         {
    93             init();
    94             var uid = Guid.Parse(u);
    95             Access.User user;
    96             if (uid == Guid.Empty)
    97                 user = new Access.User();
    98             else
     91        public IActionResult saveUser(string inpusername, string inpfullname, string inpemail, string u, string[] rolestoadd, string[] groupstoadd)
     92        {
     93
     94            if (init())
     95            {
     96                var uid = Guid.Parse(u);
     97                Access.User user;
     98                if (uid == Guid.Empty)
     99                    user = new Access.User();
     100                else
     101                    user = accessClient.Users.Find(x => x.Id == uid);
     102
     103
     104                user.FullName = inpfullname;
     105                user.Email = inpemail;
     106
     107
     108                if (uid == Guid.Empty)
     109                {
     110                    user.UserName = inpusername;
     111                    uid = accessClient.addUser(user);
     112                    ViewBag.Title = user.UserName + " added - User";
     113                }
     114                else
     115                {
     116                    accessClient.updateUser(user);
     117                    ViewBag.Title = user.UserName + " updated - User";
     118                }
     119                accessClient.RefreshUsers();
    99120                user = accessClient.Users.Find(x => x.Id == uid);
    100 
    101            
    102             user.FullName = inpfullname;
    103             user.Email = inpemail;
    104 
    105 
    106             if (uid == Guid.Empty)
    107             {
    108                 user.UserName = inpusername;
    109                 uid = accessClient.addUser(user);
    110                 ViewBag.Title = user.UserName + " added - User";
    111             }
    112             else
    113             {
    114                 accessClient.updateUser(user);
    115                 ViewBag.Title = user.UserName + " updated - User";
    116             }
    117 
    118             return RedirectToAction( "SelectUser", new {  id =  uid.ToString()});
     121                foreach (var s in rolestoadd)
     122                {
     123                    var role = accessClient.Roles.Find(x => x.Name == s);
     124
     125                    accessClient.addRoleToUser(user, role);
     126                }
     127                accessClient.RefreshUserGroups();
     128                foreach(var g in groupstoadd)
     129                {
     130                    var gid = Guid.Parse(g);
     131                    var group = accessClient.Groups.Find(x => x.Id == gid);
     132                    accessClient.addMember(user, group);
     133                }
     134                return RedirectToAction("SelectUser", new { id = uid.ToString() });
     135            }
     136            else
     137            {
     138                return RedirectToAction("Index", "Home");
     139            }
    119140
    120141        }
    121142        public IActionResult deleteUser(string id)
    122143        {
    123             init();
    124             var uid = Guid.Parse(id);
    125             UserViewModel vm = new UserViewModel(accessClient).refreshUsers();
    126            
    127             if (uid == Guid.Empty)
    128             {
    129                 vm.message = "Something went wrong, user is not deleted";
    130                 return View("Index", vm);
    131             }
    132             else
    133             {
     144            if (init())
     145            {
     146                var uid = Guid.Parse(id);
     147                UserViewModel vm = new UserViewModel(accessClient).refreshUsers();
     148
     149                if (uid == Guid.Empty)
     150                {
     151                    vm.message = "Something went wrong, user is not deleted";
     152                    return View("Index", vm);
     153                }
     154                else
     155                {
     156                    var user = vm.getUserById(uid);
     157                    vm.message = user.UserName + " (" + user.FullName + ") has been deleted";
     158                    accessClient.DeleteUser(user);
     159                    vm.refreshAll();
     160                    ViewBag.Title = "Users";
     161                    return View("Index", vm);
     162                }
     163            }
     164            else
     165            {
     166                return RedirectToAction("Index", "Home");
     167            }
     168
     169        }
     170
     171        public IActionResult deleteUserRole(string id, string role)
     172        {
     173            if (init())
     174            {
     175                var uid = Guid.Parse(id);
     176                UserViewModel vm = new UserViewModel(accessClient).refreshAll();
     177
    134178                var user = vm.getUserById(uid);
    135                 vm.message = user.UserName + " ("+user.FullName+") has been deleted";
    136                 accessClient.DeleteUser(user);
    137                 vm.refreshUsers();
    138                 return View("Index", vm);
    139             }
    140 
    141         }
    142 
     179                var r = vm.getRoleByName(role);
     180                accessClient.deleteUserRole(user, r);
     181                return RedirectToAction("SelectUser", new { id = id });
     182            }
     183            else
     184            {
     185                return RedirectToAction("Index", "Home");
     186            }
     187        }
     188        public IActionResult deleteUserGroup(string id, string group)
     189        {
     190            if (init())
     191            {
     192                var gid = Guid.Parse(group);
     193                var mid = Guid.Parse(id);
     194                UserViewModel vm = new UserViewModel(accessClient).refreshGroups().refreshUsers();
     195
     196                var user = vm.getUserById(mid);
     197                var gr = vm.getGroupById(gid);
     198                accessClient.deleteMember(user, gr);
     199                return RedirectToAction("SelectUser", new { id = id});
     200            }
     201            else
     202            {
     203                return RedirectToAction("Index", "Home");
     204            }
     205
     206        }
    143207        #endregion
    144208
    … …  
    146210        public IActionResult Groups()
    147211        {
    148             init();
    149             if (serviceLocator.CheckLogin())
     212            if (init())
    150213            {
    151214
    … …  
    161224        public IActionResult SelectGroup(string id)
    162225        {
    163             init();
    164             if (serviceLocator.CheckLogin())
     226            if (init())
    165227            {
    166228                Guid curr = Guid.Parse(id);
    … …  
    190252        public IActionResult saveGroup(string inpgroupname, string u, string[] userstoadd, string[] groupstoadd)
    191253        {
    192             init();
    193             var uid = Guid.Parse(u);
    194             var vm = new UserViewModel(accessClient).refreshGroups().refreshUsers();
    195 
    196             Access.UserGroup group;
    197            
    198             if (uid == Guid.Empty)
    199                 group = new Access.UserGroup();
    200             else
    201                 group = accessClient.Groups.Find(x => x.Id == uid);
    202 
    203             group.Name = inpgroupname;
    204 
    205             if (uid == Guid.Empty)
    206             {
    207                 uid = accessClient.addGroup(group);
    208                 ViewBag.Title = group.Name + " added - Group";
    209             }
    210             else
    211             {
    212                 accessClient.updateGroup(group);
    213                 ViewBag.Title = group.Name + " updated - Group";
    214             }
    215             vm.refreshGroups();
    216             group = vm.getGroupById(uid);
    217             foreach(var s in userstoadd)
    218             {
    219                 var tempid = Guid.Parse(s);
    220                 var member = vm.getUserById(tempid);
    221                 accessClient.addMember(member, group);
    222             }
    223             foreach (var g in groupstoadd)
    224             {
    225                 var tempid = Guid.Parse(g);
    226                 var member = vm.getGroupById(tempid);
    227                 accessClient.addMember(member, group);
    228             }
    229 
    230             return RedirectToAction("SelectGroup", new { id = uid.ToString() });
    231 
     254            if (init())
     255            {
     256                var uid = Guid.Parse(u);
     257                var vm = new UserViewModel(accessClient).refreshGroups().refreshUsers();
     258
     259                Access.UserGroup group;
     260
     261                if (uid == Guid.Empty)
     262                    group = new Access.UserGroup();
     263                else
     264                    group = accessClient.Groups.Find(x => x.Id == uid);
     265
     266                group.Name = inpgroupname;
     267
     268                if (uid == Guid.Empty)
     269                {
     270                    uid = accessClient.addGroup(group);
     271                    ViewBag.Title = group.Name + " added - Group";
     272                }
     273                else
     274                {
     275                    accessClient.updateGroup(group);
     276                    ViewBag.Title = group.Name + " updated - Group";
     277                }
     278                vm.refreshGroups();
     279                group = vm.getGroupById(uid);
     280                foreach (var s in userstoadd)
     281                {
     282                    var tempid = Guid.Parse(s);
     283                    var member = vm.getUserById(tempid);
     284                    accessClient.addMember(member, group);
     285                }
     286                foreach (var g in groupstoadd)
     287                {
     288                    var tempid = Guid.Parse(g);
     289                    var member = vm.getGroupById(tempid);
     290                    accessClient.addMember(member, group);
     291                }
     292
     293                return RedirectToAction("SelectGroup", new { id = uid.ToString() });
     294            }
     295            else
     296            {
     297                return RedirectToAction("Index", "Home");
     298            }
    232299        }
    233300        public IActionResult deleteGroup(string id)
    234301        {
    235             init();
    236             var uid = Guid.Parse(id);
    237             UserViewModel vm = new UserViewModel(accessClient).refreshGroups();
    238 
    239             if (uid == Guid.Empty)
    240             {
    241                 vm.message = "Something went wrong, group is not deleted";
    242                 return View("Groups", vm);
    243             }
    244             else
    245             {
    246                 var group = vm.getGroupById(uid);
    247                 vm.message = group.Name + " has been deleted";
    248                 accessClient.deleteUserGroup(group);
    249                 vm.refreshGroups();
    250                 return View("Groups", vm);
     302            if (init())
     303            {
     304                var uid = Guid.Parse(id);
     305                UserViewModel vm = new UserViewModel(accessClient).refreshGroups();
     306
     307                if (uid == Guid.Empty)
     308                {
     309                    vm.message = "Something went wrong, group is not deleted";
     310                    return View("Groups", vm);
     311                }
     312                else
     313                {
     314                    var group = vm.getGroupById(uid);
     315                    vm.message = group.Name + " has been deleted";
     316                    accessClient.deleteUserGroup(group);
     317                    vm.refreshGroups();
     318                    return View("Groups", vm);
     319                }
     320            }
     321            else
     322            {
     323                return RedirectToAction("Index", "Home");
    251324            }
    252325
    … …  
    254327        public IActionResult deleteMember(string g, string m)
    255328        {
    256             init();
    257             var gid = Guid.Parse(g);
    258             var mid = Guid.Parse(m);
    259             UserViewModel vm = new UserViewModel(accessClient).refreshGroups().refreshUsers() ;
    260 
    261             if (gid == Guid.Empty || mid == Guid.Empty)
    262             {
    263                 vm.message = "Something went wrong, member is not deleted";
    264                 return View("Groups", vm);
    265             }
    266             else
    267             {
    268                 var group = vm.getGroupById(gid);
    269                 Access.UserGroupBase member = vm.getUserById(mid);
    270                 if(member == null)
    271                 {
    272                     member = vm.getGroupById(mid);
    273                 }
    274                 vm.message = " Member deleted";
    275                 accessClient.deleteMember(member,group);
    276                 vm.refreshGroups();
    277                 return RedirectToAction("SelectGroup", new { id = g });
     329            if (init())
     330            {
     331                var gid = Guid.Parse(g);
     332                var mid = Guid.Parse(m);
     333                UserViewModel vm = new UserViewModel(accessClient).refreshGroups().refreshUsers();
     334
     335                if (gid == Guid.Empty || mid == Guid.Empty)
     336                {
     337                    vm.message = "Something went wrong, member is not deleted";
     338                    return View("Groups", vm);
     339                }
     340                else
     341                {
     342                    var group = vm.getGroupById(gid);
     343                    Access.UserGroupBase member = vm.getUserById(mid);
     344                    if (member == null)
     345                    {
     346                        member = vm.getGroupById(mid);
     347                    }
     348                    vm.message = " Member deleted";
     349                    accessClient.deleteMember(member, group);
     350                    vm.refreshGroups();
     351                    return RedirectToAction("SelectGroup", new { id = g });
     352                }
     353            }
     354            else
     355            {
     356                return RedirectToAction("Index", "Home");
    278357            }
    279358
    … …  
    284363        public IActionResult Roles()
    285364        {
    286             init();
    287             if (serviceLocator.CheckLogin())
     365            if (init())
    288366            {
    289367
    290368                ViewBag.Title = "Roles";
    291                 // accessClient.RefreshUsers();
    292 
    293                 return View("Roles");
     369                UserViewModel vm = new UserViewModel(accessClient).refreshRoles();
     370
     371                return View("Roles", vm);
     372            }
     373            else
     374            {
     375                return RedirectToAction("Index", "Home");
     376            }
     377        }
     378        public IActionResult SelectRole(string name)
     379        {
     380            if (init())
     381            {
     382
     383                UserViewModel vm = new UserViewModel(accessClient).refreshRoles();
     384                if (name == "" || name == null)
     385                {
     386                    ViewBag.Title = "Add Role";
     387                }
     388                else
     389                {
     390                    vm.SelectedRole = vm.getRoleByName(name);
     391                    vm.SelectedRoleEnrolled = accessClient.getEnrolled(vm.SelectedRole);
     392
     393                    ViewBag.title = vm.SelectedRole.Name;
     394                }
     395                ViewBag.Title += " - Roles";
     396                return View("Roles", vm);
     397            }
     398            else
     399            {
     400                return RedirectToAction("Index", "Home");
     401            }
     402        }
     403        [HttpPost]
     404        public IActionResult saveRole(string inprolename)
     405        {
     406            if (init())
     407            {
     408                Access.Role role = accessClient.Roles.Find(x => x.Name == inprolename);
     409                if (role == null)
     410                {
     411                    role = new Access.Role();
     412                    role.Name = inprolename;
     413                    accessClient.addRole(role);
     414                }
     415
     416                accessClient.RefreshRoles();
     417                return RedirectToAction("SelectRole", new { name = inprolename });
     418            }
     419            else
     420            {
     421                return RedirectToAction("Index", "Home");
     422            }
     423        }
     424        public IActionResult deleteRole(string name)
     425        {
     426            if (init())
     427            {
     428                accessClient.deleteRole(name);
     429                return RedirectToAction("Roles");
     430            }
     431            else
     432            {
     433                return RedirectToAction("Index", "Home");
     434            }
     435        }
     436        public IActionResult deleteRoleUser(string id, string role)
     437        {
     438            if (init())
     439            {
     440                var uid = Guid.Parse(id);
     441                UserViewModel vm = new UserViewModel(accessClient).refreshAll();
     442
     443                var user = vm.getUserById(uid);
     444                var r = vm.getRoleByName(role);
     445                vm.message = role + " role has been deleted from " + user.FullName;
     446                accessClient.deleteUserRole(user, r);
     447                return RedirectToAction("SelectRole", new { name = role });
    294448            }
    295449            else
Note: See TracChangeset for help on using the changeset viewer.