package org.apache.maven.archetype.mojos;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *   http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 import org.apache.maven.archetype.exception.UnknownArchetype;

 import org.apache.maven.archetype.old.OldArchetype;

 import org.apache.maven.archetype.old.ArchetypeDescriptorException;

 import org.apache.maven.archetype.old.ArchetypeNotFoundException;

 import org.apache.maven.archetype.old.ArchetypeTemplateProcessingException;

 import org.apache.maven.artifact.repository.ArtifactRepository;

 import org.apache.maven.artifact.repository.ArtifactRepositoryFactory;

 import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy;

 import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.project.MavenProject;

 import org.codehaus.plexus.util.StringUtils;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 /**

  * The archetype creation goal looks for an archetype with a given groupId, 

  * artifactId, and version and retrieves it from the remote repository. Once the

  * archetype is retrieved, it is then processed against a set of user parameters

  * to create a working Maven project.

  *

  * @description Creates archetype containers.

  * @requiresProject false

  * @goal create

  * @deprecated Please use the generate mojo instead.

  */

 public class MavenArchetypeMojo

     extends AbstractMojo

 {

     /**

      * Used to create the Archetype specified by the groupId, artifactId, and 

      * version from the remote repository.

      * 

      * @component

      */

     private OldArchetype archetype;

     /**

      * Used to create ArtifactRepository objects given the urls of the remote

      * repositories.

      * 

      * @component

      */

     private ArtifactRepositoryFactory artifactRepositoryFactory;

     /**

      * Determines whether the layout is legacy or not.

      * 

      * @component role="org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout" roleHint="default"

      */

     private ArtifactRepositoryLayout defaultArtifactRepositoryLayout;

     /**

      * Maven's local repository.

      * 

      * @parameter expression="${localRepository}"

      * @required

      */

     private ArtifactRepository localRepository;

     /**

      * The Archetype Group Id to be used.

      * 

      * @parameter expression="${archetypeGroupId}" default-value="org.apache.maven.archetypes"

      * @required

      */

     private String archetypeGroupId;

     /**

      * The Archetype Artifact Id to be used.

      * 

      * @parameter expression="${archetypeArtifactId}" default-value="maven-archetype-quickstart"

      * @required

      */

     private String archetypeArtifactId;

     /**

      * The Archetype Version to be used.

      * 

      * @parameter expression="${archetypeVersion}" default-value="RELEASE"

      * @required

      */

     private String archetypeVersion;

     /**

      * The Group Id of the project to be build.

      * 

      * @parameter expression="${groupId}"

      */

     private String groupId;

     /**

      * The Artifact Id of the project to be build.

      * 

      * @parameter expression="${artifactId}"

      */

     private String artifactId;

     /**

      * The Version of the project to be build.

      * 

      * @parameter expression="${version}" default-value="1.0-SNAPSHOT"

      * @required

      */

     private String version;

     /**

      * The Package Name of the project to be build.

      * 

      * @parameter expression="${packageName}" alias="package"

      */

     private String packageName;

     /**

      * The remote repositories available for discovering dependencies and extensions as indicated

      * by the POM.

      * 

      * @parameter expression="${project.remoteArtifactRepositories}"

      * @required

      */

     private List pomRemoteRepositories;

     /**

      * Other remote repositories available for discovering dependencies and extensions.

      * 

      * @parameter expression="${remoteRepositories}"

      */

     private String remoteRepositories;

     /**

      * The project to be created an archetype of.

      * 

      * @parameter expression="${project}"

      */

     private MavenProject project;

     /**

      * @parameter expression="${basedir}" default-value="${user.dir}"

      */

     private String basedir;

     public void execute()

         throws MojoExecutionException

     {

         getLog().warn( "This goal is deprecated. Please use mvn archetype:generate instead" );

         // TODO: prompt for missing values

         // TODO: configurable license

         // ----------------------------------------------------------------------

         // archetypeGroupId

         // archetypeArtifactId

         // archetypeVersion

         //

         // localRepository

         // remoteRepository

         // parameters

         // ----------------------------------------------------------------------

         if ( project.getFile() != null && groupId == null )

         {

             groupId = project.getGroupId();

         }

         if ( packageName == null )

         {

             getLog().info( "Defaulting package to group ID: " + groupId );

             packageName = groupId;

         }

         // TODO: context mojo more appropriate?

         Map map = new HashMap();

         map.put( "basedir", basedir );

         map.put( "package", packageName );

         map.put( "packageName", packageName );

         map.put( "groupId", groupId );

         map.put( "artifactId", artifactId );

         map.put( "version", version );

         List archetypeRemoteRepositories = new ArrayList( pomRemoteRepositories );

         if ( remoteRepositories != null )

         {

             getLog().info( "We are using command line specified remote repositories: " + remoteRepositories );

             archetypeRemoteRepositories = new ArrayList();

             String[] s = StringUtils.split( remoteRepositories, "," );

             for ( int i = 0; i < s.length; i++ )

             {

                 archetypeRemoteRepositories.add( createRepository( s[i], "id" + i ) );

             }

         }

         try

         {

             archetype.createArchetype(

                     archetypeGroupId, 

                     archetypeArtifactId, 

                     archetypeVersion, 

                     createRepository("http://repo1.maven.org/maven2", "central"), 

                     localRepository, 

                     archetypeRemoteRepositories, 

                     map);            

         }

         catch (UnknownArchetype e) 

         {

             throw new MojoExecutionException( "Error creating from archetype", e );

         }

         catch ( ArchetypeNotFoundException e )

         {

             throw new MojoExecutionException( "Error creating from archetype", e );

         }

         catch ( ArchetypeDescriptorException e )

         {

             throw new MojoExecutionException( "Error creating from archetype", e );

         }

         catch ( ArchetypeTemplateProcessingException e )

         {

             throw new MojoExecutionException( "Error creating from archetype", e );

         }

     }

     //TODO: this should be put in John's artifact utils and used from there instead of being repeated here. Creating

     // artifact repositories is someowhat cumbersome atm.

     public ArtifactRepository createRepository( String url, String repositoryId )

     {

         // snapshots vs releases

         // offline = to turning the update policy off

         //TODO: we'll need to allow finer grained creation of repositories but this will do for now

         String updatePolicyFlag = ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS;

         String checksumPolicyFlag = ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN;

         ArtifactRepositoryPolicy snapshotsPolicy =

             new ArtifactRepositoryPolicy( true, updatePolicyFlag, checksumPolicyFlag );

         ArtifactRepositoryPolicy releasesPolicy =

             new ArtifactRepositoryPolicy( true, updatePolicyFlag, checksumPolicyFlag );

         return artifactRepositoryFactory.createArtifactRepository( repositoryId, url, defaultArtifactRepositoryLayout,

                                                                    snapshotsPolicy, releasesPolicy );

     }

 }