Get rid of own merge fields logic in PdfPageFormCopier logic and use the one from form fields

DEVSIX-7389

Author: vitali-pr

forms/src/main/java/com/itextpdf/forms/PdfAcroForm.java

@@ -209,23 +209,35 @@ public void addField(PdfFormField field) {
      *
      * @param field the {@link PdfFormField} to be added to the form
      * @param page  the {@link PdfPage} on which to add the field
-     * @param replaceExisted if true then the existed form field will be replaced by a new one
-     *                       in case they have the same names
      */
-    public void addField(PdfFormField field, PdfPage page, boolean replaceExisted) {
+    public void addField(PdfFormField field, PdfPage page) {
+        addField(field, page, true);
+    }
+
+    /**
+     * This method adds the field to a specific page.
+     *
+     * @param field the {@link PdfFormField} to be added to the form
+     * @param page  the {@link PdfPage} on which to add the field
+     * @param throwExceptionOnError true if the exception is expected to be thrown in case of error.
+     */
+    public void addField(PdfFormField field, PdfPage page, boolean throwExceptionOnError) {
         if (!field.getPdfObject().containsKey(PdfName.T)) {
-            throw new PdfException(FormsExceptionMessageConstant.FORM_FIELD_MUST_HAVE_A_NAME);
+            if (throwExceptionOnError) {
+                throw new PdfException(FormsExceptionMessageConstant.FORM_FIELD_MUST_HAVE_A_NAME);
+            } else {
+                LOGGER.warn(FormsLogMessageConstants.FORM_FIELD_MUST_HAVE_A_NAME);
+                return;
+            }
         }
 
-        if (!replaceExisted) {
-            PdfFormFieldMergeUtil.mergeKidsWithSameNames(field, true);
-        }
+        PdfFormFieldMergeUtil.mergeKidsWithSameNames(field, throwExceptionOnError);
 
         PdfDictionary fieldDict = field.getPdfObject();
         // PdfPageFormCopier expects that we replace existed field by a new one in case they have the same names.
         String fieldName = field.getFieldName().toUnicodeString();
-        if (replaceExisted || !fields.containsKey(fieldName) ||
-                !PdfFormFieldMergeUtil.mergeTwoFieldsWithTheSameNames(fields.get(fieldName), field, true)) {
+        if (!fields.containsKey(fieldName) ||
+                !PdfFormFieldMergeUtil.mergeTwoFieldsWithTheSameNames(fields.get(fieldName), field, throwExceptionOnError)) {
             PdfArray fieldsArray = getFields();
             fieldsArray.add(fieldDict);
             fieldsArray.setModified();
@@ -240,16 +252,6 @@ public void addField(PdfFormField field, PdfPage page, boolean replaceExisted) {
         setModified();
     }
 
-    /**
-     * This method adds the field to a specific page.
-     *
-     * @param field the {@link PdfFormField} to be added to the form
-     * @param page  the {@link PdfPage} on which to add the field
-     */
-    public void addField(PdfFormField field, PdfPage page) {
-        addField(field, page, false);
-    }
-
     /**
      * This method merges field with its annotation and places it on the given
      * page. This method also work if the field has more than one widget

forms/src/main/java/com/itextpdf/forms/PdfPageFormCopier.java

@@ -25,7 +25,6 @@ This file is part of the iText (R) project.
 import com.itextpdf.forms.fields.PdfFormField;
 import com.itextpdf.forms.fields.AbstractPdfFormField;
 import com.itextpdf.forms.logs.FormsLogMessageConstants;
-import com.itextpdf.forms.fields.PdfFormFieldMergeUtil;
 import com.itextpdf.io.logs.IoLogMessageConstant;
 import com.itextpdf.commons.utils.MessageFormatUtil;
 import com.itextpdf.kernel.pdf.IPdfPageExtraCopier;
@@ -38,14 +37,14 @@ This file is part of the iText (R) project.
 import com.itextpdf.kernel.pdf.PdfString;
 import com.itextpdf.kernel.pdf.annot.PdfAnnotation;
 
+import java.util.LinkedHashSet;
+import java.util.Set;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 /**
  * A sample implementation of the {#link IPdfPageExtraCopier} interface which
@@ -62,6 +61,9 @@ public class PdfPageFormCopier implements IPdfPageExtraCopier {
     private PdfAcroForm formTo;
     private PdfDocument documentFrom;
     private PdfDocument documentTo;
+
+    private final Set<PdfObject> collectedFieldObjects = new LinkedHashSet<PdfObject>();
+
     private static Logger logger = LoggerFactory.getLogger(PdfPageFormCopier.class);
 
     @Override
@@ -98,11 +100,30 @@ public void copy(PdfPage fromPage, PdfPage toPage) {
 
         List<PdfAnnotation> annots = toPage.getAnnotations();
 
-        for (PdfAnnotation annot : annots) {
-            if (!annot.getSubtype().equals(PdfName.Widget)) {
-                continue;
+        try {
+            for (PdfAnnotation annot : annots) {
+                if (!annot.getSubtype().equals(PdfName.Widget)) {
+                    continue;
+                }
+                copyField(fieldsFrom, fieldsTo, annot);
+            }
+            for (PdfObject fieldObject : collectedFieldObjects) {
+                PdfFormField field = PdfFormField.makeFormField(fieldObject, documentTo);
+                String fieldName = field.getFieldName().toUnicodeString();
+                if (field.equals(fieldsTo.get(fieldName))) {
+                    // Here the 'field' might wrap the same pdfObject as fieldsTo.get(fieldName).
+                    // But fieldsTo.get(fieldName) might have less childFields attached
+                    // (and the same amount of Kids in pdf object it wraps, see createParentFieldCopy
+                    // where we work with the Kids array directly). Our merge logic doesn't work
+                    // with such not synchronised fields. So that we replace it with newly created field
+                    // which contains all childFields.
+                    formTo.replaceField(fieldName, field);
+                } else {
+                    formTo.addField(field, toPage, false);
+                }
             }
-            copyField(toPage, fieldsFrom, fieldsTo, annot);
+        } finally {
+            collectedFieldObjects.clear();
         }
     }
 
@@ -115,7 +136,7 @@ private AbstractPdfFormField makeFormField(PdfObject fieldDict) {
         return field;
     }
 
-    private void copyField(PdfPage toPage, Map<String, PdfFormField> fieldsFrom,
+    private void copyField(Map<String, PdfFormField> fieldsFrom,
                            Map<String, PdfFormField> fieldsTo, PdfAnnotation currentAnnot) {
         PdfDictionary parent = currentAnnot.getPdfObject().getAsDictionary(PdfName.Parent);
         if (parent != null) {
@@ -127,7 +148,7 @@ private void copyField(PdfPage toPage, Map<String, PdfFormField> fieldsFrom,
             if (parentName == null) {
                 return;
             }
-            copyParentFormField(toPage, fieldsTo, currentAnnot, parentField);
+            copyParentFormField(fieldsTo, currentAnnot, parentField);
         } else {
             PdfString annotName = currentAnnot.getPdfObject().getAsString(PdfName.T);
             String annotNameString = null;
@@ -142,108 +163,34 @@ private void copyField(PdfPage toPage, Map<String, PdfFormField> fieldsFrom,
                 if (field == null) {
                     return;
                 }
-                if (fieldsTo.get(annotNameString) != null) {
-                    field = mergeFieldsWithTheSameName(field);
+
+                if (!collectedFieldObjects.contains(field.getPdfObject())) {
+                    if (fieldsTo.get(annotNameString) != null) {
+                        logger.warn(MessageFormatUtil.format(IoLogMessageConstant.DOCUMENT_ALREADY_HAS_FIELD,
+                                annotNameString));
+                    }
+
+                    collectedFieldObjects.add(field.getPdfObject());
                 }
-                // Form may be already added to the page. PdfAcroForm will take care about it.
-                formTo.addField(field, toPage, true);
+
                 field.updateDefaultAppearance();
             }
         }
     }
 
-    private void copyParentFormField(PdfPage toPage, Map<String, PdfFormField> fieldsTo,
+    private void copyParentFormField(Map<String, PdfFormField> fieldsTo,
                                      PdfAnnotation annot, PdfFormField parentField) {
-        PdfString parentName = parentField.getFieldName();
-        // parentField should be the root field
-        if (!fieldsTo.containsKey(parentName.toUnicodeString())) {
-            // no such field, hence we should simply add it
-            PdfFormField field = createParentFieldCopy(annot.getPdfObject(), documentTo);
-            PdfArray kids = field.getKids();
-            field.getPdfObject().remove(PdfName.Kids);
-            formTo.addField(field, toPage, true);
-            field.getPdfObject().put(PdfName.Kids, kids);
-        } else {
-            // annot is either a field (field name will not be null) or a widget (field name is null)
-            AbstractPdfFormField field = makeFormField(annot.getPdfObject());
-            if (field == null) {
-                return;
-            }
-            PdfString fieldName = field.getFieldName();
-            if (fieldName != null) {
-                PdfFormField existingField = fieldsTo.get(fieldName.toUnicodeString());
-                if (existingField != null) {
-                    PdfFormField mergedField = mergeFieldsWithTheSameName(field);
-                    formTo.getDirectFormFields().put(mergedField.getFieldName().toUnicodeString(), mergedField);
-                } else {
-                    HashSet<String> existingFields = new HashSet<>();
-                    getAllFieldNames(formTo.getFields(), existingFields);
-                    addChildToExistingParent(annot.getPdfObject(), existingFields,
-                            fieldsTo);
-                }
-            } else {
-                if (!parentField.getKids().contains(field.getPdfObject())
-                        && formTo.getFields().contains(parentField.getPdfObject())) {
-                    // annot's parent is already a field of the resultant document,
-                    // hence we only need to update its children
-                    HashSet<String> existingFields = new HashSet<>();
-                    getAllFieldNames(formTo.getFields(), existingFields);
-                    addChildToExistingParent(annot.getPdfObject(), existingFields);
-                } else {
-                    // its parent is not a field of the resultant document, but the latter contains
-                    // a field of the same name, therefore we should merge them (note that merging in this context
-                    // differs from merging a widget and an annotation into a single entity)
-                    PdfFormField mergedField = mergeFieldsWithTheSameName(field);
-                    // we need to add the field not to its representation (#getFormFields()), but to
-                    // /Fields entry of the acro form
-                    formTo.addField(mergedField, toPage, true);
-                }
-            }
-        }
-    }
+        String parentName = parentField.getFieldName().toUnicodeString();
+        PdfFormField existingField = fieldsTo.get(parentName);
+        PdfFormField field = createParentFieldCopy(annot.getPdfObject(), documentTo);
 
-    private PdfFormField mergeFieldsWithTheSameName(AbstractPdfFormField newField) {
-        PdfString fieldName = newField.getPdfObject().getAsString(PdfName.T);
-        
-        PdfDictionary parent = newField.getParent();
-        if (parent != null) {
-            newField.setParent(PdfFormField.makeFormField(parent, newField.getDocument()));
-            if (fieldName == null) {
-                if (newField.isTerminalFormField()) {
-                    fieldName = new PdfString(parent.getAsString(PdfName.T).toUnicodeString() + ".");
-                } else {
-                    fieldName = parent.getAsString(PdfName.T);
-                }
+        if (!collectedFieldObjects.contains(field.getPdfObject())) {
+            if (existingField != null) {
+                logger.warn(MessageFormatUtil.format(IoLogMessageConstant.DOCUMENT_ALREADY_HAS_FIELD, parentName));
             }
-        }
-        
-        String fullFieldName = fieldName.toUnicodeString();
-        if (null != newField.getFieldName()) {
-            fullFieldName = newField.getFieldName().toUnicodeString();
-        }
 
-        logger.warn(MessageFormatUtil.format(IoLogMessageConstant.DOCUMENT_ALREADY_HAS_FIELD, fullFieldName));
-
-        PdfFormField existingField = formTo.getField(fullFieldName);
-        if (existingField.isFlushed() && newField instanceof PdfFormField) {
-            int index = 0;
-            do {
-                index++;
-                ((PdfFormField)newField).setFieldName(fieldName.toUnicodeString() + "_#" + index);
-                fullFieldName = newField.getFieldName().toUnicodeString();
-            } while (formTo.getField(fullFieldName) != null);
-            return (PdfFormField)newField;
+            collectedFieldObjects.add(field.getPdfObject());
         }
-
-        formTo.getFields().remove(existingField.getPdfObject());
-
-        if (newField instanceof PdfFormField) {
-            PdfFormFieldMergeUtil.mergeTwoFieldsWithTheSameNames(existingField, (PdfFormField) newField, true);
-        } else {
-            existingField.addKid(newField);
-        }
-
-        return existingField;
     }
 
     private static PdfFormField getParentField(PdfDictionary parent, PdfDocument pdfDoc) {
@@ -255,92 +202,25 @@ private static PdfFormField getParentField(PdfDictionary parent, PdfDocument pdf
         return PdfFormField.makeFormField(parent, pdfDoc);
     }
 
-    private PdfFormField createParentFieldCopy(PdfDictionary fieldDic, PdfDocument pdfDoc) {
-        PdfDictionary parent = fieldDic.getAsDictionary(PdfName.Parent);
+    private PdfFormField createParentFieldCopy(PdfDictionary fieldDict, PdfDocument pdfDoc) {
+        PdfDictionary parent = fieldDict.getAsDictionary(PdfName.Parent);
         PdfFormField field;
 
         if (parent != null) {
-            field = createParentFieldCopy(parent, pdfDoc);
+            // Here we operate with Kids array to do not run split/merge logic before PdfAcroForm.addField
             PdfArray kids = (PdfArray) parent.get(PdfName.Kids);
             if (kids == null) {
-                parent.put(PdfName.Kids, new PdfArray(fieldDic));
+                parent.put(PdfName.Kids, new PdfArray(fieldDict));
             } else {
-                kids.add(fieldDic);
+                if (!kids.contains(fieldDict)) {
+                    kids.add(fieldDict);
+                }
             }
+            field = createParentFieldCopy(parent, pdfDoc);
         } else {
-            field = PdfFormField.makeFormField(fieldDic, pdfDoc);
+            field = PdfFormField.makeFormField(fieldDict, pdfDoc);
         }
 
         return field;
     }
-
-    private void addChildToExistingParent(PdfDictionary fieldDic, Set<String> existingFields) {
-        PdfDictionary parent = fieldDic.getAsDictionary(PdfName.Parent);
-        if (parent == null) {
-            return;
-        }
-
-        PdfString parentName = parent.getAsString(PdfName.T);
-        if (parentName != null) {
-            String name = parentName.toUnicodeString();
-            if (existingFields.contains(name)) {
-                PdfArray kids = parent.getAsArray(PdfName.Kids);
-                kids.add(fieldDic);
-            } else {
-                parent.put(PdfName.Kids, new PdfArray(fieldDic));
-                addChildToExistingParent(parent, existingFields);
-            }
-        }
-    }
-
-    private void addChildToExistingParent(PdfDictionary fieldDic, Set<String> existingFields,
-                                          Map<String, PdfFormField> fieldsTo) {
-        PdfDictionary parent = fieldDic.getAsDictionary(PdfName.Parent);
-        if (parent == null) {
-            return;
-        }
-
-        PdfString parentName = parent.getAsString(PdfName.T);
-        if (parentName != null) {
-            String name = parentName.toUnicodeString();
-            if (existingFields.contains(name)) {
-                PdfArray kids = parent.getAsArray(PdfName.Kids);
-                for (PdfObject kid : kids) {
-                    if (((PdfDictionary) kid).get(PdfName.T) != null &&
-                            ((PdfDictionary) kid).get(PdfName.T).equals(fieldDic.get(PdfName.T))) {
-                        AbstractPdfFormField kidField = makeFormField(kid);
-                        AbstractPdfFormField field = makeFormField(fieldDic);
-                        if (kidField == null || field == null) {
-                            continue;
-                        }
-                        fieldsTo.put(kidField.getFieldName().toUnicodeString(), (PdfFormField)kidField);
-                        PdfFormField mergedField = mergeFieldsWithTheSameName(field);
-                        formTo.getDirectFormFields().put(mergedField.getFieldName().toUnicodeString(), mergedField);
-                        return;
-                    }
-                }
-                kids.add(fieldDic);
-            } else {
-                parent.put(PdfName.Kids, new PdfArray(fieldDic));
-                addChildToExistingParent(parent, existingFields);
-            }
-        }
-    }
-
-    private void getAllFieldNames(PdfArray fields, Set<String> existingFields) {
-        for (PdfObject field : fields) {
-            if (field.isFlushed()) {
-                continue;
-            }
-            PdfDictionary dic = (PdfDictionary) field;
-            PdfString name = dic.getAsString(PdfName.T);
-            if (name != null) {
-                existingFields.add(name.toUnicodeString());
-            }
-            PdfArray kids = dic.getAsArray(PdfName.Kids);
-            if (kids != null) {
-                getAllFieldNames(kids, existingFields);
-            }
-        }
-    }
 }