Merge branch '111_export_GeographicalUnit' into 111_exports_suite

src/Bundle/ChillMainBundle/Entity/GeographicalUnit.php

@@ -14,15 +14,17 @@ namespace Chill\MainBundle\Entity;
 use Doctrine\ORM\Mapping as ORM;
 
 /**
- * @ORM\Table(name="chill_main_geographical_unit")
- * @ORM\Entity
+ * @ORM\Table(name="chill_main_geographical_unit", uniqueConstraints={
+ *      @ORM\UniqueConstraint(name="geographical_unit_refid", columns={"layer_id", "unitRefId"})
+ * })
+ * @ORM\Entity(readOnly=true)
  */
 class GeographicalUnit
 {
     /**
      * @ORM\Column(type="text", nullable=true)
      */
-    private $geom;
+    private string $geom;
 
     /**
      * @ORM\Id
@@ -32,23 +34,30 @@ class GeographicalUnit
     private ?int $id = null;
 
     /**
-     * @ORM\Column(type="string", length=255, nullable=true)
+     * @ORM\Column(type="text", nullable=false, options={"default": ""})
      */
-    private $layerName;
+    private string $unitName;
 
     /**
-     * @ORM\Column(type="string", length=255, nullable=true)
+     * @ORM\Column(type="text", nullable=false, options={"default": ""})
      */
-    private $unitName;
+    private string $unitRefId;
+
+    /**
+     * @ORM\ManyToOne(targetEntity=GeographicalUnitLayer::class, inversedBy="units")
+     */
+    private ?GeographicalUnitLayer $layer;
 
     public function getId(): ?int
     {
         return $this->id;
     }
 
-    public function getLayerName(): ?string
+    protected function setId(int $id): self
     {
-        return $this->layerName;
+        $this->id = $id;
+
+        return $this;
     }
 
     public function getUnitName(): ?string
@@ -56,10 +65,31 @@ class GeographicalUnit
         return $this->unitName;
     }
 
-    public function setLayerName(?string $layerName): self
+    /**
+     * @return GeographicalUnitLayer|null
+     */
+    public function getLayer(): ?GeographicalUnitLayer
     {
-        $this->layerName = $layerName;
+        return $this->layer;
+    }
 
+    /**
+     * @param string $unitRefId
+     * @return GeographicalUnit
+     */
+    public function setUnitRefId(string $unitRefId): GeographicalUnit
+    {
+        $this->unitRefId = $unitRefId;
+        return $this;
+    }
+
+    /**
+     * @param GeographicalUnitLayer|null $layer
+     * @return GeographicalUnit
+     */
+    public function setLayer(?GeographicalUnitLayer $layer): GeographicalUnit
+    {
+        $this->layer = $layer;
         return $this;
     }
 

src/Bundle/ChillMainBundle/Entity/GeographicalUnitLayer.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace Chill\MainBundle\Entity;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Table(name="chill_main_geographical_unit_layer", uniqueConstraints={
+ *      @ORM\UniqueConstraint(name="geographical_unit_layer_refid", columns={"refId"})
+ * })
+ * @ORM\Entity
+ */
+class GeographicalUnitLayer
+{
+    /**
+     * @ORM\Id
+     * @ORM\GeneratedValue
+     * @ORM\Column(type="integer")
+     */
+    private ?int $id = null;
+
+    /**
+     * @ORM\Column(type="json", nullable=false, options={"default": "[]"})
+     */
+    private array $name = [];
+
+    /**
+     * @ORM\Column(type="text", nullable=false, options={"default": ""})
+     */
+    private string $refId = '';
+
+    /**
+     * @ORM\OneToMany(targetEntity=GeographicalUnit::class, mappedBy="layer")
+     */
+    private Collection $units;
+
+    public function __construct()
+    {
+        $this->units = new ArrayCollection();
+    }
+
+    /**
+     * @return int|null
+     */
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    /**
+     * @return array
+     */
+    public function getName(): array
+    {
+        return $this->name;
+    }
+
+    /**
+     * @param array $name
+     * @return GeographicalUnitLayer
+     */
+    public function setName(array $name): GeographicalUnitLayer
+    {
+        $this->name = $name;
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getRefId(): string
+    {
+        return $this->refId;
+    }
+
+    /**
+     * @return Collection
+     */
+    public function getUnits(): Collection
+    {
+        return $this->units;
+    }
+}

src/Bundle/ChillMainBundle/Repository/GeographicalUnitLayerLayerRepository.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Chill\MainBundle\Repository;
+
+use Chill\MainBundle\Entity\GeographicalUnit;
+use Chill\MainBundle\Entity\GeographicalUnitLayer;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\EntityRepository;
+use UnexpectedValueException;
+
+final class GeographicalUnitLayerLayerRepository implements GeographicalUnitLayerRepositoryInterface
+{
+    private EntityRepository $repository;
+
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->repository = $em->getRepository($this->getClassName());
+    }
+
+    public function find($id): ?GeographicalUnitLayer
+    {
+        return $this->repository->find($id);
+    }
+
+    /**
+     * @return array|GeographicalUnitLayer[]
+     */
+    public function findAll(): array
+    {
+        return $this->repository->findAll();
+    }
+
+    /**
+     * @return array|GeographicalUnitLayer[]
+     */
+    public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null): array
+    {
+        return $this->repository->findBy($criteria, $orderBy, $limit, $offset);
+    }
+
+    public function findOneBy(array $criteria): ?GeographicalUnitLayer
+    {
+        return $this->repository->findOneBy($criteria);
+    }
+
+    public function getClassName(): string
+    {
+        return GeographicalUnitLayer::class;
+    }
+
+    public function findAllHavingUnits(): array
+    {
+        $qb = $this->repository->createQueryBuilder('l');
+
+        return $qb->where($qb->expr()->gt('SIZE(l.units)', 0))
+            ->getQuery()
+            ->getResult();
+    }
+}

src/Bundle/ChillMainBundle/Repository/GeographicalUnitLayerRepositoryInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Chill\MainBundle\Repository;
+
+use Chill\MainBundle\Entity\GeographicalUnitLayer;
+use Doctrine\Persistence\ObjectRepository;
+
+interface GeographicalUnitLayerRepositoryInterface extends ObjectRepository
+{
+    /**
+     * @return array|GeographicalUnitLayer[]
+     */
+    public function findAllHavingUnits(): array;
+}

src/Bundle/ChillMainBundle/Repository/GeographicalUnitRepository.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Chill\MainBundle\Repository;
+
+use Chill\MainBundle\Entity\GeographicalUnit;
+use Chill\MainBundle\Entity\GeographicalUnitDTO;
+use Chill\MainBundle\Entity\GeographicalUnitLayer;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\EntityRepository;
+
+class GeographicalUnitRepository implements GeographicalUnitRepositoryInterface
+{
+    private EntityRepository $repository;
+
+    private EntityManagerInterface $em;
+
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->repository = $em->getRepository($this->getClassName());
+        $this->em = $em;
+    }
+
+
+    public function find($id): ?GeographicalUnit
+    {
+        return $this->repository->find($id);
+    }
+
+    /**
+     * Will return only partial object, where the @link{GeographicalUnit::geom} property is not loaded
+     *
+     * @return array|GeographicalUnit[]
+     */
+    public function findAll(): array
+    {
+        return $this->repository
+            ->createQueryBuilder('gu')
+            ->select('PARTIAL gu.{id,unitName,unitRefId,layer}')
+            ->addOrderBy('IDENTITY(gu.layer)')
+            ->addOrderBy(('gu.unitName'))
+            ->getQuery()
+            ->getResult();
+    }
+
+    public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null): ?GeographicalUnit
+    {
+        return $this->repository->findBy($criteria, $orderBy, $limit, $offset);
+    }
+
+    public function findOneBy(array $criteria): ?GeographicalUnit
+    {
+        return $this->repository->findOneBy($criteria);
+    }
+
+    public function getClassName(): string
+    {
+        return GeographicalUnit::class;
+    }
+}

src/Bundle/ChillMainBundle/Repository/GeographicalUnitRepositoryInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Chill\MainBundle\Repository;
+
+use Doctrine\Persistence\ObjectRepository;
+
+interface GeographicalUnitRepositoryInterface extends ObjectRepository
+{
+
+}

src/Bundle/ChillMainBundle/Service/Import/GeographicalUnitBaseImporter.php

@@ -0,0 +1,234 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\MainBundle\Service\Import;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Statement;
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Types\Types;
+use Exception;
+use LogicException;
+use Psr\Log\LoggerInterface;
+use function array_key_exists;
+use function count;
+
+final class GeographicalUnitBaseImporter
+{
+    private const INSERT = <<<'SQL'
+        INSERT INTO geographical_unit_temp
+            (layerKey, layerName, unitName, unitKey, geom)
+        SELECT
+            i.layerKey, i.layerName, i.unitName, i.unitKey,
+            ST_Transform(ST_setSrid(ST_GeomFromText(i.wkt), i.srid), 4326)
+        FROM
+            (VALUES
+                {{ values }}
+             ) AS i (layerKey, layerName, unitName, unitKey, wkt, srid)
+        SQL;
+
+    private const LOG_PREFIX = '[GeographicalUnitBAseImporter] ';
+
+    private const VALUE = '(?, ?::jsonb, ?, ?, ?, ?::int)';
+
+    /**
+     * @var array<int, Statement>
+     */
+    private array $cachingStatements = [];
+
+    private Connection $defaultConnection;
+
+    private bool $isInitialized = false;
+
+    private LoggerInterface $logger;
+
+    private array $waitingForInsert = [];
+
+    public function __construct(Connection $defaultConnection, LoggerInterface $logger)
+    {
+        $this->defaultConnection = $defaultConnection;
+        $this->logger = $logger;
+    }
+
+    public function finalize(): void
+    {
+        $this->doInsertPending();
+
+        $this->prepareForFinalize();
+
+        $this->updateGeographicalUnitTable();
+
+        $this->deleteTemporaryTable();
+
+        $this->isInitialized = false;
+    }
+
+    public function importUnit(
+        string $layerKey,
+        array $layerName,
+        string $unitName,
+        string $unitKey,
+        string $geomAsWKT,
+        int $srid = null
+    ): void {
+        $this->initialize();
+
+        $this->waitingForInsert[] = [
+            'layerKey' => $layerKey,
+            'layerName' => $layerName,
+            'unitName' => $unitName,
+            'unitKey' => $unitKey,
+            'geomAsWKT' => $geomAsWKT,
+            'srid' => $srid
+        ];
+
+        if (100 <= count($this->waitingForInsert)) {
+            $this->doInsertPending();
+        }
+    }
+
+    private function createTemporaryTable(): void
+    {
+        $this->defaultConnection->executeStatement("CREATE TEMPORARY TABLE geographical_unit_temp (
+            layerKey TEXT DEFAULT '' NOT NULL,
+            layerName JSONB DEFAULT '[]'::jsonb NOT NULL,
+            unitName TEXT default '' NOT NULL,
+            unitKey TEXT default '' NOT NULL,
+            geom GEOMETRY(MULTIPOLYGON, 4326)
+        )");
+
+        $this->defaultConnection->executeStatement('SET work_mem TO \'50MB\'');
+    }
+
+    private function deleteTemporaryTable(): void
+    {
+        $this->defaultConnection->executeStatement('DROP TABLE IF EXISTS geographical_unit_temp');
+    }
+
+    private function doInsertPending(): void
+    {
+        $forNumber = count($this->waitingForInsert);
+
+        if (0 === $forNumber) {
+            return;
+        }
+
+        if (!array_key_exists($forNumber, $this->cachingStatements)) {
+            $sql = strtr(self::INSERT, [
+                '{{ values }}' => implode(
+                    ', ',
+                    array_fill(0, $forNumber, self::VALUE)
+                ),
+            ]);
+
+            $this->logger->debug(self::LOG_PREFIX . ' generated sql for insert', [
+                'sql' => $sql,
+                'forNumber' => $forNumber,
+            ]);
+
+            $this->cachingStatements[$forNumber] = $this->defaultConnection->prepare($sql);
+        }
+
+        $statement = $this->cachingStatements[$forNumber];
+        try {
+            $i = 0;
+            foreach ($this->waitingForInsert as $insert) {
+                $statement->bindValue(++$i, $insert['layerKey'], Types::STRING);
+                $statement->bindValue(++$i, $insert['layerName'], Types::JSON);
+                $statement->bindValue(++$i, $insert['unitName'], Types::STRING);
+                $statement->bindValue(++$i, $insert['unitKey'], Types::STRING);
+                $statement->bindValue(++$i, $insert['geomAsWKT'], Types::STRING);
+                $statement->bindValue(++$i, $insert['srid'], Types::INTEGER);
+            }
+
+            $affected = $statement->executeStatement();
+
+            if ($affected === 0) {
+                throw new \RuntimeException('no row affected');
+            }
+        } catch (Exception $e) {
+            throw $e;
+        } finally {
+            $this->waitingForInsert = [];
+        }
+    }
+
+    private function initialize(): void
+    {
+        if ($this->isInitialized) {
+            return;
+        }
+
+        $this->deleteTemporaryTable();
+        $this->createTemporaryTable();
+        $this->isInitialized = true;
+    }
+
+    private function prepareForFinalize(): void
+    {
+        $this->defaultConnection->executeStatement(
+            'CREATE INDEX idx_ref_add_temp ON geographical_unit_temp (unitKey)'
+        );
+    }
+
+    private function updateGeographicalUnitTable(): void
+    {
+        $this->defaultConnection->transactional(
+            function() {
+                // 0) create new layers
+                $this->defaultConnection->executeStatement(
+                        "
+                    WITH unique_layers AS (
+                        SELECT DISTINCT layerKey, layerName FROM geographical_unit_temp
+                    )
+                    INSERT INTO chill_main_geographical_unit_layer (id, name, refid)
+                        SELECT
+                            nextval('chill_main_geographical_unit_layer_id_seq'),
+                            layerName,
+                            layerKey
+                        FROM unique_layers
+                    ON CONFLICT (refid) 
+                    DO UPDATE SET name=EXCLUDED.name
+                ");
+
+                //1) Add new units
+                $this->logger->info(self::LOG_PREFIX . 'upsert new units');
+                $affected = $this->defaultConnection->executeStatement("INSERT INTO chill_main_geographical_unit 
+            (id, geom, unitname, layer_id, unitrefid) 
+            SELECT
+                nextval('chill_main_geographical_unit_id_seq'),
+                geom,
+                unitName,
+                layer.id,
+                unitKey
+            FROM geographical_unit_temp JOIN chill_main_geographical_unit_layer AS layer ON layer.refid = layerKey
+            ON CONFLICT (layer_id, unitrefid) 
+            DO UPDATE
+            SET geom = EXCLUDED.geom, unitname = EXCLUDED.unitname
+        ");
+                $this->logger->info(self::LOG_PREFIX . 'units upserted', ['upserted' => $affected]);
+
+                //3) Delete units
+                $this->logger->info(self::LOG_PREFIX . 'soft delete adresses');
+                $affected = $this->defaultConnection->executeStatement('WITH to_delete AS (
+                    SELECT cmgu.id 
+                    FROM chill_main_geographical_unit AS cmgu
+                    JOIN chill_main_geographical_unit_layer AS cmgul ON cmgul.id = cmgu.layer_id 
+                    JOIN geographical_unit_temp AS gut ON cmgul.refid = gut.layerKey AND cmgu.unitrefid = gut.unitKey
+                )
+                DELETE FROM chill_main_geographical_unit
+                WHERE id NOT IN (SELECT id FROM to_delete)
+                ');
+                $this->logger->info(self::LOG_PREFIX . 'addresses deleted', ['deleted' => $affected]);
+            }
+        );
+    }
+}

src/Bundle/ChillMainBundle/Tests/Services/Import/GeographicalUnitBaseImporterTest.php

@@ -0,0 +1,89 @@
+<?php
+
+namespace Services\Import;
+
+use Chill\MainBundle\Service\Import\GeographicalUnitBaseImporter;
+use Doctrine\DBAL\Connection;
+use Doctrine\ORM\EntityManagerInterface;
+use Psr\Log\NullLogger;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+
+class GeographicalUnitBaseImporterTest extends KernelTestCase
+{
+    private Connection $connection;
+
+    private EntityManagerInterface $entityManager;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        self::bootKernel();
+
+        $this->connection = self::$container->get(Connection::class);
+        $this->entityManager = self::$container->get(EntityManagerInterface::class);
+    }
+
+    public function testImportUnit(): void
+    {
+        $importer = new GeographicalUnitBaseImporter(
+            $this->connection,
+            new NullLogger()
+        );
+
+        $importer->importUnit(
+            'test',
+            ['fr' => 'Test Layer'],
+            'Layer one',
+            'layer_one',
+            'MULTIPOLYGON (((30 20, 45 40, 10 40, 30 20)),((15 5, 40 10, 10 20, 5 10, 15 5)))',
+            3812
+        );
+
+        $importer->finalize();
+
+        $unit = $this->connection->executeQuery("
+            SELECT unitname, unitrefid, cmgul.refid AS layerrefid, cmgul.name AS layername, ST_AsText(ST_snapToGrid(ST_Transform(u.geom, 3812), 1)) AS geom
+            FROM chill_main_geographical_unit u JOIN chill_main_geographical_unit_layer cmgul on u.layer_id = cmgul.id 
+            WHERE u.unitrefid = ?", ['layer_one']);
+
+        $results = $unit->fetchAssociative();
+
+        $this->assertEquals($results['unitrefid'], 'layer_one');
+        $this->assertEquals($results['unitname'], 'Layer one');
+        $this->assertEquals(json_decode($results['layername'], true), ['fr' => 'Test Layer']);
+        $this->assertEquals($results['layerrefid'], 'test');
+        $this->assertEquals($results['geom'], 'MULTIPOLYGON(((30 20,45 40,10 40,30 20)),((15 5,40 10,10 20,5 10,15 5)))');
+
+        $importer = new GeographicalUnitBaseImporter(
+            $this->connection,
+            new NullLogger()
+        );
+
+        $importer->importUnit(
+            'test',
+            ['fr' => 'Test Layer fixed'],
+            'Layer one fixed',
+            'layer_one',
+            'MULTIPOLYGON (((130 120, 45 40, 10 40, 130 120)),((0 0, 15 5, 40 10, 10 20, 0 0)))',
+            3812
+        );
+
+        $importer->finalize();
+
+        $unit = $this->connection->executeQuery("
+            SELECT unitname, unitrefid, cmgul.refid AS layerrefid, cmgul.name AS layername, ST_AsText(ST_snapToGrid(ST_Transform(u.geom, 3812), 1)) AS geom
+            FROM chill_main_geographical_unit u JOIN chill_main_geographical_unit_layer cmgul on u.layer_id = cmgul.id 
+            WHERE u.unitrefid = ?", ['layer_one']);
+
+        $results = $unit->fetchAssociative();
+
+        $this->assertEquals($results['unitrefid'], 'layer_one');
+        $this->assertEquals($results['unitname'], 'Layer one fixed');
+        $this->assertEquals(json_decode($results['layername'], true), ['fr' => 'Test Layer fixed']);
+        $this->assertEquals($results['layerrefid'], 'test');
+        $this->assertEquals($results['geom'], 'MULTIPOLYGON(((130 120,45 40,10 40,130 120)),((0 0,15 5,40 10,10 20,0 0)))');
+
+    }
+
+}

src/Bundle/ChillMainBundle/migrations/Version20220913174922.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Chill\Migrations\Main;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Auto-generated Migration: Please modify to your needs!
+ */
+final class Version20220913174922 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Geographical Unit correction';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ALTER COLUMN geom SET DATA TYPE GEOMETRY(MULTIPOLYGON, 4326)');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ALTER COLUMN geom SET DATA TYPE TEXT');
+    }
+}

src/Bundle/ChillMainBundle/migrations/Version20221003112151.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Chill\Migrations\Main;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20221003112151 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Add a proper entity for GeographicalUnitLayer';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql('CREATE SEQUENCE chill_main_geographical_unit_layer_id_seq INCREMENT BY 1 MINVALUE 1 START 1');
+        $this->addSql('CREATE TABLE chill_main_geographical_unit_layer (id INT NOT NULL, name JSONB DEFAULT \'[]\'::jsonb NOT NULL, refid TEXT DEFAULT \'\' NOT NULL, PRIMARY KEY(id))');
+        $this->addSql("COMMENT ON COLUMN chill_main_geographical_unit_layer.name IS '(DC2Type:json)';");
+
+        $this->addSql('INSERT INTO chill_main_geographical_unit_layer (id, name, refid) 
+            SELECT DISTINCT nextval(\'chill_main_geographical_unit_layer_id_seq\'), jsonb_build_object(\'fr\', layername), layername FROM chill_main_geographical_unit');
+
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ADD layer_id INT DEFAULT NULL');
+
+        $this->addSql('UPDATE chill_main_geographical_unit SET layer_id = layer.id FROM chill_main_geographical_unit_layer AS layer WHERE layer.refid = chill_main_geographical_unit.layername');
+
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ADD unitRefId TEXT DEFAULT \'\' NOT NULL');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit DROP layername');
+        $this->addSql("COMMENT ON COLUMN chill_main_geographical_unit.geom IS '(DC2Type:text)';");
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ALTER unitname TYPE TEXT');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ALTER unitname SET DEFAULT \'\'');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ALTER unitname SET NOT NULL');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ADD CONSTRAINT FK_360A2B2FEA6EFDCD FOREIGN KEY (layer_id) REFERENCES chill_main_geographical_unit_layer (id) NOT DEFERRABLE INITIALLY IMMEDIATE');
+        $this->addSql('CREATE INDEX IDX_360A2B2FEA6EFDCD ON chill_main_geographical_unit (layer_id)');
+
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->throwIrreversibleMigrationException();
+
+        /* for memory
+        $this->addSql('ALTER TABLE chill_main_geographical_unit DROP CONSTRAINT FK_360A2B2FEA6EFDCD');
+        $this->addSql('DROP SEQUENCE chill_main_geographical_unit_layer_id_seq CASCADE');
+        $this->addSql('DROP TABLE chill_main_geographical_unit_layer');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ADD layername VARCHAR(255) DEFAULT NULL');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit DROP layer_id');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit DROP unitRefId');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ALTER geom TYPE VARCHAR(255)');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ALTER unitName TYPE VARCHAR(255)');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ALTER unitName DROP DEFAULT');
+        $this->addSql('ALTER TABLE chill_main_geographical_unit ALTER unitName DROP NOT NULL');
+        */
+    }
+}

src/Bundle/ChillMainBundle/migrations/Version20221003132620.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Chill\Migrations\Main;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20221003132620 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Create indexes and unique constraints on geographical unit entities';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql('CREATE UNIQUE INDEX geographical_unit_layer_refid ON chill_main_geographical_unit_layer (refId)');
+        $this->addSql('CREATE UNIQUE INDEX geographical_unit_refid ON chill_main_geographical_unit (layer_id, unitRefId)');
+        $this->addSql('CREATE INDEX chill_internal_geographical_unit_layer_geom_idx ON chill_main_geographical_unit USING GIST (layer_id, geom)');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('DROP INDEX geographical_unit_layer_refid');
+        $this->addSql('DROP INDEX geographical_unit_refid');
+        $this->addSql('DROP INDEX chill_internal_geographical_unit_layer_geom_idx');
+    }
+}

src/Bundle/ChillPersonBundle/Export/Aggregator/AccompanyingCourseAggregators/GeographicalUnitStatAggregator.php

@@ -2,39 +2,69 @@
 
 namespace Chill\PersonBundle\Export\Aggregator\AccompanyingCourseAggregators;
 
+use Chill\MainBundle\Entity\Address;
+use Chill\MainBundle\Entity\GeographicalUnit;
+use Chill\MainBundle\Entity\GeographicalUnitLayer;
 use Chill\MainBundle\Export\AggregatorInterface;
+use Chill\MainBundle\Form\Type\ChillDateType;
+use Chill\MainBundle\Repository\GeographicalUnitLayerRepositoryInterface;
+use Chill\MainBundle\Templating\TranslatableStringHelperInterface;
+use Chill\PersonBundle\Entity\Household\PersonHouseholdAddress;
 use Chill\PersonBundle\Export\Declarations;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\EntityRepository;
+use Doctrine\ORM\Query\Expr\Join;
 use Doctrine\ORM\QueryBuilder;
+use Symfony\Bridge\Doctrine\Form\Type\EntityType;
 use Symfony\Component\Form\FormBuilderInterface;
 
 final class GeographicalUnitStatAggregator implements AggregatorInterface
 {
-    /*
-    private EntityRepository $repository;
+    private GeographicalUnitLayerRepositoryInterface $geographicalUnitLayerRepository;
+
+    private TranslatableStringHelperInterface $translatableStringHelper;
 
     public function __construct(
-        EntityManagerInterface $em
+        GeographicalUnitLayerRepositoryInterface $geographicalUnitLayerRepository,
+        TranslatableStringHelperInterface $translatableStringHelper
     ) {
-        $this->repository = $em->getRepository(...::class);
+        $this->geographicalUnitLayerRepository = $geographicalUnitLayerRepository;
+        $this->translatableStringHelper = $translatableStringHelper;
     }
-    */
 
     /**
      * @inheritDoc
      */
     public function getLabels($key, array $values, $data)
     {
-        return function ($value): string {
-            if ('_header' === $value) {
-                return 'Geographical unit';
-            }
+        switch ($key) {
+            case 'acp_geog_agg_unitname':
+                return function ($value): string {
+                    if ('_header' === $value) {
+                        return 'acp_geog_agg_unitname';
+                    }
 
-            $g = $this->repository->find($value);
+                    if (null === $value) {
+                        return '';
+                    }
 
-            return $g; //...
-        };
+                    return $value;
+                };
+            case 'acp_geog_agg_unitrefid':
+                return function ($value): string {
+                    if ('_header' === $value) {
+                        return 'acp_geog_agg_unitrefid';
+                    }
+
+                    if (null === $value) {
+                        return '';
+                    }
+
+                    return $value;
+                };
+            default:
+                throw new \UnexpectedValueException('this value should not happens');
+        }
     }
 
     /**
@@ -42,7 +72,7 @@ final class GeographicalUnitStatAggregator implements AggregatorInterface
      */
     public function getQueryKeys($data): array
     {
-        return ['geographicalunitstat_aggregator'];
+        return ['acp_geog_agg_unitname', 'acp_geog_agg_unitrefid'];
     }
 
     /**
@@ -50,7 +80,22 @@ final class GeographicalUnitStatAggregator implements AggregatorInterface
      */
     public function buildForm(FormBuilderInterface $builder)
     {
-        // TODO: Implement buildForm() method.
+        $builder
+            ->add('date_calc', ChillDateType::class, [
+                'label' => 'Compute geographical location at date',
+                'required' => true,
+                'data' => new \DateTimeImmutable('today'),
+                'input' => 'datetime_immutable',
+            ])
+            ->add('level', EntityType::class, [
+                'label' => 'Geographical layer',
+                'placeholder' => 'Select a geographical layer',
+                'class' => GeographicalUnitLayer::class,
+                'choices' => $this->geographicalUnitLayerRepository->findAllHavingUnits(),
+                'choice_label' => function(GeographicalUnitLayer $item) {
+                    return $this->translatableStringHelper->localize($item->getName());
+                },
+            ]);
     }
 
     /**
@@ -74,16 +119,70 @@ final class GeographicalUnitStatAggregator implements AggregatorInterface
      */
     public function alterQuery(QueryBuilder $qb, $data)
     {
+        if (!in_array('acp_geog_agg_location_history', $qb->getAllAliases(), true)) {
+            $qb->leftJoin('acp.locationHistories', 'acp_geog_agg_location_history');
 
-        //$qb->addSelect('... AS geographicalunitstat_aggregator');
+            $qb->andWhere(
+                $qb->expr()->andX(
+                    'acp_geog_agg_location_history.startDate <= :acp_geog_aggregator_date',
+                    $qb->expr()->orX(
+                        'acp_geog_agg_location_history.endDate IS NULL',
+                        'acp_geog_agg_location_history.endDate > :acp_geog_aggregator_date'
+                    )
+                )
+            );
 
-        $groupby = $qb->getDQLPart('groupBy');
-
-        if (!empty($groupBy)) {
-            $qb->addGroupBy('geographicalunitstat_aggregator');
-        } else {
-            $qb->groupBy('geographicalunitstat_aggregator');
+            $qb->setParameter('acp_geog_aggregator_date', $data['date_calc']);
         }
+
+        // link between location history and person
+        if (!in_array('acp_geog_agg_address_person_location', $qb->getAllAliases(), true)) {
+            $qb->leftJoin(
+                PersonHouseholdAddress::class,
+                'acp_geog_agg_address_person_location',
+                Join::WITH,
+                $qb->expr()->andX(
+                    'IDENTITY(acp_geog_agg_address_person_location.person) = IDENTITY(acp_geog_agg_location_history.personLocation)',
+                    'acp_geog_agg_address_person_location.validFrom < :acp_geog_aggregator_date',
+                    $qb->expr()->orX(
+                        'acp_geog_agg_address_person_location.validTo > :acp_geog_aggregator_date',
+                        $qb->expr()->isNull('acp_geog_agg_address_person_location.validTo')
+                    )
+                )
+            );
+
+            $qb->setParameter('acp_geog_aggregator_date', $data['date_calc']);
+        }
+
+        // we finally find an address
+        if (!in_array('acp_geog_agg_address', $qb->getAllAliases(), true)) {
+            $qb->leftJoin(
+                Address::class,
+                'acp_geog_agg_address',
+                Join::WITH,
+                'COALESCE(IDENTITY(acp_geog_agg_address_person_location.address), IDENTITY(acp_geog_agg_location_history.addressLocation)) = acp_geog_agg_address.id'
+            );
+        }
+
+        // and we do a join with units
+        $qb->leftJoin(
+            GeographicalUnit::class,
+            'acp_geog_units',
+            Join::WITH,
+            'ST_CONTAINS(acp_geog_units.geom, acp_geog_agg_address.point) = TRUE'
+        );
+
+        $qb->andWhere($qb->expr()->eq('acp_geog_units.layer', ':acp_geog_unit_layer'));
+
+        $qb->setParameter('acp_geog_unit_layer', $data['level']);
+
+        // we add group by
+        $qb
+            ->addSelect('acp_geog_units.unitName AS acp_geog_agg_unitname')
+            ->addSelect('acp_geog_units.unitRefId AS acp_geog_agg_unitrefid')
+            ->addGroupBy('acp_geog_agg_unitname')
+            ->addGroupBy('acp_geog_agg_unitrefid')
+            ;
     }
 
     /**
@@ -93,4 +192,4 @@ final class GeographicalUnitStatAggregator implements AggregatorInterface
     {
         return Declarations::ACP_TYPE;
     }
-}
+}

src/Bundle/ChillPersonBundle/Export/Aggregator/PersonAggregators/GeographicalUnitAggregator.php

@@ -0,0 +1,163 @@
+<?php
+
+namespace Chill\PersonBundle\Export\Aggregator\PersonAggregators;
+
+use Chill\MainBundle\Entity\GeographicalUnit;
+use Chill\MainBundle\Entity\GeographicalUnitLayer;
+use Chill\MainBundle\Export\AggregatorInterface;
+use Chill\MainBundle\Form\Type\ChillDateType;
+use Chill\MainBundle\Repository\GeographicalUnitLayerRepositoryInterface;
+use Chill\MainBundle\Templating\TranslatableStringHelperInterface;
+use Chill\PersonBundle\Export\Declarations;
+use Doctrine\ORM\Query\Expr\Join;
+use Doctrine\ORM\QueryBuilder;
+use Symfony\Bridge\Doctrine\Form\Type\EntityType;
+use Symfony\Component\Form\FormBuilderInterface;
+
+class GeographicalUnitAggregator implements AggregatorInterface
+{
+    private GeographicalUnitLayerRepositoryInterface $geographicalUnitLayerRepository;
+
+    private TranslatableStringHelperInterface $translatableStringHelper;
+
+    public function __construct(
+        GeographicalUnitLayerRepositoryInterface $geographicalUnitLayerRepository,
+        TranslatableStringHelperInterface $translatableStringHelper
+    ) {
+        $this->geographicalUnitLayerRepository = $geographicalUnitLayerRepository;
+        $this->translatableStringHelper = $translatableStringHelper;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getLabels($key, array $values, $data)
+    {
+        switch ($key) {
+            case 'geog_unit_name':
+                return function ($value): string {
+                    if ('_header' === $value) {
+                        return 'acp_geog_agg_unitname';
+                    }
+
+                    if (null === $value) {
+                        return '';
+                    }
+
+                    return $value;
+                };
+
+            case 'geog_unit_key':
+                return function ($value): string {
+                    if ('_header' === $value) {
+                        return 'acp_geog_agg_unitrefid';
+                    }
+
+                    if (null === $value) {
+                        return '';
+                    }
+
+                    return $value;
+                };
+
+            default:
+                throw new \LogicException('key not supported');
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getQueryKeys($data)
+    {
+        return ['geog_unit_name', 'geog_unit_key'];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function buildForm(FormBuilderInterface $builder)
+    {
+        $builder
+            ->add('date_calc', ChillDateType::class, [
+                'label' => 'Address valid at this date',
+                'required' => true,
+                'data' => new \DateTimeImmutable('today'),
+                'input' => 'datetime_immutable',
+            ])
+            ->add('level', EntityType::class, [
+                'label' => 'Geographical layer',
+                'placeholder' => 'Select a geographical layer',
+                'class' => GeographicalUnitLayer::class,
+                'choices' => $this->geographicalUnitLayerRepository->findAllHavingUnits(),
+                'choice_label' => function(GeographicalUnitLayer $item) {
+                    return $this->translatableStringHelper->localize($item->getName());
+                },
+            ]);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getTitle()
+    {
+        return 'Group people by geographical unit based on his address';
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function addRole(): ?string
+    {
+        return null;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function alterQuery(QueryBuilder $qb, $data): void
+    {
+        $qb
+            ->leftJoin('person.householdAddresses', 'person_geog_agg_current_household_address')
+            ->leftJoin('person_geog_agg_current_household_address.address', 'person_geog_agg_address')
+            ->leftJoin(GeographicalUnit::class, 'person_geog_agg_geog_unit', Join::WITH, 'ST_CONTAINS(person_geog_agg_geog_unit.geom, person_geog_agg_address.point) = TRUE')
+            ->andWhere(
+                $qb->expr()->orX(
+                    $qb->expr()->isNull('person_geog_agg_current_household_address'),
+                    $qb->expr()->andX(
+                        $qb->expr()->lte('person_geog_agg_current_household_address.validFrom', ':person_geog_agg_date'),
+                        $qb->expr()->orX(
+                            $qb->expr()->isNull('person_geog_agg_current_household_address.validTo'),
+                            $qb->expr()->gt('person_geog_agg_current_household_address.validTo', ':person_geog_agg_date')
+                        )
+                    )
+                )
+            )
+            ->andWhere(
+                $qb->expr()->orX(
+                    $qb->expr()->isNull('person_geog_agg_geog_unit'),
+                    $qb->expr()->in('person_geog_agg_geog_unit.layer', ':person_geog_agg_layers')
+                )
+            )
+            ->setParameter('person_geog_agg_date', $data['date_calc'])
+            ->setParameter('person_geog_agg_layers', $data['level'])
+            ->addSelect('person_geog_agg_geog_unit.unitName AS geog_unit_name')
+            ->addSelect('person_geog_agg_geog_unit.unitRefId AS geog_unit_key')
+            ->addGroupBy('geog_unit_name')
+            ->addGroupBy('geog_unit_key')
+            ;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function applyOn()
+    {
+        return Declarations::PERSON_TYPE;
+    }
+
+    public static function getDefaultAlias(): string
+    {
+        return 'person_geog_agg';
+    }
+}

src/Bundle/ChillPersonBundle/Export/Filter/AccompanyingCourseFilters/GeographicalUnitStatFilter.php

@@ -11,29 +11,46 @@ declare(strict_types=1);
 
 namespace Chill\PersonBundle\Export\Filter\AccompanyingCourseFilters;
 
+use Chill\MainBundle\Entity\Address;
 use Chill\MainBundle\Entity\GeographicalUnit;
 use Chill\MainBundle\Export\FilterInterface;
 use Chill\MainBundle\Form\Type\ChillDateType;
+use Chill\MainBundle\Repository\GeographicalUnitRepositoryInterface;
+use Chill\MainBundle\Templating\TranslatableStringHelperInterface;
+use Chill\PersonBundle\Entity\AccompanyingPeriod;
+use Chill\PersonBundle\Entity\Household\PersonHouseholdAddress;
 use Chill\PersonBundle\Export\Declarations;
 use DateTime;
 use Doctrine\DBAL\Types\Types;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Query\Expr;
 use Doctrine\ORM\Query\Expr\Andx;
 use Doctrine\ORM\QueryBuilder;
 use Symfony\Bridge\Doctrine\Form\Type\EntityType;
 use Symfony\Component\Form\FormBuilderInterface;
 
 /**
- * e) par zone géographique.
- *
- *   Paramètre:
- *    * Date
- *    * Choix unique entre: territoire, epci, canton, commune, secteur d'intervention
- *    * une fois le premier choix effectué, l'utilisateur choisi parmi les zones (choix multiple)
- *
- *   Le filtre retiendra les parcours localisé dans un des territoires cochés, à la date indiquée en paramètre.
+ * Filter accompanying period by geographical zone
  */
 class GeographicalUnitStatFilter implements FilterInterface
 {
+
+    private GeographicalUnitRepositoryInterface $geographicalUnitRepository;
+
+    private TranslatableStringHelperInterface $translatableStringHelper;
+
+    private EntityManagerInterface $em;
+
+    public function __construct(
+        EntityManagerInterface $em,
+        GeographicalUnitRepositoryInterface $geographicalUnitRepository,
+        TranslatableStringHelperInterface $translatableStringHelper
+    ) {
+        $this->em = $em;
+        $this->geographicalUnitRepository = $geographicalUnitRepository;
+        $this->translatableStringHelper = $translatableStringHelper;
+    }
+
     public function addRole(): ?string
     {
         return null;
@@ -41,18 +58,32 @@ class GeographicalUnitStatFilter implements FilterInterface
 
     public function alterQuery(QueryBuilder $qb, $data)
     {
-        $where = $qb->getDQLPart('where');
-        $clause = $qb->expr()->eq(1, 1);
+        $subQueryDql =
+            'SELECT
+                1
+            FROM '.AccompanyingPeriod\AccompanyingPeriodLocationHistory::class.' acp_geog_filter_location_history
+            LEFT JOIN '.PersonHouseholdAddress::class.' acp_geog_filter_address_person_location
+                WITH IDENTITY(acp_geog_filter_location_history.personLocation) = IDENTITY(acp_geog_filter_address_person_location.person)
+            LEFT JOIN '.Address::class.' acp_geog_filter_address
+                WITH COALESCE(IDENTITY(acp_geog_filter_address_person_location.address), IDENTITY(acp_geog_filter_location_history.addressLocation)) = acp_geog_filter_address.id
+            LEFT JOIN '.GeographicalUnit::class.' acp_geog_filter_units WITH ST_CONTAINS(acp_geog_units.geom, acp_geog_filter_address.point) = TRUE
+            WHERE
+                (acp_geog_filter_location_history.startDate <= :acp_geog_filter_date AND (
+                    acp_geog_filter_location_history.endDate IS NULL OR acp_geog_filter_location_history.endDate < :acp_geog_filter_date
+                ))
+                AND
+                (acp_geog_filter_address_person_location.validFrom < :acp_geog_filter_date AND (
+                    acp_geog_filter_address_person_location.validTo IS NULL OR acp_geog_filter_address_person_location.validTo < :acp_geog_filter_date
+                ))
+                AND acp_geog_filter_units IN (:acp_geog_filter_units)
+                AND acp_geog_filter_location_history.period = acp.id
+            ';
 
-        if ($where instanceof Andx) {
-            $where->add($clause);
-        } else {
-            $where = $qb->expr()->andX($clause);
-        }
-
-        $qb->add('where', $where);
-        $qb->setParameter('date', $data['date'], Types::DATE_MUTABLE);
-        $qb->setParameter('loctype', $data['accepted_loctype']);
+        $qb
+            ->andWhere($qb->expr()->exists($subQueryDql))
+            ->setParameter('acp_geog_filter_date', $data['date_calc'])
+            ->setParameter('acp_geog_filter_units', $data['units'])
+        ;
     }
 
     public function applyOn(): string
@@ -63,23 +94,40 @@ class GeographicalUnitStatFilter implements FilterInterface
     public function buildForm(FormBuilderInterface $builder)
     {
         $builder
-            ->add('date', ChillDateType::class, [
-                'data' => new DateTime(),
+            ->add('date_calc', ChillDateType::class, [
+                'label' => 'Compute geographical location at date',
+                'required' => true,
+                'data' => new \DateTimeImmutable('today'),
+                'input' => 'datetime_immutable',
             ])
-            ->add('accepted_loctype', EntityType::class, [
+            ->add('units', EntityType::class, [
+                'label' => 'Geographical unit',
+                'placeholder' => 'Select a geographical unit',
                 'class' => GeographicalUnit::class,
-                'choice_label' => static function (GeographicalUnit $u) {
-                    return $u->getUnitName();
+                'choices' => $this->geographicalUnitRepository->findAll(),
+                'choice_label' => function(GeographicalUnit $item) {
+                    return $this->translatableStringHelper->localize($item->getLayer()->getName()) . ' > ' . $item->getUnitName();
                 },
+                'attr' => [
+                    'class' => 'select2',
+                ],
                 'multiple' => true,
-                'expanded' => true,
             ]);
     }
 
     public function describeAction($data, $format = 'string'): array
     {
-        return ['Filtered by geographic unit: only %date%', [
-            '%date%' => $data['date']->format('d-m-Y'),
+        return ['Filtered by geographic unit: computed at %date%, only in %units%', [
+            '%date%' => $data['date_calc']->format('d-m-Y'),
+            '%units' => implode(
+                ', ',
+                array_map(
+                    function(GeographicalUnit $item) {
+                        return $this->translatableStringHelper->localize($item->getLayer()->getName()) . ' > ' . $item->getUnitName();
+                    },
+                    $data['units']
+                )
+            )
         ]];
     }
 

src/Bundle/ChillPersonBundle/Export/Filter/PersonFilters/GeographicalUnitFilter.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace Chill\PersonBundle\Export\Filter\PersonFilters;
+
+use Chill\MainBundle\Entity\Address;
+use Chill\MainBundle\Entity\GeographicalUnit;
+use Chill\MainBundle\Form\Type\ChillDateType;
+use Chill\MainBundle\Repository\GeographicalUnitLayerRepositoryInterface;
+use Chill\MainBundle\Repository\GeographicalUnitRepositoryInterface;
+use Chill\MainBundle\Templating\TranslatableStringHelperInterface;
+use Chill\PersonBundle\Entity\Household\PersonHouseholdAddress;
+use Chill\PersonBundle\Export\Declarations;
+use Doctrine\ORM\QueryBuilder;
+use Symfony\Bridge\Doctrine\Form\Type\EntityType;
+use Symfony\Component\Form\FormBuilderInterface;
+
+class GeographicalUnitFilter implements \Chill\MainBundle\Export\FilterInterface
+{
+    private GeographicalUnitRepositoryInterface $geographicalUnitRepository;
+
+    private TranslatableStringHelperInterface $translatableStringHelper;
+
+    public function __construct(
+        GeographicalUnitRepositoryInterface $geographicalUnitRepository,
+        TranslatableStringHelperInterface $translatableStringHelper
+    ) {
+        $this->geographicalUnitRepository = $geographicalUnitRepository;
+        $this->translatableStringHelper = $translatableStringHelper;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function buildForm(FormBuilderInterface $builder)
+    {
+        $builder
+            ->add('date_calc', ChillDateType::class, [
+                'label' => 'Compute geographical location at date',
+                'required' => true,
+                'data' => new \DateTimeImmutable('today'),
+                'input' => 'datetime_immutable',
+            ])
+            ->add('units', EntityType::class, [
+                'label' => 'Geographical unit',
+                'placeholder' => 'Select a geographical unit',
+                'class' => GeographicalUnit::class,
+                'choices' => $this->geographicalUnitRepository->findAll(),
+                'choice_label' => function(GeographicalUnit $item) {
+                    return $this->translatableStringHelper->localize($item->getLayer()->getName()) . ' > ' . $item->getUnitName();
+                },
+                'attr' => [
+                    'class' => 'select2',
+                ],
+                'multiple' => true,
+            ]);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getTitle(): string
+    {
+        return 'Filter by person\'s geographical unit (based on address)';
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function describeAction($data, $format = 'string')
+    {
+        return [
+            'exports.by_person.Filtered by person\'s geographical unit (based on address) computed at datecalc, only units',
+            [
+                'datecalc' => $data['date_calc']->format('Y-m-d'),
+                'units' => implode(
+                    ', ',
+                        array_map(
+                            function (GeographicalUnit $item) {
+                                return $this->translatableStringHelper->localize($item->getLayer()->getName()) . ' > ' . $item->getUnitName();
+                            },
+                            $data['units']->toArray()
+                        )
+                )
+            ]
+        ];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function addRole(): ?string
+    {
+        return null;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function alterQuery(QueryBuilder $qb, $data)
+    {
+        $subQuery =
+            'SELECT 1
+            FROM '.PersonHouseholdAddress::class.' person_filter_geog_person_household_address
+            JOIN person_filter_geog_person_household_address.address person_filter_geog_address
+            JOIN '.GeographicalUnit::class.' person_filter_geog_unit
+                WITH ST_CONTAINS(person_filter_geog_unit.geom, person_filter_geog_address.point) = TRUE
+            WHERE
+                person_filter_geog_person_household_address.validFrom <= :person_filter_geog_date
+                AND
+                    (person_filter_geog_person_household_address.validTo IS NULL
+                    OR person_filter_geog_person_household_address.validTo > :person_filter_geog_date)
+                AND
+                    person_filter_geog_unit IN (:person_filter_geog_units)
+                AND
+                    person_filter_geog_person_household_address.person = person
+            ';
+
+        $qb
+            ->andWhere(
+                $qb->expr()->exists($subQuery)
+            )
+            ->setParameter('person_filter_geog_date', $data['date_calc'])
+            ->setParameter('person_filter_geog_units', $data['units'])
+            ;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function applyOn()
+    {
+        return Declarations::PERSON_TYPE;
+    }
+}

src/Bundle/ChillPersonBundle/Tests/Export/Aggregator/AccompanyingCourseAggregators/GeographicalUnitStatAggregatorTest.php

@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\PersonBundle\Tests\Export\Aggregator\AccompanyingCourseAggregators;
+
+use Chill\PersonBundle\Entity\AccompanyingPeriod;
+use Chill\MainBundle\Test\Export\AbstractAggregatorTest;
+use Chill\PersonBundle\Export\Aggregator\AccompanyingCourseAggregators\GeographicalUnitStatAggregator;
+use Doctrine\ORM\EntityManagerInterface;
+
+final class GeographicalUnitStatAggregatorTest extends AbstractAggregatorTest
+{
+    private GeographicalUnitStatAggregator $aggregator;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+
+        $this->aggregator = self::$container->get('chill.person.export.aggregator_geographicalunitstat');
+    }
+
+    public function getAggregator()
+    {
+        return $this->aggregator;
+    }
+
+    public function getFormData(): array
+    {
+        return [
+            [],
+        ];
+    }
+
+    public function getQueryBuilders(): array
+    {
+        if (null === self::$kernel) {
+            self::bootKernel();
+        }
+
+        $em = self::$container->get(EntityManagerInterface::class);
+
+        return [
+            $em->createQueryBuilder()
+                ->select('count(acp.id)')
+                ->from(AccompanyingPeriod::class, 'acp')
+                ,
+        ];
+    }
+}

src/Bundle/ChillPersonBundle/config/services/exports_accompanying_course.yaml

@@ -44,12 +44,12 @@ services:
         tags:
             - { name: chill.export_filter, alias: accompanyingcourse_step_filter }
 
-    #chill.person.export.filter_geographicalunitstat:
-    #    class: Chill\PersonBundle\Export\Filter\AccompanyingCourseFilters\GeographicalUnitStatFilter
-    #    autowire: true
-    #    autoconfigure: true
-    #    tags:
-    #        - { name: chill.export_filter, alias: accompanyingcourse_geographicalunitstat_filter }
+    chill.person.export.filter_geographicalunitstat:
+        class: Chill\PersonBundle\Export\Filter\AccompanyingCourseFilters\GeographicalUnitStatFilter
+        autowire: true
+        autoconfigure: true
+        tags:
+            - { name: chill.export_filter, alias: accompanyingcourse_geographicalunitstat_filter }
 
     chill.person.export.filter_socialaction:
         class: Chill\PersonBundle\Export\Filter\AccompanyingCourseFilters\SocialActionFilter
@@ -171,12 +171,12 @@ services:
         tags:
             - { name: chill.export_aggregator, alias: accompanyingcourse_step_aggregator }
 
-    #chill.person.export.aggregator_geographicalunitstat:
-    #    class: Chill\PersonBundle\Export\Aggregator\AccompanyingCourseAggregators\GeographicalUnitStatAggregator
-    #    autowire: true
-    #    autoconfigure: true
-    #    tags:
-    #        - { name: chill.export_aggregator, alias: accompanyingcourse_geographicalunitstat_aggregator }
+    chill.person.export.aggregator_geographicalunitstat:
+        class: Chill\PersonBundle\Export\Aggregator\AccompanyingCourseAggregators\GeographicalUnitStatAggregator
+        autowire: true
+        autoconfigure: true
+        tags:
+            - { name: chill.export_aggregator, alias: accompanyingcourse_geographicalunitstat_aggregator }
 
     chill.person.export.aggregator_socialaction:
         class: Chill\PersonBundle\Export\Aggregator\AccompanyingCourseAggregators\SocialActionAggregator

src/Bundle/ChillPersonBundle/config/services/exports_person.yaml

@@ -90,6 +90,12 @@ services:
         tags:
             - { name: chill.export_filter, alias: person_marital_status_filter }
 
+    Chill\PersonBundle\Export\Filter\PersonFilters\GeographicalUnitFilter:
+        autowire: true
+        autoconfigure: true
+        tags:
+            - { name: chill.export_filter, alias: person_geog_filter }
+
     ## Aggregators
     chill.person.export.aggregator_nationality:
         class: Chill\PersonBundle\Export\Aggregator\PersonAggregators\NationalityAggregator
@@ -132,3 +138,10 @@ services:
         autoconfigure: true
         tags:
             - { name: chill.export_aggregator, alias: person_household_position_aggregator }
+
+    Chill\PersonBundle\Export\Aggregator\PersonAggregators\GeographicalUnitAggregator:
+        autowire: true
+        autoconfigure: true
+        tags:
+            - { name: chill.export_aggregator, alias: person_geog_aggregator }
+

src/Bundle/ChillPersonBundle/translations/messages+intl-icu.fr.yaml

@@ -130,3 +130,8 @@ periods:
             many {Masquer # parcours clôturés ou anciens parcours}
             other {Masquer # parcours clôturés ou anciens parcours}
         }
+
+exports:
+    by_person:
+        Filtered by person\'s geographical unit (based on address) computed at date, only units:
+            "Filtré par zone géographique sur base de l'adresse, calculé à {datecalc, date, short}, seulement les zones suivantes: {units}"

src/Bundle/ChillPersonBundle/translations/messages.fr.yml

@@ -456,7 +456,14 @@ Group by step: Grouper les parcours par statut du parcours
 
 Filter by geographical unit: Filtrer les parcours par zone géographique
 Group by geographical unit: Grouper les parcours par zone géographique
+Compute geographical location at date: Date de calcul de la localisation géographique
 Geographical unit: Zone géographique
+acp_geog_agg_unitname: Zone géographique
+acp_geog_agg_unitrefid: Clé de la zone géographique
+Geographical layer: Couche géographique
+Select a geographical layer: Choisir une couche géographique
+Group people by geographical unit based on his address: Grouper les personnes par zone géographique (sur base de l'adresse)
+Filter by person's geographical unit (based on address): Filter les personnes par zone géographique (sur base de l'adresse)
 
 Filter by socialaction: Filtrer les parcours par action d'accompagnement
 Accepted socialactions: Actions d'accompagnement