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

   1 package org.apache.archiva.web.action;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import com.opensymphony.xwork2.Preparable;
  23 import com.opensymphony.xwork2.Validateable;
  24 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  25 import org.apache.archiva.audit.Auditable;
  26 import org.apache.archiva.checksum.ChecksumAlgorithm;
  27 import org.apache.archiva.common.utils.VersionUtil;
  28 import org.apache.archiva.rest.api.model.Artifact;
  29 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  30 import org.apache.archiva.rest.api.services.RepositoriesService;
  31 import org.apache.archiva.security.AccessDeniedException;
  32 import org.apache.archiva.security.ArchivaSecurityException;
  33 import org.apache.archiva.security.PrincipalNotFoundException;
  34 import org.apache.archiva.security.UserRepositories;
  35 import org.apache.commons.lang.StringUtils;
  36 import org.apache.archiva.redback.rest.services.RedbackAuthenticationThreadLocal;
  37 import org.springframework.context.annotation.Scope;
  38 import org.springframework.stereotype.Controller;
  39
  40 import javax.annotation.PostConstruct;
  41 import javax.inject.Inject;
  42 import java.util.Collections;
  43 import java.util.List;
  44
  45 /**
  46  * Delete an artifact. Metadata will be updated if one exists, otherwise it would be created.
  47  */
  48 @Controller( "deleteArtifactAction" )
  49 @Scope( "prototype" )
  50 public class DeleteArtifactAction
  51     extends AbstractActionSupport
  52     implements Validateable, Preparable, Auditable
  53 {
  54     /**
  55      * The groupId of the artifact to be deleted.
  56      */
  57     private String groupId;
  58
  59     /**
  60      * The artifactId of the artifact to be deleted.
  61      */
  62     private String artifactId;
  63
  64     /**
  65      * The version of the artifact to be deleted.
  66      */
  67     private String version;
  68
  69     /**
  70      * @since 1.4-M2
  71      *        The classifier of the artifact to be deleted (optionnal)
  72      */
  73     private String classifier;
  74
  75     /**
  76      * @since 1.4-M2
  77      *        The type of the artifact to be deleted (optionnal) (default jar)
  78      */
  79     private String type;
  80
  81     /**
  82      * The repository where the artifact is to be deleted.
  83      */
  84     private String repositoryId;
  85
  86     /**
  87      * List of managed repositories to delete from.
  88      */
  89     private List<String> managedRepos;
  90
  91     @Inject
  92     private UserRepositories userRepositories;
  93
  94     @Inject
  95     private ManagedRepositoryAdmin managedRepositoryAdmin;
  96
  97     @Inject
  98     private RepositoriesService repositoriesService;
  99
 100     private ChecksumAlgorithm[] algorithms = new ChecksumAlgorithm[]{ ChecksumAlgorithm.SHA1, ChecksumAlgorithm.MD5 };
 101
 102     @PostConstruct
 103     public void initialize()
 104     {
 105         super.initialize();
 106     }
 107
 108     public String getGroupId()
 109     {
 110         return groupId;
 111     }
 112
 113     public void setGroupId( String groupId )
 114     {
 115         this.groupId = groupId;
 116     }
 117
 118     public String getArtifactId()
 119     {
 120         return artifactId;
 121     }
 122
 123     public void setArtifactId( String artifactId )
 124     {
 125         this.artifactId = artifactId;
 126     }
 127
 128     public String getVersion()
 129     {
 130         return version;
 131     }
 132
 133     public void setVersion( String version )
 134     {
 135         this.version = version;
 136     }
 137
 138     public String getRepositoryId()
 139     {
 140         return repositoryId;
 141     }
 142
 143     public void setRepositoryId( String repositoryId )
 144     {
 145         this.repositoryId = repositoryId;
 146     }
 147
 148     public List<String> getManagedRepos()
 149     {
 150         return managedRepos;
 151     }
 152
 153     public void setManagedRepos( List<String> managedRepos )
 154     {
 155         this.managedRepos = managedRepos;
 156     }
 157
 158     public void prepare()
 159     {
 160         managedRepos = getManagableRepos();
 161     }
 162
 163     public String getClassifier()
 164     {
 165         return classifier;
 166     }
 167
 168     public void setClassifier( String classifier )
 169     {
 170         this.classifier = classifier;
 171     }
 172
 173     public String getType()
 174     {
 175         return type;
 176     }
 177
 178     public void setType( String type )
 179     {
 180         this.type = type;
 181     }
 182
 183     public String input()
 184     {
 185         return INPUT;
 186     }
 187
 188     private void reset()
 189     {
 190         // reset the fields so the form is clear when
 191         // the action returns to the jsp page
 192         groupId = "";
 193         artifactId = "";
 194         version = "";
 195         repositoryId = "";
 196         classifier = "";
 197         type = "";
 198     }
 199
 200     public String doDelete()
 201     {
 202         // services need a ThreadLocal variable to test karma
 203         RedbackAuthenticationThreadLocal.set( getRedbackRequestInformation() );
 204         try
 205         {
 206             Artifact artifact = new Artifact();
 207             artifact.setGroupId( groupId );
 208             artifact.setArtifactId( artifactId );
 209             artifact.setVersion( version );
 210             artifact.setClassifier( classifier );
 211             artifact.setPackaging( type );
 212
 213             repositoriesService.deleteArtifact( artifact, repositoryId );
 214         }
 215         catch ( ArchivaRestServiceException e )
 216         {
 217             addActionError( "ArchivaRestServiceException exception: " + e.getMessage() );
 218             return ERROR;
 219         }
 220         finally
 221         {
 222             RedbackAuthenticationThreadLocal.set( null );
 223         }
 224
 225         StringBuilder msg = new StringBuilder( "Artifact \'" ).append( groupId ).append( ":" ).append( artifactId );
 226
 227         if ( StringUtils.isNotEmpty( classifier ) )
 228         {
 229             msg.append( ":" ).append( classifier );
 230         }
 231         msg.append( ":" ).append( version ).append( "' was successfully deleted from repository '" ).append(
 232             repositoryId ).append( "'" );
 233         addActionMessage( msg.toString() );
 234         reset();
 235         return SUCCESS;
 236     }
 237
 238     public void validate()
 239     {
 240         try
 241         {
 242             if ( !userRepositories.isAuthorizedToDeleteArtifacts( getPrincipal(), repositoryId ) )
 243             {
 244                 addActionError( "User is not authorized to delete artifacts in repository '" + repositoryId + "'." );
 245             }
 246
 247             if ( ( version.length() > 0 ) && ( !VersionUtil.isVersion( version ) ) )
 248             {
 249                 addActionError( "Invalid version." );
 250             }
 251         }
 252         catch ( AccessDeniedException e )
 253         {
 254             addActionError( e.getMessage() );
 255         }
 256         catch ( ArchivaSecurityException e )
 257         {
 258             addActionError( e.getMessage() );
 259         }
 260
 261         // trims all request parameter values, since the trailing/leading white-spaces are ignored during validation.
 262         trimAllRequestParameterValues();
 263     }
 264
 265     private List<String> getManagableRepos()
 266     {
 267         try
 268         {
 269             return userRepositories.getManagableRepositoryIds( getPrincipal() );
 270         }
 271         catch ( PrincipalNotFoundException e )
 272         {
 273             log.warn( e.getMessage(), e );
 274         }
 275         catch ( AccessDeniedException e )
 276         {
 277             log.warn( e.getMessage(), e );
 278             // TODO: pass this onto the screen.
 279         }
 280         catch ( ArchivaSecurityException e )
 281         {
 282             log.warn( e.getMessage(), e );
 283         }
 284         return Collections.emptyList();
 285     }
 286
 287     private void trimAllRequestParameterValues()
 288     {
 289         if ( StringUtils.isNotEmpty( groupId ) )
 290         {
 291             groupId = groupId.trim();
 292         }
 293
 294         if ( StringUtils.isNotEmpty( artifactId ) )
 295         {
 296             artifactId = artifactId.trim();
 297         }
 298
 299         if ( StringUtils.isNotEmpty( version ) )
 300         {
 301             version = version.trim();
 302         }
 303
 304         if ( StringUtils.isNotEmpty( repositoryId ) )
 305         {
 306             repositoryId = repositoryId.trim();
 307         }
 308     }
 309
 310     public ManagedRepositoryAdmin getManagedRepositoryAdmin()
 311     {
 312         return managedRepositoryAdmin;
 313     }
 314
 315     public void setManagedRepositoryAdmin( ManagedRepositoryAdmin managedRepositoryAdmin )
 316     {
 317         this.managedRepositoryAdmin = managedRepositoryAdmin;
 318     }
 319
 320     public RepositoriesService getRepositoriesService()
 321     {
 322         return repositoriesService;
 323     }
 324
 325     public void setRepositoriesService( RepositoriesService repositoriesService )
 326     {
 327         this.repositoriesService = repositoriesService;
 328     }
 329 }