src/EventListener/JournalPaieListener.php line 31

Open in your IDE?
  1. <?php
  3. namespace App\EventListener;
  5. use App\Entity\JournalBulletinLg;
  6. use App\Entity\JournalPaieDossier;
  7. use App\Entity\PBordereau;
  8. use App\Entity\PCompteComptable;
  9. use App\Entity\Prubrique;
  10. use App\Entity\PStatut;
  11. use App\Entity\TbulletinLg;
  12. use App\Entity\VMatrix;
  13. use App\Service\JournalPaieService;
  14. use Doctrine\ORM\EntityManagerInterface;
  15. use Symfony\Component\HttpFoundation\JsonResponse;
  16. use Symfony\Component\HttpKernel\Event\TerminateEvent;
  18. class JournalPaieListener
  19. {
  20.     private $entityManager;
  21.     private JournalPaieService $journalPaieService;
  22.     private $charge;
  25.     public function __construct(EntityManagerInterface  $entityManager, JournalPaieService $journalPaieService)
  26.     {
  27.         $this->entityManager = $entityManager;
  28.         $this->journalPaieService = $journalPaieService;
  29.     }
  31.     public function onKernelTerminate(TerminateEvent $event): void
  32.     {
  33.         $request = $event->getRequest();
  35.         if (
  36.             $request->get('_route') === 'app_bulletin_employe_calcul' or
  37.             $request->get('_route') === 'app_bulletin_employe_calcul_all' or
  38.             $request->get('_route') === 'app_paie_indeminite_insert' or
  39.             $request->get('_route') === 'app_paie_honoraire_insert' or
  40.             $request->get('_route') === 'app_paie_remuneration_avance_insert' or
  41.             $request->get('_route') === 'app_paie_stc_insert' or
  42.             $request->get('_route') === 'app_tresorerie_bordereau_journal'
  43.         ) {
  44.             if ($request->request->get('bordoreauIds')) {
  45.                 $bordoreauIds = json_decode($request->request->get('bordoreauIds'), true);
  46.                 try {
  47.                     $this->journalPaieService->processBordereaux($bordoreauIds);
  48.                 } catch (\Exception $e) {
  49.                     echo $e->getMessage();
  50.                     die;
  51.                 }
  52.             }
  54.         }
  56.         return;
  57.     }
  58. //public function onKernelTerminate(TerminateEvent $event)
  59. //    {
  60. //        $request = $event->getRequest();
  61. //
  62. //        if (
  63. //            $request->get('_route') === 'app_bulletin_employe_calcul' or
  64. //            $request->get('_route') === 'app_bulletin_employe_calcul_all' or
  65. //            $request->get('_route') === 'app_paie_indeminite_insert' or
  66. //            $request->get('_route') === 'app_paie_honoraire_insert' or
  67. //            $request->get('_route') === 'app_paie_remuneration_avance_insert' or
  68. //            $request->get('_route') === 'app_paie_stc_insert' or
  69. //            $request->get('_route') === 'app_tresorerie_bordereau_journal'
  70. //        ) {
  71. //            if ($request->request->get('bordoreauIds')) {
  72. //                $bordoreauIds = json_decode($request->request->get('bordoreauIds'));
  73. //
  74. //                foreach ($bordoreauIds as $key => $bordoreauId) {
  75. //                    $bordoreau = $this->entityManager->getRepository(PBordereau::class)->find($bordoreauId);
  76. //                    $this->charge = 0;
  77. //                    $this->entityManager->refresh($bordoreau);
  78. //                    foreach ($bordoreau->getActiveBulletins() as $key => $bulletin) {
  79. //                        $this->journalBulletin($bulletin);
  80. //                    }
  81. //                    if (number_format($this->charge, 2) == 0) {
  82. //                        $bordoreau->setStatut(
  83. //                            $this->entityManager->getRepository(PStatut::class)->find(2)
  84. //                        );
  85. //                    } else {
  86. //                        $bordoreau->setStatut(
  87. //                            $this->entityManager->getRepository(PStatut::class)->find(5)
  88. //                        );
  89. //                    }
  90. //                }
  91. //                $this->entityManager->flush();
  92. //            }
  93. //        }
  94. //
  95. //        return;
  96. //    }
  98. //
  99. //    public function journalBulletin($bulletin)
  100. //    {
  101. //        $cotisationsArray = [
  102. //            "cnss" => [50, 47, 53],
  103. //            "cimr" => [48],
  104. //            "ir" => [43],
  105. //            // "netpaye" => "K10010','K10011"
  106. //        ];
  107. //        $bordoreau = $bulletin->getBordereau();
  108. //        $primes = $this->entityManager->getRepository(Prubrique::class)->findBy(['id' => [4, 6, 7, 8, 9, 10, 93, 11, 16, 24, 25, 60, 76,94]]);
  109. //        if (in_array($bordoreau->getNatureContract()->getType()->getId(), [2, 6])) {
  110. //            $primes = [];
  111. //        } else {
  112. //            $primes = $this->entityManager->getRepository(TbulletinLg::class)->findBy(['bulletin' => $bulletin, 'active' => true, 'rubrique' => $primes]);
  113. //        }
  114. //
  115. //        if ($bulletin->getDossier()->getGroupement() == 'FCZ') {
  116. //            $prevelements = $this->entityManager->getRepository(Prubrique::class)->findBy(['id' => [5, 68, 30, 31, 33, 34, 35, 36, 37, 38, 39, 85, 80, 79, 78, 77, 82, 83, 45, 84]]);
  117. //            $prevelementCabs = $this->entityManager->getRepository(Prubrique::class)->findBy(['id' => [29, 32, 40, 41, 44, 46, 59]]); // if u change this ids please change also in TbulletinLgRepositry for regularisation
  118. //            $prevelements = $this->entityManager->getRepository(TbulletinLg::class)->findByGroup($bulletin,  $prevelements);
  119. //            $prevelementCabs = $this->entityManager->getRepository(TbulletinLg::class)->findByGroup($bulletin, $prevelementCabs);
  120. //        } else {
  121. //            $prevelements = $this->entityManager->getRepository(Prubrique::class)->findBy(['id' => [5, 68, 30, 31, 33, 34, 35, 36, 37, 38, 39, 85, 80, 79, 78, 77, 82, 83, 45, 84, 29, 32, 40, 41, 44, 46, 59]]);
  122. //            $prevelements = $this->entityManager->getRepository(TbulletinLg::class)->findByGroup($bulletin, $prevelements);
  123. //            $prevelementCabs = [];
  124. //        }
  125. //
  126. //
  127. //        // disable if exist already to insert new lines
  128. //        // $journalBulletinLgs = $bulletin->getJournalBulletinLgs();
  129. //        $class = JournalBulletinLg::class;
  130. //        $query = $this->entityManager->createQuery(
  131. //            "UPDATE $class e SET e.active = :newValue WHERE e.bulletin = :someValue and e.active = 1"
  132. //        );
  133. //        $query->setParameters([
  134. //            'newValue' => '0',
  135. //            'someValue' => $bulletin,
  136. //        ]);
  137. //        $query->execute();
  138. //        // foreach($journalBulletinLgs as $journalBulletinLg) {
  139. //        //     $journalBulletinLg->setActive(false);
  140. //        // }
  141. //
  142. //
  143. //        if ($bordoreau->getNatureContract()->getType()->getId() == 1 && $bordoreau->getType() == 'paie') {
  144. //            $salaireBase = $this->entityManager->getRepository(TbulletinLg::class)->findOneBy(['bulletin' => $bulletin, 'rubrique' => $this->entityManager->getRepository(Prubrique::class)->find(1), 'active' => true]);
  145. //            $salaireAnciennte = $this->entityManager->getRepository(TbulletinLg::class)->findOneBy(['bulletin' => $bulletin, 'rubrique' => $this->entityManager->getRepository(Prubrique::class)->find(2), 'active' => true]);
  146. //
  147. //            $montantSalaireBase = $salaireBase->getMontant();
  148. //            $montantSalaireBaseInitial = $salaireBase->getMontant();
  149. //
  150. //            $montantSalaireAnciennte = $salaireAnciennte ? $salaireAnciennte->getMontant() : 0;
  151. //            $montantSalaireAnciennteInitital = $salaireAnciennte ? $salaireAnciennte->getMontant() : 0;
  152. //        } else {
  153. //
  154. //            // if($bordoreau->getType() == 'regularisation') {
  155. //            //     $rubriques = $this->entityManager->getRepository(Prubrique::class)->findBy(['id' => [5]]);
  156. //            //     $salaireBase = $this->entityManager->getRepository(TbulletinLg::class)->findOneBy(['bulletin' => $bulletin, 'rubrique' => $rubriques, 'active' => true]);
  157. //            // } else {
  158. //            $rubriques = $this->entityManager->getRepository(Prubrique::class)->findBy(['id' => [3, 12, 13, 14, 15, 17, 18, 22, 26, 27, 61, 63, 64, 65, 66, 67, 69, 70, 88]]);
  159. //            $salaireBase = $this->entityManager->getRepository(TbulletinLg::class)->findOneBy(['bulletin' => $bulletin, 'rubrique' => $rubriques, 'active' => true]);
  160. //
  161. //            // }
  162. //            $montantSalaireBase = $salaireBase->getMontant();
  163. //            $montantSalaireBaseDevise = $salaireBase->getMontantDevise() ?? 0;
  164. //            $montantSalaireBaseInitial = $salaireBase->getMontant();
  165. //            $montantSalaireAnciennte = 0;
  166. //            $montantSalaireAnciennteInitital = 0;
  167. //        }
  168. //
  169. //        if ($montantSalaireBase == 0) {
  170. //            return;
  171. //        }
  172. //
  173. //        foreach ($cotisationsArray as $key => $cotisationArray) {
  174. //            $cotisations = $this->entityManager->getRepository(TbulletinLg::class)->findByCotisation($bulletin, $cotisationArray);
  175. //            $montantTotalCotisations = $this->entityManager->getRepository(TbulletinLg::class)->findByCotisationGroupBulletin($bulletin, $cotisationArray);
  176. //            if ($cotisations and $montantTotalCotisations) {
  177. //
  178. //                $montantInitial = round($montantTotalCotisations['montant'], 2);
  179. //
  180. //                $halfMontant = round(($montantTotalCotisations['montant'] / 2), 2);
  181. //                if ($halfMontant + $halfMontant != $montantInitial) {
  182. //                    $firstHalf = $halfMontant;
  183. //                    $secondHalf = $montantInitial - $halfMontant;
  184. //                } else {
  185. //                    $firstHalf = $secondHalf = $halfMontant;
  186. //                }
  187. //                if ($firstHalf > $montantSalaireAnciennte) {
  188. //                    $minus = round(($firstHalf - $montantSalaireAnciennte), 2);
  189. //                    $montantSalaireBase  = round(($montantSalaireBase  - ($secondHalf + $minus)), 2);
  190. //                    $montantSalaireAnciennte = 0;
  191. //                } else {
  192. //                    $montantSalaireBase  = round(($montantSalaireBase - $secondHalf), 2);
  193. //                    $montantSalaireAnciennte = round(($montantSalaireAnciennte - $firstHalf), 2);
  194. //                }
  195. //
  196. //                foreach ($cotisations as $cotisation) {
  197. //                    $pcompteComptable = $this->entityManager->getRepository(PCompteComptable::class)->findOneBy(['rubrique' => $cotisation->getRubrique(), 'natureContract' => $bordoreau->getNatureContract()]);
  198. //                    // $excute = self::det_element_insert($id_employe,$element['Eléments'],$element['ID_Eléments'],abs($element['Montant_App_HRM']),NULL,$period,$code_comptable,$element['ID_Bulletin'],$id_cotis,$qte,$type,$this->em);
  199. //                    if (!$pcompteComptable) {
  200. //                        echo $cotisation->getRubrique()->getId() . '/' . $bordoreau->getNatureContract()->getId();
  201. //                        die;
  202. //                    }
  203. //                    $journalBulletinLg = new JournalBulletinLg();
  204. //                    $journalBulletinLg->setRubrique($cotisation->getRubrique());
  205. //                    $journalBulletinLg->setBulletin($bulletin);
  206. //                    $journalBulletinLg->setMontant($cotisation->getMontant());
  207. //                    $journalBulletinLg->setQte($pcompteComptable->getQte());
  208. //                    $journalBulletinLg->setCodeComptable($pcompteComptable->getCompteComptable());
  209. //                    $journalBulletinLg->setType($key);
  210. //                    $journalBulletinLg->setSens($pcompteComptable->getSens());
  211. //
  212. //                    $this->entityManager->persist($journalBulletinLg);
  213. //
  214. //                    $this->charge -= $journalBulletinLg->getMontant();
  215. //                }
  216. //
  217. //                $pcompteComptable = $this->entityManager->getRepository(PCompteComptable::class)->findOneBy(['rubrique' => $salaireBase->getRubrique(), 'natureContract' => $bordoreau->getNatureContract()]);
  218. //                // if($key == 'cimr') {
  219. //                //     echo $montantSalaireBaseInitial . '/' .$montantSalaireBase . '/' .$halfMontant;
  220. //                //     die;
  221. //                // }
  222. //                $journalBulletinLg = new JournalBulletinLg();
  223. //                $journalBulletinLg->setRubrique($salaireBase->getRubrique());
  224. //                $journalBulletinLg->setBulletin($bulletin);
  225. //                $journalBulletinLg->setMontant(round($montantSalaireBaseInitial - $montantSalaireBase, 2));
  226. //                $journalBulletinLg->setQte($pcompteComptable->getQte());
  227. //                $journalBulletinLg->setCodeComptable($pcompteComptable->getCompteComptable());
  228. //                $journalBulletinLg->setType($key);
  229. //                $journalBulletinLg->setSens($pcompteComptable->getSens());
  230. //
  231. //
  232. //                $this->entityManager->persist($journalBulletinLg);
  233. //
  234. //                $this->charge += $journalBulletinLg->getMontant();
  235. //
  236. //                if ($bordoreau->getNatureContract()->getType()->getId() == 1   && $bordoreau->getType() == 'paie' && $salaireAnciennte) {
  237. //                    $pcompteComptable = $this->entityManager->getRepository(PCompteComptable::class)->findOneBy(['rubrique' => $salaireAnciennte->getRubrique(), 'natureContract' => $bordoreau->getNatureContract()]);
  238. //
  239. //                    $journalBulletinLg = new JournalBulletinLg();
  240. //                    $journalBulletinLg->setRubrique($salaireAnciennte->getRubrique());
  241. //                    $journalBulletinLg->setBulletin($bulletin);
  242. //                    $journalBulletinLg->setMontant(round($montantSalaireAnciennteInitital - $montantSalaireAnciennte, 2));
  243. //                    $journalBulletinLg->setQte($pcompteComptable->getQte());
  244. //                    $journalBulletinLg->setCodeComptable($pcompteComptable->getCompteComptable());
  245. //                    $journalBulletinLg->setType($key);
  246. //                    $journalBulletinLg->setSens($pcompteComptable->getSens());
  247. //
  248. //
  249. //                    $this->entityManager->persist($journalBulletinLg);
  250. //
  251. //                    $this->charge += $journalBulletinLg->getMontant();
  252. //                }
  253. //
  254. //
  255. //                $montantSalaireBaseInitial = $montantSalaireBase;
  256. //                $montantSalaireAnciennteInitital = $montantSalaireAnciennte;
  257. //            }
  258. //        }
  259. //        $type = "netpaye";
  260. //
  261. //        $primesArrayInitital = [];
  262. //        // initialize the montant for each prime
  263. //        foreach ($primes as $prime) {
  264. //            array_push($primesArrayInitital, [
  265. //                'id' => $prime->getId(),
  266. //                'prime' => $prime,
  267. //                'montantInitial' => $prime->getMontant(),
  268. //                'montantFinal' => $prime->getMontant(),
  269. //                'montantMinus' => 0
  270. //            ]);
  271. //        }
  272. //
  273. //        usort($primesArrayInitital, fn ($a, $b) => $a['montantInitial'] <=> $b['montantInitial']);
  274. //
  275. //        $halfMontantPretArray = [];
  276. //        // calculate the montant for each prelevement
  277. //
  278. //        $keyToRemove = 'montantFinal';
  279. //
  280. //        // this array only for condition i keep the key to modify the montant thatt sould be removed in the original array primesArrayInitital
  281. //
  282. //
  283. //        foreach ($prevelementCabs as $key => $prevelementCab) {
  284. //
  285. //            $filtredPrimesArrayInitital = array_filter($primesArrayInitital, function ($subarray) use ($keyToRemove) {
  286. //                return $subarray[$keyToRemove] != 0;
  287. //            });
  288. //            if ($prevelementCab['montant'] > 0) {
  289. //                $nombrePrimes = count($filtredPrimesArrayInitital);
  290. //
  291. //                $details = [];
  292. //
  293. //                if (count($filtredPrimesArrayInitital) > 0) {
  294. //
  295. //                    $halfMontantPret = (($prevelementCab['montant'] / count($filtredPrimesArrayInitital)));
  296. //                    if ($this->hasMoreThanTwoDecimals($halfMontantPret)) {
  297. //                        $halfMontantPret = $this->roundUpToNDecimals($halfMontantPret, 2);
  298. //                    }
  299. //                    $reste = 0;
  300. //                    $montantMinusInitial = 0;
  301. //                    $montantDebit = 0;
  302. //                    foreach ($filtredPrimesArrayInitital as $key => $primeArray) {
  303. //
  304. //                        if ($primeArray['montantFinal'] == 0) {
  305. //                            $nombrePrimes = $nombrePrimes - 1;
  306. //                            $reste = $halfMontantPret - $primeArray['montantFinal'];
  307. //
  308. //                            if ($nombrePrimes == 0) {
  309. //                                $halfReste = round(($reste / 1), 2);
  310. //                            } else {
  311. //                                $halfReste = round(($reste / $nombrePrimes), 2);
  312. //                            }
  313. //                            $halfMontantPret += $halfReste;
  314. //
  315. //                            $montant = 0;
  316. //                        } elseif ($primeArray['montantFinal'] < $halfMontantPret) {
  317. //                            // echo $primeArray['montantFinal'] . '/'.$halfMontantPret;
  318. //                            // die;
  319. //                            $reste = $halfMontantPret - $primeArray['montantFinal'];
  320. //                            $primesArrayInitital[$key]['montantMinus'] = $primeArray['montantFinal'];
  321. //                            $montant = $primeArray['montantFinal'];
  322. //                            $primesArrayInitital[$key]['montantFinal'] = 0;
  323. //                            $montantMinusInitial += $montant;
  324. //                            $nombrePrimes = $nombrePrimes - 1;
  325. //                            if ($nombrePrimes == 0) {
  326. //                                $halfReste = round(($reste / 1), 2);
  327. //                            } else {
  328. //                                $halfReste = ($reste / $nombrePrimes);
  329. //                                if ($this->hasMoreThanTwoDecimals($halfReste)) {
  330. //                                    $halfReste = $this->roundUpToNDecimals($halfReste, 2);
  331. //                                }
  332. //                            }
  333. //                            $halfMontantPret += $halfReste;
  334. //                        } else {
  335. //                            if ($prevelementCab['montant'] < $montantMinusInitial + $halfMontantPret) {
  336. //                                $halfMontantPret = round($prevelementCab['montant'] - $montantMinusInitial, 2);
  337. //                            }
  338. //
  339. //                            $montant = $halfMontantPret;
  340. //                            $montantMinusInitial += $montant;
  341. //
  342. //
  343. //                            $primesArrayInitital[$key]['montantMinus'] = round($primesArrayInitital[$key]['montantMinus'] + $halfMontantPret, 2);
  344. //                            $primesArrayInitital[$key]['montantFinal'] = round($primesArrayInitital[$key]['montantFinal'] - $halfMontantPret, 2);
  345. //                            $filtredPrimesArrayInitital[$key]['montantMinus'] = round($filtredPrimesArrayInitital[$key]['montantMinus'] + $halfMontantPret, 2);
  346. //                            $filtredPrimesArrayInitital[$key]['montantFinal'] = round($filtredPrimesArrayInitital[$key]['montantFinal'] - $halfMontantPret, 2);
  347. //                        }
  348. //
  349. //                        $montantDebit += $montant;
  350. //
  351. //                        array_push($details, [
  352. //                            'prime' => $primeArray['prime'],
  353. //                            'montant' => $montant
  354. //                        ]);
  355. //                    }
  356. //                    // die;
  357. //                    // check if prelevement not completed from primes then debit from base and anciennete
  358. //                    $montantEcart = $prevelementCab['montant'] - $montantDebit;
  359. //
  360. //                    if ($nombrePrimes == 0 and $montantEcart  > 0) {
  361. //                        $halfMontantPret = round($montantEcart, 2);
  362. //                        $halfMontant = round(($montantEcart / 2), 2);
  363. //
  364. //                        if ($halfMontant + $halfMontant != $halfMontantPret) {
  365. //                            $firstHalf = $halfMontant;
  366. //                            $secondHalf = $halfMontantPret - $halfMontant;
  367. //                        } else {
  368. //                            $firstHalf = $secondHalf = $halfMontant;
  369. //                        }
  370. //
  371. //                        if ($firstHalf > $montantSalaireAnciennte) {
  372. //                            $minus = round(($firstHalf - $montantSalaireAnciennte), 2);
  373. //                            $montantSalaireBaseMinus  = round(($montantSalaireBase  - ($secondHalf + $minus)), 2);
  374. //                            $montantSalaireAnciennteMinus = 0;
  375. //                        } else {
  376. //                            $montantSalaireBaseMinus  = round(($montantSalaireBase - $secondHalf), 2);
  377. //                            $montantSalaireAnciennteMinus = round(($montantSalaireAnciennte - $firstHalf), 2);
  378. //                        }
  379. //
  380. //
  381. //
  382. //                        array_push($details, [
  383. //                            'prime' => $salaireBase,
  384. //                            'montant' => round($montantSalaireBase - $montantSalaireBaseMinus, 2)
  385. //                        ]);
  386. //
  387. //                        if ($bordoreau->getNatureContract()->getType()->getId() == 1 and $salaireAnciennte and $bordoreau->getType() == 'paie') {
  388. //                            array_push($details, [
  389. //                                'prime' => $salaireAnciennte,
  390. //                                'montant' => round($montantSalaireAnciennte - $montantSalaireAnciennteMinus, 2)
  391. //                            ]);
  392. //                        }
  393. //
  394. //                        $montantSalaireBase = $montantSalaireBaseMinus;
  395. //                        $montantSalaireAnciennte = $montantSalaireAnciennteMinus;
  396. //                    }
  397. //                } else {
  398. //                    // $montantSalaireBase;
  399. //                    // $montantSalaireAnciennteInitital;
  400. //
  401. //                    $halfMontantPret = round($prevelementCab['montant'], 2);
  402. //                    $halfMontant = round(($prevelementCab['montant'] / 2), 2);
  403. //
  404. //                    if ($halfMontant + $halfMontant != $halfMontantPret) {
  405. //                        $firstHalf = $halfMontant;
  406. //                        $secondHalf = $halfMontantPret - $halfMontant;
  407. //                    } else {
  408. //                        $firstHalf = $secondHalf = $halfMontant;
  409. //                    }
  410. //
  411. //                    if ($firstHalf > $montantSalaireAnciennte) {
  412. //                        $minus = round(($firstHalf - $montantSalaireAnciennte), 2);
  413. //                        $montantSalaireBaseMinus  = round(($montantSalaireBase  - ($secondHalf + $minus)), 2);
  414. //                        $montantSalaireAnciennteMinus = 0;
  415. //                    } else {
  416. //                        $montantSalaireBaseMinus  = round(($montantSalaireBase - $secondHalf), 2);
  417. //                        $montantSalaireAnciennteMinus = round(($montantSalaireAnciennte - $firstHalf), 2);
  418. //                    }
  419. //
  420. //
  421. //
  422. //                    array_push($details, [
  423. //                        'prime' => $salaireBase,
  424. //                        'montant' => round($montantSalaireBase - $montantSalaireBaseMinus, 2)
  425. //                    ]);
  426. //                    if ($bordoreau->getNatureContract()->getType()->getId() == 1 and $salaireAnciennte and $bordoreau->getType() == 'paie') {
  427. //                        array_push($details, [
  428. //                            'prime' => $salaireAnciennte,
  429. //                            'montant' => round($montantSalaireAnciennte - $montantSalaireAnciennteMinus, 2)
  430. //                        ]);
  431. //                    }
  432. //
  433. //                    $montantSalaireBase = $montantSalaireBaseMinus;
  434. //                    $montantSalaireAnciennte = $montantSalaireAnciennteMinus;
  435. //                }
  436. //
  437. //                array_push($halfMontantPretArray, [
  438. //                    'id' => $prevelementCab['id'],
  439. //                    'prelevement' => $prevelementCab,
  440. //                    'montant' => $halfMontantPret,
  441. //                    'montantInitial' => $prevelementCab['montant'],
  442. //                    'details' => $details
  443. //                ]);
  444. //            }
  445. //        }
  446. //
  447. //        // echo json_encode($halfMontantPretArray);
  448. //        // die;
  449. //        foreach ($primesArrayInitital as $primesArray) {
  450. //            $pcompteComptable = $this->entityManager->getRepository(PCompteComptable::class)->findOneBy(['rubrique' => $primesArray['prime']->getRubrique(), 'natureContract' => $bordoreau->getNatureContract()]);
  451. //
  452. //            $journalBulletinLg = new JournalBulletinLg();
  453. //            $journalBulletinLg->setRubrique($primesArray['prime']->getRubrique());
  454. //            $journalBulletinLg->setBulletin($bulletin);
  455. //            if (count($halfMontantPretArray) == 0) {
  456. //                $journalBulletinLg->setMontant(round($primesArray['montantInitial'], 2));
  457. //            } else {
  458. //                $journalBulletinLg->setMontant(round($primesArray['montantFinal'], 2));
  459. //            }
  460. //            $journalBulletinLg->setQte($pcompteComptable->getQte());
  461. //            $journalBulletinLg->setCodeComptable($pcompteComptable->getCompteComptable());
  462. //            $journalBulletinLg->setType($type);
  463. //            $journalBulletinLg->setSens($pcompteComptable->getSens());
  464. //
  465. //            $this->entityManager->persist($journalBulletinLg);
  466. //
  467. //            $this->charge += $journalBulletinLg->getMontant();
  468. //        }
  469. //        // echo json_decode($prevelements);die;
  470. //        foreach ($prevelements as $prevelement) {
  471. //            // echo json_decode($prevelement['rubrique_id']);
  472. //            // die;
  473. //            $rubrique = $this->entityManager->getRepository(Prubrique::class)->find($prevelement['rubrique_id']);
  474. //            $pcompteComptable = $this->entityManager->getRepository(PCompteComptable::class)->findOneBy(['rubrique' => $rubrique, 'natureContract' => $bordoreau->getNatureContract()]);
  475. //
  476. //            $journalBulletinLg = new JournalBulletinLg();
  477. //            $journalBulletinLg->setRubrique($rubrique);
  478. //            $journalBulletinLg->setBulletin($bulletin);
  479. //            $journalBulletinLg->setMontant($prevelement['montant']);
  480. //            $journalBulletinLg->setQte($pcompteComptable->getQte());
  481. //            $journalBulletinLg->setCodeComptable($pcompteComptable->getCompteComptable());
  482. //            $journalBulletinLg->setType($type);
  483. //            $journalBulletinLg->setSens($pcompteComptable->getSens());
  484. //            if ($bordoreau->getDevise() && $bordoreau->getDevise()->getId() != 1) {
  485. //                $journalBulletinLg->setMontantDevise($prevelement['montantDevise']);
  486. //            }
  487. //            $this->entityManager->persist($journalBulletinLg);
  488. //
  489. //            $this->charge -= $journalBulletinLg->getMontant();
  490. //        }
  491. //
  492. //        $pcompteComptable = $this->entityManager->getRepository(PCompteComptable::class)->findOneBy(['rubrique' => $salaireBase->getRubrique(), 'natureContract' => $bordoreau->getNatureContract()]);
  493. //
  494. //        $journalBulletinLg = new JournalBulletinLg();
  495. //        $journalBulletinLg->setRubrique($salaireBase->getRubrique());
  496. //        $journalBulletinLg->setBulletin($bulletin);
  497. //        $journalBulletinLg->setMontant(round($montantSalaireBase, 2));
  498. //        $journalBulletinLg->setQte($pcompteComptable->getQte());
  499. //        $journalBulletinLg->setCodeComptable($pcompteComptable->getCompteComptable());
  500. //        $journalBulletinLg->setType($type);
  501. //        $journalBulletinLg->setSens($pcompteComptable->getSens());
  502. //        if ($bordoreau->getDevise() && $bordoreau->getDevise()->getId() != 1) {
  503. //            $journalBulletinLg->setMontantDevise($montantSalaireBaseDevise);
  504. //        }
  505. //
  506. //        $this->entityManager->persist($journalBulletinLg);
  507. //
  508. //        $this->charge += $journalBulletinLg->getMontant();
  509. //
  510. //        if ($bordoreau->getNatureContract()->getType()->getId() == 1 and $bordoreau->getType() == 'paie') {
  511. //            if(!$salaireAnciennte) {
  512. //                dd($salaireAnciennte, $bulletin);
  513. //            }
  514. //            $pcompteComptable = $this->entityManager->getRepository(PCompteComptable::class)->findOneBy(['rubrique' => $salaireAnciennte->getRubrique(), 'natureContract' => $bordoreau->getNatureContract()]);
  515. //
  516. //            $journalBulletinLg = new JournalBulletinLg();
  517. //            $journalBulletinLg->setRubrique($salaireAnciennte->getRubrique());
  518. //            $journalBulletinLg->setBulletin($bulletin);
  519. //            $journalBulletinLg->setMontant(round($montantSalaireAnciennte, 2));
  520. //            $journalBulletinLg->setQte($pcompteComptable->getQte());
  521. //            $journalBulletinLg->setCodeComptable($pcompteComptable->getCompteComptable());
  522. //            $journalBulletinLg->setType($type);
  523. //            $journalBulletinLg->setSens($pcompteComptable->getSens());
  524. //
  525. //            $this->entityManager->persist($journalBulletinLg);
  526. //
  527. //            $this->charge += $journalBulletinLg->getMontant();
  528. //        }
  529. //
  530. //        foreach ($halfMontantPretArray as $halfMontantPret) {
  531. //            $rubrique = $this->entityManager->getRepository(Prubrique::class)->find($halfMontantPret['prelevement']['rubrique_id']);
  532. //            $type = $rubrique->getDesignation();
  533. //            foreach ($halfMontantPret['details'] as $det) {
  534. //
  535. //                $pcompteComptable = $this->entityManager->getRepository(PCompteComptable::class)->findOneBy(['rubrique' => $det['prime']->getRubrique(), 'natureContract' => $bordoreau->getNatureContract()]);
  536. //                $journalBulletinLg = new JournalBulletinLg();
  537. //                $journalBulletinLg->setRubrique($det['prime']->getRubrique());
  538. //                $journalBulletinLg->setBulletin($bulletin);
  539. //                $journalBulletinLg->setMontant($det['montant']);
  540. //                $journalBulletinLg->setQte($pcompteComptable->getQte());
  541. //                $journalBulletinLg->setCodeComptable($pcompteComptable->getCompteComptable());
  542. //                $journalBulletinLg->setType($type);
  543. //                $journalBulletinLg->setSens($pcompteComptable->getSens());
  544. //
  545. //                $this->entityManager->persist($journalBulletinLg);
  546. //
  547. //                $this->charge += $journalBulletinLg->getMontant();
  548. //            }
  549. //
  550. //            $pcompteComptable = $this->entityManager->getRepository(PCompteComptable::class)->findOneBy(['rubrique' => $rubrique, 'natureContract' => $bordoreau->getNatureContract()]);
  551. //            $journalBulletinLg = new JournalBulletinLg();
  552. //            $journalBulletinLg->setRubrique($rubrique);
  553. //            $journalBulletinLg->setBulletin($bulletin);
  554. //            $journalBulletinLg->setMontant($halfMontantPret['montantInitial']);
  555. //            $journalBulletinLg->setQte($pcompteComptable->getQte());
  556. //            $journalBulletinLg->setCodeComptable($pcompteComptable->getCompteComptable());
  557. //            $journalBulletinLg->setType($type);
  558. //            $journalBulletinLg->setSens($pcompteComptable->getSens());
  559. //
  560. //            $this->entityManager->persist($journalBulletinLg);
  561. //
  562. //            $this->charge -= $journalBulletinLg->getMontant();
  563. //        }
  564. //    }
  565. //
  566. //
  567. //    function hasMoreThanTwoDecimals($number)
  568. //    {
  569. //        // Convert the number to a string to handle both integers and floats
  570. //        $numberStr = strval($number);
  571. //
  572. //        // Use a regular expression to check if the number has more than two decimals
  573. //        // The pattern matches a dot (decimal point), followed by at most two digits
  574. //        return preg_match('/\.\d{3,}/', $numberStr) === 1;
  575. //    }
  576. //
  577. //    function roundUpToNDecimals($number, $decimals)
  578. //    {
  579. //        $multiplier = pow(10, $decimals);
  580. //        return ceil($number * $multiplier) / $multiplier;
  581. //    }
  582. }