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