Changeset 1623


Ignore:
Timestamp:
02/25/08 14:38:34 (7 years ago)
Author:
th-schwarz
Message:

rewritte directory creation especially for quickupload

File:
1 edited

Legend:

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

    r1607 r1623  
    5656 * Servlet to upload and browse files.<br>
    5757 *
    58  * This servlet accepts 4 commands used to retrieve and create files and folders
    59  * from a server directory. The allowed commands are:
     58 * This servlet accepts 4 commands used to retrieve and create files and folders from a server
     59 * directory. The allowed commands are:
    6060 * <ul>
    61  * <li>GetFolders: Retrive the list of directory under the current folder
    62  * <li>GetFoldersAndFiles: Retrive the list of files and directory under the
    63  * current folder
     61 * <li>GetFolders: Retrive the list of directory under the current folder
     62 * <li>GetFoldersAndFiles: Retrive the list of files and directory under the current folder
    6463 * <li>CreateFolder: Create a new directory under the current folder
    6564 * <li>FileUpload: Send a new file to the server (must be sent with a POST)
     
    7170
    7271        private static final long serialVersionUID = -5742008970929377161L;
    73         private static final Logger logger = LoggerFactory
    74                         .getLogger(ConnectorServlet.class);
     72        private static final Logger logger = LoggerFactory.getLogger(ConnectorServlet.class);
    7573
    7674        /**
    7775         * Initialize the servlet.<br>
    78          * The init parameters will be read and used to adjust the defaults of the
    79          * {@link ConfigurationHandler} and the {@link ExtensionsHandler}.
     76         * The default directory for user files will be constructed.
    8077         */
    8178        public void init() throws ServletException, IllegalArgumentException {
     
    8380                String realDefaultUserFilesPath = getServletContext().getRealPath(
    8481                        ConnectorHandler.getDefaultUserFilesPath());
    85                
     82
    8683                File defaultUserFilesDir = new File(realDefaultUserFilesPath);
    87                 File fileDir = new File(defaultUserFilesDir, ResourceTypeHandler.FILE.getPath());
    88                 File flashDir = new File(defaultUserFilesDir, ResourceTypeHandler.FLASH.getPath());
    89                 File imageDir = new File(defaultUserFilesDir, ResourceTypeHandler.IMAGE.getPath());
    90                 File mediaDir = new File(defaultUserFilesDir, ResourceTypeHandler.MEDIA.getPath());
    9184                if (!defaultUserFilesDir.exists()) {
    9285                        defaultUserFilesDir.mkdirs();
    9386                }
    94                
    95                 fileDir.mkdir();
    96                 flashDir.mkdir();
    97                 imageDir.mkdir();
    98                 mediaDir.mkdir();
    99 
    10087                logger.info("ConnectorServlet successfull initialized!");
    10188        }
     
    10794         * connector?Command=CommandName&Type=ResourceType&CurrentFolder=FolderPath<br>
    10895         * <br>
    109          * It executes the command and then return the results to the client in XML
    110          * format.
     96         * It executes the command and then return the results to the client in XML format.
    11197         *
    11298         */
    11399        public void doGet(HttpServletRequest request, HttpServletResponse response)
    114                         throws ServletException, IOException {
     100                throws ServletException, IOException {
    115101                logger.debug("Entering ConnectorServlet#doGet");
    116102
     
    129115                logger.debug("Parameter Type: {}", typeStr);
    130116
    131                 String currentPath = constructTypeBasedFolderString(fileType,
    132                                 currentFolderStr, request);
     117                String currentPath = constructTypeBasedFolderString(fileType, currentFolderStr, request);
    133118                String currentDirPath = getServletContext().getRealPath(currentPath);
    134119
    135120                File currentDir = new File(currentDirPath);
    136                 if (!currentDir.exists()
    137                                 && SessionDataHandler.isEnabledForFileBrowsing(request)) {
     121                if (!currentDir.exists() && SessionDataHandler.isEnabledForFileBrowsing(request)) {
    138122                        currentDir.mkdirs();
    139123                        logger.debug("Dir successfully created: {}", currentDirPath);
    140124                }
    141125
    142                 XmlResponse xr = new XmlResponse(commandStr, fileType, currentFolderStr, currentPath, request);
    143                
     126                XmlResponse xr = new XmlResponse(commandStr, fileType, currentFolderStr, currentPath,
     127                        request);
     128
    144129                if (!SessionDataHandler.isEnabledForFileBrowsing(request)) {
    145130                        xr.setError(1, "The current user isn't authorized for file browsing!");
     
    183168         * connector?Command=FileUpload&Type=ResourceType&CurrentFolder=FolderPath<br>
    184169         * <br>
    185          * It store the file (renaming it in case a file with the same name exists)
    186          * and then return an HTML file with a javascript command in it.
     170         * It store the file (renaming it in case a file with the same name exists) and then return an
     171         * HTML file with a javascript command in it.
    187172         *
    188173         */
    189174        public void doPost(HttpServletRequest request, HttpServletResponse response)
    190                         throws ServletException, IOException {
     175                throws ServletException, IOException {
    191176                logger.debug("Entering Connector#doPost");
    192177
     
    207192                        logger.warn("Unknown Type requested: {}", typeStr);
    208193
     194                ResourceTypeHandler fileType = ResourceTypeHandler.getDefaultResourceType(typeStr);
     195
     196                // if this is a QuickUpload-Request, 'commandStr' and 'currentFolderStr' are empty and have
     197                // to preset and construct the full resource type path !!
    209198                if (isEmpty(commandStr) && isEmpty(currentFolderStr)) {
    210199                        commandStr = "QuickUpload";
    211200                        currentFolderStr = "/";
    212                 }
    213 
    214                 ResourceTypeHandler fileType = ResourceTypeHandler.getDefaultResourceType(typeStr);
     201                        String quickUploadFolder = constructTypeBasedFolderString(fileType, currentFolderStr, request);
     202                        File file = new File(getServletContext().getRealPath(quickUploadFolder));
     203                        if (!file.exists())
     204                                file.mkdirs();
     205                }
    215206
    216207                UploadResponse ur = null;
    217208
    218                 if (!SessionDataHandler.isEnabledForFileUpload(request)) {
    219                         ur = new UploadResponse(UploadResponse.EN_SECURITY_ERROR, null,
    220                                         null,
    221                                         "The current user isn't authorized for uploading files!");
    222                 } else if (isEmpty(commandStr) || isEmpty(currentFolderStr)
    223                                 || isEmpty(typeStr))
     209                if (!Utils.isValidPath(currentFolderStr)) {
     210                        ur = new UploadResponse(UploadResponse.EN_SECURITY_ERROR, null, null,
     211                                        "'currentFolderStr' isn't valid!");                     
     212                } else if (!SessionDataHandler.isEnabledForFileUpload(request)) {
     213                        ur = new UploadResponse(UploadResponse.EN_SECURITY_ERROR, null, null,
     214                                "The current user isn't authorized for uploading files!");
     215                } else if (isEmpty(commandStr) || isEmpty(currentFolderStr) || isEmpty(typeStr))
    224216                        ur = UploadResponse.UR_BAD_REQUEST;
    225217                else if (!commandStr.matches("(File|Quick)Upload"))
     
    227219                else {
    228220
    229                         String currentPath = constructTypeBasedFolderString(fileType,
    230                                         currentFolderStr, request);
    231                         String currentDirPath = getServletContext()
    232                                         .getRealPath(currentPath);
    233 
    234                         if (!isValidPath(currentFolderStr)
    235                                         || !(new File(currentDirPath).exists()))
     221                        String currentPath = constructTypeBasedFolderString(fileType, currentFolderStr, request);
     222                        String currentDirPath = getServletContext().getRealPath(currentPath);
     223
     224                        if (!isValidPath(currentFolderStr) || !(new File(currentDirPath).exists()))
    236225                                ur = UploadResponse.UR_BAD_REQUEST;
    237226                        else {
     
    249238                                        String extension = FilenameUtils.getExtension(filename);
    250239
    251                                         boolean validExtension = ExtensionsHandler.isAllowed(
    252                                                         fileType, extension);
     240                                        boolean validExtension = ExtensionsHandler.isAllowed(fileType, extension);
    253241
    254242                                        if (!validExtension)
     
    264252                                                int counter = 1;
    265253                                                while (pathToSave.exists()) {
    266                                                         newFilename = baseName + "(" + counter + ")" + "."
    267                                                                         + extension;
     254                                                        newFilename = baseName + "(" + counter + ")" + "." + extension;
    268255                                                        pathToSave = new File(currentDirPath, newFilename);
    269256                                                        counter++;
     
    272259                                                uplFile.write(pathToSave);
    273260                                                if (isEmpty(newFilename)) {
    274                                                         ur = new UploadResponse(UploadResponse.EN_OK,
    275                                                                         Utils.constructServerAddress(request, currentPath)
    276                                                                                         + filename);
     261                                                        ur = new UploadResponse(UploadResponse.EN_OK, Utils
     262                                                                .constructServerAddress(request, currentPath)
     263                                                                + filename);
    277264                                                } else {
    278                                                         ur = new UploadResponse(UploadResponse.EN_RENAMED,
    279                                                                         Utils.constructServerAddress(request, currentPath)
    280                                                                                         + newFilename, newFilename);
     265                                                        ur = new UploadResponse(UploadResponse.EN_RENAMED, Utils
     266                                                                .constructServerAddress(request, currentPath)
     267                                                                + newFilename, newFilename);
    281268                                                }
    282269                                        }
     
    296283
    297284        private String constructTypeBasedFolderString(final ResourceTypeHandler fileType,
    298                         final String currentFolderString, final HttpServletRequest request) {
     285                final String currentFolderString, final HttpServletRequest request) {
    299286                StringBuffer sb = new StringBuffer();
    300287                sb.append(ConnectorHandler.getUserFilesPath(request));
     
    303290                return replaceAll(sb.toString(), "//", "/");
    304291        }
    305        
     292
    306293}
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2015 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy