fix: Validate required property for block editor fields (dotCMS#33937)

## Summary

Fixes validation for required block editor fields in the old content
edit screen. The required property was not being enforced, allowing
users to save content with empty required block editor fields.

**Changes:**
- Updated `ESContentletAPIImpl.java` to properly validate block editor
fields marked as required
- Ensures validation errors are raised when required block editor fields
are left empty

**Closes:** dotCMS#33906




https://github.com/user-attachments/assets/1f6b6426-9793-412a-9464-3bdc35c50fab

Author: zJaaal

dotCMS/src/main/java/com/dotcms/content/elasticsearch/business/ESContentletAPIImpl.java

@@ -56,6 +56,8 @@
 import com.dotcms.rendering.velocity.services.ContentletLoader;
 import com.dotcms.rendering.velocity.services.PageLoader;
 import com.dotcms.rest.AnonymousAccess;
+import com.dotcms.contenttype.util.StoryBlockUtil;
+import com.dotcms.util.JsonUtil;
 import com.dotcms.rest.api.v1.temp.DotTempFile;
 import com.dotcms.rest.api.v1.temp.TempFileAPI;
 import com.dotcms.storage.FileMetadataAPI;
@@ -66,7 +68,6 @@
 import com.dotcms.util.ConversionUtils;
 import com.dotcms.util.DotPreconditions;
 import com.dotcms.util.FunctionUtils;
-import com.dotcms.util.JsonUtil;
 import com.dotcms.util.ThreadContextUtil;
 import com.dotcms.util.xstream.XStreamHandler;
 import com.dotcms.variant.VariantAPI;
@@ -7549,7 +7550,7 @@ public static void parseDate(final Contentlet contentlet,
                                     field.getVelocityVarName());
                 }
             } else {
-                
+
                 contentlet.setDateProperty(field.getVelocityVarName(), null);
             }
         } else if (field.isRequired() && value == null) {
@@ -7738,6 +7739,40 @@ public void validateContentlet(final Contentlet contentlet, final List<Category>
                         Logger.warn(this, String.format("String Field [%s] is required", field.getVelocityVarName()));
                         continue;
                     }
+                } else if (field.getFieldType().equals(Field.FieldType.STORY_BLOCK_FIELD.toString())) {
+                    // Story Block validation - handle both JSON and legacy WYSIWYG content during migration
+                    if (fieldValue == null) {
+                        cveBuilder.addRequiredField(field, "null");
+                        hasError = true;
+                        Logger.warn(this, String.format("Story Block Field [%s] is required", field.getVelocityVarName()));
+                        continue;
+                    } else if (!(fieldValue instanceof String)) {
+                        cveBuilder.addBadTypeField(field, fieldValue != null ? fieldValue.toString() : "null");
+                        hasError = true;
+                        Logger.warn(this, String.format("Story Block Field [%s] must be a String, but got: %s",
+                            field.getVelocityVarName(), fieldValue.getClass().getSimpleName()));
+                        continue;
+                    } else {
+                        String stringValue = (String) fieldValue;
+                        if (JsonUtil.isValidJSON(stringValue)) {
+                            // Valid JSON - validate as Story Block
+                            if (StoryBlockUtil.isEmptyStoryBlock(stringValue)) {
+                                cveBuilder.addRequiredField(field, fieldValue.toString());
+                                hasError = true;
+                                Logger.warn(this, String.format("Story Block Field [%s] is required", field.getVelocityVarName()));
+                                continue;
+                            }
+                        } else {
+                            // Legacy WYSIWYG content (including malformed JSON) - use simple string validation for backward compatibility
+                            if (stringValue.trim().isEmpty()) {
+                                cveBuilder.addRequiredField(field, fieldValue.toString());
+                                hasError = true;
+                                Logger.warn(this, String.format("Story Block Field [%s] is required", field.getVelocityVarName()));
+                                continue;
+                            }
+                            // Otherwise, let legacy WYSIWYG content (including malformed JSON) pass validation during migration
+                        }
+                    }
                 } else if (fieldValue instanceof String) {
                     String s1 = (String) fieldValue;
                     if (!UtilMethods.isSet(s1.trim())
@@ -8105,7 +8140,7 @@ private void validateBinary(final File binary, final String fieldName, final Fie
                                                     UtilMethods.prettyByteify(maxLength))))
                                     .addBadTypeField(legacyField, String.valueOf(fileLength))
                                     .build();
-                            Logger.warn(this, String.format("Name of Binary field [%s] has a length: %d but the max length is: %d", 
+                            Logger.warn(this, String.format("Name of Binary field [%s] has a length: %d but the max length is: %d",
                                     fieldName, fileLength, maxLength));
                             throw cve;
                         }
@@ -8323,6 +8358,7 @@ private void validateSite(Contentlet contentlet) {
     }
 
 
+
     @CloseDBIfOpened
     @Override
     public void validateContentletNoRels(final Contentlet contentlet,
@@ -8383,6 +8419,7 @@ public void validateContentlet(final Contentlet contentlet,
         validateContentlet(contentlet,contentRelationships, cats, false );
     }
 
+
     @CloseDBIfOpened
     @Override
     public void validateContentlet(final Contentlet contentlet,
@@ -8480,7 +8517,7 @@ private void validateRelationships(final Contentlet contentlet,
 
                 if (!foundInRelationships && !hasExistingRelatedContent) {
                     hasError = true;
-                    Logger.error(this, String.format("Required %s relationship [%s] is not present for contentlet [%s]", 
+                    Logger.error(this, String.format("Required %s relationship [%s] is not present for contentlet [%s]",
                             (checkParent ? "child" : "parent"), rel.getRelationTypeValue(), contentletId));
                     builder.addRequiredRelationship(rel, new ArrayList<>());
                 }
@@ -8526,7 +8563,7 @@ private void validateRelationships(final Contentlet contentlet,
                         && isRelationshipParent) {
                     if (relationship.isChildRequired() && contentsInRelationship.isEmpty()) {
                         hasError = true;
-                        Logger.error(this, String.format("Error in Contentlet [%s]: Child relationship [%s] is required.", 
+                        Logger.error(this, String.format("Error in Contentlet [%s]: Child relationship [%s] is required.",
                                 contentletId, relationship.getRelationTypeValue()));
                         builder.addRequiredRelationship(relationship, contentsInRelationship);
                     }
@@ -8564,14 +8601,14 @@ private void validateRelationships(final Contentlet contentlet,
                                         contentsInRelationship);
                             }
                         } catch (final DotDataException e) {
-                            Logger.error(this, String.format("An error occurred when retrieving information from related Contentlet [%s]", 
+                            Logger.error(this, String.format("An error occurred when retrieving information from related Contentlet [%s]",
                                     contentInRelationship.getIdentifier()), e);
                         }
                     }
                 } else if (APILocator.getRelationshipAPI().isChild(relationship, contentType)) {
                     if (relationship.isParentRequired() && contentsInRelationship.isEmpty()) {
                         hasError = true;
-                        Logger.error(this, String.format("Error in Contentlet [%s]: Parent relationship [%s] is required.", 
+                        Logger.error(this, String.format("Error in Contentlet [%s]: Parent relationship [%s] is required.",
                                 contentletId, relationship.getRelationTypeValue()));
                         builder.addRequiredRelationship(relationship, contentsInRelationship);
                     }
@@ -8587,7 +8624,7 @@ private void validateRelationships(final Contentlet contentlet,
                         final String parentIds = contentsInRelationship.stream()
                                 .map(Contentlet::getIdentifier)
                                 .collect(java.util.stream.Collectors.joining(", "));
-                        final String errorMessage = String.format("ERROR! Child content [%s] is already related to another parent content [%s]", 
+                        final String errorMessage = String.format("ERROR! Child content [%s] is already related to another parent content [%s]",
                                 contentletId, parentIds);
                         Logger.error(this, errorMessage);
                         hasError = true;
@@ -8605,14 +8642,14 @@ private void validateRelationships(final Contentlet contentlet,
                                 && !contentInRelationship.getContentTypeId().equalsIgnoreCase(
                                 relationship.getParentStructureInode())) {
                             hasError = true;
-                            Logger.error(this, String.format("Content Type of Contentlet [%s] does not match the Content Type in relationship [%s]", 
+                            Logger.error(this, String.format("Content Type of Contentlet [%s] does not match the Content Type in relationship [%s]",
                                     contentletId, relationship.getRelationTypeValue()));
                             builder.addInvalidContentRelationship(relationship, contentsInRelationship);
                         }
                     }
                 } else {
                     hasError = true;
-                    Logger.error(this, String.format("Relationship [%s] is neither parent nor child of Contentlet [%s]", 
+                    Logger.error(this, String.format("Relationship [%s] is neither parent nor child of Contentlet [%s]",
                             relationship.getRelationTypeValue(), contentletId));
                     builder.addBadRelationship(relationship, contentsInRelationship);
                 }
@@ -8637,7 +8674,7 @@ private boolean isValidOneToOneRelationship(final Contentlet contentlet,
         List<Contentlet> contentsInRelationshipSameLanguage = groupContentletsByLanguage(contentsInRelationship);
         //Trying to relate more than one piece of content
         if (contentsInRelationshipSameLanguage.size() > 1) {
-            Logger.error(this, String.format("Error in Contentlet [%s]: Relationship [%s] has been defined as One to One", 
+            Logger.error(this, String.format("Error in Contentlet [%s]: Relationship [%s] has been defined as One to One",
                     contentlet.getIdentifier(), relationship.getRelationTypeValue()));
             builder.addBadCardinalityRelationship(relationship, contentsInRelationship);
             return false;
@@ -8651,13 +8688,13 @@ private boolean isValidOneToOneRelationship(final Contentlet contentlet,
                             .getSystemUser(), true, 1, 0, null);
             if (relatedContents.size() > 0 && !relatedContents.get(0).getIdentifier()
                     .equals(contentlet.getIdentifier())) {
-                Logger.error(this, String.format("Error in related Contentlet [%s]: Relationship [%s] has been defined as One to One", 
+                Logger.error(this, String.format("Error in related Contentlet [%s]: Relationship [%s] has been defined as One to One",
                         relatedContents.get(0).getIdentifier(), relationship.getRelationTypeValue()));
                 builder.addBadCardinalityRelationship(relationship, contentsInRelationship);
                 return false;
             }
         } catch (final DotDataException e) {
-            Logger.error(this, String.format("An error occurred when retrieving information from related Contentlet [%s]", 
+            Logger.error(this, String.format("An error occurred when retrieving information from related Contentlet [%s]",
                     contentsInRelationship.get(0).getIdentifier()), e);
             builder.addInvalidContentRelationship(relationship, contentsInRelationship);
             return false;

dotCMS/src/main/java/com/dotcms/contenttype/util/StoryBlockUtil.java

@@ -0,0 +1,115 @@
+package com.dotcms.contenttype.util;
+
+import com.dotcms.util.JsonUtil;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.dotmarketing.util.Logger;
+import com.dotmarketing.util.UtilMethods;
+
+/**
+ * Utility class for Story Block field validation and processing.
+ * Contains domain-specific business logic for determining whether a Story Block
+ * field contains meaningful content or is effectively empty.
+ *
+ * @author dotCMS Team
+ */
+public class StoryBlockUtil {
+
+    /**
+     * Validates if a Story Block field contains meaningful content or is effectively empty.
+     * A Story Block is considered empty if it only contains empty text blocks (paragraphs, headings, code blocks)
+     * without actual text content. Non-text blocks (images, videos, lists, tables, etc.) are always
+     * considered as having content.
+     *
+     * @param storyBlockValue The JSON string representing the Story Block content
+     * @return true if the Story Block is effectively empty, false if it has meaningful content
+     */
+    public static boolean isEmptyStoryBlock(final String storyBlockValue) {
+        if (!UtilMethods.isSet(storyBlockValue) || storyBlockValue.trim().isEmpty()) {
+            return true;
+        }
+
+        try {
+            final JsonNode storyBlockJson = JsonUtil.JSON_MAPPER.readTree(storyBlockValue);
+
+            // Check if it has content array
+            if (!storyBlockJson.has("content")) {
+                return true;
+            }
+
+            final JsonNode contentNode = storyBlockJson.get("content");
+            if (!contentNode.isArray() || contentNode.size() == 0) {
+                return true;
+            }
+
+            // If any block has content, the story block has content
+            for (JsonNode block : contentNode) {
+                if (!isEmptyBlock(block)) {
+                    return false; // Found content, story block is not empty
+                }
+            }
+
+            // All blocks are empty, so story block is empty
+            return true;
+
+        } catch (Exception e) {
+            Logger.warn(StoryBlockUtil.class, "Error parsing Story Block JSON, treating as empty due to malformation: " + e.getMessage());
+            return true; // Malformed JSON = empty = validation fails
+        }
+    }
+
+    /**
+     * Helper method to determine if a specific block within a Story Block is empty.
+     * Simple logic: If it's a text block, check if it has actual text content.
+     * For everything else (images, videos, custom blocks, etc.), assume it has content.
+     *
+     * @param block The JSON node representing a single block
+     * @return true if the block is effectively empty, false otherwise
+     */
+    public static boolean isEmptyBlock(final JsonNode block) {
+        if (!block.has("type")) {
+            return true; // No type means invalid/empty block
+        }
+
+        final String blockType = block.get("type").asText();
+
+        // For text-based blocks, check if they contain actual text content
+        if ("paragraph".equals(blockType) || "heading".equals(blockType) || "codeBlock".equals(blockType)) {
+            return isTextContentEmpty(block);
+        }
+
+        // For everything else (images, videos, lists, tables, blockquotes, custom blocks, etc.):
+        // If the block exists, it represents content,
+        // This is to avoid recursive checking of blocks that are not text-based like lists on tables or similar.
+        return false;
+    }
+
+    /**
+     * Helper method to check if a text block contains only empty text
+     * @param block The block to check for text content
+     * @return true if all text content is empty, false otherwise
+     */
+    public static boolean isTextContentEmpty(final JsonNode block) {
+        final JsonNode contentNode = block.get("content");
+        if (contentNode == null || !contentNode.isArray() || contentNode.size() == 0) {
+            return true; // No content property means empty
+        }
+
+        // Check if all content items are empty text nodes
+        for (JsonNode contentItem : contentNode) {
+            if (contentItem != null) {
+                final String itemType = contentItem.has("type") ? contentItem.get("type").asText() : "";
+
+                if ("text".equals(itemType)) {
+                    final String text = contentItem.has("text") ? contentItem.get("text").asText() : "";
+                    if (UtilMethods.isSet(text.trim())) {
+                        return false; // Found non-empty text
+                    }
+                }
+                // Note: We only consider "text" nodes for text content
+                // Other types like "hardBreak" might exist but don't contain text
+            }
+        }
+
+        return true; // All text content is empty
+    }
+}

dotcms-integration/src/test/java/com/dotcms/MainSuite3a.java

@@ -1,6 +1,8 @@
 package com.dotcms;
 
 import com.dotcms.ai.api.OpenAIVisionAPIImplTest;
+import com.dotcms.contenttype.business.StoryBlockValidationTest;
+import com.dotcms.contenttype.test.StoryBlockUtilTest;
 import com.dotcms.jitsu.validators.AnalyticsValidatorUtilTest;
 import com.dotcms.junit.MainBaseSuite;
 import com.dotcms.rest.api.v1.drive.ContentDriveHelperContentletAPIComparisonTest;
@@ -51,7 +53,9 @@
         OpenAIVisionAPIImplTest.class,
         ContentDriveHelperContentletAPIComparisonTest.class,
         AppsAPIImplTest.class,
-        Task251103AddStylePropertiesColumnInMultiTreeTest.class
+        Task251103AddStylePropertiesColumnInMultiTreeTest.class,
+        StoryBlockValidationTest.class,
+        StoryBlockUtilTest.class
 })
 
 public class MainSuite3a {