jahiafilemanagerbaseservice.java

java 写的一个新闻发布系统

                                    HttpServletResponse res,
                                    int fileID
                                  )
    {
        //JahiaConsole.println("JahiaFileManagerBaseService.handleFileDownload","started");
        JahiaFile fileItem = (JahiaFile)ServicesRegistry.getInstance().getJahiaFilemanagerService().getFileDB(fileID);

        if ( fileItem != null ){

            Filemanager fmng = getFilemanager(fileItem.getFilemanagerID());

            if ( fmng != null ) {
                String path = getFileRepositoryRootPath() + File.separator + fmng.getStoragePath() + File.separator + fileItem.getStorageName();
                //JahiaConsole.println("JahiaFileManagerBaseService.handleFileDownload","file is " + path);

                File f = new File(path);
                String mimeType = "";
                if ( f != null && f.isFile() ){
                    try {
                        //JahiaConsole.println("JahiaFileManagerBaseService.handleFileDownload","file is " + path);

                        JahiaChrono chrono = JahiaChrono.getInstance();
                        long startTime = chrono.start();
                        // JahiaConsole.println("JahiaFileManagerBaseService.handleFileDownload","Start time "+startTime);
                        FileDownload fdwn = null;

                        /*
                        if ( !JahiaTools.isMSIExplorer(req) ) {
                            //fdwn = new FileDownload(req,res,fileItem.getRealName(),path , "bin/octet-stream");
                            //fdwn = new FileDownload(req,res,fileItem.getRealName(),path , "application/octet-stream");
                            if ((fileItem.getType().indexOf("text") != -1 && fileItem.getType().indexOf("text/html") == -1) || fileItem.getType().indexOf("image") != -1)
                            {
                                //fdwn = new FileDownload(req,res,fileItem.getRealName(),path , "application/octet-stream");
                                fdwn = new FileDownload(req,res,fileItem.getRealName(),path , fileItem.getType());
                            }
                            else
                            {
                                fdwn = new FileDownload(req,res,fileItem.getRealName(),path , fileItem.getType());
                            }
                        } else {
                            //fdwn = new FileDownload(req,res,fileItem.getRealName(),path , fileItem.getType());
                            fdwn = new FileDownload(req,res,fileItem.getRealName(),path , "application/force-download");
                        }
                        */

                        mimeType = getMimeTypeFromFilename(fileItem.getRealName());
                        if ( mimeType == null || mimeType.trim().equals("") )
                            mimeType = fileItem.getType();

                        JahiaConsole.println("JahiaFileManagerBaseService.handleFileDownload","Mime type= "+mimeType);

                        fdwn = new FileDownload(req,res,fileItem.getRealName(),path , mimeType);

                        chrono.toConsole(startTime,"JahiaFileManagerBaseService.handleFileDownload> FileDownload serving time");
                        // JahiaConsole.println("JahiaFileManagerBaseService.handleFileDownload","Stop time "+chrono.start());
                        fdwn.writeFileContentToResponse();
                    } catch ( IOException ioe ) {
                        JahiaConsole.println("JahiaFilemanagerBaseService.handleFileDownload",ioe.getMessage() );
                        return false;
                    }
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } else {
            return false;
        }

        return true;
    }

    /**
     * return a FileUpload Handler object
     *  *	Files uploaded are stored in a temporary directory with a random generated name
     *
     * @param context ServletContext
     * @param req HttpServletRequest
     * @return a FileUpload object or null
     * @exception ServletException
     * @exception IOException
     *
     */
    public FileUpload getFileUploadHandler(
                                            ServletContext context,
                                            HttpServletRequest req
                                              ) throws ServletException, IOException
    {
        toConsole(" getFileUploadHandler started ");

        FileUpload fupload = null;

        File tmpDir = createTmpDirectory();
        if ( tmpDir != null && tmpDir.isDirectory() && tmpDir.canWrite() ) {

            fupload = new FileUpload(context,req,m_FileRepositoryDiskpath + File.separator + tmpDir.getName() ,m_FileUploadMaxSize);
            return fupload;
        } else {
            toConsole(" Error occured while creating temporaty directory");
            throw new IOException("ServicesRegistry.getInstance().getJahiaFileStorageService()::getFileUploadHandler fail creating temporary folder");
        }
    }


    /**
     * Handle file upload of new files, save them in the filemanager assotiated with
     * the current JahiaID
     *
     * @exception ServletException
     * @exception IOException
     * @return the id of the new file or -1 on error
     */
    public int handleFileUpload(
                                  ParamBean jParams,
                                  FileUpload fupload,
                                  int folderID,
                                  String fileTitle,
                                  String uploadUser,
                                  int isPublic

                                 ) throws ServletException, IOException, JahiaException
    {
        toConsole(" handleFileUpload started ");

        int fileID = -1;
        int pageID = jParams.getPageID();

        // init filemanager
        Filemanager fmng = getFilemanagerByOwner(jParams.getJahiaID());

        if ( fmng == null ){
            String errorMsg = "Fail initializing the requested filemanager : ";
            JahiaConsole.println( "JahiaFilemanagerBaseService", errorMsg + " -> BAILING OUT" );
            throw new JahiaException( errorMsg, errorMsg, JahiaException.SERVICE_ERROR,
                                        JahiaException.ERROR );
        }


        if ( fupload != null ){



            // get files name
            Enumeration filesName = fupload.getFileNames();

            String name;
            String filename;
            String contentType;
            String storageName;
            long size ;
            long lastModified;
            JahiaFile aFile;
            int nbError = 0;

            File parent = null;

            while (filesName.hasMoreElements()) {

                name = (String)filesName.nextElement();
                filename = fupload.getFileSystemName(name);
                //contentType = fupload.getFileContentType(name);

                contentType = getMimeTypeFromFilename(name);
                if ( contentType == null || contentType.trim().equals("") )
                    contentType = fupload.getFileContentType(name);

                File f = fupload.getFile(name);
                if ( f != null && f.exists() && f.canWrite() ) {

                    // get parent folder
                    if ( parent == null ){
                            parent = f.getParentFile();
                    }

                    size = f.length();
                    lastModified = f.lastModified();
                    storageName = "FILE" + JahiaKeyGen.getKey(10) + filename;
                    String fullFilePath = getFileRepositoryRootPath() + File.separator + fmng.getStoragePath() + File.separator + storageName;
                    toConsole(" New StoragePath = " + fullFilePath);
                    File tmpFile = new File(fullFilePath);
                    f.renameTo(tmpFile);


                    aFile = new	JahiaFile(
                                                fmng.getFilemanagerID(),
                                                folderID,
                                                uploadUser,
                                                filename,
                                                storageName,
                                                lastModified,
                                                size,
                                                contentType,
                                                fileTitle,
                                                ""
                                                );

                    aFile.setPageID(pageID);
                    aFile.setPublic(isPublic);

                    toConsole(" file name :" + aFile.getRealName() + ",size=" + aFile.getSize() + ",lastModified=" + aFile.getLastModifDate() + ",type=" + aFile.getType() );

                    fileID = insertFileDB(aFile);
                    if ( (fileID<0) ) {
                        toConsole(" fail inserting file to db");
                        f.delete();
                        nbError += 1;
                    }
                } else {
                     nbError +=1;
                }
            }

            if ( parent != null ){
                parent.delete();
            }
        }

        return fileID;
    }


    /**
     * Delete a file from disk
     *
     * @param JahiaFile the abstract file
     */
    public boolean deleteFile( JahiaFile fileItem ){

        Filemanager fmng = getFilemanager(fileItem.getFilemanagerID());
        if ( fmng != null ){
            StringBuffer buff = new StringBuffer(getFileRepositoryRootPath());
            buff.append(File.separator);
            buff.append(fmng.getStoragePath());
            buff.append(File.separator);
            buff.append(fileItem.getStorageName());
            File  f = new File(buff.toString());
            return f.delete();
        }
        return false;
    }



    /**
     * Duplicate a file on disk
     *
     * @param in the source file
     * @param out the copy abstract file object
     * @return false on any exception
     */
     protected boolean copyFile(File in, File out){

        boolean success = false;
        FileInputStream fis ;
        FileOutputStream fos ;

        try {
            fis = new FileInputStream(in);
            fos = new FileOutputStream(out);

            byte[] buffer = new byte[1024];
            int i = 0;
            while((i=fis.read(buffer))!=-1) {
                fos.write(buffer, 0, i);
            }
            success = true;
            fis.close();
            fos.close();
        } catch ( FileNotFoundException fnfex ) {
            toConsole(" copyFile, file not found :" + fnfex.getMessage() );
        } catch ( IOException ioe ) {
            toConsole(" copyFile, IOException :" + ioe.getMessage() );
        } finally {
            return success;
        }
    }


    /**
     * Method createTmpDirectory<br>
     * Create a temporaty directory with a unique name which will be used
     * to store temporarily uploaded files<br>
     *
     * @return the abstract File for the created directory else null on error
     */
    protected File createTmpDirectory() {

        File tmpDir = null;

        File rootFile = new File(getFileRepositoryRootPath());
        if ( rootFile != null && rootFile.isDirectory() && rootFile.canWrite() ){
            String tmpDirName = m_TMP_DIR_PREFIX_NAME + getUniqueDirName();
            tmpDir = new File(getFileRepositoryRootPath() + File.separator +  tmpDirName);
            tmpDir.mkdir();
        } else {
            // error with root file repository
            toConsole("createTmpDirectory, File repository path is not accessible or doesn't exists");
        }
        return tmpDir;
    }


    /**
     * Method getUniqueFileName
     * Return a random and unique String that can be
     * used as storage name for file
     *
     * @return a unique string file name
     */
    protected String getUniqueFileName() {

         return ( JahiaKeyGen.getKey(10) );
    }


    /**
     * Method getUniqueDirName
     * Return a random and unique String that can be used
     * as directory name
     *
     * @return a unique directory name
     */
    protected String getUniqueDirName() {

         return ( JahiaKeyGen.getKey(15) );
    }




   //--------------------------------------------------------------------------
   //
   //
   // Jahia Filemanager  DB Handling Section
   //
   //
   //--------------------------------------------------------------------------

    /**
     * create a filemanager for a gived owner
     */
    public boolean createFilemanager(int ownerID){

        Filemanager fmng = new Filemanager();
        return fmng.create(ownerID);
    }


    /**
     * Delete a filemanager and all its contents
     */
    public boolean deleteFilemanager(JahiaUser user ,int ownerID)
    throws JahiaException {

        if ( !user.isAdminMember(0) ){
            throw new JahiaException("JahiaFilemanagerBaseService.deleteFilemanager",
                                     "User has no right to delete the filemanager",
                                     JahiaException.ACL_ERROR,
                                     JahiaException.ERROR);
        }

        Filemanager fmng = getFilemanagerByOwner(ownerID);
        if ( fmng == null ){
            return false;
        }

        // delete the files
        Folder rootFolder = fmng.getRootFolder();
        fmng.deleteFolder(rootFolder);

        // delete the filemanager
        return m_FilemanagerDB.delete(fmng.getFilemanagerID());
    }


    /**
     * Method getFilemanager<br>
     * Return a filemanager
     *
     * @param filemanagerID the filemanager id
     * @return filemanager or null
     *
     */
     public Filemanager getFilemanager(int filemanagerID) {

        Filemanager fmng = new Filemanager();

        if (!fmng.initialize(filemanagerID) ){
            fmng = null;