Symfony Profiler

<?php
namespace App\Controller;
use Dompdf\Dompdf;
use Dompdf\Options;
use App\Entity\Pays;
use App\Entity\Zone;
use App\Entity\Annee;
use App\Entity\Frais;
use App\Entity\Tarif;
use App\Entity\Assurance;
use App\Entity\TypeTarifs;
use App\Entity\Restriction;
use App\Entity\FournitureItem;
use App\Service\BandeauService;
use App\Entity\QuantiteBouteille;
use App\Service\CalculTaxeService;
use App\Entity\FournitureCategorie;
use App\Entity\ZoneDepartementsPoids;
use Doctrine\ORM\EntityManagerInterface;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\StreamedResponse;
use Symfony\Component\HttpFoundation\ResponseHeaderBag;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
class SimulateurController extends AbstractController
{
private $zoneRepository;
private $paysRepository;
private $anneeRepository;
private $fraisRepository;
private $tarifRepository;
private $assuranceRepository;
private $typeTarifsRepository;
private $restrictionRepository;
private $fournitureItemRepository;
private $quantiteBouteilleRepository;
private $fournitureCategorieRepository;
private $montantDeliveredDutyPaid;
private $ZoneDepartementsPoidsRepository;
private $aRoyaumeUniId;
private $aSuisseId;
private $aNorvegeId;
private $aAustralieId;
private $aNouvelleZelandeId;
private $aSingapourId;
private $aCoreeSudId;
private $aJaponId;
private $aTaiwanId;
private $bandeauService;
private $calculTaxeService;
public function __construct(EntityManagerInterface $entityManager, CalculTaxeService $calculTaxeService, BandeauService $bandeauService)
{
$this->montantDeliveredDutyPaid = 19;
$this->calculTaxeService = $calculTaxeService;
$this->zoneRepository = $entityManager->getRepository(Zone::class);
$this->paysRepository = $entityManager->getRepository(Pays::class);
$this->anneeRepository = $entityManager->getRepository(Annee::class);
$this->fraisRepository = $entityManager->getRepository(Frais::class);
$this->tarifRepository = $entityManager->getRepository(Tarif::class);
$this->assuranceRepository = $entityManager->getRepository(Assurance::class);
$this->typeTarifsRepository = $entityManager->getRepository(TypeTarifs::class);
$this->restrictionRepository = $entityManager->getRepository(Restriction::class);
$this->fournitureItemRepository = $entityManager->getRepository(FournitureItem::class);
$this->quantiteBouteilleRepository = $entityManager->getRepository(QuantiteBouteille::class);
$this->fournitureCategorieRepository = $entityManager->getRepository(FournitureCategorie::class);
$this->ZoneDepartementsPoidsRepository = $entityManager->getRepository(ZoneDepartementsPoids::class);
$this->aRoyaumeUniId = [30, 31, 32];
$this->aSuisseId = [50];
$this->aNorvegeId = [33];
$this->aAustralieId = [51];
$this->aNouvelleZelandeId = [57];
$this->aSingapourId = [58];
$this->aCoreeSudId = [52];
$this->aJaponId = [55];
$this->aTaiwanId = [38];
$this->bandeauService = $bandeauService;
}
/**
* @Route("/simulateur", name="app_simulateur")
*/
public function index(Request $request): Response
{
$user = $this->getUser();
// Vérifier si l'utilisateur est authentifié
if (!$user) {
return $this->redirectToRoute('login');
}
if ($this->isGranted('ROLE_ADMIN')) {
return $this->redirectToRoute('app_admin_index');
}
// Récupérer l'année en cours
$currentYear = (int)date('Y');
// Récupération des données
$zones = $this->zoneRepository->findZonesForCurrentYear();
return $this->render('simulateur/newSimulateur.html.twig', [
'controller_name' => 'SimulateurController',
'user' => $user,
'zones' => $zones,
'currentYear' => $currentYear,
'bandeau' => $this->bandeauService->displayPopup()
]);
}
/**
* @Route("/get_construct_simulateur/{id}", name="get_construct_simulateur", methods={"GET"})
*/
public function getConstructSimulateur(Pays $pays, EntityManagerInterface $entityManager): Response
{
$user = $this->getUser();
// Vérifier si l'utilisateur est authentifié
if (!$user) {
return $this->redirectToRoute('login');
}
// Si le pays n'est pas trouvé, retourner une réponse 404
if (!$pays) {
return new Response("Pays non trouvé", Response::HTTP_NOT_FOUND);
}
$zone = $pays->getZone();
$isUsa = $zone->isIsUsa();
// Récupération des assurances
$assuranceDeBase = $this->assuranceRepository->findOneByAssuranceBase(true);
$assurances = $this->assuranceRepository->findAll();
// On récupère les emballages (si c'est une zone boolean USA alors il faut afficher uniquement les emballages compatible USA)
$emballages = null;
if ($isUsa == null or $isUsa == 0) {
$emballages = $this->fournitureCategorieRepository->findAll();
} else {
$emballages = $this->fournitureCategorieRepository->findByCompatibleUsa(true);
}
$caisseEnBois = true;
// On test si la zone ne peut pas envoyer de caisse en bois en option
if ($zone->getCaisseBoisMontantBouteilleSix() == null) {
$caisseEnBois = false;
}
$typesTarifs = $zone->getTypeTarifs();
$frais = $zone->getFrais();
// Rendre un template partiel avec les informations du pays
return $this->render('simulateur/_show_simulateur.html.twig', [
'pays' => $pays,
'typesTarifs' => $typesTarifs,
'emballages' => $emballages,
'frais' => $frais,
'caisseEnBois' => $caisseEnBois,
'assuranceDeBase' => $assuranceDeBase,
'assurances' => $assurances
]);
}
/**
* @Route("/calc_simulateur/{id}", name="calc_simulateur", methods={"POST"})
*/
public function calcSimulateur(Request $request, Pays $pays): Response
{
$user = $this->getUser();
// Vérifier si l'utilisateur est authentifié
if (!$user) {
return $this->redirectToRoute('login');
}
// Si le pays n'est pas trouvé, retourner une réponse 404
if (!$pays) {
return new Response("Pays non trouvé", Response::HTTP_NOT_FOUND);
}
// Récupérer et décoder les données JSON envoyées
$data = json_decode($request->getContent(), true);
// Assurez-vous que les données sont valides
if (!isset($data['recap']) || !is_array($data['recap'])) {
return new JsonResponse(['error' => 'Invalid data'], 400);
}
$aReturnDonnee = $this->genereAllCalc($data, $pays);
$montantTransport = $aReturnDonnee["montantTransport"];
$montantEmballage = $aReturnDonnee["montantEmballage"];
$montantAssurance = $aReturnDonnee["montantAssurance"];
$montantTaxe = $aReturnDonnee["montantTaxe"];
$montantOptions = $aReturnDonnee["montantOptions"];
$montantCaisseEnBois = $aReturnDonnee["montantCaisseEnBois"];
$montantSurPalette = $aReturnDonnee["montantSurPalette"];
$montantTotal = $aReturnDonnee["montantTotal"];
$isAssujettiTva = $aReturnDonnee["isAssujettiTva"];
$errors = $aReturnDonnee["errors"];
return $this->render('simulateur/_affichage_complet_simulateur.html.twig', [
'montantTransport' => $montantTransport,
'montantEmballage' => $montantEmballage,
'montantAssurance' => $montantAssurance,
'montantTaxe' => $montantTaxe,
'montantOptions' => $montantOptions,
'montantCaisseEnBois' => $montantCaisseEnBois,
'montantSurPalette' => $montantSurPalette,
'montantTotal' => $montantTotal,
'isAssujettiTva' => $isAssujettiTva,
'errors' => $errors
]);
}
/**
* @Route("/generate-pdf/{id}", name="generate_pdf_simu", methods={"POST"})
*/
public function generatePdf(Request $request, Pays $pays): Response
{
$user = $this->getUser();
// Vérifier si l'utilisateur est authentifié
if (!$user) {
return $this->redirectToRoute('login');
}
// Si le pays n'est pas trouvé, retourner une réponse 404
if (!$pays) {
return new Response("Pays non trouvé", Response::HTTP_NOT_FOUND);
}
// Récupérer et décoder les données JSON envoyées
$data = json_decode($request->getContent(), true);
// Assurez-vous que les données sont valides
if (!isset($data['recap']) || !is_array($data['recap'])) {
return new JsonResponse(['error' => 'Invalid data'], 400);
}
$aReturnDonnee = $this->genereAllCalc($data, $pays);
$assuranceDeBase = $this->assuranceRepository->findOneByAssuranceBase(true);
// On récupére le total des bouteilles
$totalBottles = $this->calculateTotalBottles($data['recap']);
$volumeBottles = $this->calculateVolumeBottles($data['recap']);
// Créer une instance Dompdf
$options = new Options();
$options->set('defaultFont', 'Arial');
$options->set('isRemoteEnabled', true);
$options->set('enable_html5_parser', true);
$dompdf = new Dompdf($options);
// Récupérer les données de la page
$html = $this->renderView('pdf/export_simulateur.html.twig', [
'pays' => $pays->getNom(),
'montantTransport' => $aReturnDonnee['montantTransport'],
'montantEmballage' => $aReturnDonnee['montantEmballage'],
'montantAssurance' => $aReturnDonnee['montantAssurance'],
'montantTaxe' => $aReturnDonnee['montantTaxe'],
'montantValeur' => $aReturnDonnee['montantValeur'],
'montantOptions' => $aReturnDonnee['montantOptions'],
'montantCaisseEnBois' => $aReturnDonnee['montantCaisseEnBois'],
'montantTotal' => $aReturnDonnee['montantTotal'],
'isAssujettiTva' => $aReturnDonnee['isAssujettiTva'],
'errors' => $aReturnDonnee['errors'],
'montantSurPalette' => $aReturnDonnee['montantSurPalette'],
'nomAssurrance' => $aReturnDonnee['nomAssurrance'],
'nomEmballage' => $aReturnDonnee['nomEmballage'],
'totalBottles' => $totalBottles,
'volumeBottles' => $volumeBottles,
'assuranceDeBase' => $assuranceDeBase,
'assuranceComp' => $aReturnDonnee["assuranceComp"],
'nomLivraison' => $aReturnDonnee["nomLivraison"],
'descLivraison' => $aReturnDonnee["descLivraison"],
'poidsSurPalette' => $aReturnDonnee["poidsSurPalette"],
'departementSurPalettetext' => $aReturnDonnee["departementSurPalettetext"],
]);
// Charger le HTML dans Dompdf
$dompdf->loadHtml($html);
// (Facultatif) Définir les dimensions du papier
$dompdf->setPaper('A4', 'portrait');
// Générer le PDF
$dompdf->render();
// Retourner le PDF sous forme de réponse HTTP
return new Response($dompdf->output(), 200, [
'Content-Type' => 'application/pdf',
'Content-Disposition' => 'inline; filename="page.pdf"',
]);
}
public function genereAllCalc($data, $pays)
{
// On récupère la zone
$zone = $pays->getZone();
// On récupère le boolean pour assujetti à la tva ou non
$isAssujettiTva = $zone->isAssujettiTva();
$errors = array();
$recap = $data['recap']; // Tableau des volumes et quantités
$checkedAssurances = $data['checkedAssurances']; // Tableau récap des assurances check
$checkedEmballages = $data['checkedEmballages']; // Tableau récap des emballages check
$checkedLivraisons = $data['checkedLivraisons']; // Tableau récap des livraisons check
$checkedDeliveredDutyPaid = $data['checkedDeliveredDutyPaid']; // // Check option DDP
$checkedCaisseEnBois = $data['checkedCaisseEnBois']; // Check option caisse en bois
$checkedSurPalette = $data['checkedSurPalette']; // Check option sur palette
$montantValeur = $data['montantValeur'];
$poidsSurPalette = $data['poidsSurPalette']; //poids palette
$departementSurPalette = $data['departementSurPalette']; //département palette
$departementSurPalettetext = $data['departementSurPalettetext']; //département palette text
$montantTransport = 0;
$montantEmballage = 0;
$montantAssurance = 0;
$montantTaxe = 0;
$montantOptions = 0;
$montantCaisseEnBois = 0;
$montantSurPalette = 0;
// Espace variables pour PDF
$nomAssurrance = "";
$nomEmballage = "";
$assuranceComp = "";
$nomLivraison = "";
$descLivraison = "";
// On récupére le total des bouteilles
$calculateTotalBottles = $this->calculateTotalBottles($recap);
// Traitement de l'asssurance
if (!empty($checkedAssurances)) {
$assuranceIdFront = $checkedAssurances[0];
$assuranceComp = $this->assuranceRepository->findOneById($assuranceIdFront);
$montantAssurance = $montantValeur * ($assuranceComp->getTaux() / 100);
$nomAssurrance = $assuranceComp->getTitre();
}
if (!empty($checkedEmballages)) {
$emballageIdFront = $checkedEmballages[0];
$emballageChoisi = $this->fournitureCategorieRepository->findOneById($emballageIdFront);
// Trier par nbBouteille
$itemsByNbBouteille = $this->fournitureItemRepository->findPartByCategorieAndNbBouteilleDesc($emballageIdFront);
// Trier par nbMagnum
$itemsByNbMagnum = $this->fournitureItemRepository->findPartByCategorieAndNbMagnumDesc($emballageIdFront);
// Trier par nbJeroboam
$itemsByNbJeroboam = $this->fournitureItemRepository->findPartByCategorieAndNbJeroboamDesc($emballageIdFront);
$tableauReturnTarifs = $this->calculateTarifs($recap, $itemsByNbBouteille, $itemsByNbMagnum, $itemsByNbJeroboam);
$montantEmballage = $tableauReturnTarifs['montant_total'];
$nomEmballage = $emballageChoisi->getTitre() . ' - ' . $emballageChoisi->getSousTitre() . ' - ' . $emballageChoisi->getMarque();
}
$zone = $pays->getZone();
if (!empty($checkedLivraisons)) {
$livraisonIdFront = $checkedLivraisons[0];
$typeTarif = $this->typeTarifsRepository->findOneById($livraisonIdFront);
$nomLivraison = $typeTarif->getTitre();
$descLivraison = $typeTarif->getDescription();
// On récupère les quantités bouteilles potentielles
$quantiteBouteilleLaPlusProche = $this->quantiteBouteilleRepository->findPartByBottleCountAndZone($calculateTotalBottles, $zone->getId());
if ($pays->getNom() == "France") {
$message = "Il n'est pas possible d'envoyer cette quantité de bouteilles pour ce pays et avec cet emballage.
Vous pouvez configurer le <a href='#' id='transport_palette'>transport par palette</a>.
<br> Sinon, vous pouvez consulter l'offre complète avec les différentes restrictions ci-dessous.";
} else {
$message = "Il n'est pas possible d'envoyer cette quantité de bouteilles pour ce pays et avec cet emballage. <br> Vous pouvez consulter l'offre complète avec les différentes restrictions ci-dessous.";
}
if ($quantiteBouteilleLaPlusProche == null) {
if ($calculateTotalBottles > 0) {
//si france, on regarde si l'option palette a été utilisée
if ($pays->getNom() == "France") {
if ($checkedSurPalette) {
//si le poids et le département sont remplis (France seulement)
if (!empty($poidsSurPalette) and (!empty($departementSurPalette))) {
$montantSurPalette = $this->getMontantPaletteByDepartement($poidsSurPalette, $departementSurPalette);
//si le montent existe on écrase montantTransport
$montantTransport = $montantSurPalette;
} else {
$errors[] = $message;
}
} else {
$errors[] = $message;
}
} else {
$errors[] = $message;
}
}
} else {
$montantTransportObject = $this->tarifRepository->findPartByTypeTarifAndQuantiteBouteille($typeTarif->getId(), $quantiteBouteilleLaPlusProche[0]->getId());
$montantTransport = $montantTransportObject->getMontant();
}
}
if ($checkedCaisseEnBois) {
$totalBouteillesClassiques = $this->calculateTotalBottlesClassique($recap);
/*
* lots_of_12
* lots_of_6
* remaining_bottles
* total_costs
*/
$aCaisseEnBoisCalcul = $this->calculateCaisseEnBois($totalBouteillesClassiques, $zone->getCaisseBoisMontantBouteillesDouze(), $zone->getCaisseBoisMontantBouteilleSix());
$montantCaisseEnBois = $aCaisseEnBoisCalcul["total_costs"];
}
if ($checkedDeliveredDutyPaid) {
$montantOptions = $montantOptions + $this->montantDeliveredDutyPaid;
}
if ($checkedSurPalette) {
//si le poids et le département sont remplis (France seulement)
if (!empty($poidsSurPalette) and (!empty($departementSurPalette))) {
$montantSurPalette = $this->getMontantPaletteByDepartement($poidsSurPalette, $departementSurPalette);
//si le montent existe on écrase montantTransport
$montantTransport = $montantSurPalette;
}
}
$montantTaxe = $this->handleCountryById($pays->getId(), $montantValeur, $calculateTotalBottles, $montantTransport);
if ($montantTaxe == null) {
$montantTaxe = 0;
} else {
$montantTaxe = $montantTaxe["montantAvecMarge"];
}
$montantTotal = $montantTransport + $montantEmballage + $montantAssurance + $montantTaxe + $montantOptions + $montantCaisseEnBois/* + $montantSurPalette*/;
$aReturnDonnee = array();
$aReturnDonnee["montantTransport"] = $montantTransport;
$aReturnDonnee["montantEmballage"] = $montantEmballage;
$aReturnDonnee["montantAssurance"] = $montantAssurance;
$aReturnDonnee["montantTaxe"] = $montantTaxe;
$aReturnDonnee["montantOptions"] = $montantOptions;
$aReturnDonnee["montantCaisseEnBois"] = $montantCaisseEnBois;
$aReturnDonnee["montantTotal"] = $montantTotal;
$aReturnDonnee["isAssujettiTva"] = $isAssujettiTva;
$aReturnDonnee["errors"] = $errors;
$aReturnDonnee["nomAssurrance"] = $nomAssurrance;
$aReturnDonnee["nomEmballage"] = $nomEmballage;
$aReturnDonnee["montantSurPalette"] = $montantSurPalette;
$aReturnDonnee["montantValeur"] = $montantValeur;
$aReturnDonnee["assuranceComp"] = $assuranceComp;
$aReturnDonnee["nomLivraison"] = $nomLivraison;
$aReturnDonnee["descLivraison"] = $descLivraison;
$aReturnDonnee["poidsSurPalette"] = $poidsSurPalette;
$aReturnDonnee["departementSurPalettetext"] = $departementSurPalettetext;
return $aReturnDonnee;
}
// Fonction permettant de calculer le nombre de bouteilles (3L = 4, 1.5L = 2, 0.75L = 1, 0.5L = 1)
function calculateTotalBottles(array $recap): int
{
// Définitions des équivalences volume => nombre de bouteilles
$volumeToBottleCount = [
"0.5" => 1,
"0.75" => 1,
"1.5" => 2,
"3" => 4
];
$totalBottles = 0;
// Parcourir le tableau de récap
foreach ($recap as $volume => $quantity) {
// Vérifier si le volume existe dans les équivalences
if (isset($volumeToBottleCount[$volume])) {
// Multiplier la quantité par le nombre de bouteilles correspondant au volume
$totalBottles += $quantity * $volumeToBottleCount[$volume];
}
}
return $totalBottles;
}
// Fonction permettant de retourner le tarif en fonction du poids et du departement (France seulement)
function getMontantPaletteByDepartement($poids, $departement): float
{
//on va chercher le resultat dans le repository
$tarif = $this->ZoneDepartementsPoidsRepository->findOneByPoidsAndDepartement($poids, $departement);
if ($tarif == null) {
return 0;
}
return $tarif->getMontant();
}
// Fonction permettant de calculer le nombre de bouteilles de 0.75L
function calculateTotalBottlesClassique(array $recap): int
{
$totalBottles = 0;
// Parcourir le tableau de récap
foreach ($recap as $volume => $quantity) {
// Vérifier si c'est le volume 0.75
if ($volume == "0.75") {
$totalBottles += $quantity;
}
}
return $totalBottles;
}
// Fonction permettant de calculer le volume de bouteilles (3L = 4, 1.5L = 2, 0.75L = 1, 0.5L = 1)
function calculateVolumeBottles(array $recap): float
{
$volumeTotal = 0;
// Parcourir le tableau de récap
foreach ($recap as $volume => $quantity) {
$volumeTotal += $quantity * $volume;
}
return $volumeTotal;
}
// Fonction permettant de calculer les tarifs en dégressif suivant le nombre de bouteilles
function calculateTarifs($recap, $itemsByNbBouteille, $itemsByNbMagnum, $itemsByNbJeroboam)
{
$result = [];
$totalCost = 0; // Montant final global
// Parcourir chaque volume dans le récapitulatif
foreach ($recap as $volume => $totalBottles) {
$volumeResult = [
'volume' => $volume,
'nb_bouteille' => 0,
'nb_magnum' => 0,
'nb_jeroboam' => 0,
'tarif_details' => [],
'montant_volume' => 0 // Montant total pour ce volume
];
// Sélectionner les items appropriés en fonction du volume
$items = [];
if ($volume == '0.75' || $volume == '0.5') {
$items = $itemsByNbBouteille;
} elseif ($volume == '1.5') {
$items = $itemsByNbMagnum;
} elseif ($volume == '3') {
$items = $itemsByNbJeroboam;
}
// Parcourir les items triés pour emballer les bouteilles
foreach ($items as $item) {
$nbBouteillesParCarton = $item->getNbBouteille() ?? $item->getNbMagnum() ?? $item->getNbJeroboam();
$montantUnitaire = $item->getMontantUnitaire();
while ($totalBottles >= $nbBouteillesParCarton) {
$volumeResult['tarif_details'][] = [
'montant_unitaire' => $montantUnitaire,
'nb_bouteilles' => $nbBouteillesParCarton
];
$totalBottles -= $nbBouteillesParCarton;
// Ajouter au montant total pour ce volume
$volumeResult['montant_volume'] += $montantUnitaire;
// Incrementer les compteurs correspondants
if ($volume == '0.75' || $volume == '0.5') {
$volumeResult['nb_bouteille'] += $nbBouteillesParCarton;
} elseif ($volume == '1.5') {
$volumeResult['nb_magnum'] += $nbBouteillesParCarton;
} elseif ($volume == '3') {
$volumeResult['nb_jeroboam'] += $nbBouteillesParCarton;
}
}
}
// Si des bouteilles restantes ne trouvent pas d'emballage
if ($totalBottles > 0) {
$volumeResult['tarif_details'][] = [
'montant_unitaire' => null,
'nb_bouteilles' => $totalBottles
];
if ($volume == '0.75' || $volume == '0.5') {
$volumeResult['nb_bouteille'] += $totalBottles;
} elseif ($volume == '1.5') {
$volumeResult['nb_magnum'] += $totalBottles;
} elseif ($volume == '3') {
$volumeResult['nb_jeroboam'] += $totalBottles;
}
}
// Ajouter le montant de ce volume au montant total global
$totalCost += $volumeResult['montant_volume'];
$result[] = $volumeResult;
}
return [
'result' => $result,
'montant_total' => $totalCost
];
}
// Permet de calculer le nombre de caisse en bois
function calculateCaisseEnBois($totalBottles, $pricePer12, $pricePer6)
{
if ($totalBottles <= 0) {
return [
'lots_of_12' => 0,
'lots_of_6' => 0,
'remaining_bottles' => 0,
'total_cost' => 0
];
}
// Calculer les lots de 12 bouteilles
$lotsOf12 = intdiv($totalBottles, 12);
$remainingAfter12 = $totalBottles % 12;
// Calculer les lots de 6 bouteilles avec le reste
$lotsOf6 = intdiv($remainingAfter12, 6);
$remainingBottles = $remainingAfter12 % 6;
// Calculer le montant total
$totalCost = ($lotsOf12 * $pricePer12) + ($lotsOf6 * $pricePer6);
//dd($lotsOf12);
return [
'lots_of_12' => $lotsOf12,
'lots_of_6' => $lotsOf6,
'remaining_bottles' => $remainingBottles,
'total_costs' => $totalCost
];
}
function handleCountryById(int $id, float $totalInvoice, int $numberOfBottles, float $transportCost)
{
//fix taxe : on va chercher le min ID du pays
$pays = $this->paysRepository->findOneById($id);
$old_pays = $this->paysRepository->findMinIdByName($pays->getNom());
if ($old_pays != null) {
$min_id = $old_pays['id'];
} else {
$min_id = $id;
}
// Vérification et appel de la méthode correspondante
if (in_array($min_id, $this->aRoyaumeUniId)) {
return $this->calculTaxeService->calculateRoyaumeUni($totalInvoice, $numberOfBottles);
} elseif (in_array($min_id, $this->aSuisseId)) {
return $this->calculTaxeService->calculateSuisse($totalInvoice, $numberOfBottles);
} elseif (in_array($min_id, $this->aNorvegeId)) {
return $this->calculTaxeService->calculateNorvege($totalInvoice, $numberOfBottles, $transportCost);
} elseif (in_array($min_id, $this->aAustralieId)) {
return $this->calculTaxeService->calculateAustralie($totalInvoice, $numberOfBottles, $transportCost);
} elseif (in_array($min_id, $this->aNouvelleZelandeId)) {
return $this->calculTaxeService->calculateNouvelleZelande($totalInvoice, $numberOfBottles, $transportCost);
} elseif (in_array($min_id, $this->aSingapourId)) {
return $this->calculTaxeService->calculateSingapour($totalInvoice, $numberOfBottles);
} elseif (in_array($min_id, $this->aCoreeSudId)) {
return $this->calculTaxeService->calculateCoreeSud($totalInvoice, $numberOfBottles, $transportCost);
} elseif (in_array($min_id, $this->aJaponId)) {
return $this->calculTaxeService->calculateJapon($totalInvoice, $numberOfBottles, $transportCost);
} elseif (in_array($min_id, $this->aTaiwanId)) {
return $this->calculTaxeService->calculateTaiwan($totalInvoice, $numberOfBottles, $transportCost);
}
return null;
}
}

src/Controller/SimulateurController.php line 119