package org.apache.maven.scm.provider.integrity;
   
   /*
    * 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 com.mks.api.Command;
  import com.mks.api.MultiValue;
  import com.mks.api.Option;
  import com.mks.api.response.APIException;
  import com.mks.api.response.Field;
  import com.mks.api.response.Item;
  import com.mks.api.response.Response;
  import com.mks.api.response.WorkItem;
  import com.mks.api.response.WorkItemIterator;
  import com.mks.api.si.SIModelTypeName;
  import org.apache.maven.scm.ChangeFile;
  import org.apache.maven.scm.ChangeSet;
  import org.apache.maven.scm.ScmFile;
  import org.apache.maven.scm.ScmFileStatus;
  import org.apache.maven.scm.command.changelog.ChangeLogSet;
  import org.codehaus.plexus.util.StringUtils;
  
  import java.io.File;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.List;
  
  /**
   * This class represents an MKS Integrity Sandbox and provides an encapsulation
   * for executing typical Sandbox operations
   *
   * @author <a href="mailto:cletus@mks.com">Cletus D'Souza</a>
   * @since 1.6
   */
  public class Sandbox
  {
      // Our date format
      public static final SimpleDateFormat RLOG_DATEFORMAT = new SimpleDateFormat( "MMMMM d, yyyy - h:mm:ss a" );
  
      // File Separator
      private String fs = System.getProperty( "file.separator" );
  
      // MKS API Session Object
      private APISession api;
  
      // Other sandbox specific class variables
      private Project siProject;
  
      private String sandboxDir;
  
      private String cpid;
  
      // Flag to indicate the overall add operation was successful
      private boolean addSuccess;
  
      // Flag to indicate the overall check-in operation was successful
      private boolean ciSuccess;
  
      /**
       * Fixes the default includes/excludes patterns for compatibility with MKS Integrity's 'si viewnonmembers' command
       *
       * @param pattern String pattern representing the includes/excludes file/directory list
       */
      public static String formatFilePatterns( String pattern )
      {
          StringBuilder sb = new StringBuilder();
          if ( null != pattern && pattern.length() > 0 )
          {
              String[] tokens = StringUtils.split( pattern, "," );
              for ( int i = 0; i < tokens.length; i++ )
              {
                  String tkn = tokens[i].trim();
                  if ( tkn.indexOf( "file:" ) != 0 && tkn.indexOf( "dir:" ) != 0 )
                  {
                      sb.append( tkn.indexOf( '.' ) > 0
                                     ? StringUtils.replaceOnce( tkn, "**/", "file:" )
                                     : StringUtils.replaceOnce( tkn, "**/", "dir:" ) );
                  }
                  else
                  {
                     sb.append( tkn );
                 }
                 sb.append( i < tokens.length ? "," : "" );
             }
         }
         return sb.toString();
     }
 
     /**
      * The Sandbox constructor
      *
      * @param api       MKS API Session object
      * @param cmProject Project object
      * @param dir       Absolute path to the location for the Sandbox directory
      */
     public Sandbox( APISession api, Project cmProject, String dir )
     {
         siProject = cmProject;
         sandboxDir = dir;
         this.api = api;
         cpid = System.getProperty( "maven.scm.integrity.cpid" );
         cpid = ( ( null == cpid || cpid.length() == 0 ) ? ":none" : cpid );
         addSuccess = true;
         ciSuccess = true;
     }
 
     /**
      * Attempts to figure out if the current sandbox already exists and is valid
      *
      * @param sandbox The client-side fully qualified path to the sandbox pj
      * @return true/false depending on whether or not this location has a valid sandbox
      * @throws APIException
      */
     private boolean isValidSandbox( String sandbox )
         throws APIException
     {
         Command cmd = new Command( Command.SI, "sandboxinfo" );
         cmd.addOption( new Option( "sandbox", sandbox ) );
 
         api.getLogger().debug( "Validating existing sandbox: " + sandbox );
         Response res = api.runCommand( cmd );
         WorkItemIterator wit = res.getWorkItems();
         try
         {
             WorkItem wi = wit.next();
             return wi.getField( "fullConfigSyntax" ).getValueAsString().equalsIgnoreCase(
                 siProject.getConfigurationPath() );
         }
         catch ( APIException aex )
         {
             ExceptionHandler eh = new ExceptionHandler( aex );
             api.getLogger().error( "MKS API Exception: " + eh.getMessage() );
             api.getLogger().debug( eh.getCommand() + " completed with exit code " + eh.getExitCode() );
             return false;
         }
     }
 
     /**
      * Inspects the MKS API Response object's Item field to determine whether or not a working file delta exists
      *
      * @param wfdelta MKS API Response object's Item representing the Working File Delta
      * @return true if the working file is a delta; false otherwise
      */
     private boolean isDelta( Item wfdelta )
     {
         // Return false if there is no working file
         return wfdelta.getField( "isDelta" ).getBoolean().booleanValue();
     }
 
     /**
      * Executes a 'si add' command using the message for the description
      *
      * @param memberFile Full path to the new member's location
      * @param message    Description for the new member's archive
      * @return MKS API Response object
      * @throws APIException
      */
     private Response add( File memberFile, String message )
         throws APIException
     {
         // Setup the add command
         api.getLogger().info( "Adding member: " + memberFile.getAbsolutePath() );
         Command siAdd = new Command( Command.SI, "add" );
         siAdd.addOption( new Option( "onExistingArchive", "sharearchive" ) );
         siAdd.addOption( new Option( "cpid", cpid ) );
         if ( null != message && message.length() > 0 )
         {
             siAdd.addOption( new Option( "description", message ) );
         }
         siAdd.addOption( new Option( "cwd", memberFile.getParentFile().getAbsolutePath() ) );
         siAdd.addSelection( memberFile.getName() );
         return api.runCommand( siAdd );
     }
 
     /**
      * Executes a 'si ci' command using the relativeName for the member name and message for the description
      *
      * @param memberFile   Full path to the member's current sandbox location
      * @param relativeName Relative path from the nearest subproject or project
      * @param message      Description for checking in the new update
      * @return MKS API Response object
      * @throws APIException
      */
     private Response checkin( File memberFile, String relativeName, String message )
         throws APIException
     {
         // Setup the check-in command
         api.getLogger().info( "Checking in member:  " + memberFile.getAbsolutePath() );
         Command sici = new Command( Command.SI, "ci" );
         sici.addOption( new Option( "cpid", cpid ) );
         if ( null != message && message.length() > 0 )
         {
             sici.addOption( new Option( "description", message ) );
         }
         sici.addOption( new Option( "cwd", memberFile.getParentFile().getAbsolutePath() ) );
         sici.addSelection( relativeName );
         return api.runCommand( sici );
     }
 
     /**
      * Executes a 'si drop' command using the relativeName for the member name
      *
      * @param memberFile   Full path to the member's current sandbox location
      * @param relativeName Relative path from the nearest subproject or project
      * @return MKS API Response object
      * @throws APIException
      */
     private Response dropMember( File memberFile, String relativeName )
         throws APIException
     {
         // Setup the drop command
         api.getLogger().info( "Dropping member " + memberFile.getAbsolutePath() );
         Command siDrop = new Command( Command.SI, "drop" );
         siDrop.addOption( new Option( "cwd", memberFile.getParentFile().getAbsolutePath() ) );
         siDrop.addOption( new Option( "noconfirm" ) );
         siDrop.addOption( new Option( "cpid", cpid ) );
         siDrop.addOption( new Option( "delete" ) );
         siDrop.addSelection( relativeName );
         return api.runCommand( siDrop );
     }
 
     /**
      * Executes a 'si diff' command to see if the working file has actually changed.  Even though the
      * working file delta might be true, that doesn't always mean the file has actually changed.
      *
      * @param memberFile   Full path to the member's current sandbox location
      * @param relativeName Relative path from the nearest subproject or project
      * @return MKS API Response object
      */
     private boolean hasMemberChanged( File memberFile, String relativeName )
     {
         // Setup the differences command
         Command siDiff = new Command( Command.SI, "diff" );
         siDiff.addOption( new Option( "cwd", memberFile.getParentFile().getAbsolutePath() ) );
         siDiff.addSelection( relativeName );
         try
         {
             // Run the diff command...
             Response res = api.runCommand( siDiff );
             try
             {
                 // Return the changed flag...
                 return res.getWorkItems().next().getResult().getField( "resultant" ).getItem().getField(
                     "different" ).getBoolean().booleanValue();
             }
             catch ( NullPointerException npe )
             {
                 api.getLogger().warn( "Couldn't figure out differences for file: " + memberFile.getAbsolutePath() );
                 api.getLogger().warn(
                     "Null value found along response object for WorkItem/Result/Field/Item/Field.getBoolean()" );
                 api.getLogger().warn( "Proceeding with the assumption that the file has changed!" );
             }
         }
         catch ( APIException aex )
         {
             ExceptionHandler eh = new ExceptionHandler( aex );
             api.getLogger().warn( "Couldn't figure out differences for file: " + memberFile.getAbsolutePath() );
             api.getLogger().warn( eh.getMessage() );
             api.getLogger().warn( "Proceeding with the assumption that the file has changed!" );
             api.getLogger().debug( eh.getCommand() + " completed with exit Code " + eh.getExitCode() );
         }
         return true;
     }
 
     /**
      * Returns the full path name to the current Sandbox directory
      *
      * @return
      */
     public String getSandboxDir()
     {
         return sandboxDir;
     }
 
     /**
      * Executes a 'si lock' command using the relativeName of the file
      *
      * @param memberFile   Full path to the member's current sandbox location
      * @param relativeName Relative path from the nearest subproject or project
      * @return MKS API Response object
      * @throws APIException
      */
     public Response lock( File memberFile, String relativeName )
         throws APIException
     {
         // Setup the lock command
         api.getLogger().debug( "Locking member: " + memberFile.getAbsolutePath() );
         Command siLock = new Command( Command.SI, "lock" );
         siLock.addOption( new Option( "revision", ":member" ) );
         siLock.addOption( new Option( "cpid", cpid ) );
         siLock.addOption( new Option( "cwd", memberFile.getParentFile().getAbsolutePath() ) );
         siLock.addSelection( relativeName );
         // Execute the lock command
         return api.runCommand( siLock );
     }
 
     /**
      * Executes a 'si unlock' command using the relativeName of the file
      *
      * @param memberFile   Full path to the member's current sandbox location
      * @param relativeName Relative path from the nearest subproject or project
      * @return MKS API Response object
      * @throws APIException
      */
     public Response unlock( File memberFile, String relativeName )
         throws APIException
     {
         // Setup the unlock command
         api.getLogger().debug( "Unlocking member: " + memberFile.getAbsolutePath() );
         Command siUnlock = new Command( Command.SI, "unlock" );
         siUnlock.addOption( new Option( "revision", ":member" ) );
         siUnlock.addOption( new Option( "action", "remove" ) );
         siUnlock.addOption( new Option( "cwd", memberFile.getParentFile().getAbsolutePath() ) );
         siUnlock.addSelection( relativeName );
         // Execute the unlock command
         return api.runCommand( siUnlock );
     }
 
     /**
      * Removes the registration for the Sandbox in the user's profile
      *
      * @return The API Response associated with executing this command
      * @throws APIException
      */
     public Response drop()
         throws APIException
     {
         File project = new File( siProject.getProjectName() );
         File sandboxpj = new File( sandboxDir + fs + project.getName() );
 
         // Check to see if the sandbox file already exists and its OK to use
         api.getLogger().debug( "Sandbox Project File: " + sandboxpj.getAbsolutePath() );
         Command cmd = new Command( Command.SI, "dropsandbox" );
         cmd.addOption( new Option( "delete", "members" ) );
         cmd.addOption( new Option( "sandbox", sandboxpj.getAbsolutePath() ) );
         cmd.addOption( new Option( "cwd", sandboxDir ) );
         return api.runCommand( cmd );
     }
 
     /**
      * Creates a new Sandbox in the sandboxDir specified
      *
      * @return true if the operation is successful; false otherwise
      * @throws APIException
      */
     public boolean create()
         throws APIException
     {
         File project = new File( siProject.getProjectName() );
         File sandboxpj = new File( sandboxDir + fs + project.getName() );
 
         // Check to see if the sandbox file already exists and its OK to use
         api.getLogger().debug( "Sandbox Project File: " + sandboxpj.getAbsolutePath() );
         if ( sandboxpj.isFile() )
         {
             // Validate this sandbox
             if ( isValidSandbox( sandboxpj.getAbsolutePath() ) )
             {
                 api.getLogger().debug(
                     "Reusing existing Sandbox in " + sandboxDir + " for project " + siProject.getConfigurationPath() );
                 return true;
             }
             else
             {
                 api.getLogger().error(
                     "An invalid Sandbox exists in " + sandboxDir + ". Please provide a different location!" );
                 return false;
             }
         }
         else // Create a new sandbox in the location specified
         {
             api.getLogger().debug(
                 "Creating Sandbox in " + sandboxDir + " for project " + siProject.getConfigurationPath() );
             try
             {
                 Command cmd = new Command( Command.SI, "createsandbox" );
                 cmd.addOption( new Option( "recurse" ) );
                 cmd.addOption( new Option( "nopopulate" ) );
                 cmd.addOption( new Option( "project", siProject.getConfigurationPath() ) );
                 cmd.addOption( new Option( "cwd", sandboxDir ) );
                 api.runCommand( cmd );
             }
             catch ( APIException aex )
             {
                 // Check to see if this exception is due an existing sandbox registry entry
                 ExceptionHandler eh = new ExceptionHandler( aex );
                 if ( eh.getMessage().indexOf( "There is already a registered entry" ) > 0 )
                 {
                     // This will re-validate the sandbox, if Maven blew away the old directory
                     return create();
                 }
                 else
                 {
                     throw aex;
                 }
             }
             return true;
         }
     }
 
     /**
      * Resynchronizes an existing Sandbox
      * Assumes that the create() call has already been made to validate this sandbox
      *
      * @throws APIException
      */
     public Response resync()
         throws APIException
     {
         api.getLogger().debug(
             "Resynchronizing Sandbox in " + sandboxDir + " for project " + siProject.getConfigurationPath() );
         Command cmd = new Command( Command.SI, "resync" );
         cmd.addOption( new Option( "recurse" ) );
         cmd.addOption( new Option( "populate" ) );
         cmd.addOption( new Option( "cwd", sandboxDir ) );
         return api.runCommand( cmd );
     }
 
     /**
      * Executes a 'si makewritable' command to allow edits to all files in the Sandbox directory
      *
      * @return MKS API Response object
      * @throws APIException
      */
     public Response makeWriteable()
         throws APIException
     {
         api.getLogger().debug(
             "Setting files to writeable in " + sandboxDir + " for project " + siProject.getConfigurationPath() );
         Command cmd = new Command( Command.SI, "makewritable" );
         cmd.addOption( new Option( "recurse" ) );
         cmd.addOption( new Option( "cwd", sandboxDir ) );
         return api.runCommand( cmd );
     }
 
     /**
      * Executes a 'si revert' command to roll back changes to all files in the Sandbox directory
      *
      * @return MKS API Response object
      * @throws APIException
      */
     public Response revertMembers()
         throws APIException
     {
         api.getLogger().debug(
             "Reverting changes in sandbox " + sandboxDir + " for project " + siProject.getConfigurationPath() );
         Command cmd = new Command( Command.SI, "revert" );
         cmd.addOption( new Option( "recurse" ) );
         cmd.addOption( new Option( "cwd", sandboxDir ) );
         return api.runCommand( cmd );
     }
 
     /**
      * Executes a 'si viewnonmembers' command filtering the results using the exclude and include lists
      *
      * @param exclude Pattern containing the exclude file list
      * @param include Pattern containing the include file list
      * @return List of ScmFile objects representing the new files in the Sandbox
      * @throws APIException
      */
     public List<ScmFile> getNewMembers( String exclude, String include )
         throws APIException
     {
         // Store a list of files that were added to the repository
         List<ScmFile> filesAdded = new ArrayList<ScmFile>();
         Command siViewNonMem = new Command( Command.SI, "viewnonmembers" );
         siViewNonMem.addOption( new Option( "recurse" ) );
         if ( null != exclude && exclude.length() > 0 )
         {
             siViewNonMem.addOption( new Option( "exclude", exclude ) );
         }
         if ( null != include && include.length() > 0 )
         {
             siViewNonMem.addOption( new Option( "include", include ) );
         }
         siViewNonMem.addOption( new Option( "noincludeFormers" ) );
         siViewNonMem.addOption( new Option( "cwd", sandboxDir ) );
         Response response = api.runCommand( siViewNonMem );
         for ( WorkItemIterator wit = response.getWorkItems(); wit.hasNext(); )
         {
             filesAdded.add(
                 new ScmFile( wit.next().getField( "absolutepath" ).getValueAsString(), ScmFileStatus.ADDED ) );
         }
         return filesAdded;
 
     }
 
     /**
      * Adds a list of files to the MKS Integrity SCM Project
      *
      * @param exclude Pattern containing the exclude file list
      * @param include Pattern containing the include file list
      * @param message Description for the member's archive
      * @return
      */
     public List<ScmFile> addNonMembers( String exclude, String include, String message )
     {
         // Re-initialize the overall addSuccess to be true for now
         addSuccess = true;
         // Store a list of files that were actually added to the repository
         List<ScmFile> filesAdded = new ArrayList<ScmFile>();
         api.getLogger().debug( "Looking for new members in sandbox dir: " + sandboxDir );
         try
         {
             List<ScmFile> newFileList = getNewMembers( exclude, include );
             for ( Iterator<ScmFile> sit = newFileList.iterator(); sit.hasNext(); )
             {
                 try
                 {
                     ScmFile localFile = sit.next();
                     // Attempt to add the file to the Integrity repository
                     add( new File( localFile.getPath() ), message );
                     // If it was a success, then add it to the list of files that were actually added
                     filesAdded.add( localFile );
                 }
                 catch ( APIException aex )
                 {
                     // Set the addSuccess to false, since we ran into a problem
                     addSuccess = false;
                     ExceptionHandler eh = new ExceptionHandler( aex );
                     api.getLogger().error( "MKS API Exception: " + eh.getMessage() );
                     api.getLogger().debug( eh.getCommand() + " completed with exit Code " + eh.getExitCode() );
                 }
             }
         }
         catch ( APIException aex )
         {
             // Set the addSuccess to false, since we ran into a problem
             addSuccess = false;
             ExceptionHandler eh = new ExceptionHandler( aex );
             api.getLogger().error( "MKS API Exception: " + eh.getMessage() );
             api.getLogger().debug( eh.getCommand() + " completed with exit Code " + eh.getExitCode() );
         }
         return filesAdded;
     }
 
     /**
      * Returns the overall success of the add operation
      *
      * @return
      */
     public boolean getOverallAddSuccess()
     {
         return addSuccess;
     }
 
     /**
      * Inspects the MKS API Response object's Item field to determine whether or nor a working file exists
      *
      * @param wfdelta MKS API Response object's Item representing the Working File Delta
      * @return
      */
     public boolean hasWorkingFile( Item wfdelta )
     {
         // Return false if there is no working file
         return !wfdelta.getField( "noWorkingFile" ).getBoolean().booleanValue();
     }
 
     /**
      * Executes a 'si viewsandbox' and parses the output for changed or dropped working files
      *
      * @return A list of MKS API Response WorkItem objects representing the changes in the Sandbox
      * @throws APIException
      */
     public List<WorkItem> getChangeList()
         throws APIException
     {
         // Store a list of files that were changed/removed to the repository
         List<WorkItem> changedFiles = new ArrayList<WorkItem>();
         // Setup the view sandbox command to figure out what has changed...
         Command siViewSandbox = new Command( Command.SI, "viewsandbox" );
         // Create the --fields option
         MultiValue mv = new MultiValue( "," );
         mv.add( "name" );
         mv.add( "context" );
         mv.add( "wfdelta" );
         mv.add( "memberarchive" );
         siViewSandbox.addOption( new Option( "fields", mv ) );
         siViewSandbox.addOption( new Option( "recurse" ) );
         siViewSandbox.addOption( new Option( "noincludeDropped" ) );
         siViewSandbox.addOption( new Option( "filterSubs" ) );
         siViewSandbox.addOption( new Option( "cwd", sandboxDir ) );
 
         // Run the view sandbox command
         Response r = api.runCommand( siViewSandbox );
         // Check-in all changed files, drop all members with missing working files
         for ( WorkItemIterator wit = r.getWorkItems(); wit.hasNext(); )
         {
             WorkItem wi = wit.next();
             api.getLogger().debug( "Inspecting file: " + wi.getField( "name" ).getValueAsString() );
 
             if ( wi.getModelType().equals( SIModelTypeName.MEMBER ) )
             {
                 Item wfdeltaItem = (Item) wi.getField( "wfdelta" ).getValue();
                 // Proceed with this entry only if it is an actual working file delta
                 if ( isDelta( wfdeltaItem ) )
                 {
                     File memberFile = new File( wi.getField( "name" ).getValueAsString() );
                     if ( hasWorkingFile( wfdeltaItem ) )
                     {
                         // Only report on files that have actually changed...
                         if ( hasMemberChanged( memberFile, wi.getId() ) )
                         {
                             changedFiles.add( wi );
                         }
                     }
                     else
                     {
                         // Also report on dropped files
                         changedFiles.add( wi );
                     }
                 }
             }
         }
         return changedFiles;
     }
 
     /**
      * Wrapper function to check-in all changes and drop members associated with missing working files
      *
      * @param message Description for the changes
      * @return
      */
     public List<ScmFile> checkInUpdates( String message )
     {
         // Re-initialize the overall ciSuccess to be true for now
         ciSuccess = true;
         // Store a list of files that were changed/removed to the repository
         List<ScmFile> changedFiles = new ArrayList<ScmFile>();
         api.getLogger().debug( "Looking for changed and dropped members in sandbox dir: " + sandboxDir );
 
         try
         {
             // Let the list of changed files
             List<WorkItem> changeList = getChangeList();
             // Check-in all changed files, drop all members with missing working files
             for ( Iterator<WorkItem> wit = changeList.iterator(); wit.hasNext(); )
             {
                 try
                 {
                     WorkItem wi = wit.next();
                     File memberFile = new File( wi.getField( "name" ).getValueAsString() );
                     // Check-in files that have actually changed...
                     if ( hasWorkingFile( (Item) wi.getField( "wfdelta" ).getValue() ) )
                     {
                         // Lock each member as you go...
                         lock( memberFile, wi.getId() );
                         // Commit the changes...
                         checkin( memberFile, wi.getId(), message );
                         // Update the changed file list
                         changedFiles.add( new ScmFile( memberFile.getAbsolutePath(), ScmFileStatus.CHECKED_IN ) );
                     }
                     else
                     {
                         // Drop the member if there is no working file
                         dropMember( memberFile, wi.getId() );
                         // Update the changed file list
                         changedFiles.add( new ScmFile( memberFile.getAbsolutePath(), ScmFileStatus.DELETED ) );
                     }
                 }
                 catch ( APIException aex )
                 {
                     // Set the ciSuccess to false, since we ran into a problem
                     ciSuccess = false;
                     ExceptionHandler eh = new ExceptionHandler( aex );
                     api.getLogger().error( "MKS API Exception: " + eh.getMessage() );
                     api.getLogger().debug( eh.getCommand() + " completed with exit Code " + eh.getExitCode() );
                 }
             }
         }
         catch ( APIException aex )
         {
             // Set the ciSuccess to false, since we ran into a problem
             ciSuccess = false;
             ExceptionHandler eh = new ExceptionHandler( aex );
             api.getLogger().error( "MKS API Exception: " + eh.getMessage() );
             api.getLogger().debug( eh.getCommand() + " completed with exit Code " + eh.getExitCode() );
         }
 
         return changedFiles;
     }
 
     /**
      * Returns the overall success of the check-in operation
      *
      * @return
      */
     public boolean getOverallCheckInSuccess()
     {
         return ciSuccess;
     }
 
     /**
      * Creates one subproject per directory, as required.
      *
      * @param dirPath A relative path structure of folders
      * @return Response containing the result for the created subproject
      * @throws APIException
      */
     public Response createSubproject( String dirPath )
         throws APIException
     {
         // Setup the create subproject command
         api.getLogger().debug( "Creating subprojects for: " + dirPath + "/project.pj" );
         Command siCreateSubproject = new Command( Command.SI, "createsubproject" );
         siCreateSubproject.addOption( new Option( "cpid", cpid ) );
         siCreateSubproject.addOption( new Option( "createSubprojects" ) );
         siCreateSubproject.addOption( new Option( "cwd", sandboxDir ) );
         siCreateSubproject.addSelection( dirPath + "/project.pj" );
         // Execute the create subproject command
         return api.runCommand( siCreateSubproject );
     }
 
     /**
      * Executes the 'si rlog' command to generate a list of changed revision found between startDate and endDate
      *
      * @param startDate The date range for the beginning of the operation
      * @param endDate   The date range for the end of the operation
      * @return ChangeLogSet containing a list of changes grouped by Change Package ID
      * @throws APIException
      */
     public ChangeLogSet getChangeLog( Date startDate, Date endDate )
         throws APIException
     {
         // Initialize our return object
         ChangeLogSet changeLog = new ChangeLogSet( startDate, endDate );
         // By default we're going to group-by change package
         // Non change package changes will be lumped into one big Change Set
         Hashtable<String, ChangeSet> changeSetHash = new Hashtable<String, ChangeSet>();
 
         // Lets prepare our si rlog command for execution
         Command siRlog = new Command( Command.SI, "rlog" );
         siRlog.addOption( new Option( "recurse" ) );
         MultiValue rFilter = new MultiValue( ":" );
         rFilter.add( "daterange" );
         rFilter.add( "'" + RLOG_DATEFORMAT.format( startDate ) + "'-'" + RLOG_DATEFORMAT.format( endDate ) + "'" );
         siRlog.addOption( new Option( "rfilter", rFilter ) );
         siRlog.addOption( new Option( "cwd", sandboxDir ) );
         // Execute the si rlog command
         Response response = api.runCommand( siRlog );
         for ( WorkItemIterator wit = response.getWorkItems(); wit.hasNext(); )
         {
             WorkItem wi = wit.next();
             String memberName = wi.getContext();
             // We're going to have to do a little dance to get the correct server file name
             memberName = memberName.substring( 0, memberName.lastIndexOf( '/' ) );
             memberName = memberName + '/' + wi.getId();
             memberName = memberName.replace( '\\', '/' );
             // Now lets get the revisions for this file
             Field revisionsFld = wi.getField( "revisions" );
             if ( null != revisionsFld && revisionsFld.getDataType().equals( Field.ITEM_LIST_TYPE )
                 && null != revisionsFld.getList() )
             {
                 @SuppressWarnings( "unchecked" ) List<Item> revList = revisionsFld.getList();
                 for ( Iterator<Item> lit = revList.iterator(); lit.hasNext(); )
                 {
                     Item revisionItem = lit.next();
                     String revision = revisionItem.getId();
                     String author = revisionItem.getField( "author" ).getItem().getId();
                     // Attempt to get the full name, if available
                     try
                     {
                         author = revisionItem.getField( "author" ).getItem().getField( "fullname" ).getValueAsString();
                     }
                     catch ( NullPointerException npe )
                     { /* ignore */ }
                     String cpid = ":none";
                     // Attempt to get the cpid for this revision
                     try
                     {
                         cpid = revisionItem.getField( "cpid" ).getItem().getId();
                     }
                     catch ( NullPointerException npe )
                     { /* ignore */ }
                     // Get the Change Package summary for this revision
                     String comment = cpid + ": " + revisionItem.getField( "cpsummary" ).getValueAsString();
                     // Get the date associated with this revision
                     Date date = revisionItem.getField( "date" ).getDateTime();
 
                     // Lets create our ChangeFile based on the information we've gathered so far
                     ChangeFile changeFile = new ChangeFile( memberName, revision );
 
                     // Check to see if we already have a ChangeSet grouping for this revision
                     ChangeSet changeSet = changeSetHash.get( cpid );
                     if ( null != changeSet )
                     {
                         // Set the date of the ChangeSet to the oldest entry
                         if ( changeSet.getDate().after( date ) )
                         {
                             changeSet.setDate( date );
                         }
                         // Add the new ChangeFile
                         changeSet.addFile( changeFile );
                         // Update the changeSetHash
                         changeSetHash.put( cpid, changeSet );
                     }
                     else // Create a new ChangeSet grouping and add the ChangeFile
                     {
                         List<ChangeFile> changeFileList = new ArrayList<ChangeFile>();
                         changeFileList.add( changeFile );
                         changeSet = new ChangeSet( date, comment, author, changeFileList );
                         // Update the changeSetHash with an initial entry for the cpid
                         changeSetHash.put( cpid, changeSet );
                     }
                 }
             }
 
         }
 
         // Update the Change Log with the Change Sets
         List<ChangeSet> changeSetList = new ArrayList<ChangeSet>();
         changeSetList.addAll( changeSetHash.values() );
         changeLog.setChangeSets( changeSetList );
 
         return changeLog;
     }
 }