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

   1 package org.apache.archiva.web.xmlrpc.services;
   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.Date;
  25 import java.util.List;
  26
  27 import org.apache.archiva.indexer.search.RepositorySearch;
  28 import org.apache.archiva.indexer.search.SearchResultHit;
  29 import org.apache.archiva.indexer.search.SearchResultLimits;
  30 import org.apache.archiva.indexer.search.SearchResults;
  31 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  32 import org.apache.archiva.metadata.model.ProjectVersionReference;
  33 import org.apache.archiva.metadata.repository.MetadataResolver;
  34 import org.apache.archiva.metadata.repository.storage.maven2.MavenProjectFacet;
  35 import org.apache.archiva.web.xmlrpc.api.SearchService;
  36 import org.apache.archiva.web.xmlrpc.api.beans.Artifact;
  37 import org.apache.archiva.web.xmlrpc.api.beans.Dependency;
  38 import org.apache.archiva.web.xmlrpc.security.XmlRpcUserRepositories;
  39 import org.apache.maven.archiva.common.utils.VersionUtil;
  40 import org.apache.maven.archiva.database.ArchivaDAO;
  41 import org.apache.maven.archiva.database.ArtifactDAO;
  42 import org.apache.maven.archiva.database.constraints.ArtifactsByChecksumConstraint;
  43 import org.apache.maven.archiva.database.constraints.UniqueVersionConstraint;
  44 import org.apache.maven.archiva.model.ArchivaArtifact;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 public class SearchServiceImpl
  49     implements SearchService
  50 {
  51     private Logger log = LoggerFactory.getLogger( SearchServiceImpl.class );
  52
  53     private RepositorySearch search;
  54
  55     private XmlRpcUserRepositories xmlRpcUserRepositories;
  56
  57     private ArchivaDAO archivaDAO;
  58
  59     private MetadataResolver metadataResolver;
  60
  61     public SearchServiceImpl( XmlRpcUserRepositories xmlRpcUserRepositories, ArchivaDAO archivaDAO,
  62                               MetadataResolver metadataResolver, RepositorySearch search )
  63     {
  64         this.xmlRpcUserRepositories = xmlRpcUserRepositories;
  65         this.archivaDAO = archivaDAO;
  66         this.search = search;
  67         this.metadataResolver = metadataResolver;
  68     }
  69
  70     @SuppressWarnings("unchecked")
  71     public List<Artifact> quickSearch( String queryString )
  72         throws Exception
  73     {
  74         List<Artifact> artifacts = new ArrayList<Artifact>();
  75         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
  76         SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
  77         SearchResults results = null;
  78
  79         results = search.search( "", observableRepos, queryString, limits, null );
  80
  81         for ( SearchResultHit resultHit : results.getHits() )
  82         {
  83             // double-check all versions as done in SearchAction
  84             final List<String> versions = (List<String>) archivaDAO.query(
  85                 new UniqueVersionConstraint( observableRepos, resultHit.getGroupId(), resultHit.getArtifactId() ) );
  86             if ( versions != null && !versions.isEmpty() )
  87             {
  88                 resultHit.setVersion( null );
  89                 resultHit.setVersions( filterTimestampedSnapshots( versions ) );
  90             }
  91
  92             List<String> resultHitVersions = resultHit.getVersions();
  93             if ( resultHitVersions != null )
  94             {
  95                 for ( String version : resultHitVersions )
  96                 {
  97                     Artifact artifact = null;
  98                     for ( String repoId : observableRepos )
  99                     {
 100                         // slight behaviour change to previous implementation: instead of allocating "jar" when not
 101                         // found in the database, we can rely on the metadata repository to create it on the fly. We
 102                         // just allocate the default packaging if the Maven facet is not found.
 103                         ProjectVersionMetadata model =
 104                             metadataResolver.getProjectVersion( repoId, resultHit.getGroupId(),
 105                                                                 resultHit.getArtifactId(), version );
 106
 107                         if ( model != null )
 108                         {
 109                             String packaging = "jar";
 110
 111                             MavenProjectFacet facet = (MavenProjectFacet) model.getFacet( MavenProjectFacet.FACET_ID );
 112                             if ( facet != null && facet.getPackaging() != null )
 113                             {
 114                                 packaging = facet.getPackaging();
 115                             }
 116                             artifact = new Artifact( repoId, resultHit.getGroupId(), resultHit.getArtifactId(), version,
 117                                                      packaging );
 118                             break;
 119                         }
 120                     }
 121
 122                     if ( artifact != null )
 123                     {
 124                         artifacts.add( artifact );
 125                     }
 126                 }
 127             }
 128         }
 129
 130         return artifacts;
 131     }
 132
 133     /**
 134      * Remove timestamped snapshots from versions
 135      */
 136     private static List<String> filterTimestampedSnapshots( List<String> versions )
 137     {
 138         final List<String> filtered = new ArrayList<String>();
 139         for ( final String version : versions )
 140         {
 141             final String baseVersion = VersionUtil.getBaseVersion( version );
 142             if ( !filtered.contains( baseVersion ) )
 143             {
 144                 filtered.add( baseVersion );
 145             }
 146         }
 147         return filtered;
 148     }
 149
 150     public List<Artifact> getArtifactByChecksum( String checksum )
 151         throws Exception
 152     {
 153         // 1. get ArtifactDAO from ArchivaDAO
 154         // 2. create ArtifactsByChecksumConstraint( "queryTerm" )
 155         // 3. query artifacts using constraint
 156         // 4. convert results to list of Artifact objects
 157
 158         List<Artifact> results = new ArrayList<Artifact>();
 159         ArtifactDAO artifactDAO = archivaDAO.getArtifactDAO();
 160
 161         ArtifactsByChecksumConstraint constraint = new ArtifactsByChecksumConstraint( checksum );
 162         List<ArchivaArtifact> artifacts = artifactDAO.queryArtifacts( constraint );
 163
 164         for ( ArchivaArtifact archivaArtifact : artifacts )
 165         {
 166             Artifact artifact =
 167                 new Artifact( archivaArtifact.getModel().getRepositoryId(), archivaArtifact.getModel().getGroupId(),
 168                               archivaArtifact.getModel().getArtifactId(), archivaArtifact.getModel().getVersion(),
 169                               archivaArtifact.getType() );
 170             //archivaArtifact.getModel().getWhenGathered() );
 171             results.add( artifact );
 172         }
 173
 174         return results;
 175     }
 176
 177     public List<Artifact> getArtifactVersions( String groupId, String artifactId )
 178         throws Exception
 179     {
 180         List<Artifact> artifacts = new ArrayList<Artifact>();
 181         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
 182
 183         for ( String repoId : observableRepos )
 184         {
 185             Collection<String> results = metadataResolver.getProjectVersions( repoId, groupId, artifactId );
 186
 187             for ( final String version : results )
 188             {
 189                 final Artifact artifact = new Artifact( repoId, groupId, artifactId, version, "pom" );
 190
 191                 artifacts.add( artifact );
 192             }
 193         }
 194
 195         return artifacts;
 196     }
 197
 198     public List<Artifact> getArtifactVersionsByDate( String groupId, String artifactId, String version, Date since )
 199         throws Exception
 200     {
 201         List<Artifact> artifacts = new ArrayList<Artifact>();
 202
 203         // 1. get observable repositories
 204         // 2. use RepositoryBrowsing method to query uniqueVersions? (but with date)
 205
 206         throw new UnsupportedOperationException( "getArtifactVersionsByDate not yet implemented" );
 207
 208 //        return artifacts;
 209     }
 210
 211     public List<Dependency> getDependencies( String groupId, String artifactId, String version )
 212         throws Exception
 213     {
 214         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
 215
 216         for ( String repoId : observableRepos )
 217         {
 218             ProjectVersionMetadata model = metadataResolver.getProjectVersion( repoId, groupId, artifactId, version );
 219             if ( model != null )
 220             {
 221                 List<Dependency> dependencies = new ArrayList<Dependency>();
 222                 List<org.apache.archiva.metadata.model.Dependency> modelDeps = model.getDependencies();
 223                 for ( org.apache.archiva.metadata.model.Dependency dep : modelDeps )
 224                 {
 225                     Dependency dependency =
 226                         new Dependency( dep.getGroupId(), dep.getArtifactId(), dep.getVersion(), dep.getClassifier(),
 227                                         dep.getType(), dep.getScope() );
 228                     dependencies.add( dependency );
 229                 }
 230                 return dependencies;
 231             }
 232         }
 233         throw new Exception( "Artifact does not exist." );
 234     }
 235
 236     public List<Artifact> getDependencyTree( String groupId, String artifactId, String version )
 237         throws Exception
 238     {
 239         List<Artifact> a = new ArrayList<Artifact>();
 240
 241         throw new UnsupportedOperationException( "getDependencyTree not yet implemented" );
 242 //        return a;
 243     }
 244
 245     public List<Artifact> getDependees( String groupId, String artifactId, String version )
 246         throws Exception
 247     {
 248         List<Artifact> artifacts = new ArrayList<Artifact>();
 249         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
 250
 251         for ( String repoId : observableRepos )
 252         {
 253             Collection<ProjectVersionReference> refs =
 254                 metadataResolver.getProjectReferences( repoId, groupId, artifactId, version );
 255             for ( ProjectVersionReference ref : refs )
 256             {
 257                 artifacts.add(
 258                     new Artifact( repoId, ref.getNamespace(), ref.getProjectId(), ref.getProjectVersion(), "" ) );
 259             }
 260         }
 261
 262         return artifacts;
 263     }
 264 }