Added content fields comparison to ignore updates that would result in no change (#26)

Author: jeremycr

CHANGELOG.md

@@ -1,3 +1,6 @@
+# Version 2.2.0
+* added `NotModifiedContentFilter` and a bunch of `FieldComparator` classes
+
 # version 2.1.0
 * contentWriter return created content
 

README.md

@@ -178,7 +178,7 @@ class MyDataflowType extends AbstractDataflowType
     /**
      * @var ContentStructureFactory
      */
-    private contentStructureFactory;
+    private $contentStructureFactory;
 
     public function __construct(ContentWriter $contentWriter, ContentStructureFactory $contentStructureFactory)
     {
@@ -213,6 +213,83 @@ class MyDataflowType extends AbstractDataflowType
 
 This example uses `ContentStructureFactory` to check if the content exists and returns the adequate `ContentStrucure` to pass to the content writer.
 
+## Use the NotModifiedContentFilter
+
+When updating contents, you might want to ignore contents where the update would not result in any actual changes in fields values. In that case, you can add the `NotModifiedContentFilter` as one of your steps.
+
+```php
+// In your DataflowType
+public function __construct(NotModifiedContentFilter $notModifiedContentFilter)
+{
+    $this->notModifiedContentFilter = $notModifiedContentFilter;
+}
+
+//[...]
+protected function buildDataflow(DataflowBuilder $builder, array $options): void
+{
+    //[...]
+    $builder->addStep($this->notModifiedContentFilter);
+    //[...]
+}
+```
+
+This filter compares each field value in the `ContentUpdateStructure` received to the fields values in the existing content object. If all values are identical, this filter will return `false`, otherwise, the `ContentUpdateStructure` will be returned as is.
+
+Not all field types are supported by this filter. Il a field type is not supported, values will be assumed different. If your dataflow is dealing with content types containing unsupported field types, it is better to simply not use the `NotModifiedContentFilter` to prevent unnecessary overhead. 
+
+### Supported field types
+- ezstring
+- ezauthor
+- ezboolean
+- ezcountry
+- ezdate
+- ezdatetime
+- ezemail
+- ezfloat
+- ezisbn
+- ezobjectrelation
+- ezobjectrelationlist
+- ezkeyword
+- ezselection
+- eztext
+- eztime
+- eztags
+- novaseometas
+- ezurl
+- ezmatrix
+- ezgmaplocation
+- ezrichtext
+
+### Add custom field comparator
+
+If you want to add support for a field type, simply create your own comparator.
+
+```php
+<?php
+
+use CodeRhapsodie\EzDataflowBundle\Core\FieldComparator\AbstractFieldComparator;
+use eZ\Publish\Core\FieldType\Value;
+//[...]
+
+class MyFieldComparator extends AbstractFieldComparator
+{
+    //[...]
+    protected function compareValues(Value $currentValue, Value $newValue): bool
+    {
+        // Return true if values are identical, false if values are different.
+    }
+}
+
+```
+
+```yaml
+# Service declaration
+    App\FieldComparator\MyFieldComparator:
+        parent: 'CodeRhapsodie\EzDataflowBundle\Core\FieldComparator\AbstractFieldComparator'
+        tags:
+            - { name: 'coderhapsodie.ezdataflow.field_comparator', fieldType: 'my_field_type_identifier' }
+```
+
 # Admin UI
 
 ## Access to the eZ Dataflow UI

composer.json

@@ -41,7 +41,8 @@
         }
     },
     "require": {
-        "code-rhapsodie/dataflow-bundle": "^2.0 || dev-master",
+        "php": "^7.1",
+        "code-rhapsodie/dataflow-bundle": "^2.1 || dev-master",
         "ezsystems/ezplatform-admin-ui": "^1.0",
         "ezsystems/ezpublish-kernel": "^7.0"
     },

phpunit.xml

@@ -4,7 +4,7 @@
 <phpunit
         backupGlobals="false"
         backupStaticAttributes="false"
-        bootstrap="Tests/bootstrap.php"
+        bootstrap="tests/bootstrap.php"
         convertErrorsToExceptions="true"
         convertNoticesToExceptions="true"
         convertWarningsToExceptions="true"
@@ -14,16 +14,16 @@
         <ini name="error_reporting" value="-1" />
     </php>
     <testsuites>
-        <testsuite name="Port tests suite">
-            <directory suffix="Test.php">./Tests</directory>
+        <testsuite name="EzDataflow tests suite">
+            <directory suffix="Test.php">./tests</directory>
         </testsuite>
     </testsuites>
 
     <filter>
         <whitelist>
-            <directory>./</directory>
+            <directory>./src/</directory>
             <exclude>
-                <directory>Tests/</directory>
+                <directory>tests/</directory>
                 <directory>vendor/</directory>
             </exclude>
         </whitelist>

src/CodeRhapsodieEzDataflowBundle.php

@@ -5,6 +5,7 @@
 namespace CodeRhapsodie\EzDataflowBundle;
 
 use CodeRhapsodie\EzDataflowBundle\DependencyInjection\CodeRhapsodieEzDataflowExtension;
+use CodeRhapsodie\EzDataflowBundle\DependencyInjection\Compiler\FieldComparatorCompilerPass;
 use CodeRhapsodie\EzDataflowBundle\Security\PolicyProvider;
 use eZ\Bundle\EzPublishCoreBundle\DependencyInjection\EzPublishCoreExtension;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
@@ -23,6 +24,8 @@ public function build(ContainerBuilder $container)
     {
         parent::build($container);
 
+        $container->addCompilerPass(new FieldComparatorCompilerPass());
+
         /** @var EzPublishCoreExtension $eZExtension */
         $eZExtension = $container->getExtension('ezpublish');
         $eZExtension->addPolicyProvider(new PolicyProvider());

src/Core/FieldComparator/AbstractFieldComparator.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CodeRhapsodie\EzDataflowBundle\Core\FieldComparator;
+
+use eZ\Publish\API\Repository\FieldTypeService;
+use eZ\Publish\API\Repository\Values\Content\Field;
+use eZ\Publish\Core\FieldType\Value;
+
+abstract class AbstractFieldComparator implements FieldComparatorInterface
+{
+    /** @var FieldTypeService */
+    private $fieldTypeService;
+
+    public function __construct(FieldTypeService $fieldTypeService)
+    {
+        $this->fieldTypeService = $fieldTypeService;
+    }
+
+    public function compare(Field $field, $hash): bool
+    {
+        $newValue = $this->fieldTypeService->getFieldType($field->fieldTypeIdentifier)->fromHash($hash);
+
+        return $this->compareValues($field->value, $newValue);
+    }
+
+    /**
+     * Returns true if values are equals, false otherwise
+     */
+    abstract protected function compareValues(Value $currentValue, Value $newValue): bool;
+}

src/Core/FieldComparator/DelegatorFieldComparator.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CodeRhapsodie\EzDataflowBundle\Core\FieldComparator;
+
+use eZ\Publish\API\Repository\Values\Content\Field;
+
+class DelegatorFieldComparator implements FieldComparatorInterface
+{
+    /** @var FieldComparatorInterface[] */
+    private $delegates;
+
+    /**
+     * FieldComparator constructor.
+     */
+    public function __construct()
+    {
+        $this->delegates = [];
+    }
+
+    public function compare(Field $field, $hash): bool
+    {
+        if (isset($this->delegates[$field->fieldTypeIdentifier])) {
+            return $this->delegates[$field->fieldTypeIdentifier]->compare($field, $hash);
+        }
+
+        // No comparator to handle this field type, we assume the value is different.
+        return false;
+    }
+
+    public function registerDelegateFieldComparator(FieldComparatorInterface $typedFieldComparator, string $fieldTypeIdentifier): void
+    {
+        $this->delegates[$fieldTypeIdentifier] = $typedFieldComparator;
+    }
+}

src/Core/FieldComparator/FieldComparatorInterface.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CodeRhapsodie\EzDataflowBundle\Core\FieldComparator;
+
+use eZ\Publish\API\Repository\Values\Content\Field;
+
+interface FieldComparatorInterface
+{
+    /**
+     * @return bool true if identical, false otherwise
+     */
+    public function compare(Field $field, $hash): bool;
+}

src/Core/FieldComparator/MapLocationFieldComparator.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CodeRhapsodie\EzDataflowBundle\Core\FieldComparator;
+
+use eZ\Publish\Core\FieldType\Value;
+
+class MapLocationFieldComparator extends AbstractFieldComparator
+{
+    protected function compareValues(Value $currentValue, Value $newValue): bool
+    {
+        return (string) $currentValue === (string) $newValue
+            && (float) $currentValue->longitude === (float) $newValue->longitude
+            && (float) $currentValue->latitude === (float) $newValue->latitude
+        ;
+    }
+}

src/Core/FieldComparator/MatrixFieldComparator.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CodeRhapsodie\EzDataflowBundle\Core\FieldComparator;
+
+use eZ\Publish\Core\FieldType\Value;
+
+class MatrixFieldComparator extends AbstractFieldComparator
+{
+    protected function compareValues(Value $currentValue, Value $newValue): bool
+    {
+        if (count($currentValue->rows) !== count($newValue->rows)) {
+            return false;
+        }
+
+        foreach ($newValue->rows as $index => $row) {
+            if (count($currentValue->rows[$index]->getCells()) !== count($row->getCells())) {
+                return false;
+            }
+
+            if (!empty(array_diff_assoc($currentValue->rows[$index]->getCells(), $row->getCells()))) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}