added: item-tracker implementation

src/Component/Akeneo/Client/ApiWriter.php

@@ -89,7 +89,10 @@ private function doWrite(array $data)
                 'API exception',
                 [
                     'message' => $response->getContent(),
-                    'errors' => AkeneoErrorFactory::createErrors($response->getContent())
+                    'errors' => AkeneoErrorFactory::createErrors($response->getContent()),
+                    'identifier' => $data['identifier'] ?? $data['code'] ?? $data['sku'] ?? $data['id'] ?? '',
+                    'identityClass' => $this->endpoint::NAME,
+                    'method' => $this->method,
                 ],
                 $data
             );

src/Component/Common/Pipeline/Exception/InvalidItemException.php

@@ -6,28 +6,48 @@
 
 class InvalidItemException extends \Exception
 {
-    private $invalidItem;
+    private $invalidItemData;
     private ?AkeneoErrors $errors;
     private $item;
+    private mixed $identifier;
+    private ?string $identityClass;
+    private ?string $method;
 
-    public function __construct(string $message = null, array $invalidItem, array $item = [])
+    public function __construct(string $message = null, array $invalidItemData, array $item = [])
     {
-        $this->invalidItem = $invalidItem;
-        $this->errors = $this->invalidItem['errors'] ?? null;
-        unset($this->invalidItem['errors']);
+        $this->invalidItemData = $invalidItemData;
+
+        $this->errors = $this->invalidItemData['errors'] ?? null;
+        $this->identifier = $this->invalidItemData['identifier'] ?? null;
+        $this->identityClass = $this->invalidItemData['identityClass'] ?? null;
+        $this->method = $this->invalidItemData['method'] ?? null;
+        unset($this->invalidItemData['errors']);
+        unset($this->invalidItemData['identifier']);
+        unset($this->invalidItemData['identityClass']);
+        unset($this->invalidItemData['method']);
 
         parent::__construct($message);
         $this->item = $item;
     }
 
+    public function getInvalidIdentifier(): mixed
+    {
+        return $this->identifier;
+    }
+
+    public function getInvalidIdentityClass(): ?string
+    {
+        return $this->identityClass;
+    }
+
     public function getItem(): array
     {
         return $this->item;
     }
 
-    public function getInvalidItem(): array
+    public function getInvalidItemData(): array
     {
-        return $this->invalidItem;
+        return $this->invalidItemData;
     }
 
     public function hasErrors(): bool

src/Component/Common/Pipeline/PipeItemLogger.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Misery\Component\Common\Pipeline;
+
+use Misery\Component\Logger\ItemLoggerInterface;
+use Misery\Component\Writer\ItemWriterInterface;
+
+class PipeItemLogger implements PipeWriterInterface
+{
+    public function __construct(
+        private readonly ItemLoggerInterface $itemLogger,
+        private readonly string            $identityClass,
+        private readonly string            $method
+    ) {}
+
+    public function write(array $data): void
+    {
+        $identifier = $data['identifier'] ?? $data['code'] ?? $data['sku'] ?? $data['id'] ?? '';
+
+        // swith case for HTTP method type
+        switch ($this->method) {
+            case 'POST':
+                $this->itemLogger->logCreate($this->identyClass, $identifier);
+                break;
+            case 'PATCH':
+            case 'MULTI_PATCH':
+                $this->itemLogger->logUpdate($this->identityClass, $identifier);
+                break;
+            case 'DELETE':
+                $this->itemLogger->logRemove($this->identityClass, $identifier);
+                break;
+                break;
+            default:
+                $this->itemLogger->log($this->identityClass, $identifier);
+        }
+    }
+
+    public function stop(): void
+    {
+    }
+}

src/Component/Common/Pipeline/Pipeline.php

@@ -2,6 +2,7 @@
 
 namespace Misery\Component\Common\Pipeline;
 
+use Misery\Component\Logger\ItemLoggerAwareTrait;
 use Psr\Log\LoggerAwareTrait;
 use Misery\Component\Common\Pipeline\Exception\InvalidItemException;
 use Misery\Component\Common\Pipeline\Exception\SkipPipeLineException;
@@ -11,6 +12,7 @@
 class Pipeline
 {
     use LoggerAwareTrait;
+    use ItemLoggerAwareTrait;
 
     /** @var PipeReaderInterface */
     private $in;
@@ -62,13 +64,17 @@ private function handleException(InvalidItemException $exception, int $lineNumbe
     {
         if ($exception->hasErrors()) {
             foreach ($exception->getErrors()->getErrorMessages() as $errorMessage) {
-                $this->logger->warning(sprintf('WARNING: %s', $errorMessage));
+                $this->getItemLogger()->logFailed(
+                    $exception->getInvalidIdentityClass(),
+                    $exception->getInvalidIdentifier(),
+                    $errorMessage
+                );
             }
         }
         $this->invalid->write([
             'line' => $lineNumber,
             'msg' => $exception->getMessage(),
-            'item' => json_encode($exception->getInvalidItem()),
+            'item' => json_encode($exception->getInvalidItemData()),
         ]);
 
         // WE need a silent LOGGER here

src/Component/Common/Pipeline/PipelineFactory.php

@@ -37,10 +37,21 @@ public function createFromConfiguration(
                         $pipeline->output(new PipeWriter(
                             $configurationManager->createBufferWriter($configuration['output']['http']['buffer_file'])
                         ));
+
+                        $pipeline->output(new PipeItemLogger(
+                            $configurationManager->getConfig()->getItemLogger(),
+                            $configuration['output']['http']['endpoint'],
+                            $configuration['output']['http']['method']
+                        ));
                         break;
                     }
 
                     $pipeline->output(new PipeWriter($writer));
+                    $pipeline->output(new PipeItemLogger(
+                        $configurationManager->getConfig()->getItemLogger(),
+                        $configuration['output']['http']['endpoint'],
+                        $configuration['output']['http']['method']
+                    ));
 
                     $pipeline->invalid(
                         new PipeWriter($this->createInvalid($configurationManager, $configuration))

src/Component/Configurator/Configuration.php

@@ -4,6 +4,7 @@
 
 use App\Component\ChangeManager\ChangeManager;
 use Misery\Component\Action\ItemActionProcessorFactory;
+use Misery\Component\Logger\ItemLoggerAwareTrait;
 use Psr\Log\LoggerAwareTrait;
 use Psr\Log\LoggerInterface;
 use Misery\Component\Action\ItemActionProcessor;
@@ -27,6 +28,7 @@
 class Configuration
 {
     use LoggerAwareTrait;
+    use ItemLoggerAwareTrait;
     private $pipeline = null;
     private $actions = null;
     private $groupedActions = null;

src/Component/Configurator/ConfigurationFactory.php

@@ -3,6 +3,8 @@
 namespace Misery\Component\Configurator;
 
 use App\Component\ChangeManager\ChangeManager;
+use Misery\Component\Logger\ItemLoggerInterface;
+use Misery\Component\Logger\NullItemLogger;
 use Psr\Log\LoggerInterface;
 use Misery\Component\Common\FileManager\LocalFileManager;
 use Misery\Component\Common\Pipeline\ActionPipe;
@@ -37,6 +39,7 @@ public function init(
     ) {
         $this->config = new Configuration();
         $this->config->setLogger($logger);
+        $this->config->setItemLogger(new NullItemLogger());
         $sources = ($source) ? $this->getFactory('source')->createFromFileManager($source) : null;
         $this->manager = new ConfigurationManager(
             $this->config,
@@ -49,6 +52,11 @@ public function init(
         );
     }
 
+    public function setItemLogger(ItemLoggerInterface $itemLogger)
+    {
+        $this->config->setItemLogger($itemLogger);
+    }
+
     public function setChangeManager(ChangeManager $changeManager)
     {
         $this->config->changeManager = $changeManager;

src/Component/Logger/AppItemLoggerAdapter.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Misery\Component\Logger;
+
+use App\Component\ItemTracker\ItemTrackerInterface;
+use App\Component\Logger\ItemLogger;
+
+class AppItemLoggerAdapter implements ItemLoggerInterface
+{
+    public function __construct(private readonly ItemTrackerInterface $tracker) {}
+
+    public function logCreate(string $entityClass, string $identifier): void
+    {
+        $this->tracker->trackCreate($entityClass, $identifier);
+    }
+
+    public function logUpdate(string $entityClass, string $identifier, string $updateMessage = ''): void
+    {
+        $this->tracker->trackUpdate($entityClass, $identifier, $updateMessage);
+    }
+
+    public function logRemove(string $entityClass, string $identifier): void
+    {
+        $this->tracker->trackRemove($entityClass, $identifier);
+    }
+
+    public function logFailed(string $entityClass, string $identifier, string $failMessage): void
+    {
+        $this->tracker->trackFailed($entityClass, $identifier, $failMessage);
+    }
+
+    public function logSkipped(string $entityClass, string $identifier, string $failMessage): void
+    {
+        $this->tracker->trackSkipped($entityClass, $identifier, $failMessage);
+    }
+
+    public function log(string $entityClass, string $identifier): void
+    {
+        $this->tracker->track($entityClass, $identifier);
+    }
+}

src/Component/Logger/ItemLoggerAwareTrait.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Misery\Component\Logger;
+
+use Psr\Log\LoggerInterface;
+
+/**
+ * Basic Implementation
+ */
+trait ItemLoggerAwareTrait
+{
+    /**
+     * The logger instance.
+     */
+    protected ItemLoggerInterface $itemLogger;
+
+    public function setItemLogger(ItemLoggerInterface $itemLogger): void
+    {
+        $this->itemLogger = $itemLogger;
+    }
+
+    public function getItemLogger(): ItemLoggerInterface
+    {
+        return $this->itemLogger;
+    }
+}

src/Component/Logger/ItemLoggerInterface.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Misery\Component\Logger;
+
+use App\Component\Akeneo\Api\Objects\ReferencedItemInterface;
+use App\Domain\Common\Model\OperationProgress;
+
+interface ItemLoggerInterface
+{
+// This is App only section
+
+//    public function logCreateItem(ReferencedItemInterface $entity): void;
+//
+//    public function logUpdateItem(ReferencedItemInterface $entity, string $updateMessage = ''): void;
+//
+//    public function logRemoveItem(ReferencedItemInterface $entity): void;
+//
+//    public function logFailedItem(ReferencedItemInterface $entity, string $failMessage): void;
+//
+//    public function logItem(ReferencedItemInterface $entity): void;
+
+    /** @deprecated  */
+    public function logCreate(string $entityClass, string $identifier): void;
+
+    /** @deprecated  */
+    public function logUpdate(string $entityClass, string $identifier, string $updateMessage = ''): void;
+
+    /** @deprecated  */
+    public function logRemove(string $entityClass, string $identifier): void;
+    /** @deprecated  */
+    public function logFailed(string $entityClass, string $identifier, string $failMessage): void;
+
+    /** @deprecated  */
+    public function log(string $entityClass, string $identifier): void;
+}

src/Component/Logger/NullItemLogger.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Misery\Component\Logger;
+
+class NullItemLogger implements ItemLoggerInterface
+{
+    public function logCreate(string $entityClass, string $identifier): void
+    {
+        // Do nothing
+    }
+
+    public function logUpdate(string $entityClass, string $identifier, string $updateMessage = ''): void
+    {
+        // Do nothing
+    }
+
+    public function logRemove(string $entityClass, string $identifier): void
+    {
+        // Do nothing
+    }
+
+    public function logFailed(string $entityClass, string $identifier, string $failMessage): void
+    {
+        // Do nothing
+    }
+
+    public function log(string $entityClass, string $identifier): void
+    {
+        // Do nothing
+    }
+}