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