package org.wcb.model.service.impl;
   
   import org.apache.commons.net.ftp.FTPClient;
   import org.apache.commons.net.ftp.FTPReply;
   import org.apache.commons.net.ftp.FTP;
   import org.wcb.model.service.IFTPClientService;
   
   import java.io.*;
   import java.net.SocketException;
  
  /**
   * <small>
   * Copyright (c)  2006  wbogaardt.
   * Permission is granted to copy, distribute and/or modify this document
   * under the terms of the GNU Free Documentation License, Version 1.2
   * or any later version published by the Free Software Foundation;
   * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
   * Texts.  A copy of the license is included in the section entitled "GNU
   * Free Documentation License".
   * <p/>
   * $File:  $ <br>
   * $Change:  $ submitted by $Author: wbogaardt $ at $DateTime: Mar 24, 2006 1:19:38 PM $ <br>
   * </small>
   *
   * @author wbogaardt
   * @version 1
   *          Date: Mar 24, 2006
   *          Time: 1:19:38 PM
   */
  public class FTPClientService implements IFTPClientService {
  
      private String hostAddress;
      private int hostPort;
      private String userName;
      private String password;
      private FTPClient client;
  
      public String getHostAddress() {
          return hostAddress;
      }
  
      public void setHostAddress(String hostAddress) {
          this.hostAddress = hostAddress;
      }
  
      public int getHostPort() {
          if (hostPort == -1) {
              hostPort = FTPClient.DEFAULT_PORT;
          }
          return hostPort;
      }
  
      public void setHostPort(int hostPort) {
          this.hostPort = hostPort;
      }
  
      public String getUserName() {
          return userName;
      }
  
      public void setUserName(String userName) {
          this.userName = userName;
      }
  
      public String getPassword() {
          return password;
      }
  
      public void setPassword(String password) {
          this.password = password;
      }
  
      public void getFile(String remoteFileName, File localFile) {
          if (client == null || !client.isConnected()) {
              this.openConnection();
          }
          try {
              OutputStream output = new BufferedOutputStream(new FileOutputStream(localFile));
  
              String directory = remoteFileName.substring(0, remoteFileName.lastIndexOf("/") + 1);
              System.out.println("Directory CD: " + directory);
              client.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);
              client.setFileType(FTP.BINARY_FILE_TYPE);
              client.changeWorkingDirectory(directory);
              System.out.println(client.printWorkingDirectory());
              System.out.println("Files in this directory:\n" + client.listNames());
  
              String fileNameRemote = remoteFileName.substring(remoteFileName.lastIndexOf("/") + 1, remoteFileName.length());
                  System.out.println("Remote Filename is: " + fileNameRemote);
              //InputStream input = client.retrieveFileStream(fileNameRemote);
                //     Util.copyStream(input, output);
                 client.retrieveFile(fileNameRemote, output);
  
              output.close();
          } catch (FileNotFoundException fnfe) {
              fnfe.printStackTrace();
              this.closeConnection();
          }
          catch (IOException ioe) {
             ioe.printStackTrace();
             this.closeConnection();
         }
     }
 
     /**
      * This allows puting a file from the local file system to the remote file system.
      * @param localFile  Local file name and location
      * @param remoteFileName  filename
      * @param binaryTransfer  true indicates binary mode default is false and sends ascii.
      */
     public void putFile(File localFile, String remoteFileName, boolean binaryTransfer) {
         if (client == null || !client.isConnected()) {
             this.openConnection();
         }
         try {
             System.out.println("Remote system is " + client.getSystemName());
             if (binaryTransfer) {
                 client.setFileType(FTP.BINARY_FILE_TYPE);
             }
             // Use passive mode as default because most of us are
             // behind firewalls these days.
             client.enterLocalPassiveMode();
 
             InputStream input;
 
             input = new FileInputStream(localFile);
 
             client.storeFile(remoteFileName, input);
 
             input.close();
         } catch (IOException ioe) {
             this.closeConnection();
         }
     }
 
     protected void closeConnection() {
         if (client != null && client.isConnected()) {
             try
             {
                 if(client.logout()) {
                     client.disconnect();
                 }
             }
             catch (IOException f)
             {
                 // do nothing
             }
         }
 
     }
 
     protected void openConnection() {
         client = new FTPClient();
         try {
             client.connect(this.hostAddress);
             System.out.println("Connected to " + this.hostAddress + ".");
             // After connection attempt, you should check the reply code to verify
             // success.
             int reply = client.getReplyCode();
 
             if (!FTPReply.isPositiveCompletion(reply))
             {
                 this.closeConnection();
             }
         } catch (SocketException soe) {
             soe.printStackTrace();
         } catch (IOException ioe) {
             if (client.isConnected())
             {
                 try
                 {
                     client.disconnect();
                 }
                 catch (IOException f)
                 {
                     // do nothing
                 }
             }
             System.err.println("Could not connect to server.");
             ioe.printStackTrace();
         }
         if (this.logonUser()) {
             System.out.println("Logged on");
         } else {
             System.out.println("Not Logged");
         }
     }
 
     protected boolean logonUser() {
         try {
             if (this.userName != null && this.password != null) {
                 if (!client.login(this.userName, this.password))
                 {
                     this.closeConnection();
                     return false;
                 }
                 return true;
             }
         } catch (IOException e) {
             return false;
         }
         return false;
     }
 }