src/Services/EfacApiService.php line 250

Open in your IDE?
  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  */
  6. namespace App\Services;
  9. use App\Entity\Avoir;
  10. use App\Entity\AvoirMontantTva;
  11. use App\Entity\DocUpload;
  12. use App\Entity\EfacAuth;
  13. use App\Entity\EfacData;
  14. use App\Entity\Entreprise;
  15. use App\Entity\FactureFinance;
  16. use App\Entity\FactureFinanceMontantTva;
  17. use App\Entity\Fournisseur;
  18. use App\Entity\Project;
  19. use App\Entity\ProjectAvoir;
  20. use App\Entity\ProjectFactureFinance;
  21. use App\Entity\Spv;
  22. use App\Form\CentraleType;
  23. use App\Form\EntrepriseType;
  24. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  25. use Doctrine\ORM\EntityManagerInterface;
  26. use Symfony\Component\Form\FormFactoryInterface;
  27. use Symfony\Component\HttpFoundation\Response;
  28. use Symfony\Component\HttpFoundation\Session\Flash\FlashBagInterface;
  29. use Symfony\Contracts\Translation\TranslatorInterface;
  30. use Symfony\Component\Security\Core\Security;
  31. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  32. use Twig\Environment;
  33. use App\Entity\Centrale;
  34. use Symfony\Component\Validator\Constraints as Assert;
  35. use Symfony\Component\Validator\Validator\ValidatorInterface;
  36. use Symfony\Component\Validator\Validation;
  37. use Symfony\Component\HttpClient\HttpClient;
  39. class EfacApiService
  40. {
  42.     private $em;
  43.     private $params;
  45.     public function __construct(
  46.         ParameterBagInterface $params,
  47.         EntityManagerInterface $em,
  48.         Notifications $notifications
  49.     ) {
  50.         $this->em = $em;
  51.         $this->params = $params;
  52.         $this->notification = $notifications;
  53.     }
  55.     public function authApiEfac($publicKey,$secretKey){
  56.         if (!$publicKey || !$secretKey) {
  57.             return ['error' => 'Clés manquantes' , 'status'=> Response::HTTP_UNAUTHORIZED];
  58.         }
  59.         $client = $this->em->getRepository(EfacAuth::class)->findOneBy(['publicKey' => $publicKey]);
  60.         if (!$client) {
  61.             return ['error' => 'Clé publique invalide' , 'status'=> Response::HTTP_FORBIDDEN];
  62.         }
  63.         if ($client && $client->getSecretKey() !== $secretKey ) {
  64.             return ['error' => 'Clé secrète invalide' , 'status'=> Response::HTTP_FORBIDDEN];
  65.         }
  66.         if ($client && !$client->getIsEnabled() ) {
  67.             return ['error' => 'Accès non activés' , 'status'=> Response::HTTP_FORBIDDEN];
  68.         }
  69.         return ['message' => 'Accès autorisé' , 'status'=> Response::HTTP_OK];
  71.     }
  73.     public function getTypeDocument($type){
  74.         if(in_array($type,[EfacData::document_facture_affacturee,
  75.                            EfacData::document_facture_auto_facturee,
  76.                            EfacData::document_facture_auto_facturee_affacturee,
  77.                            EfacData::document_facture_commercial,
  78.                            EfacData::document_facture_rectificative,
  79.                            EfacData::document_facture_rectificative_affacturee,
  80.                            EfacData::document_facture_rectificative_auto_facturee_affacturee,
  81.                            EfacData::document_facture_rectificative_auto_facturee
  82.         ])){
  83.             return EfacData::type_facture;
  84.         }
  85.         elseif (in_array($type,[EfacData::document_acompte_facture,EfacData::document_acompte_auto_facture])){
  86.             return EfacData::type_acompte;
  87.         }elseif  (in_array($type,[EfacData::document_avoir,
  88.                                   EfacData::document_avoir_affacturee,
  89.                                   EfacData::document_avoir_auto_facture,
  90.                                   EfacData::document_avoir_auto_facture_affacturee,
  91.                                   EfacData::document_avoir_facture_acompte,
  92.                                   EfacData::document_avoir_remise_globale
  94.             ])){
  95.             return EfacData::type_avoir;
  96.         }else{
  97.             return null;
  98.         }
  99.     }
  101.     public function addFactureOrAvoir($request){
  102.         $data = json_decode($request->getContent(), true);
  103.         if (!$data) {
  104.             $this->addEfacDataLog('',$request->getContent(),'JSON invalide');
  105.             return ['error' => 'JSON invalide' , 'status'=> Response::HTTP_BAD_REQUEST];
  106.         }
  108.         //check field blanc date number choice
  109.         $validator = Validation::createValidator();
  110.         $constraint = new Assert\Collection([
  111.             'documentList' => [
  112.                 new Assert\NotBlank(),
  113.                 new Assert\Type('array'),
  114.                 new Assert\Count(['min' => 1]),
  115.                 new Assert\All([
  116.                     new Assert\Collection([
  117.                         'invoice_document_type' => [new Assert\NotBlank()],
  118.                         'invoice_international' => [new Assert\NotBlank(), new Assert\Choice(['0', '1'])],
  119.                         'invoice_status' => [new Assert\NotBlank(), new Assert\Choice(['Accepté', 'Rejeté'])],
  120.                         'invoice_number_efac' => [new Assert\NotBlank()],
  121.                         'invoice_number_fournisseur' => [new Assert\NotBlank()],
  122.                         'invoice_issue_date' => [new Assert\NotBlank(), new Assert\Date()],
  123.                         'invoice_due_date' => [new Assert\NotBlank(), new Assert\Date()],
  124.                         'invoice_supplier' => [new Assert\NotBlank()],
  125.                         'invoice_spv' => [new Assert\NotBlank()],
  126.                         'invoice_validation_history' => [new Assert\NotBlank()],
  127.                         'invoice_link' => [new Assert\NotBlank(), new Assert\Url()],
  128.                         'invoice_pa_id' => [new Assert\NotBlank()],
  129.                         'currency' => [new Assert\NotBlank()],
  130.                         // Lignes
  131.                         'line' => [
  132.                             new Assert\NotBlank(),
  133.                             new Assert\Type('array'),
  134.                             new Assert\Count(['min' => 1]),
  135.                             new Assert\All([
  136.                                 new Assert\Collection([
  137.                                     'unitPrice' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  138.                                     'number' => [new Assert\NotBlank(), new Assert\Type('integer')],
  139.                                     'note' => [new Assert\NotBlank()],
  140.                                     'unit' => [new Assert\NotBlank()],
  141.                                     'amount' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  142.                                     'quantity' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  143.                                     'vatType' => [new Assert\NotBlank()],
  144.                                     'vatRate' => [new Assert\NotBlank(), new Assert\Type('numeric')]
  145.                                 ])
  146.                             ])
  147.                         ],
  148.                         // Total
  149.                         'total' => [
  150.                             new Assert\NotBlank(),
  151.                             new Assert\Collection([
  152.                                 'accountingCurrency' => [new Assert\NotBlank()],
  153.                                 'amount' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  154.                                 'netPayable' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  155.                                 'netAmount' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  156.                                 'reductionAmount' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  157.                                 'costAmount' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  158.                                 'amountIncludingTax' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  159.                                 'vatAmount' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  160.                             ])
  161.                         ],
  162.                     ])
  163.                 ])
  164.             ],
  165.             'count' => [new Assert\NotBlank(), new Assert\Type('integer')],
  166.             'transactionId' => [new Assert\NotBlank()]
  167.         ]);
  169.         $violations = $validator->validate($data, $constraint);
  171.         if (count($violations) > 0) {
  172.             $errors = [];
  173.             foreach ($violations as $violation) {
  174.                 $errors[] = [
  175.                     'field' => $violation->getPropertyPath(),
  176.                     'message' => $violation->getMessage()
  177.                 ];
  178.             }
  179.             $this->addEfacDataLog($data['transactionId'],$request->getContent(),json_encode($errors));
  180.             return ['errors' => $errors , 'status'=> Response::HTTP_BAD_REQUEST];
  181.         }else{
  182.             $errors = [];
  183.             //check field data base de donnée
  184.             foreach ($data['documentList'] as $key=>&$datum){
  185.                 $typeDoc = $this->getTypeDocument($datum['invoice_document_type']);
  186.                 $numero = $datum['invoice_pa_id'];
  187.                 $codeFournisseur = $datum['invoice_supplier'];
  188.                 $codeSpv = $datum['invoice_spv'];
  189.                 if($typeDoc == EfacData::type_facture || $typeDoc == EfacData::type_acompte){
  190.                     $facture = $this->em->getRepository(FactureFinance::class)->findOneBy(['invoicePaId'=>$numero]);
  191.                     if($facture){
  192.                         $errors[] = [
  193.                             'field' => "[documentList][$key][invoice_pa_id]",
  194.                             'message' => "Ce numéro de facture existe déjà."
  195.                         ];
  196.                     }
  197.                 }elseif($typeDoc == EfacData::type_avoir){
  198.                     $avoir = $this->em->getRepository(Avoir::class)->findOneBy(['invoicePaId'=>$numero]);
  199.                     if($avoir){
  200.                         $errors[] = [
  201.                             'field' => "[documentList][$key][invoice_pa_id]",
  202.                             'message' => "Ce numéro d’avoir existe déjà."
  203.                         ];
  204.                     }
  205.                 }
  206.                 $spv = $this->em->getRepository(Spv::class)->findOneBy(['codeSage'=>$codeSpv]);
  207.                 $fournisseur = $this->em->getRepository(Fournisseur::class)->findNotArchiveByCodeSingle($codeFournisseur);
  208.                 if(!$spv){
  209.                     $errors[] = [
  210.                         'field' => "[documentList][$key][invoice_spv]",
  211.                         'message' => "Le code ne correspond à aucune SPV."
  212.                     ];
  213.                 }
  214.                 if(!$fournisseur){
  215.                     $errors[] = [
  216.                         'field' => "[documentList][$key][invoice_supplier]",
  217.                         'message' => "Le code ne correspond à aucun fournisseur."
  218.                     ];
  219.                 }
  220.                 $datum['spv'] = $spv;
  221.                 $datum['fournisseur'] = $fournisseur;
  223. //                $client = HttpClient::create();
  224. //                $response = $client->request('GET', $datum['invoice_link']);
  225. //                if ($response->getStatusCode() !== 200) {
  226. //                    $errors[] = [
  227. //                        'field' => "[documentList][$key][invoice_link]",
  228. //                        'message' => "URL de fichier erronée"
  229. //                    ];
  230. //                }
  231.             }
  232.             if (count($errors) > 0) {
  233.                 $this->addEfacDataLog($data['transactionId'],$request->getContent(),json_encode($errors));
  234.                 return ['errors' => $errors , 'status'=> Response::HTTP_CONFLICT];
  235.             }else{
  236.                 foreach ($data['documentList'] as $key=>$datum){
  237.                     $typeDoc = $this->getTypeDocument($datum['invoice_document_type']);
  238.                     if($typeDoc == EfacData::type_facture || $typeDoc == EfacData::type_acompte){
  239.                         $this->addFacture($datum);
  240.                     }elseif($typeDoc == EfacData::type_avoir){
  241.                         $this->addAvoir($datum);
  242.                     }
  243.                 }
  244.                 $this->addEfacDataLog($data['transactionId'],$request->getContent(),Response::HTTP_OK);
  245.                 return ['message' => 'Facture reçue et enregistrée' , 'status'=> Response::HTTP_OK];
  246.             }
  247.         }
  248.         return ['errors' => 'Requête invalide' , 'status'=> Response::HTTP_BAD_REQUEST];
  249.     }
  250.     public function addEfacDataLog($transactionId="",$data,$msg){
  251.         $dataLog = new EfacData();
  252.         $dataLog->setDataEfac($data);
  253.         $dataLog->setMsg($msg);
  254.         $dataLog->setTransactionId($transactionId);
  255.         $this->em->persist($dataLog);
  256.         $this->em->flush();
  257.     }
  259.     public function addFacture($data){
  260.         $typeDoc = $this->getTypeDocument($data['invoice_document_type']);
  261.         if($typeDoc == EfacData::type_acompte){
  262.             $type = 'Acompte';
  263.         }else{
  264.             $type = 'Facture';
  265.         }
  266.         $facture = new FactureFinance();
  267.         $facture->setIsRfe(true);
  268.         $facture->setNumeroFacture($data['invoice_number_fournisseur']);
  269.         $facture->setCategory($type);
  270.         $facture->setFournisseur($data['fournisseur']);
  271.         $facture->setSpv($data['spv']);
  272.         $facture->setDateFacture(new \DateTime($data['invoice_issue_date']));
  273.         $facture->setDelaiPaiementDate(new \DateTime($data['invoice_due_date']));
  274.         $facture->setDelaiPaiement((new \DateTime($data['invoice_due_date']))->diff(new \DateTime($data['invoice_issue_date']))->days);
  275. //        $doc = $this->importPdf($data['invoice_link']);
  276. //        if($doc){
  277. //            $facture->setFileFacture($doc);
  278. //        }
  279.         $facture->setUrlFacture($data['invoice_link']);
  280.         $facture->setStatus(FactureFinance::STATUS_A_COMPLETER);
  281.         $facture->setInvoiceDocumentType($data['invoice_document_type']);
  283.         $facture->setInvoiceCurrency($data['currency']);
  284.         $facture->setInvoiceInternational($data['invoice_international']);
  285.         $facture->setInvoiceStatus($data['invoice_status']);
  286.         $facture->setInvoiceNumberEfac($data['invoice_number_efac']);
  287.         $facture->setInvoicePaId($data['invoice_pa_id']);
  289.         $this->em->persist($facture);
  290.         $this->em->flush();
  292.         $facture->setTauxTva(0);
  294.         foreach ($data['line'] as $line){
  295.             $nbrDivision = 100;
  296.             $factureFinanceMantant = new FactureFinanceMontantTva();
  297.             $factureFinanceMantant->setFactureFinance($facture);
  298.             $factureFinanceMantant->setUnitPrice($line['unitPrice']/$nbrDivision);
  299.             $factureFinanceMantant->setNumber($line['number']);
  300.             $factureFinanceMantant->setNote($line['note']);
  301.             $factureFinanceMantant->setUnit($line['unit']);
  302.             $factureFinanceMantant->setMontantHt($line['amount']/$nbrDivision);
  303.             $factureFinanceMantant->setQuantity($line['quantity']);
  304.             $factureFinanceMantant->setVatType($line['vatType']);
  305.             $factureFinanceMantant->setTauxTva($line['vatRate']);
  306.             $montantTva = (($line['amount']/$nbrDivision) * $line['vatRate']) / 100 ;
  307.             if(in_array($line['vatType'],["E","AE","K","G","O","Z"])){
  308.                 $factureFinanceMantant->setMontantTtc($line['amount']/$nbrDivision);
  309.             }else{
  310.                 $montantTtc = $montantTva + ($line['amount']/$nbrDivision);
  311.                 $factureFinanceMantant->setMontantTtc($montantTtc);
  312.             }
  313.             $factureFinanceMantant->setTva($montantTva);
  314.             $this->em->persist($factureFinanceMantant);
  315.             $this->em->flush();
  316.         }
  318.         $nbrDivision = 100;
  319.         $facture->setInvoiceAccountingCurrency($data['total']['accountingCurrency']);
  320.         $facture->setMonatantHt($data['total']['amount']/$nbrDivision);
  321.         $facture->setInvoiceTtcNetPayable($data['total']['netPayable']/$nbrDivision);
  322.         $facture->setMonatantHtNetAmount($data['total']['netAmount']/$nbrDivision);
  323.         $facture->setInvoiceReductionAmount($data['total']['reductionAmount']/$nbrDivision);
  324.         $facture->setInvoiceCostAmount($data['total']['costAmount']/$nbrDivision);
  325.         $facture->setInvoiceTtcAmountIncludingTax($data['total']['amountIncludingTax']/$nbrDivision);
  326.         $facture->setTva($data['total']['vatAmount']/$nbrDivision);
  327.         $facture->setMonatantTtc(($data['total']['amount']/$nbrDivision) + ($data['total']['vatAmount']/$nbrDivision));
  329.         $this->em->persist($facture);
  330.         $this->em->flush();
  331.     }
  333.     public function addAvoir($data){
  334.         $avoir = new Avoir();
  335.         $avoir->setIsRfe(true);
  336.         $avoir->setNumeroAvoir($data['invoice_number_fournisseur']);
  337.         $avoir->setFournisseur($data['fournisseur']);
  338.         $avoir->setSpv($data['spv']);
  339.         $avoir->setDateAvoir(new \DateTime($data['invoice_issue_date']));
  340. //        $doc = $this->importPdf($data['invoice_link']);
  341. //        if($doc){
  342. //            $avoir->setFileAvoir($doc);
  343. //        }
  344.         $avoir->setUrlFacture($data['invoice_link']);
  345.         $avoir->setStatus(Avoir::STATUS_A_COMPLETER);
  346.         $avoir->setInvoiceDocumentType($data['invoice_document_type']);
  347.         $avoir->setTauxTva(0);
  348.         $avoir->setInvoiceCurrency($data['currency']);
  349.         $avoir->setInvoiceInternational($data['invoice_international']);
  350.         $avoir->setInvoiceStatus($data['invoice_status']);
  351.         $avoir->setInvoiceNumberEfac($data['invoice_number_efac']);
  352.         $avoir->setInvoicePaId($data['invoice_pa_id']);
  353.         $this->em->persist($avoir);
  354.         $this->em->flush();
  356.         foreach ($data['line'] as $line){
  357.             $nbrDivision = 100;
  358.             $avoirMantant = new AvoirMontantTva();
  359.             $avoirMantant->setAvoir($avoir);
  360.             $avoirMantant->setUnitPrice($line['unitPrice']/$nbrDivision);
  361.             $avoirMantant->setNumber($line['number']);
  362.             $avoirMantant->setNote($line['note']);
  363.             $avoirMantant->setUnit($line['unit']);
  364.             $avoirMantant->setMontantHt($line['amount']/$nbrDivision);
  365.             $avoirMantant->setQuantity($line['quantity']);
  366.             $avoirMantant->setVatType($line['vatType']);
  367.             $avoirMantant->setTauxTva($line['vatRate']);
  368.             $montantTva = (($line['amount']/$nbrDivision) * $line['vatRate']) / 100 ;
  369.             $montantTtc = $montantTva + ($line['amount']/$nbrDivision);
  370.             if(in_array($line['vatType'],["E","AE","K","G","O","Z"])){
  371.                 $avoirMantant->setMontantTtc($line['amount']/$nbrDivision);
  372.             }else{
  373.                 $montantTtc = $montantTva + ($line['amount']/$nbrDivision);
  374.                 $avoirMantant->setMontantTtc($montantTtc);
  375.             }
  376.             $avoirMantant->setTva($montantTva);
  377.             $this->em->persist($avoirMantant);
  378.             $this->em->flush();
  379.         }
  381.         $nbrDivision = 100;
  382.         $avoir->setInvoiceAccountingCurrency($data['total']['accountingCurrency']);
  383.         $avoir->setMonatantHt($data['total']['amount']/$nbrDivision);
  384.         $avoir->setInvoiceTtcNetPayable($data['total']['netPayable']/$nbrDivision);
  385.         $avoir->setMonatantHtNetAmount($data['total']['netAmount']/$nbrDivision);
  386.         $avoir->setInvoiceReductionAmount($data['total']['reductionAmount']/$nbrDivision);
  387.         $avoir->setInvoiceCostAmount($data['total']['costAmount']/$nbrDivision);
  388.         $avoir->setInvoiceTtcAmountIncludingTax($data['total']['amountIncludingTax']/$nbrDivision);
  389.         $avoir->setTva($data['total']['vatAmount']/$nbrDivision);
  390.         $avoir->setMonatantTtc(($data['total']['amount']/$nbrDivision) + ($data['total']['vatAmount']/$nbrDivision));
  392.         $this->em->persist($avoir);
  393.         $this->em->flush();
  394.     }
  396.     public function addFactureV2($data){
  397.         $typeDoc = $this->getTypeDocument($data['invoice_document_type']);
  398.         if($typeDoc == EfacData::type_acompte){
  399.             $type = 'Acompte';
  400.         }else{
  401.             $type = 'Facture';
  402.         }
  403.         $facture = new FactureFinance();
  404.         $facture->setIsRfe(false);
  405.         $facture->setIsRfe2(true);
  406.         $facture->setNumeroFacture($data['invoice_number_fournisseur']);
  407.         $facture->setCategory($type);
  408.         $facture->setFournisseur($data['fournisseur']);
  409.         $facture->setSpv($data['spv']);
  410.         $facture->setDateFacture(new \DateTime($data['invoice_issue_date']));
  411.         $facture->setDelaiPaiementDate(new \DateTime($data['invoice_due_date']));
  412.         $facture->setDelaiPaiement((new \DateTime($data['invoice_due_date']))->diff(new \DateTime($data['invoice_issue_date']))->days);
  413.         $facture->setUrlFacture($data['invoice_link']);
  414.         if( $data['invoice_status'] == 'Rejeté'){
  415.             $facture->setStatus(FactureFinance::STATUS_REFUS);
  416.         }else{
  417.             $facture->setStatus(FactureFinance::STATUS_A_COMPLETER);
  418.         }
  420.         $facture->setInvoiceDocumentType($data['invoice_document_type']);
  421.         $facture->setInvoiceInternational($data['invoice_international']);
  422.         $facture->setInvoiceStatus($data['invoice_status']);
  423.         $facture->setInvoiceNumberEfac($data['invoice_number_efac']);
  424.         $facture->setInvoicePaId($data['invoice_pa_id']);
  426.         // Montants bruts (pas de division par 100 en V2)
  427.         $facture->setMonatantHt($data['invoice_amount_ht']);
  428.         $facture->setTauxTva($data['invoice_vat_rate']);
  429.         $facture->setTva($data['invoice_amount_vat']);
  430.         $facture->setMonatantTtc($data['invoice_amount_ttc']);
  432.         // Nouveaux attributs V2
  433.         $facture->setInvoiceCodeRef1($data['invoice_codeREF1']);
  434.         $facture->setInvoiceRefProjet($data['invoice_ref_projet']);
  435.         $facture->setInvoiceValideurN1($data['invoice_valideur_N1']);
  436.         $facture->setInvoiceValideurN2($data['invoice_valideur_N2']);
  437.         $facture->setInvoiceValideurN3($data['invoice_valideur_N3']);
  438.         $facture->setInvoiceDateValidationN1($this->parseDate($data['invoice_date_validation_N1']));
  439.         $facture->setInvoiceDateValidationN2($this->parseDate($data['invoice_date_validation_N2']));
  440.         $facture->setInvoiceDateValidationN3($this->parseDate($data['invoice_date_validation_N3']));
  442.         // Lien vers le projet (invoice_ref_projet = codeProject)
  443.         if(!empty($data['project'])){
  444.             $projectFactureFinance = new ProjectFactureFinance();
  445.             $projectFactureFinance->setProject($data['project']);
  446.             $projectFactureFinance->setFactureFinance($facture);
  447.             $facture->addProjectFactureFinance($projectFactureFinance);
  448.             $this->em->persist($projectFactureFinance);
  449.         }
  451.         $this->em->persist($facture);
  452.         $this->em->flush();
  453.         $this->notification->setCompteurErpiPiece($facture);
  454.         $this->notification->setCompteurErpiEcriture($facture);
  455.     }
  457.     public function addAvoirV2($data){
  458.         $avoir = new Avoir();
  459.         $avoir->setIsRfe(false);
  460.         $avoir->setIsRfe2(true);
  461.         $avoir->setNumeroAvoir($data['invoice_number_fournisseur']);
  462.         $avoir->setFournisseur($data['fournisseur']);
  463.         $avoir->setSpv($data['spv']);
  464.         $avoir->setDateAvoir(new \DateTime($data['invoice_issue_date']));
  465.         $avoir->setUrlFacture($data['invoice_link']);
  466.         if( $data['invoice_status'] == 'Rejeté'){
  467.             $avoir->setStatus(Avoir::STATUS_REFUS);
  468.         }else{
  469.             $avoir->setStatus(Avoir::STATUS_A_COMPLETER);
  470.         }
  471.         $avoir->setInvoiceDocumentType($data['invoice_document_type']);
  472.         $avoir->setInvoiceInternational($data['invoice_international']);
  473.         $avoir->setInvoiceStatus($data['invoice_status']);
  474.         $avoir->setInvoiceNumberEfac($data['invoice_number_efac']);
  475.         $avoir->setInvoicePaId($data['invoice_pa_id']);
  477.         // Montants bruts (pas de division par 100 en V2)
  478.         $avoir->setMonatantHt($data['invoice_amount_ht']);
  479.         $avoir->setTauxTva($data['invoice_vat_rate']);
  480.         $avoir->setTva($data['invoice_amount_vat']);
  481.         $avoir->setMonatantTtc($data['invoice_amount_ttc']);
  483.         // Nouveaux attributs V2
  484.         $avoir->setInvoiceCodeRef1($data['invoice_codeREF1']);
  485.         $avoir->setInvoiceRefProjet($data['invoice_ref_projet']);
  486.         $avoir->setInvoiceValideurN1($data['invoice_valideur_N1']);
  487.         $avoir->setInvoiceValideurN2($data['invoice_valideur_N2']);
  488.         $avoir->setInvoiceValideurN3($data['invoice_valideur_N3']);
  489.         $avoir->setInvoiceDateValidationN1($this->parseDate($data['invoice_date_validation_N1']));
  490.         $avoir->setInvoiceDateValidationN2($this->parseDate($data['invoice_date_validation_N2']));
  491.         $avoir->setInvoiceDateValidationN3($this->parseDate($data['invoice_date_validation_N3']));
  493.         // Lien vers le projet (invoice_ref_projet = codeProject)
  494.         if(!empty($data['project'])){
  495.             $projectAvoir = new ProjectAvoir();
  496.             $projectAvoir->setProject($data['project']);
  497.             $projectAvoir->setAvoir($avoir);
  498.             $avoir->addProjectAvoir($projectAvoir);
  499.             $this->em->persist($projectAvoir);
  500.         }
  502.         $this->em->persist($avoir);
  503.         $this->em->flush();
  504.         $this->notification->setCompteurErpiPiece(null,$avoir);
  505.         $this->notification->setCompteurErpiEcriture(null,$avoir);
  506.     }
  508.     private function parseDate($value)
  509.     {
  510.         if (empty($value)) {
  511.             return null;
  512.         }
  513.         return new \DateTime($value);
  514.     }
  516.     public function importPdf($url)
  517.     {
  518.         $client = HttpClient::create();
  519.         $response = $client->request('GET', $url);
  520.         if ($response->getStatusCode() !== 200) {
  521.             return null;
  522.         }
  523.         $content = $response->getContent();
  524.         $name = md5(uniqid());
  525.         $contentType = $response->getHeaders()['content-type'][0];
  526.         $extension = explode('/', $contentType)[1];
  528.         file_put_contents(
  529.             $this->params->get('kernel.project_dir') . '/public/uploads/'.$name.'.'.$extension,
  530.             $content
  531.         );
  532.         $doc = new DocUpload();
  533.         $doc->setName('document');
  534.         $doc->setPath($name.'.'.$extension);
  535.         $this->em->persist($doc);
  536.         $this->em->flush();
  537.         return $doc;
  538.     }
  540.     public function addFactureOrAvoirV2($request){
  541.         $data = json_decode($request->getContent(), true);
  542.         if (!$data) {
  543.             $this->addEfacDataLog('',$request->getContent(),'JSON invalide');
  544.             return ['error' => 'JSON invalide' , 'status'=> Response::HTTP_BAD_REQUEST];
  545.         }
  547.         //check field blanc date number choice
  548.         $validator = Validation::createValidator();
  549.         $constraint = new Assert\Collection([
  550.             'documentList' => [
  551.                 new Assert\NotBlank(),
  552.                 new Assert\Type('array'),
  553.                 new Assert\Count(['min' => 1]),
  554.                 new Assert\All([
  555.                     new Assert\Collection([
  556.                         'invoice_document_type' => [new Assert\NotBlank()],
  557.                         'invoice_international' => [new Assert\NotBlank(), new Assert\Choice(['0', '1'])],
  558.                         'invoice_status' => [new Assert\NotBlank(), new Assert\Choice(['Accepté', 'Rejeté'])],
  559.                         'invoice_number_efac' => [new Assert\NotBlank()],
  560.                         'invoice_number_fournisseur' => [new Assert\NotBlank()],
  561.                         'invoice_issue_date' => [new Assert\Date()],
  562.                         'invoice_due_date' => [new Assert\NotBlank(), new Assert\Date()],
  563.                         'invoice_supplier' => [new Assert\NotBlank()],
  564.                         'invoice_codeREF1' => [new Assert\NotBlank()],
  565.                         'invoice_spv' => [new Assert\NotBlank()],
  566.                         'invoice_amount_ht' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  567.                         'invoice_vat_rate' => [new Assert\Optional([new Assert\Type('numeric')])],
  568.                         'invoice_amount_vat' => [new Assert\Optional([new Assert\Type('numeric')])],
  569.                         'invoice_amount_ttc' => [new Assert\NotBlank(), new Assert\Type('numeric')],
  570.                         'invoice_valideur_N1' => [],
  571.                         'invoice_valideur_N2' => [],
  572.                         'invoice_valideur_N3' => [],
  573.                         'invoice_date_validation_N1' => [ new Assert\Date()],
  574.                         'invoice_date_validation_N2' => [ new Assert\Date()],
  575.                         'invoice_date_validation_N3' => [ new Assert\Date()],
  576.                         'invoice_link' => [new Assert\NotBlank()],
  577.                         'invoice_pa_id' => [],
  578.                         'invoice_ref_projet' => [],
  579.                     ])
  580.                 ])
  581.             ],
  582.             'count' => [new Assert\NotBlank(), new Assert\Type('integer')],
  583.             'transactionId' => [new Assert\NotBlank()]
  584.         ]);
  586.         $violations = $validator->validate($data, $constraint);
  588.         if (count($violations) > 0) {
  589.             $errors = [];
  590.             foreach ($violations as $violation) {
  591.                 $errors[] = [
  592.                     'field' => $violation->getPropertyPath(),
  593.                     'message' => $violation->getMessage()
  594.                 ];
  595.             }
  596.             $this->addEfacDataLog($data['transactionId'],$request->getContent(),json_encode($errors));
  597.             return ['errors' => $errors , 'status'=> Response::HTTP_BAD_REQUEST];
  598.         }else{
  599.             $errors = [];
  600.             //check field data base de donnée
  601.             foreach ($data['documentList'] as $key=>&$datum){
  602.                 $typeDoc = $this->getTypeDocument($datum['invoice_document_type']);
  603.                 $numero = $datum['invoice_number_efac'];
  604.                 $codeFournisseur = $datum['invoice_supplier'];
  605.                 $codeSpv = $datum['invoice_spv'];
  606.                 if($typeDoc == EfacData::type_facture || $typeDoc == EfacData::type_acompte){
  607.                     $facture = $this->em->getRepository(FactureFinance::class)->findOneBy(['invoiceNumberEfac'=>$numero]);
  608.                     if($facture){
  609.                         $errors[] = [
  610.                             'field' => "[documentList][$key][invoice_number_efac]",
  611.                             'message' => "Ce numéro de facture existe déjà."
  612.                         ];
  613.                     }
  614.                 }elseif($typeDoc == EfacData::type_avoir){
  615.                     $avoir = $this->em->getRepository(Avoir::class)->findOneBy(['invoiceNumberEfac'=>$numero]);
  616.                     if($avoir){
  617.                         $errors[] = [
  618.                             'field' => "[documentList][$key][invoice_number_efac]",
  619.                             'message' => "Ce numéro d’avoir existe déjà."
  620.                         ];
  621.                     }
  622.                 }
  623.                 $spv = $this->em->getRepository(Spv::class)->findOneBy(['raisonSociale'=>$codeSpv]);
  624.                 $fournisseur = $this->em->getRepository(Fournisseur::class)->findNotArchiveByCodeSingle($codeFournisseur);
  625.                 $project = $this->em->getRepository(Project::class)->findOneBy(['codeProject'=>$datum['invoice_ref_projet']]);
  626.                 if(!$spv){
  627.                     $errors[] = [
  628.                         'field' => "[documentList][$key][invoice_spv]",
  629.                         'message' => "Le siren ne correspond à aucune SPV."
  630.                     ];
  631.                 }
  632.                 if(!$fournisseur){
  633.                     $errors[] = [
  634.                         'field' => "[documentList][$key][invoice_supplier]",
  635.                         'message' => "Le code ne correspond à aucun fournisseur."
  636.                     ];
  637.                 }
  638.                 // Projet introuvable = non bloquant : la facture/avoir est créée sans lien projet.
  639.                 $datum['spv'] = $spv;
  640.                 $datum['fournisseur'] = $fournisseur;
  641.                 $datum['project'] = $project;
  643. //                $client = HttpClient::create();
  644. //                $response = $client->request('GET', $datum['invoice_link']);
  645. //                if ($response->getStatusCode() !== 200) {
  646. //                    $errors[] = [
  647. //                        'field' => "[documentList][$key][invoice_link]",
  648. //                        'message' => "URL de fichier erronée"
  649. //                    ];
  650. //                }
  651.             }
  652.             if (count($errors) > 0) {
  653.                 $this->addEfacDataLog($data['transactionId'],$request->getContent(),json_encode($errors));
  654.                 return ['errors' => $errors , 'status'=> Response::HTTP_CONFLICT];
  655.             }else{
  656.                 foreach ($data['documentList'] as $key=>$datum){
  657.                     $typeDoc = $this->getTypeDocument($datum['invoice_document_type']);
  658.                     if($typeDoc == EfacData::type_facture || $typeDoc == EfacData::type_acompte){
  659.                         $this->addFactureV2($datum);
  660.                     }elseif($typeDoc == EfacData::type_avoir){
  661.                         $this->addAvoirV2($datum);
  662.                     }else{
  663.                         $errors[] = [
  664.                             'field' => "[documentList][$key][invoice_document_type]",
  665.                             'message' => "Le type de document ne correspond ni à une facture ni à un avoir."
  666.                         ];
  667.                         $this->addEfacDataLog($data['transactionId'],$request->getContent(),json_encode($errors));
  668.                         return ['errors' => $errors , 'status'=> Response::HTTP_CONFLICT];
  669.                     }
  670.                 }
  671.                 $this->addEfacDataLog($data['transactionId'],$request->getContent(),Response::HTTP_OK);
  672.                 return ['message' => 'Facture reçue et enregistrée' , 'status'=> Response::HTTP_OK];
  673.             }
  674.         }
  675.         return ['errors' => 'Requête invalide' , 'status'=> Response::HTTP_BAD_REQUEST];
  676.     }
  677. }