[#278] Plan du site (!33)

| Numéro du ticket | Titre du ticket |
|------------------|-----------------|
|        #278          |        Plan du site         |

## Description de la PR
[#278] Plan du site

## Modification du .env

## Check list

- [ ] Pas de régression
- [x] TU/TI/TF rédigée
- [x] TU/TI/TF OK
- [ ] CHANGELOG modifié

Co-authored-by: Matteo <matteo@yuno.malio.fr>
Reviewed-on: https://gitea.malio.fr/MALIO-DEV/Ferme/pulls/33
Co-authored-by: tristan <tristan@yuno.malio.fr>
Co-committed-by: tristan <tristan@yuno.malio.fr>
This commit is contained in:
tristan
2026-02-25 14:16:11 +00:00
committed by Autin
parent c52f22472d
commit f263a11fe8
31 changed files with 2828 additions and 31 deletions
+267
View File
@@ -5,8 +5,12 @@ declare(strict_types=1);
namespace App\Command;
use App\Entity\Address;
use App\Entity\Bovine;
use App\Entity\BovineType;
use App\Entity\Building;
use App\Entity\BuildingCase;
use App\Entity\BuildingCasePosition;
use App\Entity\BuildingLayout;
use App\Entity\Carrier;
use App\Entity\Customer;
use App\Entity\Driver;
@@ -14,9 +18,11 @@ use App\Entity\MerchandiseType;
use App\Entity\PelletType;
use App\Entity\ReceptionType;
use App\Entity\ShipmentType;
use App\Entity\Statut;
use App\Entity\Supplier;
use App\Entity\Truck;
use App\Entity\Vehicle;
use DateTimeImmutable;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
@@ -52,6 +58,8 @@ class SeedCommand extends Command
$this->seedMerchandiseTypes();
$this->seedPelletTypes();
$this->seedBuildings();
$this->seedBuildingInfrastructure();
$this->seedBovines($io);
$this->seedReceptionTypes();
$this->seedBovineTypes();
$this->seedShipmentTypes();
@@ -215,6 +223,137 @@ class SeedCommand extends Command
}
}
private function seedBuildingInfrastructure(): void
{
$statusByCode = [];
$statusRows = [
['label' => 'Libre', 'code' => 'LB', 'color' => '#A3B18A'],
['label' => 'Occupé', 'code' => 'OC', 'color' => '#3A506B'],
['label' => 'Malade', 'code' => 'ML', 'color' => '#E07A5F'],
];
foreach ($statusRows as $statusRow) {
/** @var Statut $status */
$status = $this->upsertByCode(Statut::class, $statusRow['code'], static function (Statut $entity) use ($statusRow) {
$entity
->setLabel($statusRow['label'])
->setCode($statusRow['code'])
->setColor($statusRow['color'])
;
});
$statusByCode[$statusRow['code']] = $status;
}
$buildingRepo = $this->entityManager->getRepository(Building::class);
$layoutByBuildingCode = [];
$layoutRows = [
['buildingCode' => 'B1', 'name' => 'plan1', 'columns' => 23, 'rows' => 2],
['buildingCode' => 'B2', 'name' => 'plan2', 'columns' => 23, 'rows' => 2],
['buildingCode' => 'B3', 'name' => 'plan3', 'columns' => 23, 'rows' => 2],
];
foreach ($layoutRows as $layoutRow) {
$building = $buildingRepo->findOneBy(['code' => $layoutRow['buildingCode']]);
if (!$building instanceof Building) {
continue;
}
/** @var BuildingLayout $layout */
$layout = $this->upsertByName(BuildingLayout::class, $layoutRow['name'], static function (BuildingLayout $entity) use ($layoutRow, $building) {
$entity
->setName($layoutRow['name'])
->setColumns($layoutRow['columns'])
->setRows($layoutRow['rows'])
->setIdBuilding($building)
;
});
$layoutByBuildingCode[$layoutRow['buildingCode']] = $layout;
}
$caseRows = [
['buildingCode' => 'B1', 'from' => 1, 'to' => 12, 'status' => 'LB'],
['buildingCode' => 'B1', 'from' => 13, 'to' => 24, 'status' => 'OC'],
['buildingCode' => 'B1', 'from' => 25, 'to' => 32, 'status' => 'ML'],
['buildingCode' => 'B1', 'from' => 33, 'to' => 44, 'status' => 'LB'],
['buildingCode' => 'B2', 'from' => 1, 'to' => 10, 'status' => 'OC'],
['buildingCode' => 'B2', 'from' => 11, 'to' => 22, 'status' => 'LB'],
['buildingCode' => 'B2', 'from' => 23, 'to' => 30, 'status' => 'ML'],
['buildingCode' => 'B2', 'from' => 31, 'to' => 44, 'status' => 'OC'],
['buildingCode' => 'B3', 'from' => 1, 'to' => 8, 'status' => 'ML'],
['buildingCode' => 'B3', 'from' => 9, 'to' => 20, 'status' => 'LB'],
['buildingCode' => 'B3', 'from' => 21, 'to' => 34, 'status' => 'OC'],
['buildingCode' => 'B3', 'from' => 35, 'to' => 44, 'status' => 'ML'],
];
$caseByCode = [];
foreach ($caseRows as $caseRow) {
$building = $buildingRepo->findOneBy(['code' => $caseRow['buildingCode']]);
$status = $statusByCode[$caseRow['status']] ?? null;
if (!$building instanceof Building || !$status instanceof Statut) {
continue;
}
for ($caseNumber = $caseRow['from']; $caseNumber <= $caseRow['to']; ++$caseNumber) {
$code = sprintf('%s-C%d', $caseRow['buildingCode'], $caseNumber);
/** @var BuildingCase $buildingCase */
$buildingCase = $this->upsertByCode(BuildingCase::class, $code, static function (BuildingCase $entity) use ($code, $caseNumber, $building, $status) {
$entity
->setCode($code)
->setCaseNumber($caseNumber)
->setCapacity(15)
->setIdBuilding($building)
->setStatut($status)
;
});
$caseByCode[$code] = $buildingCase;
}
}
$slots = $this->buildSlotMap();
$positionRepo = $this->entityManager->getRepository(BuildingCasePosition::class);
foreach (['B1' => 'plan1', 'B2' => 'plan2', 'B3' => 'plan3'] as $buildingCode => $layoutName) {
$layout = $layoutByBuildingCode[$buildingCode] ?? null;
if (!$layout instanceof BuildingLayout || $layout->getName() !== $layoutName) {
continue;
}
foreach ($slots as $slot) {
$caseCode = sprintf('%s-C%d', $buildingCode, $slot['caseNumber']);
$buildingCase = $caseByCode[$caseCode] ?? null;
if (!$buildingCase instanceof BuildingCase) {
continue;
}
$position = $positionRepo->findOneBy([
'buildingLayout' => $layout,
'buildingCase' => $buildingCase,
'x' => $slot['x'],
'y' => $slot['y'],
]);
if ($position instanceof BuildingCasePosition) {
++$this->updated;
continue;
}
$position = new BuildingCasePosition();
$position
->setX($slot['x'])
->setY($slot['y'])
->setW($slot['w'])
->setH($slot['h'])
->setRenderOrder((string) $slot['renderOrder'])
->setBuildingLayout($layout)
->setBuildingCase($buildingCase)
;
++$this->created;
$this->entityManager->persist($position);
}
}
}
private function seedReceptionTypes(): void
{
$receptionTypes = [
@@ -231,6 +370,134 @@ class SeedCommand extends Command
}
}
private function seedBovines(SymfonyStyle $io): void
{
$rows = [
[1, 15, '7979580026', 390, '2026-02-25'],
[5, 113, '4405604924', 397, '2025-05-22'],
[4, 113, '4405604944', 375, '2025-05-22'],
[2, 113, '4963291114', 319, '2025-05-22'],
[3, 113, '4405604922', 386, '2025-05-22'],
[6, 126, '4415811026', 367, '2025-07-02'],
[7, 126, '4950971149', 398, '2025-07-02'],
[8, 126, '4950971170', 386, '2025-07-02'],
[9, 126, '4489751630', 408, '2025-07-02'],
[10, 126, '8551323003', 478, '2025-07-02'],
[11, 126, '8503833703', 378, '2025-07-02'],
[12, 126, '4402104572', 379, '2025-07-02'],
[13, 126, '4402104580', 465, '2025-07-02'],
[14, 126, '4402104607', 381, '2025-07-02'],
[15, 126, '8504059581', 446, '2025-07-02'],
[16, 124, '4950971161', 382, '2025-07-02'],
[17, 124, '5652911499', 376, '2025-07-02'],
[18, 124, '8551323029', 414, '2025-07-02'],
[19, 124, '4402104590', 474, '2025-07-02'],
[20, 124, '4402104594', 408, '2025-07-02'],
[21, 124, '4402104595', 399, '2025-07-02'],
[22, 124, '4402104604', 374, '2025-07-02'],
[23, 124, '8504059579', 403, '2025-07-02'],
[24, 124, '8504059590', 398, '2025-07-02'],
[25, 123, '8551782070', 395, '2025-07-02'],
[26, 123, '8551782080', 443, '2025-07-02'],
[27, 123, '8551782084', 394, '2025-07-02'],
[28, 123, '8551782090', 378, '2025-07-02'],
[29, 123, '8551782092', 424, '2025-07-02'],
[30, 123, '8551782094', 389, '2025-07-02'],
[31, 123, '8551782099', 411, '2025-07-02'],
[32, 123, '8551323020', 392, '2025-07-02'],
[33, 123, '8551323051', 371, '2025-07-02'],
[34, 123, '7947673148', 378, '2025-07-02'],
[39, 114, '1731177447', 395, '2025-06-19'],
[42, 114, '1726167608', 299, '2025-06-19'],
[38, 114, '1731177442', 343, '2025-06-19'],
[40, 114, '1731177448', 362, '2025-06-19'],
[41, 114, '1731177458', 359, '2025-06-19'],
[35, 114, '7946282100', 291, '2025-06-19'],
[43, 114, '1726167613', 339, '2025-06-19'],
[37, 114, '1731177427', 375, '2025-06-19'],
[36, 114, '7946282103', 354, '2025-06-19'],
];
$bovineRepo = $this->entityManager->getRepository(Bovine::class);
$caseRepo = $this->entityManager->getRepository(BuildingCase::class);
foreach ($rows as [, $legacyCaseId, $nationalNumber, $receivedWeight, $arrivalDate]) {
$buildingCase = $this->resolveBuildingCaseByLegacyId((int) $legacyCaseId);
if (!$buildingCase instanceof BuildingCase) {
$buildingCase = $caseRepo->find((int) $legacyCaseId);
}
if (!$buildingCase instanceof BuildingCase) {
$io->warning(sprintf(
'Bovine %s skipped: building_case token %d not found.',
$nationalNumber,
$legacyCaseId
));
continue;
}
$bovine = $bovineRepo->findOneBy(['nationalNumber' => $nationalNumber]);
if (!$bovine instanceof Bovine) {
$bovine = new Bovine();
++$this->created;
} else {
++$this->updated;
}
$bovine
->setNationalNumber((string) $nationalNumber)
->setBuildingCase($buildingCase)
->setReceivedWeight((int) $receivedWeight)
->setArrivalDate(new DateTimeImmutable((string) $arrivalDate))
;
$this->entityManager->persist($bovine);
}
}
/**
* @return array<int, array{x:int,y:int,w:int,h:int,renderOrder:int,caseNumber:int}>
*/
private function buildSlotMap(): array
{
$slots = [];
for ($column = 1; $column <= 12; ++$column) {
$slots[] = ['x' => $column, 'y' => 1, 'w' => 1, 'h' => 1, 'renderOrder' => $column, 'caseNumber' => $column + 12];
}
for ($column = 14; $column <= 23; ++$column) {
$slots[] = ['x' => $column, 'y' => 1, 'w' => 1, 'h' => 1, 'renderOrder' => $column - 1, 'caseNumber' => $column + 11];
}
for ($column = 1; $column <= 12; ++$column) {
$slots[] = ['x' => $column, 'y' => 2, 'w' => 1, 'h' => 1, 'renderOrder' => 22 + $column, 'caseNumber' => 13 - $column];
}
for ($column = 14; $column <= 23; ++$column) {
$slots[] = ['x' => $column, 'y' => 2, 'w' => 1, 'h' => 1, 'renderOrder' => 21 + $column, 'caseNumber' => 58 - $column];
}
return $slots;
}
private function resolveBuildingCaseByLegacyId(int $legacyCaseId): ?BuildingCase
{
if ($legacyCaseId < 1) {
return null;
}
$buildingNumber = intdiv($legacyCaseId - 1, 44) + 1;
$caseNumber = (($legacyCaseId - 1) % 44) + 1;
if ($buildingNumber < 1 || $buildingNumber > 3) {
return null;
}
$code = sprintf('B%d-C%d', $buildingNumber, $caseNumber);
$buildingCase = $this->entityManager->getRepository(BuildingCase::class)->findOneBy(['code' => $code]);
return $buildingCase instanceof BuildingCase ? $buildingCase : null;
}
private function seedBovineTypes(): void
{
$bovineTypes = [
+2
View File
@@ -20,6 +20,8 @@ class AppFixtures extends Fixture implements DependentFixtureInterface
return [
TransportFixtures::class,
ReferenceFixtures::class,
BuildingInfrastructureFixtures::class,
BovineFixtures::class,
UserFixtures::class,
];
}
+120
View File
@@ -0,0 +1,120 @@
<?php
declare(strict_types=1);
namespace App\DataFixtures;
use App\Entity\Bovine;
use App\Entity\BuildingCase;
use DateTimeImmutable;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Common\DataFixtures\DependentFixtureInterface;
use Doctrine\Persistence\ObjectManager;
class BovineFixtures extends Fixture implements DependentFixtureInterface
{
public function load(ObjectManager $manager): void
{
$rows = [
[1, 15, '7979580026', 390, '2026-02-25'],
[5, 113, '4405604924', 397, '2025-05-22'],
[4, 113, '4405604944', 375, '2025-05-22'],
[2, 113, '4963291114', 319, '2025-05-22'],
[3, 113, '4405604922', 386, '2025-05-22'],
[6, 126, '4415811026', 367, '2025-07-02'],
[7, 126, '4950971149', 398, '2025-07-02'],
[8, 126, '4950971170', 386, '2025-07-02'],
[9, 126, '4489751630', 408, '2025-07-02'],
[10, 126, '8551323003', 478, '2025-07-02'],
[11, 126, '8503833703', 378, '2025-07-02'],
[12, 126, '4402104572', 379, '2025-07-02'],
[13, 126, '4402104580', 465, '2025-07-02'],
[14, 126, '4402104607', 381, '2025-07-02'],
[15, 126, '8504059581', 446, '2025-07-02'],
[16, 124, '4950971161', 382, '2025-07-02'],
[17, 124, '5652911499', 376, '2025-07-02'],
[18, 124, '8551323029', 414, '2025-07-02'],
[19, 124, '4402104590', 474, '2025-07-02'],
[20, 124, '4402104594', 408, '2025-07-02'],
[21, 124, '4402104595', 399, '2025-07-02'],
[22, 124, '4402104604', 374, '2025-07-02'],
[23, 124, '8504059579', 403, '2025-07-02'],
[24, 124, '8504059590', 398, '2025-07-02'],
[25, 123, '8551782070', 395, '2025-07-02'],
[26, 123, '8551782080', 443, '2025-07-02'],
[27, 123, '8551782084', 394, '2025-07-02'],
[28, 123, '8551782090', 378, '2025-07-02'],
[29, 123, '8551782092', 424, '2025-07-02'],
[30, 123, '8551782094', 389, '2025-07-02'],
[31, 123, '8551782099', 411, '2025-07-02'],
[32, 123, '8551323020', 392, '2025-07-02'],
[33, 123, '8551323051', 371, '2025-07-02'],
[34, 123, '7947673148', 378, '2025-07-02'],
[39, 114, '1731177447', 395, '2025-06-19'],
[42, 114, '1726167608', 299, '2025-06-19'],
[38, 114, '1731177442', 343, '2025-06-19'],
[40, 114, '1731177448', 362, '2025-06-19'],
[41, 114, '1731177458', 359, '2025-06-19'],
[35, 114, '7946282100', 291, '2025-06-19'],
[43, 114, '1726167613', 339, '2025-06-19'],
[37, 114, '1731177427', 375, '2025-06-19'],
[36, 114, '7946282103', 354, '2025-06-19'],
];
$bovineRepository = $manager->getRepository(Bovine::class);
$caseRepository = $manager->getRepository(BuildingCase::class);
foreach ($rows as [, $legacyCaseId, $nationalNumber, $receivedWeight, $arrivalDate]) {
$buildingCase = $this->resolveBuildingCaseByLegacyId($manager, (int) $legacyCaseId);
if (!$buildingCase instanceof BuildingCase) {
$buildingCase = $caseRepository->find((int) $legacyCaseId);
}
if (!$buildingCase instanceof BuildingCase) {
continue;
}
/** @var null|Bovine $bovine */
$bovine = $bovineRepository->findOneBy(['nationalNumber' => (string) $nationalNumber]);
if (!$bovine instanceof Bovine) {
$bovine = new Bovine();
}
$bovine
->setNationalNumber((string) $nationalNumber)
->setBuildingCase($buildingCase)
->setReceivedWeight((int) $receivedWeight)
->setArrivalDate(new DateTimeImmutable((string) $arrivalDate))
;
$manager->persist($bovine);
}
$manager->flush();
}
public function getDependencies(): array
{
return [
BuildingInfrastructureFixtures::class,
];
}
private function resolveBuildingCaseByLegacyId(ObjectManager $manager, int $legacyCaseId): ?BuildingCase
{
if ($legacyCaseId < 1) {
return null;
}
$buildingNumber = intdiv($legacyCaseId - 1, 44) + 1;
$caseNumber = (($legacyCaseId - 1) % 44) + 1;
if ($buildingNumber < 1 || $buildingNumber > 3) {
return null;
}
$code = sprintf('B%d-C%d', $buildingNumber, $caseNumber);
$buildingCase = $manager->getRepository(BuildingCase::class)->findOneBy(['code' => $code]);
return $buildingCase instanceof BuildingCase ? $buildingCase : null;
}
}
@@ -0,0 +1,299 @@
<?php
declare(strict_types=1);
namespace App\DataFixtures;
use App\Entity\Building;
use App\Entity\BuildingCase;
use App\Entity\BuildingCasePosition;
use App\Entity\BuildingLayout;
use App\Entity\Statut;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Common\DataFixtures\DependentFixtureInterface;
use Doctrine\Persistence\ObjectManager;
use RuntimeException;
class BuildingInfrastructureFixtures extends Fixture implements DependentFixtureInterface
{
public function load(ObjectManager $manager): void
{
$statuts = $this->loadStatuts($manager);
$buildings = $this->getBuildingsByCode($manager, ['B1', 'B2', 'B3']);
$layouts = $this->loadLayouts($manager, $buildings);
$cases = $this->loadBuildingCases($manager, $buildings, $statuts);
$this->loadCasePositions($manager, $layouts, $cases);
$manager->flush();
}
public function getDependencies(): array
{
return [
ReferenceFixtures::class,
];
}
/**
* @return array<string, Statut>
*/
private function loadStatuts(ObjectManager $manager): array
{
$repo = $manager->getRepository(Statut::class);
$data = [
['label' => 'Libre', 'code' => 'LB', 'color' => '#A3B18A'],
['label' => 'Occupé', 'code' => 'OC', 'color' => '#3A506B'],
['label' => 'Malade', 'code' => 'ML', 'color' => '#E07A5F'],
];
$result = [];
foreach ($data as $row) {
/** @var null|Statut $statut */
$statut = $repo->findOneBy(['code' => $row['code']]);
if (!$statut instanceof Statut) {
$statut = new Statut()
->setLabel($row['label'])
->setCode($row['code'])
->setColor($row['color'])
;
$manager->persist($statut);
}
$result[$row['code']] = $statut;
}
return $result;
}
/**
* @param list<string> $codes
*
* @return array<string, Building>
*/
private function getBuildingsByCode(ObjectManager $manager, array $codes): array
{
$repo = $manager->getRepository(Building::class);
$result = [];
foreach ($codes as $code) {
/** @var null|Building $building */
$building = $repo->findOneBy(['code' => $code]);
if (!$building instanceof Building) {
throw new RuntimeException(sprintf('Building "%s" not found. Load ReferenceFixtures first.', $code));
}
$result[$code] = $building;
}
return $result;
}
/**
* @param array<string, Building> $buildings
*
* @return array<string, BuildingLayout>
*/
private function loadLayouts(ObjectManager $manager, array $buildings): array
{
$repo = $manager->getRepository(BuildingLayout::class);
$data = [
['name' => 'plan1', 'columns' => 23, 'rows' => 2, 'buildingCode' => 'B1'],
['name' => 'plan2', 'columns' => 23, 'rows' => 2, 'buildingCode' => 'B2'],
['name' => 'plan3', 'columns' => 23, 'rows' => 2, 'buildingCode' => 'B3'],
];
$result = [];
foreach ($data as $row) {
/** @var null|BuildingLayout $layout */
$layout = $repo->findOneBy(['name' => $row['name']]);
if (!$layout instanceof BuildingLayout) {
$layout = new BuildingLayout()
->setName($row['name'])
->setColumns($row['columns'])
->setRows($row['rows'])
->setIdBuilding($buildings[$row['buildingCode']])
;
$manager->persist($layout);
}
$result[$row['buildingCode']] = $layout;
}
return $result;
}
/**
* @param array<string, Building> $buildings
* @param array<string, Statut> $statuts
*
* @return array<string, BuildingCase>
*/
private function loadBuildingCases(ObjectManager $manager, array $buildings, array $statuts): array
{
$repo = $manager->getRepository(BuildingCase::class);
$statusRanges = [
// B1
['buildingCode' => 'B1', 'from' => 1, 'to' => 12, 'statut' => 'LB'],
['buildingCode' => 'B1', 'from' => 13, 'to' => 24, 'statut' => 'OC'],
['buildingCode' => 'B1', 'from' => 25, 'to' => 32, 'statut' => 'ML'],
['buildingCode' => 'B1', 'from' => 33, 'to' => 44, 'statut' => 'LB'],
// B2
['buildingCode' => 'B2', 'from' => 1, 'to' => 10, 'statut' => 'OC'],
['buildingCode' => 'B2', 'from' => 11, 'to' => 22, 'statut' => 'LB'],
['buildingCode' => 'B2', 'from' => 23, 'to' => 30, 'statut' => 'ML'],
['buildingCode' => 'B2', 'from' => 31, 'to' => 44, 'statut' => 'OC'],
// B3
['buildingCode' => 'B3', 'from' => 1, 'to' => 8, 'statut' => 'ML'],
['buildingCode' => 'B3', 'from' => 9, 'to' => 20, 'statut' => 'LB'],
['buildingCode' => 'B3', 'from' => 21, 'to' => 34, 'statut' => 'OC'],
['buildingCode' => 'B3', 'from' => 35, 'to' => 44, 'statut' => 'ML'],
];
$result = [];
foreach ($statusRanges as $range) {
for ($caseNumber = $range['from']; $caseNumber <= $range['to']; ++$caseNumber) {
$code = sprintf('%s-C%d', $range['buildingCode'], $caseNumber);
if (isset($result[$code])) {
continue;
}
/** @var null|BuildingCase $buildingCase */
$buildingCase = $repo->findOneBy(['code' => $code]);
if (!$buildingCase instanceof BuildingCase) {
$buildingCase = new BuildingCase()
->setCaseNumber($caseNumber)
->setCode($code)
->setCapacity(15)
->setIdBuilding($buildings[$range['buildingCode']])
->setStatut($statuts[$range['statut']])
;
$manager->persist($buildingCase);
}
$result[$code] = $buildingCase;
}
}
return $result;
}
/**
* @param array<string, BuildingLayout> $layouts
* @param array<string, BuildingCase> $casesByCode
*/
private function loadCasePositions(ObjectManager $manager, array $layouts, array $casesByCode): void
{
$repo = $manager->getRepository(BuildingCasePosition::class);
$layoutMap = [
'B1' => 'plan1',
'B2' => 'plan2',
'B3' => 'plan3',
];
$slots = $this->buildSlotMap();
foreach ($layoutMap as $buildingCode => $layoutName) {
$layout = $layouts[$buildingCode] ?? null;
if (!$layout instanceof BuildingLayout || $layout->getName() !== $layoutName) {
throw new RuntimeException(sprintf('Layout "%s" for building "%s" not found.', $layoutName, $buildingCode));
}
foreach ($slots as $slot) {
$caseCode = sprintf('%s-C%d', $buildingCode, $slot['caseNumber']);
$buildingCase = $casesByCode[$caseCode] ?? null;
if (!$buildingCase instanceof BuildingCase) {
throw new RuntimeException(sprintf('Building case "%s" not found.', $caseCode));
}
/** @var null|BuildingCasePosition $position */
$position = $repo->findOneBy([
'buildingLayout' => $layout,
'buildingCase' => $buildingCase,
'x' => $slot['x'],
'y' => $slot['y'],
]);
if ($position instanceof BuildingCasePosition) {
continue;
}
$position = new BuildingCasePosition()
->setX($slot['x'])
->setY($slot['y'])
->setW($slot['w'])
->setH($slot['h'])
->setRenderOrder((string) $slot['renderOrder'])
->setBuildingLayout($layout)
->setBuildingCase($buildingCase)
;
$manager->persist($position);
}
}
}
/**
* Reproduit le slot_map SQL (44 emplacements sur 2 lignes avec un gap en colonne 13).
*
* @return list<array{x:int,y:int,w:int,h:int,renderOrder:int,caseNumber:int}>
*/
private function buildSlotMap(): array
{
$slots = [];
// Ligne 1, colonnes 1..12 => cases 13..24
for ($c = 1; $c <= 12; ++$c) {
$slots[] = [
'x' => $c,
'y' => 1,
'w' => 1,
'h' => 1,
'renderOrder' => $c,
'caseNumber' => $c + 12,
];
}
// Ligne 1, colonnes 14..23 => cases 25..34
for ($c = 14; $c <= 23; ++$c) {
$slots[] = [
'x' => $c,
'y' => 1,
'w' => 1,
'h' => 1,
'renderOrder' => $c - 1,
'caseNumber' => $c + 11,
];
}
// Ligne 2, colonnes 1..12 => cases 12..1
for ($c = 1; $c <= 12; ++$c) {
$slots[] = [
'x' => $c,
'y' => 2,
'w' => 1,
'h' => 1,
'renderOrder' => 22 + $c,
'caseNumber' => 13 - $c,
];
}
// Ligne 2, colonnes 14..23 => cases 44..35
for ($c = 14; $c <= 23; ++$c) {
$slots[] = [
'x' => $c,
'y' => 2,
'w' => 1,
'h' => 1,
'renderOrder' => 21 + $c,
'caseNumber' => 58 - $c,
];
}
return $slots;
}
}
+121
View File
@@ -0,0 +1,121 @@
<?php
declare(strict_types=1);
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Patch;
use ApiPlatform\Metadata\Post;
use DateTimeImmutable;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Attribute\Context;
use Symfony\Component\Serializer\Attribute\Groups;
use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
#[ORM\Entity]
#[ORM\Table(name: 'bovine')]
#[ORM\UniqueConstraint(name: 'uniq_bovine_national_number', columns: ['national_number'])]
#[ApiResource(
operations: [
new Get(
requirements: ['id' => '\d+'],
normalizationContext: ['groups' => ['bovine:read']],
),
new GetCollection(
normalizationContext: ['groups' => ['bovine:read']],
),
new Post(
normalizationContext: ['groups' => ['bovine:read']],
denormalizationContext: ['groups' => ['bovine:write']],
security: "is_granted('ROLE_ADMIN')",
),
new Patch(
requirements: ['id' => '\d+'],
normalizationContext: ['groups' => ['bovine:read']],
denormalizationContext: ['groups' => ['bovine:write']],
security: "is_granted('ROLE_ADMIN')",
),
],
security: "is_granted('ROLE_USER')",
)]
class Bovine
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['bovine:read'])]
private ?int $id = null;
#[ORM\Column(length: 50)]
#[Groups(['bovine:read', 'bovine:write'])]
private string $nationalNumber = '';
#[ORM\Column(nullable: true)]
#[Groups(['bovine:read', 'bovine:write'])]
private ?int $receivedWeight = null;
#[ORM\Column(type: 'date_immutable', nullable: true)]
#[Groups(['bovine:read', 'bovine:write'])]
#[Context([DateTimeNormalizer::FORMAT_KEY => 'Y-m-d'])]
private ?DateTimeImmutable $arrivalDate = null;
#[ORM\ManyToOne(inversedBy: 'bovines')]
#[Groups(['bovine:read', 'bovine:write'])]
private ?BuildingCase $buildingCase = null;
public function getId(): ?int
{
return $this->id;
}
public function getNationalNumber(): string
{
return $this->nationalNumber;
}
public function setNationalNumber(string $nationalNumber): static
{
$this->nationalNumber = $nationalNumber;
return $this;
}
public function getReceivedWeight(): ?int
{
return $this->receivedWeight;
}
public function setReceivedWeight(?int $receivedWeight): static
{
$this->receivedWeight = $receivedWeight;
return $this;
}
public function getArrivalDate(): ?DateTimeImmutable
{
return $this->arrivalDate;
}
public function setArrivalDate(?DateTimeImmutable $arrivalDate): static
{
$this->arrivalDate = $arrivalDate;
return $this;
}
public function getBuildingCase(): ?BuildingCase
{
return $this->buildingCase;
}
public function setBuildingCase(?BuildingCase $buildingCase): static
{
$this->buildingCase = $buildingCase;
return $this;
}
}
+55 -1
View File
@@ -11,6 +11,7 @@ use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Attribute\Groups;
use Symfony\Component\Serializer\Attribute\SerializedName;
#[ORM\Entity]
#[ORM\Table(name: 'building')]
@@ -48,9 +49,25 @@ class Building
#[ORM\ManyToMany(targetEntity: Reception::class, mappedBy: 'buildings')]
private Collection $receptions;
/**
* @var Collection<int, BuildingCase>
*/
#[ORM\OneToMany(targetEntity: BuildingCase::class, mappedBy: 'id_building')]
private Collection $buildingCases;
/**
* @var Collection<int, BuildingLayout>
*/
#[ORM\OneToMany(targetEntity: BuildingLayout::class, mappedBy: 'id_building')]
#[Groups(['building:read'])]
#[SerializedName('layouts')]
private Collection $buildingLayout;
public function __construct()
{
$this->receptions = new ArrayCollection();
$this->receptions = new ArrayCollection();
$this->buildingCases = new ArrayCollection();
$this->buildingLayout = new ArrayCollection();
}
public function getId(): ?int
@@ -89,4 +106,41 @@ class Building
{
return $this->receptions;
}
/**
* @return Collection<int, BuildingCase>
*/
public function getBuildingCases(): Collection
{
return $this->buildingCases;
}
public function addBuildingCase(BuildingCase $buildingCase): static
{
if (!$this->buildingCases->contains($buildingCase)) {
$this->buildingCases->add($buildingCase);
$buildingCase->setIdBuilding($this);
}
return $this;
}
public function removeBuildingCase(BuildingCase $buildingCase): static
{
if ($this->buildingCases->removeElement($buildingCase)) {
if ($buildingCase->getIdBuilding() === $this) {
$buildingCase->setIdBuilding(null);
}
}
return $this;
}
/**
* @return Collection<int, BuildingLayout>
*/
public function getBuildingLayout(): Collection
{
return $this->buildingLayout;
}
}
+210
View File
@@ -0,0 +1,210 @@
<?php
declare(strict_types=1);
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\OpenApi\Model\Operation as OpenApiOperation;
use App\Repository\BuildingCaseRepository;
use App\State\BuildingCaseWeightsReportProvider;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Attribute\Groups;
use Symfony\Component\Serializer\Attribute\SerializedName;
#[ORM\Entity(repositoryClass: BuildingCaseRepository::class)]
#[ApiResource(
operations: [
new Get(
uriTemplate: '/building_cases/{id}/weights-report',
requirements: ['id' => '\d+'],
openapi: new OpenApiOperation(
summary: 'Render case weights report',
description: 'Returns a PDF report of bovines stored in the selected case.',
),
output: false,
provider: BuildingCaseWeightsReportProvider::class,
),
],
security: "is_granted('ROLE_USER')",
)]
class BuildingCase
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $id = null;
#[ORM\Column]
#[Groups(['building:read'])]
#[SerializedName('caseNumber')]
private ?int $case_number = null;
#[ORM\Column(length: 255)]
#[Groups(['building:read'])]
private ?string $code = null;
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $capacity = null;
/**
* @var Collection<int, BuildingCasePosition>
*/
#[ORM\OneToMany(targetEntity: BuildingCasePosition::class, mappedBy: 'buildingCase')]
private Collection $id_case_position;
#[ORM\ManyToOne(inversedBy: 'buildingCases')]
private ?Building $id_building = null;
#[ORM\ManyToOne(inversedBy: 'id_case')]
#[Groups(['building:read'])]
private ?Statut $statut = null;
/**
* @var Collection<int, Bovine>
*/
#[ORM\OneToMany(targetEntity: Bovine::class, mappedBy: 'buildingCase')]
private Collection $bovines;
public function __construct()
{
$this->id_case_position = new ArrayCollection();
$this->bovines = new ArrayCollection();
}
public function getId(): ?int
{
return $this->id;
}
public function setId(int $id): static
{
$this->id = $id;
return $this;
}
public function getCaseNumber(): ?int
{
return $this->case_number;
}
public function setCaseNumber(int $case_number): static
{
$this->case_number = $case_number;
return $this;
}
public function getCode(): ?string
{
return $this->code;
}
public function setCode(string $code): static
{
$this->code = $code;
return $this;
}
public function getCapacity(): ?int
{
return $this->capacity;
}
public function setCapacity(int $capacity): static
{
$this->capacity = $capacity;
return $this;
}
/**
* @return Collection<int, BuildingCasePosition>
*/
public function getIdCasePosition(): Collection
{
return $this->id_case_position;
}
public function addIdCasePosition(BuildingCasePosition $idCasePosition): static
{
if (!$this->id_case_position->contains($idCasePosition)) {
$this->id_case_position->add($idCasePosition);
$idCasePosition->setBuildingCase($this);
}
return $this;
}
public function removeIdCasePosition(BuildingCasePosition $idCasePosition): static
{
if ($this->id_case_position->removeElement($idCasePosition)) {
// set the owning side to null (unless already changed)
if ($idCasePosition->getBuildingCase() === $this) {
$idCasePosition->setBuildingCase(null);
}
}
return $this;
}
public function getIdBuilding(): ?Building
{
return $this->id_building;
}
public function setIdBuilding(?Building $id_building): static
{
$this->id_building = $id_building;
return $this;
}
public function getStatut(): ?Statut
{
return $this->statut;
}
public function setStatut(?Statut $statut): static
{
$this->statut = $statut;
return $this;
}
/**
* @return Collection<int, Bovine>
*/
public function getBovines(): Collection
{
return $this->bovines;
}
public function addBovine(Bovine $bovine): static
{
if (!$this->bovines->contains($bovine)) {
$this->bovines->add($bovine);
$bovine->setBuildingCase($this);
}
return $this;
}
public function removeBovine(Bovine $bovine): static
{
if ($this->bovines->removeElement($bovine)) {
if ($bovine->getBuildingCase() === $this) {
$bovine->setBuildingCase(null);
}
}
return $this;
}
}
+146
View File
@@ -0,0 +1,146 @@
<?php
declare(strict_types=1);
namespace App\Entity;
use App\Repository\BuildingCasePositionRepository;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Attribute\Groups;
use Symfony\Component\Serializer\Attribute\SerializedName;
#[ORM\Entity(repositoryClass: BuildingCasePositionRepository::class)]
class BuildingCasePosition
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $id = null;
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $x = null;
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $y = null;
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $w = null;
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $h = null;
#[ORM\Column(length: 255)]
#[Groups(['building:read'])]
#[SerializedName('renderOrder')]
private ?string $render_order = null;
#[ORM\ManyToOne(inversedBy: 'id_case_position')]
#[ORM\JoinColumn(nullable: false)]
private ?BuildingLayout $buildingLayout = null;
#[ORM\ManyToOne(inversedBy: 'id_case_position')]
#[ORM\JoinColumn(nullable: false)]
#[Groups(['building:read'])]
private ?BuildingCase $buildingCase = null;
public function getId(): ?int
{
return $this->id;
}
public function setId(int $id): static
{
$this->id = $id;
return $this;
}
public function getX(): ?int
{
return $this->x;
}
public function setX(int $x): static
{
$this->x = $x;
return $this;
}
public function getY(): ?int
{
return $this->y;
}
public function setY(int $y): static
{
$this->y = $y;
return $this;
}
public function getW(): ?int
{
return $this->w;
}
public function setW(int $w): static
{
$this->w = $w;
return $this;
}
public function getH(): ?int
{
return $this->h;
}
public function setH(int $h): static
{
$this->h = $h;
return $this;
}
public function getRenderOrder(): ?string
{
return $this->render_order;
}
public function setRenderOrder(string $render_order): static
{
$this->render_order = $render_order;
return $this;
}
public function getBuildingLayout(): ?BuildingLayout
{
return $this->buildingLayout;
}
public function setBuildingLayout(?BuildingLayout $buildingLayout): static
{
$this->buildingLayout = $buildingLayout;
return $this;
}
public function getBuildingCase(): ?BuildingCase
{
return $this->buildingCase;
}
public function setBuildingCase(?BuildingCase $buildingCase): static
{
$this->buildingCase = $buildingCase;
return $this;
}
}
+141
View File
@@ -0,0 +1,141 @@
<?php
declare(strict_types=1);
namespace App\Entity;
use App\Repository\BuildingLayoutRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Attribute\Groups;
use Symfony\Component\Serializer\Attribute\SerializedName;
#[ORM\Entity(repositoryClass: BuildingLayoutRepository::class)]
class BuildingLayout
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $id = null;
#[ORM\Column(length: 255)]
#[Groups(['building:read'])]
private ?string $name = null;
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $columns = null;
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $rows = null;
#[ORM\ManyToOne(inversedBy: 'buildingLayout')]
#[ORM\JoinColumn(nullable: false)]
private ?Building $id_building = null;
/**
* @var Collection<int, BuildingCasePosition>
*/
#[ORM\OneToMany(targetEntity: BuildingCasePosition::class, mappedBy: 'buildingLayout')]
#[Groups(['building:read'])]
#[SerializedName('casePositions')]
private Collection $id_case_position;
public function __construct()
{
$this->id_case_position = new ArrayCollection();
}
public function getId(): ?int
{
return $this->id;
}
public function setId(int $id): static
{
$this->id = $id;
return $this;
}
public function getName(): ?string
{
return $this->name;
}
public function setName(string $name): static
{
$this->name = $name;
return $this;
}
public function getColumns(): ?int
{
return $this->columns;
}
public function setColumns(int $columns): static
{
$this->columns = $columns;
return $this;
}
public function getRows(): ?int
{
return $this->rows;
}
public function setRows(int $rows): static
{
$this->rows = $rows;
return $this;
}
public function getIdBuilding(): ?Building
{
return $this->id_building;
}
public function setIdBuilding(?Building $id_building): static
{
$this->id_building = $id_building;
return $this;
}
/**
* @return Collection<int, BuildingCasePosition>
*/
public function getIdCasePosition(): Collection
{
return $this->id_case_position;
}
public function addIdCasePosition(BuildingCasePosition $idCasePosition): static
{
if (!$this->id_case_position->contains($idCasePosition)) {
$this->id_case_position->add($idCasePosition);
$idCasePosition->setBuildingLayout($this);
}
return $this;
}
public function removeIdCasePosition(BuildingCasePosition $idCasePosition): static
{
if ($this->id_case_position->removeElement($idCasePosition)) {
// set the owning side to null (unless already changed)
if ($idCasePosition->getBuildingLayout() === $this) {
$idCasePosition->setBuildingLayout(null);
}
}
return $this;
}
}
+139
View File
@@ -0,0 +1,139 @@
<?php
declare(strict_types=1);
namespace App\Entity;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use App\Repository\StatutRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Attribute\Groups;
use Symfony\Component\Serializer\Attribute\SerializedName;
#[ORM\Entity(repositoryClass: StatutRepository::class)]
#[ApiResource(
operations: [
new Get(
requirements: ['id' => '\d+'],
normalizationContext: ['groups' => ['building:read']],
),
new GetCollection(
normalizationContext: ['groups' => ['building:read']],
),
],
security: "is_granted('ROLE_USER')",
)]
class Statut
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['building:read'])]
private ?int $id = null;
#[ORM\Column(length: 255)]
#[Groups(['building:read'])]
private ?string $label = null;
#[ORM\Column(length: 255)]
#[Groups(['building:read'])]
private ?string $code = null;
#[ORM\Column(length: 255)]
#[Groups(['building:read'])]
#[SerializedName('couleur')]
private ?string $color = null;
/**
* @var Collection<int, BuildingCase>
*/
#[ORM\OneToMany(targetEntity: BuildingCase::class, mappedBy: 'statut')]
private Collection $id_case;
public function __construct()
{
$this->id_case = new ArrayCollection();
}
public function getId(): ?int
{
return $this->id;
}
public function setId(int $id): static
{
$this->id = $id;
return $this;
}
public function getLabel(): ?string
{
return $this->label;
}
public function setLabel(string $label): static
{
$this->label = $label;
return $this;
}
public function getCode(): ?string
{
return $this->code;
}
public function setCode(string $code): static
{
$this->code = $code;
return $this;
}
public function getColor(): ?string
{
return $this->color;
}
public function setColor(string $color): static
{
$this->color = $color;
return $this;
}
/**
* @return Collection<int, BuildingCase>
*/
public function getIdCase(): Collection
{
return $this->id_case;
}
public function addIdCase(BuildingCase $idCase): static
{
if (!$this->id_case->contains($idCase)) {
$this->id_case->add($idCase);
$idCase->setStatut($this);
}
return $this;
}
public function removeIdCase(BuildingCase $idCase): static
{
if ($this->id_case->removeElement($idCase)) {
// set the owning side to null (unless already changed)
if ($idCase->getStatut() === $this) {
$idCase->setStatut(null);
}
}
return $this;
}
}
@@ -0,0 +1,45 @@
<?php
declare(strict_types=1);
namespace App\Repository;
use App\Entity\BuildingCasePosition;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
/**
* @extends ServiceEntityRepository<BuildingCasePosition>
*/
class BuildingCasePositionRepository extends ServiceEntityRepository
{
public function __construct(ManagerRegistry $registry)
{
parent::__construct($registry, BuildingCasePosition::class);
}
// /**
// * @return BuildingCasePosition[] Returns an array of BuildingCasePosition objects
// */
// public function findByExampleField($value): array
// {
// return $this->createQueryBuilder('b')
// ->andWhere('b.exampleField = :val')
// ->setParameter('val', $value)
// ->orderBy('b.id', 'ASC')
// ->setMaxResults(10)
// ->getQuery()
// ->getResult()
// ;
// }
// public function findOneBySomeField($value): ?BuildingCasePosition
// {
// return $this->createQueryBuilder('b')
// ->andWhere('b.exampleField = :val')
// ->setParameter('val', $value)
// ->getQuery()
// ->getOneOrNullResult()
// ;
// }
}
+45
View File
@@ -0,0 +1,45 @@
<?php
declare(strict_types=1);
namespace App\Repository;
use App\Entity\BuildingCase;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
/**
* @extends ServiceEntityRepository<BuildingCase>
*/
class BuildingCaseRepository extends ServiceEntityRepository
{
public function __construct(ManagerRegistry $registry)
{
parent::__construct($registry, BuildingCase::class);
}
// /**
// * @return BuildingCase[] Returns an array of BuildingCase objects
// */
// public function findByExampleField($value): array
// {
// return $this->createQueryBuilder('b')
// ->andWhere('b.exampleField = :val')
// ->setParameter('val', $value)
// ->orderBy('b.id', 'ASC')
// ->setMaxResults(10)
// ->getQuery()
// ->getResult()
// ;
// }
// public function findOneBySomeField($value): ?BuildingCase
// {
// return $this->createQueryBuilder('b')
// ->andWhere('b.exampleField = :val')
// ->setParameter('val', $value)
// ->getQuery()
// ->getOneOrNullResult()
// ;
// }
}
@@ -0,0 +1,45 @@
<?php
declare(strict_types=1);
namespace App\Repository;
use App\Entity\BuildingLayout;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
/**
* @extends ServiceEntityRepository<BuildingLayout>
*/
class BuildingLayoutRepository extends ServiceEntityRepository
{
public function __construct(ManagerRegistry $registry)
{
parent::__construct($registry, BuildingLayout::class);
}
// /**
// * @return BuildingLayout[] Returns an array of BuildingLayout objects
// */
// public function findByExampleField($value): array
// {
// return $this->createQueryBuilder('b')
// ->andWhere('b.exampleField = :val')
// ->setParameter('val', $value)
// ->orderBy('b.id', 'ASC')
// ->setMaxResults(10)
// ->getQuery()
// ->getResult()
// ;
// }
// public function findOneBySomeField($value): ?BuildingLayout
// {
// return $this->createQueryBuilder('b')
// ->andWhere('b.exampleField = :val')
// ->setParameter('val', $value)
// ->getQuery()
// ->getOneOrNullResult()
// ;
// }
}
+45
View File
@@ -0,0 +1,45 @@
<?php
declare(strict_types=1);
namespace App\Repository;
use App\Entity\Statut;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
/**
* @extends ServiceEntityRepository<Statut>
*/
class StatutRepository extends ServiceEntityRepository
{
public function __construct(ManagerRegistry $registry)
{
parent::__construct($registry, Statut::class);
}
// /**
// * @return Statut[] Returns an array of Statut objects
// */
// public function findByExampleField($value): array
// {
// return $this->createQueryBuilder('s')
// ->andWhere('s.exampleField = :val')
// ->setParameter('val', $value)
// ->orderBy('s.id', 'ASC')
// ->setMaxResults(10)
// ->getQuery()
// ->getResult()
// ;
// }
// public function findOneBySomeField($value): ?Statut
// {
// return $this->createQueryBuilder('s')
// ->andWhere('s.exampleField = :val')
// ->setParameter('val', $value)
// ->getQuery()
// ->getOneOrNullResult()
// ;
// }
}
@@ -0,0 +1,214 @@
<?php
declare(strict_types=1);
namespace App\State;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;
use App\Entity\Bovine;
use App\Entity\BuildingCase;
use DateTimeImmutable;
use Doctrine\ORM\EntityManagerInterface;
use Dompdf\Dompdf;
use Malio\EdnotifBundle\Bovin\Api\BovinApiInterface;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Throwable;
use Twig\Environment;
use Twig\Error\LoaderError;
use Twig\Error\RuntimeError;
use Twig\Error\SyntaxError;
final readonly class BuildingCaseWeightsReportProvider implements ProviderInterface
{
private const FRENCH_MONTHS = [
1 => 'Janvier',
2 => 'Février',
3 => 'Mars',
4 => 'Avril',
5 => 'Mai',
6 => 'Juin',
7 => 'Juillet',
8 => 'Août',
9 => 'Septembre',
10 => 'Octobre',
11 => 'Novembre',
12 => 'Décembre',
];
public function __construct(
private Environment $twig,
private EntityManagerInterface $entityManager,
private BovinApiInterface $bovinApi,
) {}
/**
* @throws RuntimeError
* @throws SyntaxError
* @throws LoaderError
*/
public function provide(Operation $operation, array $uriVariables = [], array $context = []): Response
{
$id = $uriVariables['id'] ?? null;
if (null === $id) {
throw new NotFoundHttpException('Case not found.');
}
$buildingCase = $this->entityManager->getRepository(BuildingCase::class)->find($id);
if (!$buildingCase instanceof BuildingCase) {
throw new NotFoundHttpException('Case not found.');
}
$rows = [];
$firstArrivalDate = null;
$headerBreedCode = null;
foreach ($buildingCase->getBovines() as $bovine) {
if (!$bovine instanceof Bovine) {
continue;
}
$workNumber = null;
$birthDate = null;
$breedCode = null;
try {
$animalFileDto = $this->bovinApi->getAnimalFile(
nationalNumber: $bovine->getNationalNumber(),
countryCode: 'FR',
);
$workNumber = $animalFileDto->identification?->workNumber;
$birthDate = $animalFileDto->identification?->birthDate?->date?->format('d/m/y');
$breedCode = $this->normalizeBreedCode($animalFileDto->identification?->breedType);
if (null === $headerBreedCode && null !== $breedCode) {
$headerBreedCode = $breedCode;
}
} catch (Throwable) {
// Keep row data even if external identification service is unavailable.
}
$arrivalDate = $bovine->getArrivalDate();
if ($arrivalDate instanceof DateTimeImmutable && null === $firstArrivalDate) {
$firstArrivalDate = $arrivalDate;
}
$projectedWeights = $this->buildProjectedWeights(
$bovine->getReceivedWeight(),
$arrivalDate,
$breedCode,
);
$rows[] = [
'nationalNumber' => $bovine->getNationalNumber(),
'workNumber' => $workNumber,
'birthDate' => $birthDate,
'receivedWeight' => $bovine->getReceivedWeight(),
'arrivalDate' => $bovine->getArrivalDate()?->format('d/m/Y'),
'projectedWeights' => $projectedWeights,
];
}
$monthHeaders = $this->buildMonthHeaders($firstArrivalDate, $headerBreedCode);
$dompdf = new Dompdf();
$html = $this->twig->render('case_weights_report.html.twig', [
'buildingCase' => $buildingCase,
'rows' => $rows,
'monthHeaders' => $monthHeaders,
'printedAt' => new DateTimeImmutable(),
]);
$dompdf->loadHtml($html);
$dompdf->setPaper('A4', 'landscape');
$dompdf->render();
$filename = sprintf('tableau-poids-case-%d.pdf', $buildingCase->getId());
return new Response($dompdf->output(), Response::HTTP_OK, [
'Content-Type' => 'application/pdf',
'Content-Disposition' => 'inline; filename="'.$filename.'"',
]);
}
private function normalizeBreedCode(mixed $breedType): ?string
{
if (null === $breedType) {
return null;
}
if (is_numeric($breedType)) {
return (string) $breedType;
}
if (is_string($breedType) && preg_match('/\d+/', $breedType, $matches)) {
return $matches[0];
}
return null;
}
private function resolveDailyGainKg(?string $breedCode): float
{
return match ($breedCode) {
'34' => 1.3, // Limousin
'38' => 1.5, // Charolais
default => 1.4, // Other breeds
};
}
/**
* @return array<int, null|float>
*/
private function buildProjectedWeights(?int $receivedWeight, ?DateTimeImmutable $arrivalDate, ?string $breedCode): array
{
$result = array_fill(0, 12, null);
if (null === $receivedWeight || !$arrivalDate instanceof DateTimeImmutable) {
return $result;
}
$currentWeight = (float) $receivedWeight;
$dailyGainKg = $this->resolveDailyGainKg($breedCode);
for ($i = 0; $i < 12; ++$i) {
$monthDate = $arrivalDate->modify('first day of this month')->modify(sprintf('+%d month', $i));
$daysInMonth = (int) $monthDate->format('t');
$daysToApply = 0 === $i
? max($daysInMonth - (int) $arrivalDate->format('j'), 0)
: $daysInMonth;
$currentWeight += $daysToApply * $dailyGainKg;
$result[$i] = $currentWeight;
}
return $result;
}
/**
* @return array<int, array{name:string,days:string,base:string}>
*/
private function buildMonthHeaders(?DateTimeImmutable $arrivalDate, ?string $breedCode): array
{
$referenceDate = $arrivalDate ?? new DateTimeImmutable('first day of january this year');
$dailyGainKg = $this->resolveDailyGainKg($breedCode);
$headers = [];
for ($i = 0; $i < 12; ++$i) {
$monthDate = $referenceDate->modify('first day of this month')->modify(sprintf('+%d month', $i));
$monthIndex = (int) $monthDate->format('n');
$daysInMonth = (int) $monthDate->format('t');
$daysToApply = 0 === $i
? max($daysInMonth - (int) $referenceDate->format('j'), 0)
: $daysInMonth;
$headers[] = [
'name' => self::FRENCH_MONTHS[$monthIndex],
'days' => sprintf('%d jours', $daysToApply),
'baseValue' => $daysToApply * $dailyGainKg,
];
}
return $headers;
}
}