MavenCommandFactory

/*
 * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
 *
 * Licensed 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.
 */
package de.smartics.maven.bugzilla;

import java.util.List;

import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.apache.maven.project.MavenProject;

import de.smartics.maven.bugzilla.AbstractIssueMojo.IssueServer;
import de.smartics.maven.bugzilla.AbstractMojoHelperProduct.ProductInfo;
import de.smartics.maven.issue.command.AddComponentCommand;
import de.smartics.maven.issue.command.AddMilestoneCommand;
import de.smartics.maven.issue.command.AddProductCommand;
import de.smartics.maven.issue.command.AddVersionCommand;
import de.smartics.maven.issue.command.ClassificationNavigationCommand;
import de.smartics.maven.issue.command.CommandArgument;
import de.smartics.maven.issue.command.CommandFactory;
import de.smartics.maven.issue.command.LoginCommand;
import de.smartics.maven.issue.command.LogoutCommand;
import de.smartics.maven.issue.command.ProductNavigationCommand;
import de.smartics.maven.issue.command.UpdateProductCommand;
import de.smartics.maven.issue.config.Component;

/**
 * Factory to create commands within the Maven environment.
 */
final class MavenCommandFactory
{ // NOPMD
  // ********************************* Fields *********************************

  // --- constants ------------------------------------------------------------

  // --- members --------------------------------------------------------------

  /**
   * The Maven project.
   */
  private final MavenProject project;

  /**
   * The command factory for issue management commands.
   */
  private final CommandFactory commandFactory;

  // ****************************** Initializer *******************************

  // ****************************** Constructors ******************************

  MavenCommandFactory(final MavenProject project,
      final CommandFactory commandFactory)
  {
    this.project = project;
    this.commandFactory = commandFactory;
  }

  // ****************************** Inner Classes *****************************

  // ********************************* Methods ********************************

  // --- init -----------------------------------------------------------------

  // --- get&set --------------------------------------------------------------

  // --- business -------------------------------------------------------------

  String calculateNextVersion()
  {
    final String version = project.getVersion();
    final ArtifactVersion artifactVersion = new DefaultArtifactVersion(version);
    final int nextIncrement = artifactVersion.getIncrementalVersion();
    final String nextVersion =
        String.valueOf(artifactVersion.getMajorVersion()) + '.'
            + artifactVersion.getMajorVersion() + '.' + nextIncrement;
    return nextVersion;
  }

  LoginCommand createLoginCommand(final IssueServer server)
  {
    final String loginString = server.getUsername();
    final CommandArgument<LoginCommand> login =
        CommandArgument.create(LoginCommand.Parameter.LOGIN, loginString);
    final String passwordString = server.getPassword();
    final CommandArgument<LoginCommand> password =
        CommandArgument.create(LoginCommand.Parameter.PASSWORD, passwordString,
            true);
    final LoginCommand command =
        commandFactory.createLoginCommand(login, password);
    return command;
  }

  AddVersionCommand createAddVersionCommand(final String productString,
      final String nextVersionString, final String tokenString)
  {
    final CommandArgument<AddVersionCommand> product =
        CommandArgument.create(AddVersionCommand.Parameter.PRODUCT,
            productString);
    final CommandArgument<AddVersionCommand> version =
        CommandArgument.create(AddVersionCommand.Parameter.VERSION,
            nextVersionString);
    final CommandArgument<AddVersionCommand> token =
        CommandArgument.create(AddVersionCommand.Parameter.TOKEN, tokenString);
    final AddVersionCommand command =
        commandFactory.createAddVersionCommand(product, version, token);
    return command;
  }

  AddMilestoneCommand createAddMilestoneCommand(final String productString,
      final String nextMilestoneString, final String sortkeyString,
      final String tokenString)
  {
    final CommandArgument<AddMilestoneCommand> product =
        CommandArgument.create(AddMilestoneCommand.Parameter.PRODUCT,
            productString);
    final CommandArgument<AddMilestoneCommand> milestone =
        CommandArgument.create(AddMilestoneCommand.Parameter.MILESTONE,
            nextMilestoneString);
    final CommandArgument<AddMilestoneCommand> sortkey =
        CommandArgument.create(AddMilestoneCommand.Parameter.SORTKEY,
            sortkeyString);
    final CommandArgument<AddMilestoneCommand> token =
        CommandArgument
            .create(AddMilestoneCommand.Parameter.TOKEN, tokenString);
    final AddMilestoneCommand command =
        commandFactory.createAddMilestoneCommand(product, milestone, sortkey,
            token);
    return command;
  }

  // CHECKSTYLE:OFF
  AddProductCommand createAddProductCommand(
      // NOPMD
      final String classificationString, final String productString,
      final String descriptionString, final String defaultMilestoneString,
      final String versionString, final String tokenString,
      final ProductInfo productInfo, final List<Component> components)
  {
    final CommandArgument<AddProductCommand> classification =
        CommandArgument.create(AddProductCommand.Parameter.CLASSIFICATION,
            classificationString);
    final CommandArgument<AddProductCommand> product =
        CommandArgument.create(AddProductCommand.Parameter.PRODUCT,
            productString);
    final CommandArgument<AddProductCommand> description =
        CommandArgument.create(AddProductCommand.Parameter.DESCRIPTION,
            descriptionString);
    final CommandArgument<AddProductCommand> defaultMilestone =
        CommandArgument.create(AddProductCommand.Parameter.DEFAULT_MILESTONE,
            defaultMilestoneString);
    final CommandArgument<AddProductCommand> version =
        CommandArgument.create(AddProductCommand.Parameter.VERSION,
            versionString);
    final CommandArgument<AddProductCommand> token =
        CommandArgument.create(AddProductCommand.Parameter.TOKEN, tokenString);

    final AddProductCommand command;
    if (commandFactory.requiresComponentOnProductCreation()
        && !components.isEmpty())
    {
      final Component component = components.get(0);
      final CommandArgument<AddProductCommand> componentArg =
          CommandArgument.create(AddProductCommand.Parameter.COMPONENT,
              component.getName());
      final CommandArgument<AddProductCommand> componentDescription =
          CommandArgument.create(
              AddProductCommand.Parameter.COMPONENT_DESCRIPTION,
              component.getDescription());
      final CommandArgument<AddProductCommand> componentInitialOwner =
          CommandArgument.create(
              AddProductCommand.Parameter.COMPONENT_INITIAL_OWNER,
              productInfo.getInitialOwner());
      command =
          commandFactory.createAddProductCommand(classification, product,
              description, defaultMilestone, version, token, componentArg,
              componentDescription, componentInitialOwner);
    }
    else
    {
      command =
          commandFactory.createAddProductCommand(classification, product,
              description, defaultMilestone, version, token);
    }

    return command;
  }

  // CHECKSTYLE:ON

  // CHECKSTYLE:OFF
  UpdateProductCommand createUpdateProductCommand(
      // NOPMD
      final String productOldString, final String productString,
      final String descriptionString, final String defaultMilestoneString,
      final String tokenString)
  {
    final CommandArgument<UpdateProductCommand> oldProduct =
        CommandArgument.create(UpdateProductCommand.Parameter.PRODUCT_OLD_NAME,
            productOldString);
    final CommandArgument<UpdateProductCommand> product =
        CommandArgument.create(UpdateProductCommand.Parameter.PRODUCT,
            productString);
    final CommandArgument<UpdateProductCommand> description =
        CommandArgument.create(UpdateProductCommand.Parameter.DESCRIPTION,
            descriptionString);
    final CommandArgument<UpdateProductCommand> defaultMilestone =
        CommandArgument.create(
            UpdateProductCommand.Parameter.DEFAULT_MILESTONE,
            defaultMilestoneString);
    final CommandArgument<UpdateProductCommand> token =
        CommandArgument.create(UpdateProductCommand.Parameter.TOKEN,
            tokenString);
    final UpdateProductCommand command =
        commandFactory.createUpdateProductCommand(oldProduct, product,
            description, defaultMilestone, token);
    return command;
  }

  // CHECKSTYLE:ON

  AddComponentCommand createAddComponentCommand(final String productString,
      final String componentString, final String descriptionString,
      final String initialOwnerString, final String tokenString)
  {
    final CommandArgument<AddComponentCommand> product =
        CommandArgument.create(AddComponentCommand.Parameter.PRODUCT,
            productString);
    final CommandArgument<AddComponentCommand> component =
        CommandArgument.create(AddComponentCommand.Parameter.COMPONENT,
            componentString);
    final CommandArgument<AddComponentCommand> description =
        CommandArgument.create(AddComponentCommand.Parameter.DESCRIPTION,
            descriptionString);
    final CommandArgument<AddComponentCommand> initialOwner =
        CommandArgument.create(AddComponentCommand.Parameter.INITIAL_OWNER,
            initialOwnerString);
    final CommandArgument<AddComponentCommand> token =
        CommandArgument
            .create(AddComponentCommand.Parameter.TOKEN, tokenString);
    final AddComponentCommand command =
        commandFactory.createAddComponentCommand(product, component,
            description, initialOwner, token);
    return command;
  }

  LogoutCommand createLogoutCommand()
  {
    final LogoutCommand command = commandFactory.createLogoutCommand();
    return command;
  }

  // TODO: Create a class for this command
  ClassificationNavigationCommand createClassificationNavigationCommand(
      final String classificationString)
  {
    final CommandArgument<ClassificationNavigationCommand> classification =
        CommandArgument.create(
            ClassificationNavigationCommand.Parameter.CLASSIFICATION,
            classificationString);
    final ClassificationNavigationCommand command =
        commandFactory.createClassificationNavigationCommand(
            "editproducts.cgi", classification);
    return command;
  }

  // TODO: Create a class for this command
  ProductNavigationCommand createVersionProductNavigationCommand(
      final String productString)
  {
    return createProductNavigationCommand("editversions.cgi", productString);
  }

  // TODO: Create a class for this command
  ProductNavigationCommand createMilestoneProductNavigationCommand(
      final String productString)
  {
    return createProductNavigationCommand("editmilestones.cgi", productString);
  }

  // TODO: Create a class for this command
  ProductNavigationCommand createComponentProductNavigationCommand(
      final String productString)
  {
    return createProductNavigationCommand("editcomponents.cgi", productString);
  }

  // TODO: Create a class for this command
  ProductNavigationCommand createProductNavigationCommand(
      final String productString)
  {
    final CommandArgument<ProductNavigationCommand> action =
        CommandArgument.create(ProductNavigationCommand.Parameter.ACTION,
            "edit");
    final CommandArgument<ProductNavigationCommand> product =
        CommandArgument.create(ProductNavigationCommand.Parameter.PRODUCT,
            productString);
    final ProductNavigationCommand command =
        commandFactory.createProductNavigationCommand("editproducts.cgi",
            action, product);
    return command;
  }

  private ProductNavigationCommand createProductNavigationCommand(
      final String service, final String productString)
  {
    final CommandArgument<ProductNavigationCommand> product =
        CommandArgument.create(ProductNavigationCommand.Parameter.PRODUCT,
            productString);
    final ProductNavigationCommand command =
        commandFactory.createProductNavigationCommand(service, product);
    return command;
  }

  // --- object basics --------------------------------------------------------

}