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 org.apache.archiva.admin.model.RepositoryAdminException;
  22 import org.apache.archiva.admin.model.admin.ArchivaAdministration;
  23 import org.apache.archiva.admin.model.beans.FileType;
  24 import org.apache.archiva.admin.model.beans.LegacyArtifactPath;
  25 import org.apache.archiva.admin.model.beans.NetworkConfiguration;
  26 import org.apache.archiva.admin.model.beans.OrganisationInformation;
  27 import org.apache.archiva.admin.model.beans.UiConfiguration;
  28 import org.apache.archiva.model.ArtifactReference;
  29 import org.apache.archiva.repository.ManagedRepositoryContent;
  30 import org.apache.archiva.repository.scanner.RepositoryContentConsumers;
  31 import org.apache.archiva.rest.api.model.AdminRepositoryConsumer;
  32 import org.apache.archiva.rest.api.services.ArchivaAdministrationService;
  33 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  34 import org.apache.archiva.rest.services.utils.AddAdminRepoConsumerClosure;
  35 import org.apache.archiva.rest.services.utils.AdminRepositoryConsumerComparator;
  36 import org.apache.commons.collections.CollectionUtils;
  37 import org.apache.commons.lang.StringUtils;
  38 import org.springframework.stereotype.Service;
  39
  40 import javax.inject.Inject;
  41 import javax.inject.Named;
  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  * @since 1.4-M1
  50  */
  51 @Service ( "archivaAdministrationService#default" )
  52 public class DefaultArchivaAdministrationService
  53     extends AbstractRestService
  54     implements ArchivaAdministrationService
  55 {
  56     @Inject
  57     private ArchivaAdministration archivaAdministration;
  58
  59     @Inject
  60     @Named ( value = "managedRepositoryContent#legacy" )
  61     private ManagedRepositoryContent repositoryContent;
  62
  63     @Inject
  64     private RepositoryContentConsumers repoConsumerUtil;
  65
  66     @Override
  67     public List<LegacyArtifactPath> getLegacyArtifactPaths()
  68         throws ArchivaRestServiceException
  69     {
  70         try
  71         {
  72             return archivaAdministration.getLegacyArtifactPaths();
  73         }
  74         catch ( RepositoryAdminException e )
  75         {
  76             throw new ArchivaRestServiceException( e.getMessage(), e );
  77         }
  78     }
  79
  80     @Override
  81     public void addLegacyArtifactPath( LegacyArtifactPath legacyArtifactPath )
  82         throws ArchivaRestServiceException
  83     {
  84
  85         // Check the proposed Artifact matches the path
  86         ArtifactReference artifact = new ArtifactReference();
  87
  88         artifact.setGroupId( legacyArtifactPath.getGroupId() );
  89         artifact.setArtifactId( legacyArtifactPath.getArtifactId() );
  90         artifact.setClassifier( legacyArtifactPath.getClassifier() );
  91         artifact.setVersion( legacyArtifactPath.getVersion() );
  92         artifact.setType( legacyArtifactPath.getType() );
  93         String path = repositoryContent.toPath( artifact );
  94         if ( !StringUtils.equals( path, legacyArtifactPath.getPath() ) )
  95         {
  96             throw new ArchivaRestServiceException(
  97                 "artifact path reference '" + legacyArtifactPath.getPath() + "' does not match the initial path: '"
  98                     + path + "'", Response.Status.BAD_REQUEST.getStatusCode(), null );
  99         }
 100
 101         try
 102         {
 103
 104             archivaAdministration.addLegacyArtifactPath( legacyArtifactPath, getAuditInformation() );
 105         }
 106         catch ( RepositoryAdminException e )
 107         {
 108             throw new ArchivaRestServiceException( e.getMessage(), e );
 109         }
 110     }
 111
 112     @Override
 113     public Boolean deleteLegacyArtifactPath( String path )
 114         throws ArchivaRestServiceException
 115     {
 116         try
 117         {
 118             archivaAdministration.deleteLegacyArtifactPath( path, getAuditInformation() );
 119             return Boolean.TRUE;
 120         }
 121         catch ( RepositoryAdminException e )
 122         {
 123             throw new ArchivaRestServiceException( e.getMessage(), e );
 124         }
 125     }
 126
 127
 128     @Override
 129     public Boolean addFileTypePattern( String fileTypeId, String pattern )
 130         throws ArchivaRestServiceException
 131     {
 132         try
 133         {
 134             archivaAdministration.addFileTypePattern( fileTypeId, pattern, getAuditInformation() );
 135             return Boolean.TRUE;
 136         }
 137         catch ( RepositoryAdminException e )
 138         {
 139             throw new ArchivaRestServiceException( e.getMessage(), e );
 140         }
 141     }
 142
 143     @Override
 144     public Boolean removeFileTypePattern( String fileTypeId, String pattern )
 145         throws ArchivaRestServiceException
 146     {
 147         try
 148         {
 149             archivaAdministration.removeFileTypePattern( fileTypeId, pattern, getAuditInformation() );
 150             return Boolean.TRUE;
 151         }
 152         catch ( RepositoryAdminException e )
 153         {
 154             throw new ArchivaRestServiceException( e.getMessage(), e );
 155         }
 156     }
 157
 158     @Override
 159     public FileType getFileType( String fileTypeId )
 160         throws ArchivaRestServiceException
 161     {
 162         try
 163         {
 164             return archivaAdministration.getFileType( fileTypeId );
 165         }
 166         catch ( RepositoryAdminException e )
 167         {
 168             throw new ArchivaRestServiceException( e.getMessage(), e );
 169         }
 170     }
 171
 172     @Override
 173     public void addFileType( FileType fileType )
 174         throws ArchivaRestServiceException
 175     {
 176         try
 177         {
 178             archivaAdministration.addFileType( fileType, getAuditInformation() );
 179         }
 180         catch ( RepositoryAdminException e )
 181         {
 182             throw new ArchivaRestServiceException( e.getMessage(), e );
 183         }
 184     }
 185
 186     @Override
 187     public Boolean removeFileType( String fileTypeId )
 188         throws ArchivaRestServiceException
 189     {
 190         try
 191         {
 192             archivaAdministration.removeFileType( fileTypeId, getAuditInformation() );
 193             return Boolean.TRUE;
 194         }
 195         catch ( RepositoryAdminException e )
 196         {
 197             throw new ArchivaRestServiceException( e.getMessage(), e );
 198         }
 199     }
 200
 201     @Override
 202     public Boolean enabledKnownContentConsumer( String knownContentConsumer )
 203         throws ArchivaRestServiceException
 204     {
 205         try
 206         {
 207             archivaAdministration.addKnownContentConsumer( knownContentConsumer, getAuditInformation() );
 208             return Boolean.TRUE;
 209         }
 210         catch ( RepositoryAdminException e )
 211         {
 212             throw new ArchivaRestServiceException( e.getMessage(), e );
 213         }
 214     }
 215
 216     @Override
 217     public void enabledKnownContentConsumers( List<String> knownContentConsumers )
 218         throws ArchivaRestServiceException
 219     {
 220         try
 221         {
 222             archivaAdministration.setKnownContentConsumers( knownContentConsumers, getAuditInformation() );
 223         }
 224         catch ( RepositoryAdminException e )
 225         {
 226             throw new ArchivaRestServiceException( e.getMessage(), e );
 227         }
 228     }
 229
 230     @Override
 231     public Boolean disabledKnownContentConsumer( String knownContentConsumer )
 232         throws ArchivaRestServiceException
 233     {
 234         try
 235         {
 236             archivaAdministration.removeKnownContentConsumer( knownContentConsumer, getAuditInformation() );
 237             return Boolean.TRUE;
 238         }
 239         catch ( RepositoryAdminException e )
 240         {
 241             throw new ArchivaRestServiceException( e.getMessage(), e );
 242         }
 243     }
 244
 245     @Override
 246     public Boolean enabledInvalidContentConsumer( String invalidContentConsumer )
 247         throws ArchivaRestServiceException
 248     {
 249         try
 250         {
 251             archivaAdministration.addInvalidContentConsumer( invalidContentConsumer, getAuditInformation() );
 252             return Boolean.TRUE;
 253         }
 254         catch ( RepositoryAdminException e )
 255         {
 256             throw new ArchivaRestServiceException( e.getMessage(), e );
 257         }
 258     }
 259
 260     @Override
 261     public void enabledInvalidContentConsumers( List<String> invalidContentConsumers )
 262         throws ArchivaRestServiceException
 263     {
 264         try
 265         {
 266             archivaAdministration.setInvalidContentConsumers( invalidContentConsumers, getAuditInformation() );
 267         }
 268         catch ( RepositoryAdminException e )
 269         {
 270             throw new ArchivaRestServiceException( e.getMessage(), e );
 271         }
 272     }
 273
 274     @Override
 275     public Boolean disabledInvalidContentConsumer( String invalidContentConsumer )
 276         throws ArchivaRestServiceException
 277     {
 278         try
 279         {
 280             archivaAdministration.removeInvalidContentConsumer( invalidContentConsumer, getAuditInformation() );
 281             return Boolean.TRUE;
 282         }
 283         catch ( RepositoryAdminException e )
 284         {
 285             throw new ArchivaRestServiceException( e.getMessage(), e );
 286         }
 287     }
 288
 289     @Override
 290     public List<FileType> getFileTypes()
 291         throws ArchivaRestServiceException
 292     {
 293         try
 294         {
 295             List<FileType> modelfileTypes = archivaAdministration.getFileTypes();
 296             if ( modelfileTypes == null || modelfileTypes.isEmpty() )
 297             {
 298                 return Collections.emptyList();
 299             }
 300             return modelfileTypes;
 301         }
 302         catch ( RepositoryAdminException e )
 303         {
 304             throw new ArchivaRestServiceException( e.getMessage(), e );
 305         }
 306     }
 307
 308     @Override
 309     public List<String> getKnownContentConsumers()
 310         throws ArchivaRestServiceException
 311     {
 312         try
 313         {
 314             return new ArrayList<String>( archivaAdministration.getKnownContentConsumers() );
 315         }
 316         catch ( RepositoryAdminException e )
 317         {
 318             throw new ArchivaRestServiceException( e.getMessage(), e );
 319         }
 320     }
 321
 322     @Override
 323     public List<String> getInvalidContentConsumers()
 324         throws ArchivaRestServiceException
 325     {
 326         try
 327         {
 328             return new ArrayList<String>( archivaAdministration.getInvalidContentConsumers() );
 329         }
 330         catch ( RepositoryAdminException e )
 331         {
 332             throw new ArchivaRestServiceException( e.getMessage(), e );
 333         }
 334     }
 335
 336     @Override
 337     public OrganisationInformation getOrganisationInformation()
 338         throws ArchivaRestServiceException
 339     {
 340         try
 341         {
 342             return archivaAdministration.getOrganisationInformation();
 343         }
 344         catch ( RepositoryAdminException e )
 345         {
 346             throw new ArchivaRestServiceException( e.getMessage(), e );
 347         }
 348     }
 349
 350     @Override
 351     public void setOrganisationInformation( OrganisationInformation organisationInformation )
 352         throws ArchivaRestServiceException
 353     {
 354         try
 355         {
 356             archivaAdministration.setOrganisationInformation( organisationInformation );
 357         }
 358         catch ( RepositoryAdminException e )
 359         {
 360             throw new ArchivaRestServiceException( e.getMessage(), e );
 361         }
 362     }
 363
 364     @Override
 365     public Boolean registrationDisabled()
 366         throws ArchivaRestServiceException
 367     {
 368         return getUiConfiguration().isDisableRegistration();
 369     }
 370
 371     @Override
 372     public UiConfiguration getUiConfiguration()
 373         throws ArchivaRestServiceException
 374     {
 375         try
 376         {
 377             return archivaAdministration.getUiConfiguration();
 378         }
 379         catch ( RepositoryAdminException e )
 380         {
 381             throw new ArchivaRestServiceException( e.getMessage(), e );
 382         }
 383     }
 384
 385     @Override
 386     public void setUiConfiguration( UiConfiguration uiConfiguration )
 387         throws ArchivaRestServiceException
 388     {
 389         try
 390         {
 391             // fix for MRM-1757
 392             // strip any trailing '/' at the end of the url so it won't affect url/link calculations in UI
 393             uiConfiguration.setApplicationUrl(StringUtils.stripEnd(uiConfiguration.getApplicationUrl(), "/"));
 394
 395             archivaAdministration.updateUiConfiguration( uiConfiguration );
 396         }
 397         catch ( RepositoryAdminException e )
 398         {
 399             throw new ArchivaRestServiceException( e.getMessage(), e );
 400         }
 401     }
 402
 403     @Override
 404     public String getApplicationUrl()
 405         throws ArchivaRestServiceException
 406     {
 407         try
 408         {
 409             return archivaAdministration.getUiConfiguration().getApplicationUrl();
 410         }
 411         catch ( RepositoryAdminException e )
 412         {
 413             throw new ArchivaRestServiceException( e.getMessage(), e );
 414         }
 415     }
 416
 417     @Override
 418     public NetworkConfiguration getNetworkConfiguration()
 419         throws ArchivaRestServiceException
 420     {
 421         try
 422         {
 423             return archivaAdministration.getNetworkConfiguration();
 424         }
 425         catch ( RepositoryAdminException e )
 426         {
 427             throw new ArchivaRestServiceException( e.getMessage(), e );
 428         }
 429     }
 430
 431     @Override
 432     public void setNetworkConfiguration( NetworkConfiguration networkConfiguration )
 433         throws ArchivaRestServiceException
 434     {
 435         try
 436         {
 437             archivaAdministration.setNetworkConfiguration( networkConfiguration );
 438         }
 439         catch ( RepositoryAdminException e )
 440         {
 441             throw new ArchivaRestServiceException( e.getMessage(), e );
 442         }
 443     }
 444
 445     @Override
 446     public List<AdminRepositoryConsumer> getKnownContentAdminRepositoryConsumers()
 447         throws ArchivaRestServiceException
 448     {
 449         try
 450         {
 451             AddAdminRepoConsumerClosure addAdminRepoConsumer =
 452                 new AddAdminRepoConsumerClosure( archivaAdministration.getKnownContentConsumers() );
 453             CollectionUtils.forAllDo( repoConsumerUtil.getAvailableKnownConsumers(), addAdminRepoConsumer );
 454             List<AdminRepositoryConsumer> knownContentConsumers = addAdminRepoConsumer.getList();
 455             Collections.sort( knownContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 456             return knownContentConsumers;
 457         }
 458         catch ( RepositoryAdminException e )
 459         {
 460             throw new ArchivaRestServiceException( e.getMessage(), e );
 461         }
 462     }
 463
 464     @Override
 465     public List<AdminRepositoryConsumer> getInvalidContentAdminRepositoryConsumers()
 466         throws ArchivaRestServiceException
 467     {
 468         try
 469         {
 470             AddAdminRepoConsumerClosure addAdminRepoConsumer =
 471                 new AddAdminRepoConsumerClosure( archivaAdministration.getInvalidContentConsumers() );
 472             CollectionUtils.forAllDo( repoConsumerUtil.getAvailableInvalidConsumers(), addAdminRepoConsumer );
 473             List<AdminRepositoryConsumer> invalidContentConsumers = addAdminRepoConsumer.getList();
 474             Collections.sort( invalidContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 475             return invalidContentConsumers;
 476         }
 477         catch ( RepositoryAdminException e )
 478         {
 479             throw new ArchivaRestServiceException( e.getMessage(), e );
 480         }
 481     }
 482 }