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

   1 package org.apache.archiva.rest.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 net.sf.beanlib.provider.replicator.BeanReplicator;
  23 import org.apache.archiva.admin.model.RepositoryAdminException;
  24 import org.apache.archiva.indexer.search.RepositorySearch;
  25 import org.apache.archiva.indexer.search.RepositorySearchException;
  26 import org.apache.archiva.indexer.search.SearchFields;
  27 import org.apache.archiva.indexer.search.SearchResultHit;
  28 import org.apache.archiva.indexer.search.SearchResultLimits;
  29 import org.apache.archiva.indexer.search.SearchResults;
  30 import org.apache.archiva.rest.api.model.Artifact;
  31 import org.apache.archiva.rest.api.model.Dependency;
  32 import org.apache.archiva.rest.api.model.GroupIdList;
  33 import org.apache.archiva.rest.api.model.SearchRequest;
  34 import org.apache.archiva.rest.api.model.StringList;
  35 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  36 import org.apache.archiva.rest.api.services.SearchService;
  37 import org.apache.commons.collections.ListUtils;
  38 import org.apache.commons.lang.StringUtils;
  39 import org.springframework.stereotype.Service;
  40
  41 import javax.inject.Inject;
  42 import javax.ws.rs.core.Response;
  43 import java.util.ArrayList;
  44 import java.util.Collections;
  45 import java.util.List;
  46
  47 /**
  48  * @author Olivier Lamy
  49  */
  50 @Service( "searchService#rest" )
  51 public class DefaultSearchService
  52     extends AbstractRestService
  53     implements SearchService
  54 {
  55
  56     @Inject
  57     private RepositorySearch repositorySearch;
  58
  59     public List<Artifact> quickSearch( String queryString )
  60         throws ArchivaRestServiceException
  61     {
  62         if ( StringUtils.isBlank( queryString ) )
  63         {
  64             return Collections.emptyList();
  65         }
  66
  67         SearchResultLimits limits = new SearchResultLimits( 0 );
  68         try
  69         {
  70             SearchResults searchResults =
  71                 repositorySearch.search( getPrincipal(), getObservableRepos(), queryString, limits,
  72                                          Collections.<String>emptyList() );
  73             return getArtifacts( searchResults );
  74
  75         }
  76         catch ( RepositorySearchException e )
  77         {
  78             log.error( e.getMessage(), e );
  79             throw new ArchivaRestServiceException( e.getMessage(), e );
  80         }
  81     }
  82
  83     public List<Artifact> quickSearchWithRepositories( SearchRequest searchRequest )
  84         throws ArchivaRestServiceException
  85     {
  86         String queryString = searchRequest.getQueryTerms();
  87         if ( StringUtils.isBlank( queryString ) )
  88         {
  89             return Collections.emptyList();
  90         }
  91         List<String> repositories = searchRequest.getRepositories();
  92         if ( repositories == null || repositories.isEmpty() )
  93         {
  94             repositories = getObservableRepos();
  95         }
  96         SearchResultLimits limits = new SearchResultLimits( 0 );
  97         try
  98         {
  99             SearchResults searchResults = repositorySearch.search( getPrincipal(), repositories, queryString, limits,
 100                                                                    Collections.<String>emptyList() );
 101             return getArtifacts( searchResults );
 102
 103         }
 104         catch ( RepositorySearchException e )
 105         {
 106             log.error( e.getMessage(), e );
 107             throw new ArchivaRestServiceException( e.getMessage(), e );
 108         }
 109     }
 110
 111     public List<Artifact> getArtifactVersions( String groupId, String artifactId, String packaging )
 112         throws ArchivaRestServiceException
 113     {
 114         if ( StringUtils.isBlank( groupId ) || StringUtils.isBlank( artifactId ) )
 115         {
 116             return Collections.emptyList();
 117         }
 118         SearchFields searchField = new SearchFields();
 119         searchField.setGroupId( groupId );
 120         searchField.setArtifactId( artifactId );
 121         searchField.setPackaging( StringUtils.isBlank( packaging ) ? "jar" : packaging );
 122         searchField.setRepositories( getObservableRepos() );
 123
 124         try
 125         {
 126             SearchResults searchResults = repositorySearch.search( getPrincipal(), searchField, null );
 127             return getArtifacts( searchResults );
 128         }
 129         catch ( RepositorySearchException e )
 130         {
 131             log.error( e.getMessage(), e );
 132             throw new ArchivaRestServiceException( e.getMessage(), e );
 133         }
 134     }
 135
 136     public List<Artifact> searchArtifacts( SearchRequest searchRequest )
 137         throws ArchivaRestServiceException
 138     {
 139         if ( searchRequest == null )
 140         {
 141             return Collections.emptyList();
 142         }
 143         SearchFields searchField = new BeanReplicator().replicateBean( searchRequest, SearchFields.class );
 144         SearchResultLimits limits = new SearchResultLimits( 0 );
 145
 146         // if no repos set we use ones available for the user
 147         if ( searchField.getRepositories() == null || searchField.getRepositories().isEmpty() )
 148         {
 149             searchField.setRepositories( getObservableRepos() );
 150         }
 151
 152         try
 153         {
 154             SearchResults searchResults = repositorySearch.search( getPrincipal(), searchField, limits );
 155             return getArtifacts( searchResults );
 156         }
 157         catch ( RepositorySearchException e )
 158         {
 159             log.error( e.getMessage(), e );
 160             throw new ArchivaRestServiceException( e.getMessage(), e );
 161         }
 162     }
 163
 164     public GroupIdList getAllGroupIds( List<String> selectedRepos )
 165         throws ArchivaRestServiceException
 166     {
 167         List<String> observableRepos = getObservableRepos();
 168         List<String> repos = ListUtils.intersection( observableRepos, selectedRepos );
 169         if ( repos == null || repos.isEmpty() )
 170         {
 171             return new GroupIdList( Collections.<String>emptyList() );
 172         }
 173         try
 174         {
 175             return new GroupIdList( new ArrayList<String>( repositorySearch.getAllGroupIds( getPrincipal(), repos ) ) );
 176         }
 177         catch ( RepositorySearchException e )
 178         {
 179             log.error( e.getMessage(), e );
 180             throw new ArchivaRestServiceException( e.getMessage(), e );
 181         }
 182
 183     }
 184
 185     public List<Dependency> getDependencies( String groupId, String artifactId, String version )
 186         throws ArchivaRestServiceException
 187     {
 188         return null;  //To change body of implemented methods use File | Settings | File Templates.
 189     }
 190
 191     public List<Artifact> getArtifactByChecksum( String checksum )
 192         throws ArchivaRestServiceException
 193     {
 194         return null;  //To change body of implemented methods use File | Settings | File Templates.
 195     }
 196
 197     public StringList getObservablesRepoIds()
 198         throws ArchivaRestServiceException
 199     {
 200         return new StringList( getObservableRepos() );
 201     }
 202
 203     //-------------------------------------
 204     // internal
 205     //-------------------------------------
 206     protected List<Artifact> getArtifacts( SearchResults searchResults )
 207         throws ArchivaRestServiceException
 208     {
 209
 210         if ( searchResults == null || searchResults.isEmpty() )
 211         {
 212             return Collections.emptyList();
 213         }
 214         List<Artifact> artifacts = new ArrayList<Artifact>( searchResults.getReturnedHitsCount() );
 215         for ( SearchResultHit hit : searchResults.getHits() )
 216         {
 217             // duplicate Artifact one per available version
 218             if ( hit.getVersions().size() > 0 )
 219             {
 220                 for ( String version : hit.getVersions() )
 221                 {
 222
 223                     Artifact versionned = new BeanReplicator().replicateBean( hit, Artifact.class );
 224
 225                     if ( StringUtils.isNotBlank( version ) )
 226                     {
 227                         versionned.setVersion( version );
 228                         versionned.setUrl( getArtifactUrl( versionned, version ) );
 229
 230                         artifacts.add( versionned );
 231
 232                     }
 233                 }
 234             }
 235         }
 236         return artifacts;
 237     }
 238
 239
 240
 241
 242 }