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.List;
  24
  25 import com.opensymphony.xwork2.Validateable;
  26 import org.apache.archiva.metadata.model.Dependency;
  27 import org.apache.archiva.metadata.model.MailingList;
  28 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  29 import org.apache.archiva.metadata.model.ProjectVersionReference;
  30 import org.apache.archiva.metadata.repository.MetadataResolver;
  31 import org.apache.archiva.metadata.repository.MetadataResolverException;
  32 import org.apache.commons.lang.StringUtils;
  33
  34 /**
  35  * Browse the repository.
  36  *
  37  * TODO change name to ShowVersionedAction to conform to terminology.
  38  *
  39  * @plexus.component role="com.opensymphony.xwork2.Action" role-hint="showArtifactAction" instantiation-strategy="per-lookup"
  40  */
  41 public class ShowArtifactAction
  42     extends AbstractRepositoryBasedAction
  43     implements Validateable
  44 {
  45     /* .\ Not Exposed \._____________________________________________ */
  46
  47     /**
  48      * @plexus.requirement
  49      */
  50     private MetadataResolver metadataResolver;
  51
  52     /* .\ Exposed Output Objects \.__________________________________ */
  53
  54     private String groupId;
  55
  56     private String artifactId;
  57
  58     private String version;
  59
  60     private String repositoryId;
  61
  62     /**
  63      * The model of this versioned project.
  64      */
  65     private ProjectVersionMetadata model;
  66
  67     /**
  68      * The list of artifacts that depend on this versioned project.
  69      */
  70     private List<ProjectVersionReference> dependees;
  71
  72     private List<MailingList> mailingLists;
  73
  74     private List<Dependency> dependencies;
  75
  76     private List<String> snapshotVersions;
  77
  78     /**
  79      * Show the versioned project information tab.
  80      * TODO: Change name to 'project' - we are showing project versions here, not specific artifact information (though
  81      * that is rendered in the download box).
  82      */
  83     public String artifact()
  84     {
  85         // In the future, this should be replaced by the repository grouping mechanism, so that we are only making
  86         // simple resource requests here and letting the resolver take care of it
  87         ProjectVersionMetadata versionMetadata = null;
  88         snapshotVersions = new ArrayList<String>();
  89         for ( String repoId : getObservableRepos() )
  90         {
  91             if ( versionMetadata == null )
  92             {
  93                 // TODO: though we have a simple mapping now, do we want to support paths like /1.0-20090111.123456-1/
  94                 //   again by mapping it to /1.0-SNAPSHOT/? Currently, the individual versions are not supported as we
  95                 //   are only displaying the project's single version.
  96
  97                 // we don't want the implementation being that intelligent - so another resolver to do the
  98                 // "just-in-time" nature of picking up the metadata (if appropriate for the repository type) is used
  99                 try
 100                 {
 101                     versionMetadata = metadataResolver.getProjectVersion( repoId, groupId, artifactId, version );
 102                 }
 103                 catch ( MetadataResolverException e )
 104                 {
 105                     addActionError( "Error occurred resolving metadata for project: " + e.getMessage() );
 106                     return ERROR;
 107                 }
 108                 if ( versionMetadata != null )
 109                 {
 110                     repositoryId = repoId;
 111
 112                     snapshotVersions.addAll(
 113                         metadataResolver.getArtifactVersions( repoId, groupId, artifactId, versionMetadata.getId() ) );
 114                     snapshotVersions.remove( version );
 115                 }
 116             }
 117         }
 118
 119         if ( versionMetadata == null )
 120         {
 121             addActionError( "Artifact not found" );
 122             return ERROR;
 123         }
 124         model = versionMetadata;
 125
 126         return SUCCESS;
 127     }
 128
 129     /**
 130      * Show the artifact information tab.
 131      */
 132     public String dependencies()
 133     {
 134         ProjectVersionMetadata versionMetadata = null;
 135         for ( String repoId : getObservableRepos() )
 136         {
 137             if ( versionMetadata == null )
 138             {
 139                 try
 140                 {
 141                     versionMetadata = metadataResolver.getProjectVersion( repoId, groupId, artifactId, version );
 142                 }
 143                 catch ( MetadataResolverException e )
 144                 {
 145                     addActionError( "Error occurred resolving metadata for project: " + e.getMessage() );
 146                     return ERROR;
 147                 }
 148             }
 149         }
 150
 151         if ( versionMetadata == null )
 152         {
 153             addActionError( "Artifact not found" );
 154             return ERROR;
 155         }
 156         model = versionMetadata;
 157
 158         this.dependencies = model.getDependencies();
 159
 160         return SUCCESS;
 161     }
 162
 163     /**
 164      * Show the mailing lists information tab.
 165      */
 166     public String mailingLists()
 167     {
 168         ProjectVersionMetadata versionMetadata = null;
 169         for ( String repoId : getObservableRepos() )
 170         {
 171             if ( versionMetadata == null )
 172             {
 173                 try
 174                 {
 175                     versionMetadata = metadataResolver.getProjectVersion( repoId, groupId, artifactId, version );
 176                 }
 177                 catch ( MetadataResolverException e )
 178                 {
 179                     addActionError( "Error occurred resolving metadata for project: " + e.getMessage() );
 180                     return ERROR;
 181                 }
 182             }
 183         }
 184
 185         if ( versionMetadata == null )
 186         {
 187             addActionError( "Artifact not found" );
 188             return ERROR;
 189         }
 190         model = versionMetadata;
 191
 192         this.mailingLists = model.getMailingLists();
 193
 194         return SUCCESS;
 195     }
 196
 197     /**
 198      * Show the reports tab.
 199      */
 200     public String reports()
 201     {
 202         // TODO: hook up reports on project
 203
 204         return SUCCESS;
 205     }
 206
 207     /**
 208      * Show the dependees (other artifacts that depend on this project) tab.
 209      */
 210     public String dependees()
 211     {
 212         ProjectVersionMetadata versionMetadata = null;
 213         for ( String repoId : getObservableRepos() )
 214         {
 215             if ( versionMetadata == null )
 216             {
 217                 try
 218                 {
 219                     versionMetadata = metadataResolver.getProjectVersion( repoId, groupId, artifactId, version );
 220                 }
 221                 catch ( MetadataResolverException e )
 222                 {
 223                     addActionError( "Error occurred resolving metadata for project: " + e.getMessage() );
 224                     return ERROR;
 225                 }
 226             }
 227         }
 228
 229         if ( versionMetadata == null )
 230         {
 231             addActionError( "Artifact not found" );
 232             return ERROR;
 233         }
 234         model = versionMetadata;
 235
 236         List<ProjectVersionReference> references = new ArrayList<ProjectVersionReference>();
 237         // TODO: what if we get duplicates across repositories?
 238         for ( String repoId : getObservableRepos() )
 239         {
 240             // TODO: what about if we want to see this irrespective of version?
 241             references.addAll( metadataResolver.getProjectReferences( repoId, groupId, artifactId, version ) );
 242         }
 243
 244         this.dependees = references;
 245
 246         // TODO: may need to note on the page that references will be incomplete if the other artifacts are not yet stored in the content repository
 247         // (especially in the case of pre-population import)
 248
 249         return SUCCESS;
 250     }
 251
 252     /**
 253      * Show the dependencies of this versioned project tab.
 254      */
 255     public String dependencyTree()
 256     {
 257         // temporarily use this as we only need the model for the tag to perform, but we should be resolving the
 258         // graph here instead
 259
 260         // TODO: may need to note on the page that tree will be incomplete if the other artifacts are not yet stored in the content repository
 261         // (especially in the case of pre-population import)
 262
 263         return artifact();
 264     }
 265
 266     @Override
 267     public void validate()
 268     {
 269         if ( StringUtils.isBlank( groupId ) )
 270         {
 271             addActionError( "You must specify a group ID to browse" );
 272         }
 273
 274         if ( StringUtils.isBlank( artifactId ) )
 275         {
 276             addActionError( "You must specify a artifact ID to browse" );
 277         }
 278
 279         if ( StringUtils.isBlank( version ) )
 280         {
 281             addActionError( "You must specify a version to browse" );
 282         }
 283     }
 284
 285     public ProjectVersionMetadata getModel()
 286     {
 287         return model;
 288     }
 289
 290     public String getGroupId()
 291     {
 292         return groupId;
 293     }
 294
 295     public void setGroupId( String groupId )
 296     {
 297         this.groupId = groupId;
 298     }
 299
 300     public String getArtifactId()
 301     {
 302         return artifactId;
 303     }
 304
 305     public void setArtifactId( String artifactId )
 306     {
 307         this.artifactId = artifactId;
 308     }
 309
 310     public String getVersion()
 311     {
 312         return version;
 313     }
 314
 315     public void setVersion( String version )
 316     {
 317         this.version = version;
 318     }
 319
 320     public List<MailingList> getMailingLists()
 321     {
 322         return mailingLists;
 323     }
 324
 325     public List<Dependency> getDependencies()
 326     {
 327         return dependencies;
 328     }
 329
 330     public List<ProjectVersionReference> getDependees()
 331     {
 332         return dependees;
 333     }
 334
 335     public String getRepositoryId()
 336     {
 337         return repositoryId;
 338     }
 339
 340     public void setRepositoryId( String repositoryId )
 341     {
 342         this.repositoryId = repositoryId;
 343     }
 344
 345     public List<String> getSnapshotVersions()
 346     {
 347         return snapshotVersions;
 348     }
 349
 350     public MetadataResolver getMetadataResolver()
 351     {
 352         return metadataResolver;
 353     }
 354 }