Editing pdf/word content (text replacement)

[Naresh Chaurasia]

Hi,
I am trying to work on a project that would allow me to do text replacement in pdf & word file.
I spend some time using iText to edit pdf(doing text replacement), but it does not work efficiently. The formatting is lost, words overlap etc.

I am now trying to do similar thing in word document. I am trying to use poi project from poi.apache.org. I am not able to do text replacement or editing existing word document.

Any suggestion / API help will be appreciated.

[Ulf Dittmer]

PDFs are not meant for editing, certainly not for altering the textual contents. Adobe's Acrobat Pro can do that, but I'm not aware of any free Java libraries for that.

My last post in this topic suggests a solution for DOC files.

It'll probably be easier if you were to do this using RTF files. This discussion should also be of interest: https://coderanch.com/t/278413/Streams/java/apache-POI-HWPF-search-replace

[Naresh Chaurasia]

I am trying to use the code posed on the following URLs

http://test.javaranch.com/ulf/ParagraphText.java and http://test.javaranch.com/ulf/InsertText.java

When i run the program , i am generating output file : Copy.doc. When i try to open the file it give me the following error: word was unable to read this document. It may be corrupt

Please suggest what needs to be done.

Regards.

[Ulf Dittmer]

I'm surprised you even got the code to compile; that means you're using an old version of POI. When I tried it just now I had to replace "usesUnicode" by "isUnicode" to get it compile against POI 3.7. Then I was able to create and open the output file using both LibreOffice and Mellel just fine (I don't have Word around). And, also important, the replacement was done correctly :-)

Try upgrading to the latest POI version; each new version has lots of bug fixes.

[Naresh Chaurasia]

I am using poi3.7. I also made the change replace "usesUnicode" by "isUnicode".

Following is my code

InsertText

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.usermodel.Range;
import org.apache.poi.hwpf.usermodel.Paragraph;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.hwpf.model.TextPiece;

/**
 * An instance of this class can be used to replace 'placeholders' with
 * text within a Word document. Any and all occurrences found within paragraphs
 * of text contained either within the body of the document or the cells of a
 * table will be replaced.
 * 
 * Currently, the replacement takes no regard of any formatting applied to the
 * original text. Instead, it will simply replace the 'placeholder' with text
 * formatted in accordance with the 'Normal' style.
 * 
 * @author AA
 * 
 * @version 1.00 8th December 2008.
 */
public class InsertText {
    
    private File inputFile = null;
    private HWPFDocument document = null;
    private HashMap<String, String> replacementText = null;
    private Set<String> keys = null;
        
    /**
     * Create a new instance of the InsertText class using the following parameters;
     * 
     * @param filename An instance of the String class encapsulating the path
     *        path to and name of the MS Word file that is to be processed. No
     *        checks are made to ensure that the file is accessible or even
     *        of the correct data type.
     * @param replacementText An instance of the HashMap class that contains
     *        one or more key value pairs. Each pair consists of two Strings
     *        the first encapsulates the placeholder and the second the
     *        text that should replace it.
     * 
     * @throws NullPointerException if a null value is passed to either parameter.
     * @throws IllegalArgumentException if the vallue passed to either parameter is empty.
     */
    public InsertText(String filename, HashMap<String, String> replacementText) throws NullPointerException, IllegalArgumentException {
        
        // Not strictly necessary as a similar exception will be thrown on
        // instantiation of the File object later. Still like to test the parameters though.
        if(filename == null) {
            throw new NullPointerException("Null value passed to the filename parameter of the InsertText class constructor.");
        }
        if(replacementText == null) {
            throw new NullPointerException("Null value passed to the replacementText parameter of the InsertText class constructor.");
        }
        if(filename==null) {
            throw new IllegalArgumentException("An empty String was passed to the filename parameter of the InsertText class constructor.");
        }
        if(replacementText.isEmpty()) {
            throw new IllegalArgumentException("An empty HashMap was passed to the replacementText parameter of the InsertText class constructor.");
        }
        // Copy parameters to local variables. Get the set of keys backing the HashMap and open the file.
        this.replacementText = replacementText;
        this.keys = replacementText.keySet();
        this.inputFile = new File(filename);
    }
    
    /**
     * Called to replace any named 'placeholders' with their accompanying text.
     */
    public void processFile() {
        Range range = null;
        BufferedInputStream buffInputStream = null;
        BufferedOutputStream buffOutputStream = null;
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        ParagraphText[] paraText = null;

        try {
            // Open the input file.
            fileInputStream = new FileInputStream(this.inputFile);
            buffInputStream = new BufferedInputStream(fileInputStream);
            this.document = new HWPFDocument(new POIFSFileSystem(buffInputStream));
            
            // Get an instance of the Range class and load all of the Paragrpahs
            // the document contains into a local array of type ParagraphText.
            range = this.document.getRange();
            paraText = this.loadParagraphs(range);

            // Step through the paragraph text.
            for(int i = 0; i < paraText.length; i++) {
                
                // Step through the Set of keys that backs the HashMap of
                // key/value pairs. For each key, test to see whether it exists
				// in the paragraph of text and if so replace it with the specified text value.
                for(String key : this.keys) {
                	System.out.println(paraText[i].getUpdatedText());
                    if(paraText[i].getUpdatedText().contains(key)) {
                        paraText[i].updateText(
                            this.replacePlaceholders(key, this.replacementText.get(key), paraText[i].getUpdatedText()));
                    }
                }
                
                // After the paragraph has been tested against all of the keys
                // for placeholders, check to see if any replacements were nade.
                // If there were any replacements made then call the replaceText()
                // method for the specific paragraph. Here the paragraph's
                // number is recovered by calling the getParagraphNumber()
                // method - this could easilly be replaced in the current
                // situation with the number i which is the index of the enclosing
                // for loop. If the updates were made in another loop however, the
                // availability of the paragraph number could be useful.
                //
                // Note that two further calls are made to get the raw text - the
                // text that was originallg recovered from the paragraph - and the
                // updated text - the text with any placeholders replaced. It
                // proved necessary to copy the text recovered from the paragraph
                // becuase a call to the text() method of the Paragraph object
                // only returned part of the text for the final paragraph.
                if(paraText[i].isUpdated()) {
                    range.getParagraph(paraText[i].getParagraphNumber()).replaceText(
                            paraText[i].getRawText(), paraText[i].getUpdatedText(), 0);
                }
            }
            // Save the document away.
            fileOutputStream = new FileOutputStream(new File("Copy.doc"));
            buffOutputStream = new BufferedOutputStream(fileOutputStream);
            this.document.write(buffOutputStream);
        }
        catch(IOException ioEx) {
            System.out.println("Caught an: " + ioEx.getClass().getName());
            System.out.println("Message: " + ioEx.getMessage());
            System.out.println("StackTrace follows:");
            ioEx.printStackTrace(System.out);
        }
        finally {
            if(buffInputStream != null) {
                try {
                    buffInputStream.close();
                }
                catch(IOException ioEx) {
                    // I G N O R E //
                }
            }
            
            if(buffOutputStream != null) {
                try {
                    buffOutputStream.flush();
                    buffOutputStream.close();
                }
                catch(IOException ioEx) {
                    // I G N O R E //
                }
            }
        }
    }
    
    /**
     * Called to replace all occurrences of a placeholder.
     * 
     * @param key An instance of the String class that encapsulates the text of the placeholder.
     * @param value An instance of the String class that encapsulates the
     *        text that will be used to replace the placeholder.
     * @param text An instance of the String class that contains the contents
     *        of a paragraph read from a Word document.
     * 
     * @return An instance of the String class containing an updated version
     *         of the text originally recovered from the Word document; one
     *         where all occurrences of the placeholder have been replaced.
     */
    private String replacePlaceholders(String key, String value, String text) {
        int index = 0;
        // This is far from the most efficient way to parse the String as it
        // always starts from the beginning even after one or more substitutions
        // have been made. For now though it does work but will have obvious
        // limitations if the chunks of text are very large.
        while((index = text.indexOf(key)) >= 0) {
            text = text.substring(0, index) + value + text.substring(index + key.length());
        }
        return(text);
    }
    
    /**
     * Reads the contents of the document as a series of Paragraph objects. The
     * text is extracted from each and encapsulated into a instances of the ParagraphText calss.
     * 
     * It proved to be problematic to call the text() method on an instance
     * of the Paragraph class - sometimes, such a call would fail to return
     * all of the text the actual paragraph contained. So, it was necessary to
     * read all of the text into local variables so that it could be more
     * effectivley and successfully processed and this method was copied -
     * along with it's companion getTextFromPieces() from Nick Burch's WordExtractor class.
     * 
     * @param range An instance of the org.apache.poi.hwpf.usermodel.Range class
     *        that encapsulates information about the Word document - it's
     *        sections, paragraphs, tables, pictures, etc.
     * 
     * @return An array of type ParagraphText. Each element will contain an
     *         instance of the ParagraphText class that encasulates information
     *         about a paragraph of text - the text itself, the number of the
     *         paragraph, whether the text has been modified since it was read, etc.
     */
    private ParagraphText[] loadParagraphs(Range range) {
        ParagraphText[] paraText = new ParagraphText[range.numParagraphs()];
        Paragraph paragraph = null;
        String readText = null;
        try{
        
            for(int i = 0; i < range.numParagraphs(); i++) {
                paragraph = range.getParagraph(i);
                readText = paragraph.text();
                if(readText.endsWith("\n")) {
                    readText = readText + "\n";
                }
                paraText[i] = new ParagraphText(i, readText);
            }
        }
        catch(Exception ex) {
            paraText[0] = this.getTextFromPieces();
        }
        return(paraText);
    }

    /**
     * Again, with thanks to Nick Burch, this method will reconstruct the 
     * document's text from a series of TextPieces.
     * 
     * @return An instance of the ParagraphText class that encapsulates all
     *         of the text recovered from the document and treats it as one
     *         very large - potentially - paragraph.
     */
    private ParagraphText getTextFromPieces() {
        TextPiece piece = null;
        StringBuffer buffer = new StringBuffer();
        String text = null;
        String encoding = "Cp1252";
        
       	Iterator textPieces = this.document.getTextTable().getTextPieces().iterator();
       	while (textPieces.hasNext()) {
            piece = (TextPiece)textPieces.next();
            if (piece.isUnicode()) {
                encoding = "UTF-16LE";
            }
            try {
                text = new String(piece.getRawBytes(), encoding);
       		buffer.append(text);
            } catch(UnsupportedEncodingException e) {
                throw new InternalError("Standard Encoding " + encoding + " not found, JVM broken");
            }
       	}
       	text = buffer.toString();
       	// Fix line endings (Note - won't get all of them
       	text = text.replaceAll("\r\r\r", "\r\n\r\n\r\n");
       	text = text.replaceAll("\r\r", "\r\n\r\n");
       	if(text.endsWith("\r")) {
       		text += "\n";
       	}
      	return(new ParagraphText(0, text));
      }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            HashMap<String, String> replacementText = new HashMap<String, String>();
            replacementText.put("$PH1", "MODIFIED REPLACEMENT 1");
            replacementText.put("$PH2", "MODIFIED REPLACEMENT 2");
            new InsertText("Sample.doc", replacementText).processFile();
            System.out.println("Ok");
        }
        catch(Exception eEx) {
            System.out.println("Caught an: " + eEx.getClass().getName());
            System.out.println("Message: " + eEx.getMessage());
            System.out.println("StackTrace follows:");
            eEx.printStackTrace(System.out);
        }
    }
}

ParagraphText

/**
 * An instance of this class encapsulates information about a paragraph
 * recovered from a Word cocument.
 * 
 * @author AA
 * 
 * @version 1.00 8th December 2008.
 */
public class ParagraphText {
    
    private String rawText = null;
    private String updatedText = null;
    private boolean updated = false;
    private int paragraphNumber = 0;

    /**
     * Create an instance of the ParagraphText class using the following
     * parameters;
     * 
     * @param paragraphNumber A primitive int whose value indicates the
     *        number of the paragraph.
     * @param text An instance of the String class encapsulating the text
     *        recovered from the document.
     */
    public ParagraphText(int paragraphNumber, String text) {
        // Note that two 'copies' of the document's text are made. This is
        // so that one can be modofed whilst the other is unaltered for
        // later use in the replaceText() method. This approach was adopted
        // because a call to the text() method on the final paragraph of the
        // document produced inconsistent results and it is essentil to know the
        // paragraphs original contents in order to update it successfully.
        this.rawText = text;
        this.updatedText = new String(text);
        this.paragraphNumber = paragraphNumber;
        this.updated = false;
    }
    
    /**
     * Get the original - unaltered - contents of the paragraph.
     * 
     * @return A String object that encapsulates the text as it was orginally
     *         recovered from the paragraph.
     */
    public String getRawText() {
        return(this.rawText);
    }
    
    /**
     * Get the contents for the paragraph following any modifications.
     * 
     * @return A String object encapsulating the modified version of the
     *         paragraphs text - that is the version where any and all
     *         'placeholders' have been replaced.
     */
    public String getUpdatedText() {
        return(this.updatedText);
    }
    
    /**
     * Get the number of the paragraph.
     * 
     * @return A primtive int whose value indicates the position of the
     *         paragraph within the entire series of paragraphs read from the
     *         document.
     */
    public int getParagraphNumber() {
        return(this.paragraphNumber);
    }
    
    /**
     * Update or modify the paragraphs contents.
     * 
     * @param text A String object that encapsulates the text the paragraph
     *        should contain following modification.
     */
    public void updateText(String text) {
        this.updatedText = text;
        this.setUpdated(true);
    }
    
    /**
     * Indicates whether the paragraphs text has been updated.
     * 
     * @return A boolean value indicating whether the text has been updated 
     *         - true - or not - false.
     */
    public boolean isUpdated() {
        return(this.updated);
    }

    /**
     * Retruns a String that represents the succrent state of the object.
     * 
     * @return A String that encapsulates information about the objets state.
     *         In this case, the contents of it's member variables.
     * 
     * @Override
     */
    public String toString() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("ParagraphText: ");
        buffer.append("Paragraph Number: ");
        buffer.append(this.paragraphNumber);
        buffer.append(" Raw Text: ");
        buffer.append(this.rawText);
        buffer.append(" Updated Text: ");
        buffer.append(this.updatedText);
        buffer.append(" Updated: ");
        buffer.append(this.updated);
        return(buffer.toString().trim());
    }
    
    /**
     * A utility method used to set the state of the updated flag.
     */
    private void setUpdated(boolean updated) {
        this.updated = updated;
    }
}

Not sure if i have to make some other change to make this thing work correctly.

[Naresh Chaurasia]

I am working on poi 3.7 and running the test case testRangeInsertion from file TestRangeInsertion.java. I added the following lines of code

		FileOutputStream fileOutputStream = new FileOutputStream(new File("Copy.doc"));
		BufferedOutputStream buffOutputStream = new BufferedOutputStream(fileOutputStream);
		daDoc.write(buffOutputStream);

and the final function is as follows:

	public void testRangeInsertion() {
		
		try {
			
		

		HWPFDocument daDoc = HWPFTestDataSamples.openSampleFile(illustrativeDocFile);
		System.out.println(daDoc.getClass());

		if (false) { // TODO - delete or resurrect this code
			Range range = daDoc.getRange();
			Section section = range.getSection(0);
			Paragraph para = section.getParagraph(2);
			String text = para.getCharacterRun(0).text() + para.getCharacterRun(1).text() +
			para.getCharacterRun(2).text();

			System.out.println(text);
		}

		Range range = new Range(insertionPoint, (insertionPoint + 2), daDoc);
		range.insertBefore(textToInsert);

		// we need to let the model re-calculate the Range before we evaluate it
		range = daDoc.getRange();

		assertEquals(1, range.numSections());
		Section section = range.getSection(0);

		assertEquals(3, section.numParagraphs());
		Paragraph para = section.getParagraph(2);
		assertEquals((textToInsert + originalText), para.text());

		assertEquals(3, para.numCharacterRuns());
		String text =
			para.getCharacterRun(0).text() +
			para.getCharacterRun(1).text() +
			para.getCharacterRun(2).text()
		;

		// System.out.println(text);

		assertEquals((textToInsert + originalText), text);
		
        // Save the document away.
		FileOutputStream fileOutputStream = new FileOutputStream(new File("Copy.doc"));
		BufferedOutputStream buffOutputStream = new BufferedOutputStream(fileOutputStream);
		daDoc.write(buffOutputStream);
		
		} catch (Exception e) {
			System.out.println("exc: "+ e);
		}

	}

I am not able to open the output file generated from the above test case. Any suggestions. This problem is similar to the above problem. I am not able to understand why the newly created file is corrupted/not opening using MS word.

[Mohit Uppal]

Hello Naresh Chaurasia,

I am able to read and edit document and also the code you posted is making new document file but that document file
is not able to open in MS Word 2007. Did you find any solution to problem ??

please reply... Its urgent...

Thanks

[Mohit Uppal]

Hello Ulf Dittmer,

As you have said that you are able to create and open the output file using both LibreOffice and Mellel just fine
and you don't have MS Word around. So if you can open the file with MS word and check if you are able to do that.
Because i am not able to open it with Office 2007.

I have used POI 3.7 and POI 3.8 Beta 3, same result with both APIs

Thanks and Please reply

Urgent....

Thanks

[Rob Spoor]

Mohit Uppal wrote:Urgent....

Please EaseUp. There's no such thing as "urgent" around here.