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.rest.api.services.ArchivaAdministrationService;
  31 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  32 import org.apache.commons.lang.StringUtils;
  33 import org.springframework.stereotype.Service;
  34
  35 import javax.inject.Inject;
  36 import javax.inject.Named;
  37 import javax.ws.rs.core.Response;
  38 import java.util.ArrayList;
  39 import java.util.Collections;
  40 import java.util.List;
  41
  42 /**
  43  * @author Olivier Lamy
  44  * @since 1.4-M1
  45  */
  46 @Service( "archivaAdministrationService#default" )
  47 public class DefaultArchivaAdministrationService
  48     extends AbstractRestService
  49     implements ArchivaAdministrationService
  50 {
  51     @Inject
  52     private ArchivaAdministration archivaAdministration;
  53
  54     @Inject
  55     @Named( value = "managedRepositoryContent#legacy" )
  56     private ManagedRepositoryContent repositoryContent;
  57
  58     public List<LegacyArtifactPath> getLegacyArtifactPaths()
  59         throws ArchivaRestServiceException
  60     {
  61         try
  62         {
  63             return archivaAdministration.getLegacyArtifactPaths();
  64         }
  65         catch ( RepositoryAdminException e )
  66         {
  67             throw new ArchivaRestServiceException( e.getMessage() );
  68         }
  69     }
  70
  71     public void addLegacyArtifactPath( LegacyArtifactPath legacyArtifactPath )
  72         throws ArchivaRestServiceException
  73     {
  74
  75         // Check the proposed Artifact macthes the path
  76         ArtifactReference artifact = new ArtifactReference();
  77
  78         artifact.setGroupId( legacyArtifactPath.getGroupId() );
  79         artifact.setArtifactId( legacyArtifactPath.getArtifactId() );
  80         artifact.setClassifier( legacyArtifactPath.getClassifier() );
  81         artifact.setVersion( legacyArtifactPath.getVersion() );
  82         artifact.setType( legacyArtifactPath.getType() );
  83         String path = repositoryContent.toPath( artifact );
  84         if ( !StringUtils.equals( path, legacyArtifactPath.getPath() ) )
  85         {
  86             throw new ArchivaRestServiceException(
  87                 "artifact path reference '" + legacyArtifactPath.getPath() + "' does not match the initial path: '"
  88                     + path + "'", Response.Status.BAD_REQUEST.getStatusCode() );
  89         }
  90
  91         try
  92         {
  93
  94             archivaAdministration.addLegacyArtifactPath( legacyArtifactPath, getAuditInformation() );
  95         }
  96         catch ( RepositoryAdminException e )
  97         {
  98             throw new ArchivaRestServiceException( e.getMessage() );
  99         }
 100     }
 101
 102     public Boolean deleteLegacyArtifactPath( String path )
 103         throws ArchivaRestServiceException
 104     {
 105         try
 106         {
 107             archivaAdministration.deleteLegacyArtifactPath( path, getAuditInformation() );
 108             return Boolean.TRUE;
 109         }
 110         catch ( RepositoryAdminException e )
 111         {
 112             throw new ArchivaRestServiceException( e.getMessage() );
 113         }
 114     }
 115
 116
 117     public Boolean addFileTypePattern( String fileTypeId, String pattern )
 118         throws ArchivaRestServiceException
 119     {
 120         try
 121         {
 122             archivaAdministration.addFileTypePattern( fileTypeId, pattern, getAuditInformation() );
 123             return Boolean.TRUE;
 124         }
 125         catch ( RepositoryAdminException e )
 126         {
 127             throw new ArchivaRestServiceException( e.getMessage() );
 128         }
 129     }
 130
 131     public Boolean removeFileTypePattern( String fileTypeId, String pattern )
 132         throws ArchivaRestServiceException
 133     {
 134         try
 135         {
 136             archivaAdministration.removeFileTypePattern( fileTypeId, pattern, getAuditInformation() );
 137             return Boolean.TRUE;
 138         }
 139         catch ( RepositoryAdminException e )
 140         {
 141             throw new ArchivaRestServiceException( e.getMessage() );
 142         }
 143     }
 144
 145     public FileType getFileType( String fileTypeId )
 146         throws ArchivaRestServiceException
 147     {
 148         try
 149         {
 150             return archivaAdministration.getFileType( fileTypeId );
 151         }
 152         catch ( RepositoryAdminException e )
 153         {
 154             throw new ArchivaRestServiceException( e.getMessage() );
 155         }
 156     }
 157
 158     public void addFileType( FileType fileType )
 159         throws ArchivaRestServiceException
 160     {
 161         try
 162         {
 163             archivaAdministration.addFileType( fileType, getAuditInformation() );
 164         }
 165         catch ( RepositoryAdminException e )
 166         {
 167             throw new ArchivaRestServiceException( e.getMessage() );
 168         }
 169     }
 170
 171     public Boolean removeFileType( String fileTypeId )
 172         throws ArchivaRestServiceException
 173     {
 174         try
 175         {
 176             archivaAdministration.removeFileType( fileTypeId, getAuditInformation() );
 177             return Boolean.TRUE;
 178         }
 179         catch ( RepositoryAdminException e )
 180         {
 181             throw new ArchivaRestServiceException( e.getMessage() );
 182         }
 183     }
 184
 185     public Boolean addKnownContentConsumer( String knownContentConsumer )
 186         throws ArchivaRestServiceException
 187     {
 188         try
 189         {
 190             archivaAdministration.addKnownContentConsumer( knownContentConsumer, getAuditInformation() );
 191             return Boolean.TRUE;
 192         }
 193         catch ( RepositoryAdminException e )
 194         {
 195             throw new ArchivaRestServiceException( e.getMessage() );
 196         }
 197     }
 198
 199     public void setKnownContentConsumers( List<String> knownContentConsumers )
 200         throws ArchivaRestServiceException
 201     {
 202         try
 203         {
 204             archivaAdministration.setKnownContentConsumers( knownContentConsumers, getAuditInformation() );
 205         }
 206         catch ( RepositoryAdminException e )
 207         {
 208             throw new ArchivaRestServiceException( e.getMessage() );
 209         }
 210     }
 211
 212     public Boolean removeKnownContentConsumer( String knownContentConsumer )
 213         throws ArchivaRestServiceException
 214     {
 215         try
 216         {
 217             archivaAdministration.removeKnownContentConsumer( knownContentConsumer, getAuditInformation() );
 218             return Boolean.TRUE;
 219         }
 220         catch ( RepositoryAdminException e )
 221         {
 222             throw new ArchivaRestServiceException( e.getMessage() );
 223         }
 224     }
 225
 226     public Boolean addInvalidContentConsumer( String invalidContentConsumer )
 227         throws ArchivaRestServiceException
 228     {
 229         try
 230         {
 231             archivaAdministration.addInvalidContentConsumer( invalidContentConsumer, getAuditInformation() );
 232             return Boolean.TRUE;
 233         }
 234         catch ( RepositoryAdminException e )
 235         {
 236             throw new ArchivaRestServiceException( e.getMessage() );
 237         }
 238     }
 239
 240     public void setInvalidContentConsumers( List<String> invalidContentConsumers )
 241         throws ArchivaRestServiceException
 242     {
 243         try
 244         {
 245             archivaAdministration.setInvalidContentConsumers( invalidContentConsumers, getAuditInformation() );
 246         }
 247         catch ( RepositoryAdminException e )
 248         {
 249             throw new ArchivaRestServiceException( e.getMessage() );
 250         }
 251     }
 252
 253     public Boolean removeInvalidContentConsumer( String invalidContentConsumer )
 254         throws ArchivaRestServiceException
 255     {
 256         try
 257         {
 258             archivaAdministration.removeInvalidContentConsumer( invalidContentConsumer, getAuditInformation() );
 259             return Boolean.TRUE;
 260         }
 261         catch ( RepositoryAdminException e )
 262         {
 263             throw new ArchivaRestServiceException( e.getMessage() );
 264         }
 265     }
 266
 267     public List<FileType> getFileTypes()
 268         throws ArchivaRestServiceException
 269     {
 270         try
 271         {
 272             List<FileType> modelfileTypes = archivaAdministration.getFileTypes();
 273             if ( modelfileTypes == null || modelfileTypes.isEmpty() )
 274             {
 275                 return Collections.emptyList();
 276             }
 277             return modelfileTypes;
 278         }
 279         catch ( RepositoryAdminException e )
 280         {
 281             throw new ArchivaRestServiceException( e.getMessage() );
 282         }
 283     }
 284
 285     public List<String> getKnownContentConsumers()
 286         throws ArchivaRestServiceException
 287     {
 288         try
 289         {
 290             return new ArrayList<String>( archivaAdministration.getKnownContentConsumers() );
 291         }
 292         catch ( RepositoryAdminException e )
 293         {
 294             throw new ArchivaRestServiceException( e.getMessage() );
 295         }
 296     }
 297
 298     public List<String> getInvalidContentConsumers()
 299         throws ArchivaRestServiceException
 300     {
 301         try
 302         {
 303             return new ArrayList<String>( archivaAdministration.getInvalidContentConsumers() );
 304         }
 305         catch ( RepositoryAdminException e )
 306         {
 307             throw new ArchivaRestServiceException( e.getMessage() );
 308         }
 309     }
 310
 311     public OrganisationInformation getOrganisationInformation()
 312         throws ArchivaRestServiceException
 313     {
 314         try
 315         {
 316             return archivaAdministration.getOrganisationInformation();
 317         }
 318         catch ( RepositoryAdminException e )
 319         {
 320             throw new ArchivaRestServiceException( e.getMessage() );
 321         }
 322     }
 323
 324     public void setOrganisationInformation( OrganisationInformation organisationInformation )
 325         throws ArchivaRestServiceException
 326     {
 327         try
 328         {
 329             archivaAdministration.setOrganisationInformation( organisationInformation );
 330         }
 331         catch ( RepositoryAdminException e )
 332         {
 333             throw new ArchivaRestServiceException( e.getMessage() );
 334         }
 335     }
 336
 337
 338     public UiConfiguration getUiConfiguration()
 339         throws ArchivaRestServiceException
 340     {
 341         try
 342         {
 343             return archivaAdministration.getUiConfiguration();
 344         }
 345         catch ( RepositoryAdminException e )
 346         {
 347             throw new ArchivaRestServiceException( e.getMessage() );
 348         }
 349     }
 350
 351     public void setUiConfiguration( UiConfiguration uiConfiguration )
 352         throws ArchivaRestServiceException
 353     {
 354         try
 355         {
 356             archivaAdministration.updateUiConfiguration( uiConfiguration );
 357         }
 358         catch ( RepositoryAdminException e )
 359         {
 360             throw new ArchivaRestServiceException( e.getMessage() );
 361         }
 362     }
 363
 364     public NetworkConfiguration getNetworkConfiguration()
 365         throws ArchivaRestServiceException
 366     {
 367         try
 368         {
 369             return archivaAdministration.getNetworkConfiguration();
 370         }
 371         catch ( RepositoryAdminException e )
 372         {
 373             throw new ArchivaRestServiceException( e.getMessage() );
 374         }
 375     }
 376
 377     public void setNetworkConfiguration( NetworkConfiguration networkConfiguration )
 378         throws ArchivaRestServiceException
 379     {
 380         try
 381         {
 382             archivaAdministration.setNetworkConfiguration( networkConfiguration );
 383         }
 384         catch ( RepositoryAdminException e )
 385         {
 386             throw new ArchivaRestServiceException( e.getMessage() );
 387         }
 388     }
 389 }