source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.redback.struts2.action.admin;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.redback.rbac.Permission;
  23 import org.apache.archiva.redback.rbac.RbacManagerException;
  24 import org.apache.archiva.redback.rbac.Resource;
  25 import org.apache.archiva.redback.rbac.Role;
  26 import org.apache.archiva.redback.rbac.UserAssignment;
  27 import org.apache.archiva.redback.users.User;
  28 import org.apache.commons.lang.StringEscapeUtils;
  29 import org.apache.archiva.redback.struts2.action.AbstractUserCredentialsAction;
  30 import org.apache.archiva.redback.struts2.action.AuditEvent;
  31 import org.apache.archiva.redback.users.UserManager;
  32 import org.apache.archiva.redback.users.UserNotFoundException;
  33 import org.codehaus.plexus.util.StringUtils;
  34 import org.apache.archiva.redback.integration.interceptor.SecureActionBundle;
  35 import org.apache.archiva.redback.integration.interceptor.SecureActionException;
  36 import org.apache.archiva.redback.integration.security.role.RedbackRoleConstants;
  37 import org.springframework.context.annotation.Scope;
  38 import org.springframework.stereotype.Controller;
  39
  40 import java.util.ArrayList;
  41 import java.util.List;
  42 import java.util.Map;
  43
  44 /**
  45  * EditRoleAction
  46  *
  47  * @author <a href="mailto:joakim@erdfelt.com">Joakim Erdfelt</a>
  48  *
  49  */
  50 @Controller( "redback-role-edit" )
  51 @Scope( "prototype" )
  52 public class EditRoleAction
  53     extends AbstractUserCredentialsAction
  54 {
  55     // ------------------------------------------------------------------
  56     // Action Parameters
  57     // ------------------------------------------------------------------
  58
  59     private String name;
  60
  61     private String description;
  62
  63     private String newDescription;
  64
  65     private List<String> childRoleNames = new ArrayList<String>();
  66
  67     private List<String> parentRoleNames = new ArrayList<String>();
  68
  69     private List<Permission> permissions = new ArrayList<Permission>();
  70
  71     private List<User> users = new ArrayList<User>();
  72
  73     private List<User> parentUsers = new ArrayList<User>();
  74
  75     private List<User> allUsers = new ArrayList<User>();
  76
  77     private List<String> usersList = new ArrayList<String>();
  78
  79     private List<String> availableUsers = new ArrayList<String>();
  80
  81     private List<String> currentUsers = new ArrayList<String>();
  82
  83     // ------------------------------------------------------------------
  84     // Action Entry Points - (aka Names)
  85     // ------------------------------------------------------------------
  86
  87     public String input()
  88     {
  89         if ( name == null )
  90         {
  91             addActionError( getText( "cannot.edit.null.role" ) );
  92             return ERROR;
  93         }
  94
  95         if ( StringUtils.isEmpty( name ) )
  96         {
  97             addActionError( getText( "cannot.edit.empty.role" ) );
  98             return ERROR;
  99         }
 100
 101         name = StringEscapeUtils.escapeXml( name );
 102
 103         if ( !getManager().roleExists( name ) )
 104         {
 105             // Means that the role name doesn't exist.
 106             // We should exit early and not attempt to look up the role information.
 107             return INPUT;
 108         }
 109
 110         try
 111         {
 112             if ( !isAuthorized() )
 113             {
 114                 log.warn( getCurrentUser() + " isn't authorized to access to the role '" + name + "'" );
 115                 addActionError( getText( "alert.message" ) );
 116                 return ERROR;
 117             }
 118
 119             Role role = getManager().getRole( name );
 120             if ( role == null )
 121             {
 122                 addActionError( getText( "cannot.operate.null.role" ) );
 123                 return ERROR;
 124             }
 125
 126             description = role.getDescription();
 127             childRoleNames = role.getChildRoleNames();
 128             Map<String, Role> parentRoles = getManager().getParentRoles( role );
 129             for ( String roleName : parentRoles.keySet() )
 130             {
 131                 parentRoleNames.add( roleName );
 132             }
 133             permissions = role.getPermissions();
 134
 135             //Get users of the current role
 136             List<String> roles = new ArrayList<String>();
 137             roles.add( name );
 138             List<UserAssignment> userAssignments = getManager().getUserAssignmentsForRoles( roles );
 139             users = new ArrayList<User>();
 140             if ( userAssignments != null )
 141             {
 142                 for ( UserAssignment userAssignment : userAssignments )
 143                 {
 144                     try
 145                     {
 146                         User user = getUserManager().findUser( userAssignment.getPrincipal() );
 147                         users.add( user );
 148                     }
 149                     catch ( UserNotFoundException e )
 150                     {
 151                         log.warn( "User '" + userAssignment.getPrincipal() + "' doesn't exist.", e );
 152                     }
 153                 }
 154             }
 155
 156             //Get users of the parent roles
 157             parentUsers = new ArrayList<User>();
 158             if ( !parentRoles.isEmpty() )
 159             {
 160                 List<UserAssignment> userParentAssignments =
 161                     getManager().getUserAssignmentsForRoles( parentRoles.keySet() );
 162                 if ( userParentAssignments != null )
 163                 {
 164                     for ( UserAssignment userAssignment : userParentAssignments )
 165                     {
 166                         try
 167                         {
 168                             User user = getUserManager().findUser( userAssignment.getPrincipal() );
 169                             parentUsers.add( user );
 170                         }
 171                         catch ( UserNotFoundException e )
 172                         {
 173                             log.warn( "User '" + userAssignment.getPrincipal() + "' doesn't exist.", e );
 174                         }
 175                     }
 176                 }
 177             }
 178         }
 179         catch ( RbacManagerException e )
 180         {
 181             List<Object> list = new ArrayList<Object>();
 182             list.add( name );
 183             list.add( e.getMessage() );
 184             addActionError( getText( "cannot.get.role", list ) );
 185             return ERROR;
 186         }
 187
 188         return INPUT;
 189     }
 190
 191     private boolean isAuthorized()
 192         throws RbacManagerException
 193     {
 194         List<Role> assignableRoles = getFilteredRolesForCurrentUserAccess();
 195         boolean updatableRole = false;
 196         for ( Role r : assignableRoles )
 197         {
 198             if ( r.getName().equalsIgnoreCase( name ) )
 199             {
 200                 updatableRole = true;
 201             }
 202         }
 203
 204         return updatableRole;
 205     }
 206
 207     public String edit()
 208     {
 209         String result = input();
 210         if ( ERROR.equals( result ) )
 211         {
 212             return result;
 213         }
 214
 215         newDescription = description;
 216
 217         //TODO: Remove all users defined in parent roles too
 218         allUsers = getUserManager().getUsers();
 219
 220         for ( User user : users )
 221         {
 222             if ( allUsers.contains( user ) )
 223             {
 224                 allUsers.remove( user );
 225             }
 226         }
 227
 228         for ( User user : parentUsers )
 229         {
 230             if ( allUsers.contains( user ) )
 231             {
 232                 allUsers.remove( user );
 233             }
 234         }
 235
 236         return result;
 237     }
 238
 239     public String save()
 240     {
 241         String result = input();
 242         if ( ERROR.equals( result ) )
 243         {
 244             return result;
 245         }
 246
 247         if ( name == null )
 248         {
 249             addActionError( getText( "cannot.edit.null.role" ) );
 250             return ERROR;
 251         }
 252
 253         if ( StringUtils.isEmpty( name ) )
 254         {
 255             addActionError( getText( "cannot.edit.empty.role" ) );
 256             return ERROR;
 257         }
 258
 259         try
 260         {
 261             Role role;
 262             if ( getManager().roleExists( name ) )
 263             {
 264                 role = getManager().getRole( name );
 265             }
 266             else
 267             {
 268                 role = getManager().createRole( name );
 269             }
 270
 271             //TODO: allow to modify childRoleNames and permissions
 272             role.setDescription( newDescription );
 273             //role.setChildRoleNames( childRoleNames );
 274             //role.setPermissions( permissions );
 275
 276             getManager().saveRole( role );
 277
 278             List<Object> list = new ArrayList<Object>();
 279             list.add( name );
 280             String currentUser = getCurrentUser();
 281             AuditEvent event = new AuditEvent( getText( "log.role.edit" ) );
 282             event.setRole( name );
 283             event.setCurrentUser( currentUser );
 284             event.log();
 285             addActionMessage( getText( "save.role.success", list ) );
 286         }
 287         catch ( RbacManagerException e )
 288         {
 289             List<Object> list = new ArrayList<Object>();
 290             list.add( name );
 291             list.add( e.getMessage() );
 292             addActionError( getText( "cannot.get.role", list ) );
 293             return ERROR;
 294         }
 295
 296         return SUCCESS;
 297     }
 298
 299     public String addUsers()
 300     {
 301         if ( availableUsers == null || availableUsers.isEmpty() )
 302         {
 303             return INPUT;
 304         }
 305
 306         for ( String principal : availableUsers )
 307         {
 308             if ( !getUserManager().userExists( principal ) )
 309             {
 310                 // Means that the role name doesn't exist.
 311                 // We need to fail fast and return to the previous page.
 312                 List<Object> list = new ArrayList<Object>();
 313                 list.add( principal );
 314                 addActionError( getText( "user.does.not.exist", list ) );
 315                 return ERROR;
 316             }
 317
 318             try
 319             {
 320                 UserAssignment assignment;
 321
 322                 if ( getManager().userAssignmentExists( principal ) )
 323                 {
 324                     assignment = getManager().getUserAssignment( principal );
 325                 }
 326                 else
 327                 {
 328                     assignment = getManager().createUserAssignment( principal );
 329                 }
 330
 331                 assignment.addRoleName( name );
 332                 assignment = getManager().saveUserAssignment( assignment );
 333                 log.info( "{} role assigned to {}", name, principal );
 334             }
 335             catch ( RbacManagerException e )
 336             {
 337                 List<Object> list = new ArrayList<Object>();
 338                 list.add( principal );
 339                 list.add( e.getMessage() );
 340                 addActionError( getText( "cannot.assign.role", list ) );
 341                 return ERROR;
 342             }
 343         }
 344
 345         edit();
 346         return SUCCESS;
 347     }
 348
 349     public String removeUsers()
 350     {
 351         if ( currentUsers == null || currentUsers.isEmpty() )
 352         {
 353             return INPUT;
 354         }
 355
 356         for ( String principal : currentUsers )
 357         {
 358             if ( !getUserManager().userExists( principal ) )
 359             {
 360                 // Means that the role name doesn't exist.
 361                 // We need to fail fast and return to the previous page.
 362                 List<Object> list = new ArrayList<Object>();
 363                 list.add( principal );
 364                 addActionError( getText( "user.does.not.exist", list ) );
 365                 return ERROR;
 366             }
 367
 368             try
 369             {
 370                 UserAssignment assignment;
 371
 372                 if ( getManager().userAssignmentExists( principal ) )
 373                 {
 374                     assignment = getManager().getUserAssignment( principal );
 375                 }
 376                 else
 377                 {
 378                     assignment = getManager().createUserAssignment( principal );
 379                 }
 380
 381                 assignment.removeRoleName( name );
 382                 assignment = getManager().saveUserAssignment( assignment );
 383                 log.info( "{} role unassigned to {}", name, principal );
 384             }
 385             catch ( RbacManagerException e )
 386             {
 387                 List<Object> list = new ArrayList<Object>();
 388                 list.add( principal );
 389                 list.add( e.getMessage() );
 390                 addActionError( getText( "cannot.assign.role", list ) );
 391                 return ERROR;
 392             }
 393         }
 394
 395         edit();
 396         return SUCCESS;
 397     }
 398
 399     private UserManager getUserManager()
 400     {
 401         return securitySystem.getUserManager();
 402     }
 403
 404     // ------------------------------------------------------------------
 405     // Parameter Accessor Methods
 406     // ------------------------------------------------------------------
 407
 408     public String getName()
 409     {
 410         return name;
 411     }
 412
 413     public void setName( String roleName )
 414     {
 415         this.name = roleName;
 416     }
 417
 418     public List<String> getChildRoleNames()
 419     {
 420         return childRoleNames;
 421     }
 422
 423     public void setChildRoleNames( List<String> childRoleNames )
 424     {
 425         this.childRoleNames = childRoleNames;
 426     }
 427
 428     public String getDescription()
 429     {
 430         return description;
 431     }
 432
 433     public void setDescription( String description )
 434     {
 435         this.description = description;
 436     }
 437
 438     public String getNewDescription()
 439     {
 440         return newDescription;
 441     }
 442
 443     public void setNewDescription( String newDescription )
 444     {
 445         this.newDescription = newDescription;
 446     }
 447
 448     public List<Permission> getPermissions()
 449     {
 450         return permissions;
 451     }
 452
 453     public void setPermissions( List<Permission> permissions )
 454     {
 455         this.permissions = permissions;
 456     }
 457
 458     public List<User> getUsers()
 459     {
 460         return users;
 461     }
 462
 463     public void setUsers( List<User> users )
 464     {
 465         this.users = users;
 466     }
 467
 468     public List<User> getAllUsers()
 469     {
 470         return allUsers;
 471     }
 472
 473     public void setAllUsers( List<User> allUsers )
 474     {
 475         this.allUsers = allUsers;
 476     }
 477
 478     public List<String> getUsersList()
 479     {
 480         return usersList;
 481     }
 482
 483     public void setUsersList( List<String> usersList )
 484     {
 485         this.usersList = usersList;
 486     }
 487
 488     public List<String> getAvailableUsers()
 489     {
 490         return availableUsers;
 491     }
 492
 493     public void setAvailableUsers( List<String> availableUsers )
 494     {
 495         this.availableUsers = availableUsers;
 496     }
 497
 498     public List<String> getCurrentUsers()
 499     {
 500         return currentUsers;
 501     }
 502
 503     public void setCurrentUsers( List<String> currentUsers )
 504     {
 505         this.currentUsers = currentUsers;
 506     }
 507
 508     public List<String> getParentRoleNames()
 509     {
 510         return parentRoleNames;
 511     }
 512
 513     public void setParentRoleNames( List<String> parentRoleNames )
 514     {
 515         this.parentRoleNames = parentRoleNames;
 516     }
 517
 518     public List<User> getParentUsers()
 519     {
 520         return parentUsers;
 521     }
 522
 523     public void setParentUsers( List<User> parentUsers )
 524     {
 525         this.parentUsers = parentUsers;
 526     }
 527
 528     // ------------------------------------------------------------------
 529     // Internal Support Methods
 530     // ------------------------------------------------------------------
 531
 532     public SecureActionBundle initSecureActionBundle()
 533         throws SecureActionException
 534     {
 535         SecureActionBundle bundle = new SecureActionBundle();
 536         bundle.setRequiresAuthentication( true );
 537         bundle.addRequiredAuthorization( RedbackRoleConstants.USER_MANAGEMENT_USER_EDIT_OPERATION, Resource.GLOBAL );
 538         bundle.addRequiredAuthorization( RedbackRoleConstants.USER_MANAGEMENT_RBAC_ADMIN_OPERATION, Resource.GLOBAL );
 539         bundle.addRequiredAuthorization( RedbackRoleConstants.USER_MANAGEMENT_ROLE_GRANT_OPERATION, Resource.GLOBAL );
 540         bundle.addRequiredAuthorization( RedbackRoleConstants.USER_MANAGEMENT_ROLE_DROP_OPERATION, Resource.GLOBAL );
 541         bundle.addRequiredAuthorization( RedbackRoleConstants.USER_MANAGEMENT_USER_ROLE_OPERATION, Resource.GLOBAL );
 542         return bundle;
 543     }
 544 }