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.Date;
  24 import java.util.List;
  25
  26 import org.apache.archiva.indexer.search.RepositorySearch;
  27 import org.apache.archiva.web.xmlrpc.api.SearchService;
  28 import org.apache.archiva.web.xmlrpc.api.beans.Artifact;
  29 import org.apache.archiva.web.xmlrpc.api.beans.Dependency;
  30 import org.apache.archiva.web.xmlrpc.security.XmlRpcUserRepositories;
  31 import org.apache.maven.archiva.database.ArchivaDAO;
  32 import org.apache.maven.archiva.database.ArchivaDatabaseException;
  33 import org.apache.maven.archiva.database.ArtifactDAO;
  34 import org.apache.maven.archiva.database.ObjectNotFoundException;
  35 import org.apache.maven.archiva.database.browsing.BrowsingResults;
  36 import org.apache.maven.archiva.database.browsing.RepositoryBrowsing;
  37 import org.apache.maven.archiva.database.constraints.ArtifactsByChecksumConstraint;
  38 import org.apache.maven.archiva.indexer.search.SearchResultHit;
  39 import org.apache.maven.archiva.indexer.search.SearchResultLimits;
  40 import org.apache.maven.archiva.indexer.search.SearchResults;
  41 import org.apache.maven.archiva.model.ArchivaArtifact;
  42 import org.apache.maven.archiva.model.ArchivaProjectModel;
  43
  44 /**
  45  * SearchServiceImpl
  46  *
  47  * @version $Id: SearchServiceImpl.java
  48  */
  49 public class SearchServiceImpl
  50     implements SearchService
  51 {
  52     private RepositorySearch search;
  53
  54     private XmlRpcUserRepositories xmlRpcUserRepositories;
  55
  56     private ArchivaDAO archivaDAO;
  57
  58     private RepositoryBrowsing repoBrowsing;
  59
  60     public SearchServiceImpl( XmlRpcUserRepositories xmlRpcUserRepositories, ArchivaDAO archivaDAO,
  61                               RepositoryBrowsing repoBrowsing, RepositorySearch search )
  62     {
  63         this.xmlRpcUserRepositories = xmlRpcUserRepositories;
  64         this.archivaDAO = archivaDAO;
  65         this.repoBrowsing = repoBrowsing;
  66         this.search = search;
  67     }
  68
  69     /*
  70      * quick/general text search which returns a list of artifacts
  71      * query for an artifact based on a checksum
  72      * query for all available versions of an artifact, sorted in version significance order
  73      * query for all available versions of an artifact since a given date
  74      * query for an artifact's direct dependencies
  75      * query for an artifact's dependency tree (as with mvn dependency:tree - no duplicates should be included)
  76      * query for all artifacts that depend on a given artifact
  77      */
  78
  79     public List<Artifact> quickSearch( String queryString )
  80         throws Exception
  81     {
  82         // 1. check whether bytecode search or ordinary search
  83         // 2. get observable repos
  84         // 3. convert results to a list of Artifact objects
  85
  86         List<Artifact> artifacts = new ArrayList<Artifact>();
  87         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
  88         SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
  89         SearchResults results = null;
  90
  91         results = search.search( "", observableRepos, queryString, limits, null );
  92
  93         List<SearchResultHit> hits = results.getHits();
  94         for( SearchResultHit hit : hits )
  95         {
  96             ArtifactDAO artifactDAO = archivaDAO.getArtifactDAO();
  97             try
  98             {
  99                 ArchivaArtifact pomArtifact = artifactDAO.getArtifact(
 100                            hit.getGroupId(), hit.getArtifactId(), hit.getVersion(), "", "pom", hit.getRepositoryId() );
 101
 102                 if( pomArtifact != null )
 103                 {
 104                     Artifact artifact = new Artifact( pomArtifact.getModel().getRepositoryId(), pomArtifact.getGroupId(), pomArtifact.getArtifactId(), pomArtifact.getVersion(),
 105                                                       pomArtifact.getType() );
 106                                                       //pomArtifact.getType(), pomArtifact.getModel().getWhenGathered() );
 107                     artifacts.add( artifact );
 108                 }
 109                 else
 110                 {
 111                     continue;
 112                 }
 113             }
 114             catch ( ObjectNotFoundException e )
 115             {
 116                 continue;
 117             }
 118             catch ( ArchivaDatabaseException e )
 119             {
 120                 continue;
 121             }
 122         }
 123
 124         return artifacts;
 125     }
 126
 127     public List<Artifact> getArtifactByChecksum( String checksum )
 128         throws Exception
 129     {
 130         // 1. get ArtifactDAO from ArchivaDAO
 131         // 2. create ArtifactsByChecksumConstraint( "queryTerm" )
 132         // 3. query artifacts using constraint
 133         // 4. convert results to list of Artifact objects
 134
 135         List<Artifact> results = new ArrayList<Artifact>();
 136         ArtifactDAO artifactDAO = archivaDAO.getArtifactDAO();
 137
 138         ArtifactsByChecksumConstraint constraint = new ArtifactsByChecksumConstraint( checksum );
 139         List<ArchivaArtifact> artifacts = artifactDAO.queryArtifacts( constraint );
 140
 141         for( ArchivaArtifact archivaArtifact : artifacts )
 142         {
 143             Artifact artifact = new Artifact( archivaArtifact.getModel().getRepositoryId(), archivaArtifact.getModel().getGroupId(),
 144                           archivaArtifact.getModel().getArtifactId(), archivaArtifact.getModel().getVersion(), archivaArtifact.getType() );
 145                           //archivaArtifact.getModel().getWhenGathered() );
 146             results.add( artifact );
 147         }
 148
 149         return results;
 150     }
 151
 152     public List<Artifact> getArtifactVersions( String groupId, String artifactId )
 153         throws Exception
 154     {
 155         final List<Artifact> artifacts = new ArrayList<Artifact>();
 156         final List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
 157
 158         final BrowsingResults results = repoBrowsing.selectArtifactId( "", observableRepos, groupId, artifactId );
 159         final ArtifactDAO artifactDAO = archivaDAO.getArtifactDAO();
 160
 161         for( final String version : results.getVersions() )
 162         {
 163             final Artifact artifact = new Artifact( "", groupId, artifactId, version, "pom" );
 164             //ArchivaArtifact pomArtifact = artifactDAO.getArtifact( groupId, artifactId, version, "", "pom",  );
 165             //Artifact artifact = new Artifact( "", groupId, artifactId, version, pomArtifact.getType() );
 166                           //pomArtifact.getModel().getWhenGathered() );
 167
 168             artifacts.add( artifact );
 169         }
 170
 171         // 1. get observable repositories
 172         // 2. use RepositoryBrowsing method to query uniqueVersions?
 173         return artifacts;
 174     }
 175
 176     public List<Artifact> getArtifactVersionsByDate( String groupId, String artifactId, String version, Date since )
 177         throws Exception
 178     {
 179         List<Artifact> artifacts = new ArrayList<Artifact>();
 180
 181         // 1. get observable repositories
 182         // 2. use RepositoryBrowsing method to query uniqueVersions? (but with date)
 183
 184         return artifacts;
 185     }
 186
 187     public List<Dependency> getDependencies( String groupId, String artifactId, String version )
 188         throws Exception
 189     {
 190         List<Dependency> dependencies = new ArrayList<Dependency>();
 191         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
 192
 193         try
 194         {
 195             ArchivaProjectModel model = repoBrowsing.selectVersion( "", observableRepos, groupId, artifactId, version );
 196             List<org.apache.maven.archiva.model.Dependency> modelDeps = model.getDependencies();
 197             for( org.apache.maven.archiva.model.Dependency dep : modelDeps )
 198             {
 199                 Dependency dependency = new Dependency(
 200                     dep.getGroupId(), dep.getArtifactId(), dep.getVersion(), dep.getClassifier(), dep.getType(), dep.getScope() );
 201                 dependencies.add( dependency );
 202             }
 203         }
 204         catch ( ObjectNotFoundException oe )
 205         {
 206             throw new Exception( "Artifact does not exist." );
 207         }
 208
 209         return dependencies;
 210     }
 211
 212     public List<Artifact> getDependencyTree( String groupId, String artifactId, String version )
 213         throws Exception
 214     {
 215         List<Artifact> a = new ArrayList<Artifact>();
 216
 217         return a;
 218     }
 219
 220   //get artifacts that depend on a given artifact
 221     public List<Artifact> getDependees( String groupId, String artifactId, String version )
 222         throws Exception
 223     {
 224         List<Artifact> artifacts = new ArrayList<Artifact>();
 225         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
 226
 227         List<ArchivaProjectModel> dependees = repoBrowsing.getUsedBy( "", observableRepos, "org.apache.archiva", "archiva-test", "1.0" );
 228         for( ArchivaProjectModel model : dependees )
 229         {
 230             Artifact artifact =
 231                 new Artifact( "", model.getGroupId(), model.getArtifactId(), model.getVersion(), "" );
 232                               //model.getWhenIndexed() );
 233             artifacts.add( artifact );
 234         }
 235
 236         return artifacts;
 237     }
 238 }