getDecodedJson( self::META_KEY_CONDITIONS ); if ( empty( $data ) ) { delete_post_meta( $post_id, Constants::META_PREFIX . self::META_KEY_CONDITIONS ); return; } $sanitized_data = $this->sanitize_tree( $data ); // Only save if there are any groups with conditions left after sanitization if ( ! empty( $sanitized_data['groups'] ) && ! empty( $sanitized_data['groups'][0]['conditions'] ) ) { update_post_meta( $post_id, Constants::META_PREFIX . self::META_KEY_CONDITIONS, wp_slash( wp_json_encode( $sanitized_data ) ) ); } else { delete_post_meta( $post_id, Constants::META_PREFIX . self::META_KEY_CONDITIONS ); } } /** * Recursively sanitizes the condition tree. * * @param array $tree The decoded JSON tree from the user input. * * @return array The sanitized tree. */ private function sanitize_tree( array $tree ): array { $sanitized_tree = []; // Sanitize the outer connector $sanitized_tree['outer_connector'] = ( ( $tree['outer_connector'] ?? 'AND' ) === 'OR' ) ? 'OR' : 'AND'; $sanitized_tree['groups'] = []; if ( isset( $tree['groups'] ) && is_array( $tree['groups'] ) ) { foreach ( $tree['groups'] as $group_node ) { if ( ! is_array( $group_node ) ) { continue; } $sanitized_group = $this->sanitize_group( $group_node, $sanitized_tree['outer_connector'] ); // Only add the group if it contains valid conditions after sanitization if ( ! empty( $sanitized_group['conditions'] ) ) { $sanitized_tree['groups'][] = $sanitized_group; } } } return $sanitized_tree; } /** * Helper function to sanitize a single group node. * * @param array $group The group array. * @param string $outer_connector The sanitized outer connector ('AND' or 'OR'). * * @return array The sanitized group. */ private function sanitize_group( array $group, string $outer_connector ): array { $sanitized_group = []; // The inner connector is always the opposite of the outer one - the UI // only exposes the outer toggle. Stored verbatim so external readers // (REST summary etc.) see a consistent tree. $sanitized_group['inner_connector'] = 'OR' === $outer_connector ? 'AND' : 'OR'; $sanitized_group['conditions'] = []; if ( isset( $group['conditions'] ) && is_array( $group['conditions'] ) ) { foreach ( $group['conditions'] as $condition_node ) { if ( ! is_array( $condition_node ) ) { continue; } $sanitized_condition = $this->sanitize_condition( $condition_node ); // Only add the condition if it's valid and has a value if ( ! empty( $sanitized_condition ) ) { $sanitized_group['conditions'][] = $sanitized_condition; } } } return $sanitized_group; } /** * Helper function to sanitize a single condition leaf node. * * @param array $condition The condition array from user input. * * @return array The sanitized condition, or an empty array if invalid. */ private function sanitize_condition( array $condition ): array { $sanitized_condition = []; $registry = Condition_Registry::get(); $type = $condition['type'] ?? ''; $condition_object = $registry->get_condition( $type ); if ( ! $condition_object ) { return []; } $sanitized_condition['type'] = $type; $sanitized_condition['id'] = sanitize_key( $condition['id'] ?? '' ); $operator = $condition['operator'] ?? ''; if ( ! array_key_exists( $operator, $condition_object->get_supported_operators() ) ) { $operator = array_key_first( $condition_object->get_supported_operators() ); } $sanitized_condition['operator'] = $operator; $raw_value = $condition['value'] ?? null; $sanitized_value = $condition_object->sanitize_value( $raw_value ); // Discard conditions with empty values if ( $sanitized_value === null || $sanitized_value === '' || ( is_array( $sanitized_value ) && empty( $sanitized_value ) ) ) { return []; } $sanitized_condition['value'] = $sanitized_value; return $sanitized_condition; } }