Add center filtering logic to export generation

Introduced a `filterStatsByCenters` configuration in `ExportGenerator` to enable conditional center filtering during exports. Updated related methods and tests to account for this parameter, ensuring compatibility with both filtered and unfiltered scenarios.

src/Bundle/ChillMainBundle/Tests/Export/ExportGeneratorTest.php

@@ -25,6 +25,7 @@ use Chill\MainBundle\Export\ExportManager;
 use Chill\MainBundle\Export\FilterInterface;
 use Chill\MainBundle\Export\FormattedExportGeneration;
 use Chill\MainBundle\Export\FormatterInterface;
+use Chill\MainBundle\Repository\CenterRepositoryInterface;
 use Chill\MainBundle\Security\Authorization\AuthorizationHelperInterface;
 use Chill\MainBundle\Service\Regroupement\CenterRegroupementResolver;
 use Doctrine\ORM\NativeQuery;
@@ -33,6 +34,8 @@ use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Prophecy\PhpUnit\ProphecyTrait;
 use Psr\Log\NullLogger;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 
 /**
  * @internal
@@ -43,6 +46,13 @@ class ExportGeneratorTest extends TestCase
 {
     use ProphecyTrait;
 
+    private function buildParameter(bool $filterStat): ParameterBagInterface
+    {
+        return new ParameterBag(
+            ['chill_main' => ['acl' => ['filter_stats_by_center' => $filterStat]]]
+        );
+    }
+
     public function testGenerateHappyScenario()
     {
         $initialData = ['initial' => 'test'];
@@ -133,18 +143,22 @@ class ExportGeneratorTest extends TestCase
         $authorizationHelper = $this->prophesize(AuthorizationHelperInterface::class);
         $authorizationHelper->getReachableCenters($user, 'dummy_role')->willReturn([$centerA, $centerB]);
 
+        $centerRepository = $this->prophesize(CenterRepositoryInterface::class);
+        $centerRepository->findActive()->shouldNotBeCalled();
+
         $generator = new ExportGenerator(
             $exportManager->reveal(),
             $exportConfigNormalizer->reveal(),
             new NullLogger(),
             $authorizationHelper->reveal(),
             new CenterRegroupementResolver(),
-            new ExportConfigProcessor($exportManager->reveal())
+            new ExportConfigProcessor($exportManager->reveal()),
+            $this->buildParameter(true),
+            $centerRepository->reveal(),
         );
 
         $actual = $generator->generate('dummy', $initialData, $user);
 
-        self::assertInstanceOf(FormattedExportGeneration::class, $actual);
         self::assertEquals('export result', $actual->content);
         self::assertEquals('text/text', $actual->contentType);
     }
@@ -201,13 +215,18 @@ class ExportGeneratorTest extends TestCase
         $authorizationHelper = $this->prophesize(AuthorizationHelperInterface::class);
         $authorizationHelper->getReachableCenters($user, 'dummy_role')->willReturn([$centerA, $centerB]);
 
+        $centerRepository = $this->prophesize(CenterRepositoryInterface::class);
+        $centerRepository->findActive()->shouldNotBeCalled();
+
         $generator = new ExportGenerator(
             $exportManager->reveal(),
             $exportConfigNormalizer->reveal(),
             new NullLogger(),
             $authorizationHelper->reveal(),
             new CenterRegroupementResolver(),
-            new ExportConfigProcessor($exportManager->reveal())
+            new ExportConfigProcessor($exportManager->reveal()),
+            $this->buildParameter(true),
+            $centerRepository->reveal(),
         );
 
         $actual = $generator->generate('dummy', $initialData, $user);
@@ -250,6 +269,9 @@ class ExportGeneratorTest extends TestCase
         $authorizationHelper = $this->prophesize(AuthorizationHelperInterface::class);
         $authorizationHelper->getReachableCenters($user, 'dummy_role')->willReturn([$centerA, $centerB]);
 
+        $centerRepository = $this->prophesize(CenterRepositoryInterface::class);
+        $centerRepository->findActive()->shouldNotBeCalled();
+
         $generator = new ExportGenerator(
             $exportManager->reveal(),
             $exportConfigNormalizer->reveal(),
@@ -257,6 +279,8 @@ class ExportGeneratorTest extends TestCase
             $authorizationHelper->reveal(),
             new CenterRegroupementResolver(),
             new ExportConfigProcessor($exportManager->reveal()),
+            $this->buildParameter(true),
+            $centerRepository->reveal(),
         );
 
         $actual = $generator->generate('dummy', $initialData, $user);
@@ -265,4 +289,116 @@ class ExportGeneratorTest extends TestCase
         self::assertEquals('export result', $actual->content);
         self::assertEquals('text/text', $actual->contentType);
     }
+
+    public function testGenerateHappyScenarioWithoutCenterFiltering()
+    {
+        $initialData = ['initial' => 'test'];
+        $fullConfig = [
+            'export' => $formExportData = ['key' => 'form1'],
+            'filters' => [
+                'dummy_filter' => ['enabled' => true, 'form' => $formFilterData = ['key' => 'form2']],
+                'disabled_filter' => ['enabled' => false],
+            ],
+            'aggregators' => [
+                'dummy_aggregator' => ['enabled' => true, 'form' => $formAggregatorData = ['key' => 'form3']],
+                'disabled_aggregator' => ['enabled' => false],
+            ],
+            'pick_formatter' => 'xlsx',
+            'formatter' => $formatterData = ['key' => 'form4'],
+            'centers' => ['centers' => [], 'regroupments' => []],
+        ];
+        $user = new User();
+        $centerA = new Center();
+        $centerB = new Center();
+
+        $export = $this->prophesize(ExportInterface::class);
+        $filter = $this->prophesize(FilterInterface::class);
+        $filter->applyOn()->willReturn('tagada');
+        $aggregator = $this->prophesize(AggregatorInterface::class);
+        $aggregator->applyOn()->willReturn('tsointsoin');
+        $formatter = $this->prophesize(FormatterInterface::class);
+
+        $query = $this->prophesize(QueryBuilder::class);
+
+        // required methods
+        $export->initiateQuery(
+            ['tagada', 'tsointsoin'],
+            Argument::that(function ($arg) use ($centerB, $centerA) {
+                if (!is_array($arg)) {
+                    return false;
+                }
+                if (2 !== count($arg)) {
+                    return false;
+                }
+
+                foreach ($arg as $item) {
+                    if ([] !== $item['circles']) {
+                        return false;
+                    }
+                    if (!in_array($item['center'], [$centerA, $centerB], true)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            }),
+            ['key' => 'form1'],
+            Argument::that(static fn ($context) => $context instanceof ExportGenerationContext && $context->byUser === $user),
+        )->shouldBeCalled()->willReturn($query->reveal());
+        $export->getResult($query->reveal(), $formExportData, Argument::that(static fn (ExportGenerationContext $context) => $context->byUser === $user))
+            ->shouldBeCalled()->willReturn([['result0' => '0']]);
+        $export->requiredRole()->willReturn('dummy_role');
+
+        $filter->alterQuery($query->reveal(), $formFilterData, Argument::that(static fn (ExportGenerationContext $context) => $context->byUser === $user))
+            ->shouldBeCalled();
+        $aggregator->alterQuery($query->reveal(), $formAggregatorData, Argument::that(static fn (ExportGenerationContext $context) => $context->byUser === $user))
+            ->shouldBeCalled();
+
+        $formatter->generate(
+            [['result0' => '0']],
+            $formatterData,
+            'dummy',
+            $formExportData,
+            ['dummy_filter' => $formFilterData],
+            ['dummy_aggregator' => $formAggregatorData],
+            Argument::that(static fn ($context) => $context instanceof ExportGenerationContext && $context->byUser === $user),
+        )
+            ->shouldBeCalled()
+            ->willReturn(new FormattedExportGeneration('export result', 'text/text'));
+
+        $exportConfigNormalizer = $this->prophesize(ExportConfigNormalizer::class);
+        $exportConfigNormalizer->denormalizeConfig('dummy', $initialData)->willReturn($fullConfig);
+
+        $exportManager = $this->prophesize(ExportManager::class);
+        $exportManager->getExport('dummy')->willReturn($export->reveal());
+        $exportManager->getFilter('dummy_filter')->willReturn($filter->reveal());
+        $exportManager->hasFilter('dummy_filter')->willReturn(true);
+        $exportManager->hasFilter('disabled_filter')->willReturn(true);
+        $exportManager->getAggregator('dummy_aggregator')->willReturn($aggregator->reveal());
+        $exportManager->hasAggregator('dummy_aggregator')->willReturn(true);
+        $exportManager->hasAggregator('disabled_aggregator')->willReturn(true);
+        $exportManager->getFormatter('xlsx')->willReturn($formatter->reveal());
+
+        $authorizationHelper = $this->prophesize(AuthorizationHelperInterface::class);
+        $authorizationHelper->getReachableCenters($user, 'dummy_role')->shouldNotBeCalled();
+
+        $centerRepository = $this->prophesize(CenterRepositoryInterface::class);
+        $centerRepository->findActive()->willReturn([$centerA, $centerB])->shouldBeCalled();
+
+        $generator = new ExportGenerator(
+            $exportManager->reveal(),
+            $exportConfigNormalizer->reveal(),
+            new NullLogger(),
+            $authorizationHelper->reveal(),
+            new CenterRegroupementResolver(),
+            new ExportConfigProcessor($exportManager->reveal()),
+            $this->buildParameter(false),
+            $centerRepository->reveal(),
+        );
+
+        $actual = $generator->generate('dummy', $initialData, $user);
+
+        self::assertEquals('export result', $actual->content);
+        self::assertEquals('text/text', $actual->contentType);
+    }
 }