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             artifact.setContext( repositoryId );
 213
 214             repositoriesService.deleteArtifact( artifact );
 215         }
 216         catch ( ArchivaRestServiceException e )
 217         {
 218             addActionError( "ArchivaRestServiceException exception: " + e.getMessage() );
 219             return ERROR;
 220         }
 221         finally
 222         {
 223             RedbackAuthenticationThreadLocal.set( null );
 224         }
 225
 226         StringBuilder msg = new StringBuilder( "Artifact \'" ).append( groupId ).append( ":" ).append( artifactId );
 227
 228         if ( StringUtils.isNotEmpty( classifier ) )
 229         {
 230             msg.append( ":" ).append( classifier );
 231         }
 232         msg.append( ":" ).append( version ).append( "' was successfully deleted from repository '" ).append(
 233             repositoryId ).append( "'" );
 234         addActionMessage( msg.toString() );
 235         reset();
 236         return SUCCESS;
 237     }
 238
 239     public void validate()
 240     {
 241         try
 242         {
 243             if ( !userRepositories.isAuthorizedToDeleteArtifacts( getPrincipal(), repositoryId ) )
 244             {
 245                 addActionError( "User is not authorized to delete artifacts in repository '" + repositoryId + "'." );
 246             }
 247
 248             if ( ( version.length() > 0 ) && ( !VersionUtil.isVersion( version ) ) )
 249             {
 250                 addActionError( "Invalid version." );
 251             }
 252         }
 253         catch ( AccessDeniedException e )
 254         {
 255             addActionError( e.getMessage() );
 256         }
 257         catch ( ArchivaSecurityException e )
 258         {
 259             addActionError( e.getMessage() );
 260         }
 261
 262         // trims all request parameter values, since the trailing/leading white-spaces are ignored during validation.
 263         trimAllRequestParameterValues();
 264     }
 265
 266     private List<String> getManagableRepos()
 267     {
 268         try
 269         {
 270             return userRepositories.getManagableRepositoryIds( getPrincipal() );
 271         }
 272         catch ( PrincipalNotFoundException e )
 273         {
 274             log.warn( e.getMessage(), e );
 275         }
 276         catch ( AccessDeniedException e )
 277         {
 278             log.warn( e.getMessage(), e );
 279             // TODO: pass this onto the screen.
 280         }
 281         catch ( ArchivaSecurityException e )
 282         {
 283             log.warn( e.getMessage(), e );
 284         }
 285         return Collections.emptyList();
 286     }
 287
 288     private void trimAllRequestParameterValues()
 289     {
 290         if ( StringUtils.isNotEmpty( groupId ) )
 291         {
 292             groupId = groupId.trim();
 293         }
 294
 295         if ( StringUtils.isNotEmpty( artifactId ) )
 296         {
 297             artifactId = artifactId.trim();
 298         }
 299
 300         if ( StringUtils.isNotEmpty( version ) )
 301         {
 302             version = version.trim();
 303         }
 304
 305         if ( StringUtils.isNotEmpty( repositoryId ) )
 306         {
 307             repositoryId = repositoryId.trim();
 308         }
 309     }
 310
 311     public ManagedRepositoryAdmin getManagedRepositoryAdmin()
 312     {
 313         return managedRepositoryAdmin;
 314     }
 315
 316     public void setManagedRepositoryAdmin( ManagedRepositoryAdmin managedRepositoryAdmin )
 317     {
 318         this.managedRepositoryAdmin = managedRepositoryAdmin;
 319     }
 320
 321     public RepositoriesService getRepositoriesService()
 322     {
 323         return repositoriesService;
 324     }
 325
 326     public void setRepositoriesService( RepositoriesService repositoriesService )
 327     {
 328         this.repositoriesService = repositoriesService;
 329     }
 330 }