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     public List<LegacyArtifactPath> getLegacyArtifactPaths()
  67         throws ArchivaRestServiceException
  68     {
  69         try
  70         {
  71             return archivaAdministration.getLegacyArtifactPaths();
  72         }
  73         catch ( RepositoryAdminException e )
  74         {
  75             throw new ArchivaRestServiceException( e.getMessage(), e );
  76         }
  77     }
  78
  79     public void addLegacyArtifactPath( LegacyArtifactPath legacyArtifactPath )
  80         throws ArchivaRestServiceException
  81     {
  82
  83         // Check the proposed Artifact matches the path
  84         ArtifactReference artifact = new ArtifactReference();
  85
  86         artifact.setGroupId( legacyArtifactPath.getGroupId() );
  87         artifact.setArtifactId( legacyArtifactPath.getArtifactId() );
  88         artifact.setClassifier( legacyArtifactPath.getClassifier() );
  89         artifact.setVersion( legacyArtifactPath.getVersion() );
  90         artifact.setType( legacyArtifactPath.getType() );
  91         String path = repositoryContent.toPath( artifact );
  92         if ( !StringUtils.equals( path, legacyArtifactPath.getPath() ) )
  93         {
  94             throw new ArchivaRestServiceException(
  95                 "artifact path reference '" + legacyArtifactPath.getPath() + "' does not match the initial path: '"
  96                     + path + "'", Response.Status.BAD_REQUEST.getStatusCode(), null );
  97         }
  98
  99         try
 100         {
 101
 102             archivaAdministration.addLegacyArtifactPath( legacyArtifactPath, getAuditInformation() );
 103         }
 104         catch ( RepositoryAdminException e )
 105         {
 106             throw new ArchivaRestServiceException( e.getMessage(), e );
 107         }
 108     }
 109
 110     public Boolean deleteLegacyArtifactPath( String path )
 111         throws ArchivaRestServiceException
 112     {
 113         try
 114         {
 115             archivaAdministration.deleteLegacyArtifactPath( path, getAuditInformation() );
 116             return Boolean.TRUE;
 117         }
 118         catch ( RepositoryAdminException e )
 119         {
 120             throw new ArchivaRestServiceException( e.getMessage(), e );
 121         }
 122     }
 123
 124
 125     public Boolean addFileTypePattern( String fileTypeId, String pattern )
 126         throws ArchivaRestServiceException
 127     {
 128         try
 129         {
 130             archivaAdministration.addFileTypePattern( fileTypeId, pattern, getAuditInformation() );
 131             return Boolean.TRUE;
 132         }
 133         catch ( RepositoryAdminException e )
 134         {
 135             throw new ArchivaRestServiceException( e.getMessage(), e );
 136         }
 137     }
 138
 139     public Boolean removeFileTypePattern( String fileTypeId, String pattern )
 140         throws ArchivaRestServiceException
 141     {
 142         try
 143         {
 144             archivaAdministration.removeFileTypePattern( fileTypeId, pattern, getAuditInformation() );
 145             return Boolean.TRUE;
 146         }
 147         catch ( RepositoryAdminException e )
 148         {
 149             throw new ArchivaRestServiceException( e.getMessage(), e );
 150         }
 151     }
 152
 153     public FileType getFileType( String fileTypeId )
 154         throws ArchivaRestServiceException
 155     {
 156         try
 157         {
 158             return archivaAdministration.getFileType( fileTypeId );
 159         }
 160         catch ( RepositoryAdminException e )
 161         {
 162             throw new ArchivaRestServiceException( e.getMessage(), e );
 163         }
 164     }
 165
 166     public void addFileType( FileType fileType )
 167         throws ArchivaRestServiceException
 168     {
 169         try
 170         {
 171             archivaAdministration.addFileType( fileType, getAuditInformation() );
 172         }
 173         catch ( RepositoryAdminException e )
 174         {
 175             throw new ArchivaRestServiceException( e.getMessage(), e );
 176         }
 177     }
 178
 179     public Boolean removeFileType( String fileTypeId )
 180         throws ArchivaRestServiceException
 181     {
 182         try
 183         {
 184             archivaAdministration.removeFileType( fileTypeId, getAuditInformation() );
 185             return Boolean.TRUE;
 186         }
 187         catch ( RepositoryAdminException e )
 188         {
 189             throw new ArchivaRestServiceException( e.getMessage(), e );
 190         }
 191     }
 192
 193     public Boolean enabledKnownContentConsumer( String knownContentConsumer )
 194         throws ArchivaRestServiceException
 195     {
 196         try
 197         {
 198             archivaAdministration.addKnownContentConsumer( knownContentConsumer, getAuditInformation() );
 199             return Boolean.TRUE;
 200         }
 201         catch ( RepositoryAdminException e )
 202         {
 203             throw new ArchivaRestServiceException( e.getMessage(), e );
 204         }
 205     }
 206
 207     public void enabledKnownContentConsumers( List<String> knownContentConsumers )
 208         throws ArchivaRestServiceException
 209     {
 210         try
 211         {
 212             archivaAdministration.setKnownContentConsumers( knownContentConsumers, getAuditInformation() );
 213         }
 214         catch ( RepositoryAdminException e )
 215         {
 216             throw new ArchivaRestServiceException( e.getMessage(), e );
 217         }
 218     }
 219
 220     public Boolean disabledKnownContentConsumer( String knownContentConsumer )
 221         throws ArchivaRestServiceException
 222     {
 223         try
 224         {
 225             archivaAdministration.removeKnownContentConsumer( knownContentConsumer, getAuditInformation() );
 226             return Boolean.TRUE;
 227         }
 228         catch ( RepositoryAdminException e )
 229         {
 230             throw new ArchivaRestServiceException( e.getMessage(), e );
 231         }
 232     }
 233
 234     public Boolean enabledInvalidContentConsumer( String invalidContentConsumer )
 235         throws ArchivaRestServiceException
 236     {
 237         try
 238         {
 239             archivaAdministration.addInvalidContentConsumer( invalidContentConsumer, getAuditInformation() );
 240             return Boolean.TRUE;
 241         }
 242         catch ( RepositoryAdminException e )
 243         {
 244             throw new ArchivaRestServiceException( e.getMessage(), e );
 245         }
 246     }
 247
 248     public void enabledInvalidContentConsumers( List<String> invalidContentConsumers )
 249         throws ArchivaRestServiceException
 250     {
 251         try
 252         {
 253             archivaAdministration.setInvalidContentConsumers( invalidContentConsumers, getAuditInformation() );
 254         }
 255         catch ( RepositoryAdminException e )
 256         {
 257             throw new ArchivaRestServiceException( e.getMessage(), e );
 258         }
 259     }
 260
 261     public Boolean disabledInvalidContentConsumer( String invalidContentConsumer )
 262         throws ArchivaRestServiceException
 263     {
 264         try
 265         {
 266             archivaAdministration.removeInvalidContentConsumer( invalidContentConsumer, getAuditInformation() );
 267             return Boolean.TRUE;
 268         }
 269         catch ( RepositoryAdminException e )
 270         {
 271             throw new ArchivaRestServiceException( e.getMessage(), e );
 272         }
 273     }
 274
 275     public List<FileType> getFileTypes()
 276         throws ArchivaRestServiceException
 277     {
 278         try
 279         {
 280             List<FileType> modelfileTypes = archivaAdministration.getFileTypes();
 281             if ( modelfileTypes == null || modelfileTypes.isEmpty() )
 282             {
 283                 return Collections.emptyList();
 284             }
 285             return modelfileTypes;
 286         }
 287         catch ( RepositoryAdminException e )
 288         {
 289             throw new ArchivaRestServiceException( e.getMessage(), e );
 290         }
 291     }
 292
 293     public List<String> getKnownContentConsumers()
 294         throws ArchivaRestServiceException
 295     {
 296         try
 297         {
 298             return new ArrayList<String>( archivaAdministration.getKnownContentConsumers() );
 299         }
 300         catch ( RepositoryAdminException e )
 301         {
 302             throw new ArchivaRestServiceException( e.getMessage(), e );
 303         }
 304     }
 305
 306     public List<String> getInvalidContentConsumers()
 307         throws ArchivaRestServiceException
 308     {
 309         try
 310         {
 311             return new ArrayList<String>( archivaAdministration.getInvalidContentConsumers() );
 312         }
 313         catch ( RepositoryAdminException e )
 314         {
 315             throw new ArchivaRestServiceException( e.getMessage(), e );
 316         }
 317     }
 318
 319     public OrganisationInformation getOrganisationInformation()
 320         throws ArchivaRestServiceException
 321     {
 322         try
 323         {
 324             return archivaAdministration.getOrganisationInformation();
 325         }
 326         catch ( RepositoryAdminException e )
 327         {
 328             throw new ArchivaRestServiceException( e.getMessage(), e );
 329         }
 330     }
 331
 332     public void setOrganisationInformation( OrganisationInformation organisationInformation )
 333         throws ArchivaRestServiceException
 334     {
 335         try
 336         {
 337             archivaAdministration.setOrganisationInformation( organisationInformation );
 338         }
 339         catch ( RepositoryAdminException e )
 340         {
 341             throw new ArchivaRestServiceException( e.getMessage(), e );
 342         }
 343     }
 344
 345     public Boolean registrationDisabled()
 346         throws ArchivaRestServiceException
 347     {
 348         return getUiConfiguration().isDisableRegistration();
 349     }
 350
 351     public UiConfiguration getUiConfiguration()
 352         throws ArchivaRestServiceException
 353     {
 354         try
 355         {
 356             return archivaAdministration.getUiConfiguration();
 357         }
 358         catch ( RepositoryAdminException e )
 359         {
 360             throw new ArchivaRestServiceException( e.getMessage(), e );
 361         }
 362     }
 363
 364     public void setUiConfiguration( UiConfiguration uiConfiguration )
 365         throws ArchivaRestServiceException
 366     {
 367         try
 368         {
 369             archivaAdministration.updateUiConfiguration( uiConfiguration );
 370         }
 371         catch ( RepositoryAdminException e )
 372         {
 373             throw new ArchivaRestServiceException( e.getMessage(), e );
 374         }
 375     }
 376
 377     public String getApplicationUrl()
 378         throws ArchivaRestServiceException
 379     {
 380         try
 381         {
 382             return archivaAdministration.getUiConfiguration().getApplicationUrl();
 383         }
 384         catch ( RepositoryAdminException e )
 385         {
 386             throw new ArchivaRestServiceException( e.getMessage(), e );
 387         }
 388     }
 389
 390     public NetworkConfiguration getNetworkConfiguration()
 391         throws ArchivaRestServiceException
 392     {
 393         try
 394         {
 395             return archivaAdministration.getNetworkConfiguration();
 396         }
 397         catch ( RepositoryAdminException e )
 398         {
 399             throw new ArchivaRestServiceException( e.getMessage(), e );
 400         }
 401     }
 402
 403     public void setNetworkConfiguration( NetworkConfiguration networkConfiguration )
 404         throws ArchivaRestServiceException
 405     {
 406         try
 407         {
 408             archivaAdministration.setNetworkConfiguration( networkConfiguration );
 409         }
 410         catch ( RepositoryAdminException e )
 411         {
 412             throw new ArchivaRestServiceException( e.getMessage(), e );
 413         }
 414     }
 415
 416     public List<AdminRepositoryConsumer> getKnownContentAdminRepositoryConsumers()
 417         throws ArchivaRestServiceException
 418     {
 419         try
 420         {
 421             AddAdminRepoConsumerClosure addAdminRepoConsumer =
 422                 new AddAdminRepoConsumerClosure( archivaAdministration.getKnownContentConsumers() );
 423             CollectionUtils.forAllDo( repoConsumerUtil.getAvailableKnownConsumers(), addAdminRepoConsumer );
 424             List<AdminRepositoryConsumer> knownContentConsumers = addAdminRepoConsumer.getList();
 425             Collections.sort( knownContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 426             return knownContentConsumers;
 427         }
 428         catch ( RepositoryAdminException e )
 429         {
 430             throw new ArchivaRestServiceException( e.getMessage(), e );
 431         }
 432     }
 433
 434     public List<AdminRepositoryConsumer> getInvalidContentAdminRepositoryConsumers()
 435         throws ArchivaRestServiceException
 436     {
 437         try
 438         {
 439             AddAdminRepoConsumerClosure addAdminRepoConsumer =
 440                 new AddAdminRepoConsumerClosure( archivaAdministration.getInvalidContentConsumers() );
 441             CollectionUtils.forAllDo( repoConsumerUtil.getAvailableInvalidConsumers(), addAdminRepoConsumer );
 442             List<AdminRepositoryConsumer> invalidContentConsumers = addAdminRepoConsumer.getList();
 443             Collections.sort( invalidContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 444             return invalidContentConsumers;
 445         }
 446         catch ( RepositoryAdminException e )
 447         {
 448             throw new ArchivaRestServiceException( e.getMessage(), e );
 449         }
 450     }
 451 }