Changeset 1690


Ignore:
Timestamp:
03/13/08 14:08:42 (6 years ago)
Author:
mosipov
Message:

ASSIGNED - #1896: [Connector] Reworking checking of type parameter

Location:
FCKeditor.Java/branches/2.4/src
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • FCKeditor.Java/branches/2.4/src/main/java/net/fckeditor/connector/ConnectorServlet.java

    r1674 r1690  
    7979 
    8080                File defaultUserFilesDir = new File(realDefaultUserFilesPath); 
    81                 if (!defaultUserFilesDir.exists()) { 
    82                         defaultUserFilesDir.mkdirs(); 
    83                 } 
     81                UtilsFile.checkDirAndCreate(defaultUserFilesDir); 
     82                 
     83                // FIXME wrong spelling 
    8484                logger.info("ConnectorServlet successfull initialized!"); 
    8585        } 
     
    113113                XmlResponse xr; 
    114114                 
    115                 if (!CommandHandler.isValidForGet(commandStr)) 
     115                if (!SessionDataHandler.isEnabledForFileBrowsing(request)) 
    116116                        xr = new XmlResponse(XmlResponse.EN_ERROR, 
    117                                         XmlResponse.CM_INVALID_COMMAND); 
    118                 else if (!SessionDataHandler.isEnabledForFileBrowsing(request)) 
     117                                        Messages.NOT_AUTHORIZED_FOR_BROWSING); 
     118                else if (!CommandHandler.isValidForGet(commandStr)) 
    119119                        xr = new XmlResponse(XmlResponse.EN_ERROR, 
    120                                         XmlResponse.CM_NOT_AUTHORIZED); 
     120                                        Messages.INVALID_COMMAND);  
    121121                else if (typeStr != null && !ResourceTypeHandler.isValid(typeStr)) 
    122122                        xr = new XmlResponse(XmlResponse.EN_ERROR, 
    123                                         XmlResponse.CM_INVALID_TYPE); 
     123                                        Messages.INVALID_TYPE); 
    124124                else if (!UtilsFile.isValidPath(currentFolderStr)) 
    125                         xr = new XmlResponse(XmlResponse.EN_INVALID_FOLDER_NAME); 
     125                        xr = new XmlResponse(XmlResponse.EN_ERROR,  
     126                                        Messages.INVALID_CURRENT_FOLDER); 
    126127                else { 
    127128                        CommandHandler command = CommandHandler.getCommand(commandStr); 
    128129                        ResourceTypeHandler resourceType = ResourceTypeHandler 
    129130                                        .getDefaultResourceType(typeStr); 
    130                         // TODO clean up this folder handling mess somehow?! 
     131 
    131132                        String typePath = constructResourceTypeUrl(resourceType, request); 
    132133                        String typeDirPath = getServletContext().getRealPath(typePath); 
     
    134135 
    135136                        File typeDir = new File(typeDirPath); 
    136                         if (!typeDir.exists()) { 
    137                                 typeDir.mkdirs(); 
    138                                 logger.debug("Type dir '{}' successfully created", typeDirPath); 
    139                         } 
     137                        UtilsFile.checkDirAndCreate(typeDir); 
    140138 
    141139                        File currentDir = new File(typeDir, currentFolderStr); 
     
    204202 
    205203                logger.debug("Parameter Command: {}", commandStr); 
     204                logger.debug("Parameter Type: {}", typeStr); 
    206205                logger.debug("Parameter CurrentFolder: {}", currentFolderStr); 
    207                 logger.debug("Parameter Type: {}", typeStr); 
    208  
    209                 if (!ResourceTypeHandler.isValid(typeStr)) 
    210                         logger.warn("Unknown Type requested: {}", typeStr); 
    211  
    212                 ResourceTypeHandler fileType = ResourceTypeHandler.getDefaultResourceType(typeStr); 
    213  
     206 
     207                UploadResponse ur; 
     208                 
     209                // FIXME improve comment 
    214210                // if this is a QuickUpload-Request, 'commandStr' and 'currentFolderStr' are empty and have 
    215211                // to preset and construct the full resource type path !! 
     
    217213                        commandStr = "QuickUpload"; 
    218214                        currentFolderStr = "/"; 
    219                         String quickUploadFolder = constructResponseUrl(fileType, currentFolderStr, 
    220                                 request); 
    221                         File file = new File(getServletContext().getRealPath(quickUploadFolder)); 
    222                         if (!file.exists()) 
    223                                 file.mkdirs(); 
    224215                } 
    225  
    226                 UploadResponse ur = null; 
    227  
    228                 if (Utils.isEmpty(commandStr) || Utils.isEmpty(currentFolderStr) 
    229                         || Utils.isEmpty(typeStr)) 
    230                         ur = UploadResponse.UR_BAD_REQUEST; 
     216                 
     217                if (!SessionDataHandler.isEnabledForFileUpload(request)) 
     218                        ur = new UploadResponse(UploadResponse.EN_SECURITY_ERROR, null, 
     219                                        null, Messages.NOT_AUTHORIZED_FOR_UPLOAD); 
    231220                else if (!CommandHandler.isValidForPost(commandStr)) 
    232                         ur = UploadResponse.UR_SECURITY_ERROR; 
    233                 else if (!UtilsFile.isValidPath(currentFolderStr)) { 
    234                         ur = new UploadResponse(UploadResponse.EN_SECURITY_ERROR, null, null, 
    235                                 "'currentFolderStr' isn't valid!"); 
    236                 } else if (!SessionDataHandler.isEnabledForFileUpload(request)) { 
    237                         ur = new UploadResponse(UploadResponse.EN_SECURITY_ERROR, null, null, 
    238                                 "The current user isn't authorized for uploading files!"); 
    239                 } else { 
    240                         String currentPath = constructResponseUrl(fileType, currentFolderStr, request); 
    241                         File currentDirPath = new File(getServletContext().getRealPath(currentPath)); 
    242  
    243                         if (!UtilsFile.isValidPath(currentFolderStr) || !currentDirPath.exists()) 
    244                                 ur = UploadResponse.UR_BAD_REQUEST; 
     221                        ur = new UploadResponse(UploadResponse.EN_ERROR, null, null, 
     222                                        Messages.INVALID_COMMAND); 
     223                else if (typeStr != null && !ResourceTypeHandler.isValid(typeStr)) 
     224                        ur = new UploadResponse(UploadResponse.EN_ERROR, null, null, 
     225                                        Messages.INVALID_TYPE); 
     226                else if (!UtilsFile.isValidPath(currentFolderStr)) 
     227                        ur = new UploadResponse(UploadResponse.EN_ERROR, null, null, 
     228                                        Messages.INVALID_CURRENT_FOLDER); 
     229                else { 
     230                        ResourceTypeHandler resourceType = ResourceTypeHandler.getDefaultResourceType(typeStr); 
     231                         
     232                        String typePath = constructResourceTypeUrl(resourceType, request); 
     233                        String typeDirPath = getServletContext().getRealPath(typePath); 
     234                        String currentPath = typePath + currentFolderStr; 
     235 
     236                        File typeDir = new File(typeDirPath); 
     237                        UtilsFile.checkDirAndCreate(typeDir); 
     238 
     239                        File currentDir = new File(typeDir, currentFolderStr); 
     240 
     241                        if (!currentDir.exists()) 
     242                                ur = new UploadResponse(UploadResponse.EN_ERROR, null, null, 
     243                                                Messages.INVALID_CURRENT_FOLDER); 
    245244                        else { 
    246  
     245                                 
    247246                                String newFilename = null; 
    248247                                FileItemFactory factory = new DiskFileItemFactory(); 
    249248                                ServletFileUpload upload = new ServletFileUpload(factory); 
     249                                 
    250250                                try { 
     251                                         
    251252                                        List<FileItem> items = upload.parseRequest(request); 
    252253 
     
    258259                                        String extension = FilenameUtils.getExtension(filename); 
    259260 
    260                                         boolean validExtension = ExtensionsHandler.isAllowed(fileType, extension); 
    261  
    262                                         if (!validExtension) 
    263                                                 ur = UploadResponse.UR_INVALID_EXTENSION; 
     261                                        if (!ExtensionsHandler.isAllowed(resourceType, extension)) 
     262                                                ur = new UploadResponse(UploadResponse.EN_INVALID_EXTENSION); 
    264263                                        else { 
    265264 
    266265                                                // construct an unique file name 
    267                                                 File pathToSave = new File(currentDirPath, filename); 
     266                                                File pathToSave = new File(currentDir, filename); 
    268267                                                int counter = 1; 
    269268                                                while (pathToSave.exists()) { 
    270                                                         newFilename = baseName.concat("(").concat(String.valueOf(counter)) 
    271                                                                 .concat(")").concat(".").concat(extension); 
    272                                                         pathToSave = new File(currentDirPath, newFilename); 
     269                                                        newFilename = baseName.concat("(").concat( 
     270                                                                        String.valueOf(counter)).concat(")") 
     271                                                                        .concat(".").concat(extension); 
     272                                                        pathToSave = new File(currentDir, newFilename); 
    273273                                                        counter++; 
    274274                                                } 
    275275 
    276                                                 if (Utils.isEmpty(newFilename)) { 
     276                                                if (Utils.isEmpty(newFilename)) 
    277277                                                        ur = new UploadResponse(UploadResponse.EN_OK, Utils 
    278                                                                 .constructServerAddress(request, currentPath).concat(filename)); 
    279                                                 } else { 
    280                                                         ur = new UploadResponse(UploadResponse.EN_RENAMED, Utils 
    281                                                                 .constructServerAddress(request, currentPath).concat( 
    282                                                                         newFilename), newFilename); 
    283                                                 } 
     278                                                                        .constructServerAddress(request, 
     279                                                                                        currentPath).concat(filename)); 
     280                                                else 
     281                                                        ur = new UploadResponse(UploadResponse.EN_RENAMED, 
     282                                                                        Utils.constructServerAddress(request, 
     283                                                                                        currentPath).concat(newFilename), 
     284                                                                        newFilename); 
    284285 
    285286                                                // secure image check 
    286                                                 if (fileType.equals(ResourceTypeHandler.IMAGE) && ConnectorHandler.isSecureImageUploads()) { 
    287                                                         boolean check = UtilsFile.isImage(uplFile.getInputStream()); 
    288                                                         if (check) { 
     287                                                if (resourceType.equals(ResourceTypeHandler.IMAGE) 
     288                                                                && ConnectorHandler.isSecureImageUploads()) { 
     289                                                        if (UtilsFile.isImage(uplFile.getInputStream())) 
    289290                                                                uplFile.write(pathToSave); 
    290                                                         } else { 
     291                                                        else { 
    291292                                                                uplFile.delete(); 
    292                                                                 ur = UploadResponse.UR_INVALID_EXTENSION; 
     293                                                                ur = new UploadResponse( 
     294                                                                                UploadResponse.EN_INVALID_EXTENSION); 
    293295                                                        } 
    294                                                 } else { 
     296                                                } else 
    295297                                                        uplFile.write(pathToSave); 
    296                                                 } 
    297298 
    298299                                        } 
    299                                 } catch (FileUploadException ex) { 
    300                                         ur = UploadResponse.UR_BAD_REQUEST; 
    301300                                } catch (Exception e) { 
    302                                         ur = UploadResponse.UR_SECURITY_ERROR; 
     301                                        ur = new UploadResponse(UploadResponse.EN_SECURITY_ERROR); 
    303302                                } 
    304303                        } 
    305                 } 
     304                                 
     305                }                        
     306                 
    306307                out.print(ur); 
    307308                out.flush(); 
     
    322323         
    323324        /** 
    324          * TODO document me 
     325         * TODO document me! 
    325326         * @param resourceType 
    326327         * @param request 
  • FCKeditor.Java/branches/2.4/src/main/java/net/fckeditor/response/UploadResponse.java

    r1571 r1690  
    2121package net.fckeditor.response; 
    2222 
     23import net.fckeditor.connector.Messages; 
    2324import net.fckeditor.tool.Utils; 
    2425 
     
    5556        public static final int EN_ERROR = 1; 
    5657 
    57         /** Error number WARNING */ 
    58         public static final int EN_WARNING = 101; 
    59  
    6058        /** Error number RENAMED */ 
    6159        public static final int EN_RENAMED = 201; 
     
    6664        /** Error number SECURITY ERROR */ 
    6765        public static final int EN_SECURITY_ERROR = 203; 
    68  
    69         /** Error number GENERIC ERROR */ 
    70         public static final int EN_GENERIC_NUMBER = -1; 
    71  
    72         /** HTTP 400 Status text */ 
    73         public static final String CM_HTTP_400 = "400 Bad request"; 
    74  
    75         /** UploadResponse INVALID EXTENSION */ 
    76         public static final UploadResponse UR_INVALID_EXTENSION = new UploadResponse( 
    77                         EN_INVALID_EXTENSION); 
    78  
    79         /** UploadResponse SECURITY ERROR */ 
    80         public static final UploadResponse UR_SECURITY_ERROR = new UploadResponse( 
    81                         EN_SECURITY_ERROR); 
    82  
    83         /** UploadResponse GENERIC NUMBER */ 
    84         public static final UploadResponse UR_GENERIC_NUMBER = new UploadResponse( 
    85                         EN_GENERIC_NUMBER); 
    86  
    87         /** UploadResponse BAD REQUEST */ 
    88         public static final UploadResponse UR_BAD_REQUEST = new UploadResponse( 
    89                         EN_ERROR, null, null, CM_HTTP_400); 
    9066 
    9167        /** 
  • FCKeditor.Java/branches/2.4/src/main/java/net/fckeditor/response/XmlResponse.java

    r1667 r1690  
    7676        /** Error number UNKNOWN ERROR */ 
    7777        public static final int EN_UKNOWN = 110; 
    78  
    79         /** Error message NOT AUTHORIZED FOR BROWSING */ 
    80         public static final String CM_NOT_AUTHORIZED = "The current user isn't authorized for file browsing!"; 
    81          
    82         /** Error message INVALID TYPE SUPPLIED */ 
    83         public static final String CM_INVALID_TYPE = "Invalid resource type specified"; 
    84          
    85         /** Error message INVALID TYPE SUPPLIED */ 
    86         public static final String CM_INVALID_COMMAND = "Invalid command specified"; 
    8778 
    8879        /** 
  • FCKeditor.Java/branches/2.4/src/main/java/net/fckeditor/tool/UtilsFile.java

    r1650 r1690  
    2121package net.fckeditor.tool; 
    2222 
     23import java.io.File; 
    2324import java.io.InputStream; 
    2425 
    2526import org.apache.commons.io.FilenameUtils; 
    2627import org.devlib.schmidt.imageinfo.ImageInfo; 
     28import org.slf4j.Logger; 
     29import org.slf4j.LoggerFactory; 
    2730 
    2831import net.fckeditor.handlers.ConnectorHandler; 
     
    3437 */ 
    3538public class UtilsFile { 
     39         
     40        private static final Logger logger = LoggerFactory.getLogger(UtilsFile.class); 
    3641 
    3742        /** 
     
    125130        return filename.matches("[^\\.]+\\.[^\\.]+"); 
    126131    } 
     132     
     133    /** 
     134         * TODO - document me! 
     135         * @param dir 
     136         */ 
     137        public static void checkDirAndCreate(File dir) { 
     138                if (!dir.exists()) { 
     139                        dir.mkdirs(); 
     140                        logger.debug("Dir '{}' successfully created", dir); 
     141                } 
     142        } 
    127143 
    128144} 
  • FCKeditor.Java/branches/2.4/src/test/java/net/fckeditor/tool/UploadResponseTest.java

    r1571 r1690  
    2323                new UploadResponse("1"); 
    2424        } 
    25  
     25/* 
    2626        @Test 
    2727        public void onlyErrorNumber() throws Exception { 
     
    3131                assertEquals(expected, actual.toString()); 
    3232        } 
    33          
     33        */ 
    3434        @Test 
    3535        public void fourArguments() throws Exception { 
     
    4747                assertEquals(expected, actual.toString()); 
    4848        } 
    49          
     49/*       
    5050        @Test 
    5151        public void customMessage() throws Exception { 
     
    5656                assertEquals(expected, actual.toString()); 
    5757        } 
    58          
     58*/ 
     59/* 
    5960        @Test 
    6061        public void nullArguments() throws Exception { 
     
    6465                assertEquals(expected, actual.toString()); 
    6566        } 
    66  
     67*/ 
    6768} 
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy