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

   1 package org.apache.archiva.rest.api.model.v2;/*
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements.  See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership.  The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License.  You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  * Unless required by applicable law or agreed to in writing,
  12  * software distributed under the License is distributed on an
  13  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14  * KIND, either express or implied.  See the License for the
  15  * specific language governing permissions and limitations
  16  * under the License.
  17  */
  18
  19 import io.swagger.v3.oas.annotations.media.Schema;
  20 import org.apache.archiva.admin.model.beans.RedbackRuntimeConfiguration;
  21
  22 import javax.xml.bind.annotation.XmlRootElement;
  23 import java.io.Serializable;
  24 import java.util.ArrayList;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.TreeMap;
  28
  29 /**
  30  * @author Martin Stockhammer <martin_s@apache.org>
  31  */
  32 @XmlRootElement(name = "securityConfiguration")
  33 @Schema(name = "SecurityConfiguration", description = "Security configuration attributes.")
  34 public class SecurityConfiguration implements Serializable
  35 {
  36     private static final long serialVersionUID = -4186866365979053029L;
  37
  38     private final List<String> activeUserManagers = new ArrayList<>(  );
  39     private final List<String> activeRbacManagers = new ArrayList<>(  );
  40     private final Map<String,String> properties = new TreeMap<>(  );
  41     private boolean userCacheEnabled=false;
  42     private boolean ldapActive=false;
  43
  44     public SecurityConfiguration() {
  45
  46     }
  47
  48     public static SecurityConfiguration ofRedbackConfiguration( RedbackRuntimeConfiguration configuration ) {
  49         SecurityConfiguration secConfig = new SecurityConfiguration( );
  50         secConfig.setActiveRbacManagers( configuration.getRbacManagerImpls() );
  51         secConfig.setActiveUserManagers( configuration.getUserManagerImpls() );
  52         secConfig.setProperties( configuration.getConfigurationProperties() );
  53         boolean rbLdapActive = configuration.getUserManagerImpls( ).stream( ).anyMatch( um -> um.contains( "ldap" ) );
  54         secConfig.setLdapActive( rbLdapActive );
  55         secConfig.setUserCacheEnabled( configuration.isUseUsersCache() );
  56         return secConfig;
  57     }
  58
  59     @Schema(name="active_user_managers", description = "List of ids of the active user managers")
  60     public List<String> getActiveUserManagers( )
  61     {
  62         return activeUserManagers;
  63     }
  64
  65     public void setActiveUserManagers( List<String> activeUserManagers )
  66     {
  67         this.activeUserManagers.clear();
  68         this.activeUserManagers.addAll( activeUserManagers );
  69     }
  70
  71     public void addSelectedUserManager(String userManager) {
  72         this.activeUserManagers.add( userManager );
  73     }
  74
  75     @Schema(name="active_rbac_managers", description = "List of ids of the active rbac managers")
  76     public List<String> getActiveRbacManagers( )
  77     {
  78         return activeRbacManagers;
  79     }
  80
  81     public void setActiveRbacManagers( List<String> activeRbacManagers )
  82     {
  83         this.activeRbacManagers.clear();
  84         this.activeRbacManagers.addAll( activeRbacManagers );
  85     }
  86
  87     public void addSelectedRbacManager(String rbacManager) {
  88         this.activeRbacManagers.add( rbacManager );
  89     }
  90
  91     @Schema(description = "Map of all security properties")
  92     public Map<String, String> getProperties( )
  93     {
  94         return properties;
  95     }
  96
  97     public void setProperties( Map<String, String> properties )
  98     {
  99         this.properties.clear();
 100         this.properties.putAll( properties );
 101     }
 102
 103     @Schema(name="user_cache_enabled", description = "True, if the user cache is active. It caches data from user backend.")
 104     public boolean isUserCacheEnabled( )
 105     {
 106         return userCacheEnabled;
 107     }
 108
 109     public void setUserCacheEnabled( boolean userCacheEnabled )
 110     {
 111         this.userCacheEnabled = userCacheEnabled;
 112     }
 113
 114     @Schema(name="ldap_active", description = "True, if LDAP is used as user manager")
 115     public boolean isLdapActive( )
 116     {
 117         return ldapActive;
 118     }
 119
 120     public void setLdapActive( boolean ldapActive )
 121     {
 122         this.ldapActive = ldapActive;
 123     }
 124
 125     @Override
 126     public boolean equals( Object o )
 127     {
 128         if ( this == o ) return true;
 129         if ( o == null || getClass( ) != o.getClass( ) ) return false;
 130
 131         SecurityConfiguration that = (SecurityConfiguration) o;
 132
 133         if ( userCacheEnabled != that.userCacheEnabled ) return false;
 134         if ( ldapActive != that.ldapActive ) return false;
 135         if ( !activeUserManagers.equals( that.activeUserManagers ) ) return false;
 136         if ( !activeRbacManagers.equals( that.activeRbacManagers ) ) return false;
 137         return properties.equals( that.properties );
 138     }
 139
 140     @Override
 141     public int hashCode( )
 142     {
 143         int result = activeUserManagers.hashCode( );
 144         result = 31 * result + activeRbacManagers.hashCode( );
 145         result = 31 * result + properties.hashCode( );
 146         result = 31 * result + ( userCacheEnabled ? 1 : 0 );
 147         result = 31 * result + ( ldapActive ? 1 : 0 );
 148         return result;
 149     }
 150
 151     @SuppressWarnings( "StringBufferReplaceableByString" )
 152     @Override
 153     public String toString( )
 154     {
 155         final StringBuilder sb = new StringBuilder( "SecurityConfiguration{" );
 156         sb.append( "active_user_managers=" ).append( activeUserManagers );
 157         sb.append( ", active_rbac_managers=" ).append( activeRbacManagers );
 158         sb.append( ", properties=" ).append( properties );
 159         sb.append( ", user_cache_nabled=" ).append( userCacheEnabled );
 160         sb.append( ", ldap_active=" ).append( ldapActive );
 161         sb.append( '}' );
 162         return sb.toString( );
 163     }
 164 }