| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // JDK API |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.BufferedInputStream; |
| import java.util.Enumeration; |
| |
| // Servlet API |
| import javax.servlet.ServletException; |
| import javax.servlet.http.HttpServlet; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import javax.servlet.ServletOutputStream; |
| |
| // Helper API |
| import com.oreilly.servlet.MultipartRequest; |
| import com.oreilly.servlet.MultipartResponse; |
| import com.oreilly.servlet.ServletUtils; |
| |
| // UNO API |
| import com.sun.star.bridge.XUnoUrlResolver; |
| import com.sun.star.uno.XComponentContext; |
| import com.sun.star.uno.UnoRuntime; |
| import com.sun.star.frame.XComponentLoader; |
| import com.sun.star.frame.XStorable; |
| import com.sun.star.util.XCloseable; |
| import com.sun.star.beans.PropertyValue; |
| import com.sun.star.beans.XPropertySet; |
| import com.sun.star.lang.XComponent; |
| import com.sun.star.lang.XMultiComponentFactory; |
| |
| |
| /** This class implements a http servlet in order to convert an incoming document |
| * with help of a running OpenOffice.org and to push the converted file back |
| * to the client. |
| */ |
| public class ConverterServlet extends HttpServlet { |
| /** Specifies the temporary directory on the web server. |
| */ |
| private String stringWorkingDirectory = |
| System.getProperty( "java.io.tmpdir" ).replace( '\\', '/' ); |
| |
| /** Specifies the host for the office server. |
| */ |
| private String stringHost = "localhost"; |
| |
| /** Specifies the port for the office server. |
| */ |
| private String stringPort = "2083"; |
| |
| /** Called by the server (via the service method) to allow a servlet to handle |
| * a POST request. The file from the client will be uploaded to the web server |
| * and converted on the web server and after all pushed to the client. |
| * @param request Object that contains the request the client has made of the servlet. |
| * @param response Object that contains the response the servlet sends to the client. |
| * @throws ServletException If the request for the POST could not be handled. |
| * @throws IOException If an input or output error is detected when the servlet handles the request. |
| */ |
| protected void doPost( HttpServletRequest request, |
| HttpServletResponse response) throws ServletException, java.io.IOException { |
| try { |
| // If necessary, add a slash to the end of the string. |
| if ( !stringWorkingDirectory.endsWith( "/" ) ) { |
| stringWorkingDirectory += "/"; |
| } |
| |
| // Construct a MultipartRequest to help read the information. |
| // Pass in the request, a directory to save files to, and the |
| // maximum POST size we should attempt to handle. |
| MultipartRequest multipartrequest = |
| new MultipartRequest( request, stringWorkingDirectory, 5 * 1024 * 1024 ); |
| |
| // Getting all file names from the request |
| Enumeration files = multipartrequest.getFileNames(); |
| |
| // Every received file will be converted to the specified type |
| while (files.hasMoreElements()) { |
| // Getting the name from the element |
| String stringName = (String)files.nextElement(); |
| |
| // Getting the filename from the request |
| String stringFilename = |
| multipartrequest.getFilesystemName( stringName ); |
| |
| // Converting the given file on the server to the specified type and |
| // append a special extension |
| File cleanupFile = null; |
| String stringSourceFile = stringWorkingDirectory + stringFilename; |
| |
| try { |
| String stringConvertedFile = convertDocument(stringSourceFile, |
| multipartrequest.getParameter( "converttype" ), |
| multipartrequest.getParameter( "extension" )); |
| |
| String shortFileName = stringConvertedFile.substring( |
| stringConvertedFile.lastIndexOf('/') + 1); |
| |
| // Set the response header |
| // Set the filename, is used when the file will be saved (problem with mozilla) |
| response.addHeader( "Content-Disposition", |
| "attachment; filename=" + shortFileName); |
| |
| // Constructing the multi part response to the client |
| MultipartResponse multipartresponse = new MultipartResponse(response); |
| |
| // Is the convert type HTML? |
| if ( ( multipartrequest.getParameter( "converttype" ).equals( |
| "swriter: HTML (StarWriter)" ) ) |
| || ( multipartrequest.getParameter( "converttype" ).equals( |
| "scalc: HTML (StarCalc)" ) ) ) { |
| // Setting the content type of the response being sent to the client |
| // to text |
| multipartresponse.startResponse( "text/html" ); |
| } else { |
| // Setting the content type of the response being sent to the client |
| // to application/octet-stream so that file will open a dialog box |
| // at the client in order to save the converted file |
| multipartresponse.startResponse( "application/octet-stream" ); |
| } |
| |
| // Pushing the converted file to the client |
| ServletUtils.returnFile( stringConvertedFile, |
| response.getOutputStream() ); |
| |
| // Finishing the multi part response |
| multipartresponse.finish(); |
| |
| // clean up the working directory |
| cleanupFile = new File(stringConvertedFile); |
| if ( cleanupFile.exists() ) |
| cleanupFile.delete(); |
| |
| } catch (Exception exc) { |
| response.setContentType( "text/html;charset=8859-1" ); |
| PrintWriter out = response.getWriter(); |
| |
| exc.printStackTrace(); |
| |
| out.println( "<html><head>" ); |
| out.println( " <title>" + "SDK Converter Servlet" + "</title>" ); |
| out.println( "</head>" ); |
| out.println( "<body><br><p>"); |
| out.println( "<b>Sorry, the conversion failed!</b></p>"); |
| out.println( "<p><b>Error Mesage:</b><br>" + exc.getMessage() + "<br>"); |
| exc.printStackTrace(out); |
| out.println( "</p></body><html>"); |
| } |
| |
| // clean up the working directory |
| cleanupFile = new File(stringSourceFile); |
| if ( cleanupFile.exists() ) |
| cleanupFile.delete(); |
| } |
| } |
| catch (Exception exception) { |
| System.err.println( exception.toString() ); |
| } |
| } |
| |
| /** This method converts a document to a given type by using a running |
| * OpenOffice.org and saves the converted document to the specified |
| * working directory. |
| * @param stringDocumentName The full path name of the file on the server to be converted. |
| * @param stringConvertType Type to convert to. |
| * @param stringExtension This string will be appended to the file name of the converted file. |
| * @return The full path name of the converted file will be returned. |
| * @see stringWorkingDirectory |
| */ |
| private String convertDocument( String stringDocumentName, |
| String stringConvertType, |
| String stringExtension) |
| throws Exception |
| { |
| String stringConvertedFile = ""; |
| |
| // Converting the document to the favoured type |
| // try { |
| // Composing the URL |
| String stringUrl = "file:///" + stringDocumentName; |
| |
| /* Bootstraps a component context with the jurt base components |
| registered. Component context to be granted to a component for running. |
| Arbitrary values can be retrieved from the context. */ |
| XComponentContext xcomponentcontext = |
| com.sun.star.comp.helper.Bootstrap.createInitialComponentContext( null ); |
| |
| /* Gets the service manager instance to be used (or null). This method has |
| been added for convenience, because the service manager is a often used |
| object. */ |
| XMultiComponentFactory xmulticomponentfactory = |
| xcomponentcontext.getServiceManager(); |
| |
| /* Creates an instance of the component UnoUrlResolver which |
| supports the services specified by the factory. */ |
| Object objectUrlResolver = |
| xmulticomponentfactory.createInstanceWithContext( |
| "com.sun.star.bridge.UnoUrlResolver", xcomponentcontext ); |
| |
| // Create a new url resolver |
| XUnoUrlResolver xurlresolver = ( XUnoUrlResolver ) |
| UnoRuntime.queryInterface( XUnoUrlResolver.class, |
| objectUrlResolver ); |
| |
| // Resolves an object that is specified as follow: |
| // uno:<connection description>;<protocol description>;<initial object name> |
| Object objectInitial = xurlresolver.resolve( |
| "uno:socket,host=" + stringHost + ",port=" + stringPort + |
| ";urp;StarOffice.ServiceManager" ); |
| |
| // Create a service manager from the initial object |
| xmulticomponentfactory = ( XMultiComponentFactory ) |
| UnoRuntime.queryInterface( XMultiComponentFactory.class, objectInitial ); |
| |
| // Query for the XPropertySet interface. |
| XPropertySet xpropertysetMultiComponentFactory = ( XPropertySet ) |
| UnoRuntime.queryInterface( XPropertySet.class, xmulticomponentfactory ); |
| |
| // Get the default context from the office server. |
| Object objectDefaultContext = |
| xpropertysetMultiComponentFactory.getPropertyValue( "DefaultContext" ); |
| |
| // Query for the interface XComponentContext. |
| xcomponentcontext = ( XComponentContext ) UnoRuntime.queryInterface( |
| XComponentContext.class, objectDefaultContext ); |
| |
| /* A desktop environment contains tasks with one or more |
| frames in which components can be loaded. Desktop is the |
| environment for components which can instanciate within |
| frames. */ |
| XComponentLoader xcomponentloader = ( XComponentLoader ) |
| UnoRuntime.queryInterface( XComponentLoader.class, |
| xmulticomponentfactory.createInstanceWithContext( |
| "com.sun.star.frame.Desktop", xcomponentcontext ) ); |
| |
| // Preparing properties for loading the document |
| PropertyValue propertyvalue[] = new PropertyValue[ 1 ]; |
| // Setting the flag for hidding the open document |
| propertyvalue[ 0 ] = new PropertyValue(); |
| propertyvalue[ 0 ].Name = "Hidden"; |
| propertyvalue[ 0 ].Value = new Boolean(true); |
| |
| // Loading the wanted document |
| Object objectDocumentToStore = |
| xcomponentloader.loadComponentFromURL( |
| stringUrl, "_blank", 0, propertyvalue ); |
| |
| // Getting an object that will offer a simple way to store a document to a URL. |
| XStorable xstorable = |
| ( XStorable ) UnoRuntime.queryInterface( XStorable.class, |
| objectDocumentToStore ); |
| |
| // Preparing properties for converting the document |
| propertyvalue = new PropertyValue[ 2 ]; |
| // Setting the flag for overwriting |
| propertyvalue[ 0 ] = new PropertyValue(); |
| propertyvalue[ 0 ].Name = "Overwrite"; |
| propertyvalue[ 0 ].Value = new Boolean(true); |
| // Setting the filter name |
| propertyvalue[ 1 ] = new PropertyValue(); |
| propertyvalue[ 1 ].Name = "FilterName"; |
| propertyvalue[ 1 ].Value = stringConvertType; |
| |
| // Appending the favoured extension to the origin document name |
| int index = stringUrl.lastIndexOf('.'); |
| if ( index >= 0 ) { |
| stringConvertedFile = stringUrl.substring(0, index) + "." + stringExtension; |
| } else { |
| stringConvertedFile = stringUrl + "." + stringExtension; |
| } |
| |
| // Storing and converting the document |
| xstorable.storeAsURL( stringConvertedFile, propertyvalue ); |
| |
| XCloseable xcloseable = (XCloseable)UnoRuntime.queryInterface( XCloseable.class,xstorable ); |
| |
| // Closing the converted document |
| if ( xcloseable != null ) |
| xcloseable.close(false); |
| else { |
| // If Xcloseable is not supported (older versions, |
| // use dispose() for closing the document |
| XComponent xComponent = ( XComponent ) UnoRuntime.queryInterface( |
| XComponent.class, xstorable ); |
| xComponent.dispose(); |
| } |
| |
| // } |
| // catch( Exception exception ) { |
| // exception.printStackTrace(); |
| // return( "" ); |
| // } |
| |
| if ( stringConvertedFile.startsWith( "file:///" ) ) { |
| // Truncating the beginning of the file name |
| stringConvertedFile = stringConvertedFile.substring( 8 ); |
| } |
| |
| // Returning the name of the converted file |
| return stringConvertedFile; |
| } |
| } |