(PW-3126) Fix BIC branch extraction from DN (#297)

* fix(PW-3126): fix DN to BIC extraction to include branch from ou component

Added parseBranch() to DistinguishedName to extract the branch code from
the ou field of a SWIFT DN string, selecting the rightmost ou when multiple
are present (closest to o=<bic8>).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(PW-3126): use BIC class in parseBIC to produce a valid BIC11 including branch

parseBIC now constructs a BIC object from the extracted BIC8, sets the branch
from the ou component via parseBranch, and returns getBic11(). When no branch
is present XXX is used as default branch code.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(PW-3126): ignore ou components with invalid length when parsing branch from DN

parseBranch now skips ou values that are not exactly 3 characters, gracefully
handling malformed DNs without throwing or returning incorrect branch codes.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: zubri

CHANGELOG.md

@@ -1,5 +1,8 @@
 # Prowide Core - CHANGELOG
 
+#### 10.3.10 - SNAPSHOT
+  * (PW-3126) Fixed DN to BIC extraction in `DistinguishedName` to include the branch code from the `ou` component
+
 #### 10.3.9 - February 2026
   * Deprecated `Field.validatorPattern()` - validation patterns moved to Integrator's `FieldPatternRegistry`
   * Updated MT message structures from schema regeneration (MT081, MT513-MT543, MT586, MT920, MT942) 

src/main/java/com/prowidesoftware/swift/model/DistinguishedName.java

@@ -1,6 +1,7 @@
 package com.prowidesoftware.swift.model;
 
 import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.Strings;
 
 /**
  * Represents a Distinguished Name (DN) in the context of a directory service.
@@ -57,16 +58,69 @@ public String toString() {
         return dn.toString();
     }
 
+    /**
+     * Parses a BIC11 from a SWIFT Distinguished Name string.
+     *
+     * <p>Extracts the institution BIC8 from the {@code o=} component and the branch from the
+     * {@code ou=} component. The result is always an 11-character BIC: if no branch is present
+     * in the DN, {@code XXX} is used as the default branch code.
+     *
+     * <p>When multiple {@code ou} components are present, the one closest to {@code o=&lt;bic8&gt;}
+     * (rightmost) is used as the branch. See {@link #parseBranch(String)} for details.
+     *
+     * @param dn the Distinguished Name string, may be null or blank
+     * @return the BIC11 in uppercase, or null if no BIC8 component is found or the input is blank
+     * @see #parseBranch(String)
+     */
     public static String parseBIC(final String dn) {
         if (StringUtils.isBlank(dn)) {
             return null;
         }
+        String bic8 = null;
+        for (String s : StringUtils.split(dn, ",")) {
+            if (Strings.CS.startsWith(s, "o=") && !Strings.CS.equals(s, "o=swift")) {
+                bic8 = StringUtils.upperCase(StringUtils.substringAfter(s, "o="));
+                break;
+            }
+        }
+        if (bic8 == null) {
+            return null;
+        }
+        BIC bic = new BIC(bic8);
+        String branch = parseBranch(dn);
+        if (branch != null) {
+            bic.setBranch(branch);
+        }
+        return bic.getBic11();
+    }
+
+    /**
+     * Parses the branch code from a SWIFT Distinguished Name string.
+     *
+     * <p>The branch is represented by the {@code ou} component. Only {@code ou} values with exactly
+     * 3 characters are considered valid; others are silently ignored. When multiple valid {@code ou}
+     * components are present, the one closest to {@code o=&lt;bic8&gt;} (i.e. the rightmost) is used,
+     * as DNs are read right-to-left from least to most specific:
+     * <pre>cn=a,ou=dept,ou=bbb,o=biccode,o=swift → branch is "BBB"</pre>
+     *
+     * @param dn the Distinguished Name string, may be null or blank
+     * @return the branch code in uppercase, or null if not present, invalid, or if the input is blank
+     */
+    protected static String parseBranch(final String dn) {
+        if (StringUtils.isBlank(dn)) {
+            return null;
+        }
+        String branch = null;
         for (String s : StringUtils.split(dn, ",")) {
-            if (StringUtils.startsWith(s, "o=") && !StringUtils.equals(s, "o=swift")) {
-                return StringUtils.upperCase(StringUtils.substringAfter(s, "o="));
+            if (Strings.CS.startsWith(s, "ou=")) {
+                String value = StringUtils.substringAfter(s, "ou=");
+                if (value.length() == 3) {
+                    // keep iterating — last valid match is the rightmost (closest to o=<bic8>)
+                    branch = value;
+                }
             }
         }
-        return null;
+        return branch != null ? StringUtils.upperCase(branch) : null;
     }
 
     /**

src/test/java/com/prowidesoftware/swift/model/DistinguishedNameTest.java

@@ -46,15 +46,69 @@ void testParseBIC() {
         assertNull(DistinguishedName.parseBIC(dn1));
 
         dn1 = "o=bic8code,o=swift";
-        assertEquals("BIC8CODE", DistinguishedName.parseBIC(dn1));
+        assertEquals("BIC8CODEXXX", DistinguishedName.parseBIC(dn1));
 
         dn1 = "ou=bar,o=bic8code,o=swift";
-        assertEquals("BIC8CODE", DistinguishedName.parseBIC(dn1));
+        assertEquals("BIC8CODEBAR", DistinguishedName.parseBIC(dn1));
 
         assertNull(DistinguishedName.parseBIC(null));
 
         assertNull(DistinguishedName.parseBIC(""));
 
         assertNull(DistinguishedName.parseBIC("XXX"));
     }
+
+    @Test
+    void testParseBranchSingleOU() {
+        assertEquals("XXX", DistinguishedName.parseBranch("ou=xxx,o=biccode,o=swift"));
+    }
+
+    @Test
+    void testParseBranchUppercasesResult() {
+        assertEquals("XXX", DistinguishedName.parseBranch("ou=XXX,o=biccode,o=swift"));
+    }
+
+    @Test
+    void testParseBranchWithCN() {
+        assertEquals("XXX", DistinguishedName.parseBranch("cn=a,ou=xxx,o=biccode,o=swift"));
+    }
+
+    @Test
+    void testParseBranchMultipleOU() {
+        // rightmost ou (closest to o=<bic8>) is the branch; leftmost is a subdivision
+        assertEquals("BBB", DistinguishedName.parseBranch("cn=a,ou=dept,ou=bbb,o=biccode,o=swift"));
+    }
+
+    @Test
+    void testParseBranchNoOU() {
+        assertNull(DistinguishedName.parseBranch("o=biccode,o=swift"));
+    }
+
+    @Test
+    void testParseBranchNull() {
+        assertNull(DistinguishedName.parseBranch(null));
+    }
+
+    @Test
+    void testParseBranchBlank() {
+        assertNull(DistinguishedName.parseBranch(""));
+        assertNull(DistinguishedName.parseBranch("   "));
+    }
+
+    @Test
+    void testParseBranchNoMatch() {
+        assertNull(DistinguishedName.parseBranch("o=biccode,o=swift"));
+    }
+
+    @Test
+    void testParseBranchIgnoresInvalidOULength() {
+        // ou values with length != 3 must be ignored
+        assertNull(DistinguishedName.parseBranch("ou=toolong,o=biccode,o=swift"));
+        assertNull(DistinguishedName.parseBranch("ou=ab,o=biccode,o=swift"));
+        assertNull(DistinguishedName.parseBranch("ou=x,o=biccode,o=swift"));
+        // valid ou present alongside invalid ones — valid one wins
+        assertEquals("XXX", DistinguishedName.parseBranch("ou=toolong,ou=xxx,o=biccode,o=swift"));
+        // multiple invalid ou, no valid one
+        assertNull(DistinguishedName.parseBranch("ou=ab,ou=toolong,o=biccode,o=swift"));
+    }
 }