Legacy .doc with HWPF

<dependencies>
    <!-- OLE2 file system, shared by every legacy format -->
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>5.5.1</version>
    </dependency>
    <!-- HWPF (.doc), HSLF, HSMF and the other scratchpad components -->
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-scratchpad</artifactId>
        <version>5.5.1</version>
    </dependency>
    <!-- Only if the same application also reads or writes .docx or .xlsx -->
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>5.5.1</version>
    </dependency>
    <!-- Only for the XSL-FO to PDF path shown below -->
    <dependency>
        <groupId>org.apache.xmlgraphics</groupId>
        <artifactId>fop</artifactId>
        <version>2.11</version>
    </dependency>
</dependencies>

dependencies {
    implementation("org.apache.poi:poi:5.5.1")
    implementation("org.apache.poi:poi-scratchpad:5.5.1")
    implementation("org.apache.poi:poi-ooxml:5.5.1")
    implementation("org.apache.xmlgraphics:fop:2.11")
}

package bookshelf.legacy;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.OldWordFileFormatException;
import org.apache.poi.poifs.filesystem.FileMagic;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public final class LegacyDocOpener {

    public enum Kind { DOC, DOCX, OLD_WORD, UNSUPPORTED }

    private LegacyDocOpener() {
    }

    /** Classifies the file by content, not by its name. */
    public static Kind classify(Path file) throws IOException {
        try (InputStream raw = Files.newInputStream(file);
             InputStream in = FileMagic.prepareToCheckMagic(raw)) {
            FileMagic magic = FileMagic.valueOf(in);
            if (magic == FileMagic.OOXML) {
                return Kind.DOCX;
            }
            if (magic != FileMagic.OLE2) {
                return Kind.UNSUPPORTED;
            }
        }
        // OLE2: try to open as Word 97-2003 and detect the older versions
        try (POIFSFileSystem fs = new POIFSFileSystem(file.toFile(), true);
             HWPFDocument ignored = new HWPFDocument(fs)) {
            return Kind.DOC;
        } catch (OldWordFileFormatException e) {
            return Kind.OLD_WORD;
        } catch (RuntimeException e) {
            return Kind.UNSUPPORTED;
        }
    }
}

package bookshelf.legacy;

import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class LoanLetterTextExtractor {

    public record LetterText(String body, String header, String footer, List<String> comments) {
    }

    public LetterText extract(Path docFile) throws IOException {
        try (POIFSFileSystem fs = new POIFSFileSystem(docFile.toFile(), true);
             HWPFDocument doc = new HWPFDocument(fs);
             WordExtractor extractor = new WordExtractor(doc)) {
            extractor.setCloseFilesystem(false); // the try-with-resources owns the file system
            return new LetterText(
                    extractor.getText().strip(),
                    extractor.getHeaderText().strip(),
                    extractor.getFooterText().strip(),
                    List.of(extractor.getCommentsText()));
        }
    }
}

package bookshelf.legacy;

import java.io.IOException;
import java.nio.file.Path;
import org.apache.poi.hwpf.extractor.Word6Extractor;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class OldWordTextExtractor {

    public String extract(Path file) throws IOException {
        try (POIFSFileSystem fs = new POIFSFileSystem(file.toFile(), true);
             Word6Extractor extractor = new Word6Extractor(fs)) {
            extractor.setCloseFilesystem(false);
            return String.join("\n", extractor.getParagraphText()).strip();
        }
    }
}

package bookshelf.legacy;

import java.io.IOException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.usermodel.CharacterRun;
import org.apache.poi.hwpf.usermodel.Paragraph;
import org.apache.poi.hwpf.usermodel.Range;
import org.apache.poi.hwpf.usermodel.Table;
import org.apache.poi.hwpf.usermodel.TableCell;
import org.apache.poi.hwpf.usermodel.TableRow;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class BookRequestFormReader {

    public record RequestedBook(String isbn, String title, int copies) {
    }

    public record Form(List<String> headings, List<String> paragraphs, List<RequestedBook> books) {
    }

    public Form read(Path docFile) throws IOException {
        List<String> headings = new ArrayList<>();
        List<String> paragraphs = new ArrayList<>();
        List<RequestedBook> books = new ArrayList<>();

        try (POIFSFileSystem fs = new POIFSFileSystem(docFile.toFile(), true);
             HWPFDocument doc = new HWPFDocument(fs)) {
            Range body = doc.getRange();
            int i = 0;
            while (i < body.numParagraphs()) {
                Paragraph paragraph = body.getParagraph(i);
                if (paragraph.isInTable()) {
                    Table table = body.getTable(paragraph);
                    readBooks(table, books);
                    // the table is a range that includes its own paragraphs: skip them all
                    i += table.numParagraphs();
                    continue;
                }
                String text = clean(paragraph.text());
                if (!text.isEmpty()) {
                    String style = doc.getStyleSheet()
                            .getStyleDescription(paragraph.getStyleIndex()).getName();
                    if (style.startsWith("Heading")) {
                        headings.add(text);
                    } else if (!allRunsBold(paragraph) || text.length() > 60) {
                        paragraphs.add(text);
                    } else {
                        headings.add(text); // a short, fully bold line used as a heading
                    }
                }
                i++;
            }
        }
        return new Form(headings, paragraphs, books);
    }

    private void readBooks(Table table, List<RequestedBook> books) {
        // row 0 is the header row
        for (int r = 1; r < table.numRows(); r++) {
            TableRow row = table.getRow(r);
            if (row.numCells() < 3) {
                continue;
            }
            books.add(new RequestedBook(
                    clean(row.getCell(0).text()),
                    clean(row.getCell(1).text()),
                    parseInt(clean(row.getCell(2).text()))));
        }
    }

    private boolean allRunsBold(Paragraph paragraph) {
        for (int c = 0; c < paragraph.numCharacterRuns(); c++) {
            CharacterRun run = paragraph.getCharacterRun(c);
            if (!run.isBold() && !clean(run.text()).isEmpty()) {
                return false;
            }
        }
        return true;
    }

    /** Removes the paragraph mark, the cell mark and surrounding spaces. */
    private static String clean(String text) {
        return text.replace("\r", "").replace("\u0007", "").replace("\f", "").strip();
    }

    private static int parseInt(String text) {
        try {
            return Integer.parseInt(text);
        } catch (NumberFormatException e) {
            return 0;
        }
    }
}

package bookshelf.legacy;

import java.io.IOException;
import java.nio.file.Path;
import java.util.Objects;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.usermodel.HeaderStories;
import org.apache.poi.hwpf.usermodel.Range;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class LoanLetterHeaderFooterReader {

    public void print(Path docFile) throws IOException {
        try (POIFSFileSystem fs = new POIFSFileSystem(docFile.toFile(), true);
             HWPFDocument doc = new HWPFDocument(fs)) {
            HeaderStories stories = new HeaderStories(doc);
            stories.setAreFieldsStripped(true); // drop PAGE and NUMPAGES field codes
            System.out.println("Odd header : " + Objects.toString(stories.getOddHeader(), "").strip());
            System.out.println("First header: " + Objects.toString(stories.getFirstHeader(), "").strip());
            System.out.println("Odd footer : " + Objects.toString(stories.getOddFooter(), "").strip());

            Range comments = doc.getCommentsRange();
            for (int i = 0; i < comments.numParagraphs(); i++) {
                System.out.println("Comment: " + comments.getParagraph(i).text().strip());
            }
            Range footnotes = doc.getFootnoteRange();
            System.out.println("Footnote paragraphs: " + footnotes.numParagraphs());
        }
    }
}

package bookshelf.legacy;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.usermodel.Picture;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class LoanLetterPictureExtractor {

    /** Saves every picture of the document and returns the files written. */
    public int extract(Path docFile, Path outputDirectory) throws IOException {
        Files.createDirectories(outputDirectory);
        try (POIFSFileSystem fs = new POIFSFileSystem(docFile.toFile(), true);
             HWPFDocument doc = new HWPFDocument(fs)) {
            List<Picture> pictures = doc.getPicturesTable().getAllPictures();
            int index = 0;
            for (Picture picture : pictures) {
                String name = "picture-" + (++index) + "." + picture.suggestFileExtension();
                Files.write(outputDirectory.resolve(name), picture.getContent());
                System.out.printf("%s %s %dx%d%n", name, picture.getMimeType(),
                        picture.getWidth(), picture.getHeight());
            }
            return pictures.size();
        }
    }
}

package bookshelf.legacy;

import java.io.IOException;
import java.nio.file.Path;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.usermodel.Range;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class LoanLetterFiller {

    private static final DateTimeFormatter DATE = DateTimeFormatter.ofPattern("d MMMM yyyy");
    private static final Pattern PLACEHOLDER = Pattern.compile("\\$\\{[A-Za-z0-9_.]+}");

    public void fill(Path template, Path output, String borrower, String title, LocalDate dueDate)
            throws IOException {
        Map<String, String> values = new LinkedHashMap<>();
        values.put("${borrower}", borrower);
        values.put("${title}", title);
        values.put("${dueDate}", dueDate.format(DATE));

        try (POIFSFileSystem fs = new POIFSFileSystem(template.toFile(), true);
             HWPFDocument doc = new HWPFDocument(fs)) {
            replaceAll(doc, values);
            doc.write(output.toFile());
        }
    }

    /** Replaces the markers one occurrence at a time, left to right, never rescanning an inserted value. */
    static void replaceAll(HWPFDocument doc, Map<String, String> values) {
        int from = 0;
        while (true) {
            // one pointer: take a fresh range for every replacement
            Range range = doc.getRange();
            Matcher marker = PLACEHOLDER.matcher(range.text());
            if (!marker.find(from)) {
                return;
            }
            String value = values.get(marker.group());
            if (value == null) {
                from = marker.end();                       // unknown marker: leave it
            } else {
                range.replaceText(marker.group(), value, marker.start());
                from = marker.start() + value.length();    // continue after the value
            }
        }
    }
}

// Add a reference line at the top of the letter and remove the "draft" paragraph
Range body = doc.getRange();
body.getParagraph(0).insertBefore("Ref: BK-2026-0042\r");

body = doc.getRange(); // fresh pointer after the edit
for (int i = 0; i < body.numParagraphs(); i++) {
    if (body.getParagraph(i).text().startsWith("DRAFT")) {
        body.getParagraph(i).delete();
        break;
    }
}

$ soffice --headless --convert-to docx:"MS Word 2007 XML" --outdir converted archive/old-loan-letters/loan-letter.doc
convert archive/old-loan-letters/loan-letter.doc -> converted/loan-letter.docx using filter : MS Word 2007 XML
$ ls converted
loan-letter.docx

package bookshelf.legacy;

import java.io.IOException;
import java.nio.file.Path;
import org.springframework.stereotype.Service;

@Service
public class WordUploadRouter {

    private final LoanLetterTextExtractor docExtractor = new LoanLetterTextExtractor();
    private final OldWordTextExtractor oldWordExtractor = new OldWordTextExtractor();

    /** Returns the plain text of any supported Word upload. */
    public String textOf(Path upload) throws IOException {
        return switch (LegacyDocOpener.classify(upload)) {
            case DOC -> docExtractor.extract(upload).body();
            case OLD_WORD -> oldWordExtractor.extract(upload);
            case DOCX -> throw new UnsupportedOperationException(
                    "Route .docx to the XWPF reader, see word-xwpf-basics");
            case UNSUPPORTED -> throw new IllegalArgumentException("Not a Word document");
        };
    }
}