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

   1 package org.apache.maven.archiva.web.action.admin.legacy;
   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 org.apache.maven.archiva.configuration.ArchivaConfiguration;
  23 import org.apache.maven.archiva.configuration.Configuration;
  24 import org.apache.maven.archiva.configuration.IndeterminateConfigurationException;
  25 import org.apache.maven.archiva.configuration.LegacyArtifactPath;
  26 import org.apache.maven.archiva.model.ArtifactReference;
  27 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  28 import org.codehaus.plexus.registry.RegistryException;
  29
  30 import com.opensymphony.xwork2.Preparable;
  31 import com.opensymphony.xwork2.Validateable;
  32 import org.apache.commons.lang.StringUtils;
  33 import org.apache.maven.archiva.web.action.AbstractActionSupport;
  34 import org.springframework.context.annotation.Scope;
  35 import org.springframework.stereotype.Controller;
  36
  37 import javax.inject.Inject;
  38 import javax.inject.Named;
  39
  40 /**
  41  * Add a LegacyArtifactPath to archiva configuration
  42  *
  43  * @since 1.1
  44  */
  45 @Controller( "addLegacyArtifactPathAction" )
  46 @Scope( "prototype" )
  47 public class AddLegacyArtifactPathAction
  48     extends AbstractActionSupport
  49     implements Preparable, Validateable
  50 {
  51
  52     @Inject
  53     private ArchivaConfiguration archivaConfiguration;
  54
  55     @Inject
  56     @Named(value = "managedRepositoryContent#legacy")
  57     private ManagedRepositoryContent repositoryContent;
  58
  59
  60     private LegacyArtifactPath legacyArtifactPath;
  61
  62     private String groupId;
  63
  64     private String artifactId;
  65
  66     private String version;
  67
  68     private String classifier;
  69
  70     private String type;
  71
  72
  73     public void prepare()
  74     {
  75         this.legacyArtifactPath = new LegacyArtifactPath();
  76     }
  77
  78     public String input()
  79     {
  80         return INPUT;
  81     }
  82
  83     public String commit()
  84     {
  85         this.legacyArtifactPath.setArtifact( this.groupId + ":" + this.artifactId + ":" + this.version + ":" +
  86             this.classifier + ":" + this.type );
  87
  88         // Check the proposed Artifact macthes the path
  89         ArtifactReference artifact = new ArtifactReference();
  90
  91                 artifact.setGroupId( this.groupId );
  92                 artifact.setArtifactId( this.artifactId );
  93                 artifact.setClassifier( this.classifier );
  94                 artifact.setVersion( this.version );
  95                 artifact.setType( this.type );
  96
  97         String path = repositoryContent.toPath( artifact );
  98         if ( ! path.equals( this.legacyArtifactPath.getPath() ) )
  99         {
 100             addActionError( "artifact reference does not match the initial path : " + path );
 101             return ERROR;
 102         }
 103
 104         Configuration configuration = archivaConfiguration.getConfiguration();
 105         configuration.addLegacyArtifactPath( legacyArtifactPath );
 106         return saveConfiguration( configuration );
 107     }
 108
 109     public LegacyArtifactPath getLegacyArtifactPath()
 110     {
 111         return legacyArtifactPath;
 112     }
 113
 114     public void setLegacyArtifactPath( LegacyArtifactPath legacyArtifactPath )
 115     {
 116         this.legacyArtifactPath = legacyArtifactPath;
 117     }
 118
 119     public void validate()
 120     {
 121         // trim all unecessary trailing/leading white-spaces; always put this statement before the closing braces(after all validation).
 122         trimAllRequestParameterValues();
 123     }
 124
 125     protected String saveConfiguration( Configuration configuration )
 126     {
 127         try
 128         {
 129             archivaConfiguration.save( configuration );
 130             addActionMessage( "Successfully saved configuration" );
 131         }
 132         catch ( IndeterminateConfigurationException e )
 133         {
 134             addActionError( e.getMessage() );
 135             return INPUT;
 136         }
 137         catch ( RegistryException e )
 138         {
 139             addActionError( "Configuration Registry Exception: " + e.getMessage() );
 140             return INPUT;
 141         }
 142
 143         return SUCCESS;
 144     }
 145
 146     private void trimAllRequestParameterValues()
 147     {
 148         if(StringUtils.isNotEmpty(legacyArtifactPath.getPath()))
 149         {
 150             legacyArtifactPath.setPath(legacyArtifactPath.getPath().trim());
 151         }
 152
 153         if(StringUtils.isNotEmpty(groupId))
 154         {
 155             groupId = groupId.trim();
 156         }
 157
 158         if(StringUtils.isNotEmpty(artifactId))
 159         {
 160             artifactId = artifactId.trim();
 161         }
 162
 163         if(StringUtils.isNotEmpty(version))
 164         {
 165             version = version.trim();
 166         }
 167
 168         if(StringUtils.isNotEmpty(classifier))
 169         {
 170             classifier = classifier.trim();
 171         }
 172
 173         if(StringUtils.isNotEmpty(type))
 174         {
 175             type = type.trim();
 176         }
 177     }
 178
 179     public String getGroupId()
 180     {
 181         return groupId;
 182     }
 183
 184     public void setGroupId( String groupId )
 185     {
 186         this.groupId = groupId;
 187     }
 188
 189     public String getArtifactId()
 190     {
 191         return artifactId;
 192     }
 193
 194     public void setArtifactId( String artifactId )
 195     {
 196         this.artifactId = artifactId;
 197     }
 198
 199     public String getVersion()
 200     {
 201         return version;
 202     }
 203
 204     public void setVersion( String version )
 205     {
 206         this.version = version;
 207     }
 208
 209     public String getClassifier()
 210     {
 211         return classifier;
 212     }
 213
 214     public void setClassifier( String classifier )
 215     {
 216         this.classifier = classifier;
 217     }
 218
 219     public String getType()
 220     {
 221         return type;
 222     }
 223
 224     public void setType( String type )
 225     {
 226         this.type = type;
 227     }
 228 }