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

   1 package org.apache.archiva.rest.services;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  *   http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import net.sf.beanlib.provider.replicator.BeanReplicator;
  22 import org.apache.archiva.indexer.search.RepositorySearch;
  23 import org.apache.archiva.indexer.search.RepositorySearchException;
  24 import org.apache.archiva.indexer.search.SearchFields;
  25 import org.apache.archiva.indexer.search.SearchResultHit;
  26 import org.apache.archiva.indexer.search.SearchResultLimits;
  27 import org.apache.archiva.indexer.search.SearchResults;
  28 import org.apache.archiva.rest.api.model.Artifact;
  29 import org.apache.archiva.rest.api.model.Dependency;
  30 import org.apache.archiva.rest.api.model.GroupIdList;
  31 import org.apache.archiva.rest.api.model.SearchRequest;
  32 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  33 import org.apache.archiva.rest.api.services.SearchService;
  34 import org.apache.archiva.rest.services.interceptors.HttpContext;
  35 import org.apache.archiva.rest.services.interceptors.HttpContextThreadLocal;
  36 import org.apache.archiva.security.AccessDeniedException;
  37 import org.apache.archiva.security.ArchivaSecurityException;
  38 import org.apache.archiva.security.PrincipalNotFoundException;
  39 import org.apache.archiva.security.UserRepositories;
  40 import org.apache.commons.collections.ListUtils;
  41 import org.apache.commons.lang.StringUtils;
  42 import org.codehaus.plexus.redback.users.UserManager;
  43 import org.codehaus.redback.rest.services.RedbackAuthenticationThreadLocal;
  44 import org.codehaus.redback.rest.services.RedbackRequestInformation;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47 import org.springframework.stereotype.Service;
  48
  49 import javax.inject.Inject;
  50 import javax.servlet.http.HttpServletRequest;
  51 import java.util.ArrayList;
  52 import java.util.Collection;
  53 import java.util.Collections;
  54 import java.util.List;
  55
  56 /**
  57  * @author Olivier Lamy
  58  */
  59 @Service( "searchService#rest" )
  60 public class DefaultSearchService
  61     implements SearchService
  62 {
  63
  64     private Logger log = LoggerFactory.getLogger( getClass() );
  65
  66     @Inject
  67     private RepositorySearch repositorySearch;
  68
  69     @Inject
  70     private UserRepositories userRepositories;
  71
  72     public List<Artifact> quickSearch( String queryString )
  73         throws ArchivaRestServiceException
  74     {
  75         if ( StringUtils.isBlank( queryString ) )
  76         {
  77             return Collections.emptyList();
  78         }
  79
  80         SearchResultLimits limits = new SearchResultLimits( 0 );
  81         List<String> observableRepoIds = getObservableRepos();
  82         try
  83         {
  84             SearchResults searchResults =
  85                 repositorySearch.search( getPrincipal(), getObservableRepos(), queryString, limits,
  86                                          Collections.<String>emptyList() );
  87             return getArtifacts( searchResults );
  88
  89         }
  90         catch ( RepositorySearchException e )
  91         {
  92             log.error( e.getMessage(), e );
  93             throw new ArchivaRestServiceException( e.getMessage() );
  94         }
  95     }
  96
  97     public List<Artifact> getArtifactVersions( String groupId, String artifactId, String packaging )
  98         throws ArchivaRestServiceException
  99     {
 100         if ( StringUtils.isBlank( groupId ) || StringUtils.isBlank( artifactId ) )
 101         {
 102             return Collections.emptyList();
 103         }
 104         SearchFields searchField = new SearchFields();
 105         searchField.setGroupId( groupId );
 106         searchField.setArtifactId( artifactId );
 107         searchField.setPackaging( StringUtils.isBlank( packaging ) ? "jar" : packaging );
 108         searchField.setRepositories( getObservableRepos() );
 109
 110         try
 111         {
 112             SearchResults searchResults = repositorySearch.search( getPrincipal(), searchField, null );
 113             return getArtifacts( searchResults );
 114         }
 115         catch ( RepositorySearchException e )
 116         {
 117             log.error( e.getMessage(), e );
 118             throw new ArchivaRestServiceException( e.getMessage() );
 119         }
 120     }
 121
 122     public List<Artifact> searchArtifacts( SearchRequest searchRequest )
 123         throws ArchivaRestServiceException
 124     {
 125         if ( searchRequest == null )
 126         {
 127             return Collections.emptyList();
 128         }
 129         SearchFields searchField = new BeanReplicator().replicateBean( searchRequest, SearchFields.class );
 130         SearchResultLimits limits = new SearchResultLimits( 0 );
 131
 132         try
 133         {
 134             SearchResults searchResults = repositorySearch.search( getPrincipal(), searchField, limits );
 135             return getArtifacts( searchResults );
 136         }
 137         catch ( RepositorySearchException e )
 138         {
 139             log.error( e.getMessage(), e );
 140             throw new ArchivaRestServiceException( e.getMessage() );
 141         }
 142     }
 143
 144     public GroupIdList getAllGroupIds(List<String> selectedRepos)
 145         throws ArchivaRestServiceException
 146     {
 147         List<String> observableRepos = getObservableRepos();
 148         List<String> repos = ListUtils.intersection( observableRepos, selectedRepos );
 149         if (repos == null || repos.isEmpty())
 150         {
 151             return new GroupIdList( Collections.<String>emptyList() );
 152         }
 153         try
 154         {
 155             return new GroupIdList( new ArrayList<String>( repositorySearch.getAllGroupIds( getPrincipal(), repos  ) ) );
 156         }
 157         catch ( RepositorySearchException e )
 158         {
 159             log.error( e.getMessage(), e );
 160             throw new ArchivaRestServiceException( e.getMessage() );
 161         }
 162
 163     }
 164
 165     public List<Dependency> getDependencies( String groupId, String artifactId, String version )
 166         throws ArchivaRestServiceException
 167     {
 168         return null;  //To change body of implemented methods use File | Settings | File Templates.
 169     }
 170
 171     public List<Artifact> getArtifactByChecksum( String checksum )
 172         throws ArchivaRestServiceException
 173     {
 174         return null;  //To change body of implemented methods use File | Settings | File Templates.
 175     }
 176
 177
 178     protected List<String> getObservableRepos()
 179     {
 180         try
 181         {
 182             List<String> ids = userRepositories.getObservableRepositoryIds( getPrincipal() );
 183             return ids == null ? Collections.<String>emptyList() : ids;
 184         }
 185         catch ( PrincipalNotFoundException e )
 186         {
 187             log.warn( e.getMessage(), e );
 188         }
 189         catch ( AccessDeniedException e )
 190         {
 191             log.warn( e.getMessage(), e );
 192         }
 193         catch ( ArchivaSecurityException e )
 194         {
 195             log.warn( e.getMessage(), e );
 196         }
 197         return Collections.emptyList();
 198     }
 199
 200     protected String getPrincipal()
 201     {
 202         RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
 203
 204         return redbackRequestInformation == null
 205             ? UserManager.GUEST_USERNAME
 206             : ( redbackRequestInformation.getUser() == null
 207                 ? UserManager.GUEST_USERNAME
 208                 : redbackRequestInformation.getUser().getUsername() );
 209     }
 210
 211     protected List<Artifact> getArtifacts( SearchResults searchResults )
 212     {
 213
 214         HttpContext httpContext = HttpContextThreadLocal.get();
 215         if ( searchResults == null || searchResults.isEmpty() )
 216         {
 217             return Collections.emptyList();
 218         }
 219         List<Artifact> artifacts = new ArrayList<Artifact>( searchResults.getReturnedHitsCount() );
 220         for ( SearchResultHit hit : searchResults.getHits() )
 221         {
 222             // duplicate Artifact one per available version
 223             if ( hit.getVersions().size() > 0 )
 224             {
 225                 for ( String version : hit.getVersions() )
 226                 {
 227                     /*
 228                     Artifact versionned = new Artifact(  );
 229                     versionned.setArtifactId( hit.getArtifactId());
 230                     versionned.setGroupId( hit.getGroupId() );
 231                     versionned.setRepositoryId(hit.getRepositoryId() );
 232
 233
 234                     versionned.setBundleExportPackage( hit.getBundleExportPackage() );
 235                     versionned.setBundleExportService( hit.getBundleExportService());
 236                     versionned.setBundleSymbolicName(hit.getBundleSymbolicName() );
 237                     versionned.setBundleVersion( artifactInfo.bundleVersion );
 238                     versionned.setBundleDescription( artifactInfo.bundleDescription );
 239                     versionned.setBundleDocUrl( artifactInfo.bundleDocUrl );
 240
 241                     versionned.setBundleRequireBundle( artifactInfo.bundleRequireBundle );
 242                     versionned.setBundleImportPackage( artifactInfo.bundleImportPackage );
 243                     versionned.setBundleLicense( artifactInfo.bundleLicense );
 244                     versionned.setBundleName( artifactInfo.bundleName );
 245                     versionned.setContext( artifactInfo.context );
 246                     versionned.setGoals( artifactInfo.goals );
 247                     versionned.setPrefix( artifactInfo.prefix );
 248                     // sure ??
 249                     versionned.setUrl( artifactInfo.remoteUrl );
 250                     */
 251                     // FIXME archiva url ??
 252
 253                     Artifact versionned = new BeanReplicator().replicateBean( hit, Artifact.class );
 254
 255                     if ( StringUtils.isNotBlank( version ) )
 256                     {
 257                         versionned.setVersion( version );
 258                         versionned.setUrl( getArtifactUrl( httpContext, versionned ) );
 259
 260                         artifacts.add( versionned );
 261
 262                     }
 263                 }
 264             }
 265         }
 266         return artifacts;
 267     }
 268
 269     private String getArtifactUrl( HttpContext httpContext, Artifact artifact )
 270     {
 271         if ( httpContext == null )
 272         {
 273             return null;
 274         }
 275         if ( httpContext.getHttpServletRequest() == null )
 276         {
 277             return null;
 278         }
 279         if ( StringUtils.isEmpty( artifact.getUrl() ) )
 280         {
 281             return null;
 282         }
 283         StringBuilder sb = new StringBuilder( getBaseUrl( httpContext.getHttpServletRequest() ) );
 284
 285         sb.append( "/repository" );
 286         if ( !StringUtils.startsWith( artifact.getUrl(), "/" ) )
 287         {
 288             sb.append( '/' );
 289         }
 290         sb.append( artifact.getUrl() );
 291         return sb.toString();
 292     }
 293
 294     protected String getBaseUrl( HttpServletRequest req )
 295     {
 296         return req.getScheme() + "://" + req.getServerName()
 297             + ( req.getServerPort() == 80 ? "" : ":" + req.getServerPort() ) + req.getContextPath();
 298     }
 299 }