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.Collections;
  24 import java.util.List;
  25
  26 import com.opensymphony.xwork2.Validateable;
  27 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  28 import org.apache.archiva.metadata.repository.MetadataResolver;
  29 import org.apache.archiva.metadata.repository.MetadataResolverException;
  30 import org.apache.archiva.metadata.repository.storage.maven2.MavenProjectFacet;
  31 import org.apache.commons.lang.StringUtils;
  32 import org.apache.maven.archiva.database.ArchivaDatabaseException;
  33 import org.apache.maven.archiva.database.ObjectNotFoundException;
  34 import org.apache.maven.archiva.database.browsing.RepositoryBrowsing;
  35 import org.apache.maven.archiva.model.ArchivaProjectModel;
  36 import org.apache.maven.archiva.model.CiManagement;
  37 import org.apache.maven.archiva.model.Dependency;
  38 import org.apache.maven.archiva.model.IssueManagement;
  39 import org.apache.maven.archiva.model.License;
  40 import org.apache.maven.archiva.model.MailingList;
  41 import org.apache.maven.archiva.model.Organization;
  42 import org.apache.maven.archiva.model.Scm;
  43 import org.apache.maven.archiva.model.VersionedReference;
  44 import org.apache.maven.archiva.security.AccessDeniedException;
  45 import org.apache.maven.archiva.security.ArchivaSecurityException;
  46 import org.apache.maven.archiva.security.PrincipalNotFoundException;
  47 import org.apache.maven.archiva.security.UserRepositories;
  48
  49 /**
  50  * Browse the repository.
  51  *
  52  * TODO change name to ShowVersionedAction to conform to terminology.
  53  *
  54  * @plexus.component role="com.opensymphony.xwork2.Action" role-hint="showArtifactAction" instantiation-strategy="per-lookup"
  55  */
  56 public class ShowArtifactAction
  57     extends PlexusActionSupport
  58     implements Validateable
  59 {
  60     /* .\ Not Exposed \._____________________________________________ */
  61
  62     /**
  63      * @plexus.requirement role-hint="default"
  64      */
  65     private RepositoryBrowsing repoBrowsing;
  66
  67     /**
  68      * @plexus.requirement
  69      */
  70     private UserRepositories userRepositories;
  71
  72     /**
  73      * @plexus.requirement
  74      */
  75     private MetadataResolver metadataResolver;
  76
  77     /* .\ Exposed Output Objects \.__________________________________ */
  78
  79     private String groupId;
  80
  81     private String artifactId;
  82
  83     private String version;
  84
  85     private String repositoryId;
  86
  87     /**
  88      * The model of this versioned project.
  89      */
  90     private ArchivaProjectModel model;
  91
  92     /**
  93      * The list of artifacts that depend on this versioned project.
  94      */
  95     private List<ArchivaProjectModel> dependees;
  96
  97     private List<MailingList> mailingLists;
  98
  99     private List<Dependency> dependencies;
 100
 101     private List<String> snapshotVersions;
 102
 103     /**
 104      * Show the versioned project information tab.
 105      * TODO: Change name to 'project' - we are showing project versions here, not specific artifact information (though
 106      * that is rendered in the download box).
 107      */
 108     public String artifact()
 109     {
 110         // In the future, this should be replaced by the repository grouping mechanism, so that we are only making
 111         // simple resource requests here and letting the resolver take care of it
 112         ProjectVersionMetadata versionMetadata = null;
 113         snapshotVersions = new ArrayList<String>();
 114         for ( String repoId : getObservableRepos() )
 115         {
 116             if ( versionMetadata == null )
 117             {
 118                 // TODO: though we have a simple mapping now, do we want to support paths like /1.0-20090111.123456-1/
 119                 //   again by mapping it to /1.0-SNAPSHOT/? Currently, the individual versions are not supported as we
 120                 //   are only displaying the project's single version.
 121
 122                 // we don't want the implementation being that intelligent - so another resolver to do the
 123                 // "just-in-time" nature of picking up the metadata (if appropriate for the repository type) is used
 124                 try
 125                 {
 126                     versionMetadata = metadataResolver.getProjectVersion( repoId, groupId, artifactId, version );
 127                 }
 128                 catch ( MetadataResolverException e )
 129                 {
 130                     addActionError( "Error occurred resolving metadata for project: " + e.getMessage() );
 131                     return ERROR;
 132                 }
 133                 if ( versionMetadata != null )
 134                 {
 135                     repositoryId = repoId;
 136
 137                     snapshotVersions.addAll(
 138                         metadataResolver.getArtifactVersions( repoId, groupId, artifactId, versionMetadata.getId() ) );
 139                     snapshotVersions.remove( version );
 140                 }
 141             }
 142         }
 143
 144         if ( versionMetadata == null )
 145         {
 146             addActionError( "Artifact not found" );
 147             return ERROR;
 148         }
 149
 150         // TODO: eventually, move to just use the metadata directly, with minimal JSP changes, mostly for Maven specifics
 151         model = new ArchivaProjectModel();
 152         MavenProjectFacet projectFacet = (MavenProjectFacet) versionMetadata.getFacet( MavenProjectFacet.FACET_ID );
 153         model.setGroupId( projectFacet.getGroupId() );
 154         model.setArtifactId( projectFacet.getArtifactId() );
 155         model.setPackaging( projectFacet.getPackaging() );
 156         if ( projectFacet.getParent() != null )
 157         {
 158             VersionedReference parent = new VersionedReference();
 159             parent.setGroupId( projectFacet.getParent().getGroupId() );
 160             parent.setArtifactId( projectFacet.getParent().getArtifactId() );
 161             parent.setVersion( projectFacet.getParent().getVersion() );
 162             model.setParentProject( parent );
 163         }
 164
 165         model.setVersion( versionMetadata.getId() );
 166         model.setDescription( versionMetadata.getDescription() );
 167         model.setName( versionMetadata.getName() );
 168         model.setUrl( versionMetadata.getUrl() );
 169         if ( versionMetadata.getOrganization() != null )
 170         {
 171             Organization organization = new Organization();
 172             organization.setName( versionMetadata.getOrganization().getName() );
 173             organization.setUrl( versionMetadata.getOrganization().getUrl() );
 174             model.setOrganization( organization );
 175         }
 176         if ( versionMetadata.getCiManagement() != null )
 177         {
 178             CiManagement ci = new CiManagement();
 179             ci.setSystem( versionMetadata.getCiManagement().getSystem() );
 180             ci.setUrl( versionMetadata.getCiManagement().getUrl() );
 181             model.setCiManagement( ci );
 182         }
 183         if ( versionMetadata.getIssueManagement() != null )
 184         {
 185             IssueManagement issueManagement = new IssueManagement();
 186             issueManagement.setSystem( versionMetadata.getIssueManagement().getSystem() );
 187             issueManagement.setUrl( versionMetadata.getIssueManagement().getUrl() );
 188             model.setIssueManagement( issueManagement );
 189         }
 190         if ( versionMetadata.getScm() != null )
 191         {
 192             Scm scm = new Scm();
 193             scm.setConnection( versionMetadata.getScm().getConnection() );
 194             scm.setDeveloperConnection( versionMetadata.getScm().getDeveloperConnection() );
 195             scm.setUrl( versionMetadata.getScm().getUrl() );
 196             model.setScm( scm );
 197         }
 198         if ( versionMetadata.getLicenses() != null )
 199         {
 200             for ( org.apache.archiva.metadata.model.License l : versionMetadata.getLicenses() )
 201             {
 202                 License license = new License();
 203                 license.setName( l.getName() );
 204                 license.setUrl( l.getUrl() );
 205                 model.addLicense( license );
 206             }
 207         }
 208
 209         return SUCCESS;
 210     }
 211
 212     /**
 213      * Show the artifact information tab.
 214      */
 215     public String dependencies()
 216         throws ObjectNotFoundException, ArchivaDatabaseException
 217     {
 218         this.model = repoBrowsing.selectVersion( getPrincipal(), getObservableRepos(), groupId, artifactId, version );
 219
 220         this.dependencies = model.getDependencies();
 221
 222         return SUCCESS;
 223     }
 224
 225     /**
 226      * Show the mailing lists information tab.
 227      */
 228     public String mailingLists()
 229         throws ObjectNotFoundException, ArchivaDatabaseException
 230     {
 231         this.model = repoBrowsing.selectVersion( getPrincipal(), getObservableRepos(), groupId, artifactId, version );
 232         this.mailingLists = model.getMailingLists();
 233
 234         return SUCCESS;
 235     }
 236
 237     /**
 238      * Show the reports tab.
 239      */
 240     public String reports()
 241         throws ObjectNotFoundException, ArchivaDatabaseException
 242     {
 243         // TODO: hook up reports on project - this.reports = artifactsDatabase.findArtifactResults( groupId, artifactId,
 244         // version );
 245
 246         return SUCCESS;
 247     }
 248
 249     /**
 250      * Show the dependees (other artifacts that depend on this project) tab.
 251      */
 252     public String dependees()
 253         throws ObjectNotFoundException, ArchivaDatabaseException
 254     {
 255         this.model = repoBrowsing.selectVersion( getPrincipal(), getObservableRepos(), groupId, artifactId, version );
 256
 257         this.dependees = repoBrowsing.getUsedBy( getPrincipal(), getObservableRepos(), groupId, artifactId, version );
 258
 259         return SUCCESS;
 260     }
 261
 262     /**
 263      * Show the dependencies of this versioned project tab.
 264      */
 265     public String dependencyTree()
 266         throws ObjectNotFoundException, ArchivaDatabaseException
 267     {
 268         this.model = repoBrowsing.selectVersion( getPrincipal(), getObservableRepos(), groupId, artifactId, version );
 269
 270         return SUCCESS;
 271     }
 272
 273     private List<String> getObservableRepos()
 274     {
 275         try
 276         {
 277             return userRepositories.getObservableRepositoryIds( getPrincipal() );
 278         }
 279         catch ( PrincipalNotFoundException e )
 280         {
 281             log.warn( e.getMessage(), e );
 282         }
 283         catch ( AccessDeniedException e )
 284         {
 285             log.warn( e.getMessage(), e );
 286             // TODO: pass this onto the screen.
 287         }
 288         catch ( ArchivaSecurityException e )
 289         {
 290             log.warn( e.getMessage(), e );
 291         }
 292         return Collections.emptyList();
 293     }
 294
 295     @Override
 296     public void validate()
 297     {
 298         if ( StringUtils.isBlank( groupId ) )
 299         {
 300             addActionError( "You must specify a group ID to browse" );
 301         }
 302
 303         if ( StringUtils.isBlank( artifactId ) )
 304         {
 305             addActionError( "You must specify a artifact ID to browse" );
 306         }
 307
 308         if ( StringUtils.isBlank( version ) )
 309         {
 310             addActionError( "You must specify a version to browse" );
 311         }
 312     }
 313
 314     public ArchivaProjectModel getModel()
 315     {
 316         return model;
 317     }
 318
 319     public String getGroupId()
 320     {
 321         return groupId;
 322     }
 323
 324     public void setGroupId( String groupId )
 325     {
 326         this.groupId = groupId;
 327     }
 328
 329     public String getArtifactId()
 330     {
 331         return artifactId;
 332     }
 333
 334     public void setArtifactId( String artifactId )
 335     {
 336         this.artifactId = artifactId;
 337     }
 338
 339     public String getVersion()
 340     {
 341         return version;
 342     }
 343
 344     public void setVersion( String version )
 345     {
 346         this.version = version;
 347     }
 348
 349     public List<MailingList> getMailingLists()
 350     {
 351         return mailingLists;
 352     }
 353
 354     public List<Dependency> getDependencies()
 355     {
 356         return dependencies;
 357     }
 358
 359     public List<ArchivaProjectModel> getDependees()
 360     {
 361         return dependees;
 362     }
 363
 364     public String getRepositoryId()
 365     {
 366         return repositoryId;
 367     }
 368
 369     public void setRepositoryId( String repositoryId )
 370     {
 371         this.repositoryId = repositoryId;
 372     }
 373
 374     public List<String> getSnapshotVersions()
 375     {
 376         return snapshotVersions;
 377     }
 378
 379     public void setSnapshotVersions( List<String> snapshotVersions )
 380     {
 381         this.snapshotVersions = snapshotVersions;
 382     }
 383
 384     public MetadataResolver getMetadataResolver()
 385     {
 386         return metadataResolver;
 387     }
 388 }