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