Commit 24410a22 authored by Bertrand Gauthier's avatar Bertrand Gauthier
Browse files

to be tested...

parent 16d91302
Loading
Loading
Loading
Loading
+42 −153
Changes for module/Import/src/Import/Service/DbService.php: 42 added lines, 153 removed lines.
Original line number Diff line number Diff line
@@ -44,6 +44,25 @@ class DbService
     */
    private $tableName;

    /**
     * @var SQLGenerator
     */
    private $sqlGenerator;

    /**
     * @var JSONExtractor
     */
    private $jsonExtractor;

    /**
     * DbService constructor.
     */
    public function __construct()
    {
        $this->sqlGenerator = new SQLGenerator();
        $this->jsonExtractor = new JSONExtractor();
    }

    /**
     * @param Etablissement $etablissement
     * @return self
@@ -52,6 +71,8 @@ class DbService
    {
        $this->etablissement = $etablissement;

        $this->jsonExtractor->setEtablissement($etablissement);

        return $this;
    }

@@ -79,6 +100,8 @@ class DbService
    {
        $this->loadEntityClassMetadata();

        $tableColumns = $this->entityClassMetadata->columnNames;

        /** Etablissement de la transaction Oracle */
        $connection = $this->entityManager->getConnection();
        $connection->beginTransaction();
@@ -86,7 +109,8 @@ class DbService
        /** Construction des requêtes SQL **/
        $queries = [];
        foreach ($jsonEntities as $jsonEntity) {
            $queries[] = $this->generateSQLQueryForSavingData($jsonEntity);
            $columnsValues = $this->generateValueArray($jsonEntity);
            $queries[] = $this->sqlGenerator->generateSQLQueryForSavingData($this->tableName, $tableColumns, $columnsValues);
        }

        /** Execution des requetes SQL par groupes de N */
@@ -94,7 +118,7 @@ class DbService
        $queriesChunks = array_chunk($queries, self::INSERT_QUERIES_CHUNK_SIZE);
        foreach ($queriesChunks as $queryChunk) {
            $this->logger->debug(sprintf("Execution de %s requête(s).", count($queryChunk)));
            $sql = $this->wrapSQLQueriesInBeginEnd($queryChunk);
            $sql = $this->sqlGenerator->wrapSQLQueriesInBeginEnd($queryChunk);
            try {
                $connection->executeQuery($sql);
            } catch (DBALException $e) {
@@ -118,7 +142,10 @@ class DbService
    {
        $this->loadEntityClassMetadata();

        $query = $this->generateSQLQueryForClearingExistingData($filters);
        $filters = $this->prepareFiltersForTableUpdate($filters);
        $filters['etablissement_id'] = $this->etablissement->getStructure()->getCode();

        $query = $this->sqlGenerator->generateSQLQueryForClearingExistingData($this->tableName, $filters);

        $connection = $this->entityManager->getConnection();
        try {
@@ -165,7 +192,9 @@ class DbService
        $this->entityClassMetadata = $this->entityManager->getClassMetadata($entityClass);
        $this->tableName = $this->entityClassMetadata->table['name'];

        $this->logMetadata($this->serviceName);
        $this->sqlGenerator->setDatabasePlatform($this->entityManager->getConnection()->getDatabasePlatform());

        $this->logMetadata();
    }

    /**
@@ -236,69 +265,11 @@ class DbService
        return $entityClass;
    }

    /**
     * Génère la requête SQL de suppression de tout ou partie des données déjà importées de l'établissement courant.
     *
     * @param array $filters
     * @return string
     */
    private function generateSQLQueryForClearingExistingData(array $filters = [])
    {
        $codeStructureEtablissement = $this->etablissement->getStructure()->getCode();

        $query = sprintf("DELETE FROM %s WHERE ETABLISSEMENT_ID = '%s'", $this->tableName, $codeStructureEtablissement);

        $filters = $this->prepareFiltersForTmpTableUpdate($filters);

        if (count($filters) > 0) {
            $wheres = $filters;
            // NB: préfixage par le code établissement doit être fait en amont
            array_walk($wheres, function (&$v, $k) {
                $v = strtoupper($k) . " = '$v'";
            });
            $wheres = implode(' AND ', $wheres);
            $query .= ' AND ' . $wheres;
        }

        return $query;
    }

    /**
     * Génère les requêtes SQL de persistence d'une donnée importée de l'établissement courant.
     *
     * @param stdClass $jsonEntity
     * @return string[]
     */
    private function generateSQLQueryForSavingData(stdClass $jsonEntity)
    {
        $tableColumns = $this->entityClassMetadata->columnNames;
        $forceCodeEtablissement = null;

        return sprintf("INSERT INTO %s (%s) VALUES (%s)",
            $this->tableName,
            implode(", ", $tableColumns),
            implode(", ", $this->generateValueArray($jsonEntity))
        );
    }

    /**
     * @param array $queries
     * @return string
     */
    private function wrapSQLQueriesInBeginEnd(array $queries)
    {
        $indent = '  ';

        $sql = $indent . implode(';' . PHP_EOL . $indent, $queries) . ';';

        return implode(PHP_EOL, ['BEGIN', $sql, 'END;']);
    }

    /**
     * @param array $filters
     * @return array
     */
    private function prepareFiltersForTmpTableUpdate(array $filters)
    private function prepareFiltersForTableUpdate(array $filters)
    {
        if (empty($filters)) {
            return $filters;
@@ -326,118 +297,36 @@ class DbService
    }

    /**
     * Mise sous forme de table des données appartenant à une entité
     * Mise sous forme de liste de valeurs des attributs d'une entité JSON, dans l'ordre des colonnes de la table.
     *
     * @param stdClass $jsonEntity : le json associé à une entité
     * @return array les données mises sous forme d'un tableau
     */
    private function generateValueArray(stdClass $jsonEntity)
    {
        $codeEtablissement = $this->etablissement->getStructure()->getCode();
        $f = new EtablissementPrefixFilter();
        $valuesArray = [];

        foreach ($this->entityClassMetadata->columnNames as $property => $colonne) {
            $prefix = null;
            $value = null;
            switch ($property) {
                case "etablissementId": // UCN, URN, ULHN ou INSA, sans préfixage
                    $value = $codeEtablissement;
                    break;
                case "sourceCode":
                    $prefix = $codeEtablissement;
                    $value = $jsonEntity->id;
                    break;
                case "sourceId":
                case "individuId":
                case "roleId":
                case "theseId":
                case "doctorantId":
                case "structureId":
                case "ecoleDoctId":
                case "uniteRechId":
                case "acteurEtablissementId":
                    $prefix = $codeEtablissement;
                    $value = isset($jsonEntity->{$property}) ? $jsonEntity->{$property} : null;
                    break;
                case "origineFinancementId":
                    $prefix = Etablissement::CODE_STRUCTURE_COMUE; // particularité!
                    $value = isset($jsonEntity->{$property}) ? $jsonEntity->{$property} : null;
                    break;
                default:
                    $value = isset($jsonEntity->{$property}) ? $jsonEntity->{$property} : null;
                    break;
            }

            // préfixage éventuel
            if ($value !== null && $prefix !== null) {
                $value = $f->addPrefixTo($value, $prefix);
            }

            $valuesArray[] = $this->prepValueForProperty($value, $property);
        }

        return $valuesArray;
    }

    /**
     * Fonction de mise en forme d'une valeur selon les metatadata de la propriété spécifiée.
     *
     * @param mixed  $value    La valeur à formater
     * @param string $property La propriété concernée
     * @return string La donnée formatée
     *
     * RMQ si un format n'est pas prévu par le traitement la valeur est retournée sans traitement et un message est
     * affiché
     */
    private function prepValueForProperty($value, $property)
    {
        foreach ($this->entityClassMetadata->columnNames as $property => $columnName) {
            $value = $this->jsonExtractor ->extractPropertyValue($property, $jsonEntity);
            $type = $this->entityClassMetadata->fieldMappings[$property]["type"];

        $nvalue = null;
        switch ($type) {
            case "string":
                $nvalue = $this->prepString($value);
                break;
            case "date":
                $nvalue = $this->prepDate($value);
                break;
            default:
                $nvalue = $value;
                break;
        }

        return $nvalue;
    }

    private function prepString($value)
    {
        return "'" . str_replace("'", "''", $value) . "'";
    }

    private function prepDate($value)
    {
        if ($value === null) {
            return "null";
            $valuesArray[] = $this->sqlGenerator->formatValueForPropertyType($value, $type);
        }
        $date = explode(' ', $value->{'date'})[0];

        return "to_date('" . $date . "','YYYY-MM-DD')";
        return $valuesArray;
    }

    /**
     * Ajoute aux logs les metadonnées associées à une entity
     *
     * @param string $dataName    : le nom de l'entité
     * Log les metadonnées associées au service courant.
     */
    private function logMetadata($dataName)
    private function logMetadata()
    {
        $entityClass = $this->entityClassMetadata->name;
        $tableName = $this->entityClassMetadata->table['name'];
        $tableColumns = $this->entityClassMetadata->columnNames;

        $str = <<<EOS
La table associée à l'entité [$dataName][$entityClass] est [$tableName]"
La table associée à l'entité [$this->serviceName][$entityClass] est [$tableName]"
Relation dans propriétés/colonnes: 
EOS;
        foreach ($tableColumns as $propriete => $colonne) {
+76 −0
Changes for module/Import/src/Import/Service/JSONExtractor.php: 76 added lines, 0 removed lines.
Original line number Diff line number Diff line
<?php

namespace Import\Service;

use Application\Entity\Db\Etablissement;
use Application\Filter\EtablissementPrefixFilter;
use stdClass;

class JSONExtractor
{
    /**
     * @var Etablissement
     */
    private $etablissement;

    /**
     * @param Etablissement $etablissement
     * @return self
     */
    public function setEtablissement(Etablissement $etablissement)
    {
        $this->etablissement = $etablissement;

        return $this;
    }

    /**
     * @param string $propertyName
     * @param stdClass $jsonEntity
     * @return string|null
     */
    public function extractPropertyValue($propertyName, stdClass $jsonEntity)
    {
        $codeEtablissement = $this->etablissement->getStructure()->getCode();

        $prefix = null;
        $value = null;

        switch ($propertyName) {
            case 'etablissementId': // UCN, URN, ULHN ou INSA, sans préfixage
                $value = $codeEtablissement;
                break;
            case 'sourceCode':
                $prefix = $codeEtablissement;
                $value = $jsonEntity->id;
                break;
            case 'sourceId':
            case 'individuId':
            case 'roleId':
            case 'theseId':
            case 'doctorantId':
            case 'structureId':
            case 'ecoleDoctId':
            case 'uniteRechId':
            case 'acteurEtablissementId':
                $prefix = $codeEtablissement;
                $value = isset($jsonEntity->{$propertyName}) ? $jsonEntity->{$propertyName} : null;
                break;
            case 'origineFinancementId':
                $prefix = Etablissement::CODE_STRUCTURE_COMUE; // particularité!
                $value = isset($jsonEntity->{$propertyName}) ? $jsonEntity->{$propertyName} : null;
                break;
            default:
                $value = isset($jsonEntity->{$propertyName}) ? $jsonEntity->{$propertyName} : null;
                break;
        }

        // préfixage éventuel
        $f = new EtablissementPrefixFilter();
        if ($value !== null && $prefix !== null) {
            $value = $f->addPrefixTo($value, $prefix);
        }

        return $value;
    }
}
 No newline at end of file
+116 −0
Changes for module/Import/src/Import/Service/SQLGenerator.php: 116 added lines, 0 removed lines.
Original line number Diff line number Diff line
<?php

namespace Import\Service;

use Doctrine\DBAL\Platforms\AbstractPlatform;

class SQLGenerator
{
    /**
     * @var AbstractPlatform
     */
    private $databasePlatform;

    /**
     * @param AbstractPlatform $databasePlatform
     * @return self
     */
    public function setDatabasePlatform($databasePlatform)
    {
        $this->databasePlatform = $databasePlatform;

        return $this;
    }

    /**
     * Génère la requête SQL de suppression de tout ou partie des données déjà importées.
     *
     * @param string $tableName
     * @param array $filters
     * @return string
     */
    public function generateSQLQueryForClearingExistingData($tableName, array $filters = [])
    {
        $query = "DELETE FROM " . $tableName;

        if (count($filters) > 0) {
            $wheres = $filters;
            // NB: préfixage par le code établissement doit être fait en amont
            array_walk($wheres, function (&$v, $k) {
                $v = strtoupper($k) . " = '$v'";
            });
            $wheres = implode(' AND ', $wheres);
            $query .= ' WHERE ' . $wheres;
        }

        return $query;
    }

    /**
     * Génère les requêtes SQL de persistence d'une donnée importée.
     *
     * @param string $tableName
     * @param array $tableColumns
     * @param array $columnsValues
     * @return string
     */
    public function generateSQLQueryForSavingData($tableName, array $tableColumns, array $columnsValues)
    {
        return sprintf("INSERT INTO %s (%s) VALUES (%s)",
            $tableName,
            implode(", ", $tableColumns),
            implode(", ", $columnsValues)
        );
    }

    /**
     * @param array $queries
     * @return string
     */
    public function wrapSQLQueriesInBeginEnd(array $queries)
    {
        $indent = '  ';

        $sql = $indent . implode(';' . PHP_EOL . $indent, $queries) . ';';

        return implode(PHP_EOL, ['BEGIN', $sql, 'END;']);
    }

    /**
     * Fonction de mise en forme d'une valeur selon les metatadata de la propriété spécifiée.
     *
     * @param mixed $value La valeur à formater
     * @param string $type
     * @return string La donnée formatée
     *
     * RMQ si un format n'est pas prévu par le traitement la valeur est retournée sans traitement et un message est
     * affiché
     */
    public function formatValueForPropertyType($value, $type)
    {
        switch ($type) {
            case 'string':
                return $this->prepareString($value);
            case 'date':
                return $this->prepareDate($value);
            default:
                return $value;
        }
    }

    private function prepareString($value)
    {
        return "'" . $this->databasePlatform->quoteStringLiteral($value) . "'";
    }

    private function prepareDate($value)
    {
        if ($value === null) {
            return "NULL";
        }

        $yyymmdd = explode(' ', $value->date)[0];

        return "TO_DATE('$yyymmdd', 'YYYY-MM-DD')";
    }
}
+24 −3
Changes for module/Import/tests/Import/Service/DbServiceTest.php: 24 added lines, 3 removed lines.
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ use Doctrine\DBAL\Connection;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Mapping\ClassMetadata;
use Import\Service\DbService;
use Import\Service\SQLGenerator;
use Zend\Log\LoggerInterface;

class DbServiceTest extends \PHPUnit_Framework_TestCase
@@ -30,6 +31,11 @@ class DbServiceTest extends \PHPUnit_Framework_TestCase
     */
    private $connection;

    /**
     * @var SQLGenerator|\PHPUnit_Framework_MockObject_MockObject
     */
    private $sqlGenerator;

    protected function setUp()
    {
        $this->entityClassMetadata = $this->createMock(ClassMetadata::class);
@@ -37,8 +43,8 @@ class DbServiceTest extends \PHPUnit_Framework_TestCase
        $this->entityClassMetadata->table = ['name' => 'TABLE'];
        $this->entityClassMetadata->columnNames = ['one'=>'ONE', 'two'=>'TWO'];
        $this->entityClassMetadata->fieldMappings = [
            'one' => ["type" => 'string'],
            'two' => ["type" => 'string'],
            'one' => ['type' => 'string'],
            'two' => ['type' => 'string'],
        ];

        $this->connection = $this->createMock(Connection::class);
@@ -48,10 +54,25 @@ class DbServiceTest extends \PHPUnit_Framework_TestCase
        $this->entityManager->expects($this->once())->method('getConnection')->willReturn($this->connection);

        $this->logger = $this->createMock(LoggerInterface::class);

        $this->sqlGenerator = $this->createMock(SQLGenerator::class);
    }

    public function testCanSaveEntity()
    public function testCanSaveEntities()
    {
        $jsonEntity = new \stdClass();

        $this->entityClassMetadata->columnNames = [
            'one' => 'ONE',
            'two' => 'TWO',
        ];
        $this->entityClassMetadata->fieldMappings = [
            'one' => ['type' => 'string'],
            'two' => ['type' => 'string'],
        ];

        $service = new DbService();
        $service->save([$jsonEntity]);

    }
}
+88 −0
Changes for module/Import/tests/Import/Service/SQLGeneratorTest.php: 88 added lines, 0 removed lines.
Original line number Diff line number Diff line
<?php

namespace ImportTest\Service;

use Doctrine\DBAL\Platforms\AbstractPlatform;
use Import\Service\SQLGenerator;

class SQLGeneratorTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var SQLGenerator
     */
    private $sqlGenerator;

    protected function setUp()
    {
        $this->sqlGenerator = new SQLGenerator();
    }

    public function test_generateSQLQueryForClearingExistingData()
    {
        $filters = [];
        $sql = $this->sqlGenerator->generateSQLQueryForClearingExistingData('table_basse', $filters);
        $this->assertEquals("DELETE FROM table_basse", $sql);

        $filters = ['tiroir_id' => 1234];
        $sql = $this->sqlGenerator->generateSQLQueryForClearingExistingData('table_basse', $filters);
        $this->assertEquals("DELETE FROM table_basse WHERE TIROIR_ID = '1234'", $sql);

        $filters = ['tiroir_id' => 1234, 'couleur' => 'bleue'];
        $sql = $this->sqlGenerator->generateSQLQueryForClearingExistingData('table_basse', $filters);
        $this->assertEquals("DELETE FROM table_basse WHERE TIROIR_ID = '1234' AND COULEUR = 'bleue'", $sql);
    }

    public function test_generateSQLQueryForSavingData()
    {
        $tableColumns = ['largeur', 'hauteur', 'couleur'];
        $columnsValues = [12, '30', "'bleue'"];
        $sql = $this->sqlGenerator->generateSQLQueryForSavingData('table_basse', $tableColumns, $columnsValues);
        $this->assertEquals("INSERT INTO table_basse (largeur, hauteur, couleur) VALUES (12, 30, 'bleue')", $sql);
    }

    public function test_wrapSQLQueriesInBeginEnd()
    {
        $queries = ['insert ceci', 'insert cela'];
        $sql = $this->sqlGenerator->wrapSQLQueriesInBeginEnd($queries);
        $expected = <<<EOS
BEGIN
  insert ceci;
  insert cela;
END;
EOS;
        $this->assertEquals($expected, $sql);
    }

    public function getDataset()
    {
        $date = (new \stdClass());
        $date->date = '2018-11-15 08:00:00';

        return [
            [null,      'string',   "'quoted'"],
            ['valeur',  'string',   "'quoted'"],
            [12,        'string',   "'quoted'"],
            [null,      'date',     "NULL"],
            [$date,     'date',     "TO_DATE('2018-11-15', 'YYYY-MM-DD')"],
            ['valeur',  '??????',   'valeur'],
            [12,        '??????',   12],
        ];
    }

    /**
     * @param $value
     * @param $type
     * @param $expected
     * @dataProvider getDataset
     */
    public function test_formatValueForPropertyType($value, $type, $expected)
    {
        /** @var AbstractPlatform|\PHPUnit_Framework_MockObject_MockObject $platform */
        $platform = $this->createMock(AbstractPlatform::class);
        $this->sqlGenerator->setDatabasePlatform($platform);

        $platform->expects($this->any())->method('quoteStringLiteral')->with($value)->willReturn("quoted");
        $res = $this->sqlGenerator->formatValueForPropertyType($value, $type);
        $this->assertEquals($expected, $res);
    }
}