source: other-projects/FileTransfer-WebSocketPair/testGXTWithGreenstone/src/com/gs3/testGXT/server/FileConflictCheckServiceImpl.java@ 33053

package com.gs3.testGXT.server;

import java.io.File;
import java.io.IOException;
import java.util.LinkedList;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import com.gs3.testGXT.client.services.FileConflictCheckService;

@SuppressWarnings("serial")
public class FileConflictCheckServiceImpl extends RemoteServiceServlet implements FileConflictCheckService {

    public final int NO_ERR_CODE = 0;
    public final int ERR_SOURCE_NOT_FOUND = 1;
    public final int ERR_SOURCE_NOT_READABLE = 2;
    public final int ERR_DEST_NOT_WRITEABLE = 3;
    public final int ERR_FILE_SELF_SIMILAR = 4;
    public final int ERR_INSUFFICIENT_SPACE = 5;

    /**
     * input:  list of folders and files to be copied (merged)
     * output: list of files which conflict with already existing files
     */
    @Override
    public LinkedList<String[]> fileConflictCheck(LinkedList<String> paths, String remoteTarget) {
        CheckConflictInstance instance = new CheckConflictInstance();
        return instance.fileConflictCheck(paths, remoteTarget); 
    }

    private class CheckConflictInstance {
        private LinkedList<String[]> res;
        private int conflicts = 0;

        public LinkedList<String[]> fileConflictCheck(LinkedList<String> paths, String remoteTarget) {
            res = new LinkedList<String[]>();
            // Structure:
            //   first string[] is return status
            //   second and following are conflicts
            File target = new File(remoteTarget);
            String[] response;
            String basePath = null;
            if(target.isDirectory()) {
                for(String path : paths) {
                    int i = path.lastIndexOf("/");
                    basePath = path.substring(0, i); //TODO: if necessary, add 1 to that index?
                    checkConflict(path, remoteTarget, basePath);
                }

                if(conflicts == 0) { //at this point, we can probably just perform the copy serverside
                    response = new String[] {"Success", conflicts + " conflicting files detected"};
                }
                else { //we need to get confirmation before we do the copy
                    response = new String[] {"Warning", conflicts + " conflicting files detected"};
                }
            }
            else { //we shouldn't be able to do this unless we have some multi-user trickery going on
                response = new String[] {"Error", "The item at '" + remoteTarget + "' is not a directory, and cannot be made to contain files."};           
            }
            System.err.println();
            res.addFirst(response);
            printArr(response);
            return res;
        }

        //TODO: replace this with an iterative stack-based solution, 
        //      to avoid any potential stack overflow errors on extremely large file-systems: 
        //      low priority, but would be needed for a final solution
        private void checkConflict(String fullFromPath, String remoteTarget, String baseFromPath) {
            //Structure:
            //  file:
            //    warn on conflict
            //  folder:
            //    recurse on conflict
            //  only root level elements are given as crossfunction input, so we can recurse on the children of those elements
            String modifiedPath = fullFromPath.substring(baseFromPath.length(), fullFromPath.length());
            String outputPath   = remoteTarget + modifiedPath;
            System.err.println("Base path: " + baseFromPath);
            System.err.println("Resultant path: " + modifiedPath);
            System.err.println("output path: " + outputPath);

            //check if the input file exists
            File destination = new File(outputPath);

            //check that we aren't replacing the same file with itself on the filesystem
            File source = new File(fullFromPath);

            /** We ensure that the source file actually does exist - just incase the user had a stale version of the tree */
            if(!source.exists()) {
                String[] str = new String[]{"Error", destination.getName(), destination.getPath(), 
                        source.getPath(), "" + source.length(), "" + ERR_SOURCE_NOT_FOUND};

                System.err.println("The source file does not exist");

                conflicts++;
                res.add(str);
                return;
            }

            //we need to make sure we can actually read this file
            if(!source.canRead()/* && source.canExecute()*/) {
                String[] str = new String[]{"Error", destination.getName(), destination.getPath(), 
                        source.getPath(), "" + source.length(), "" + ERR_SOURCE_NOT_READABLE};

                System.err.println("The source file does not exist");

                conflicts++;
                res.add(str);
                return;
            }

            /** Here, we check if we're copying a file into itself - we can omit the error message, and just ignore these cases in the future */
            if(source.getAbsolutePath().equals(destination.getAbsolutePath())) {                
                //TODO: this one should ACTUALLY be an ignore - or should it?
                String[] str = new String[]{"Error", destination.getName(), destination.getPath(), 
                        source.getPath(), "" + source.length(), "" + ERR_FILE_SELF_SIMILAR};

                System.err.println("Detected attempt to replace file with itself");

                conflicts++;
                res.add(str);
                return; //try not to replace a file with itself
            }

            //Response Structure:
            //  
            //  Conflict/No Conflict
            //  Destination Name
            //  Destination Path
            //  Source Path
            //  File Size (if not folder - just give 0 for those)
            //  Error Code (if one exists)

            /** check if the destination exists - needed for merge/replace operations */
            if(destination.exists()) {
                //file exists: this means there is a conflict
                System.err.println("Conflict: the file '" + outputPath + "' already exists!");

                if(destination.isDirectory()) {
                    //we need to make a check and see if the file on the left is a directory
                    if(source.isDirectory()) {
                        //if it conflicts and is a directory, we do a recursive check
                        File[] children = source.listFiles();
                        for(File child : children) {
                            try {
                                checkConflict(child.getCanonicalPath(), remoteTarget, baseFromPath);                            
                            } catch (IOException e) { 
                                e.printStackTrace();
                            }
                        }
                    }
                    else {//the file on the left is a file: we may be replacing a folder with a file.
                        
                        //we need to make sure that we have permissions to delete the file
                        if(!(destination.canRead() && destination.canWrite())) {
                            String[] str = new String[]{"Error", destination.getName(), destination.getPath(), 
                                    source.getPath(), "" + source.length(), "" + ERR_DEST_NOT_WRITEABLE};

                            System.err.println("The source file does not exist");

                            conflicts++;
                            res.add(str);
                            return;
                        }
                        
                        String[] str = new String[]{"Conflict", destination.getName(), destination.getPath(), source.getPath(), "" + source.length()};
                        res.add(str);
                        conflicts++;
                    }
                }
                else if (destination.isFile()) {
                    //if it conflicts and is a file, then we create a warning
                    //                         conflict, file,           location 
                    String[] str = new String[]{"Conflict", destination.getName(), destination.getPath(), source.getPath(), "" + source.length()};
                    res.add(str);
                    conflicts++;
                }
            }
            /** The destination doesn't exist - we're free to do whatever */
            else {
                //we want to specifically check any children (if they exist) as well - primarily just for permissions
                if(source.isDirectory()) { //if it's a directory and has children, we must also check those children (to get the file sizes)
                    File[] children = source.listFiles();
                    if(children != null  && children.length > 0) { //the != null check can probably be used in place of the directory check
                        //check specifically each child - we're copying these
                        for(File child : children) {
                            try {
                                checkConflict(child.getCanonicalPath(), remoteTarget, baseFromPath);                            
                            } catch (IOException e) { 
                                e.printStackTrace(); //TODO: update this - something more meaningful has to happen here...
                            }
                        }
                        return;
                    }
                }
                String[] str = new String[]{"No Conflict", destination.getName(), destination.getPath(), source.getPath(), "" + source.length()};
                res.add(str);
            }
        }

        private void printArr(String[] input) {
            for (int i = 0; i < input.length; i++)
                if(i == input.length -1)
                    System.err.print(input[i]);
                else
                    System.err.print(input[i] + ": ");
            System.err.println();
        }
    }
}