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

   1 package org.apache.maven.archiva.web.action;
   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 java.util.ArrayList;
  23 import java.util.Collection;
  24 import java.util.Collections;
  25 import java.util.LinkedHashSet;
  26 import java.util.List;
  27 import java.util.Set;
  28
  29 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  30 import org.apache.archiva.metadata.repository.MetadataResolver;
  31 import org.apache.archiva.metadata.repository.MetadataResolverException;
  32 import org.apache.archiva.metadata.repository.storage.maven2.MavenProjectFacet;
  33 import org.apache.commons.collections.CollectionUtils;
  34 import org.apache.commons.lang.StringUtils;
  35
  36 /**
  37  * Browse the repository.
  38  *
  39  * @todo implement repository selectors (all or specific repository)
  40  * @plexus.component role="com.opensymphony.xwork2.Action" role-hint="browseAction" instantiation-strategy="per-lookup"
  41  */
  42 public class BrowseAction
  43     extends AbstractRepositoryBasedAction
  44 {
  45     /**
  46      * @plexus.requirement
  47      */
  48     private MetadataResolver metadataResolver;
  49
  50     private String groupId;
  51
  52     private String artifactId;
  53
  54     private String repositoryId;
  55
  56     private ProjectVersionMetadata sharedModel;
  57
  58     private Collection<String> namespaces;
  59
  60     private Collection<String> projectIds;
  61
  62     private Collection<String> projectVersions;
  63
  64     public String browse()
  65     {
  66         List<String> selectedRepos = getObservableRepos();
  67         if ( CollectionUtils.isEmpty( selectedRepos ) )
  68         {
  69             return GlobalResults.ACCESS_TO_NO_REPOS;
  70         }
  71
  72         Set<String> namespaces = new LinkedHashSet<String>();
  73         for ( String repoId : selectedRepos )
  74         {
  75             Collection<String> rootNamespaces = metadataResolver.getRootNamespaces( repoId );
  76             // TODO: this logic should be optional, particularly remembering we want to keep this code simple
  77             //       it is located here to avoid the content repository implementation needing to do too much for what
  78             //       is essentially presentation code
  79             for ( String n : rootNamespaces )
  80             {
  81                 // TODO: check performance of this
  82                 namespaces.add( collapseNamespaces( repoId, n ) );
  83             }
  84         }
  85
  86         this.namespaces = getSortedList( namespaces );
  87         return SUCCESS;
  88     }
  89
  90     private String collapseNamespaces( String repoId, String n )
  91     {
  92         Collection<String> subNamespaces = metadataResolver.getNamespaces( repoId, n );
  93         if ( subNamespaces.size() != 1 )
  94         {
  95             return n;
  96         }
  97         else
  98         {
  99             Collection<String> projects = metadataResolver.getProjects( repoId, n );
 100             if ( projects != null && !projects.isEmpty() )
 101             {
 102                 return n;
 103             }
 104             else
 105             {
 106                 return collapseNamespaces( repoId, n + "." + subNamespaces.iterator().next() );
 107             }
 108         }
 109     }
 110
 111     public String browseGroup()
 112     {
 113         if ( StringUtils.isEmpty( groupId ) )
 114         {
 115             // TODO: i18n
 116             addActionError( "You must specify a group ID to browse" );
 117             return ERROR;
 118         }
 119
 120         List<String> selectedRepos = getObservableRepos();
 121         if ( CollectionUtils.isEmpty( selectedRepos ) )
 122         {
 123             return GlobalResults.ACCESS_TO_NO_REPOS;
 124         }
 125
 126         Set<String> namespaces = new LinkedHashSet<String>();
 127         Set<String> projects = new LinkedHashSet<String>();
 128         for ( String repoId : selectedRepos )
 129         {
 130             Collection<String> childNamespaces = metadataResolver.getNamespaces( repoId, groupId );
 131             // TODO: this logic should be optional, particularly remembering we want to keep this code simple
 132             //       it is located here to avoid the content repository implementation needing to do too much for what
 133             //       is essentially presentation code
 134             for ( String n : childNamespaces )
 135             {
 136                 // TODO: check performance of this
 137                 namespaces.add( collapseNamespaces( repoId, groupId + "." + n ) );
 138             }
 139
 140             projects.addAll( metadataResolver.getProjects( repoId, groupId ) );
 141         }
 142
 143         this.namespaces = getSortedList( namespaces );
 144         this.projectIds = getSortedList( projects );
 145         return SUCCESS;
 146     }
 147
 148     private ArrayList<String> getSortedList( Set<String> set )
 149     {
 150         ArrayList<String> list = new ArrayList<String>( set );
 151         Collections.sort( list );
 152         return list;
 153     }
 154
 155     public String browseArtifact()
 156         throws MetadataResolverException
 157     {
 158         if ( StringUtils.isEmpty( groupId ) )
 159         {
 160             // TODO: i18n
 161             addActionError( "You must specify a group ID to browse" );
 162             return ERROR;
 163         }
 164
 165         if ( StringUtils.isEmpty( artifactId ) )
 166         {
 167             // TODO: i18n
 168             addActionError( "You must specify a artifact ID to browse" );
 169             return ERROR;
 170         }
 171
 172         List<String> selectedRepos = getObservableRepos();
 173         if ( CollectionUtils.isEmpty( selectedRepos ) )
 174         {
 175             return GlobalResults.ACCESS_TO_NO_REPOS;
 176         }
 177
 178         Set<String> versions = new LinkedHashSet<String>();
 179         for ( String repoId : selectedRepos )
 180         {
 181             versions.addAll( metadataResolver.getProjectVersions( repoId, groupId, artifactId ) );
 182         }
 183
 184         // TODO: sort by known version ordering method
 185         this.projectVersions = new ArrayList<String>( versions );
 186
 187         populateSharedModel( selectedRepos, versions );
 188
 189         return SUCCESS;
 190     }
 191
 192     private void populateSharedModel( Collection<String> selectedRepos, Collection<String> projectVersions )
 193         throws MetadataResolverException
 194     {
 195         sharedModel = new ProjectVersionMetadata();
 196
 197         MavenProjectFacet mavenFacet = new MavenProjectFacet();
 198         mavenFacet.setGroupId( groupId );
 199         mavenFacet.setArtifactId( artifactId );
 200         sharedModel.addFacet( mavenFacet );
 201
 202         boolean isFirstVersion = true;
 203
 204         for ( String version : projectVersions )
 205         {
 206             ProjectVersionMetadata versionMetadata = null;
 207             for ( String repoId : selectedRepos )
 208             {
 209                 if ( versionMetadata == null )
 210                 {
 211                     versionMetadata = metadataResolver.getProjectVersion( repoId, groupId, artifactId, version );
 212                 }
 213             }
 214
 215             if ( versionMetadata == null )
 216             {
 217                 continue;
 218             }
 219
 220             if ( isFirstVersion )
 221             {
 222                 sharedModel = versionMetadata;
 223                 sharedModel.setId( null );
 224             }
 225             else
 226             {
 227                 MavenProjectFacet versionMetadataMavenFacet =
 228                     (MavenProjectFacet) versionMetadata.getFacet( MavenProjectFacet.FACET_ID );
 229                 if ( versionMetadataMavenFacet != null )
 230                 {
 231                     if ( mavenFacet.getPackaging() != null && !StringUtils.equalsIgnoreCase( mavenFacet.getPackaging(),
 232                                                                                              versionMetadataMavenFacet.getPackaging() ) )
 233                     {
 234                         mavenFacet.setPackaging( null );
 235                     }
 236                 }
 237
 238                 if ( sharedModel.getName() != null &&
 239                     !StringUtils.equalsIgnoreCase( sharedModel.getName(), versionMetadata.getName() ) )
 240                 {
 241                     sharedModel.setName( "" );
 242                 }
 243
 244                 if ( sharedModel.getDescription() != null &&
 245                     !StringUtils.equalsIgnoreCase( sharedModel.getDescription(), versionMetadata.getDescription() ) )
 246                 {
 247                     sharedModel.setDescription( null );
 248                 }
 249
 250                 if ( sharedModel.getIssueManagement() != null && versionMetadata.getIssueManagement() != null &&
 251                     !StringUtils.equalsIgnoreCase( sharedModel.getIssueManagement().getUrl(),
 252                                                    versionMetadata.getIssueManagement().getUrl() ) )
 253                 {
 254                     sharedModel.setIssueManagement( null );
 255                 }
 256
 257                 if ( sharedModel.getCiManagement() != null && versionMetadata.getCiManagement() != null &&
 258                     !StringUtils.equalsIgnoreCase( sharedModel.getCiManagement().getUrl(),
 259                                                    versionMetadata.getCiManagement().getUrl() ) )
 260                 {
 261                     sharedModel.setCiManagement( null );
 262                 }
 263
 264                 if ( sharedModel.getOrganization() != null && versionMetadata.getOrganization() != null &&
 265                     !StringUtils.equalsIgnoreCase( sharedModel.getOrganization().getName(),
 266                                                    versionMetadata.getOrganization().getName() ) )
 267                 {
 268                     sharedModel.setOrganization( null );
 269                 }
 270
 271                 if ( sharedModel.getUrl() != null &&
 272                     !StringUtils.equalsIgnoreCase( sharedModel.getUrl(), versionMetadata.getUrl() ) )
 273                 {
 274                     sharedModel.setUrl( null );
 275                 }
 276             }
 277
 278             isFirstVersion = false;
 279         }
 280     }
 281
 282     public String getGroupId()
 283     {
 284         return groupId;
 285     }
 286
 287     public void setGroupId( String groupId )
 288     {
 289         this.groupId = groupId;
 290     }
 291
 292     public String getArtifactId()
 293     {
 294         return artifactId;
 295     }
 296
 297     public void setArtifactId( String artifactId )
 298     {
 299         this.artifactId = artifactId;
 300     }
 301
 302     public Collection<String> getNamespaces()
 303     {
 304         return namespaces;
 305     }
 306
 307     public String getRepositoryId()
 308     {
 309
 310         return repositoryId;
 311     }
 312
 313     public void setRepositoryId( String repositoryId )
 314     {
 315
 316         this.repositoryId = repositoryId;
 317     }
 318
 319     public ProjectVersionMetadata getSharedModel()
 320     {
 321         return sharedModel;
 322     }
 323
 324     public MetadataResolver getMetadataResolver()
 325     {
 326         return metadataResolver;
 327     }
 328
 329     public Collection<String> getProjectIds()
 330     {
 331         return projectIds;
 332     }
 333
 334     public Collection<String> getProjectVersions()
 335     {
 336         return projectVersions;
 337     }
 338 }