src/Controller/ImportazioneController.php line 5227

  1. <?php
  2. namespace App\Controller;
  3. use App\Entity\AlberoMenuProdotti;
  4. use App\Entity\AnagraficaOpzioniAggiuntive;
  5. use App\Entity\Anagrafiche;
  6. use App\Entity\AnagraficheBlocchi;
  7. use App\Entity\AnagraficheIndirizzi;
  8. use App\Entity\Articoli;
  9. use App\Entity\AssociazioneArticoliCliente;
  10. use App\Entity\AssociazioneArticoliTipoOrdine;
  11. use App\Entity\AssociazioneAttributi;
  12. use App\Entity\AssociazioneCategorieAlberoMappaCategorieArticoli;
  13. use App\Entity\AssociazioneCodiciAgentiUtente;
  14. use App\Entity\AssociazioneSpedizioniClienti;
  15. use App\Entity\Attributi;
  16. use App\Entity\BarcodeArticoli;
  17. use App\Entity\Categorie;
  18. use App\Entity\CategorieAlbero;
  19. use App\Entity\Consegna;
  20. use App\Entity\Destinazioni;
  21. use App\Entity\DisponibilitaAFasce;
  22. use App\Entity\Documenti;
  23. use App\Entity\DocumentiRighe;
  24. use App\Entity\FiltroVisualizzazioneArticoliClienti;
  25. use App\Entity\LimitazioniOrdinazioniArticoli;
  26. use App\Entity\ListiniVendita;
  27. use App\Entity\MagazziniSecondari;
  28. use App\Entity\MagazzinoSecondarioDisponibilita;
  29. use App\Entity\MailSecondarieUtenti;
  30. use App\Entity\MappaCategorieArticoli;
  31. use App\Entity\Nazioni;
  32. use App\Entity\OfferteAllegati;
  33. use App\Entity\OfferteRegistroEventi;
  34. use App\Entity\OfferteRighe;
  35. use App\Entity\Ordini;
  36. use App\Entity\Pagamenti;
  37. use App\Entity\Report;
  38. use App\Entity\RisorseAnagrafiche;
  39. use App\Entity\RisorseAnagraficheColonne;
  40. use App\Entity\RisorseAnagraficheColonneValori;
  41. use App\Entity\ScontiAnagrafiche;
  42. use App\Entity\Spedizione;
  43. use App\Entity\TipoOrdine;
  44. use App\Entity\UnitaMisura;
  45. use App\Entity\User;
  46. use App\Entity\Varianti;
  47. use App\Entity\Offerte;
  48. use App\Model\Caching\Caching_Categorie;
  49. use App\Model\Caching\Caching_CategorieAlbero;
  50. use App\Model\Entita\OffertaRegistroEventi;
  51. use App\Model\Google\GoogleMapsAPI;
  52. use App\Model\Mailer;
  53. use App\Model\Translating\Translating;
  54. use Doctrine\DBAL\Exception;
  55. use Psr\Log\LoggerInterface;
  56. use Symfony\Component\Filesystem\Filesystem;
  57. use Symfony\Component\HttpFoundation\Request;
  58. use Symfony\Component\HttpFoundation\Response;
  59. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  60. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  61. use Symfony\Component\Routing\Annotation\Route;
  62. /**
  63.  *
  64.  */
  65. class ImportazioneController extends AbstractController
  66. {
  67.     /** @var ServiziController */
  68.     private $servizi;
  69.     /** @var ReturnImpostazioniServiceController */
  70.     private $imp;
  71.     /** @var Translating */
  72.     private $translating;
  73.     /** @var Mailer */
  74.     private $mailer;
  75.     /** @var LoggerInterface */
  76.     private $logger;
  77.     /** @var UserPasswordHasherInterface */
  78.     private $passwordHasher;
  79.     /**
  80.      * ImportazioneController constructor.
  81.      * @param ServiziController $servizi
  82.      * @param ReturnImpostazioniServiceController $imp
  83.      * @param Translating $translating
  84.      * @param Mailer $mailer
  85.      * @param LoggerInterface $logger
  86.      * @param UserPasswordHasherInterface $passwordHasher
  87.      */
  88.     public function __construct(ServiziController $serviziReturnImpostazioniServiceController $impTranslating $translatingMailer $mailerLoggerInterface $loggerUserPasswordHasherInterface $passwordHasher)
  89.     {
  90.         $this->servizi $servizi;
  91.         $this->imp $imp;
  92.         $this->translating $translating;
  93.         $this->mailer $mailer;
  94.         $this->logger $logger;
  95.         $this->passwordHasher $passwordHasher;
  96.         $this->imp->caricaCacheImpostazioniDaFamiglie(['Importazioni']);
  97.     }
  98.     /**
  99.      * @param $ip string
  100.      * @param $debug string
  101.      * @param boolean $esito
  102.      * @param $messaggio string
  103.      * @param $utente User
  104.      */
  105.     function ScriviRegistroAttivita($em$ip$debug$esito$messaggio$utente$collegamento=''$categoria1=''$categoria2='')
  106.     {
  107.         $this->servizi->ScriviRegistroAttivita($ip$debug$esito$messaggio$utente$collegamento$categoria1$categoria2);
  108.     }
  109.     function endsWith($haystack$needle)
  110.     {
  111.         $length strlen($needle);
  112.         if ($length == 0) {
  113.             return true;
  114.         }
  115.         return (substr($haystack, -$length) === $needle);
  116.     }
  117.     /**
  118.      * @param $path
  119.      * @return string
  120.      */
  121.     function verificaPathImg($path){
  122.         if($path == '')
  123.             return '';
  124.         if(strpos($path"/uploads/") !== false){
  125.             return $path;
  126.         }else if (strpos($path"/") !== false){
  127.                return "/uploads" $path;
  128.         }else{
  129.             return "/uploads/" $path;
  130.         }
  131.     }
  132.     /**
  133.      * @param $valore
  134.      * @param $seVuotoMetti0
  135.      * @return int|mixed
  136.      */
  137.     function verificaInt($valore$seVuotoMetti0 true){
  138.         if($valore == '' and $seVuotoMetti0){
  139.             $valore 0;
  140.         }
  141.         return $valore;
  142.     }
  143.     /**
  144.      * @param $valore
  145.      * @param $seVuotoMettiFalse
  146.      * @return false|mixed
  147.      */
  148.     function verificaBool($valore$seVuotoMettiFalse true){
  149.         if($valore == '' and $seVuotoMettiFalse){
  150.             $valore false;
  151.         }
  152.         return $valore;
  153.     }
  154.     /**
  155.      * @param $stringa
  156.      * @param false $ancheOra
  157.      * @return \DateTime|null
  158.      */
  159.     private static function OttieniDataDaStringa($stringa$ancheOra false){
  160.         $ritorno null;
  161.         try {
  162.             if ($stringa != '') {
  163.                 if ($ancheOra) {
  164.                     $ritorno \DateTime::createFromFormat('Y-m-d H:i:s'$stringa);
  165.                 } else {
  166.                     $ritorno \DateTime::createFromFormat('Y-m-d'$stringa);
  167.                 }
  168.             }
  169.         } catch (\Exception|\Throwable $ex){
  170.         }
  171.         if($ritorno === false)
  172.             $ritorno null;
  173.         return $ritorno;
  174.     }
  175.     /**
  176.      * @Route("/caricaArticoliDb/{svuota}/{dbg}", name="carica_articoli_db", defaults={"svuota"="0", "dbg"="0"})
  177.      */
  178.     public function caricaArticoliDbAction(Request $request$svuota$dbg)
  179.     {
  180.         $collegamentoRnd $this->servizi->randomString2();
  181.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  182.             ini_set('max_execution_time', -1);
  183.             ini_set('memory_limit''4G');
  184.             if($dbg == '1'){
  185.                 ini_set('display_errors',1);
  186.                 error_reporting(E_ALL);
  187.             }
  188.             $start microtime(true);
  189.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  190.             $em $this->servizi->doctrine->getManager();
  191.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaArticoliDb/' $svuota ' --- Inizio il caricamento degli articoli'null$collegamentoRnd'ImportazioneController''caricaArticoliDb');
  192.             $connection $this->servizi->doctrine->getConnection();
  193.             if($svuota == "1"){
  194.                 $em $this->servizi->doctrine->getManager();
  195.                 $connection->beginTransaction();
  196.                 try {
  197.                     $connection->query("SET FOREIGN_KEY_CHECKS=0;");
  198.                     $connection->executeUpdate("TRUNCATE `albero_menu_prodotti`;");
  199.                     $connection->executeUpdate("TRUNCATE `articoli`;");
  200.                     $connection->executeUpdate("TRUNCATE `articoli_in_lingua`;");
  201.                     $connection->executeUpdate("TRUNCATE `associazione_articoli_cliente`;");
  202.                     $connection->executeUpdate("TRUNCATE `associazione_attributi`;");
  203.                     $connection->executeUpdate("TRUNCATE `attributi`;");
  204.                     $connection->executeUpdate("TRUNCATE `attributi_in_lingua`;");
  205.                     $connection->executeUpdate("TRUNCATE `carrello`;");
  206.                     $connection->executeUpdate("TRUNCATE `categorie`;");
  207.                     $connection->executeUpdate("TRUNCATE `categorie_in_lingua`;");
  208.                     $connection->executeUpdate("TRUNCATE `combinazione_albero_mappa_categorie_articoli`;");
  209.                     $connection->executeUpdate("TRUNCATE `listini_vendita`;");
  210.                     $connection->executeUpdate("TRUNCATE `magazzino_secondario_disponibilita`;");
  211.                     $connection->executeUpdate("TRUNCATE `mappa_categorie_articoli`;");
  212.                     $connection->executeUpdate("TRUNCATE `ordini`;");
  213.                     $connection->executeUpdate("TRUNCATE `ordini_righe`;");
  214.                     $connection->executeUpdate("TRUNCATE `righe_carrello`;");
  215.                     $connection->executeUpdate("TRUNCATE `statistiche_categorie`;");
  216.                     $connection->executeUpdate("TRUNCATE `statistiche_click_articoli`;");
  217.                     $connection->executeUpdate("TRUNCATE `tipologie_preimpostate`;");
  218.                     $connection->executeUpdate("TRUNCATE `tipologie_preimpostate_lista`;");
  219.                     $connection->executeUpdate("TRUNCATE `unita_misura`;");
  220.                     $connection->executeUpdate("TRUNCATE `varianti`;");
  221.                     $connection->executeUpdate("TRUNCATE `varianti_in_lingua`;");
  222.                     $connection->query("SET FOREIGN_KEY_CHECKS=1;");
  223.                     $connection->commit();
  224.                 }catch (\Exception|\Throwable $ex){
  225.                     $this->servizi->DebuggaException($ex"Errore pulizia articoli DB"falsenull$collegamentoRnd'ImportazioneController''caricaArticoliDb');
  226.                 }
  227.             }
  228.             $bool_rigeneraAlbero false;
  229.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  230.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  231.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  232.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  233.             $root_path $pathFileBase "articoli.csv";
  234.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  235.             $contatore 0;
  236.             $row 0;
  237.             $queryEseguite 0;
  238.             $batch_size 100;
  239.             $errori "";
  240.             /*
  241.              * TRACCIATO FILE IMPORTAZIONE articoli.csv
  242.              *
  243.                 0    codice articolo
  244.                 1    nome articolo
  245.                 2    descrizione breve
  246.                 3    descrizione estesa articolo
  247.                 4    immagine minuatura
  248.                 5    immagine
  249.                 6    codice aliquota
  250.                 7    valore aliquota
  251.                 8    unita di misura
  252.                 9    codice categoria
  253.                 10    descrizione categoria
  254.                 11    codice sub-categoria 1
  255.                 12    descrizione sub-categoria 1
  256.                 13    codice sub-categoria 2
  257.                 14    descrizione sub-categoria 2
  258.                 15    codice sub-categoria 3
  259.                 16    descrizione sub-categoria 3
  260.                 17    marca
  261.                 18    operazione
  262.                 19    disponibilita
  263.                 20    um_peso
  264.                 21    peso netto
  265.                 22    peso lordo
  266.                 23    codice originale importazione
  267.                 24    prezzo a richiesta
  268.                 25    codice sub-categoria 4
  269.                 26    descrizione sub-categoria 4
  270.                 27  immagine cat1
  271.                 28  immagine cat2
  272.                 29  immagine cat3
  273.                 30  immagine cat4
  274.                 31  immagine cat5
  275.                 32    ordine_categoria1
  276.                 33    ordine_categoria2
  277.                 34    ordine_categoria3
  278.                 35    ordine_categoria4
  279.                 36    ordine_categoria5
  280.                 37    ordine_articolo
  281.                 38    ordine_mappa
  282.                 39  barcode
  283.                 50  ordini_fornitori
  284.              */
  285.             try {
  286.                 if (($handle fopen($root_path"r")) !== false) {
  287.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  288.                         /*if(!$em->isOpen()){
  289.                             $em = $em->create(
  290.                                 $em->getConnection(),
  291.                                 $em->getConfiguration()
  292.                             );
  293.                         }*/
  294.                         if ($row == 0) {
  295.                             $row 1;
  296.                             continue;
  297.                         }
  298.                         //
  299.                         if ($queryEseguite >= $batch_size) {
  300.                             $contatore $contatore $row;
  301.                             $row 1;
  302.                             $queryEseguite 0;
  303.                             $em->flush();
  304.                             $em->clear();
  305.                         }
  306.                         $now = new \DateTime('now');
  307.                         /**
  308.                          * @var $cat1 Categorie
  309.                          * @var $cat2 Categorie
  310.                          * @var $cat3 Categorie
  311.                          * @var $cat4 Categorie
  312.                          * @var $cat5 Categorie
  313.                          * @var $articolo Articoli
  314.                          */
  315.                         $cat1 null;
  316.                         $cat2 null;
  317.                         $cat3 null;
  318.                         $cat4 null;
  319.                         $cat5 null;
  320.                         $articolo null;
  321.                         try {
  322.                             //categoria
  323.                             if ($data[9] != "") {
  324.                                 $categoriaPresente $this->servizi->ritornaCategoriaSeInserita(substr($data[9], 0255), '1');
  325.                                 if ($categoriaPresente != null) {
  326.                                     $categoriaPresente->setNome(substr($data[10], 0255));
  327.                                     $categoriaPresente->setOrdinamento(count($data) >= 33 ? ($data[32] != '' ? (int)$data[32] : 0) : 0);
  328.                                     if(count($data) >= 28 && $data[27] != '')
  329.                                         $categoriaPresente->setImmagine(count($data) >= 28 self::verificaPathImg($data[27]) : '');
  330.                                     $categoriaPresente->setDataModifica($now);
  331.                                     $categoriaPresente->setUtente(null);
  332.                                     $em->persist($categoriaPresente);
  333.                                     $cat1 $categoriaPresente;
  334.                                 } else {
  335.                                     $cat = new Categorie();
  336.                                     $cat->setNome(substr($data[10], 0255));
  337.                                     $cat->setCodice(substr($data[9], 0255));
  338.                                     $cat->setColonnaProvenienza("1");
  339.                                     $cat->setOrdinamento(count($data) >= 33 ? ($data[32] != '' ? (int)$data[32] : 0) : 0);
  340.                                     $cat->setDescrizione('');
  341.                                     if(count($data) >= 28 && $data[27] != '')
  342.                                         $cat->setImmagine(count($data) >= 28 self::verificaPathImg($data[27]) : '');
  343.                                     $cat->setDataCreazione($now);
  344.                                     $cat->setDataModifica($now);
  345.                                     $cat->setNomeUnivoco(substr($cat->getNome() . '-' $cat->getCodice(), 0255));
  346.                                     $cat->setUtente(null);
  347.                                     $cat->setAttivo(true);
  348.                                     $em->persist($cat);
  349.                                     if (!$bool_rigeneraAlbero)
  350.                                         $bool_rigeneraAlbero true;
  351.                                     $cat1 $cat;
  352.                                 }
  353.                                 $em->flush();
  354.                                 $queryEseguite++;
  355.                             }
  356.                             //riclassifica lib 1
  357.                             if ($data[11] != "") {
  358.                                 $categoriaPresente $this->servizi->ritornaCategoriaSeInserita(substr($data[11], 0255), '2');
  359.                                 if ($categoriaPresente != null) {
  360.                                     $categoriaPresente->setNome(substr($data[12], 0255));
  361.                                     if(count($data) >= 28 && $data[27] != '')
  362.                                         $categoriaPresente->setImmagine(count($data) >= 29 self::verificaPathImg($data[28]) : '');
  363.                                     $categoriaPresente->setDataModifica($now);
  364.                                     $categoriaPresente->setOrdinamento(count($data) >= 34 ? ($data[33] != '' ? (int)$data[33] : 0) : 0);
  365.                                     $categoriaPresente->setUtente(null);
  366.                                     $em->persist($categoriaPresente);
  367.                                     $cat2 $categoriaPresente;
  368.                                 } else {
  369.                                     $cat = new Categorie();
  370.                                     $cat->setNome(substr($data[12], 0255));
  371.                                     $cat->setCodice(substr($data[11], 0255));
  372.                                     $cat->setColonnaProvenienza("2");
  373.                                     $cat->setOrdinamento(count($data) >= 34 ? ($data[33] != '' ? (int)$data[33] : 0) : 0);
  374.                                     $cat->setDescrizione('');
  375.                                     if(count($data) >= 28 && $data[27] != '')
  376.                                         $cat->setImmagine(count($data) >= 29 self::verificaPathImg($data[28]) : '');
  377.                                     $cat->setDataCreazione($now);
  378.                                     $cat->setDataModifica($now);
  379.                                     $cat->setNomeUnivoco(substr($cat->getNome() . '-' $cat->getCodice(), 0255));
  380.                                     $cat->setUtente(null);
  381.                                     $cat->setAttivo(true);
  382.                                     $em->persist($cat);
  383.                                     if (!$bool_rigeneraAlbero)
  384.                                         $bool_rigeneraAlbero true;
  385.                                     $cat2 $cat;
  386.                                 }
  387.                                 $em->flush();
  388.                                 $queryEseguite++;
  389.                             }
  390.                             //riclassifica lib 2
  391.                             if ($data[13] != "") {
  392.                                 $categoriaPresente $this->servizi->ritornaCategoriaSeInserita(substr($data[13], 0255), '3');
  393.                                 if ($categoriaPresente != null) {
  394.                                     $categoriaPresente->setNome(substr($data[14], 0255));
  395.                                     $categoriaPresente->setDataModifica($now);
  396.                                     $categoriaPresente->setOrdinamento(count($data) >= 35 ? ($data[34] != '' ? (int)$data[34] : 0) : 0);
  397.                                     if(count($data) >= 28 && $data[27] != '')
  398.                                         $categoriaPresente->setImmagine(count($data) >= 30 self::verificaPathImg($data[29]) : '');
  399.                                     $categoriaPresente->setUtente(null);
  400.                                     $em->persist($categoriaPresente);
  401.                                     $cat3 $categoriaPresente;
  402.                                 } else {
  403.                                     $cat = new Categorie();
  404.                                     $cat->setNome(substr($data[14], 0255));
  405.                                     $cat->setCodice(substr($data[13], 0255));
  406.                                     $cat->setColonnaProvenienza("3");
  407.                                     $cat->setOrdinamento(count($data) >= 35 ? ($data[34] != '' ? (int)$data[34] : 0) : 0);
  408.                                     $cat->setDescrizione('');
  409.                                     if(count($data) >= 28 && $data[27] != '')
  410.                                         $cat->setImmagine(count($data) >= 30 self::verificaPathImg($data[29]) : '');
  411.                                     $cat->setDataCreazione($now);
  412.                                     $cat->setDataModifica($now);
  413.                                     $cat->setNomeUnivoco(substr($cat->getNome() . '-' $cat->getCodice(), 0255));
  414.                                     $cat->setUtente(null);
  415.                                     $cat->setAttivo(true);
  416.                                     $em->persist($cat);
  417.                                     if (!$bool_rigeneraAlbero)
  418.                                         $bool_rigeneraAlbero true;
  419.                                     $cat3 $cat;
  420.                                 }
  421.                                 $em->flush();
  422.                                 $queryEseguite++;
  423.                             }
  424.                             //riclassifica lib 3
  425.                             if ($data[15] != "") {
  426.                                 $categoriaPresente $this->servizi->ritornaCategoriaSeInserita(substr($data[15], 0255), '4');
  427.                                 if ($categoriaPresente != null) {
  428.                                     $categoriaPresente->setNome(substr($data[16], 0255));
  429.                                     $categoriaPresente->setDataModifica($now);
  430.                                     $categoriaPresente->setOrdinamento(count($data) >= 36 ? ($data[35] != '' ? (int)$data[35] : 0) : 0);
  431.                                     if(count($data) >= 28 && $data[27] != '')
  432.                                         $categoriaPresente->setImmagine(count($data) >= 31 self::verificaPathImg($data[30]) : '');
  433.                                     $categoriaPresente->setUtente(null);
  434.                                     $em->persist($categoriaPresente);
  435.                                     $cat4 $categoriaPresente;
  436.                                 } else {
  437.                                     $cat = new Categorie();
  438.                                     $cat->setNome(substr($data[16], 0255));
  439.                                     $cat->setCodice(substr($data[15], 0255));
  440.                                     $cat->setOrdinamento(count($data) >= 36 ? ($data[35] != '' ? (int)$data[35] : 0) : 0);
  441.                                     $cat->setColonnaProvenienza("4");
  442.                                     $cat->setDescrizione('');
  443.                                     if(count($data) >= 28 && $data[27] != '')
  444.                                         $cat->setImmagine(count($data) >= 31 self::verificaPathImg($data[30]) : '');
  445.                                     $cat->setDataCreazione($now);
  446.                                     $cat->setDataModifica($now);
  447.                                     $cat->setNomeUnivoco(substr($cat->getNome() . '-' $cat->getCodice(), 0255));
  448.                                     $cat->setUtente(null);
  449.                                     $cat->setAttivo(true);
  450.                                     $em->persist($cat);
  451.                                     if (!$bool_rigeneraAlbero)
  452.                                         $bool_rigeneraAlbero true;
  453.                                     $cat4 $cat;
  454.                                 }
  455.                                 $em->flush();
  456.                                 $queryEseguite++;
  457.                             }
  458.                             //riclassifica lib 4
  459.                             if (count($data) >= 26 && $data[25] != "") {
  460.                                 $categoriaPresente $this->servizi->ritornaCategoriaSeInserita(substr($data[25], 0255), '5');
  461.                                 if ($categoriaPresente != null) {
  462.                                     $categoriaPresente->setNome(substr($data[26], 0255));
  463.                                     $categoriaPresente->setDataModifica($now);
  464.                                     $categoriaPresente->setOrdinamento(count($data) >= 37 ? ($data[36] != '' ? (int)$data[36] : 0) : 0);
  465.                                     if(count($data) >= 28 && $data[27] != '')
  466.                                         $categoriaPresente->setImmagine(count($data) >= 32 self::verificaPathImg($data[31]) : '');
  467.                                     $categoriaPresente->setUtente(null);
  468.                                     $em->persist($categoriaPresente);
  469.                                     $cat4 $categoriaPresente;
  470.                                 } else {
  471.                                     $cat = new Categorie();
  472.                                     $cat->setNome(substr($data[26], 0255));
  473.                                     $cat->setCodice(substr($data[25], 0255));
  474.                                     $cat->setColonnaProvenienza("5");
  475.                                     $cat->setOrdinamento(count($data) >= 37 ? ($data[36] != '' ? (int)$data[36] : 0) : 0);
  476.                                     $cat->setDescrizione('');
  477.                                     if(count($data) >= 28 && $data[27] != '')
  478.                                         $cat->setImmagine(count($data) >= 32 self::verificaPathImg($data[31]) : '');
  479.                                     $cat->setDataCreazione($now);
  480.                                     $cat->setDataModifica($now);
  481.                                     $cat->setNomeUnivoco(substr($cat->getNome() . '-' $cat->getCodice(), 0255));
  482.                                     $cat->setUtente(null);
  483.                                     $cat->setAttivo(true);
  484.                                     $em->persist($cat);
  485.                                     if (!$bool_rigeneraAlbero)
  486.                                         $bool_rigeneraAlbero true;
  487.                                     $cat5 $cat;
  488.                                 }
  489.                                 $em->flush();
  490.                                 $queryEseguite++;
  491.                             }
  492.                             $unitaMisura $em->find(UnitaMisura::class,$data[8]);
  493.                             if (!$unitaMisura) {
  494.                                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true"Nuova unita di misura trovata: " $data[8], null);
  495.                                 $unitaMisura = new UnitaMisura();
  496.                                 $unitaMisura->setDataCreazione(new \DateTime());
  497.                                 $unitaMisura->setDataModifica(new \DateTime());
  498.                                 $unitaMisura->setAttivo(true);
  499.                                 $unitaMisura->setFattoreConversione(1);
  500.                                 $unitaMisura->setCodice($data[8]);
  501.                                 $unitaMisura->setNumeroDecimali(0);
  502.                                 $em->persist($unitaMisura);
  503.                                 $em->flush();
  504.                                 $unitaMisura $em->find(UnitaMisura::class,$data[8]);
  505.                                 $queryEseguite++;
  506.                             }
  507.                             if ($data[8] != $data[20]) { //Verifico se UM peso e UM sono diverse
  508.                                 $umPeso $em->find(UnitaMisura::class,$data[20]);
  509.                             } else {
  510.                                 $umPeso $unitaMisura;
  511.                             }
  512.                             if (!$umPeso && $data[20] != '') {
  513.                                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true"Nuova unita di misura peso trovata: " $data[20], null);
  514.                                 $umPeso = new UnitaMisura();
  515.                                 $umPeso->setDataCreazione(new \DateTime());
  516.                                 $umPeso->setDataModifica(new \DateTime());
  517.                                 $umPeso->setAttivo(true);
  518.                                 $umPeso->setFattoreConversione(1);
  519.                                 $umPeso->setCodice($data[20]);
  520.                                 $umPeso->setNumeroDecimali(3);
  521.                                 $em->persist($umPeso);
  522.                                 $em->flush();
  523.                                 $umPeso $em->find(UnitaMisura::class,$data[20]);
  524.                                 $queryEseguite++;
  525.                             }
  526.                             $articoloPresente $this->servizi->ritornaArticoloSeInserito(substr($data[0], 0255), substr($data[9], 0255));
  527.                             //articolo
  528.                             if ($articoloPresente != null) {
  529.                                 $articoloPresente->setNome(substr($data[1], 0255));
  530.                                 $articoloPresente->setDescrizione($data[3]);
  531.                                 $articoloPresente->setOrdinamento(count($data) >= 38 ? ($data[37] != '' ? (int)$data[37] : 0) : 0);
  532.                                 $articoloPresente->setDescrizioneBreve(substr($data[2], 0255));
  533.                                 $articoloPresente->setCodiceGruppoArticoli('');
  534.                                 $articoloPresente->setCodiceAliquota($data[6]);
  535.                                 $articoloPresente->setUmPeso($umPeso);
  536.                                 if($data[5] != '')
  537.                                     $articoloPresente->setImage(self::verificaPathImg($data[5]));
  538.                                 $pesoNet str_replace(",""."$data[21]);
  539.                                 if (!is_numeric($pesoNet) || $pesoNet 99999.9)
  540.                                     $pesoNet 0;
  541.                                 $pesoLord str_replace(",""."$data[22]);
  542.                                 if (!is_numeric($pesoLord) || $pesoLord 99999.9)
  543.                                     $pesoLord 0;
  544.                                 $articoloPresente->setPesoNetto($pesoNet);
  545.                                 $articoloPresente->setPesoLordo($pesoLord);
  546.                                 $articoloPresente->setValoreAliquota($data[7] == '' str_replace(",""."$data[7]));
  547.                                 $articoloPresente->setDataModifica($now);
  548.                                 $articoloPresente->setCodiceImportazione(count($data) >= 24 substr($data[23], 0255) : '');
  549.                                 $articoloPresente->setUtente(null);
  550.                                 $articoloPresente->setPrezzoSuRichiesta(count($data) >= 25 ? ($data[24] == '1' true false) : false);
  551.                                 $articoloPresente->setUm($unitaMisura);
  552.                                 $articoloPresente->setAttivo(true);
  553.                                 $em->persist($articoloPresente);
  554.                                 $articolo $articoloPresente;
  555.                             } else {
  556.                                 $art = new Articoli();
  557.                                 $art->setCodice(substr($data[0], 0255));
  558.                                 $art->setMacroCategoria(substr($data[9], 0255));
  559.                                 $art->setNome(substr($data[1], 0255));
  560.                                 $art->setDescrizione($data[3]);
  561.                                 $art->setOrdinamento(count($data) >= 38 ? ($data[37] != '' ? (int)$data[37] : 0) : 0);
  562.                                 if($data[5] != '')
  563.                                     $art->setImage(self::verificaPathImg($data[5]));
  564.                                 $art->setDescrizioneBreve(substr($data[2], 0255));
  565.                                 $art->setCodiceGruppoArticoli('');
  566.                                 $art->setCodiceAliquota($data[6]);
  567.                                 $art->setValoreAliquota($data[7] == '' str_replace(",""."$data[7]));
  568.                                 $art->setUmPeso($umPeso);
  569.                                 $pesoNet str_replace(",""."$data[21]);
  570.                                 if (!is_numeric($pesoNet))
  571.                                     $pesoNet 0;
  572.                                 $pesoLord str_replace(",""."$data[22]);
  573.                                 if (!is_numeric($pesoLord))
  574.                                     $pesoLord 0;
  575.                                 $art->setPesoNetto($pesoNet);
  576.                                 $art->setPesoLordo($pesoLord);
  577.                                 $art->setUm($unitaMisura);
  578.                                 $art->setDataCreazione($now);
  579.                                 $art->setDataModifica($now);
  580.                                 $art->setCodiceImportazione(count($data) >= 24 $data[23] : '');
  581.                                 $art->setUtente(null);
  582.                                 $art->setTipologiePreimpostate(null);
  583.                                 $art->setUsaTipologiePreimpostate(false);
  584.                                 $art->setPrezzoSuRichiesta(count($data) >= 25 ? ($data[24] == '1' true false) : false);
  585.                                 $art->setAttivo(true);
  586.                                 $em->persist($art);
  587.                                 $articolo $art;
  588.                             }
  589.                             $queryEseguite++;
  590.                             if (!$unitaMisura) {
  591.                                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Unita di misura: ' $data[8] . ' non trovata per l\' articolo: ' $data[0] . '-' $data[1], null$collegamentoRnd'ImportazioneController''caricaArticoliDb');
  592.                             }
  593.                             //mappa_categorie_articoli
  594.                             if ($mappaCategoriaArticoliPresente $this->servizi->ritornaMappaCategoriaArticoliSeInserita($articolo$cat1$cat2$cat3$cat4$data[17])) {
  595.                                 if($data[18] == 'E'){
  596.                                     $mappaCategoriaArticoliPresente->setAttivo(false);
  597.                                 }else{
  598.                                     $mappaCategoriaArticoliPresente->setAttivo(true);
  599.                                 }
  600.                                 $mappaCategoriaArticoliPresente->setDataModifica($now);
  601.                                 $mappaCategoriaArticoliPresente->setUtente(null);
  602.                                 $mappaCategoriaArticoliPresente->setCodiceGruppoCategorie(ServiziController::OttieniCodiceGruppoCategorieDaMappa($mappaCategoriaArticoliPresente));
  603.                                 $mappaCategoriaArticoliPresente->setOrdinamento(count($data) >= 39 ? ($data[38] != '' ? (int)$data[38] : 0) : 0);
  604.                                 $mappaCategoriaArticoliPresente->setDisponibile($data[19] == '' str_replace(",""."$data[19]));
  605.                                 $mappaCategoriaArticoliPresente->setOrdiniFornitori(count($data) >= 41 ? ($data[40] != '' str_replace(",""."$data[40]) : 0) : 0);
  606.                                 $em->persist($mappaCategoriaArticoliPresente);
  607.                             } else {
  608.                                 $mp = new MappaCategorieArticoli();
  609.                                 $mp->setCategoria1($cat1);
  610.                                 $mp->setCategoria2($cat2);
  611.                                 $mp->setCategoria3($cat3);
  612.                                 $mp->setCategoria4($cat4);
  613.                                 $mp->setCategoria5($cat5);
  614.                                 $mp->setUtente(null);
  615.                                 $mp->setMarca($data[17]);
  616.                                 $mp->setDataModifica($now);
  617.                                 $mp->setDataCreazione($now);
  618.                                 $mp->setCodiceGruppoCategorie(ServiziController::OttieniCodiceGruppoCategorieDaMappa($mp));
  619.                                 $mp->setOrdinamento(count($data) >= 39 ? ($data[38] != '' ? (int)$data[38] : 0) : 0);
  620.                                 $mp->setArticolo($articolo);
  621.                                 $mp->setVariantiPresenti(false);
  622.                                 $mp->setDisponibile($data[19] == '' str_replace(",""."$data[19]));
  623.                                 $mp->setAttivo(true);
  624.                                 $mp->setOrdiniFornitori(count($data) >= 41 ? ($data[40] != '' str_replace(",""."$data[40]) : 0) : 0);
  625.                                 $em->persist($mp);
  626.                                 $mappaCategoriaArticoliPresente $mp;
  627.                                 if (!$bool_rigeneraAlbero)
  628.                                     $bool_rigeneraAlbero true;
  629.                             }
  630.                             $queryEseguite++;
  631.                             $em->flush();
  632.                             if (count($data) >= 40 && $data[39] != ''){
  633.                                 $elenco = array();
  634.                                 if (strpos($data[39], ',') !== false){
  635.                                     $elenco explode(','$data[39]);
  636.                                 }else{
  637.                                     array_push($elenco$data[39]);
  638.                                 }
  639.                                 foreach ($elenco as $brc){
  640.                                     $barcode = new BarcodeArticoli();
  641.                                     $barcode->setBarcode($brc);
  642.                                     $barcode->setDataCreazione(new \DateTime());
  643.                                     $barcode->setDataModifica(new \DateTime());
  644.                                     $barcode->setMappaCategoriaArticoli($mappaCategoriaArticoliPresente);
  645.                                     $em->persist($barcode);
  646.                                 }
  647.                                 $em->flush();
  648.                             }
  649.                         }catch (Exception $ex2){
  650.                             if($em->isOpen()){
  651.                                 $em $em->resetManager();
  652.                             }
  653.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), $ex2->getTraceAsString(), false'Errore importazione (RIGA: ' . ($contatore $row) . ') : ' $ex2->getMessage() . '</br>' $ex2->getTraceAsString() . '</br>'null$collegamentoRnd'ImportazioneController''caricaArticoliDb');
  654.                             $errori .= ('Errore importazione (RIGA: ' . ($contatore $row) . ') : ' $ex2->getMessage() . '</br>' $ex2->getTraceAsString() . '</br>');
  655.                         }catch (\Exception|\Throwable $ex){
  656.                             if($em->isOpen()){
  657.                                 $em $em->resetManager();
  658.                             }
  659.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione (RIGA: ' . ($contatore $row) . ') : ' $ex->getMessage() . '</br>' $ex->getTraceAsString() . '</br>'null$collegamentoRnd'ImportazioneController''caricaArticoliDb');
  660.                             $errori .= ('Errore importazione (RIGA: ' . ($contatore $row) . ') : ' $ex->getMessage() . '</br>' $ex->getTraceAsString() . '</br>');
  661.                         }
  662.                         $row++;
  663.                     }
  664.                 }else{
  665.                     $errori .= "Impossibile aprire il file!";
  666.                 }
  667.                 //$row = $contatore + $row;
  668.                 $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row '</br>Errori:' $errorinull$collegamentoRnd'ImportazioneController''caricaArticoliDb');
  669.                 $messaggioSupporto "";
  670.                 if ($bool_rigeneraAlbero)
  671.                     $this->generaAlberoAction($request"1");
  672.                 return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds \n ' $row '\n' $messaggioSupporto);
  673.             } catch (Exception $ex2) {
  674.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex2->getTraceAsString(), false"Errore importazione articoli: " $ex2->getMessage(), null$collegamentoRnd'ImportazioneController''caricaArticoliDb');
  675.                 return new Response('Errore importazione (RIGA: ' . ($contatore $row) . ') : ' $ex2->getMessage() . '/n' $ex2->getTraceAsString());
  676.             } catch (\Exception|\Throwable $ex) {
  677.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false"Errore importazione articoli: " $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaArticoliDb');
  678.                 return new Response('Errore importazione (RIGA: ' . ($contatore $row) . ') : ' $ex->getMessage() . '/n' $ex->getTraceAsString());
  679.             }
  680.             //return new Response("Importazione completata || " . $time_elapsed_secs = microtime(true) - $start . " || secondi");
  681.         } else {
  682.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false"Errore importazione articoli: ERRORE_PERMESSO"null$collegamentoRnd'ImportazioneController''caricaArticoliDb');
  683.             return new Response("ERRORE PERMESSO");
  684.         }
  685.     } //OK
  686.     /**
  687.      * @Route("/caricaCategorieAlbero/{svuota}/{dbg}", name="carica_categorie_albero", defaults={"svuota"="0", "dbg"="0"})
  688.      */
  689.     public function caricaCategorieAlbero(Request $request$svuota$dbg)
  690.     {
  691.         $collegamentoRnd $this->servizi->randomString2();
  692.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  693.             ini_set('max_execution_time', -1);
  694.             ini_set('memory_limit''4G');
  695.             if($dbg == '1'){
  696.                 ini_set('display_errors',1);
  697.                 error_reporting(E_ALL);
  698.             }
  699.             $start microtime(true);
  700.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  701.             $em $this->servizi->doctrine->getManager();
  702.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaCategorieAlbero/' $svuota ' --- Inizio il caricamento delle categorie albero'null$collegamentoRnd'ImportazioneController''caricaCategorieAlbero');
  703.             $connection $this->servizi->doctrine->getConnection();
  704.             if($svuota == "1"){
  705.                 $em $this->servizi->doctrine->getManager();
  706.                 $connection->beginTransaction();
  707.                 try {
  708.                     $connection->query("SET FOREIGN_KEY_CHECKS=0;");
  709.                     $connection->executeUpdate("TRUNCATE `categorie_albero`;");
  710.                     $connection->executeUpdate("TRUNCATE `associazione_categorie_albero_mappa_categorie_articoli`;");
  711.                     $connection->query("SET FOREIGN_KEY_CHECKS=1;");
  712.                     $connection->commit();
  713.                 }catch (\Exception|\Throwable $ex){
  714.                     $this->servizi->DebuggaException($ex"Errore pulizia categorie albero DB"falsenull$collegamentoRnd'ImportazioneController''caricaCategorieAlbero');
  715.                 }
  716.             }
  717.             $bool_rigeneraAlbero false;
  718.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  719.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  720.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  721.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  722.             $root_path $pathFileBase "categorie_albero.csv";
  723.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  724.             $contatore 0;
  725.             $row 0;
  726.             $queryEseguite 0;
  727.             $batch_size 100;
  728.             $errori "";
  729.             $debugMessage "";
  730.             /*
  731.              * Index    File finale
  732.                     0    codice articolo
  733.                     1    codice_cat1
  734.                     2    codice_cat2
  735.                     3    codice_cat3
  736.                     4    codice_cat4
  737.                     5    codice_cat5
  738.                     6    marca
  739.                     7    codice_catAlbero1
  740.                     8    descrizione_catAlbero1
  741.                     9    immagine_catAlbero1
  742.                     10    ordine_catAlbero1
  743.                     11    prezzoARichiesta_catAlbero1
  744.                     12    codice_catAlbero2
  745.                     13    descrizione_catAlbero2
  746.                     14    immagine_catAlbero2
  747.                     15    ordine_catAlbero2
  748.                     16    prezzoARichiesta_catAlbero2
  749.                     17    codice_catAlbero3
  750.                     18    descrizione_catAlbero3
  751.                     19    immagine_catAlbero3
  752.                     20    ordine_catAlbero3
  753.                     21    prezzoARichiesta_catAlbero3
  754.                     22    codice_catAlbero4
  755.                     23    descrizione_catAlbero4
  756.                     24    immagine_catAlbero4
  757.                     25    ordine_catAlbero4
  758.                     26    prezzoARichiesta_catAlbero4
  759.                     27    codice_catAlbero5
  760.                     28    descrizione_catAlbero5
  761.                     29    immagine_catAlbero5
  762.                     30    ordine_catAlbero5
  763.                     31    prezzoARichiesta_catAlbero5
  764.                     32    operazione
  765.                     33    codice_catAlbero6
  766.                     34    descrizione_catAlbero6
  767.                     35    immagine_catAlbero6
  768.                     36    ordine_catAlbero6
  769.                     37    prezzoARichiesta_catAlbero6
  770.                     38    codice_catAlbero7
  771.                     39    descrizione_catAlbero7
  772.                     40    immagine_catAlbero7
  773.                     41    ordine_catAlbero7
  774.                     42    prezzoARichiesta_catAlbero7
  775.                     43    codice_catAlbero8
  776.                     44    descrizione_catAlbero8
  777.                     45    immagine_catAlbero8
  778.                     46    ordine_catAlbero8
  779.                     47    prezzoARichiesta_catAlbero8
  780.                     48    codice_catAlbero9
  781.                     49    descrizione_catAlbero9
  782.                     50    immagine_catAlbero9
  783.                     51    ordine_catAlbero9
  784.                     52    prezzoARichiesta_catAlbero9
  785.                     53    codice_catAlbero10
  786.                     54    descrizione_catAlbero10
  787.                     55    immagine_catAlbero10
  788.                     56    ordine_catAlbero10
  789.                     57    prezzoARichiesta_catAlbero10
  790.              */
  791.             $indici = array(
  792.                 "codiceArticolo" => 0,
  793.                 "codiceCat1" => 1,
  794.                 "codiceCat2" => 2,
  795.                 "codiceCat3" => 3,
  796.                 "codiceCat4" => 4,
  797.                 "codiceCat5" => 5,
  798.                 "marca" => 6,
  799.                 "codice_catAlbero1" => 7,
  800.                 "descrizione_catAlbero1" => 8,
  801.                 "immagine_catAlbero1" => 9,
  802.                 "ordine_catAlbero1" => 10,
  803.                 "prezzoARichiesta_catAlbero1" => 11,
  804.                 "codice_catAlbero2" => 12,
  805.                 "descrizione_catAlbero2" => 13,
  806.                 "immagine_catAlbero2" => 14,
  807.                 "ordine_catAlbero2" => 15,
  808.                 "prezzoARichiesta_catAlbero2" => 16,
  809.                 "codice_catAlbero3" => 17,
  810.                 "descrizione_catAlbero3" => 18,
  811.                 "immagine_catAlbero3" => 19,
  812.                 "ordine_catAlbero3" => 20,
  813.                 "prezzoARichiesta_catAlbero3" => 21,
  814.                 "codice_catAlbero4" => 22,
  815.                 "descrizione_catAlbero4" => 23,
  816.                 "immagine_catAlbero4" => 24,
  817.                 "ordine_catAlbero4" => 25,
  818.                 "prezzoARichiesta_catAlbero4" => 26,
  819.                 "codice_catAlbero5" => 27,
  820.                 "descrizione_catAlbero5" => 28,
  821.                 "immagine_catAlbero5" => 29,
  822.                 "ordine_catAlbero5" => 30,
  823.                 "prezzoARichiesta_catAlbero5" => 31,
  824.                 "operazione" => 32,
  825.                 "codice_catAlbero6" => 33,
  826.                 "descrizione_catAlbero6" => 34,
  827.                 "immagine_catAlbero6" => 35,
  828.                 "ordine_catAlbero6" => 36,
  829.                 "prezzoARichiesta_catAlbero6" => 37,
  830.                 "codice_catAlbero7" => 38,
  831.                 "descrizione_catAlbero7" => 39,
  832.                 "immagine_catAlbero7" => 40,
  833.                 "ordine_catAlbero7" => 41,
  834.                 "prezzoARichiesta_catAlbero7" => 42,
  835.                 "codice_catAlbero8" => 43,
  836.                 "descrizione_catAlbero8" => 44,
  837.                 "immagine_catAlbero8" => 45,
  838.                 "ordine_catAlbero8" => 46,
  839.                 "prezzoARichiesta_catAlbero8" => 47,
  840.                 "codice_catAlbero9" => 48,
  841.                 "descrizione_catAlbero9" => 49,
  842.                 "immagine_catAlbero9" => 50,
  843.                 "ordine_catAlbero9" => 51,
  844.                 "prezzoARichiesta_catAlbero9" => 52,
  845.                 "codice_catAlbero10" => 53,
  846.                 "descrizione_catAlbero10" => 54,
  847.                 "immagine_catAlbero10" => 55,
  848.                 "ordine_catAlbero10" => 56,
  849.                 "prezzoARichiesta_catAlbero10" => 57
  850.             );
  851.             try {
  852.                 $bool_rigeneraAlbero false;
  853.                 if (($handle fopen($root_path"r")) !== false) {
  854.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  855.                         /*if(!$em->isOpen()){
  856.                             $em = $em->create(
  857.                                 $em->getConnection(),
  858.                                 $em->getConfiguration()
  859.                             );
  860.                         }*/
  861.                         if ($row == 0) {
  862.                             $row 1;
  863.                             continue;
  864.                         }
  865.                         //
  866.                         if ($queryEseguite >= $batch_size) {
  867.                             $contatore $contatore $row;
  868.                             $row 1;
  869.                             $queryEseguite 0;
  870.                             $em->flush();
  871.                             $em->clear();
  872.                         }
  873.                         $now = new \DateTime('now');
  874.                         /**
  875.                          * @var $cat1 Categorie
  876.                          * @var $cat2 Categorie
  877.                          * @var $cat3 Categorie
  878.                          * @var $cat4 Categorie
  879.                          * @var $cat5 Categorie
  880.                          * @var $articolo Articoli
  881.                          */
  882.                         $cat1 null;
  883.                         $cat2 null;
  884.                         $cat3 null;
  885.                         $cat4 null;
  886.                         $cat5 null;
  887.                         $articolo null;
  888.                         try {
  889.                             $cat1 $this->servizi->ritornaCategoriaSeInserita($data[$indici['codiceCat1']], '1');
  890.                             $cat2 $this->servizi->ritornaCategoriaSeInserita($data[$indici['codiceCat2']], '2');
  891.                             $cat3 $this->servizi->ritornaCategoriaSeInserita($data[$indici['codiceCat3']], '3');
  892.                             $cat4 $this->servizi->ritornaCategoriaSeInserita($data[$indici['codiceCat4']], '4');
  893.                             $cat5 $this->servizi->ritornaCategoriaSeInserita($data[$indici['codiceCat5']], '5');
  894.                             $articolo $this->servizi->ritornaArticoloSeInserito($data[$indici['codiceArticolo']]);
  895.                             if($dbg){
  896.                                 $debugMessage .= ('RIGA: ' . ($contatore $row) . ' - Articolo: ' . ($articolo $articolo->getId() : 'null') . ' -  Cat1: ' . ($cat1 $cat1->getId() : 'null') . ' - Cat2: ' . ($cat2 $cat2->getId() : 'null') . ' - Cat3: ' . ($cat3 $cat3->getId() : 'null') . ' - Cat4: ' . ($cat4 $cat4->getId() : 'null') . ' - Cat5: ' . ($cat5 $cat5->getId() : 'null') . '</br>');
  897.                             }
  898.                             //mappa_categorie_articoli
  899.                             if ($mappaCategoriaArticoliPresente $this->servizi->ritornaMappaCategoriaArticoliSeInserita($articolo$cat1$cat2$cat3$cat4$data[$indici['marca']], $cat5)) {
  900.                                 $categoriaAlbero1 null;
  901.                                 $categoriaAlbero2 null;
  902.                                 $categoriaAlbero3 null;
  903.                                 $categoriaAlbero4 null;
  904.                                 $categoriaAlbero5 null;
  905.                                 $categoriaAlbero6 null;
  906.                                 $categoriaAlbero7 null;
  907.                                 $categoriaAlbero8 null;
  908.                                 $categoriaAlbero9 null;
  909.                                 $categoriaAlbero10 null;
  910.                                 $associazioneCatAlberoMappaCatArt null;
  911.                                 if ($data[$indici["codice_catAlbero1"]] != ''){
  912.                                     $categoriaAlbero1 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero1"]], '1');
  913.                                     if(!$categoriaAlbero1){
  914.                                         $categoriaAlbero1 = new CategorieAlbero();
  915.                                         $categoriaAlbero1->setCodice($data[$indici['codice_catAlbero1']]);
  916.                                         $categoriaAlbero1->setCodiceOriginale($data[$indici['codice_catAlbero1']]);
  917.                                         $categoriaAlbero1->setColonnaProvenienza("1");
  918.                                         $categoriaAlbero1->setAttivo(true);
  919.                                         $categoriaAlbero1->setDataCreazione(new \DateTime());
  920.                                     }
  921.                                     $categoriaAlbero1->setNome($data[$indici['descrizione_catAlbero1']]);
  922.                                     $categoriaAlbero1->setNomeUnivoco(substr($categoriaAlbero1->getNome() . '-' $categoriaAlbero1->getCodice(), 0255));
  923.                                     $categoriaAlbero1->setDescrizione($data[$indici['descrizione_catAlbero1']]);
  924.                                     $categoriaAlbero1->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero1']]));
  925.                                     if($data[$indici['immagine_catAlbero1']] != '')
  926.                                         $categoriaAlbero1->setImmagine($data[$indici['immagine_catAlbero1']]);
  927.                                     $categoriaAlbero1->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero1']]));
  928.                                     $categoriaAlbero1->setDataModifica(new \DateTime());
  929.                                     $em->persist($categoriaAlbero1);
  930.                                     $em->flush();
  931.                                     $categoriaAlbero1 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero1"]], '1');
  932.                                 }
  933.                                 if ($data[$indici["codice_catAlbero2"]] != ''){
  934.                                     $categoriaAlbero2 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero2"]], '2');
  935.                                     if(!$categoriaAlbero2){
  936.                                         $categoriaAlbero2 = new CategorieAlbero();
  937.                                         $categoriaAlbero2->setCodice($data[$indici['codice_catAlbero2']]);
  938.                                         $categoriaAlbero2->setCodiceOriginale($data[$indici['codice_catAlbero2']]);
  939.                                         $categoriaAlbero2->setColonnaProvenienza("2");
  940.                                         $categoriaAlbero2->setAttivo(true);
  941.                                         $categoriaAlbero2->setDataCreazione(new \DateTime());
  942.                                     }
  943.                                     $categoriaAlbero2->setNome($data[$indici['descrizione_catAlbero2']]);
  944.                                     $categoriaAlbero2->setNomeUnivoco(substr($categoriaAlbero2->getNome() . '-' $categoriaAlbero2->getCodice(), 0255));
  945.                                     $categoriaAlbero2->setDescrizione($data[$indici['descrizione_catAlbero2']]);
  946.                                     $categoriaAlbero2->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero2']]));
  947.                                     if($data[$indici['immagine_catAlbero2']] != '')
  948.                                         $categoriaAlbero2->setImmagine($data[$indici['immagine_catAlbero2']]);
  949.                                     $categoriaAlbero2->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero2']]));
  950.                                     $categoriaAlbero2->setDataModifica(new \DateTime());
  951.                                     $em->persist($categoriaAlbero2);
  952.                                     $em->flush();
  953.                                     $categoriaAlbero2 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero2"]], '2');
  954.                                 }
  955.                                 if ($data[$indici["codice_catAlbero3"]] != ''){
  956.                                     $categoriaAlbero3 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero3"]], '3');
  957.                                     if(!$categoriaAlbero3){
  958.                                         $categoriaAlbero3 = new CategorieAlbero();
  959.                                         $categoriaAlbero3->setCodice($data[$indici['codice_catAlbero3']]);
  960.                                         $categoriaAlbero3->setCodiceOriginale($data[$indici['codice_catAlbero3']]);
  961.                                         $categoriaAlbero3->setColonnaProvenienza("3");
  962.                                         $categoriaAlbero3->setAttivo(true);
  963.                                         $categoriaAlbero3->setDataCreazione(new \DateTime());
  964.                                     }
  965.                                     $categoriaAlbero3->setNome($data[$indici['descrizione_catAlbero3']]);
  966.                                     $categoriaAlbero3->setNomeUnivoco(substr($categoriaAlbero3->getNome() . '-' $categoriaAlbero3->getCodice(), 0255));
  967.                                     $categoriaAlbero3->setDescrizione($data[$indici['descrizione_catAlbero3']]);
  968.                                     $categoriaAlbero3->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero3']]));
  969.                                     if($data[$indici['immagine_catAlbero3']] != '')
  970.                                         $categoriaAlbero3->setImmagine($data[$indici['immagine_catAlbero3']]);
  971.                                     $categoriaAlbero3->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero3']]));
  972.                                     $categoriaAlbero3->setDataModifica(new \DateTime());
  973.                                     $em->persist($categoriaAlbero3);
  974.                                     $em->flush();
  975.                                     $categoriaAlbero3 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero3"]], '3');
  976.                                 }
  977.                                 if ($data[$indici["codice_catAlbero4"]] != ''){
  978.                                     $categoriaAlbero4 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero4"]], '4');
  979.                                     if(!$categoriaAlbero4){
  980.                                         $categoriaAlbero4 = new CategorieAlbero();
  981.                                         $categoriaAlbero4->setCodice($data[$indici['codice_catAlbero4']]);
  982.                                         $categoriaAlbero4->setCodiceOriginale($data[$indici['codice_catAlbero4']]);
  983.                                         $categoriaAlbero4->setColonnaProvenienza("4");
  984.                                         $categoriaAlbero4->setAttivo(true);
  985.                                         $categoriaAlbero4->setDataCreazione(new \DateTime());
  986.                                     }
  987.                                     $categoriaAlbero4->setNome($data[$indici['descrizione_catAlbero4']]);
  988.                                     $categoriaAlbero4->setNomeUnivoco(substr($categoriaAlbero4->getNome() . '-' $categoriaAlbero4->getCodice(), 0255));
  989.                                     $categoriaAlbero4->setDescrizione($data[$indici['descrizione_catAlbero4']]);
  990.                                     $categoriaAlbero4->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero4']]));
  991.                                     if($data[$indici['immagine_catAlbero4']] != '')
  992.                                         $categoriaAlbero4->setImmagine($data[$indici['immagine_catAlbero4']]);
  993.                                     $categoriaAlbero4->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero4']]));
  994.                                     $categoriaAlbero4->setDataModifica(new \DateTime());
  995.                                     $em->persist($categoriaAlbero4);
  996.                                     $em->flush();
  997.                                     $categoriaAlbero4 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero4"]], '4');
  998.                                 }
  999.                                 if ($data[$indici["codice_catAlbero5"]] != ''){
  1000.                                     $categoriaAlbero5 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero5"]], '5');
  1001.                                     if(!$categoriaAlbero5){
  1002.                                         $categoriaAlbero5 = new CategorieAlbero();
  1003.                                         $categoriaAlbero5->setCodice($data[$indici['codice_catAlbero5']]);
  1004.                                         $categoriaAlbero5->setCodiceOriginale($data[$indici['codice_catAlbero5']]);
  1005.                                         $categoriaAlbero5->setColonnaProvenienza("5");
  1006.                                         $categoriaAlbero5->setAttivo(true);
  1007.                                         $categoriaAlbero5->setDataCreazione(new \DateTime());
  1008.                                     }
  1009.                                     $categoriaAlbero5->setNome($data[$indici['descrizione_catAlbero5']]);
  1010.                                     $categoriaAlbero5->setNomeUnivoco(substr($categoriaAlbero5->getNome() . '-' $categoriaAlbero5->getCodice(), 0255));
  1011.                                     $categoriaAlbero5->setDescrizione($data[$indici['descrizione_catAlbero5']]);
  1012.                                     $categoriaAlbero5->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero5']]));
  1013.                                     if($data[$indici['immagine_catAlbero5']] != '')
  1014.                                         $categoriaAlbero5->setImmagine($data[$indici['immagine_catAlbero5']]);
  1015.                                     $categoriaAlbero5->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero5']]));
  1016.                                     $categoriaAlbero5->setDataModifica(new \DateTime());
  1017.                                     $em->persist($categoriaAlbero5);
  1018.                                     $em->flush();
  1019.                                     $categoriaAlbero5 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero5"]], '5');
  1020.                                 }
  1021.                                 if ($data[$indici["codice_catAlbero6"]] != ''){
  1022.                                     $categoriaAlbero6 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero6"]], '6');
  1023.                                     if(!$categoriaAlbero6){
  1024.                                         $categoriaAlbero6 = new CategorieAlbero();
  1025.                                         $categoriaAlbero6->setCodice($data[$indici['codice_catAlbero6']]);
  1026.                                         $categoriaAlbero6->setCodiceOriginale($data[$indici['codice_catAlbero6']]);
  1027.                                         $categoriaAlbero6->setColonnaProvenienza("6");
  1028.                                         $categoriaAlbero6->setAttivo(true);
  1029.                                         $categoriaAlbero6->setDataCreazione(new \DateTime());
  1030.                                     }
  1031.                                     $categoriaAlbero6->setNome($data[$indici['descrizione_catAlbero6']]);
  1032.                                     $categoriaAlbero6->setNomeUnivoco(substr($categoriaAlbero6->getNome() . '-' $categoriaAlbero6->getCodice(), 0255));
  1033.                                     $categoriaAlbero6->setDescrizione($data[$indici['descrizione_catAlbero6']]);
  1034.                                     $categoriaAlbero6->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero6']]));
  1035.                                     if($data[$indici['immagine_catAlbero6']] != '')
  1036.                                         $categoriaAlbero6->setImmagine($data[$indici['immagine_catAlbero6']]);
  1037.                                     $categoriaAlbero6->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero6']]));
  1038.                                     $categoriaAlbero6->setDataModifica(new \DateTime());
  1039.                                     $em->persist($categoriaAlbero6);
  1040.                                     $em->flush();
  1041.                                     $categoriaAlbero6 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero6"]], '6');
  1042.                                 }
  1043.                                 if ($data[$indici["codice_catAlbero7"]] != ''){
  1044.                                     $categoriaAlbero7 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero7"]], '7');
  1045.                                     if(!$categoriaAlbero7){
  1046.                                         $categoriaAlbero7 = new CategorieAlbero();
  1047.                                         $categoriaAlbero7->setCodice($data[$indici['codice_catAlbero7']]);
  1048.                                         $categoriaAlbero7->setCodiceOriginale($data[$indici['codice_catAlbero7']]);
  1049.                                         $categoriaAlbero7->setColonnaProvenienza("7");
  1050.                                         $categoriaAlbero7->setAttivo(true);
  1051.                                         $categoriaAlbero7->setDataCreazione(new \DateTime());
  1052.                                     }
  1053.                                     $categoriaAlbero7->setNome($data[$indici['descrizione_catAlbero7']]);
  1054.                                     $categoriaAlbero7->setNomeUnivoco(substr($categoriaAlbero7->getNome() . '-' $categoriaAlbero7->getCodice(), 0255));
  1055.                                     $categoriaAlbero7->setDescrizione($data[$indici['descrizione_catAlbero7']]);
  1056.                                     $categoriaAlbero7->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero7']]));
  1057.                                     if($data[$indici['immagine_catAlbero7']] != '')
  1058.                                         $categoriaAlbero7->setImmagine($data[$indici['immagine_catAlbero7']]);
  1059.                                     $categoriaAlbero7->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero7']]));
  1060.                                     $categoriaAlbero7->setDataModifica(new \DateTime());
  1061.                                     $em->persist($categoriaAlbero7);
  1062.                                     $em->flush();
  1063.                                     $categoriaAlbero7 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero7"]], '7');
  1064.                                 }
  1065.                                 if ($data[$indici["codice_catAlbero8"]] != ''){
  1066.                                     $categoriaAlbero8 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero8"]], '8');
  1067.                                     if(!$categoriaAlbero8){
  1068.                                         $categoriaAlbero8 = new CategorieAlbero();
  1069.                                         $categoriaAlbero8->setCodice($data[$indici['codice_catAlbero8']]);
  1070.                                         $categoriaAlbero8->setCodiceOriginale($data[$indici['codice_catAlbero8']]);
  1071.                                         $categoriaAlbero8->setColonnaProvenienza("8");
  1072.                                         $categoriaAlbero8->setAttivo(true);
  1073.                                         $categoriaAlbero8->setDataCreazione(new \DateTime());
  1074.                                     }
  1075.                                     $categoriaAlbero8->setNome($data[$indici['descrizione_catAlbero8']]);
  1076.                                     $categoriaAlbero8->setNomeUnivoco(substr($categoriaAlbero8->getNome() . '-' $categoriaAlbero8->getCodice(), 0255));
  1077.                                     $categoriaAlbero8->setDescrizione($data[$indici['descrizione_catAlbero8']]);
  1078.                                     $categoriaAlbero8->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero8']]));
  1079.                                     if($data[$indici['immagine_catAlbero8']] != '')
  1080.                                         $categoriaAlbero8->setImmagine($data[$indici['immagine_catAlbero8']]);
  1081.                                     $categoriaAlbero8->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero8']]));
  1082.                                     $categoriaAlbero8->setDataModifica(new \DateTime());
  1083.                                     $em->persist($categoriaAlbero8);
  1084.                                     $em->flush();
  1085.                                     $categoriaAlbero8 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero8"]], '8');
  1086.                                 }
  1087.                                 if ($data[$indici["codice_catAlbero9"]] != ''){
  1088.                                     $categoriaAlbero9 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero9"]], '9');
  1089.                                     if(!$categoriaAlbero9){
  1090.                                         $categoriaAlbero9 = new CategorieAlbero();
  1091.                                         $categoriaAlbero9->setCodice($data[$indici['codice_catAlbero9']]);
  1092.                                         $categoriaAlbero9->setCodiceOriginale($data[$indici['codice_catAlbero9']]);
  1093.                                         $categoriaAlbero9->setColonnaProvenienza("9");
  1094.                                         $categoriaAlbero9->setAttivo(true);
  1095.                                         $categoriaAlbero9->setDataCreazione(new \DateTime());
  1096.                                     }
  1097.                                     $categoriaAlbero9->setNome($data[$indici['descrizione_catAlbero9']]);
  1098.                                     $categoriaAlbero9->setNomeUnivoco(substr($categoriaAlbero9->getNome() . '-' $categoriaAlbero9->getCodice(), 0255));
  1099.                                     $categoriaAlbero9->setDescrizione($data[$indici['descrizione_catAlbero9']]);
  1100.                                     $categoriaAlbero9->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero9']]));
  1101.                                     if($data[$indici['immagine_catAlbero9']] != '')
  1102.                                         $categoriaAlbero9->setImmagine($data[$indici['immagine_catAlbero9']]);
  1103.                                     $categoriaAlbero9->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero9']]));
  1104.                                     $categoriaAlbero9->setDataModifica(new \DateTime());
  1105.                                     $em->persist($categoriaAlbero9);
  1106.                                     $em->flush();
  1107.                                     $categoriaAlbero9 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero9"]], '9');
  1108.                                 }
  1109.                                 if ($data[$indici["codice_catAlbero10"]] != ''){
  1110.                                     $categoriaAlbero10 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero10"]], '10');
  1111.                                     if(!$categoriaAlbero10){
  1112.                                         $categoriaAlbero10 = new CategorieAlbero();
  1113.                                         $categoriaAlbero10->setCodice($data[$indici['codice_catAlbero10']]);
  1114.                                         $categoriaAlbero10->setCodiceOriginale($data[$indici['codice_catAlbero10']]);
  1115.                                         $categoriaAlbero10->setColonnaProvenienza("10");
  1116.                                         $categoriaAlbero10->setAttivo(true);
  1117.                                         $categoriaAlbero10->setDataCreazione(new \DateTime());
  1118.                                     }
  1119.                                     $categoriaAlbero10->setNome($data[$indici['descrizione_catAlbero10']]);
  1120.                                     $categoriaAlbero10->setNomeUnivoco(substr($categoriaAlbero10->getNome() . '-' $categoriaAlbero10->getCodice(), 0255));
  1121.                                     $categoriaAlbero10->setDescrizione($data[$indici['descrizione_catAlbero10']]);
  1122.                                     $categoriaAlbero10->setOrdinamento(self::verificaInt($data[$indici['ordine_catAlbero10']]));
  1123.                                     if($data[$indici['immagine_catAlbero10']] != '')
  1124.                                         $categoriaAlbero10->setImmagine($data[$indici['immagine_catAlbero10']]);
  1125.                                     $categoriaAlbero10->setPrezzoSuRichiesta(self::verificaBool($data[$indici['prezzoARichiesta_catAlbero10']]));
  1126.                                     $categoriaAlbero10->setDataModifica(new \DateTime());
  1127.                                     $em->persist($categoriaAlbero10);
  1128.                                     $em->flush();
  1129.                                     $categoriaAlbero10 $this->servizi->ritornaCategoriaAlberoSeInserita($data[$indici["codice_catAlbero10"]], '10');
  1130.                                 }
  1131.                                 $associazioneCatAlberoMappaCatArt $this->servizi->ritornaAssociazioneCategorieAlberoMappaCategoriaArticoliSeInserita($mappaCategoriaArticoliPresente$categoriaAlbero1$categoriaAlbero2$categoriaAlbero3$categoriaAlbero4$categoriaAlbero5$categoriaAlbero6$categoriaAlbero7$categoriaAlbero8$categoriaAlbero9$categoriaAlbero10);
  1132.                                 if($data[$indici["operazione"]] == 'E'){
  1133.                                     $em->remove($associazioneCatAlberoMappaCatArt);
  1134.                                 }else{
  1135.                                     if (!$associazioneCatAlberoMappaCatArt){
  1136.                                         $associazioneCatAlberoMappaCatArt = new AssociazioneCategorieAlberoMappaCategorieArticoli();
  1137.                                         $associazioneCatAlberoMappaCatArt->setMappaCategoriaArticolo($mappaCategoriaArticoliPresente);
  1138.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero1($categoriaAlbero1);
  1139.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero2($categoriaAlbero2);
  1140.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero3($categoriaAlbero3);
  1141.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero4($categoriaAlbero4);
  1142.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero5($categoriaAlbero5);
  1143.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero6($categoriaAlbero6);
  1144.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero7($categoriaAlbero7);
  1145.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero8($categoriaAlbero8);
  1146.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero9($categoriaAlbero9);
  1147.                                         $associazioneCatAlberoMappaCatArt->setCategoriaAlbero10($categoriaAlbero10);
  1148.                                         $associazioneCatAlberoMappaCatArt->setArticolo($mappaCategoriaArticoliPresente $mappaCategoriaArticoliPresente->getArticolo() : null);
  1149.                                         $associazioneCatAlberoMappaCatArt->setDataModifica(new \DateTime());
  1150.                                         $associazioneCatAlberoMappaCatArt->setDataCreazione(new \DateTime());
  1151.                                         $em->persist($associazioneCatAlberoMappaCatArt);
  1152.                                         $bool_rigeneraAlbero true;
  1153.                                     }
  1154.                                     $em->persist($mappaCategoriaArticoliPresente);
  1155.                                 }
  1156.                             } else {
  1157.                                 $this->ScriviRegistroAttivita($em$request->getClientIp(), ''false'Errore importazione categorie albero (RIGA: ' . ($contatore $row) . ') : Mappa categoria articoli non trovata </br>'null$collegamentoRnd'ImportazioneController''caricaCategorieAlbero');
  1158.                                 $errori .= ('Errore importazione categorie albero (RIGA: ' . ($contatore $row) . ') : Mappa categoria articoli non trovata </br>');
  1159.                             }
  1160.                             $queryEseguite++;
  1161.                             $em->flush();
  1162.                         }catch (Exception $ex2){
  1163.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), $ex2->getTraceAsString(), false'Errore importazione categorie albero (RIGA: ' . ($contatore $row) . ') : ' $ex2->getMessage() . '</br>' $ex2->getTraceAsString() . '</br>'null$collegamentoRnd'ImportazioneController''caricaCategorieAlbero');
  1164.                             $errori .= ('Errore importazione categorie albero (RIGA: ' . ($contatore $row) . ') : ' $ex2->getMessage() . '</br>' $ex2->getTraceAsString() . '</br>');
  1165.                         }catch (\Exception|\Throwable $ex){
  1166.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione categorie albero (RIGA: ' . ($contatore $row) . ') : ' $ex->getMessage() . '</br>' $ex->getTraceAsString() . '</br>'null$collegamentoRnd'ImportazioneController''caricaCategorieAlbero');
  1167.                             $errori .= ('Errore importazione categorie albero (RIGA: ' . ($contatore $row) . ') : ' $ex->getMessage() . '</br>' $ex->getTraceAsString() . '</br>');
  1168.                         }
  1169.                         $row++;
  1170.                     }
  1171.                 }else{
  1172.                     $errori .= "Impossibile aprire il file!";
  1173.                 }
  1174.                 //$row = $contatore + $row;
  1175.                 $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row '</br>Errori:' $errorinull$collegamentoRnd'ImportazioneController''caricaCategorieAlbero');
  1176.                 $messaggioSupporto "";
  1177.                 if ($bool_rigeneraAlbero)
  1178.                     $this->generaAlberoAction($request"1");
  1179.                 return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds </br> ' $row '</br>' $messaggioSupporto '</br>Errori:' $errori . ($dbg '</br>Debug: ' $debugMessage  ''));
  1180.             } catch (Exception $ex2) {
  1181.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex2->getTraceAsString(), false"Errore importazione categorie albero: " $ex2->getMessage(), null$collegamentoRnd'ImportazioneController''caricaCategorieAlbero');
  1182.                 return new Response('Errore importazione (RIGA: ' . ($contatore $row) . ') : ' $ex2->getMessage() . '/n' $ex2->getTraceAsString());
  1183.             } catch (\Exception|\Throwable $ex) {
  1184.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false"Errore importazione categorie albero: " $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaCategorieAlbero');
  1185.                 return new Response('Errore importazione (RIGA: ' . ($contatore $row) . ') : ' $ex->getMessage() . '/n' $ex->getTraceAsString());
  1186.             }
  1187.             //return new Response("Importazione completata || " . $time_elapsed_secs = microtime(true) - $start . " || secondi");
  1188.         } else {
  1189.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false"Errore importazione categorie albero: ERRORE_PERMESSO"null$collegamentoRnd'ImportazioneController''caricaCategorieAlbero');
  1190.             return new Response("ERRORE PERMESSO");
  1191.         }
  1192.     }
  1193.     /**
  1194.      * @Route("/generaIndicizzazioneAttributi", name="genera_indicizzazione_attributi")
  1195.      */
  1196.     public function generaIndicizzazioneAttributi(Request $request$chiamataInternaSenzaRisposta false){
  1197.         $collegamentoRnd $this->servizi->randomString2();
  1198.         try{
  1199.             $start microtime(true);
  1200.             ini_set('max_execution_time'2400);
  1201.             ini_set('memory_limit''4G');
  1202.             $usaCategorieAlbero $this->imp->ritornaImpostazioneDaNome('UtilizzaCategorieAlberoPerGenerazione');
  1203.             $connection $this->servizi->doctrine->getConnection();
  1204.             $connection->beginTransaction();
  1205.             $connection->query("SET FOREIGN_KEY_CHECKS=0;");
  1206.             $connection->executeUpdate("TRUNCATE `attributi_indicizzazione`;");
  1207.             $connection->query("SET FOREIGN_KEY_CHECKS=1; ");
  1208.             if($usaCategorieAlbero == '1') {
  1209.                 $sql 'INSERT INTO `attributi_indicizzazione`(`attributo_id`, `categoria_albero1_id`, `categoria_albero2_id`, `categoria_albero3_id`, `categoria_albero4_id`, `categoria_albero5_id`, `data_creazione`, `data_modifica`)  
  1210.             SELECT DISTINCT 
  1211.                         att.id,
  1212.                          albero.categoria_albero1_id, 
  1213.                         albero.categoria_albero2_id, 
  1214.                         albero.categoria_albero3_id, 
  1215.                         albero.categoria_albero4_id, 
  1216.                         albero.categoria_albero5_id, 
  1217.                         NOW(), 
  1218.                         NOW()
  1219.                     FROM `associazione_attributi` assAtt
  1220.                         LEFT JOIN attributi att ON att.id = assAtt.attributo_id
  1221.                         LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = assAtt.mappa_categoria_articolo_id
  1222.                         LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli albero ON albero.articolo_id = mappa.articolo_id; ';
  1223.             }else{
  1224.                 $sql 'INSERT INTO `attributi_indicizzazione`(`attributo_id`, `categoria1_id`, `categoria2_id`, `categoria3_id`, `categoria4_id`, `categoria5_id`, `data_creazione`, `data_modifica`)  
  1225.             SELECT DISTINCT 
  1226.                         att.id,
  1227.                         mappa.categoria1_id, 
  1228.                         mappa.categoria2_id, 
  1229.                         mappa.categoria3_id, 
  1230.                         mappa.categoria4_id,
  1231.                         mappa.categoria5_id,
  1232.                         NOW(), 
  1233.                         NOW()
  1234.                     FROM `associazione_attributi` assAtt
  1235.                         LEFT JOIN attributi att ON att.id = assAtt.attributo_id
  1236.                         LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = assAtt.mappa_categoria_articolo_id; ';
  1237.             }
  1238.             $connection->executeUpdate($sql);
  1239.             if(!$chiamataInternaSenzaRisposta)
  1240.                 return new Response('Generazione indicizzazione attributi completata in ' $time_elapsed_secs microtime(true) - $start ' seconds \n');
  1241.             else
  1242.                 return true;
  1243.         }catch (\Exception|\Throwable $ex) {
  1244.             $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false"Errore genera indicizzazione articoli: " $ex->getMessage(), null$collegamentoRnd'ImportazioneController''generaIndicizzazioneAttributi');
  1245.             if(!$chiamataInternaSenzaRisposta)
  1246.                 return new Response('Errore genera indicizzazione attributi  EX: ' $ex->getMessage() . '/n' $ex->getTraceAsString());
  1247.             else
  1248.                 return false;
  1249.         }
  1250.     }
  1251.     /**
  1252.      * @Route("/generaAlbero/{indicizzaAttributi}/{codiceArticolo}", name="genera_albero", defaults={"indicizzaAttributi"="1","codiceArticolo"=""})
  1253.      */
  1254.     public function generaAlberoAction(Request $request$indicizzaAttributi 1$codiceArticolo "")
  1255.     {
  1256.         $collegamentoRnd $this->servizi->randomString2();
  1257.         # Se specifico il codice articolo non pulisco la tabella e tento la creazione albero solo del codice indicato
  1258.         try {
  1259.             $start microtime(true);
  1260.             ini_set('max_execution_time'2400);
  1261.             ini_set('memory_limit''4G');
  1262.             $connection $this->servizi->doctrine->getConnection();
  1263.             $repoAlbero $this->servizi->doctrine->getRepository(AlberoMenuProdotti::class);
  1264.             if ($codiceArticolo == "") {
  1265.                 $connection->executeQuery("SET FOREIGN_KEY_CHECKS=0;");
  1266.                 $connection->executeQuery("TRUNCATE associazione_albero_menu_prodotti_tipo_ordine;");
  1267.                 $connection->executeQuery("TRUNCATE albero_menu_prodotti;");
  1268.                 $connection->executeQuery("SET FOREIGN_KEY_CHECKS=1; ");
  1269.             }
  1270.             $imp $this->servizi->impostazioni;
  1271.             $imp->caricaCacheImpostazioniDaFamiglie(['Generale']);
  1272.             //Se vero non utilizzo le 5 categorie presenti nella mappa categorie articoli per generare l'albero ma utilizzo la tabella dedicata all'associazione categorie albero
  1273.             $usaCategorieAlbero $imp->ritornaImpostazioneDaNome('UtilizzaCategorieAlberoPerGenerazione');
  1274.             $debugRitorno "";
  1275.             $user $this->servizi->OttieniUtenteCorrente();
  1276.             $arrayCacheCategorie = array();
  1277.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Chiamata effettuata a /generaAlbero --- Inizio la generazione dell\' albero'$user$collegamentoRnd'ImportazioneController''generaAlbero');
  1278.             $posizioneAssoluta 0;
  1279.             $conn $this->servizi->doctrine->getConnection();
  1280.             $sql "SELECT COUNT(*) AS conta
  1281.                         FROM mappa_categorie_articoli mappa ";
  1282.             if ($codiceArticolo != ""){
  1283.                 $sql .= " LEFT JOIN articoli a ON a.id = mappa.articolo_id WHERE a.codice = ? ";
  1284.             }
  1285.             $sql .= "GROUP BY mappa.categoria1_id, mappa.categoria2_id, mappa.categoria3_id, mappa.categoria4_id, mappa.categoria5_id";
  1286.             if ($usaCategorieAlbero == '1'){
  1287.                 $sql "SELECT COUNT(*) AS conta
  1288.                         FROM mappa_categorie_articoli mappa ";
  1289.                 if ($codiceArticolo != ""){
  1290.                     $sql .= " LEFT JOIN articoli a ON a.id = mappa.articolo_id ";
  1291.                 }
  1292.                 $sql .= " LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass ON ass.mappa_categoria_articolo_id = mappa.id ";
  1293.                 if ($codiceArticolo != ""){
  1294.                     $sql .= " WHERE a.codice = ? ";
  1295.                 }
  1296.                 $sql .= "  GROUP BY ass.categoria_albero1_id, ass.categoria_albero2_id, ass.categoria_albero3_id, ass.categoria_albero4_id, ass.categoria_albero5_id, ass.categoria_albero6_id, ass.categoria_albero7_id, ass.categoria_albero8_id, ass.categoria_albero9_id, ass.categoria_albero10_id";
  1297.             }
  1298.             $stmt $conn->prepare($sql);
  1299.             if ($codiceArticolo != ""){
  1300.                 $stmt->bindValue(1$codiceArticolo);
  1301.             }
  1302.             $rst $stmt->executeQuery();
  1303.             $cont $rst->fetchAllAssociative();
  1304.             $totRighe count($cont);
  1305.             $batch 100;
  1306.             $inizio 0;
  1307.             while($totRighe $inizio) {
  1308.                 $sql 'SELECT 
  1309.                             mappa.categoria1_id AS cat1,
  1310.                             mappa.categoria2_id AS cat2,
  1311.                             mappa.categoria3_id AS cat3,
  1312.                             mappa.categoria4_id AS cat4,
  1313.                             mappa.categoria5_id AS cat5
  1314.                         FROM mappa_categorie_articoli mappa
  1315.                             LEFT JOIN categorie c1 ON c1.id = mappa.categoria1_id
  1316.                             LEFT JOIN categorie c2 ON c2.id = mappa.categoria2_id
  1317.                             LEFT JOIN categorie c3 ON c3.id = mappa.categoria3_id
  1318.                             LEFT JOIN categorie c4 ON c4.id = mappa.categoria4_id
  1319.                             LEFT JOIN categorie c5 ON c5.id = mappa.categoria5_id
  1320.                             LEFT JOIN articoli a on mappa.articolo_id = a.id
  1321.                         WHERE mappa.attivo = 1 AND a.attivo = 1
  1322.                           AND (c1.attivo = 1 OR mappa.categoria1_id IS NULL) 
  1323.                           AND (c2.attivo = 1 OR mappa.categoria2_id IS NULL) 
  1324.                           AND (c3.attivo = 1 OR mappa.categoria3_id IS NULL) 
  1325.                           AND (c4.attivo = 1 OR mappa.categoria4_id IS NULL) 
  1326.                           AND (c5.attivo = 1 OR mappa.categoria5_id IS NULL) ';
  1327.                 if ($codiceArticolo != ""){
  1328.                     $sql .= " AND a.codice = ? ";
  1329.                 }
  1330.                 $sql .= 'GROUP BY mappa.categoria1_id, mappa.categoria2_id, mappa.categoria3_id, mappa.categoria4_id, mappa.categoria5_id
  1331.                         ORDER BY c1.ordinamento, c1.nome, c2.ordinamento, c2.nome, c3.ordinamento, c3.nome, c4.ordinamento, c4.nome, c5.ordinamento, c5.nome
  1332.                         LIMIT ' $batch " OFFSET " $inizio;
  1333.                 if($usaCategorieAlbero){
  1334.                     $sql 'SELECT 
  1335.                             ass.categoria_albero1_id AS cat1,
  1336.                             ass.categoria_albero2_id AS cat2,
  1337.                             ass.categoria_albero3_id AS cat3,
  1338.                             ass.categoria_albero4_id AS cat4,
  1339.                             ass.categoria_albero5_id AS cat5,
  1340.                             ass.categoria_albero6_id AS cat6,
  1341.                             ass.categoria_albero7_id AS cat7,
  1342.                             ass.categoria_albero8_id AS cat8,
  1343.                             ass.categoria_albero9_id AS cat9,
  1344.                             ass.categoria_albero10_id AS cat10
  1345.                         FROM mappa_categorie_articoli mappa
  1346.                             LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass ON ass.mappa_categoria_articolo_id = mappa.id 
  1347.                             LEFT JOIN categorie_albero c1 ON c1.id = ass.categoria_albero1_id
  1348.                             LEFT JOIN categorie_albero c2 ON c2.id = ass.categoria_albero2_id
  1349.                             LEFT JOIN categorie_albero c3 ON c3.id = ass.categoria_albero3_id
  1350.                             LEFT JOIN categorie_albero c4 ON c4.id = ass.categoria_albero4_id
  1351.                             LEFT JOIN categorie_albero c5 ON c5.id = ass.categoria_albero5_id
  1352.                             LEFT JOIN categorie_albero c6 ON c6.id = ass.categoria_albero6_id
  1353.                             LEFT JOIN categorie_albero c7 ON c7.id = ass.categoria_albero7_id
  1354.                             LEFT JOIN categorie_albero c8 ON c8.id = ass.categoria_albero8_id
  1355.                             LEFT JOIN categorie_albero c9 ON c9.id = ass.categoria_albero9_id
  1356.                             LEFT JOIN categorie_albero c10 ON c10.id = ass.categoria_albero10_id
  1357.                             LEFT JOIN articoli a on mappa.articolo_id = a.id
  1358.                         WHERE mappa.attivo = 1 AND a.attivo = 1
  1359.                           AND (c1.attivo = 1 OR c1.id IS NULL) 
  1360.                           AND (c2.attivo = 1 OR c2.id IS NULL) 
  1361.                           AND (c3.attivo = 1 OR c3.id IS NULL) 
  1362.                           AND (c4.attivo = 1 OR c4.id IS NULL) 
  1363.                           AND (c5.attivo = 1 OR c5.id IS NULL) 
  1364.                           AND (c6.attivo = 1 OR c6.id IS NULL) 
  1365.                           AND (c7.attivo = 1 OR c7.id IS NULL) 
  1366.                           AND (c8.attivo = 1 OR c8.id IS NULL) 
  1367.                           AND (c9.attivo = 1 OR c9.id IS NULL) 
  1368.                           AND (c10.attivo = 1 OR c10.id IS NULL) ';
  1369.                     if ($codiceArticolo != ""){
  1370.                         $sql .= " AND a.codice = ? ";
  1371.                     }
  1372.                     $sql .= ' GROUP BY ass.categoria_albero1_id, ass.categoria_albero2_id, ass.categoria_albero3_id, ass.categoria_albero4_id, ass.categoria_albero5_id, ass.categoria_albero6_id, ass.categoria_albero7_id, ass.categoria_albero8_id, ass.categoria_albero9_id, ass.categoria_albero10_id
  1373.                         ORDER BY c1.ordinamento, c1.nome, c2.ordinamento, c2.nome, c3.ordinamento, c3.nome, c4.ordinamento, c4.nome, c5.ordinamento, c5.nome, c6.ordinamento, c6.nome, c7.ordinamento, c7.nome, c8.ordinamento, c8.nome, c9.ordinamento, c9.nome, c10.ordinamento, c10.nome
  1374.                         LIMIT ' $batch " OFFSET " $inizio;
  1375.                 }
  1376.                 $stmt $conn->prepare($sql);
  1377.                 if ($codiceArticolo != ""){
  1378.                     $stmt->bindValue(1$codiceArticolo);
  1379.                 }
  1380.                 $rst $stmt->executeQuery();
  1381.                 $risultati $rst->fetchAllAssociative();
  1382.                 foreach ($risultati as $mappa) {
  1383.                     $ct1 null$ct2 null$ct3 null$ct4 null$ct5 null;
  1384.                     $alberoLivello1 null;
  1385.                     $alberoLivello2 null;
  1386.                     $alberoLivello3 null;
  1387.                     $alberoLivello4 null;
  1388.                     $alberoLivello5 null;
  1389.                     $alberoLivello6 null;
  1390.                     $alberoLivello7 null;
  1391.                     $alberoLivello8 null;
  1392.                     $alberoLivello9 null;
  1393.                     $alberoLivello10 null;
  1394.                     if ($mappa['cat1']) {
  1395.                         /** @var Categorie|CategorieAlbero $ct1 */
  1396.                         if ($usaCategorieAlbero == '1'){
  1397.                             $ct1 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat1'])[$mappa['cat1']];
  1398.                             $alberoLivello1 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct1'parentId' => null'livello' => '0'));
  1399.                         }else {
  1400.                             $ct1 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat1'])[$mappa['cat1']];
  1401.                             $alberoLivello1 $repoAlbero->findOneBy(array('categoria' => $ct1'parentId' => null'livello' => '0'));
  1402.                         }
  1403.                         if (!$alberoLivello1) {
  1404.                             if ($codiceArticolo != ""){
  1405.                                 print ("Inserisco albero 1 (ID): " $mappa['cat1']);
  1406.                             }
  1407.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  1408.                                     VALUES (?, NULL, ?, 0, 0, 
  1409.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id IS NULL) IS NOT NULL 
  1410.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id IS NULL) ELSE 0 END,
  1411.                                         ?, NOW(), NOW(),
  1412.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE
  1413.                                                                 ris.codice_anagrafica = '' AND 
  1414.                                                                 ris.codice_categoria1 = ? AND 
  1415.                                                                 ris.codice_categoria2 = '' AND  
  1416.                                                                 ris.codice_categoria3 = '' AND   
  1417.                                                                 ris.codice_categoria4 = '' AND   
  1418.                                                                 ris.codice_categoria5 = '' AND                 
  1419.                                                                 ris.codice_articolo = '' AND 
  1420.                                                                 ris.marca = '' AND 
  1421.                                                                 ris.codice_dimensione1 = '' AND   
  1422.                                                                 ris.codice_dimensione2 = '' AND 
  1423.                                                                 ris.codice_dimensione3 = '' AND 
  1424.                                                                 ris.codice_dimensione4 = '' AND 
  1425.                                                                 ris.codice_dimensione5 = ''                                           
  1426.                                                 ) THEN 1 ELSE 0 END
  1427.                                             )";
  1428.                             $stmt $connection->prepare($sql);
  1429.                             $stmt->bindValue(1$ct1->getId());
  1430.                             $stmt->bindValue(2$user $user->getId() : null);
  1431.                             $stmt->bindValue(3$posizioneAssoluta);
  1432.                             $stmt->bindValue(4$ct1->getCodice());
  1433.                             $stmt->execute();
  1434.                             $sqlTipoOrdine "
  1435.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  1436.                                     DISTINCT(ass.tipo_ordine_id),
  1437.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct1->getId() . " AND alb.parent_id_id IS NULL AND alb.livello = 0 LIMIT 1)
  1438.                                 FROM associazione_articoli_tipo_ordine ass
  1439.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  1440.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass2.mappa_categoria_articolo_id = mappa.id 
  1441.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId();
  1442.                             $stmt $connection->prepare($sqlTipoOrdine);
  1443.                             $stmt->execute();
  1444.                             $posizioneAssoluta++;
  1445.                             $alberoLivello1 null;
  1446.                             if ($usaCategorieAlbero){
  1447.                                 $alberoLivello1 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct1'parentId' => null'livello' => '0'));
  1448.                             }else{
  1449.                                 $alberoLivello1 $repoAlbero->findOneBy(array('categoria' => $ct1'parentId' => null'livello' => '0'));
  1450.                             }
  1451.                         }
  1452.                     }
  1453.                     if ($mappa['cat2']) {
  1454.                         /** @var Categorie $ct2 */
  1455.                         if($usaCategorieAlbero == '1'){
  1456.                             $ct2 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat2'])[$mappa['cat2']];
  1457.                         }else{
  1458.                             $ct2 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat2'])[$mappa['cat2']];
  1459.                         }
  1460.                         if($alberoLivello1) {
  1461.                             if($usaCategorieAlbero == '1'){
  1462.                                 $alberoLivello2 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct2'parentId' => $alberoLivello1->getId(), 'livello' => '1'));
  1463.                             }else{
  1464.                                 $alberoLivello2 $repoAlbero->findOneBy(array('categoria' => $ct2'parentId' => $alberoLivello1->getId(), 'livello' => '1'));
  1465.                             }
  1466.                         }
  1467.                         if (!$alberoLivello2 && $alberoLivello1) {
  1468.                             if ($codiceArticolo != ""){
  1469.                                 print ("Inserisco albero 2 (ID): " $mappa['cat2']);
  1470.                             }
  1471.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  1472.                                     VALUES (?, ?, ?, 1, 0, 
  1473.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) IS NOT NULL 
  1474.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) ELSE 0 END,
  1475.                                         ?, NOW(), NOW(),
  1476.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE 
  1477.                                                                 ris.codice_anagrafica = '' AND 
  1478.                                                                 ris.codice_categoria1 = ? AND 
  1479.                                                                 ris.codice_categoria2 = ? AND  
  1480.                                                                 ris.codice_categoria3 = '' AND   
  1481.                                                                 ris.codice_categoria4 = '' AND   
  1482.                                                                 ris.codice_categoria5 = '' AND                 
  1483.                                                                 ris.codice_articolo = '' AND 
  1484.                                                                 ris.marca = '' AND 
  1485.                                                                 ris.codice_dimensione1 = '' AND   
  1486.                                                                 ris.codice_dimensione2 = '' AND 
  1487.                                                                 ris.codice_dimensione3 = '' AND 
  1488.                                                                 ris.codice_dimensione4 = '' AND 
  1489.                                                                 ris.codice_dimensione5 = ''                                           
  1490.                                                 ) THEN 1 ELSE 0 END
  1491.                                                 )";
  1492.                             $stmt $connection->prepare($sql);
  1493.                             $stmt->bindValue(1$ct2->getId());
  1494.                             $stmt->bindValue(2$alberoLivello1->getId());
  1495.                             $stmt->bindValue(3$user $user->getId() : null);
  1496.                             $stmt->bindValue(4$alberoLivello1->getId());
  1497.                             $stmt->bindValue(5$alberoLivello1->getId());
  1498.                             $stmt->bindValue(6$posizioneAssoluta);
  1499.                             $stmt->bindValue(7$ct1->getCodice());
  1500.                             $stmt->bindValue(8$ct2->getCodice());
  1501.                             $stmt->execute();
  1502.                             $sqlTipoOrdine "
  1503.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  1504.                                     DISTINCT(ass.tipo_ordine_id),
  1505.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct2->getId() . " AND alb.parent_id_id = " $alberoLivello1->getId() . " AND alb.livello = 1 LIMIT 1)
  1506.                                 FROM associazione_articoli_tipo_ordine ass
  1507.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  1508.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass2.mappa_categoria_articolo_id = mappa.id 
  1509.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero2_id" "mappa.categoria2_id" ) . " = " $ct2->getId();
  1510.                             $stmt $connection->prepare($sqlTipoOrdine);
  1511.                             $stmt->execute();
  1512.                             $posizioneAssoluta++;
  1513.                             $sql 'UPDATE albero_menu_prodotti SET has_child = 1 WHERE id = ?';
  1514.                             $stmt $connection->prepare($sql);
  1515.                             $stmt->bindValue(1$alberoLivello1->getId());
  1516.                             $stmt->execute();
  1517.                             if($usaCategorieAlbero == '1') {
  1518.                                 $alberoLivello2 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct2'parentId' => $alberoLivello1->getId(), 'livello' => '1'));
  1519.                             }else{
  1520.                                 $alberoLivello2 $repoAlbero->findOneBy(array('categoria' => $ct2'parentId' => $alberoLivello1->getId(), 'livello' => '1'));
  1521.                             }
  1522.                         }
  1523.                     }
  1524.                     if ($mappa['cat3']) {
  1525.                         /** @var Categorie $ct3 */
  1526.                         if($usaCategorieAlbero == '1'){
  1527.                             $ct3 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat3'])[$mappa['cat3']];
  1528.                         }else {
  1529.                             $ct3 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat3'])[$mappa['cat3']];
  1530.                         }
  1531.                         if($alberoLivello2) {
  1532.                             if($usaCategorieAlbero == '1') {
  1533.                                 $alberoLivello3 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct3'parentId' => $alberoLivello2->getId(), 'livello' => '2'));
  1534.                             }else{
  1535.                                 $alberoLivello3 $repoAlbero->findOneBy(array('categoria' => $ct3'parentId' => $alberoLivello2->getId(), 'livello' => '2'));
  1536.                             }
  1537.                         }
  1538.                         if (!$alberoLivello3 && $alberoLivello2) {
  1539.                             if ($codiceArticolo != ""){
  1540.                                 print ("Inserisco albero 3 (ID): " $mappa['cat3']);
  1541.                             }
  1542.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  1543.                                     VALUES (?, ?, ?, 2, 0, 
  1544.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) IS NOT NULL 
  1545.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) ELSE 0 END,
  1546.                                         ?, NOW(), NOW(),
  1547.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE 
  1548.                                                                 ris.codice_anagrafica = '' AND 
  1549.                                                                 ris.codice_categoria1 = ? AND 
  1550.                                                                 ris.codice_categoria2 = ? AND  
  1551.                                                                 ris.codice_categoria3 = ? AND   
  1552.                                                                 ris.codice_categoria4 = '' AND   
  1553.                                                                 ris.codice_categoria5 = '' AND                 
  1554.                                                                 ris.codice_articolo = '' AND 
  1555.                                                                 ris.marca = '' AND 
  1556.                                                                 ris.codice_dimensione1 = '' AND   
  1557.                                                                 ris.codice_dimensione2 = '' AND 
  1558.                                                                 ris.codice_dimensione3 = '' AND 
  1559.                                                                 ris.codice_dimensione4 = '' AND 
  1560.                                                                 ris.codice_dimensione5 = ''                                           
  1561.                                                 ) THEN 1 ELSE 0 END)";
  1562.                             $stmt $connection->prepare($sql);
  1563.                             $stmt->bindValue(1$ct3->getId());
  1564.                             $stmt->bindValue(2$alberoLivello2->getId());
  1565.                             $stmt->bindValue(3$user $user->getId() : null);
  1566.                             $stmt->bindValue(4$alberoLivello2->getId());
  1567.                             $stmt->bindValue(5$alberoLivello2->getId());
  1568.                             $stmt->bindValue(6$posizioneAssoluta);
  1569.                             $stmt->bindValue(7$ct1->getCodice());
  1570.                             $stmt->bindValue(8$ct2->getCodice());
  1571.                             $stmt->bindValue(9$ct3->getCodice());
  1572.                             $stmt->execute();
  1573.                             $posizioneAssoluta++;
  1574.                             $sqlTipoOrdine "
  1575.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  1576.                                     DISTINCT(ass.tipo_ordine_id),
  1577.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct3->getId() . " AND alb.parent_id_id = " $alberoLivello2->getId() . " AND alb.livello = 2 LIMIT 1)
  1578.                                 FROM associazione_articoli_tipo_ordine ass
  1579.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  1580.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass.mappa_categoria_articolo_id = mappa.id 
  1581.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero2_id" "mappa.categoria2_id" ) . " = " $ct2->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero3_id" "mappa.categoria3_id" ) . " = " $ct3->getId();
  1582.                             $stmt $connection->prepare($sqlTipoOrdine);
  1583.                             $stmt->execute();
  1584.                             $sql 'UPDATE albero_menu_prodotti SET has_child = 1 WHERE id = ?';
  1585.                             $stmt $connection->prepare($sql);
  1586.                             $stmt->bindValue(1$alberoLivello2->getId());
  1587.                             $stmt->execute();
  1588.                             if($usaCategorieAlbero == '1'){
  1589.                                 $alberoLivello3 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct3'parentId' => $alberoLivello2->getId(), 'livello' => '2'));
  1590.                             }else {
  1591.                                 $alberoLivello3 $repoAlbero->findOneBy(array('categoria' => $ct3'parentId' => $alberoLivello2->getId(), 'livello' => '2'));
  1592.                             }
  1593.                         }
  1594.                     }
  1595.                     if ($mappa['cat4']) {
  1596.                         /** @var Categorie $ct4 */
  1597.                         if($usaCategorieAlbero == '1'){
  1598.                             $ct4 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat4'])[$mappa['cat4']];
  1599.                         }else {
  1600.                             $ct4 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat4'])[$mappa['cat4']];
  1601.                         }
  1602.                         if($alberoLivello3) {
  1603.                             if($usaCategorieAlbero == '1'){
  1604.                                 $alberoLivello4 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct4'parentId' => $alberoLivello3->getId(), 'livello' => '3'));
  1605.                             }else {
  1606.                                 $alberoLivello4 $repoAlbero->findOneBy(array('categoria' => $ct4'parentId' => $alberoLivello3->getId(), 'livello' => '3'));
  1607.                             }
  1608.                         }
  1609.                         if (!$alberoLivello4 && $alberoLivello3) {
  1610.                             if ($codiceArticolo != ""){
  1611.                                 print ("Inserisco albero 4 (ID): " $mappa['cat4']);
  1612.                             }
  1613.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  1614.                                     VALUES (?, ?, ?, 3, 0, 
  1615.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) IS NOT NULL 
  1616.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) ELSE 0 END,
  1617.                                         ?, NOW(), NOW(),
  1618.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE 
  1619.                                                                 ris.codice_anagrafica = '' AND 
  1620.                                                                 ris.codice_categoria1 = ? AND 
  1621.                                                                 ris.codice_categoria2 = ? AND  
  1622.                                                                 ris.codice_categoria3 = ? AND   
  1623.                                                                 ris.codice_categoria4 = ? AND   
  1624.                                                                 ris.codice_categoria5 = '' AND                 
  1625.                                                                 ris.codice_articolo = '' AND 
  1626.                                                                 ris.marca = '' AND 
  1627.                                                                 ris.codice_dimensione1 = '' AND   
  1628.                                                                 ris.codice_dimensione2 = '' AND 
  1629.                                                                 ris.codice_dimensione3 = '' AND 
  1630.                                                                 ris.codice_dimensione4 = '' AND 
  1631.                                                                 ris.codice_dimensione5 = ''                                           
  1632.                                                 ) THEN 1 ELSE 0 END)";
  1633.                             $stmt $connection->prepare($sql);
  1634.                             $stmt->bindValue(1$ct4->getId());
  1635.                             $stmt->bindValue(2$alberoLivello3->getId());
  1636.                             $stmt->bindValue(3$user $user->getId() : null);
  1637.                             $stmt->bindValue(4$alberoLivello3->getId());
  1638.                             $stmt->bindValue(5$alberoLivello3->getId());
  1639.                             $stmt->bindValue(6$posizioneAssoluta);
  1640.                             $stmt->bindValue(7$ct1->getCodice());
  1641.                             $stmt->bindValue(8$ct2->getCodice());
  1642.                             $stmt->bindValue(9$ct3->getCodice());
  1643.                             $stmt->bindValue(10$ct4->getCodice());
  1644.                             $stmt->execute();
  1645.                             $posizioneAssoluta++;
  1646.                             $sqlTipoOrdine "
  1647.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  1648.                                     DISTINCT(ass.tipo_ordine_id),
  1649.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct4->getId() . " AND alb.parent_id_id = " $alberoLivello3->getId() . " AND alb.livello = 3 LIMIT 1)
  1650.                                 FROM associazione_articoli_tipo_ordine ass
  1651.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  1652.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass2.mappa_categoria_articolo_id = mappa.id 
  1653.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero2_id" "mappa.categoria2_id" ) . " = " $ct2->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero3_id" "mappa.categoria3_id" ) . " = " $ct3->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero4_id" "mappa.categoria4_id" ) . " = " $ct4->getId();
  1654.                             $stmt $connection->prepare($sqlTipoOrdine);
  1655.                             $stmt->execute();
  1656.                             $sql 'UPDATE albero_menu_prodotti SET has_child = 1 WHERE id = ?';
  1657.                             $stmt $connection->prepare($sql);
  1658.                             $stmt->bindValue(1$alberoLivello3->getId());
  1659.                             $stmt->execute();
  1660.                             if($usaCategorieAlbero == '1'){
  1661.                                 $alberoLivello4 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct4'parentId' => $alberoLivello3->getId(), 'livello' => '3'));
  1662.                             }else {
  1663.                                 $alberoLivello4 $repoAlbero->findOneBy(array('categoria' => $ct4'parentId' => $alberoLivello3->getId(), 'livello' => '3'));
  1664.                             }
  1665.                         }
  1666.                     }
  1667.                     if ($mappa['cat5']) {
  1668.                         /** @var Categorie $ct5 */
  1669.                         if($usaCategorieAlbero == '1') {
  1670.                             $ct5 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat5'])[$mappa['cat5']];
  1671.                         }else{
  1672.                             $ct5 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat5'])[$mappa['cat5']];
  1673.                         }
  1674.                         if($alberoLivello4) {
  1675.                             if($usaCategorieAlbero == '1') {
  1676.                                 $alberoLivello5 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct5'parentId' => $alberoLivello4->getId(), 'livello' => '4'));
  1677.                             }else{
  1678.                                 $alberoLivello5 $repoAlbero->findOneBy(array('categoria' => $ct5'parentId' => $alberoLivello4->getId(), 'livello' => '4'));
  1679.                             }
  1680.                         }
  1681.                         if (!$alberoLivello5 && $alberoLivello4) {
  1682.                             if ($codiceArticolo != ""){
  1683.                                 print ("Inserisco albero 5 (ID): " $mappa['cat5']);
  1684.                             }
  1685.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  1686.                                     VALUES (?, ?, ?, 4, 0, 
  1687.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) IS NOT NULL 
  1688.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) ELSE 0 END,
  1689.                                         ?, NOW(), NOW(),
  1690.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE 
  1691.                                                                 ris.codice_anagrafica = '' AND 
  1692.                                                                 ris.codice_categoria1 = ? AND 
  1693.                                                                 ris.codice_categoria2 = ? AND  
  1694.                                                                 ris.codice_categoria3 = ? AND   
  1695.                                                                 ris.codice_categoria4 = ? AND   
  1696.                                                                 ris.codice_categoria5 = ? AND                 
  1697.                                                                 ris.codice_articolo = '' AND 
  1698.                                                                 ris.marca = '' AND 
  1699.                                                                 ris.codice_dimensione1 = '' AND   
  1700.                                                                 ris.codice_dimensione2 = '' AND 
  1701.                                                                 ris.codice_dimensione3 = '' AND 
  1702.                                                                 ris.codice_dimensione4 = '' AND 
  1703.                                                                 ris.codice_dimensione5 = ''                                           
  1704.                                                 ) THEN 1 ELSE 0 END)";
  1705.                             $stmt $connection->prepare($sql);
  1706.                             $stmt->bindValue(1$ct5->getId());
  1707.                             $stmt->bindValue(2$alberoLivello4->getId());
  1708.                             $stmt->bindValue(3$user $user->getId() : null);
  1709.                             $stmt->bindValue(4$alberoLivello4->getId());
  1710.                             $stmt->bindValue(5$alberoLivello4->getId());
  1711.                             $stmt->bindValue(6$posizioneAssoluta);
  1712.                             $stmt->bindValue(7$ct1->getCodice());
  1713.                             $stmt->bindValue(8$ct2->getCodice());
  1714.                             $stmt->bindValue(9$ct3->getCodice());
  1715.                             $stmt->bindValue(10$ct4->getCodice());
  1716.                             $stmt->bindValue(11$ct5->getCodice());
  1717.                             $stmt->execute();
  1718.                             $posizioneAssoluta++;
  1719.                             $sqlTipoOrdine "
  1720.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  1721.                                     DISTINCT(ass.tipo_ordine_id),
  1722.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct5->getId() . " AND alb.parent_id_id = " $alberoLivello4->getId() . " AND alb.livello = 4 LIMIT 1)
  1723.                                 FROM associazione_articoli_tipo_ordine ass
  1724.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  1725.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass2.mappa_categoria_articolo_id = mappa.id 
  1726.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero2_id" "mappa.categoria2_id" ) . " = " $ct2->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero3_id" "mappa.categoria3_id" ) . " = " $ct3->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero4_id" "mappa.categoria4_id" ) . " = " $ct4->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero5_id" "mappa.categoria5_id" ) . " = " $ct5->getId();
  1727.                             $stmt $connection->prepare($sqlTipoOrdine);
  1728.                             $stmt->execute();
  1729.                             $sql 'UPDATE albero_menu_prodotti SET has_child = 1 WHERE id = ?';
  1730.                             $stmt $connection->prepare($sql);
  1731.                             $stmt->bindValue(1$alberoLivello4->getId());
  1732.                             $stmt->execute();
  1733.                             if($usaCategorieAlbero == '1'){
  1734.                                 $alberoLivello5 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct5'parentId' => $alberoLivello4->getId(), 'livello' => '4'));
  1735.                             }else {
  1736.                                 $alberoLivello5 $repoAlbero->findOneBy(array('categoria' => $ct5'parentId' => $alberoLivello4->getId(), 'livello' => '4'));
  1737.                             }
  1738.                         }
  1739.                     }
  1740.                     if ($mappa['cat6']) {
  1741.                         /** @var Categorie $ct6 */
  1742.                         if($usaCategorieAlbero == '1') {
  1743.                             $ct6 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat6'])[$mappa['cat6']];
  1744.                         }else{
  1745.                             $ct6 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat6'])[$mappa['cat6']];
  1746.                         }
  1747.                         if($alberoLivello5) {
  1748.                             if($usaCategorieAlbero == '1') {
  1749.                                 $alberoLivello6 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct6'parentId' => $alberoLivello5->getId(), 'livello' => '5'));
  1750.                             }else{
  1751.                                 $alberoLivello6 $repoAlbero->findOneBy(array('categoria' => $ct6'parentId' => $alberoLivello5->getId(), 'livello' => '5'));
  1752.                             }
  1753.                         }
  1754.                         if (!$alberoLivello6 && $alberoLivello5) {
  1755.                             if ($codiceArticolo != ""){
  1756.                                 print ("Inserisco albero 6 (ID): " $mappa['cat6']);
  1757.                             }
  1758.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  1759.                                     VALUES (?, ?, ?, 5, 0, 
  1760.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) IS NOT NULL 
  1761.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) ELSE 0 END,
  1762.                                         ?, NOW(), NOW(),
  1763.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE 
  1764.                                                                 ris.codice_anagrafica = '' AND 
  1765.                                                                 ris.codice_categoria1 = ? AND 
  1766.                                                                 ris.codice_categoria2 = ? AND  
  1767.                                                                 ris.codice_categoria3 = ? AND   
  1768.                                                                 ris.codice_categoria4 = ? AND   
  1769.                                                                 ris.codice_categoria5 = ? AND                 
  1770.                                                                 ris.codice_articolo = '' AND 
  1771.                                                                 ris.marca = '' AND 
  1772.                                                                 ris.codice_dimensione1 = '' AND   
  1773.                                                                 ris.codice_dimensione2 = '' AND 
  1774.                                                                 ris.codice_dimensione3 = '' AND 
  1775.                                                                 ris.codice_dimensione4 = '' AND 
  1776.                                                                 ris.codice_dimensione5 = ''                                           
  1777.                                                 ) THEN 1 ELSE 0 END)";
  1778.                             $stmt $connection->prepare($sql);
  1779.                             $stmt->bindValue(1$ct6->getId());
  1780.                             $stmt->bindValue(2$alberoLivello5->getId());
  1781.                             $stmt->bindValue(3$user $user->getId() : null);
  1782.                             $stmt->bindValue(4$alberoLivello5->getId());
  1783.                             $stmt->bindValue(5$alberoLivello5->getId());
  1784.                             $stmt->bindValue(6$posizioneAssoluta);
  1785.                             $stmt->bindValue(7$ct1->getCodice());
  1786.                             $stmt->bindValue(8$ct2->getCodice());
  1787.                             $stmt->bindValue(9$ct3->getCodice());
  1788.                             $stmt->bindValue(10$ct4->getCodice());
  1789.                             $stmt->bindValue(11$ct5->getCodice());
  1790.                             $stmt->execute();
  1791.                             $posizioneAssoluta++;
  1792.                             $sqlTipoOrdine "
  1793.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  1794.                                     DISTINCT(ass.tipo_ordine_id),
  1795.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct6->getId() . " AND alb.parent_id_id = " $alberoLivello5->getId() . " AND alb.livello = 5 LIMIT 1)
  1796.                                 FROM associazione_articoli_tipo_ordine ass
  1797.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  1798.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass2.mappa_categoria_articolo_id = mappa.id 
  1799.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero2_id" "mappa.categoria2_id" ) . " = " $ct2->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero3_id" "mappa.categoria3_id" ) . " = " $ct3->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero4_id" "mappa.categoria4_id" ) . " = " $ct4->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero5_id" "mappa.categoria5_id" ) . " = " $ct5->getId(). " AND " . ($usaCategorieAlbero "ass2.categoria_albero6_id" "mappa.categoria6_id" ) . " = " $ct6->getId();
  1800.                             $stmt $connection->prepare($sqlTipoOrdine);
  1801.                             $stmt->execute();
  1802.                             $sql 'UPDATE albero_menu_prodotti SET has_child = 1 WHERE id = ?';
  1803.                             $stmt $connection->prepare($sql);
  1804.                             $stmt->bindValue(1$alberoLivello5->getId());
  1805.                             $stmt->execute();
  1806.                             if($usaCategorieAlbero == '1'){
  1807.                                 $alberoLivello6 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct6'parentId' => $alberoLivello5->getId(), 'livello' => '5'));
  1808.                             }else {
  1809.                                 $alberoLivello6 $repoAlbero->findOneBy(array('categoria' => $ct6'parentId' => $alberoLivello5->getId(), 'livello' => '5'));
  1810.                             }
  1811.                         }
  1812.                     }
  1813.                     if ($mappa['cat7']) {
  1814.                         /** @var Categorie $ct7 */
  1815.                         if($usaCategorieAlbero == '1') {
  1816.                             $ct7 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat7'])[$mappa['cat7']];
  1817.                         }else{
  1818.                             $ct7 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat7'])[$mappa['cat7']];
  1819.                         }
  1820.                         if($alberoLivello6) {
  1821.                             if($usaCategorieAlbero == '1') {
  1822.                                 $alberoLivello7 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct7'parentId' => $alberoLivello6->getId(), 'livello' => '6'));
  1823.                             }else{
  1824.                                 $alberoLivello7 $repoAlbero->findOneBy(array('categoria' => $ct7'parentId' => $alberoLivello6->getId(), 'livello' => '6'));
  1825.                             }
  1826.                         }
  1827.                         if (!$alberoLivello7 && $alberoLivello6) {
  1828.                             if ($codiceArticolo != ""){
  1829.                                 print ("Inserisco albero 7 (ID): " $mappa['cat7']);
  1830.                             }
  1831.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  1832.                                     VALUES (?, ?, ?, 6, 0, 
  1833.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) IS NOT NULL 
  1834.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) ELSE 0 END,
  1835.                                         ?, NOW(), NOW(),
  1836.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE 
  1837.                                                                 ris.codice_anagrafica = '' AND 
  1838.                                                                 ris.codice_categoria1 = ? AND 
  1839.                                                                 ris.codice_categoria2 = ? AND  
  1840.                                                                 ris.codice_categoria3 = ? AND   
  1841.                                                                 ris.codice_categoria4 = ? AND   
  1842.                                                                 ris.codice_categoria5 = ? AND                 
  1843.                                                                 ris.codice_articolo = '' AND 
  1844.                                                                 ris.marca = '' AND 
  1845.                                                                 ris.codice_dimensione1 = '' AND   
  1846.                                                                 ris.codice_dimensione2 = '' AND 
  1847.                                                                 ris.codice_dimensione3 = '' AND 
  1848.                                                                 ris.codice_dimensione4 = '' AND 
  1849.                                                                 ris.codice_dimensione5 = ''                                           
  1850.                                                 ) THEN 1 ELSE 0 END)";
  1851.                             $stmt $connection->prepare($sql);
  1852.                             $stmt->bindValue(1$ct7->getId());
  1853.                             $stmt->bindValue(2$alberoLivello6->getId());
  1854.                             $stmt->bindValue(3$user $user->getId() : null);
  1855.                             $stmt->bindValue(4$alberoLivello6->getId());
  1856.                             $stmt->bindValue(5$alberoLivello6->getId());
  1857.                             $stmt->bindValue(6$posizioneAssoluta);
  1858.                             $stmt->bindValue(7$ct1->getCodice());
  1859.                             $stmt->bindValue(8$ct2->getCodice());
  1860.                             $stmt->bindValue(9$ct3->getCodice());
  1861.                             $stmt->bindValue(10$ct4->getCodice());
  1862.                             $stmt->bindValue(11$ct5->getCodice());
  1863.                             $stmt->execute();
  1864.                             $posizioneAssoluta++;
  1865.                             $sqlTipoOrdine "
  1866.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  1867.                                     DISTINCT(ass.tipo_ordine_id),
  1868.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct7->getId() . " AND alb.parent_id_id = " $alberoLivello6->getId() . " AND alb.livello = 6 LIMIT 1)
  1869.                                 FROM associazione_articoli_tipo_ordine ass
  1870.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  1871.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass2.mappa_categoria_articolo_id = mappa.id 
  1872.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero2_id" "mappa.categoria2_id" ) . " = " $ct2->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero3_id" "mappa.categoria3_id" ) . " = " $ct3->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero4_id" "mappa.categoria4_id" ) . " = " $ct4->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero5_id" "mappa.categoria5_id" ) . " = " $ct5->getId(). " AND " . ($usaCategorieAlbero "ass2.categoria_albero6_id" "mappa.categoria6_id" ) . " = " $ct6->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero7_id" "mappa.categoria7_id" ) . " = " $ct7->getId();
  1873.                             $stmt $connection->prepare($sqlTipoOrdine);
  1874.                             $stmt->execute();
  1875.                             $sql 'UPDATE albero_menu_prodotti SET has_child = 1 WHERE id = ?';
  1876.                             $stmt $connection->prepare($sql);
  1877.                             $stmt->bindValue(1$alberoLivello6->getId());
  1878.                             $stmt->execute();
  1879.                             if($usaCategorieAlbero == '1'){
  1880.                                 $alberoLivello7 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct7'parentId' => $alberoLivello6->getId(), 'livello' => '6'));
  1881.                             }else {
  1882.                                 $alberoLivello7 $repoAlbero->findOneBy(array('categoria' => $ct7'parentId' => $alberoLivello6->getId(), 'livello' => '6'));
  1883.                             }
  1884.                         }
  1885.                     }
  1886.                     if ($mappa['cat8']) {
  1887.                         /** @var Categorie $ct8 */
  1888.                         if($usaCategorieAlbero == '1') {
  1889.                             $ct8 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat8'])[$mappa['cat8']];
  1890.                         }else{
  1891.                             $ct8 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat8'])[$mappa['cat8']];
  1892.                         }
  1893.                         if($alberoLivello7) {
  1894.                             if($usaCategorieAlbero == '1') {
  1895.                                 $alberoLivello8 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct8'parentId' => $alberoLivello7->getId(), 'livello' => '7'));
  1896.                             }else{
  1897.                                 $alberoLivello8 $repoAlbero->findOneBy(array('categoria' => $ct8'parentId' => $alberoLivello7->getId(), 'livello' => '7'));
  1898.                             }
  1899.                         }
  1900.                         if (!$alberoLivello8 && $alberoLivello7) {
  1901.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  1902.                                     VALUES (?, ?, ?, 7, 0, 
  1903.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) IS NOT NULL 
  1904.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) ELSE 0 END,
  1905.                                         ?, NOW(), NOW(),
  1906.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE 
  1907.                                                                 ris.codice_anagrafica = '' AND 
  1908.                                                                 ris.codice_categoria1 = ? AND 
  1909.                                                                 ris.codice_categoria2 = ? AND  
  1910.                                                                 ris.codice_categoria3 = ? AND   
  1911.                                                                 ris.codice_categoria4 = ? AND   
  1912.                                                                 ris.codice_categoria5 = ? AND                 
  1913.                                                                 ris.codice_articolo = '' AND 
  1914.                                                                 ris.marca = '' AND 
  1915.                                                                 ris.codice_dimensione1 = '' AND   
  1916.                                                                 ris.codice_dimensione2 = '' AND 
  1917.                                                                 ris.codice_dimensione3 = '' AND 
  1918.                                                                 ris.codice_dimensione4 = '' AND 
  1919.                                                                 ris.codice_dimensione5 = ''                                           
  1920.                                                 ) THEN 1 ELSE 0 END)";
  1921.                             $stmt $connection->prepare($sql);
  1922.                             $stmt->bindValue(1$ct8->getId());
  1923.                             $stmt->bindValue(2$alberoLivello7->getId());
  1924.                             $stmt->bindValue(3$user $user->getId() : null);
  1925.                             $stmt->bindValue(4$alberoLivello7->getId());
  1926.                             $stmt->bindValue(5$alberoLivello7->getId());
  1927.                             $stmt->bindValue(6$posizioneAssoluta);
  1928.                             $stmt->bindValue(7$ct1->getCodice());
  1929.                             $stmt->bindValue(8$ct2->getCodice());
  1930.                             $stmt->bindValue(9$ct3->getCodice());
  1931.                             $stmt->bindValue(10$ct4->getCodice());
  1932.                             $stmt->bindValue(11$ct5->getCodice());
  1933.                             $stmt->execute();
  1934.                             $posizioneAssoluta++;
  1935.                             $sqlTipoOrdine "
  1936.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  1937.                                     DISTINCT(ass.tipo_ordine_id),
  1938.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct8->getId() . " AND alb.parent_id_id = " $alberoLivello7->getId() . " AND alb.livello = 7 LIMIT 1)
  1939.                                 FROM associazione_articoli_tipo_ordine ass
  1940.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  1941.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass2.mappa_categoria_articolo_id = mappa.id 
  1942.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero2_id" "mappa.categoria2_id" ) . " = " $ct2->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero3_id" "mappa.categoria3_id" ) . " = " $ct3->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero4_id" "mappa.categoria4_id" ) . " = " $ct4->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero5_id" "mappa.categoria5_id" ) . " = " $ct5->getId(). " AND " . ($usaCategorieAlbero "ass2.categoria_albero6_id" "mappa.categoria6_id" ) . " = " $ct6->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero7_id" "mappa.categoria7_id" ) . " = " $ct7->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero8_id" "mappa.categoria8_id" ) . " = " $ct8->getId();
  1943.                             $stmt $connection->prepare($sqlTipoOrdine);
  1944.                             $stmt->execute();
  1945.                             $sql 'UPDATE albero_menu_prodotti SET has_child = 1 WHERE id = ?';
  1946.                             $stmt $connection->prepare($sql);
  1947.                             $stmt->bindValue(1$alberoLivello7->getId());
  1948.                             $stmt->execute();
  1949.                             if($usaCategorieAlbero == '1'){
  1950.                                 $alberoLivello8 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct8'parentId' => $alberoLivello7->getId(), 'livello' => '7'));
  1951.                             }else {
  1952.                                 $alberoLivello8 $repoAlbero->findOneBy(array('categoria' => $ct8'parentId' => $alberoLivello7->getId(), 'livello' => '7'));
  1953.                             }
  1954.                         }
  1955.                     }
  1956.                     if ($mappa['cat9']) {
  1957.                         /** @var Categorie $ct9 */
  1958.                         if($usaCategorieAlbero == '1') {
  1959.                             $ct9 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat9'])[$mappa['cat9']];
  1960.                         }else{
  1961.                             $ct9 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat9'])[$mappa['cat9']];
  1962.                         }
  1963.                         if($alberoLivello8) {
  1964.                             if($usaCategorieAlbero == '1') {
  1965.                                 $alberoLivello9 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct9'parentId' => $alberoLivello8->getId(), 'livello' => '8'));
  1966.                             }else{
  1967.                                 $alberoLivello9 $repoAlbero->findOneBy(array('categoria' => $ct9'parentId' => $alberoLivello8->getId(), 'livello' => '8'));
  1968.                             }
  1969.                         }
  1970.                         if (!$alberoLivello9 && $alberoLivello8) {
  1971.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  1972.                                     VALUES (?, ?, ?, 8, 0, 
  1973.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) IS NOT NULL 
  1974.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) ELSE 0 END,
  1975.                                         ?, NOW(), NOW(),
  1976.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE 
  1977.                                                                 ris.codice_anagrafica = '' AND 
  1978.                                                                 ris.codice_categoria1 = ? AND 
  1979.                                                                 ris.codice_categoria2 = ? AND  
  1980.                                                                 ris.codice_categoria3 = ? AND   
  1981.                                                                 ris.codice_categoria4 = ? AND   
  1982.                                                                 ris.codice_categoria5 = ? AND                 
  1983.                                                                 ris.codice_articolo = '' AND 
  1984.                                                                 ris.marca = '' AND 
  1985.                                                                 ris.codice_dimensione1 = '' AND   
  1986.                                                                 ris.codice_dimensione2 = '' AND 
  1987.                                                                 ris.codice_dimensione3 = '' AND 
  1988.                                                                 ris.codice_dimensione4 = '' AND 
  1989.                                                                 ris.codice_dimensione5 = ''                                           
  1990.                                                 ) THEN 1 ELSE 0 END)";
  1991.                             $stmt $connection->prepare($sql);
  1992.                             $stmt->bindValue(1$ct9->getId());
  1993.                             $stmt->bindValue(2$alberoLivello8->getId());
  1994.                             $stmt->bindValue(3$user $user->getId() : null);
  1995.                             $stmt->bindValue(4$alberoLivello8->getId());
  1996.                             $stmt->bindValue(5$alberoLivello8->getId());
  1997.                             $stmt->bindValue(6$posizioneAssoluta);
  1998.                             $stmt->bindValue(7$ct1->getCodice());
  1999.                             $stmt->bindValue(8$ct2->getCodice());
  2000.                             $stmt->bindValue(9$ct3->getCodice());
  2001.                             $stmt->bindValue(10$ct4->getCodice());
  2002.                             $stmt->bindValue(11$ct5->getCodice());
  2003.                             $stmt->execute();
  2004.                             $posizioneAssoluta++;
  2005.                             $sqlTipoOrdine "
  2006.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  2007.                                     DISTINCT(ass.tipo_ordine_id),
  2008.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct9->getId() . " AND alb.parent_id_id = " $alberoLivello8->getId() . " AND alb.livello = 8 LIMIT 1)
  2009.                                 FROM associazione_articoli_tipo_ordine ass
  2010.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  2011.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass2.mappa_categoria_articolo_id = mappa.id 
  2012.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero2_id" "mappa.categoria2_id" ) . " = " $ct2->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero3_id" "mappa.categoria3_id" ) . " = " $ct3->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero4_id" "mappa.categoria4_id" ) . " = " $ct4->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero5_id" "mappa.categoria5_id" ) . " = " $ct5->getId(). " AND " . ($usaCategorieAlbero "ass2.categoria_albero6_id" "mappa.categoria6_id" ) . " = " $ct6->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero7_id" "mappa.categoria7_id" ) . " = " $ct7->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero8_id" "mappa.categoria8_id" ) . " = " $ct8->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero9_id" "mappa.categoria9_id" ) . " = " $ct9->getId();
  2013.                             $stmt $connection->prepare($sqlTipoOrdine);
  2014.                             $stmt->execute();
  2015.                             $sql 'UPDATE albero_menu_prodotti SET has_child = 1 WHERE id = ?';
  2016.                             $stmt $connection->prepare($sql);
  2017.                             $stmt->bindValue(1$alberoLivello8->getId());
  2018.                             $stmt->execute();
  2019.                             if($usaCategorieAlbero == '1'){
  2020.                                 $alberoLivello9 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct9'parentId' => $alberoLivello8->getId(), 'livello' => '8'));
  2021.                             }else {
  2022.                                 $alberoLivello9 $repoAlbero->findOneBy(array('categoria' => $ct9'parentId' => $alberoLivello8->getId(), 'livello' => '8'));
  2023.                             }
  2024.                         }
  2025.                     }
  2026.                     if ($mappa['cat10']) {
  2027.                         /** @var Categorie $ct10 */
  2028.                         if($usaCategorieAlbero == '1') {
  2029.                             $ct10 $this->ricavaCategoriaAlbero($arrayCacheCategorie$mappa['cat10'])[$mappa['cat10']];
  2030.                         }else{
  2031.                             $ct10 $this->ricavaCategoria($arrayCacheCategorie$mappa['cat10'])[$mappa['cat10']];
  2032.                         }
  2033.                         if($alberoLivello9) {
  2034.                             if($usaCategorieAlbero == '1') {
  2035.                                 $alberoLivello10 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct10'parentId' => $alberoLivello9->getId(), 'livello' => '9'));
  2036.                             }else{
  2037.                                 $alberoLivello10 $repoAlbero->findOneBy(array('categoria' => $ct10'parentId' => $alberoLivello9->getId(), 'livello' => '9'));
  2038.                             }
  2039.                         }
  2040.                         if (!$alberoLivello10 && $alberoLivello9) {
  2041.                             $sql "INSERT INTO albero_menu_prodotti (" . ($usaCategorieAlbero "categoria_albero_id" "categoria_id") . ", parent_id_id, utente_id, livello, has_child, posizione, posizione_assoluta, data_creazione, data_modifica, risorse_presenti)
  2042.                                     VALUES (?, ?, ?, 9, 0, 
  2043.                                             CASE WHEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) IS NOT NULL 
  2044.                                                 THEN (SELECT COUNT(alb.id) FROM albero_menu_prodotti alb WHERE alb.parent_id_id = ?) ELSE 0 END,
  2045.                                         ?, NOW(), NOW(),
  2046.                                             CASE WHEN EXISTS(SELECT ris.id FROM risorse_anagrafiche ris WHERE 
  2047.                                                                 ris.codice_anagrafica = '' AND 
  2048.                                                                 ris.codice_categoria1 = ? AND 
  2049.                                                                 ris.codice_categoria2 = ? AND  
  2050.                                                                 ris.codice_categoria3 = ? AND   
  2051.                                                                 ris.codice_categoria4 = ? AND   
  2052.                                                                 ris.codice_categoria5 = ? AND                 
  2053.                                                                 ris.codice_articolo = '' AND 
  2054.                                                                 ris.marca = '' AND 
  2055.                                                                 ris.codice_dimensione1 = '' AND   
  2056.                                                                 ris.codice_dimensione2 = '' AND 
  2057.                                                                 ris.codice_dimensione3 = '' AND 
  2058.                                                                 ris.codice_dimensione4 = '' AND 
  2059.                                                                 ris.codice_dimensione5 = ''                                           
  2060.                                                 ) THEN 1 ELSE 0 END)";
  2061.                             $stmt $connection->prepare($sql);
  2062.                             $stmt->bindValue(1$ct10->getId());
  2063.                             $stmt->bindValue(2$alberoLivello9->getId());
  2064.                             $stmt->bindValue(3$user $user->getId() : null);
  2065.                             $stmt->bindValue(4$alberoLivello9->getId());
  2066.                             $stmt->bindValue(5$alberoLivello9->getId());
  2067.                             $stmt->bindValue(6$posizioneAssoluta);
  2068.                             $stmt->bindValue(7$ct1->getCodice());
  2069.                             $stmt->bindValue(8$ct2->getCodice());
  2070.                             $stmt->bindValue(9$ct3->getCodice());
  2071.                             $stmt->bindValue(10$ct4->getCodice());
  2072.                             $stmt->bindValue(11$ct5->getCodice());
  2073.                             $stmt->execute();
  2074.                             $posizioneAssoluta++;
  2075.                             $sqlTipoOrdine "
  2076.                                 INSERT INTO associazione_albero_menu_prodotti_tipo_ordine (tipo_ordine_id, albero_menu_id) SELECT 
  2077.                                     DISTINCT(ass.tipo_ordine_id),
  2078.                                     (SELECT alb.id FROM albero_menu_prodotti alb WHERE " . ($usaCategorieAlbero ?  "alb.categoria_albero_id" "alb.categoria_id") . " = " $ct10->getId() . " AND alb.parent_id_id = " $alberoLivello9->getId() . " AND alb.livello = 9 LIMIT 1)
  2079.                                 FROM associazione_articoli_tipo_ordine ass
  2080.                                     LEFT JOIN mappa_categorie_articoli mappa ON mappa.id = ass.mappa_categoria_articolo_id
  2081.                                     LEFT JOIN associazione_categorie_albero_mappa_categorie_articoli ass2 ON ass2.mappa_categoria_articolo_id = mappa.id 
  2082.                                 WHERE " . ($usaCategorieAlbero "ass2.categoria_albero1_id" "mappa.categoria1_id" ) . " = " $ct1->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero2_id" "mappa.categoria2_id" ) . " = " $ct2->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero3_id" "mappa.categoria3_id" ) . " = " $ct3->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero4_id" "mappa.categoria4_id" ) . " = " $ct4->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero5_id" "mappa.categoria5_id" ) . " = " $ct5->getId(). " AND " . ($usaCategorieAlbero "ass2.categoria_albero6_id" "mappa.categoria6_id" ) . " = " $ct6->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero7_id" "mappa.categoria7_id" ) . " = " $ct7->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero8_id" "mappa.categoria8_id" ) . " = " $ct8->getId() . " AND " . ($usaCategorieAlbero "ass2.categoria_albero9_id" "mappa.categoria9_id" ) . " = " $ct9->getId(). " AND " . ($usaCategorieAlbero "ass2.categoria_albero10_id" "mappa.categoria10_id" ) . " = " $ct10->getId();
  2083.                             $stmt $connection->prepare($sqlTipoOrdine);
  2084.                             $stmt->execute();
  2085.                             $sql 'UPDATE albero_menu_prodotti SET has_child = 1 WHERE id = ?';
  2086.                             $stmt $connection->prepare($sql);
  2087.                             $stmt->bindValue(1$alberoLivello9->getId());
  2088.                             $stmt->execute();
  2089.                             if($usaCategorieAlbero == '1'){
  2090.                                 $alberoLivello10 $repoAlbero->findOneBy(array('categoriaAlbero' => $ct10'parentId' => $alberoLivello9->getId(), 'livello' => '9'));
  2091.                             }else {
  2092.                                 $alberoLivello10 $repoAlbero->findOneBy(array('categoria' => $ct10'parentId' => $alberoLivello9->getId(), 'livello' => '9'));
  2093.                             }
  2094.                         }
  2095.                     }
  2096.                 }
  2097.                 $inizio $inizio $batch;
  2098.             }
  2099.             $this->addFlash(
  2100.                 'notice',
  2101.                 'Albero menu rigenerato con successo in ' $time_elapsed_secs microtime(true) - $start ' seconds'
  2102.             );
  2103.             if($indicizzaAttributi == "1")
  2104.                 $this->generaIndicizzazioneAttributi($requesttrue);
  2105.             $this->servizi->ScriviRegistroAttivita($request->getClientIp(), ''true'Albero menu rigenerato con successo in ' $time_elapsed_secs microtime(true) - $start ' seconds'$user$collegamentoRnd'ImportazioneController''generaAlbero');
  2106.             return $this->render('default/index.html.twig', array('testo' => $debugRitorno));
  2107.         } catch (\PDOException $exx){
  2108.             $this->servizi->DebuggaException($exx'Errore genera albero: 'falsenull$collegamentoRnd'ImportazioneController''generaAlbero');
  2109.         } catch (\Exception|\Throwable $ex) {
  2110.             $this->servizi->DebuggaException($ex'Errore genera albero: 'falsenull$collegamentoRnd'ImportazioneController''generaAlbero');
  2111.         }
  2112.         return new Response('ERRORE');
  2113.     }
  2114.     function ricavaCategoria($arrayCache$idCategoria){
  2115.         if(!array_key_exists($idCategoria$arrayCache)){
  2116.             $cacheCategorie = new Caching_Categorie($this->servizi);
  2117.             $arrayCache[$idCategoria] = $cacheCategorie->getCategoria($idCategoria);
  2118.             //$this->servizi->doctrine->getRepository(Categorie::class)->find($idCategoria);
  2119.         }
  2120.         return $arrayCache;
  2121.     }
  2122.     function ricavaCategoriaAlbero($arrayCache$idCategoria){
  2123.         if(!array_key_exists($idCategoria$arrayCache)){
  2124.             $cacheCategorie = new Caching_CategorieAlbero($this->servizi);
  2125.             $arrayCache[$idCategoria] = $cacheCategorie->getCategoriaAlbero($idCategoria);
  2126.             //$this->servizi->doctrine->getRepository(Categorie::class)->find($idCategoria);
  2127.         }
  2128.         return $arrayCache;
  2129.     }
  2130.     function controllaEAggiungiSeInsistente($array$chiave)
  2131.     {
  2132.         if (!array_key_exists($chiave$array)) {
  2133.             $array[$chiave] = array();
  2134.         }
  2135.         return $array;
  2136.     }
  2137.     /**
  2138.      * @Route("/caricaRisorseAnagraficheValori", name="carica_risorse_anagrafiche_valori")
  2139.      */
  2140.     public function caricaRisorseAnagraficheValori(Request $request)
  2141.     {
  2142.         $collegamentoRnd $this->servizi->randomString2();
  2143.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  2144.             ini_set('max_execution_time'900);
  2145.             ini_set('memory_limit''4G');
  2146.             $start microtime(true);
  2147.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  2148.             $em $this->servizi->doctrine->getManager();
  2149.             $user $this->servizi->OttieniUtenteCorrente();
  2150.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  2151.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  2152.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  2153.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  2154.             $repoRisorse $this->servizi->doctrine->getRepository(RisorseAnagrafiche::class);
  2155.             $repoRisValori $this->servizi->doctrine->getRepository(RisorseAnagraficheColonneValori::class);
  2156.             $repoColonne $this->servizi->doctrine->getRepository(RisorseAnagraficheColonne::class);
  2157.             $errori "";
  2158.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaRisorseAnagraficheValori --- Inizio l\' importazione delle scontistiche delle anagrafiche'null$collegamentoRnd'ImportazioneController''caricaRisorseAnagraficheValori');
  2159.             $root_path $pathFileBase "risorse_anagrafiche_valori.csv";
  2160.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  2161.             $contatore 0;
  2162.             $query_eseguite 0;
  2163.             $row 0;
  2164.             $batch_size 50;
  2165.             /*
  2166.              * Index    Campo
  2167.                 0    identificativo_unico_risorsa_anagrafica
  2168.                 1    nome_colonna
  2169.                 2    ordinatore
  2170.                 3    valore
  2171.                 4    tipo_dato
  2172.                 5    header_visualizzato
  2173.                 6    nascosto
  2174.                 7    operazione
  2175.                 8   direzione_ordinamento
  2176.                 9   ordinazione_ordinamento
  2177.              */
  2178.             $indici = array(
  2179.                 "identificativoUnicoRisorsaAnagrafica" => 0,
  2180.                 "nomeColonna" => 1,
  2181.                 "ordinatore" => 2,
  2182.                 "valore" => 3,
  2183.                 "tipoDato" => 4,
  2184.                 "headerVisualizzato" => 5,
  2185.                 "nascosto" => 6,
  2186.                 "operazione" => 7,
  2187.                 "direzioneOrdinamento" => 8,
  2188.                 "ordinazioneOrdinamento" => 9
  2189.             );
  2190.             $tipiDatoAutorizzati $this->servizi->RitornaArrayTipoDato();
  2191.             $tt = array();
  2192.             foreach ($tipiDatoAutorizzati as $key){
  2193.                 array_push($tt$key);
  2194.             }
  2195.             $tipiDatoAutorizzati $tt;
  2196.             try {
  2197.                 if (($handle fopen($root_path"r")) !== false) {
  2198.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  2199.                         if ($row == 0) {
  2200.                             $row 1;
  2201.                             continue;
  2202.                         }
  2203.                         if ($query_eseguite >= $batch_size) {
  2204.                             $contatore $contatore $row 1;
  2205.                             $row 1;
  2206.                             $query_eseguite 0;
  2207.                             $em->flush();
  2208.                             $em->clear();
  2209.                         }
  2210.                         if(in_array($data[$indici['tipoDato']], $tipiDatoAutorizzati)) {
  2211.                             $testataRisorsa $repoRisorse->findOneBy(array('identificativoUnico' => $data[$indici['identificativoUnicoRisorsaAnagrafica']]));
  2212.                             if ($testataRisorsa) {
  2213.                                 $risorsa $repoRisValori->findOneBy(array('risorsaAnagrafica' => $testataRisorsa'nomeColonna' => $data[$indici['nomeColonna']]));
  2214.                                 if ($data[$indici['operazione']] == 'E') {
  2215.                                     if ($risorsa) {
  2216.                                         $em->remove($risorsa);
  2217.                                         $query_eseguite++;
  2218.                                     }
  2219.                                 } else {
  2220.                                     //Identifico la testata Risorsa anagrafica
  2221.                                     //Identifico la colonna
  2222.                                     $colonna $repoColonne->findOneBy(array('nome' => $data[$indici['nomeColonna']], 'tipoDato' => $data[$indici['tipoDato']]));
  2223.                                     if (!$colonna) {
  2224.                                         $colonna = new RisorseAnagraficheColonne();
  2225.                                         $colonna->setNome($data[$indici['nomeColonna']]);
  2226.                                         $colonna->setTipoDato($data[$indici['tipoDato']]);
  2227.                                         $colonna->setHeaderVisualizzato($data[$indici['headerVisualizzato']] != '' $data[$indici['headerVisualizzato']] : $colonna->getNome());
  2228.                                         $colonna->setNascosto($data[$indici['nascosto']] != '0' true false);
  2229.                                         $colonna->setDataCreazione(new \DateTime());
  2230.                                         $colonna->setDataModifica(new \DateTime());
  2231.                                         if(count($data) > 8)
  2232.                                             $colonna->setDirezioneOrdinamento(strtolower($data[$indici['direzioneOrdinamento']] ? $data[$indici['direzioneOrdinamento']] : ''));
  2233.                                         if(count($data) > 9)
  2234.                                             $colonna->setOrdinazioneOrdinamento($data[$indici['ordinazioneOrdinamento']] != '' $data[$indici['ordinazioneOrdinamento']] : null);
  2235.                                         $em->persist($colonna);
  2236.                                         $query_eseguite++;
  2237.                                     } else {
  2238.                                         $colonna->setHeaderVisualizzato($data[$indici['headerVisualizzato']] != '' $data[$indici['headerVisualizzato']] : $colonna->getNome());
  2239.                                         $colonna->setNascosto($data[$indici['nascosto']] != '0' true false);
  2240.                                         $colonna->setDataModifica(new \DateTime());
  2241.                                         $em->persist($colonna);
  2242.                                         $query_eseguite++;
  2243.                                     }
  2244.                                     if (!$risorsa) {
  2245.                                         $risorsa = new RisorseAnagraficheColonneValori();
  2246.                                         $risorsa->setRisorsaAnagrafica($testataRisorsa);
  2247.                                         $risorsa->setColonna($colonna);
  2248.                                         $risorsa->setNomeColonna($data[$indici['nomeColonna']]);
  2249.                                         $risorsa->setOrdinatore($data[$indici['ordinatore']]);
  2250.                                         $risorsa->setValore(null);
  2251.                                         $risorsa->setValoreBoolean(null);
  2252.                                         $risorsa->setValoreDatetime(null);
  2253.                                         $risorsa->setValoreDecimale(null);
  2254.                                         $risorsa->setValoreInteger(null);
  2255.                                         switch ($colonna->getTipoDato())
  2256.                                         {
  2257.                                             case 'text':{
  2258.                                                 $risorsa->setValore($data[$indici['valore']]);
  2259.                                                 break;
  2260.                                             }
  2261.                                             case 'integer':{
  2262.                                                 $risorsa->setValoreInteger($data[$indici['valore']]);
  2263.                                                 break;
  2264.                                             }
  2265.                                             case 'decimal':{
  2266.                                                 $risorsa->setValoreDecimale($data[$indici['valore']]);
  2267.                                                 break;
  2268.                                             }
  2269.                                             case 'boolean':{
  2270.                                                 $risorsa->setValoreBoolean(boolval($data[$indici['valore']]));
  2271.                                                 break;
  2272.                                             }
  2273.                                             case 'datetime':{
  2274.                                                 $risorsa->setValoreDatetime(\DateTime::createFromFormat('Y-m-d H:i:s'$data[$indici['valore']]));
  2275.                                                 break;
  2276.                                             }
  2277.                                             case 'date':{
  2278.                                                 $dat \DateTime::createFromFormat('Y-m-d'$data[$indici['valore']]);
  2279.                                                 $dat->setTime(000);
  2280.                                                 $risorsa->setValoreDatetime($dat);
  2281.                                                 break;
  2282.                                             }
  2283.                                             case 'time':{
  2284.                                                 $dat \DateTime::createFromFormat('H:i:s'$data[$indici['valore']]);
  2285.                                                 $dat->setDate(189900);
  2286.                                                 $risorsa->setValoreDatetime($dat);
  2287.                                                 break;
  2288.                                             }
  2289.                                         }
  2290.                                         $risorsa->setDataModifica(new \DateTime());
  2291.                                         $risorsa->setDataCreazione(new \DateTime());
  2292.                                         $em->persist($risorsa);
  2293.                                         $query_eseguite++;
  2294.                                     } else {
  2295.                                         $risorsa->setOrdinatore($data[$indici['ordinatore']]);
  2296.                                         $risorsa->setValore(null);
  2297.                                         $risorsa->setValoreBoolean(null);
  2298.                                         $risorsa->setValoreDatetime(null);
  2299.                                         $risorsa->setValoreDecimale(null);
  2300.                                         $risorsa->setValoreInteger(null);
  2301.                                         switch ($colonna->getTipoDato())
  2302.                                         {
  2303.                                             case 'text':{
  2304.                                                 $risorsa->setValore($data[$indici['valore']]);
  2305.                                                 break;
  2306.                                             }
  2307.                                             case 'integer':{
  2308.                                                 $risorsa->setValoreInteger($data[$indici['valore']]);
  2309.                                                 break;
  2310.                                             }
  2311.                                             case 'decimal':{
  2312.                                                 $risorsa->setValoreDecimale($data[$indici['valore']]);
  2313.                                                 break;
  2314.                                             }
  2315.                                             case 'boolean':{
  2316.                                                 $risorsa->setValoreBoolean(boolval($data[$indici['valore']]));
  2317.                                                 break;
  2318.                                             }
  2319.                                             case 'datetime':{
  2320.                                                 $risorsa->setValoreDatetime(\DateTime::createFromFormat('Y-m-d H:i:s'$data[$indici['valore']]));
  2321.                                                 break;
  2322.                                             }
  2323.                                             case 'date':{
  2324.                                                 $dat \DateTime::createFromFormat('Y-m-d'$data[$indici['valore']]);
  2325.                                                 $dat->setTime(000);
  2326.                                                 $risorsa->setValoreDatetime($dat);
  2327.                                                 break;
  2328.                                             }
  2329.                                             case 'time':{
  2330.                                                 $dat \DateTime::createFromFormat('H:i:s'$data[$indici['valore']]);
  2331.                                                 $dat->setDate(189900);
  2332.                                                 $risorsa->setValoreDatetime($dat);
  2333.                                                 break;
  2334.                                             }
  2335.                                         }
  2336.                                         $risorsa->setDataModifica(new \DateTime());
  2337.                                         $em->persist($risorsa);
  2338.                                         $query_eseguite++;
  2339.                                     }
  2340.                                 }
  2341.                             } else {
  2342.                                 $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Risorsa anagrafica con identificativo univoco: ' $data[$indici['identificativoUnicoRisorsaAnagrafica']] . ' non trovata!'$user$collegamentoRnd'ImportazioneController''caricaRisorseAnagraficheValori');
  2343.                             }
  2344.                         }else{
  2345.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Tipo dato: ' $data[$indici['tipoDato']] . ' non riconosciuto!'null$collegamentoRnd'ImportazioneController''caricaRisorseAnagraficheValori');
  2346.                         }
  2347.                         $row++;
  2348.                         $em->flush();
  2349.                     }
  2350.                     $em->flush();
  2351.                     $em->clear();
  2352.                 }else{
  2353.                     $errori .= "Impossibile aprire il file!";
  2354.                 }
  2355.                 $row $contatore $row;
  2356.                 if ($errori == "") {
  2357.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaRisorseAnagraficheValori');
  2358.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  2359.                 } else {
  2360.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaRisorseAnagraficheValori');
  2361.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  2362.                 }
  2363.             } catch (\Exception|\Throwable $ex) {
  2364.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaRisorseAnagraficheValori');
  2365.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  2366.             }
  2367.         } else {
  2368.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaRisorseAnagraficheValori');
  2369.             return new Response("ERRORE PERMESSO");
  2370.         }
  2371.     } //OK
  2372.     /**
  2373.      * @Route("/caricaAssociazioniArticoliClienti/{svuota}", name="carica_rassociazione_articoli_clienti", defaults={"svuota"="0"})
  2374.      */
  2375.     public function caricaAssociazioneArticoliClienti(Request $request$svuota)
  2376.     {
  2377.         $collegamentoRnd $this->servizi->randomString2();
  2378.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  2379.             ini_set('max_execution_time'7200);
  2380.             ini_set('memory_limit''4G');
  2381.             $start microtime(true);
  2382.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  2383.             $em $this->servizi->doctrine->getManager();
  2384.             $user $this->servizi->OttieniUtenteCorrente();
  2385.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  2386.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  2387.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  2388.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  2389.             $repoArticoli $this->servizi->doctrine->getRepository(Articoli::class);
  2390.             $repoClienti $this->servizi->doctrine->getRepository(User::class);
  2391.             $repoAnagrafica $this->servizi->doctrine->getRepository(Anagrafiche::class);
  2392.             $repoCategoria $this->servizi->doctrine->getRepository(Categorie::class);
  2393.             $repoVarianti $this->servizi->doctrine->getRepository(Varianti::class);
  2394.             $repoAssociazione $this->servizi->doctrine->getRepository(AssociazioneArticoliCliente::class);
  2395.             $errori "";
  2396.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaAssociazioniArticoliClienti/' $svuota ' --- Inizio l\' importazione delle associazione articoli clienti'null$collegamentoRnd'ImportazioneController''caricaAssociazioniArticoliClienti');
  2397.             if($svuota == "1"){
  2398.                 $connection $this->servizi->doctrine->getConnection();
  2399.                 $connection->beginTransaction();
  2400.                 try {
  2401.                     $connection->query("SET FOREIGN_KEY_CHECKS=0;");
  2402.                     $connection->executeUpdate("TRUNCATE `associazione_articoli_cliente`;");
  2403.                     $connection->query("SET FOREIGN_KEY_CHECKS=1;");
  2404.                     $connection->commit();
  2405.                 }catch (\Exception|\Throwable $ex){
  2406.                     $this->servizi->DebuggaException($ex"Errore pulizia associazione articoli cliente DB"falsenull$collegamentoRnd'ImportazioneController''caricaAssociazioniArticoliClienti' );
  2407.                 }
  2408.             }
  2409.             $root_path $pathFileBase "associazione_articoli_clienti.csv";
  2410.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  2411.             $contatore 0;
  2412.             $query_eseguite 0;
  2413.             $row 0;
  2414.             $batch_size 50;
  2415.             /*
  2416.              * Index    Campo
  2417.                 0    codice_cliente
  2418.                 1    codice_articolo
  2419.                 2    codice_cat1
  2420.                 3    codice_cat2
  2421.                 4    codice_cat3
  2422.                 5    codice_cat4
  2423.                 6    codice_cat5
  2424.                 7    marca
  2425.                 8    codice_variante
  2426.                 9    ass_codice
  2427.                 10    ass_nome
  2428.                 11    ass_descrizione
  2429.                 12    ass_marca
  2430.                 13    ass_immagine_dimensione_1
  2431.                 14    ass_codice_dimensione_1
  2432.                 15    ass_descrizione_dimensione_1
  2433.                 16    ass_immagine_dimensione_2
  2434.                 17    ass_codice_dimensione_2
  2435.                 18    ass_descrizione_dimensione_2
  2436.                 19    ass_immagine_dimensione_3
  2437.                 20    ass_codice_dimensione_3
  2438.                 21    ass_descrizione_dimensione_3
  2439.                 22    ass_immagine_dimensione_4
  2440.                 23    ass_codice_dimensione_4
  2441.                 24    ass_descrizione_dimensione_4
  2442.                 25    ass_immagine_dimensione_5
  2443.                 26    ass_codice_dimensione_5
  2444.                 27    ass_descrizione_dimensione_5
  2445.                 28  operazione
  2446.              */
  2447.             $indici = array(
  2448.                 "codiceCliente" => 0,
  2449.                 "codiceArticolo" => 1,
  2450.                 "cat1" => 2,
  2451.                 "cat2" => 3,
  2452.                 "cat3" => 4,
  2453.                 "cat4" => 5,
  2454.                 "cat5" => 6,
  2455.                 "marca" => 7,
  2456.                 'codiceVariante' => 8,
  2457.                 'assCodice' => 9,
  2458.                 'assNome' => 10,
  2459.                 'assDescrizione' => 11,
  2460.                 'assMarca' => 12,
  2461.                 'assImmagineDimensione1' => 13,
  2462.                 'assCodiceDimensione1' => 14,
  2463.                 'assDescrizioneDimensione1' => 15,
  2464.                 'assImmagineDimensione2' => 16,
  2465.                 'assCodiceDimensione2' => 17,
  2466.                 'assDescrizioneDimensione2' => 18,
  2467.                 'assImmagineDimensione3' => 19,
  2468.                 'assCodiceDimensione3' => 20,
  2469.                 'assDescrizioneDimensione3' => 21,
  2470.                 'assImmagineDimensione4' => 22,
  2471.                 'assCodiceDimensione4' => 23,
  2472.                 'assDescrizioneDimensione4' => 24,
  2473.                 'assImmagineDimensione5' => 25,
  2474.                 'assCodiceDimensione5' => 26,
  2475.                 'assDescrizioneDimensione5' => 27,
  2476.                 'operazione' => 28
  2477.             );
  2478.             try {
  2479.                 if (($handle fopen($root_path"r")) !== false) {
  2480.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  2481.                         if ($row == 0) {
  2482.                             $row 1;
  2483.                             continue;
  2484.                         }
  2485.                         if ($query_eseguite >= $batch_size) {
  2486.                             $contatore $contatore $row 1;
  2487.                             $row 1;
  2488.                             $query_eseguite 0;
  2489.                             $em->flush();
  2490.                             $em->clear();
  2491.                         }
  2492.                         $cliente $repoClienti->findOneBy(array('codiceCliente' => $data[$indici['codiceCliente']]));
  2493.                         $anagrafica $repoAnagrafica->findOneBy(array('codice' => $data[$indici['codiceCliente']]));
  2494.                         $articolo null;
  2495.                         if ($data[$indici['codiceArticolo']] != '') {
  2496.                             $articolo $repoArticoli->findOneBy(array('codice' => $data[$indici['codiceArticolo']]));
  2497.                         }
  2498.                         if ($articolo) {
  2499.                             $cat1 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat1']]));
  2500.                             $cat2 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat2']]));
  2501.                             $cat3 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat3']]));
  2502.                             $cat4 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat4']]));
  2503.                             $cat5 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat5']]));
  2504.                             $mappa $this->servizi->ritornaMappaCategoriaArticoliSeInserita($articolo$cat1$cat2$cat3$cat4$data[$indici['marca']], $cat5);
  2505.                             $variante $repoVarianti->findOneBy(array('mappa' => $mappa'codiceVariante' => $data[$indici['codiceVariante']]));
  2506.                             $qb $repoAssociazione->createQueryBuilder('ass')
  2507.                                 ->where('ass.mappaCategoriaArticoli = :mappa OR ass.articolo = :art')
  2508.                                 ->setParameter('mappa'$mappa)->setParameter('art'$articolo);
  2509.                             if ($variante) {
  2510.                                 $qb $qb->andWhere('ass.variante = :variante')->setParameter('variante'$variante);
  2511.                             } else {
  2512.                                 $qb $qb->andWhere('ass.variante IS NULL');
  2513.                             }
  2514.                             if ($cliente) {
  2515.                                 $qb $qb->andWhere('ass.cliente = :cliente')->setParameter('cliente'$cliente);
  2516.                             } else {
  2517.                                 $qb $qb->andWhere('ass.cliente IS NULL');
  2518.                             }
  2519.                             if ($anagrafica) {
  2520.                                 $qb $qb->andWhere('ass.anagrafica = :anagrafica')->setParameter('anagrafica'$anagrafica);
  2521.                             } else {
  2522.                                 $qb $qb->andWhere('ass.anagrafica IS NULL');
  2523.                             }
  2524.                             if($data[$indici['codiceArticolo']] != ''){
  2525.                                 $qb $qb->andWhere('ass.codiceArticoloOriginale = :codOr')->setParameter('codOr'$data[$indici['codiceArticolo']]);
  2526.                             }else{
  2527.                                 $qb $qb->andWhere("ass.codiceArticoloOriginale IS NULL OR ass.codiceArticoloOriginale = ''");
  2528.                             }
  2529.                             if($data[$indici['codiceCliente']] != ''){
  2530.                                 $qb $qb->andWhere('ass.codiceAnagrafica = :codAna')->setParameter('codAna'$data[$indici['codiceCliente']]);
  2531.                             }else{
  2532.                                 $qb $qb->andWhere("ass.codiceAnagrafica IS NULL OR ass.codiceAnagrafica = ''");
  2533.                             }
  2534.                             $ritorno $qb->setMaxResults(1)->getQuery()->getResult();
  2535.                             $associazioneArticoloCliente null;
  2536.                             if (count($ritorno) > 0) {
  2537.                                 $associazioneArticoloCliente $ritorno[0];
  2538.                             }
  2539.                             if ($data[$indici['operazione']] == 'E') {
  2540.                                 if ($associazioneArticoloCliente != null) {
  2541.                                     $em->remove($associazioneArticoloCliente);
  2542.                                     $query_eseguite++;
  2543.                                 }
  2544.                             } else {
  2545.                                 if ($associazioneArticoloCliente == null) {
  2546.                                     $associazioneArticoloCliente = new AssociazioneArticoliCliente();
  2547.                                     $associazioneArticoloCliente->setMappaCategoriaArticoli($mappa);
  2548.                                     $associazioneArticoloCliente->setArticolo($articolo);
  2549.                                     $associazioneArticoloCliente->setVariante($variante);
  2550.                                     $associazioneArticoloCliente->setCliente($cliente);
  2551.                                     $associazioneArticoloCliente->setAnagrafica($anagrafica);
  2552.                                     $associazioneArticoloCliente->setCodiceAnagrafica($data[$indici['codiceCliente']]);
  2553.                                     $associazioneArticoloCliente->setCodiceArticoloOriginale($data[$indici['codiceArticolo']]);
  2554.                                     $associazioneArticoloCliente->setDataCreazione(new \DateTime());
  2555.                                     $associazioneArticoloCliente->setMarca($data[$indici['marca']]);
  2556.                                 }
  2557.                                 $associazioneArticoloCliente->setNome($data[$indici['assNome']]);
  2558.                                 $associazioneArticoloCliente->setCodice($data[$indici['assCodice']]);
  2559.                                 $associazioneArticoloCliente->setMarca($data[$indici['assMarca']]);
  2560.                                 $associazioneArticoloCliente->setDescrizione($data[$indici['assDescrizione']]);
  2561.                                 $associazioneArticoloCliente->setImmagineDimensione1($data[$indici['assImmagineDimensione1']]);
  2562.                                 $associazioneArticoloCliente->setCodiceDimensione1($data[$indici['assCodiceDimensione1']]);
  2563.                                 $associazioneArticoloCliente->setDescrizioneDimensione1($data[$indici['assDescrizioneDimensione1']]);
  2564.                                 $associazioneArticoloCliente->setImmagineDimensione2($data[$indici['assImmagineDimensione2']]);
  2565.                                 $associazioneArticoloCliente->setCodiceDimensione2($data[$indici['assCodiceDimensione2']]);
  2566.                                 $associazioneArticoloCliente->setDescrizioneDimensione2($data[$indici['assDescrizioneDimensione2']]);
  2567.                                 $associazioneArticoloCliente->setImmagineDimensione3($data[$indici['assImmagineDimensione3']]);
  2568.                                 $associazioneArticoloCliente->setCodiceDimensione3($data[$indici['assCodiceDimensione3']]);
  2569.                                 $associazioneArticoloCliente->setDescrizioneDimensione3($data[$indici['assDescrizioneDimensione3']]);
  2570.                                 $associazioneArticoloCliente->setImmagineDimensione4($data[$indici['assImmagineDimensione4']]);
  2571.                                 $associazioneArticoloCliente->setCodiceDimensione4($data[$indici['assCodiceDimensione4']]);
  2572.                                 $associazioneArticoloCliente->setDescrizioneDimensione4($data[$indici['assDescrizioneDimensione4']]);
  2573.                                 $associazioneArticoloCliente->setImmagineDimensione5($data[$indici['assImmagineDimensione5']]);
  2574.                                 $associazioneArticoloCliente->setCodiceDimensione5($data[$indici['assCodiceDimensione5']]);
  2575.                                 $associazioneArticoloCliente->setDescrizioneDimensione5($data[$indici['assDescrizioneDimensione5']]);
  2576.                                 $associazioneArticoloCliente->setDataModifica(new \DateTime());
  2577.                                 $em->persist($associazioneArticoloCliente);
  2578.                                 $query_eseguite++;
  2579.                             }
  2580.                         } else {
  2581.                             $errori .= ("RIGA: " . ($contatore $row) . ' -- Articolo con codice ' $data[$indici['codiceArticolo']] . ' non trovato!\n');
  2582.                         }
  2583.                         $row++;
  2584.                     }
  2585.                     $em->flush();
  2586.                     $em->clear();
  2587.                 }else{
  2588.                     $errori .= "Impossibile aprire il file!";
  2589.                 }
  2590.                 $row $contatore $row;
  2591.                 if ($errori == "") {
  2592.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaAssociazioniArticoliClienti');
  2593.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  2594.                 } else {
  2595.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaAssociazioniArticoliClienti');
  2596.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  2597.                 }
  2598.             } catch (\Exception|\Throwable $ex) {
  2599.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAssociazioniArticoliClienti');
  2600.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  2601.             }
  2602.         }else {
  2603.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaAssociazioniArticoliClienti');
  2604.             return new Response("ERRORE PERMESSO");
  2605.         }
  2606.     }
  2607.     /**
  2608.      * @Route("/caricaDisponibilita", name="carica_disponibilita")
  2609.      */
  2610.     public function caricaDisponibilita(Request $request)
  2611.     {
  2612.         $collegamentoRnd $this->servizi->randomString2();
  2613.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  2614.             ini_set('max_execution_time'7200);
  2615.             ini_set('memory_limit''4G');
  2616.             $start microtime(true);
  2617.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  2618.             $em $this->servizi->doctrine->getManager();
  2619.             $user $this->servizi->OttieniUtenteCorrente();
  2620.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  2621.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  2622.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  2623.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  2624.             $repoArticoli $this->servizi->doctrine->getRepository(Articoli::class);
  2625.             $repoCategoria $this->servizi->doctrine->getRepository(Categorie::class);
  2626.             $repoVarianti $this->servizi->doctrine->getRepository(Varianti::class);
  2627.             $errori "";
  2628.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaDisponibilita --- Inizio l\' importazione delle disponibilita articoli'null$collegamentoRnd'ImportazioneController''caricaDisponibilita');
  2629.             $root_path $pathFileBase "disponibilita.csv";
  2630.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  2631.             $contatore 0;
  2632.             $query_eseguite 0;
  2633.             $row 0;
  2634.             $batch_size 50;
  2635.             /*
  2636.              * Index    Campo
  2637.                 0    codice_articolo
  2638.                 1    codice_cat1
  2639.                 2    codice_cat2
  2640.                 3    codice_cat3
  2641.                 4    codice_cat4
  2642.                 5    codice_cat5
  2643.                 6    marca
  2644.                 7    codice_variante
  2645.                 8    disponibilita
  2646.                 9    ordini_fornitori
  2647.                 10    operazione
  2648.              */
  2649.             $indici = array(
  2650.                 "codiceArticolo" => 0,
  2651.                 "cat1" => 1,
  2652.                 "cat2" => 2,
  2653.                 "cat3" => 3,
  2654.                 "cat4" => 4,
  2655.                 "cat5" => 5,
  2656.                 "marca" => 6,
  2657.                 "codiceVariante" => 7,
  2658.                 'disponibilita' => 8,
  2659.                 'ordiniFornitori' => 9,
  2660.                 'operazione' => 10
  2661.             );
  2662.             try {
  2663.                 if (($handle fopen($root_path"r")) !== false) {
  2664.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  2665.                         if ($row == 0) {
  2666.                             $row 1;
  2667.                             continue;
  2668.                         }
  2669.                         if ($query_eseguite >= $batch_size) {
  2670.                             $contatore $contatore $row 1;
  2671.                             $row 1;
  2672.                             $query_eseguite 0;
  2673.                             $em->flush();
  2674.                             $em->clear();
  2675.                         }
  2676.                         $articolo null;
  2677.                         if ($data[$indici['codiceArticolo']] != '') {
  2678.                             $articolo $repoArticoli->findOneBy(array('codice' => $data[$indici['codiceArticolo']]));
  2679.                         }
  2680.                         if ($articolo) {
  2681.                             $cat1 null$cat2 null$cat3 null$cat4 null$cat5 null;
  2682.                             if($data[$indici['cat1']] != '')
  2683.                                 $cat1 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat1']]));
  2684.                             if($data[$indici['cat2']] != '')
  2685.                                 $cat2 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat2']]));
  2686.                             if($data[$indici['cat3']] != '')
  2687.                                 $cat3 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat3']]));
  2688.                             if($data[$indici['cat4']] != '')
  2689.                                 $cat4 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat4']]));
  2690.                             if($data[$indici['cat5']] != '')
  2691.                                 $cat5 $repoCategoria->findOneBy(array('codice' => $data[$indici['cat5']]));
  2692.                             $mappa $this->servizi->ritornaMappaCategoriaArticoliSeInserita($articolo$cat1$cat2$cat3$cat4$data[$indici['marca']], $cat5);
  2693.                             $variante null;
  2694.                             if($data[$indici['codiceVariante']] != '')
  2695.                                 $variante $repoVarianti->findOneBy(array('mappa' => $mappa'codiceVariante' => $data[$indici['codiceVariante']]));
  2696.                             if($mappa){
  2697.                                 $mappa->setDisponibile(str_replace(',''.'$data[$indici['disponibilita']]));
  2698.                                 $mappa->setOrdiniFornitori(str_replace(',''.'$data[$indici['ordiniFornitori']]));
  2699.                                 $em->persist($mappa);
  2700.                                 $query_eseguite++;
  2701.                             }else{
  2702.                                 $errori .= ("RIGA: " . ($contatore $row) . ' -- Mappa con codice articolo: ' $data[$indici['codiceArticolo']] . ' non trovato!\n');
  2703.                             }
  2704.                         } else {
  2705.                             $errori .= ("RIGA: " . ($contatore $row) . ' -- Articolo con codice ' $data[$indici['codiceArticolo']] . ' non trovato!\n');
  2706.                         }
  2707.                         $row++;
  2708.                     }
  2709.                     $em->flush();
  2710.                     $em->clear();
  2711.                 }else{
  2712.                     $errori .= "Impossibile aprire il file!";
  2713.                 }
  2714.                 $row $contatore $row;
  2715.                 if ($errori == "") {
  2716.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaDisponibilita');
  2717.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  2718.                 } else {
  2719.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaDisponibilita');
  2720.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  2721.                 }
  2722.             } catch (\Exception|\Throwable $ex) {
  2723.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaDisponibilita');
  2724.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  2725.             }
  2726.         }else {
  2727.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaDisponibilita');
  2728.             return new Response("ERRORE PERMESSO");
  2729.         }
  2730.     }
  2731.     /**
  2732.      * @Route("/caricaRisorseAnagrafiche/{svuota}", name="carica_risorse_anagrafiche", defaults={"svuota"="0"})
  2733.      */
  2734.     public function caricaRisorseAnagrafiche(Request $request$svuota)
  2735.     {
  2736.         $collegamentoRnd $this->servizi->randomString2();
  2737.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  2738.             ini_set('max_execution_time'900);
  2739.             ini_set('memory_limit''4G');
  2740.             $start microtime(true);
  2741.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  2742.             $em $this->servizi->doctrine->getManager();
  2743.             $user $this->servizi->OttieniUtenteCorrente();
  2744.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  2745.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  2746.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  2747.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  2748.             $repoRisorse $this->servizi->doctrine->getRepository(RisorseAnagrafiche::class);
  2749.             $errori "";
  2750.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaRisorseAnagrafiche/' $svuota ' --- Inizio l\' importazione delle scontistiche delle anagrafiche'null$collegamentoRnd'ImportazioneController''caricaRisorseAnagrafiche');
  2751.             if($svuota == '1'){
  2752.                 $this->servizi->doctrine->getConnection()->executeQuery('TRUNCATE TABLE risorse_anagrafiche;');
  2753.                 $this->servizi->doctrine->getConnection()->executeQuery('TRUNCATE TABLE risorse_anagrafiche_colonne;');
  2754.                 $this->servizi->doctrine->getConnection()->executeQuery('TRUNCATE TABLE risorse_anagrafiche_colonne_valori;');
  2755.             }
  2756.             $root_path $pathFileBase "risorse_anagrafiche.csv";
  2757.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  2758.             $contatore 0;
  2759.             $query_eseguite 0;
  2760.             $row 0;
  2761.             $batch_size 50;
  2762.             /*
  2763.              * Index    Campo
  2764.                 0    codice_anagrafica
  2765.                 1    tipo_risorsa
  2766.                 2    path_file
  2767.                 3    nome_file
  2768.                 4    identificativo_unico_risorsa
  2769.                 5    categoria
  2770.                 6    operazione
  2771.                 7   visibile a cliente
  2772.                 8   dataRisorsa
  2773.                 9    codice_categoria1
  2774.                 10    codice_categoria2
  2775.                 11    codice_categoria3
  2776.                 12    codice_categoria4
  2777.                 13    codice_categoria5
  2778.                 14    codice_articolo
  2779.                 15    marca
  2780.                 16    codice_dimensione1
  2781.                 17    codice_dimensione2
  2782.                 18    codice_dimensione3
  2783.                 19    codice_dimensione4
  2784.                 20    codice_dimensione5
  2785.                 21 chiave ricerca esterno
  2786.                 22  recupera_con_webservice
  2787.              */
  2788.             $indici = array(
  2789.                 "codiceAnagrafica" => 0,
  2790.                 "tipoRisorsa" => 1,
  2791.                 "pathFile" => 2,
  2792.                 "nomeFile" => 3,
  2793.                 "identificativoUnicoRisorsa" => 4,
  2794.                 "categoria" => 5,
  2795.                 "operazione" => 6,
  2796.                 "visibileACliente" => 7,
  2797.                 'dataRisorsa' => 8,
  2798.                 'codiceCategoria1' => 9,
  2799.                 'codiceCategoria2' => 10,
  2800.                 'codiceCategoria3' => 11,
  2801.                 'codiceCategoria4' => 12,
  2802.                 'codiceCategoria5' => 13,
  2803.                 'codiceArticolo' => 14,
  2804.                 'marca' => 15,
  2805.                 'codiceDimensione1' => 16,
  2806.                 'codiceDimensione2' => 17,
  2807.                 'codiceDimensione3' => 18,
  2808.                 'codiceDimensione4' => 19,
  2809.                 'codiceDimensione5' => 20,
  2810.                 'chiaveRicercaEsterna' => 21,
  2811.                 'recuperaConWebservice' => 22
  2812.             );
  2813.             $tipiRisorsaAutorizzati $this->servizi->RitornaArrayTipoRisorsa();
  2814.             $tt = array();
  2815.             foreach ($tipiRisorsaAutorizzati as $key) {
  2816.                 array_push($tt$key);
  2817.             }
  2818.             $tipiRisorsaAutorizzati $tt;
  2819.             try {
  2820.                 if (($handle fopen($root_path"r")) !== false) {
  2821.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  2822.                         if ($row == 0) {
  2823.                             $row 1;
  2824.                             continue;
  2825.                         }
  2826.                         if ($query_eseguite >= $batch_size) {
  2827.                             $contatore $contatore $row 1;
  2828.                             $row 1;
  2829.                             $query_eseguite 0;
  2830.                             $em->flush();
  2831.                             $em->clear();
  2832.                         }
  2833.                         if(in_array($data[$indici['tipoRisorsa']], $tipiRisorsaAutorizzati)) {
  2834.                             $risorsa $repoRisorse->findOneBy(array('identificativoUnico' => $data[$indici['identificativoUnicoRisorsa']]));
  2835.                             if($data[$indici['operazione']] == 'E'){
  2836.                                 if($risorsa){
  2837.                                     $em->remove($risorsa);
  2838.                                     $query_eseguite++;
  2839.                                 }
  2840.                             }else {
  2841.                                 if (!$risorsa) {
  2842.                                     $risorsa = new RisorseAnagrafiche();
  2843.                                     $risorsa->setDataModifica(new \DateTime());
  2844.                                     $risorsa->setDataCreazione(new \DateTime());
  2845.                                     $risorsa->setCodiceAnagrafica($data[$indici['codiceAnagrafica']]);
  2846.                                     $risorsa->setCategoria($data[$indici['categoria']]);
  2847.                                     $risorsa->setIdentificativoUnico($data[$indici['identificativoUnicoRisorsa']]);
  2848.                                     $risorsa->setNomeFile($data[$indici['nomeFile']]);
  2849.                                     $risorsa->setPathFile($data[$indici["pathFile"]]);
  2850.                                     $risorsa->setTipoRisorsa($data[$indici['tipoRisorsa']]);
  2851.                                     if(count($data) >= 8)
  2852.                                         $risorsa->setVisibileAlCliente($data[$indici["visibileACliente"]]);
  2853.                                     if(count($data) >= 9){
  2854.                                         $valore $data[$indici['dataRisorsa']];
  2855.                                         if($valore != '' ){
  2856.                                             $format 'Ymd';
  2857.                                             if(strpos($valore'-') !== false)
  2858.                                                 $format 'Y-m-d';
  2859.                                             $risorsa->setDataRisorsa(\DateTime::createFromFormat($format$valore));
  2860.                                         }
  2861.                                     }
  2862.                                     if(count($data) >= 10){
  2863.                                         $risorsa->setCodiceCategoria1($data[$indici['codiceCategoria1']]);
  2864.                                         $risorsa->setCodiceCategoria2($data[$indici['codiceCategoria2']]);
  2865.                                         $risorsa->setCodiceCategoria3($data[$indici['codiceCategoria3']]);
  2866.                                         $risorsa->setCodiceCategoria4($data[$indici['codiceCategoria4']]);
  2867.                                         $risorsa->setCodiceCategoria5($data[$indici['codiceCategoria5']]);
  2868.                                         $risorsa->setCodiceArticolo($data[$indici['codiceArticolo']]);
  2869.                                         $risorsa->setMarca($data[$indici['marca']]);
  2870.                                         $risorsa->setCodiceDimensione1($data[$indici['codiceDimensione1']]);
  2871.                                         $risorsa->setCodiceDimensione2($data[$indici['codiceDimensione2']]);
  2872.                                         $risorsa->setCodiceDimensione3($data[$indici['codiceDimensione3']]);
  2873.                                         $risorsa->setCodiceDimensione4($data[$indici['codiceDimensione4']]);
  2874.                                         $risorsa->setCodiceDimensione5($data[$indici['codiceDimensione5']]);
  2875.                                     }
  2876.                                     if (count($data) > $indici['chiaveRicercaEsterna']){
  2877.                                         $risorsa->setChiaveRicercaEsterno($data[$indici['chiaveRicercaEsterna']]);
  2878.                                     }
  2879.                                     if (count($data) > $indici['recuperaConWebservice']){
  2880.                                         $risorsa->setRecuperaConWebservice(self::verificaBool($data[$indici['recuperaConWebservice']]));
  2881.                                     }
  2882.                                     $em->persist($risorsa);
  2883.                                     $query_eseguite++;
  2884.                                 } else {
  2885.                                     $risorsa->setDataModifica(new \DateTime());
  2886.                                     $risorsa->setCodiceAnagrafica($data[$indici['codiceAnagrafica']]);
  2887.                                     $risorsa->setCategoria($data[$indici['categoria']]);
  2888.                                     $risorsa->setNomeFile($data[$indici['nomeFile']]);
  2889.                                     $risorsa->setPathFile($data[$indici["pathFile"]]);
  2890.                                     $risorsa->setTipoRisorsa($data[$indici['tipoRisorsa']]);
  2891.                                     if(count($data) > 8)
  2892.                                         $risorsa->setVisibileAlCliente($data[$indici["visibileACliente"]]);
  2893.                                     if(count($data) >= 9){
  2894.                                         $valore $data[$indici['dataRisorsa']];
  2895.                                         if($valore != '' ){
  2896.                                             $format 'Ymd';
  2897.                                             if(strpos($valore'-') !== false)
  2898.                                                 $format 'Y-m-d';
  2899.                                             $risorsa->setDataRisorsa(\DateTime::createFromFormat($format$valore));
  2900.                                         }
  2901.                                     }
  2902.                                     if(count($data) >= 10){
  2903.                                         $risorsa->setCodiceCategoria1($data[$indici['codiceCategoria1']]);
  2904.                                         $risorsa->setCodiceCategoria2($data[$indici['codiceCategoria2']]);
  2905.                                         $risorsa->setCodiceCategoria3($data[$indici['codiceCategoria3']]);
  2906.                                         $risorsa->setCodiceCategoria4($data[$indici['codiceCategoria4']]);
  2907.                                         $risorsa->setCodiceCategoria5($data[$indici['codiceCategoria5']]);
  2908.                                         $risorsa->setCodiceArticolo($data[$indici['codiceArticolo']]);
  2909.                                         $risorsa->setMarca($data[$indici['marca']]);
  2910.                                         $risorsa->setCodiceDimensione1($data[$indici['codiceDimensione1']]);
  2911.                                         $risorsa->setCodiceDimensione2($data[$indici['codiceDimensione2']]);
  2912.                                         $risorsa->setCodiceDimensione3($data[$indici['codiceDimensione3']]);
  2913.                                         $risorsa->setCodiceDimensione4($data[$indici['codiceDimensione4']]);
  2914.                                         $risorsa->setCodiceDimensione5($data[$indici['codiceDimensione5']]);
  2915.                                     }
  2916.                                     if (count($data) > $indici['chiaveRicercaEsterna']){
  2917.                                         $risorsa->setChiaveRicercaEsterno($data[$indici['chiaveRicercaEsterna']]);
  2918.                                     }
  2919.                                     if (count($data) > $indici['recuperaConWebservice']){
  2920.                                         $risorsa->setRecuperaConWebservice(self::verificaBool($data[$indici['recuperaConWebservice']]));
  2921.                                     }
  2922.                                     $em->persist($risorsa);
  2923.                                     $query_eseguite++;
  2924.                                 }
  2925.                             }
  2926.                         }else{
  2927.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Tipo risorsa: ' $data[$indici['tipoRisorsa']] . ' non riconosciuto!'$user$collegamentoRnd'ImportazioneController''caricaRisorseAnagrafiche');
  2928.                         }
  2929.                         $row++;
  2930.                     }
  2931.                     $em->flush();
  2932.                     $em->clear();
  2933.                 }else{
  2934.                     $errori .= "Impossibile aprire il file!";
  2935.                 }
  2936.                 $row $contatore $row;
  2937.                 if ($errori == "") {
  2938.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaRisorseAnagrafiche');
  2939.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  2940.                 } else {
  2941.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaRisorseAnagrafiche');
  2942.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  2943.                 }
  2944.             } catch (\Exception|\Throwable $ex) {
  2945.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaRisorseAnagrafiche');
  2946.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  2947.             }
  2948.         } else {
  2949.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaRisorseAnagrafiche');
  2950.             return new Response("ERRORE PERMESSO");
  2951.         }
  2952.     } //OK
  2953.     /**
  2954.      * @Route("/caricaReport/{svuota}", name="carica_report", defaults={"svuota"="0"})
  2955.      */
  2956.     public function caricaReport(Request $request$svuota)
  2957.     {
  2958.         $collegamentoRnd $this->servizi->randomString2();
  2959.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  2960.             ini_set('max_execution_time'900);
  2961.             ini_set('memory_limit''4G');
  2962.             $start microtime(true);
  2963.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  2964.             $em $this->servizi->doctrine->getManager();
  2965.             $user $this->servizi->OttieniUtenteCorrente();
  2966.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  2967.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  2968.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  2969.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  2970.             $repo $this->servizi->doctrine->getRepository(Report::class);
  2971.             $errori "";
  2972.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaReport/' $svuota ' --- Inizio l\' importazione dei report'null$collegamentoRnd'ImportazioneController''caricaReport');
  2973.             if($svuota == '1'){
  2974.                 $this->servizi->doctrine->getConnection()->executeQuery('TRUNCATE TABLE report;');
  2975.             }
  2976.             $root_path $pathFileBase "report.csv";
  2977.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  2978.             $contatore 0;
  2979.             $query_eseguite 0;
  2980.             $row 0;
  2981.             $batch_size 50;
  2982.             /*
  2983.              * 0    identificativo_univoco
  2984.                 1    titolo
  2985.                 2    sottotitolo
  2986.                 3    agente
  2987.                 4    categoria
  2988.                 5    codice_cliente
  2989.                 6    chiave_ricerca_esterno
  2990.                 7    recupera_con_webservice
  2991.                 8    livello_permesso
  2992.                 9    raw_html_contenuto
  2993.                 10    path_file_recupero_webservice_custom
  2994.                 11    operazione
  2995.                 12    raw_html_header
  2996.              */
  2997.             $indici = array(
  2998.                 "identificativoUnivoco" => 0,
  2999.                 "titolo" => 1,
  3000.                 "sottotitolo" => 2,
  3001.                 "agente" => 3,
  3002.                 "categoria" => 4,
  3003.                 "codiceCliente" => 5,
  3004.                 "chiaveRicercaEsterno" => 6,
  3005.                 "recuperaConWebservice" => 7,
  3006.                 'livelloPermesso' => 8,
  3007.                 'rawHtmlContenuto' => 9,
  3008.                 'pathFileRecuperoWebserviceCustom' => 10,
  3009.                 'operazione' => 11,
  3010.                 'rawHtmlHeader' => 12
  3011.             );
  3012.             try {
  3013.                 if (($handle fopen($root_path"r")) !== false) {
  3014.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  3015.                         if ($row == 0) {
  3016.                             $row 1;
  3017.                             continue;
  3018.                         }
  3019.                         if ($query_eseguite >= $batch_size) {
  3020.                             $contatore $contatore $row 1;
  3021.                             $row 1;
  3022.                             $query_eseguite 0;
  3023.                             $em->flush();
  3024.                             $em->clear();
  3025.                         }
  3026.                         $report $repo->findOneBy(array('identificativoUnico' => $data[$indici['identificativoUnivoco']]));
  3027.                         if ($data[$indici['operazione']] == 'E') {
  3028.                             if ($report) {
  3029.                                 $em->remove($report);
  3030.                                 $query_eseguite++;
  3031.                             }
  3032.                         } else {
  3033.                             if (!$report) {
  3034.                                 $report = new Report();
  3035.                                 $report->setDataCreazione(new \DateTime());
  3036.                                 $report->setIdentificativoUnico($data[$indici['identificativoUnivoco']]);
  3037.                                 $report->setAttivo(true);
  3038.                             }
  3039.                             $report->setTitolo($data[$indici['titolo']]);
  3040.                             $report->setSottoTitolo($data[$indici['sottotitolo']]);
  3041.                             $report->setAgente($data[$indici['agente']]);
  3042.                             $report->setCategoria($data[$indici['categoria']]);
  3043.                             $report->setCodiceCliente($data[$indici['codiceCliente']]);
  3044.                             $report->setChiaveRicercaEsterno($data[$indici['chiaveRicercaEsterno']]);
  3045.                             $report->setLivelloPermesso($data[$indici['livelloPermesso']]);
  3046.                             $report->setRecuperaConWebservice(self::verificaBool($data[$indici['recuperaConWebservice']]));
  3047.                             $report->setRawHtmlContenuto($data[$indici['rawHtmlContenuto']]);
  3048.                             $report->setPathFileRecuperoWebserviceCustom($data[$indici['pathFileRecuperoWebserviceCustom']]);
  3049.                             $report->setRawHtmlHeader($data[$indici['rawHtmlHeader']]);
  3050.                             $em->persist($report);
  3051.                             $query_eseguite++;
  3052.                         }
  3053.                         $row++;
  3054.                     }
  3055.                     $em->flush();
  3056.                     $em->clear();
  3057.                 }else{
  3058.                     $errori .= "Impossibile aprire il file!";
  3059.                 }
  3060.                 $row $contatore $row;
  3061.                 if ($errori == "") {
  3062.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaReport');
  3063.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  3064.                 } else {
  3065.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaReport');
  3066.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  3067.                 }
  3068.             } catch (\Exception|\Throwable $ex) {
  3069.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaReport');
  3070.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  3071.             }
  3072.         } else {
  3073.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaReport');
  3074.             return new Response("ERRORE PERMESSO");
  3075.         }
  3076.     } //OK
  3077.     /**
  3078.      * @Route("/caricaDisponibilitaPerFascia/{svuota}", name="carica_disponibilita_per_fascia", defaults={"svuota"="0"})
  3079.      */
  3080.     public function caricaDisponibilitaPerFascia(Request $request$svuota)
  3081.     {
  3082.         $collegamentoRnd $this->servizi->randomString2();
  3083.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  3084.             ini_set('max_execution_time'900);
  3085.             ini_set('memory_limit''4G');
  3086.             $start microtime(true);
  3087.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  3088.             $em $this->servizi->doctrine->getManager();
  3089.             $user $this->servizi->OttieniUtenteCorrente();
  3090.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  3091.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  3092.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  3093.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  3094.             $repoMappa $this->servizi->doctrine->getRepository(MappaCategorieArticoli::class);
  3095.             $repoArticoli $this->servizi->doctrine->getRepository(Articoli::class);
  3096.             $repo $this->servizi->doctrine->getRepository(DisponibilitaAFasce::class);
  3097.             $repoVariante $this->servizi->doctrine->getRepository(Varianti::class);
  3098.             $errori "";
  3099.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaDisponibilitaPerFascia/' $svuota ' --- Inizio l\' importazione delle disponibilità per fasce'null$collegamentoRnd'ImportazioneController''caricaDisponibilitaPerFascia');
  3100.             if($svuota == '1'){
  3101.                 $this->servizi->doctrine->getConnection()->executeQuery('TRUNCATE TABLE disponibilita_afasce;');
  3102.             }
  3103.             $root_path $pathFileBase "disponibilita_per_fascia.csv";
  3104.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  3105.             $contatore 0;
  3106.             $query_eseguite 0;
  3107.             $row 0;
  3108.             $batch_size 50;
  3109.             /*
  3110.                 0    codice articolo
  3111.                 1    codice categoria 1
  3112.                 2    codice categoria 2
  3113.                 3    codice categoria 3
  3114.                 4    codice categoria 4
  3115.                 5    codice categoria 5
  3116.                 6    marca
  3117.                 7    disponibilita
  3118.                 8    etichetta
  3119.                 9    operazione
  3120.                 10    principale
  3121.                 11    codice_variante
  3122.              */
  3123.             $indici = array(
  3124.                 "codiceArticolo" => 0,
  3125.                 "categoria1" => 1,
  3126.                 "categoria2" => 2,
  3127.                 "categoria3" => 3,
  3128.                 "categoria4" => 4,
  3129.                 "categoria5" => 5,
  3130.                 "marca" => 6,
  3131.                 "disponiblita" => 7,
  3132.                 'etichetta' => 8,
  3133.                 'operazione' => 9,
  3134.                 'principale' => 10,
  3135.                 'codice_variante' => 11
  3136.             );
  3137.             try {
  3138.                 if (($handle fopen($root_path"r")) !== false) {
  3139.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  3140.                         if ($row == 0) {
  3141.                             $row 1;
  3142.                             continue;
  3143.                         }
  3144.                         if ($query_eseguite >= $batch_size) {
  3145.                             $contatore $contatore $row 1;
  3146.                             $row 1;
  3147.                             $query_eseguite 0;
  3148.                             $em->flush();
  3149.                             $em->clear();
  3150.                         }
  3151.                         $articolo $repoArticoli->findOneBy(array('codice' => $data[$indici['codiceArticolo']]));
  3152.                         if($articolo){
  3153.                             $qbMappa $repoMappa->createQueryBuilder('mappa_categorie_articoli')
  3154.                                 ->leftJoin('mappa_categorie_articoli.categoria1''cat1')
  3155.                                 ->leftJoin('mappa_categorie_articoli.categoria2''cat2')
  3156.                                 ->leftJoin('mappa_categorie_articoli.categoria3''cat3')
  3157.                                 ->leftJoin('mappa_categorie_articoli.categoria4''cat4')
  3158.                                 ->leftJoin('mappa_categorie_articoli.categoria5''cat5')
  3159.                                 ->leftJoin('mappa_categorie_articoli.articolo''art')
  3160.                                 ->where('art.codice = :art')->setParameter('art'$articolo->getCodice());
  3161.                             if($data[$indici['categoria1']] != ''){
  3162.                                 $qbMappa $qbMappa->andWhere('cat1.codice = :cat1')->setParameter('cat1'$data[$indici['categoria1']]);
  3163.                             }else{
  3164.                                 $qbMappa $qbMappa->andWhere('cat1.codice IS NULL');
  3165.                             }
  3166.                             if($data[$indici['categoria2']] != ''){
  3167.                                 $qbMappa $qbMappa->andWhere('cat2.codice = :cat2')->setParameter('cat2'$data[$indici['categoria2']]);
  3168.                             }else{
  3169.                                 $qbMappa $qbMappa->andWhere('cat2.codice IS NULL');
  3170.                             }
  3171.                             if($data[$indici['categoria3']] != ''){
  3172.                                 $qbMappa $qbMappa->andWhere('cat3.codice = :cat3')->setParameter('cat3'$data[$indici['categoria3']]);
  3173.                             }else{
  3174.                                 $qbMappa $qbMappa->andWhere('cat3.codice IS NULL');
  3175.                             }
  3176.                             if($data[$indici['categoria4']] != ''){
  3177.                                 $qbMappa $qbMappa->andWhere('cat4.codice = :cat4')->setParameter('cat4'$data[$indici['categoria4']]);
  3178.                             }else{
  3179.                                 $qbMappa $qbMappa->andWhere('cat4.codice IS NULL');
  3180.                             }
  3181.                             if($data[$indici['categoria5']] != ''){
  3182.                                 $qbMappa $qbMappa->andWhere('cat5.codice = :cat5')->setParameter('cat5'$data[$indici['categoria5']]);
  3183.                             }else{
  3184.                                 $qbMappa $qbMappa->andWhere('cat5.codice IS NULL');
  3185.                             }
  3186.                             $qbMappa $qbMappa->andWhere('mappa_categorie_articoli.marca = :marca')->setParameter('marca'$data[$indici['marca']])
  3187.                                 ->setMaxResults(1)->getQuery()->getResult();
  3188.                             if(count($qbMappa) > 0){
  3189.                                 $mappa $qbMappa[0];
  3190.                                 $variante $repoVariante->findOneBy(array('mappa' => $mappa'codiceVariante' => $data[$indici['codice_variante']]));
  3191.                                 $entita $repo->findOneBy(array('etichetta' => $data[$indici['etichetta']], 'articolo' => $articolo'mappa_categoria_articolo' => $mappa'variante' => $variante));
  3192.                                 if($data[$indici['operazione']] == 'E' && $entita != null){
  3193.                                     $em->remove($entita);
  3194.                                     $em->flush();
  3195.                                 }else if ($data[$indici['operazione']] != 'E'){
  3196.                                     if(!$entita) {
  3197.                                         $entita = new DisponibilitaAFasce();
  3198.                                         $entita->setArticolo($articolo);
  3199.                                         $entita->setVariante($variante);
  3200.                                         $entita->setMappaCategoriaArticolo($mappa);
  3201.                                         $entita->setEtichetta($data[$indici['etichetta']]);
  3202.                                         $entita->setDataCreazione(new \DateTime());
  3203.                                     }
  3204.                                     $entita->setDataModifica(new \DateTime());
  3205.                                     $entita->setPrincipale($data[$indici['principale']] == '1' true false);
  3206.                                     $entita->setDisponibilita(str_replace(',''.'$data[$indici['disponiblita']]));
  3207.                                     $em->persist($entita);
  3208.                                     $query_eseguite++;
  3209.                                 }
  3210.                             }else{
  3211.                                 $errori .= ("RIGA: " . ($contatore $row) . ' -- Mappa non trovata ');
  3212.                             }
  3213.                         }else{
  3214.                             $errori .= ("RIGA: " . ($contatore $row) . ' - Articolo: ' $data[$indici['codiceArticolo']] . ' non trovato!');
  3215.                         }
  3216.                         $row++;
  3217.                     }
  3218.                     $em->flush();
  3219.                     $em->clear();
  3220.                 }else{
  3221.                     $errori .= "Impossibile aprire il file!";
  3222.                 }
  3223.                 $row $contatore $row;
  3224.                 if ($errori == "") {
  3225.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaDisponibilitaPerFascia');
  3226.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  3227.                 } else {
  3228.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaDisponibilitaPerFascia');
  3229.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  3230.                 }
  3231.             } catch (\Exception|\Throwable $ex) {
  3232.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: (RIGA: ' $contatore ') :' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaDisponibilitaPerFascia');
  3233.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  3234.             }
  3235.         } else {
  3236.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaDisponibilitaPerFascia');
  3237.             return new Response("ERRORE PERMESSO");
  3238.         }
  3239.     } //OK
  3240.     /**
  3241.      * @Route("/caricaAssociazioneArticoliTipoOrdine/{svuota}", name="carica_associazione_articoli_tipo_ordine", defaults={"svuota"="0"})
  3242.      */
  3243.     public function caricaAssociazioneArticoliTipoOrdine(Request $request$svuota)
  3244.     {
  3245.         $collegamentoRnd $this->servizi->randomString2();
  3246.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  3247.             ini_set('max_execution_time'900);
  3248.             ini_set('memory_limit''4G');
  3249.             $start microtime(true);
  3250.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  3251.             $em $this->servizi->doctrine->getManager();
  3252.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  3253.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  3254.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  3255.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  3256.             $repoMappa $this->servizi->doctrine->getRepository(MappaCategorieArticoli::class);
  3257.             $repoArticoli $this->servizi->doctrine->getRepository(Articoli::class);
  3258.             $repo $this->servizi->doctrine->getRepository(AssociazioneArticoliTipoOrdine::class);
  3259.             $repoTipoOrdine $this->servizi->doctrine->getRepository(TipoOrdine::class);
  3260.             $repoVariante $this->servizi->doctrine->getRepository(Varianti::class);
  3261.             $errori "";
  3262.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaAssociazioneArticoliTipoOrdine/' $svuota ' --- Inizio l\' importazione delle associazione articoli tipo ordine'null$collegamentoRnd'ImportazioneController''caricaAssociazioneArticoliTipoOrdine');
  3263.             if($svuota == '1'){
  3264.                 $this->servizi->doctrine->getConnection()->executeQuery('TRUNCATE TABLE associazione_articoli_tipo_ordine;');
  3265.             }
  3266.             $root_path $pathFileBase "associazione_articoli_tipo_ordine.csv";
  3267.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  3268.             $contatore 0;
  3269.             $query_eseguite 0;
  3270.             $row 0;
  3271.             $batch_size 50;
  3272.             /*
  3273.                 0    codice articolo
  3274.                 1    codice categoria 1
  3275.                 2    codice categoria 2
  3276.                 3    codice categoria 3
  3277.                 4    codice categoria 4
  3278.                 5    codice categoria 5
  3279.                 6    marca
  3280.                 7    codice_variante
  3281.                 8    codice_tipo_ordine
  3282.                 9    operazione
  3283.              */
  3284.             $indici = array(
  3285.                 "codiceArticolo" => 0,
  3286.                 "categoria1" => 1,
  3287.                 "categoria2" => 2,
  3288.                 "categoria3" => 3,
  3289.                 "categoria4" => 4,
  3290.                 "categoria5" => 5,
  3291.                 "marca" => 6,
  3292.                 "codiceVariante" => 7,
  3293.                 'codiceTipoOrdine' => 8,
  3294.                 'operazione' => 9
  3295.             );
  3296.             try {
  3297.                 if (($handle fopen($root_path"r")) !== false) {
  3298.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  3299.                         if ($row == 0) {
  3300.                             $row 1;
  3301.                             continue;
  3302.                         }
  3303.                         if ($query_eseguite >= $batch_size) {
  3304.                             $contatore $contatore $row 1;
  3305.                             $row 1;
  3306.                             $query_eseguite 0;
  3307.                             $em->flush();
  3308.                             $em->clear();
  3309.                         }
  3310.                         $articolo $repoArticoli->findOneBy(array('codice' => $data[$indici['codiceArticolo']]));
  3311.                         if($articolo){
  3312.                             $qbMappa $repoMappa->createQueryBuilder('mappa_categorie_articoli')
  3313.                                 ->leftJoin('mappa_categorie_articoli.categoria1''cat1')
  3314.                                 ->leftJoin('mappa_categorie_articoli.categoria2''cat2')
  3315.                                 ->leftJoin('mappa_categorie_articoli.categoria3''cat3')
  3316.                                 ->leftJoin('mappa_categorie_articoli.categoria4''cat4')
  3317.                                 ->leftJoin('mappa_categorie_articoli.categoria5''cat5')
  3318.                                 ->leftJoin('mappa_categorie_articoli.articolo''art')
  3319.                                 ->where('art.codice = :art')->setParameter('art'$articolo->getCodice());
  3320.                             if($data[$indici['categoria1']] != ''){
  3321.                                 $qbMappa $qbMappa->andWhere('cat1.codice = :cat1')->setParameter('cat1'$data[$indici['categoria1']]);
  3322.                             }else{
  3323.                                 $qbMappa $qbMappa->andWhere('mappa_categorie_articoli.categoria1 IS NULL');
  3324.                             }
  3325.                             if($data[$indici['categoria2']] != ''){
  3326.                                 $qbMappa $qbMappa->andWhere('cat2.codice = :cat2')->setParameter('cat2'$data[$indici['categoria2']]);
  3327.                             }else{
  3328.                                 $qbMappa $qbMappa->andWhere('mappa_categorie_articoli.categoria2 IS NULL');
  3329.                             }
  3330.                             if($data[$indici['categoria3']] != ''){
  3331.                                 $qbMappa $qbMappa->andWhere('cat3.codice = :cat3')->setParameter('cat3'$data[$indici['categoria3']]);
  3332.                             }else{
  3333.                                 $qbMappa $qbMappa->andWhere('mappa_categorie_articoli.categoria3 IS NULL');
  3334.                             }
  3335.                             if($data[$indici['categoria4']] != ''){
  3336.                                 $qbMappa $qbMappa->andWhere('cat4.codice = :cat4')->setParameter('cat4'$data[$indici['categoria4']]);
  3337.                             }else{
  3338.                                 $qbMappa $qbMappa->andWhere('mappa_categorie_articoli.categoria4 IS NULL');
  3339.                             }
  3340.                             if($data[$indici['categoria5']] != ''){
  3341.                                 $qbMappa $qbMappa->andWhere('cat5.codice = :cat5')->setParameter('cat5'$data[$indici['categoria5']]);
  3342.                             }else{
  3343.                                 $qbMappa $qbMappa->andWhere('mappa_categorie_articoli.categoria5 IS NULL');
  3344.                             }
  3345.                             $qbMappa $qbMappa->andWhere('mappa_categorie_articoli.marca = :marca')->setParameter('marca'$data[$indici['marca']])
  3346.                                 ->setMaxResults(1)->getQuery();
  3347.                             $query $qbMappa->getSQL();
  3348.                             $risultati $qbMappa->getResult();
  3349.                             if(count($risultati) > 0){
  3350.                                 $mappa $risultati[0];
  3351.                                 $variante $data[$indici['codiceVariante']] != '' $repoVariante->findOneBy(array('mappa' => $mappa'codiceVariante' => $data[$indici['codiceVariante']])) : null;
  3352.                                 $tipoOrdine $repoTipoOrdine->findOneBy(array('codice' => $data[$indici['codiceTipoOrdine']]));
  3353.                                 if($tipoOrdine) {
  3354.                                     $entita $repo->findOneBy(array('tipoOrdine' => $tipoOrdine'articolo' => $articolo'mappaCategoriaArticolo' => $mappa'variante' => $variante));
  3355.                                     if ($data[$indici['operazione']] == 'E' && $entita != null) {
  3356.                                         $em->remove($entita);
  3357.                                         $em->flush();
  3358.                                     } else if ($data[$indici['operazione']] != 'E') {
  3359.                                         if (!$entita) {
  3360.                                             $entita = new AssociazioneArticoliTipoOrdine();
  3361.                                             $entita->setArticolo($articolo);
  3362.                                             $entita->setVariante($variante);
  3363.                                             $entita->setMappaCategoriaArticolo($mappa);
  3364.                                             $entita->setTipoOrdine($tipoOrdine);
  3365.                                             $entita->setDataCreazione(new \DateTime());
  3366.                                         }
  3367.                                         $entita->setDataModifica(new \DateTime());
  3368.                                         $em->persist($entita);
  3369.                                         $query_eseguite++;
  3370.                                     }
  3371.                                 }else{
  3372.                                     $errori .= ("RIGA: " . ($contatore $row) . ' -- Tipo ordine non trovato: ' $data[$indici['codiceTipoOrdine']] . "\n<br/>");
  3373.                                 }
  3374.                             }else{
  3375.                                 $errori .= ("RIGA: " . ($contatore $row) . ' -- Mappa non trovata - Art:' $data[$indici['codiceArticolo']] . ' - Cat: ' $data[$indici['categoria1']] . '-' $data[$indici['categoria2']] . '-' .$data[$indici['categoria3']] . '-' .$data[$indici['categoria4']] . '-' .$data[$indici['categoria5']] . '- Marca: ' $data[$indici['marca']] . '<br/>Query:' $query "\n<br/><br/>");
  3376.                             }
  3377.                         }else{
  3378.                             $errori .= ("RIGA: " . ($contatore $row) . ' - Articolo: ' $data[$indici['codiceArticolo']] . ' non trovato!' "\n<br/>");
  3379.                         }
  3380.                         $row++;
  3381.                     }
  3382.                     $em->flush();
  3383.                     $em->clear();
  3384.                 }else{
  3385.                     $errori .= "Impossibile aprire il file!";
  3386.                 }
  3387.                 $row $contatore $row;
  3388.                 $this->generaAlberoAction($request"1");
  3389.                 if ($errori == "") {
  3390.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaAssociazioneArticoliTipoOrdine');
  3391.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  3392.                 } else {
  3393.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaAssociazioneArticoliTipoOrdine');
  3394.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  3395.                 }
  3396.             } catch (\Exception|\Throwable $ex) {
  3397.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAssociazioneArticoliTipoOrdine');
  3398.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  3399.             }
  3400.         } else {
  3401.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaAssociazioneArticoliTipoOrdine');
  3402.             return new Response("ERRORE PERMESSO");
  3403.         }
  3404.     } //OK
  3405.     /**
  3406.      * @Route("/caricaTipoOrdine/{svuota}", name="carica_tipo_ordine", defaults={"svuota"="0"})
  3407.      */
  3408.     public function caricaTipoOrdine(Request $request$svuota)
  3409.     {
  3410.         $collegamentoRnd $this->servizi->randomString2();
  3411.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  3412.             ini_set('max_execution_time'900);
  3413.             ini_set('memory_limit''4G');
  3414.             $start microtime(true);
  3415.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  3416.             $em $this->servizi->doctrine->getManager();
  3417.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  3418.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  3419.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  3420.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  3421.             $repo $this->servizi->doctrine->getRepository(TipoOrdine::class);
  3422.             $errori "";
  3423.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaTipoOrdine/' $svuota ' --- Inizio l\' importazione dei tipi ordine'null$collegamentoRnd'ImportazioneController''caricaTipoOrdine');
  3424.             if($svuota == '1'){
  3425.                 $this->servizi->doctrine->getConnection()->executeQuery('TRUNCATE TABLE tipo_ordine;');
  3426.             }
  3427.             $root_path $pathFileBase "tipo_ordine.csv";
  3428.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  3429.             $contatore 0;
  3430.             $query_eseguite 0;
  3431.             $row 0;
  3432.             $batch_size 50;
  3433.             /*
  3434.                 0    codice
  3435.                 1    descrizione
  3436.                 2    testo visualizzato
  3437.                 3    codice esportazione
  3438.                 4    operazione
  3439.                 5   mostra tutto
  3440.                 6   nascondi disponibilita
  3441.              */
  3442.             $indici = array(
  3443.                 'codice' => 0,
  3444.                 'descrizione' => 1,
  3445.                 'testoVisualizzato' => 2,
  3446.                 'codiceEsportazione' => 3,
  3447.                 'operazione' => 4,
  3448.                 'mostraTutto' => 5,
  3449.                 'nascondiDisponibilita' => 6
  3450.             );
  3451.             try {
  3452.                 if (($handle fopen($root_path"r")) !== false) {
  3453.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  3454.                         if ($row == 0) {
  3455.                             $row 1;
  3456.                             continue;
  3457.                         }
  3458.                         if ($query_eseguite >= $batch_size) {
  3459.                             $contatore $contatore $row 1;
  3460.                             $row 1;
  3461.                             $query_eseguite 0;
  3462.                             $em->flush();
  3463.                             $em->clear();
  3464.                         }
  3465.                         $tipoOrdine $repo->findOneBy(array('codice' => $data[$indici['codice']]));
  3466.                         if ($tipoOrdine && $data[$indici['operazione']] == 'E') {
  3467.                             $em->remove($tipoOrdine);
  3468.                             $query_eseguite++;
  3469.                         } else {
  3470.                             if (!$tipoOrdine) {
  3471.                                 $tipoOrdine = new TipoOrdine();
  3472.                                 $tipoOrdine->setDataCreazione(new \DateTime());
  3473.                                 $tipoOrdine->setCodice($data[$indici['codice']]);
  3474.                             }
  3475.                             $tipoOrdine->setDescrizione($data[$indici['descrizione']]);
  3476.                             $tipoOrdine->setTestoVisualizzato($data[$indici['testoVisualizzato']]);
  3477.                             $tipoOrdine->setCodiceEsportazione($data[$indici['codiceEsportazione']]);
  3478.                             $tipoOrdine->setMostraTutto($data[$indici['mostraTutto']] == '1' true false);
  3479.                             if(count($data) >= 5){
  3480.                                 $tipoOrdine->setNascondiDisponibilita($data[$indici['nascondiDisponibilita']] == '1' true false);
  3481.                             }
  3482.                             $tipoOrdine->setDataModifica(new \DateTime());
  3483.                             $tipoOrdine->setUtenteModifica($this->servizi->OttieniUtenteCorrente());
  3484.                             $em->persist($tipoOrdine);
  3485.                             $query_eseguite++;
  3486.                         }
  3487.                         $em->flush();
  3488.                         $em->clear();
  3489.                         $row $contatore $row;
  3490.                     }
  3491.                 }else{
  3492.                     $errori .= "Impossibile aprire il file!";
  3493.                 }
  3494.                 if ($errori == "") {
  3495.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaTipoOrdine');
  3496.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  3497.                 } else {
  3498.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaTipoOrdine');
  3499.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  3500.                 }
  3501.             } catch (\Exception|\Throwable $ex) {
  3502.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaTipoOrdine');
  3503.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  3504.             }
  3505.         } else {
  3506.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaTipoOrdine');
  3507.             return new Response("ERRORE PERMESSO");
  3508.         }
  3509.     } //OK
  3510.     /**
  3511.      * @Route("/aggiornaOrdini", name="aggiorna_ordini")
  3512.      */
  3513.     public function aggiornaOrdini(Request $request)
  3514.     {
  3515.         $collegamentoRnd $this->servizi->randomString2();
  3516.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  3517.             ini_set('max_execution_time'900);
  3518.             ini_set('memory_limit''4G');
  3519.             $start microtime(true);
  3520.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  3521.             $em $this->servizi->doctrine->getManager();
  3522.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  3523.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  3524.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  3525.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  3526.             $repo $this->servizi->doctrine->getRepository(Ordini::class);
  3527.             $errori "";
  3528.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /aggiornaOrdini --- Inizio l\' aggiornamento degli ordini'null$collegamentoRnd'ImportazioneController''aggiornaOrdini');
  3529.             $root_path $pathFileBase "aggiornamento_ordini.csv";
  3530.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  3531.             $contatore 0;
  3532.             $query_eseguite 0;
  3533.             $row 0;
  3534.             $batch_size 50;
  3535.             /*
  3536.                 0    id_ordine
  3537.                 1    fattura
  3538.                 2    nome_file_fattura
  3539.                 3    ddt
  3540.                 4    nome_file_ddt
  3541.                 5    ordine
  3542.                 6    nome_file_ordine
  3543.                 7    offerta
  3544.                 8    nome_file_offerta
  3545.                 9    url_tracking_vettore
  3546.                 10    vettore
  3547.                 11    codice_tracking_vettore
  3548.              */
  3549.             $indici = array(
  3550.                 'idOrdine' => 0,
  3551.                 'fattura' => 1,
  3552.                 'nomeFileFattura' => 2,
  3553.                 'ddt' => 3,
  3554.                 'nomeFileDdt' => 4,
  3555.                 'ordine' => 5,
  3556.                 'nomeFileOrdine' => 6,
  3557.                 'offerta' => 7,
  3558.                 'nomeFileOfferta' => 8,
  3559.                 'urlTrackingVettore' => 9,
  3560.                 'vettore' => 10,
  3561.                 'codiceTrackingVettore' => 11
  3562.             );
  3563.             try {
  3564.                 if (($handle fopen($root_path"r")) !== false) {
  3565.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  3566.                         if ($row == 0) {
  3567.                             $row 1;
  3568.                             continue;
  3569.                         }
  3570.                         if ($query_eseguite >= $batch_size) {
  3571.                             $contatore $contatore $row 1;
  3572.                             $row 1;
  3573.                             $query_eseguite 0;
  3574.                             $em->flush();
  3575.                             $em->clear();
  3576.                         }
  3577.                         /** $ordine Ordini */
  3578.                         $ordine $repo->find($data[$indici['idOrdine']]);
  3579.                         if($ordine) {
  3580.                             $ordine->setFattura($data[$indici["fattura"]]);
  3581.                             $ordine->setNomeFileFattura($data[$indici["nomeFileFattura"]]);
  3582.                             $ordine->setDdt($data[$indici['ddt']]);
  3583.                             $ordine->setNomeFileDdt($data[$indici['nomeFileDdt']]);
  3584.                             $ordine->setOrdine($data[$indici["ordine"]]);
  3585.                             $ordine->setNomeFileOrdine($data[$indici["nomeFileOrdine"]]);
  3586.                             $ordine->setOfferta($data[$indici["offerta"]]);
  3587.                             $ordine->setNomeFileOfferta($data[$indici["nomeFileOfferta"]]);
  3588.                             $ordine->setUrlTrackingVettore($data[$indici["urlTrackingVettore"]]);
  3589.                             $ordine->setVettore($data[$indici["vettore"]]);
  3590.                             $ordine->setCodiceTrackingVettore($data[$indici["codiceTrackingVettore"]]);
  3591.                             $em->persist($ordine);
  3592.                             $query_eseguite++;
  3593.                         }else{
  3594.                             $errori .= ("Ordine cond id: " $data[$indici['idOrdine']] . " non trovato!");
  3595.                         }
  3596.                         $row $contatore $row;
  3597.                     }
  3598.                     $em->flush();
  3599.                     $em->clear();
  3600.                 }else{
  3601.                     $errori .= "Impossibile aprire il file!";
  3602.                 }
  3603.                 if ($errori == "") {
  3604.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''aggiornaOrdini');
  3605.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  3606.                 } else {
  3607.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''aggiornaOrdini');
  3608.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  3609.                 }
  3610.             } catch (\Exception|\Throwable $ex) {
  3611.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''aggiornaOrdini');
  3612.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  3613.             }
  3614.         } else {
  3615.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''aggiornaOrdini');
  3616.             return new Response("ERRORE PERMESSO");
  3617.         }
  3618.     } //OK
  3619.     /**
  3620.      * @Route("/caricaFiltriVisualizzazioneArticoli/{svuota}", name="carica_filtri_visualizzazione_articoli", defaults={"svuota"="0"})
  3621.      */
  3622.     public function caricaFiltriVisualizzazioneArticoli(Request $request$svuota)
  3623.     {
  3624.         $collegamentoRnd $this->servizi->randomString2();
  3625.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  3626.             ini_set('max_execution_time'900);
  3627.             ini_set('memory_limit''4G');
  3628.             $start microtime(true);
  3629.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  3630.             $em $this->servizi->doctrine->getManager();
  3631.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  3632.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  3633.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  3634.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  3635.             $repoUser $this->servizi->doctrine->getRepository(User::class);
  3636.             $repo $this->servizi->doctrine->getRepository(FiltroVisualizzazioneArticoliClienti::class);
  3637.             $errori "";
  3638.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaFiltriVisualizzazioneArticoli/' $svuota ' --- Inizio l\' importazione dei filtri visualizzazione articoli'null$collegamentoRnd'ImportazioneController''caricaFiltriVisualizzazioneArticoli');
  3639.             if($svuota == '1'){
  3640.                 $this->servizi->doctrine->getConnection()->exec('UPDATE fos_user SET filtro_visualizzazione_articoli_clienti_id = NULL;');
  3641.             }
  3642.             $root_path $pathFileBase "filtri_visualizzazione_articoli.csv";
  3643.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  3644.             $contatore 0;
  3645.             $query_eseguite 0;
  3646.             $row 0;
  3647.             $batch_size 50;
  3648.             /*
  3649.                 0    username
  3650.                 1    categorie
  3651.                 2    mostra
  3652.                 3    operazione
  3653.              */
  3654.             $indici = array(
  3655.                 "username" => 0,
  3656.                 "categorie" => 1,
  3657.                 "mostra" => 2,
  3658.                 "operazione" => 3
  3659.             );
  3660.             try {
  3661.                 if (($handle fopen($root_path"r")) !== false) {
  3662.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  3663.                         if ($row == 0) {
  3664.                             $row 1;
  3665.                             continue;
  3666.                         }
  3667.                         if ($query_eseguite >= $batch_size) {
  3668.                             $contatore $contatore $row 1;
  3669.                             $row 1;
  3670.                             $query_eseguite 0;
  3671.                             $em->flush();
  3672.                             $em->clear();
  3673.                         }
  3674.                         $utente $repoUser->findOneBy(array('username' => $data[$indici['username']]));
  3675.                         if ($utente) {
  3676.                             //Verifico se il filtro esiste
  3677.                             $entita $repo->findOneBy(array('elencoCategorie' => $data[$indici['categorie']], 'mostra' => $data[$indici['mostra']] == '1' true false));
  3678.                             if ($entita != null) {
  3679.                                 $utente->setFiltroVisualizzazioneArticoliClienti($entita);
  3680.                                 $em->persist($utente);
  3681.                             } else {
  3682.                                 $entita = new FiltroVisualizzazioneArticoliClienti();
  3683.                                 $entita->setNome(randomString(15));
  3684.                                 $entita->setUtenteModifica($this->servizi->OttieniUtenteCorrente());
  3685.                                 $entita->setDataModifica(new \DateTime());
  3686.                                 $entita->setDataCreazione(new \DateTime());
  3687.                                 $entita->setMostra($data[$indici['mostra']] == '1' true false);
  3688.                                 $entita->setElencoCategorie($data[$indici['categorie']]);
  3689.                                 $em->persist($entita);
  3690.                                 $utente->setFiltroVisualizzazioneArticoliClienti($entita);
  3691.                                 $em->persist($utente);
  3692.                                 $query_eseguite++;
  3693.                             }
  3694.                         } else {
  3695.                             $errori .= ("RIGA: " $contatore ' - Utente con username: ' $data[$indici['username']] . ' non trovato!');
  3696.                         }
  3697.                         $row++;
  3698.                     }
  3699.                     $em->flush();
  3700.                     $em->clear();
  3701.                     $row $contatore $row;
  3702.                 }else{
  3703.                     $errori .= "Impossibile aprire il file!";
  3704.                 }
  3705.                 if ($errori == "") {
  3706.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaFiltriVisualizzazioneArticoli');
  3707.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  3708.                 } else {
  3709.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaFiltriVisualizzazioneArticoli');
  3710.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  3711.                 }
  3712.             } catch (\Exception|\Throwable $ex) {
  3713.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaFiltriVisualizzazioneArticoli');
  3714.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  3715.             }
  3716.         } else {
  3717.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaFiltriVisualizzazioneArticoli');
  3718.             return new Response("ERRORE PERMESSO");
  3719.         }
  3720.     } //OK
  3721.     /**
  3722.      * @Route("/caricaScontiClientiAnagrafiche/{svuota}", name="carica_sconti_clienti_anagrafiche", defaults={"svuota"="0"})
  3723.      */
  3724.     public function caricaScontiAnagraficheAction(Request $request$svuota)
  3725.     {
  3726.         $collegamentoRnd $this->servizi->randomString2();
  3727.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  3728.             ini_set('max_execution_time'900);
  3729.             ini_set('memory_limit''4G');
  3730.             $start microtime(true);
  3731.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  3732.             $em $this->servizi->doctrine->getManager();
  3733.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  3734.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  3735.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  3736.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  3737.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaScontiAnagrafiche/' $svuota ' --- Inizio l\' importazione delle scontistiche delle anagrafiche'null$collegamentoRnd'ImportazioneController''caricaScontiClientiAnagrafiche');
  3738.             $repoScontiClientiBase $this->servizi->doctrine->getRepository(ScontiAnagrafiche::class);
  3739.             $errori "";
  3740.             $connection $this->servizi->doctrine->getConnection();
  3741.             if($svuota == "1"){
  3742.                 $em $this->servizi->doctrine->getManager();
  3743.                 $connection->beginTransaction();
  3744.                 try {
  3745.                     $connection->query("SET FOREIGN_KEY_CHECKS=0;");
  3746.                     $connection->executeUpdate("TRUNCATE `sconti_anagrafiche`;");
  3747.                     $connection->query("SET FOREIGN_KEY_CHECKS=1;");
  3748.                     $connection->commit();
  3749.                 }catch (\Exception|\Throwable|\Throwable $ex){
  3750.                     $this->servizi->DebuggaException($ex"Errore pulizia sconti anagrafiche"falsenull$collegamentoRnd'ImportazioneController''caricaScontiClientiAnagrafiche');
  3751.                 }
  3752.             }
  3753.             $root_path $pathFileBase "articoli_sconti.csv";
  3754.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  3755.             $contatore 0;
  3756.             $query_eseguite 0;
  3757.             $row 0;
  3758.             $batch_size 50;
  3759.             /*
  3760.              * Index    Campo
  3761.                 0    codice_anagrafica
  3762.                 1    codice_articolo
  3763.                 2    codice_variante
  3764.                 3    etichetta
  3765.                 4    sconto
  3766.                 5    operazione
  3767.                 6   applica_sempre
  3768.                 7   codice_categorie
  3769.              */
  3770.             $indici = array(
  3771.                 "codiceAnagrafica" => 0,
  3772.                 "codiceGruppoAnagrafica" => '',
  3773.                 "codiceGruppoArticoli" => '',
  3774.                 "codiceArticolo" => 1,
  3775.                 "codiceVariante" => 2,
  3776.                 "etichetta" => 3,
  3777.                 "sconto" => 4,
  3778.                 "operazione" => 5,
  3779.                 'applicaSempre' => 6,
  3780.                 'codiceGruppoCategorie' => 7
  3781.             );
  3782.             try {
  3783.                 if (($handle fopen($root_path"r")) !== false) {
  3784.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  3785.                         if ($row == 0) {
  3786.                             $row 1;
  3787.                             continue;
  3788.                         }
  3789.                         if ($query_eseguite >= $batch_size) {
  3790.                             $contatore $contatore $row 1;
  3791.                             $row 1;
  3792.                             $query_eseguite 0;
  3793.                             $em->flush();
  3794.                             $em->clear();
  3795.                         }
  3796.                         $now = new \DateTime('now');
  3797.                         $criterioRicerca = [
  3798.                             'codiceAnagrafica' => $indici["codiceAnagrafica"] !== '' $data[$indici["codiceAnagrafica"]] : "",
  3799.                             'codiceGruppoAnagrafica' => $indici["codiceGruppoAnagrafica"] !== '' $data[$indici["codiceGruppoAnagrafica"]] : "",
  3800.                             'codiceGruppoArticoli' => $indici["codiceGruppoArticoli"] !== '' $data[$indici["codiceGruppoArticoli"]] : "",
  3801.                             'codiceVariante' => $indici["codiceVariante"] !== '' $data[$indici["codiceVariante"]] : "",
  3802.                             'codiceArticolo' => $indici["codiceArticolo"] !== '' $data[$indici["codiceArticolo"]] : "",
  3803.                         ];
  3804.                         if(count($data) > 7){
  3805.                             $criterioRicerca['codiceGruppoCategorie'] = $indici['codiceGruppoCategorie'] !== '' $data[$indici['codiceGruppoCategorie']] : "";
  3806.                         }
  3807.                         if(count($data) > ) {
  3808.                             $criterioRicerca['applicaSempre'] = $data[$indici['applicaSempre']] == '1' true false;
  3809.                         }
  3810.                         $scontoPresente $repoScontiClientiBase->findOneBy($criterioRicerca);
  3811.                         if ($scontoPresente) {
  3812.                             if ($data[$indici["operazione"]] == "E") {
  3813.                                 $em->remove($scontoPresente);
  3814.                                 $query_eseguite++;
  3815.                             } else {
  3816.                                 $scontoPresente->setSconto($indici["sconto"] !== '' $data[$indici["sconto"]] : "");
  3817.                                 if(count($data) > ){
  3818.                                     $scontoPresente->setApplicaSempre($data[$indici['applicaSempre']]);
  3819.                                 }
  3820.                                 $scontoPresente->setEtichetta($indici["etichetta"] !== '' $data[$indici["etichetta"]] : "");
  3821.                                 $scontoPresente->setDataModifica($now);
  3822.                                 $em->persist($scontoPresente);
  3823.                                 $query_eseguite++;
  3824.                             }
  3825.                         } else {
  3826.                             $scontoPresente = new ScontiAnagrafiche();
  3827.                             $scontoPresente->setCodiceAnagrafica($indici["codiceAnagrafica"] !== '' $data[$indici["codiceAnagrafica"]] : "");
  3828.                             $scontoPresente->setCodiceGruppoAnagrafica($indici["codiceGruppoAnagrafica"] !== '' $data[$indici["codiceGruppoAnagrafica"]] : "");
  3829.                             $scontoPresente->setCodiceGruppoArticoli($indici["codiceGruppoArticoli"] !== '' $data[$indici["codiceGruppoArticoli"]] : "");
  3830.                             $scontoPresente->setCodiceArticolo($indici["codiceArticolo"] !== '' $data[$indici["codiceArticolo"]] : "");
  3831.                             $scontoPresente->setCodiceVariante($indici["codiceVariante"] !== '' $data[$indici["codiceVariante"]] : "");
  3832.                             $scontoPresente->setSconto($indici["sconto"] !== '' $data[$indici["sconto"]] : "");
  3833.                             if(count($data) > ){
  3834.                                 $scontoPresente->setApplicaSempre($data[$indici['applicaSempre']]);
  3835.                             }
  3836.                             if(count($data) > 7){
  3837.                                 $scontoPresente->setCodiceGruppoCategorie($indici['codiceGruppoCategorie'] !== '' $data[$indici['codiceGruppoCategorie']] : "");
  3838.                             }
  3839.                             $scontoPresente->setEtichetta($indici["etichetta"] !== '' $data[$indici["etichetta"]] : "");
  3840.                             $scontoPresente->setDataCreazione($now);
  3841.                             $scontoPresente->setDataModifica($now);
  3842.                             $em->persist($scontoPresente);
  3843.                             $query_eseguite++;
  3844.                         }
  3845.                         $row++;
  3846.                         $em->flush();
  3847.                     }
  3848.                     $em->flush();
  3849.                     $em->clear();
  3850.                 }else{
  3851.                     $errori .= "Impossibile aprire il file!";
  3852.                 }
  3853.                 $row $contatore $row;
  3854.                 if ($errori == "") {
  3855.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaScontiClientiAnagrafiche');
  3856.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  3857.                 } else {
  3858.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaScontiClientiAnagrafiche');
  3859.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  3860.                 }
  3861.             } catch (\Exception|\Throwable $ex) {
  3862.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaScontiClientiAnagrafiche');
  3863.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  3864.             }
  3865.         } else {
  3866.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaScontiClientiAnagrafiche');
  3867.             return new Response("ERRORE PERMESSO");
  3868.         }
  3869.     } //OK
  3870.     /**
  3871.      * @Route("/caricaAnagraficheOpzioniAggiuntive/{svuota}", name="carica_anagrafiche_opzioni_aggiuntive", defaults={"svuota"="0"})
  3872.      */
  3873.     public function caricaAnagraficheOpzioniAggiuntive(Request $request$svuota)
  3874.     {
  3875.         $collegamentoRnd $this->servizi->randomString2();
  3876.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  3877.             ini_set('max_execution_time'900);
  3878.             ini_set('memory_limit''4G');
  3879.             $start microtime(true);
  3880.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  3881.             $em $this->servizi->doctrine->getManager();
  3882.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  3883.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  3884.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  3885.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  3886.             $repo $this->servizi->doctrine->getRepository(AnagraficaOpzioniAggiuntive::class);
  3887.             $errori "";
  3888.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaAnagraficheOpzioniAggiuntive/' $svuota ' --- Inizio l\' importazione delle scontistiche delle anagrafiche'null$collegamentoRnd'ImportazioneController''caricaAnagraficheOpzioniAggiuntive');
  3889.             if($svuota == '1'){
  3890.                 $this->servizi->doctrine->getConnection()->executeQuery('TRUNCATE TABLE anagrafica_opzioni_aggiuntive;');
  3891.             }
  3892.             $root_path $pathFileBase "anagrafiche_opzioni_aggiuntive.csv";
  3893.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  3894.             $contatore 0;
  3895.             $query_eseguite 0;
  3896.             $row 0;
  3897.             $batch_size 50;
  3898.             /*
  3899.              Index    Campo
  3900.                 0    codice_anagrafica
  3901.                 1    ordine
  3902.                 2    identificativo
  3903.                 3    etichetta
  3904.                 4    valore
  3905.                 5    operazione
  3906.                 6    tipo
  3907.                 7   livello_permesso
  3908.              */
  3909.             $indici = array(
  3910.                 "codiceAnagrafica" => 0,
  3911.                 "ordine" => 1,
  3912.                 "identificativo" => 2,
  3913.                 "etichetta" => 3,
  3914.                 "valore" => 4,
  3915.                 "tipo" => 6,
  3916.                 "operazione" => 5,
  3917.                 "livelloPermesso" => 7
  3918.             );
  3919.             try {
  3920.                 if (($handle fopen($root_path"r")) !== false) {
  3921.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  3922.                         if ($row == 0) {
  3923.                             $row 1;
  3924.                             continue;
  3925.                         }
  3926.                         if ($query_eseguite >= $batch_size) {
  3927.                             $contatore $contatore $row 1;
  3928.                             $row 1;
  3929.                             $query_eseguite 0;
  3930.                             $em->flush();
  3931.                             $em->clear();
  3932.                         }
  3933.                         $now = new \DateTime('now');
  3934.                         try {
  3935.                             $opzioneAgg $repo->findOneBy(array(
  3936.                                 'codiceAnagrafica' => $data[$indici["codiceAnagrafica"]],
  3937.                                 'identificativo' => $data[$indici["identificativo"]]
  3938.                             ));
  3939.                             if ($opzioneAgg) {
  3940.                                 if ($data[$indici["operazione"]] == "E") {
  3941.                                     $em->remove($opzioneAgg);
  3942.                                     $query_eseguite++;
  3943.                                 } else {
  3944.                                     $opzioneAgg->setEtichetta($indici["etichetta"] !== '' $data[$indici["etichetta"]] : '');
  3945.                                     $opzioneAgg->setOrdine($indici["ordine"] !== '' $data[$indici["ordine"]] : '');
  3946.                                     $opzioneAgg->setValore($indici["valore"] !== '' $data[$indici["valore"]] : '');
  3947.                                     $opzioneAgg->setTipo($indici["tipo"] !== '' $data[$indici["tipo"]] : '');
  3948.                                     if(count($data) > $indici["livelloPermesso"])
  3949.                                         $opzioneAgg->setLivelloPermesso($indici["livelloPermesso"] !== '' $data[$indici["livelloPermesso"]] : null);
  3950.                                     $opzioneAgg->setDataModifica($now);
  3951.                                     $em->persist($opzioneAgg);
  3952.                                     $query_eseguite++;
  3953.                                 }
  3954.                             } else {
  3955.                                 $opzioneAgg = new AnagraficaOpzioniAggiuntive();
  3956.                                 $opzioneAgg->setCodiceAnagrafica($indici["codiceAnagrafica"] !== '' $data[$indici["codiceAnagrafica"]] : '');
  3957.                                 $opzioneAgg->setOrdine($indici["ordine"] !== '' $data[$indici["ordine"]] : '');
  3958.                                 $opzioneAgg->setIdentificativo($indici["identificativo"] !== '' $data[$indici["identificativo"]] : '');
  3959.                                 $opzioneAgg->setEtichetta($indici["etichetta"] !== '' $data[$indici["etichetta"]] : '');
  3960.                                 $opzioneAgg->setValore($indici["valore"] !== '' $data[$indici["valore"]] : '');
  3961.                                 $opzioneAgg->setTipo($indici["tipo"] !== '' $data[$indici["tipo"]] : '');
  3962.                                 if(count($data) > $indici["livelloPermesso"])
  3963.                                     $opzioneAgg->setLivelloPermesso($indici["livelloPermesso"] !== '' $data[$indici["livelloPermesso"]] : null);
  3964.                                 $opzioneAgg->setDataCreazione($now);
  3965.                                 $opzioneAgg->setDataModifica($now);
  3966.                                 $em->persist($opzioneAgg);
  3967.                                 $query_eseguite++;
  3968.                             }
  3969.                         } catch (\Exception|\Throwable $ex) {
  3970.                             $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: (RIGA: ' $contatore '): ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAnagraficheOpzioniAggiuntive');
  3971.                             $errori .= ('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage() . '<br>');
  3972.                         }
  3973.                         $row++;
  3974.                         $em->flush();
  3975.                     }
  3976.                     $em->flush();
  3977.                     $em->clear();
  3978.                 }else{
  3979.                     $errori .= "Impossibile aprire il file!";
  3980.                 }
  3981.                 $row $contatore $row;
  3982.                 if ($errori == "") {
  3983.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaAnagraficheOpzioniAggiuntive');
  3984.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  3985.                 } else {
  3986.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), var_export($erroritrue), false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds' $rownull$collegamentoRnd'ImportazioneController''caricaAnagraficheOpzioniAggiuntive');
  3987.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  3988.                 }
  3989.             } catch (\Exception|\Throwable $ex) {
  3990.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), $ex->getTraceAsString(), false'Errore importazione: (RIGA: ' $contatore '): ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAnagraficheOpzioniAggiuntive');
  3991.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  3992.             }
  3993.         } else {
  3994.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaAnagraficheOpzioniAggiuntive');
  3995.             return new Response("ERRORE PERMESSO");
  3996.         }
  3997.     } //OK
  3998.     function randomString($length 6)
  3999.     {
  4000.         $str "";
  4001.         $characters array_merge(range('A''Z'), range('a''z'), range('0''9'));
  4002.         $max count($characters) - 1;
  4003.         for ($i 0$i $length$i++) {
  4004.             $rand mt_rand(0$max);
  4005.             $str .= $characters[$rand];
  4006.         }
  4007.         return $str;
  4008.     }
  4009.     /**
  4010.      * @Route("/caricaUnitaDiMisura", name="carica_unita_misura")
  4011.      */
  4012.     public function caricaUnitaDiMisura(Request $request)
  4013.     {
  4014.         $collegamentoRnd $this->servizi->randomString2();
  4015.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  4016.             ini_set('max_execution_time'1200);
  4017.             ini_set('memory_limit''4G');
  4018.             $start microtime(true);
  4019.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  4020.             $em $this->servizi->doctrine->getManager();
  4021.             $repo $this->servizi->doctrine->getRepository(UnitaMisura::class);
  4022.             $errori "";
  4023.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  4024.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  4025.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  4026.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  4027.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaUnitaDiMisura --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaUnitaDiMisura');
  4028.             $errori "";
  4029.             $root_path $pathFileBase "um.csv";
  4030.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  4031.             $contatore 0;
  4032.             $row 0;
  4033.             $query_eseguite 0;
  4034.             $batch_size 50;
  4035.             /*
  4036.              *  0    codice
  4037.                 1    descrizione
  4038.                 2    fattore conversione
  4039.                 3    numero decimali
  4040.              */
  4041.             try {
  4042.                 if (($handle fopen($root_path"r")) !== false) {
  4043.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  4044.                         if ($row == 0) {
  4045.                             $row 1;
  4046.                             continue;
  4047.                         }
  4048.                         if ($query_eseguite >= $batch_size) {
  4049.                             $contatore $contatore $row 1;
  4050.                             $row 1;
  4051.                             $query_eseguite 0;
  4052.                             $em->flush();
  4053.                             $em->clear();
  4054.                         }
  4055.                         $now = new \DateTime('now');
  4056.                         try {
  4057.                             $umDb $repo->findOneBy(array('codice' => $data[0]));
  4058.                             if ($umDb) {
  4059.                                 $umDb->setDescrizione($data[1]);
  4060.                                 $umDb->setFattoreConversione(str_replace(',''.'$data[2]));
  4061.                                 $umDb->setNumeroDecimali(str_replace(',''.'$data[3]));
  4062.                                 $umDb->setDataModifica(new \DateTime());
  4063.                             } else {
  4064.                                 $umDb = new UnitaMisura();
  4065.                                 $umDb->setCodice($data[0]);
  4066.                                 $umDb->setDescrizione($data[1]);
  4067.                                 $umDb->setFattoreConversione(str_replace(',''.'$data[2]));
  4068.                                 $umDb->setNumeroDecimali(str_replace(',''.'$data[3]));
  4069.                                 $umDb->setAttivo(true);
  4070.                                 $umDb->setDataCreazione(new \DateTime());
  4071.                                 $umDb->setDataModifica(new \DateTime());
  4072.                             }
  4073.                             $em->persist($umDb);
  4074.                         } catch (\PDOException $ex) {
  4075.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaUnitaDiMisura');
  4076.                         } catch (\Exception|\Throwable $exception) {
  4077.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaUnitaDiMisura');
  4078.                         }
  4079.                         $row++;
  4080.                         $em->flush();
  4081.                     }
  4082.                 }else{
  4083.                     $errori .= "Impossibile aprire il file!";
  4084.                 }
  4085.                 $em->flush();
  4086.                 $row $contatore $row 1;
  4087.                 if ($errori == "") {
  4088.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaUnitaDiMisura');
  4089.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  4090.                 } else {
  4091.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaUnitaDiMisura');
  4092.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  4093.                 }
  4094.             } catch (\Exception|\Throwable $ex) {
  4095.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaUnitaDiMisura');
  4096.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  4097.             }
  4098.         } else {
  4099.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaUnitaDiMisura');
  4100.             return new Response("ERRORE PERMESSO");
  4101.         }
  4102.     } //OK
  4103.     /**
  4104.      * @Route("/caricaNazioni", name="carica_nazioni")
  4105.      */
  4106.     public function caricaNazioni(Request $request)
  4107.     {
  4108.         $collegamentoRnd $this->servizi->randomString2();
  4109.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  4110.             ini_set('max_execution_time'1200);
  4111.             ini_set('memory_limit''4G');
  4112.             $start microtime(true);
  4113.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  4114.             $em $this->servizi->doctrine->getManager();
  4115.             $repo $this->servizi->doctrine->getRepository(Nazioni::class);
  4116.             $errori "";
  4117.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  4118.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  4119.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  4120.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  4121.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaNazioni --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaNazioni');
  4122.             $errori "";
  4123.             $root_path $pathFileBase "nazioni.csv";
  4124.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  4125.             $contatore 0;
  4126.             $row 0;
  4127.             $query_eseguite 0;
  4128.             $batch_size 50;
  4129.             /*
  4130.              *  0    sigla iso
  4131.                 1    descrizione
  4132.                 2    flag paese cee
  4133.                 3    flag black list
  4134.                 4    operazione
  4135.              */
  4136.             try {
  4137.                 if (($handle fopen($root_path"r")) !== false) {
  4138.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  4139.                         if ($row == 0) {
  4140.                             $row 1;
  4141.                             continue;
  4142.                         }
  4143.                         if ($query_eseguite >= $batch_size) {
  4144.                             $contatore $contatore $row 1;
  4145.                             $row 1;
  4146.                             $query_eseguite 0;
  4147.                             $em->flush();
  4148.                             $em->clear();
  4149.                         }
  4150.                         $now = new \DateTime('now');
  4151.                         try {
  4152.                             $entity $repo->findOneBy(array('siglaIso' => $data[0]));
  4153.                             if ($entity) {
  4154.                                 if ($data[4] == "E") {
  4155.                                     $em->remove($entity);
  4156.                                     $query_eseguite++;
  4157.                                 } else {
  4158.                                     $entity->setDataModifica($now);
  4159.                                     $entity->setDescrizione($data[1]);
  4160.                                     $entity->setPaeseCee($data[2] == "1" true false);
  4161.                                     $entity->setBlacklist($data[3] == "1" true false);
  4162.                                     $em->persist($entity);
  4163.                                     $query_eseguite++;
  4164.                                 }
  4165.                             } else {
  4166.                                 $entity = new Nazioni();
  4167.                                 $entity->setSiglaIso($data[0]);
  4168.                                 $entity->setDescrizione($data[1]);
  4169.                                 $entity->setPaeseCee($data[2] == "1" true false);
  4170.                                 $entity->setBlacklist($data[3] == "1" true false);
  4171.                                 $entity->setDataCreazione($now);
  4172.                                 $entity->setDataModifica($now);
  4173.                                 $em->persist($entity);
  4174.                                 $query_eseguite++;
  4175.                             }
  4176.                         } catch (\PDOException $ex) {
  4177.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaNazioni');
  4178.                         } catch (\Exception|\Throwable $exception) {
  4179.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaNazioni');
  4180.                         }
  4181.                         $row++;
  4182.                         $em->flush();
  4183.                     }
  4184.                 }else{
  4185.                     $errori .= "Impossibile aprire il file!";
  4186.                 }
  4187.                 $em->flush();
  4188.                 $row $contatore $row 1;
  4189.                 if ($errori == "") {
  4190.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaNazioni');
  4191.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  4192.                 } else {
  4193.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaNazioni');
  4194.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  4195.                 }
  4196.             } catch (\Exception|\Throwable $ex) {
  4197.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaNazioni');
  4198.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  4199.             }
  4200.         } else {
  4201.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaNazioni');
  4202.             return new Response("ERRORE PERMESSO");
  4203.         }
  4204.     } //OK
  4205.     /**
  4206.      * @Route("/caricaBlocchiAnagrafiche/{svuota}", name="carica_blocchi_anagrafiche", defaults={"svuota" = 0})
  4207.      */
  4208.     public function caricaBlocchiAnagrafiche(Request $request$svuota 0)
  4209.     {
  4210.         $collegamentoRnd $this->servizi->randomString2();
  4211.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  4212.             ini_set('max_execution_time'1200);
  4213.             ini_set('memory_limit''4G');
  4214.             $start microtime(true);
  4215.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  4216.             $em $this->servizi->doctrine->getManager();
  4217.             $repo $this->servizi->doctrine->getRepository(AnagraficheBlocchi::class);
  4218.             $errori "";
  4219.             /** @var User|null $user */
  4220.             $user $this->servizi->OttieniUtenteCorrente();
  4221.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  4222.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  4223.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  4224.             $svuota = ($svuota == '1' true false);
  4225.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  4226.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaBlocchiAnagrafiche --- Inizio l\' importazione dei dati' . ($svuota ' con svuotamento tabella' ''), null$collegamentoRnd'ImportazioneController''caricaBlocchiAnagrafiche');
  4227.             $errori "";
  4228.             $root_path $pathFileBase "blocchi_anagrafiche.csv";
  4229.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  4230.             $contatore 0;
  4231.             $row 0;
  4232.             $query_eseguite 0;
  4233.             $batch_size 50;
  4234.             if($svuota){
  4235.                 $this->servizi->doctrine->getConnection()->executeQuery("TRUNCATE TABLE anagrafiche_blocchi;");
  4236.             }
  4237.             /*
  4238.              *  0    codice_cliente
  4239.                 1    identificativo_blocco
  4240.                 2    tipo_blocco
  4241.                 3    mostra_avviso
  4242.                 4    testo_avviso
  4243.                 5    vincola_a_codice_agente
  4244.                 6    operazione
  4245.              */
  4246.             $indici = array(
  4247.                 "codiceCliente" => 0,
  4248.                 "identificativoBlocco" => 1,
  4249.                 "tipoBlocco" => 2,
  4250.                 "mostraAvviso" => 3,
  4251.                 "testoAvviso" => 4,
  4252.                 "vincolaACodiceAgente" => 5,
  4253.                 "operazione" => 6
  4254.             );
  4255.             try {
  4256.                 if (($handle fopen($root_path"r")) !== false) {
  4257.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  4258.                         if ($row == 0) {
  4259.                             $row 1;
  4260.                             continue;
  4261.                         }
  4262.                         if ($query_eseguite >= $batch_size) {
  4263.                             $contatore $contatore $row 1;
  4264.                             $row 1;
  4265.                             $query_eseguite 0;
  4266.                             $em->flush();
  4267.                             $em->clear();
  4268.                         }
  4269.                         try {
  4270.                             $entity null;
  4271.                             if (!$svuota && $data[$indici['identificativoBlocco']] != ''){
  4272.                                 $entity $repo->findOneBy(array('codiceCliente' => $data[$indici['codiceCliente']], 'identificativoBlocco' => $data[$indici['identificativoBlocco']]));
  4273.                             }
  4274.                             if ($entity) {
  4275.                                 if ($data[$indici['operazione']] == "E") {
  4276.                                     $em->remove($entity);
  4277.                                     $query_eseguite++;
  4278.                                 } else {
  4279.                                     $entity->setDataModifica(new \DateTime());
  4280.                                     $entity->setTipoBlocco($data[$indici['tipoBlocco']]);
  4281.                                     $entity->setMostraAvviso($data[$indici['mostraAvviso']] == '1' true false);
  4282.                                     $entity->setTestoAvviso($data[$indici['testoAvviso']]);
  4283.                                     $entity->setVincolaACodiceAgente($data[$indici['vincolaACodiceAgente']]);
  4284.                                     $em->persist($entity);
  4285.                                     $query_eseguite++;
  4286.                                 }
  4287.                             } else {
  4288.                                 $entity = new AnagraficheBlocchi();
  4289.                                 $entity->setDataModifica(new \DateTime());
  4290.                                 $entity->setTipoBlocco($data[$indici['tipoBlocco']]);
  4291.                                 $entity->setMostraAvviso($data[$indici['mostraAvviso']] == '1' true false);
  4292.                                 $entity->setTestoAvviso($data[$indici['testoAvviso']]);
  4293.                                 $entity->setVincolaACodiceAgente($data[$indici['vincolaACodiceAgente']]);
  4294.                                 $entity->setCodiceCliente($data[$indici['codiceCliente']]);
  4295.                                 $entity->setDataCreazione(new \DateTime());
  4296.                                 $em->persist($entity);
  4297.                                 $query_eseguite++;
  4298.                             }
  4299.                         } catch (\PDOException $ex) {
  4300.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaBlocchiAnagrafiche');
  4301.                         } catch (\Exception|\Throwable $exception) {
  4302.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaBlocchiAnagrafiche');
  4303.                         }
  4304.                         $row++;
  4305.                         $em->flush();
  4306.                     }
  4307.                 }else{
  4308.                     $errori .= "Impossibile aprire il file!";
  4309.                 }
  4310.                 $em->flush();
  4311.                 $row $contatore $row 1;
  4312.                 if ($errori == "") {
  4313.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaBlocchiAnagrafiche');
  4314.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  4315.                 } else {
  4316.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaBlocchiAnagrafiche');
  4317.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  4318.                 }
  4319.             } catch (\Exception|\Throwable $ex) {
  4320.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaBlocchiAnagrafiche');
  4321.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  4322.             }
  4323.         } else {
  4324.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaBlocchiAnagrafiche');
  4325.             return new Response("ERRORE PERMESSO");
  4326.         }
  4327.     } //OK
  4328.     /**
  4329.      * @Route("/caricaAttributiArticoli/{svuota}", name="carica_attributi_articoli", defaults={"svuota" = 0})
  4330.      */
  4331.     public function carticaAttributiArticoli(Request $request$svuota 0)
  4332.     {
  4333.         $collegamentoRnd $this->servizi->randomString2();
  4334.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  4335.             ini_set('max_execution_time', -1);
  4336.             ini_set('memory_limit''4G');
  4337.             $start microtime(true);
  4338.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  4339.             $em $this->servizi->doctrine->getManager();
  4340.             $repo $this->servizi->doctrine->getRepository(Attributi::class);
  4341.             $repoAssociazioneAtt $this->servizi->doctrine->getRepository(AssociazioneAttributi::class);
  4342.             $repoMappa $this->servizi->doctrine->getRepository(MappaCategorieArticoli::class);
  4343.             $repoArticoli $this->servizi->doctrine->getRepository(Articoli::class);
  4344.             $errori "";
  4345.             /** @var User|null $user */
  4346.             $user $this->servizi->OttieniUtenteCorrente();
  4347.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  4348.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  4349.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  4350.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  4351.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaAttributiArticoli --- Inizio l\' importazione dei dati' . ($svuota ' con svuotamento tabella' ''), null$collegamentoRnd'ImportazioneController''caricaAttributiArticoli');
  4352.             $errori "";
  4353.             $root_path $pathFileBase "attributi_articoli.csv";
  4354.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  4355.             $contatore 0;
  4356.             $row 0;
  4357.             $query_eseguite 0;
  4358.             $batch_size 100;
  4359.             $indiciPrimaRiga = array();
  4360.             try {
  4361.                 if (($handle fopen($root_path"r")) !== false) {
  4362.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  4363.                         var_dump("AAA PRIMA");
  4364.                         if ($row == 0) {
  4365.                             for($i 0$i count($data); $i++){
  4366.                                 $indiciPrimaRiga[$i] = $data[$i];
  4367.                             }
  4368.                             $row 1;
  4369.                             continue;
  4370.                         }
  4371.                         var_dump($indiciPrimaRiga);
  4372.                         if ($query_eseguite >= $batch_size) {
  4373.                             $contatore $contatore $row 1;
  4374.                             $row 1;
  4375.                             $query_eseguite 0;
  4376.                             $em->flush();
  4377.                             $em->clear();
  4378.                         }
  4379.                         try {
  4380.                             $articolo $repoArticoli->findOneBy(array('codice' => $data[0]));
  4381.                             if($articolo){
  4382.                                 $mappa $repoMappa->findOneBy(array('articolo' => $articolo'marca' => $data[1]));
  4383.                                 if($mappa){
  4384.                                     for($i 2$i count($indiciPrimaRiga) + 2$i++){
  4385.                                         if($data[$i] != '') {
  4386.                                             $attributo $repo->findOneBy(array('nome' => $indiciPrimaRiga[$i]));
  4387.                                             if (!$attributo) {
  4388.                                                 $attributo = new Attributi();
  4389.                                                 $attributo->setNome($indiciPrimaRiga[$i]);
  4390.                                                 $attributo->setTestoVisualizzato($indiciPrimaRiga[$i]);
  4391.                                                 $attributo->setCodiceIdentificativo($indiciPrimaRiga[$i]);
  4392.                                                 $attributo->setDataCreazione(new \DateTime());
  4393.                                                 $attributo->setDataModifica(new \DateTime());
  4394.                                                 $em->persist($attributo);
  4395.                                                 $em->flush();
  4396.                                             }
  4397.                                             $assAtt $repoAssociazioneAtt->findOneBy(array('mappaCategoriaArticolo' => $mappa'articolo' => $articolo'attributo' => $attributo));
  4398.                                             if (!$assAtt) {
  4399.                                                 $assAtt = new AssociazioneAttributi();
  4400.                                                 $assAtt->setDataCreazione(new \DateTime());
  4401.                                                 $assAtt->setDataModifica(new \DateTime());
  4402.                                                 $assAtt->setMappaCategoriaArticolo($mappa);
  4403.                                                 $assAtt->setArticolo($articolo);
  4404.                                                 $assAtt->setAttributo($attributo);
  4405.                                                 $assAtt->setValore(str_replace(',''.'$data[$i]));
  4406.                                                 $em->persist($assAtt);
  4407.                                                 $query_eseguite++;
  4408.                                             } else {
  4409.                                                 $assAtt->setDataModifica(new \DateTime());
  4410.                                                 $assAtt->setValore(str_replace(',''.'$data[$i]));
  4411.                                                 $em->persist($assAtt);
  4412.                                                 $query_eseguite++;
  4413.                                             }
  4414.                                         }
  4415.                                     }
  4416.                                 }else{
  4417.                                     $errori .= ('Errore carica attributi articoli! Mappa articolo con codice articolo: ' $data[0] . ' e marca: ' $data[1] . ' non trovata!<br/>');
  4418.                                 }
  4419.                             }else{
  4420.                                 $errori .= ('Errore carica attributi articoli! Articolo con codice: ' $data[0] . ' non trovato!<br/>');
  4421.                             }
  4422.                         } catch (\PDOException $ex) {
  4423.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAttributiArticoli');
  4424.                         } catch (\Exception|\Throwable $exception) {
  4425.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAttributiArticoli');
  4426.                         }
  4427.                         $row++;
  4428.                         $em->flush();
  4429.                     }
  4430.                 }else{
  4431.                     $errori .= "Impossibile aprire il file!";
  4432.                 }
  4433.                 $em->flush();
  4434.                 $row $contatore $row 1;
  4435.                 if ($errori == "") {
  4436.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaAttributiArticoli');
  4437.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  4438.                 } else {
  4439.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaAttributiArticoli');
  4440.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  4441.                 }
  4442.             } catch (\Exception|\Throwable $ex) {
  4443.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAttributiArticoli');
  4444.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  4445.             }
  4446.         } else {
  4447.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaAttributiArticoli');
  4448.             return new Response("ERRORE PERMESSO");
  4449.         }
  4450.     } //OK
  4451.     /**
  4452.      * @Route("/caricaVarianti", name="carica_varianti")
  4453.      */
  4454.     public function caricaVarianti(Request $request)
  4455.     {
  4456.         $collegamentoRnd $this->servizi->randomString2();
  4457.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  4458.             ini_set('max_execution_time'1200);
  4459.             ini_set('memory_limit''4G');
  4460.             $start microtime(true);
  4461.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  4462.             $em $this->servizi->doctrine->getManager();
  4463.             $repo $this->servizi->doctrine->getRepository(Varianti::class);
  4464.             $errori "";
  4465.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  4466.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  4467.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  4468.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  4469.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  4470.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaVarianti --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaVarianti');
  4471.             $errori "";
  4472.             $root_path $pathFileBase "articoli_varianti.csv";
  4473.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  4474.             $contatore 0;
  4475.             $row 0;
  4476.             $query_eseguite 0;
  4477.             $batch_size 50;
  4478.             /*  0    codice articolo
  4479.                 1    codice dimensione 01
  4480.                 2    descrizione dimensione 01
  4481.                 3    posizione dimensione 01
  4482.                 4    immagine dimensione 01
  4483.                 5    codice dimensione 02
  4484.                 6    descrizione dimensione 02
  4485.                 7    posizione dimensione 02
  4486.                 8    immagine dimensione 02
  4487.                 9    codice dimensione 02
  4488.                 10    descrizione dimensione 02
  4489.                 11    posizione dimensione 02
  4490.                 12    immagine dimensione 02
  4491.                 13    codice dimensione 02
  4492.                 14    descrizione dimensione 02
  4493.                 15    posizione dimensione 02
  4494.                 16    immagine dimensione 02
  4495.                 17    codice dimensione 02
  4496.                 18    descrizione dimensione 02
  4497.                 19    posizione dimensione 02
  4498.                 20    immagine dimensione 02
  4499.                 21    codice variante
  4500.                 22    disponibilita
  4501.                 23    operazione
  4502.                 24  um_peso
  4503.                 25    peso netto
  4504.                 26    peso lordo
  4505.              */
  4506.             $indici = array(
  4507.                 "codiceArticolo" => 0,
  4508.                 "codiceDimensione1" => 1,
  4509.                 "descrizioneDimenisone1" => 2,
  4510.                 "posizioneDimensione1" => 3,
  4511.                 "immagineDimensione1" => 4,
  4512.                 "codiceDimensione2" => 5,
  4513.                 "descrizioneDimenisone2" => 6,
  4514.                 "posizioneDimensione2" => 7,
  4515.                 "immagineDimensione2" => 8,
  4516.                 "codiceDimensione3" => 9,
  4517.                 "descrizioneDimenisone3" => 10,
  4518.                 "posizioneDimensione3" => 11,
  4519.                 "immagineDimensione3" => 12,
  4520.                 "codiceDimensione4" => 13,
  4521.                 "descrizioneDimenisone4" => 14,
  4522.                 "posizioneDimensione4" => 15,
  4523.                 "immagineDimensione4" => 16,
  4524.                 "codiceDimensione5" => 17,
  4525.                 "descrizioneDimenisone5" => 18,
  4526.                 "posizioneDimensione5" => 19,
  4527.                 "immagineDimensione5" => 20,
  4528.                 "codiceVariante" => 21,
  4529.                 "disponibilita" => 22,
  4530.                 "operazione" => 23,
  4531.                 "umPeso" => 24,
  4532.                 "pesoNetto" => 25,
  4533.                 "pesoLordo" => 26
  4534.             );
  4535.             try {
  4536.                 if (($handle fopen($root_path"r")) !== false) {
  4537.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  4538.                         if ($row == 0) {
  4539.                             $row 1;
  4540.                             continue;
  4541.                         }
  4542.                         if ($query_eseguite >= $batch_size) {
  4543.                             $contatore $contatore $row 1;
  4544.                             $row 1;
  4545.                             $query_eseguite 0;
  4546.                             $em->flush();
  4547.                             $em->clear();
  4548.                         }
  4549.                         $now = new \DateTime('now');
  4550.                         try {
  4551.                             $entita null;
  4552.                             $umPeso null;
  4553.                             if(count($data) >= 25) {
  4554.                                 $umPeso $this->servizi->doctrine->getRepository(UnitaMisura::class)->findOneBy(array('codice' => $data[$indici['umPeso']]));
  4555.                                 if (!$umPeso && $data[$indici['umPeso']] != '') {
  4556.                                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true"Nuova unita di misura peso trovata: " $data[20], null);
  4557.                                     $umPeso = new UnitaMisura();
  4558.                                     $umPeso->setDataCreazione(new \DateTime());
  4559.                                     $umPeso->setDataModifica(new \DateTime());
  4560.                                     $umPeso->setAttivo(true);
  4561.                                     $umPeso->setFattoreConversione(1);
  4562.                                     $umPeso->setCodice($data[20]);
  4563.                                     $umPeso->setNumeroDecimali(3);
  4564.                                     $em->persist($umPeso);
  4565.                                     $query_eseguite++;
  4566.                                 }
  4567.                             }
  4568.                             /** @var  $listaVarianti Varianti[] */
  4569.                             $listaVarianti $repo->createQueryBuilder('varianti')
  4570.                                 ->leftJoin('varianti.mappa''mappa')
  4571.                                 ->leftJoin('mappa.articolo''articolo')
  4572.                                 ->where('articolo.codice = :codArt')->setParameter('codArt'$data[$indici["codiceArticolo"]])
  4573.                                 ->andWhere('varianti.codiceVariante = :codVar')->setParameter('codVar'$data[$indici["codiceVariante"]])
  4574.                                 ->andWhere('varianti.codiceDimensione1 = :codDim1')->setParameter('codDim1'$data[$indici["codiceDimensione1"]])
  4575.                                 ->andWhere('varianti.codiceDimensione2 = :codDim2')->setParameter('codDim2'$data[$indici["codiceDimensione2"]])
  4576.                                 ->andWhere('varianti.codiceDimensione3 = :codDim3')->setParameter('codDim3'$data[$indici["codiceDimensione3"]])
  4577.                                 ->andWhere('varianti.codiceDimensione4 = :codDim4')->setParameter('codDim4'$data[$indici["codiceDimensione4"]])
  4578.                                 ->andWhere('varianti.codiceDimensione5 = :codDim5')->setParameter('codDim5'$data[$indici["codiceDimensione5"]])
  4579.                                 ->getQuery()->getResult();
  4580.                             if (count($listaVarianti) > 0) {
  4581.                                 $entita $listaVarianti[0];
  4582.                                 if ($data[$indici["operazione"]] == "E") {
  4583.                                     $entita->setDataModifica(new \DateTime());
  4584.                                     $entita->setAttivo(false);
  4585.                                     $em->persist($entita);
  4586.                                     $query_eseguite++;
  4587.                                 } else {
  4588.                                     $entita->setDescrizioneDimensione1($data[$indici["descrizioneDimenisone1"]]);
  4589.                                     $entita->setPosizioneDimensione1($data[$indici["posizioneDimensione1"]]);
  4590.                                     $entita->setImmagineDimensione1($data[$indici["immagineDimensione1"]]);
  4591.                                     $entita->setDescrizioneDimensione2($data[$indici["descrizioneDimenisone2"]]);
  4592.                                     $entita->setPosizioneDimensione2($data[$indici["posizioneDimensione2"]]);
  4593.                                     $entita->setImmagineDimensione2($data[$indici["immagineDimensione2"]]);
  4594.                                     $entita->setDescrizioneDimensione3($data[$indici["descrizioneDimenisone3"]]);
  4595.                                     $entita->setPosizioneDimensione3($data[$indici["posizioneDimensione3"]]);
  4596.                                     $entita->setImmagineDimensione3($data[$indici["immagineDimensione3"]]);
  4597.                                     $entita->setDescrizioneDimensione4($data[$indici["descrizioneDimenisone4"]]);
  4598.                                     $entita->setPosizioneDimensione4($data[$indici["posizioneDimensione4"]]);
  4599.                                     $entita->setImmagineDimensione4($data[$indici["immagineDimensione4"]]);
  4600.                                     $entita->setDescrizioneDimensione5($data[$indici["descrizioneDimenisone5"]]);
  4601.                                     $entita->setPosizioneDimensione5($data[$indici["posizioneDimensione5"]]);
  4602.                                     $entita->setImmagineDimensione5($data[$indici["immagineDimensione5"]]);
  4603.                                     $entita->setDisponibile(str_replace(',''.'$data[$indici["disponibilita"]]));
  4604.                                     $entita->setUmPeso($umPeso);
  4605.                                     $entita->setPesoNetto(str_replace(',''.', (count($data) >= 26 $data[$indici["pesoNetto"]] : 0)));
  4606.                                     $entita->setPesoLordo(str_replace(',''.', (count($data) >= 27 $data[$indici["pesoLordo"]] : 0)));
  4607.                                     $entita->setOrdiniFornitori(0);
  4608.                                     $entita->setAttivo(true);
  4609.                                     $entita->setDataModifica($now);
  4610.                                     $em->persist($entita);
  4611.                                     $mappa $entita->getMappa();
  4612.                                     $mappa->setVariantiPresenti(true);
  4613.                                     $em->persist($mappa);
  4614.                                     $query_eseguite += 2;
  4615.                                 }
  4616.                             } else {
  4617.                                 $listaMappe $this->servizi->doctrine->getRepository(MappaCategorieArticoli::class)->createQueryBuilder('mappa_categorie_articoli')
  4618.                                     ->leftJoin('mappa_categorie_articoli.articolo''articolo')
  4619.                                     ->where('articolo.codice = :cod')->setParameter('cod'$data[0])
  4620.                                     ->getQuery()->getResult();
  4621.                                 if (count($listaMappe) > 0) {
  4622.                                     /** @var MappaCategorieArticoli $mp */
  4623.                                     $mp $listaMappe[0];
  4624.                                     if (!$mp->getVariantiPresenti()) {
  4625.                                         $mp->setVariantiPresenti(true);
  4626.                                         $em->persist($mp);
  4627.                                         $query_eseguite++;
  4628.                                     }
  4629.                                     $entita = new Varianti();
  4630.                                     $entita->setMappa($listaMappe[0]);
  4631.                                     $entita->setCodiceVariante($data[$indici["codiceVariante"]]);
  4632.                                     $entita->setCodiceDimensione1($data[$indici["codiceDimensione1"]]);
  4633.                                     $entita->setDescrizioneDimensione1($data[$indici["descrizioneDimenisone1"]]);
  4634.                                     $entita->setPosizioneDimensione1($data[$indici["posizioneDimensione1"]]);
  4635.                                     $entita->setImmagineDimensione1($data[$indici["immagineDimensione1"]]);
  4636.                                     $entita->setCodiceDimensione2($data[$indici["codiceDimensione2"]]);
  4637.                                     $entita->setDescrizioneDimensione2($data[$indici["descrizioneDimenisone2"]]);
  4638.                                     $entita->setPosizioneDimensione2($data[$indici["posizioneDimensione2"]]);
  4639.                                     $entita->setImmagineDimensione2($data[$indici["immagineDimensione2"]]);
  4640.                                     $entita->setCodiceDimensione3($data[$indici["codiceDimensione3"]]);
  4641.                                     $entita->setDescrizioneDimensione3($data[$indici["descrizioneDimenisone3"]]);
  4642.                                     $entita->setPosizioneDimensione3($data[$indici["posizioneDimensione3"]]);
  4643.                                     $entita->setImmagineDimensione3($data[$indici["immagineDimensione3"]]);
  4644.                                     $entita->setCodiceDimensione4($data[$indici["codiceDimensione4"]]);
  4645.                                     $entita->setDescrizioneDimensione4($data[$indici["descrizioneDimenisone4"]]);
  4646.                                     $entita->setPosizioneDimensione4($data[$indici["posizioneDimensione4"]]);
  4647.                                     $entita->setImmagineDimensione4($data[$indici["immagineDimensione4"]]);
  4648.                                     $entita->setCodiceDimensione5($data[$indici["codiceDimensione5"]]);
  4649.                                     $entita->setDescrizioneDimensione5($data[$indici["descrizioneDimenisone5"]]);
  4650.                                     $entita->setPosizioneDimensione5($data[$indici["posizioneDimensione5"]]);
  4651.                                     $entita->setImmagineDimensione5($data[$indici["immagineDimensione5"]]);
  4652.                                     $entita->setDisponibile(str_replace(',''.'$data[$indici["disponibilita"]]));
  4653.                                     $entita->setUmPeso($umPeso);
  4654.                                     $entita->setAttivo(true);
  4655.                                     $entita->setPesoNetto(str_replace(',''.', (count($data) >= 26 $data[$indici["pesoNetto"]] : 0)));
  4656.                                     $entita->setPesoLordo(str_replace(',''.', (count($data) >= 27 $data[$indici["pesoLordo"]] : 0)));
  4657.                                     $entita->setOrdiniFornitori(0);
  4658.                                     $entita->setDataModifica($now);
  4659.                                     $entita->setDataCreazione($now);
  4660.                                     $em->persist($entita);
  4661.                                     $query_eseguite++;
  4662.                                 } else {
  4663.                                     $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione variante. Mappa con codice articolo: ' $data[$indici["codiceArticolo"]] . ' non trovata! 'null$collegamentoRnd'ImportazioneController''caricaVarianti');
  4664.                                 }
  4665.                             }
  4666.                         } catch (\PDOException $ex) {
  4667.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaVarianti');
  4668.                         } catch (\Exception|\Throwable $exception) {
  4669.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaVarianti');
  4670.                         }
  4671.                         $row++;
  4672.                         $em->flush();
  4673.                     }
  4674.                 }else{
  4675.                     $errori .= "Impossibile aprire il file!";
  4676.                 }
  4677.                 $em->flush();
  4678.                 $row $contatore $row 1;
  4679.                 if ($errori == "") {
  4680.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaVarianti');
  4681.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  4682.                 } else {
  4683.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaVarianti');
  4684.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  4685.                 }
  4686.             } catch (\Exception|\Throwable $ex) {
  4687.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaVarianti');
  4688.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  4689.             }
  4690.         } else {
  4691.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaVarianti');
  4692.             return new Response("ERRORE PERMESSO");
  4693.         }
  4694.     } //OK
  4695.     /**
  4696.      * @Route("/caricaPagamenti", name="carica_pagamenti")
  4697.      */
  4698.     public function caricaPagamenti(Request $request)
  4699.     {
  4700.         $collegamentoRnd $this->servizi->randomString2();
  4701.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  4702.             ini_set('max_execution_time'1200);
  4703.             ini_set('memory_limit''4G');
  4704.             $start microtime(true);
  4705.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  4706.             $em $this->servizi->doctrine->getManager();
  4707.             $repo $this->servizi->doctrine->getRepository(Pagamenti::class);
  4708.             $errori "";
  4709.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  4710.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  4711.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  4712.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  4713.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaPagamenti --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaPagamenti');
  4714.             $errori "";
  4715.             $root_path $pathFileBase "pagamenti.csv";
  4716.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  4717.             $contatore 0;
  4718.             $row 0;
  4719.             $query_eseguite 0;
  4720.             $batch_size 50;
  4721.             /*
  4722.              * 0    codice
  4723.                 1    descrizione
  4724.                 2    operazione
  4725.              */
  4726.             try {
  4727.                 if (($handle fopen($root_path"r")) !== false) {
  4728.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  4729.                         if ($row == 0) {
  4730.                             $row 1;
  4731.                             continue;
  4732.                         }
  4733.                         if ($query_eseguite >= $batch_size) {
  4734.                             $contatore $contatore $row 1;
  4735.                             $row 1;
  4736.                             $query_eseguite 0;
  4737.                             $em->flush();
  4738.                             $em->clear();
  4739.                         }
  4740.                         $now = new \DateTime('now');
  4741.                         try {
  4742.                             $entita null;
  4743.                             $nuovo false;
  4744.                             $entita $repo->findOneBy(array('codice' => $data[0]));
  4745.                             if (!$entita) {
  4746.                                 $entita = new Pagamenti();
  4747.                                 $nuovo true;
  4748.                             }
  4749.                             if ($data[2] == "E") {
  4750.                                 $em->remove($entita);
  4751.                                 $query_eseguite++;
  4752.                             } else {
  4753.                                 $entita->setCodice($data[0]);
  4754.                                 $entita->setNome($data[1]);
  4755.                                 $entita->setDescrizione($data[1]);
  4756.                                 $entita->setCodiceEsportazione($data[0]);
  4757.                                 $entita->setDataModifica($now);
  4758.                                 if ($nuovo)
  4759.                                     $entita->setDataCreazione($now);
  4760.                                 $em->persist($entita);
  4761.                                 $query_eseguite++;
  4762.                             }
  4763.                         } catch (\PDOException $ex) {
  4764.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaPagamenti');
  4765.                         } catch (\Exception|\Throwable $exception) {
  4766.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaPagamenti');
  4767.                         }
  4768.                         $row++;
  4769.                         $em->flush();
  4770.                     }
  4771.                 }else{
  4772.                     $errori .= "Impossibile aprire il file!";
  4773.                 }
  4774.                 $em->flush();
  4775.                 $row $contatore $row 1;
  4776.                 if ($errori == "") {
  4777.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaPagamenti');
  4778.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  4779.                 } else {
  4780.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaPagamenti');
  4781.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  4782.                 }
  4783.             } catch (\Exception|\Throwable $ex) {
  4784.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaPagamenti');
  4785.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  4786.             }
  4787.         } else {
  4788.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaPagamenti');
  4789.             return new Response("ERRORE PERMESSO");
  4790.         }
  4791.     } //OK
  4792.     /**
  4793.      * @Route("/caricaLimitazioneOrdinazioni", name="carica_limitazioni_ordinazioni")
  4794.      */
  4795.     public function caricaLimitazioneOrdinazioni(Request $request)
  4796.     {
  4797.         $collegamentoRnd $this->servizi->randomString2();
  4798.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  4799.             ini_set('max_execution_time'1200);
  4800.             ini_set('memory_limit''4G');
  4801.             $start microtime(true);
  4802.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  4803.             $em $this->servizi->doctrine->getManager();
  4804.             $repo $this->servizi->doctrine->getRepository(LimitazioniOrdinazioniArticoli::class);
  4805.             $errori "";
  4806.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  4807.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  4808.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  4809.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  4810.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaLimitazioneOrdinazioni --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaLimitazioneOrdinazioni');
  4811.             $errori "";
  4812.             $root_path $pathFileBase "limitazione_ordinazioni.csv";
  4813.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  4814.             $contatore 0;
  4815.             $row 0;
  4816.             $query_eseguite 0;
  4817.             $batch_size 50;
  4818.             /*
  4819.              *  0    codice_variante
  4820.                 1    identificativo_campo
  4821.                 2    nome
  4822.                 3    multipli_di
  4823.                 4    qta_minima
  4824.                 5    messaggio_errore
  4825.                 6    attivo
  4826.                 7    operazione
  4827.                 8   codice_articolo
  4828.              */
  4829.             try {
  4830.                 if (($handle fopen($root_path"r")) !== false) {
  4831.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  4832.                         if ($row == 0) {
  4833.                             $row 1;
  4834.                             continue;
  4835.                         }
  4836.                         $contatore++;
  4837.                         if ($query_eseguite >= $batch_size) {
  4838.                             $contatore $contatore $row 1;
  4839.                             $row 1;
  4840.                             $query_eseguite 0;
  4841.                             $em->flush();
  4842.                             $em->clear();
  4843.                         }
  4844.                         $now = new \DateTime('now');
  4845.                         try {
  4846.                             $entita null;
  4847.                             $nuovo false;
  4848.                             $variante $this->servizi->doctrine->getRepository(Varianti::class)->findOneBy(array('codiceVariante' => $data[0]));
  4849.                             if($variante) {
  4850.                                 $entita $repo->findOneBy(array('identificativoCampo' => $data[1]));
  4851.                                 if (!$entita) {
  4852.                                     $entita = new LimitazioniOrdinazioniArticoli();
  4853.                                     $nuovo true;
  4854.                                 }
  4855.                                 if ($data[7] == "E") {
  4856.                                     if ($data[0] != '') {
  4857.                                         $variante $this->servizi->doctrine->getRepository(Varianti::class)->findOneBy(array('codiceVariante' => $data[0]));
  4858.                                         if ($entita->getVarianti()->contains($variante->getId())){
  4859.                                             $entita->removeVarianti($variante);
  4860.                                             $em->persist($entita);
  4861.                                         }
  4862.                                     }else if (count($data) >= && $data[8] != '') {
  4863.                                         $articolo $this->servizi->doctrine->getRepository(Articoli::class)->findOneBy(array('codice' => $data[8]));
  4864.                                         if($entita->getArticoli()->contains($articolo->getId())){
  4865.                                             $entita->removeArticoli($articolo);
  4866.                                             $em->persist($entita);
  4867.                                         }
  4868.                                     }
  4869.                                     if($entita->getArticoli()->count() <= 0
  4870.                                         && $entita->getVarianti()->count() <= 0
  4871.                                         && $entita->getCategorie1()->count() <= 0
  4872.                                         && $entita->getCategorie2()->count() <= 0
  4873.                                         && $entita->getCategorie3()->count() <= 0
  4874.                                         && $entita->getCategorie4()->count() <= 0
  4875.                                         && $entita->getCategorie5()->count() <= 0
  4876.                                         && $entita->getMappeCategorieArticoli()->count() <= 0
  4877.                                     ){
  4878.                                         $em->remove($entita);
  4879.                                         $query_eseguite++;
  4880.                                     }
  4881.                                 } else {
  4882.                                     $variante null;
  4883.                                     $articolo null;
  4884.                                     if ($data[0] != '')
  4885.                                         $variante $this->servizi->doctrine->getRepository(Varianti::class)->findOneBy(array('codiceVariante' => $data[0]));
  4886.                                     if (count($data) >= && $data[8] != '')
  4887.                                         $articolo $this->servizi->doctrine->getRepository(Articoli::class)->findOneBy(array('codice' => $data[8]));
  4888.                                     if ($variante || $articolo) {
  4889.                                         if($variante){
  4890.                                             $entita->addVarianti($variante);
  4891.                                         } else if($articolo){
  4892.                                             $entita->addArticoli($articolo);
  4893.                                         }
  4894.                                         $entita->setIdentificativoCampo($data[1]);
  4895.                                         $entita->setNome($data[2]);
  4896.                                         $entita->setBloccaOrdinazioneSeEsaurito(false);
  4897.                                         $entita->setMultipliDi(str_replace(",""."$data[3]));
  4898.                                         $entita->setQtaMinima(str_replace(",""."$data[4]));
  4899.                                         if ($data[5] != "")
  4900.                                             $entita->setMessaggioErrore($data[5]);
  4901.                                         else
  4902.                                             $entita->setMessaggioErrore("Attenzione la quantità minima ordinabile Ã¨ di " number_format($entita->getQtaMinima(), 0) . "<br />sono ammessi solo multipli di " number_format($entita->getMultipliDi(), 0));
  4903.                                         $entita->setAttivo($data[6] == '1' true false);
  4904.                                         $entita->setDataModifica($now);
  4905.                                         if ($nuovo)
  4906.                                             $entita->setDataCreazione($now);
  4907.                                         $em->persist($entita);
  4908.                                         $query_eseguite++;
  4909.                                     } else {
  4910.                                         $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione limitazione ordinazione articoli - Variante articolo con codice variante: ' $data[0] . ' non trovata!'null$collegamentoRnd'ImportazioneController''caricaLimitazioneOrdinazioni');
  4911.                                     }
  4912.                                 }
  4913.                             }else{
  4914.                                 $errori .= ('Errore importazione (RIGA: ' $contatore ') : Variante con codice: ' $data[0] . ' non trovata!\n' );
  4915.                             }
  4916.                         } catch (\PDOException $ex) {
  4917.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione:  (RIGA: ' $contatore ') : ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaLimitazioneOrdinazioni');
  4918.                         } catch (\Exception|\Throwable $exception) {
  4919.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione:  (RIGA: ' $contatore ') : ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaLimitazioneOrdinazioni');
  4920.                         }
  4921.                         $row++;
  4922.                         $em->flush();
  4923.                     }
  4924.                 }else{
  4925.                     $errori .= "Impossibile aprire il file!";
  4926.                 }
  4927.                 $em->flush();
  4928.                 $row $contatore $row 1;
  4929.                 if ($errori == "") {
  4930.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaLimitazioneOrdinazioni');
  4931.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  4932.                 } else {
  4933.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaLimitazioneOrdinazioni');
  4934.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  4935.                 }
  4936.             } catch (\Exception|\Throwable $ex) {
  4937.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione:  (RIGA: ' $contatore ') : ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaLimitazioneOrdinazioni');
  4938.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  4939.             }
  4940.         } else {
  4941.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaLimitazioneOrdinazioni');
  4942.             return new Response("ERRORE PERMESSO");
  4943.         }
  4944.     } //OK
  4945.     /**
  4946.      * @Route("/caricaAnagraficheIndirizzi", name="carica_anagrafiche_indirizzi")
  4947.      */
  4948.     public function caricaAnagraficheIndirizzi(Request $request)
  4949.     {
  4950.         $collegamentoRnd $this->servizi->randomString2();
  4951.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  4952.             ini_set('max_execution_time'1200);
  4953.             ini_set('memory_limit''4G');
  4954.             $start microtime(true);
  4955.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  4956.             $em $this->servizi->doctrine->getManager();
  4957.             $repo $this->servizi->doctrine->getRepository(Anagrafiche::class);
  4958.             $repoIndirizzi $this->servizi->doctrine->getRepository(AnagraficheIndirizzi::class);
  4959.             $repoFosUser $this->servizi->doctrine->getRepository(User::class);
  4960.             $errori "";
  4961.             $this->imp->caricaCacheImpostazioniDaFamiglie(['Google']);
  4962.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  4963.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  4964.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  4965.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  4966.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaAnagraficheIndirizzi --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaAnagraficheIndirizzi');
  4967.             $errori "";
  4968.             $root_path $pathFileBase "anagrafiche_indirizzi.csv";
  4969.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  4970.             $contatore 0;
  4971.             $row 0;
  4972.             $query_eseguite 0;
  4973.             $batch_size 50;
  4974.             /*
  4975.              *  0    codice_cliente
  4976.                 1    tipo_indirizzo
  4977.                 2    ragione_sociale
  4978.                 3    indirizzo
  4979.                 4    cap
  4980.                 5    citta
  4981.                 6    provincia
  4982.                 7    nazione
  4983.                 8    latitudine
  4984.                 9    longitudine
  4985.                 10    operazione
  4986.              */
  4987.             try {
  4988.                 if (($handle fopen($root_path"r")) !== false) {
  4989.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  4990.                         if ($row == 0) {
  4991.                             $row 1;
  4992.                             continue;
  4993.                         }
  4994.                         if ($query_eseguite >= $batch_size) {
  4995.                             $contatore $contatore $row 1;
  4996.                             $row 1;
  4997.                             $query_eseguite 0;
  4998.                             $em->flush();
  4999.                             $em->clear();
  5000.                         }
  5001.                         $now = new \DateTime('now');
  5002.                         try {
  5003.                             $nuova false;
  5004.                             $indirizzo $repoIndirizzi->findOneBy(array('codice' => $data[0], 'tipoIndirizzo' => $data[1]));
  5005.                             if ($data[10] == "E"//trovata operazione E quindi devo eliminare la riga
  5006.                             {
  5007.                                 if ($indirizzo) {
  5008.                                     $em->remove($indirizzo);
  5009.                                     $query_eseguite++;
  5010.                                 }
  5011.                             } else {
  5012.                                 $clienteAttivoOnline $this->servizi->doctrine->getRepository(User::class)->findOneBy(array('codiceCliente' => $data[0]));
  5013.                                 if (!$indirizzo) {
  5014.                                     $indirizzo = new AnagraficheIndirizzi();
  5015.                                     $indirizzo->setCodice($data[0]);
  5016.                                     $indirizzo->setTipoIndirizzo($data[1]);
  5017.                                     $indirizzo->setDataCreazione($now);
  5018.                                 }
  5019.                                 $indirizzo->setRagioneSociale($data[2]);
  5020.                                 $indirizzo->setIndirizzo($data[3]);
  5021.                                 $indirizzo->setCap($data[4]);
  5022.                                 $indirizzo->setCitta($data[5]);
  5023.                                 $indirizzo->setProvincia($data[6]);
  5024.                                 $indirizzo->setNazione($data[7]);
  5025.                                 $indirizzo->setLatitudine(str_replace(",""."$data[8]));
  5026.                                 $indirizzo->setLongitudine(str_replace(",""."$data[9]));
  5027.                                 if($data[8] != '' && $data[8] != && $data[9] != '' && $data[9] != && $this->imp->ritornaImpostazioneDaNome('GoogleMapsAPIAttiva') == '1' && $this->imp->ritornaImpostazioneDaNome('GoogleMapsAPIRecuperaInAutomaticoImportAnagrafiche') == '1'){
  5028.                                     $gogl = new GoogleMapsAPI($this->imp$this->servizi);
  5029.                                     $latLon $gogl->OttieniLatitudineLongitudine($indirizzo->getIndirizzo() . ' ' $indirizzo->getCitta() . ' ' $indirizzo->getProvincia() . ' ' $indirizzo->getCap() . ' ' $indirizzo->getNazione());
  5030.                                     $indirizzo->setLatitudine($latLon['latitudine']);
  5031.                                     $indirizzo->setLongitudine($latLon['longitudine']);
  5032.                                 }
  5033.                                 $indirizzo->setDataModifica($now);
  5034.                                 $em->persist($indirizzo);
  5035.                                 $query_eseguite++;
  5036.                                 if ($clienteAttivoOnline) {
  5037.                                     //verifico se presente la destinazione altrimenti la creo
  5038.                                     $destinazione $this->servizi->doctrine->getRepository(Destinazioni::class)->findOneBy(array('azienda' => $clienteAttivoOnline'codiceGestionale' => $data[1]));
  5039.                                     if (!$destinazione) {
  5040.                                         $destinazione = new Destinazioni();
  5041.                                         $destinazione->setAzienda($clienteAttivoOnline);
  5042.                                         $destinazione->setUtente($clienteAttivoOnline);
  5043.                                         $destinazione->setCodiceGestionale($data[1]);
  5044.                                         $destinazione->setDataCreazione($now);
  5045.                                     }
  5046.                                     $destinazione->setRagioneSociale($data[2]);
  5047.                                     $destinazione->setEmail($clienteAttivoOnline->getEmail());
  5048.                                     $destinazione->setIndirizzo($data[3]);
  5049.                                     $destinazione->setCap($data[4]);
  5050.                                     $destinazione->setCitta($data[5]);
  5051.                                     $destinazione->setProvincia($data[6]);
  5052.                                     $destinazione->setStato($data[7]);
  5053.                                     $destinazione->setTelefono($clienteAttivoOnline->getTelefono());
  5054.                                     $destinazione->setDataModifica($now);
  5055.                                     $destinazione->setDenominazioneDestinazioneDiversa($data[1]);
  5056.                                     $destinazione->setUnivocoIndirizzo($data[1]);// codice AA perchè indirizzo base
  5057.                                     $em->persist($destinazione);
  5058.                                     $query_eseguite++;
  5059.                                 }
  5060.                             }
  5061.                         } catch (\PDOException $ex) {
  5062.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAnagraficheIndirizzi');
  5063.                         } catch (\Exception|\Throwable $exception) {
  5064.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAnagraficheIndirizzi');
  5065.                         }
  5066.                         $row++;
  5067.                         $em->flush();
  5068.                     }
  5069.                 }else{
  5070.                     $errori .= "Impossibile aprire il file!";
  5071.                 }
  5072.                 $em->flush();
  5073.                 $row $contatore $row 1;
  5074.                 if ($errori == "") {
  5075.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaAnagraficheIndirizzi');
  5076.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  5077.                 } else {
  5078.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaAnagraficheIndirizzi');
  5079.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  5080.                 }
  5081.             } catch (\Exception|\Throwable $ex) {
  5082.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAnagraficheIndirizzi');
  5083.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  5084.             }
  5085.         } else {
  5086.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaAnagraficheIndirizzi');
  5087.             return new Response("ERRORE PERMESSO");
  5088.         }
  5089.     } //OK
  5090.     /**
  5091.      * @Route("/caricaAnagrafiche/{svuota}", name="carica_anagrafiche", defaults={"svuota"="0"})
  5092.      */
  5093.     public function caricaAnagrafiche(Request $request$svuota)
  5094.     {
  5095.         $collegamentoRnd $this->servizi->randomString2();
  5096.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  5097.             ini_set('max_execution_time'1200);
  5098.             ini_set('memory_limit''4G');
  5099.             $this->imp->caricaCacheImpostazioniDaFamiglie(['Google']);
  5100.             $inviaMail $this->imp->ritornaImpostazioneDaNome("InviaMailNuoviClienti");
  5101.             $ccMail $this->imp->ritornaImpostazioneDaNome("MailCcComunicazioni");
  5102.             $from $this->imp->ritornaImpostazioneDaNome("IndirizzoMailFromInvioComunicazioni");
  5103.             $nomeShop $this->imp->ritornaImpostazioneDaNome("NomeShop");
  5104.             $start microtime(true);
  5105.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  5106.             $em $this->servizi->doctrine->getManager();
  5107.             $repo $this->servizi->doctrine->getRepository(Anagrafiche::class);
  5108.             $repoIndirizzi $this->servizi->doctrine->getRepository(AnagraficheIndirizzi::class);
  5109.             $repoFosUser $this->servizi->doctrine->getRepository(User::class);
  5110.             $repoSpedizione $this->servizi->doctrine->getRepository(Spedizione::class);
  5111.             $repoConsegna $this->servizi->doctrine->getRepository(Consegna::class);
  5112.             $errori "";
  5113.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  5114.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  5115.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  5116.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  5117.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaAnagrafiche/' $svuota ' --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5118.             switch ($svuota){
  5119.                 case "1":{ //Svuoto tutte le tabelle collegate
  5120.                     $em $this->servizi->doctrine->getManager();
  5121.                     $connection $this->servizi->doctrine->getConnection();
  5122.                     $connection->executeQuery("SET FOREIGN_KEY_CHECKS=0;");
  5123.                     $connection->executeQuery("TRUNCATE `anagrafica_opzioni_aggiuntive`;");
  5124.                     $connection->executeQuery("TRUNCATE `anagrafiche`;");
  5125.                     $connection->executeQuery("TRUNCATE `anagrafiche_indirizzi`;");
  5126.                     $connection->executeQuery("TRUNCATE `risorse_anagrafiche_colonne_valori`;");
  5127.                     $connection->executeQuery("TRUNCATE `risorse_anagrafiche`;");
  5128.                     $connection->executeQuery("TRUNCATE `risorse_anagrafiche_colonne`;");
  5129.                     $connection->executeQuery("TRUNCATE `sconti_anagrafiche`;");
  5130.                     $connection->executeQuery("TRUNCATE `anagrafiche_blocchi`;");
  5131.                     $connection->executeQuery("SET FOREIGN_KEY_CHECKS=1;");
  5132.                     break;
  5133.                 }
  5134.             }
  5135.             $errori "";
  5136.             $root_path $pathFileBase "anagrafiche.csv";
  5137.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  5138.             $contatore 0;
  5139.             $row 0;
  5140.             $query_eseguite 0;
  5141.             $batch_size 50;
  5142.             /*
  5143.              *  0    codice_cliente
  5144.                 1    ragione_sociale
  5145.                 2    indirizzo
  5146.                 3    cap
  5147.                 4    citta
  5148.                 5    provincia
  5149.                 6    nazione
  5150.                 7    codice_zona
  5151.                 8    descrizione_zona
  5152.                 9    telefono
  5153.                 10    fax
  5154.                 11    cellulare
  5155.                 12    sito_web
  5156.                 13    indirizzi_mail
  5157.                 14    codice_fiscale
  5158.                 15    partita_iva
  5159.                 16    codice_assoggettamento_fiscale
  5160.                 17    descrizione_assoggettamento_fiscale
  5161.                 18    codice_abi
  5162.                 19    codice_cab
  5163.                 20    iban
  5164.                 21    codice_pagamnto
  5165.                 22    descrizione_pagamento
  5166.                 23    sconto_commerciale
  5167.                 24    sconto_pagamento
  5168.                 25    codice_riclassifica_amm_1
  5169.                 26    descrizione_riclassifica_amministrativa_1
  5170.                 27    codice_spedizione
  5171.                 28    descrizione_spedizione
  5172.                 29    codice_consegna
  5173.                 30    descrizione_consegna
  5174.                 31    codice_agente
  5175.                 32    descrizione_agente
  5176.                 33    codice_canale_commerciale
  5177.                 34    descrizione_canale_commerciale
  5178.                 35    latitudine
  5179.                 36    longitudine
  5180.                 37    note_anagrafica
  5181.                 38    operazione
  5182.                 39    codice_listino
  5183.                 40    descrizione_listino
  5184.                 41    attiva_online
  5185.                 42    mail_attivazione_online
  5186.                 43  valore_aliquota_iva
  5187.                 44  codice_aliquota_iva
  5188.                 45  ruolo
  5189.                 46  associazione_codici_agenti_fornitori
  5190.                 47    andamento generale fatturato
  5191.                 48    importo_minimo_ordine
  5192.              */
  5193.             try {
  5194.                 if (($handle fopen($root_path"r")) !== false) {
  5195.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  5196.                         if ($row == 0) {
  5197.                             $row 1;
  5198.                             continue;
  5199.                         }
  5200.                         if ($query_eseguite >= $batch_size) {
  5201.                             $contatore $contatore $row 1;
  5202.                             $row 1;
  5203.                             $query_eseguite 0;
  5204.                             $em->flush();
  5205.                             $em->clear();
  5206.                         }
  5207.                         $now = new \DateTime('now');
  5208.                         try {
  5209.                             $nuova false;
  5210.                             $anagrafica $repo->findOneBy(array('codice' => $data[0]));
  5211.                             if ($data[38] == "E"//trovata operazione E quindi devo eliminare la riga
  5212.                             {
  5213.                                 if ($anagrafica) {
  5214.                                     $anagrafica->setAttivo(false);
  5215.                                     $anagrafica->setDataModifica(new \DateTime());
  5216.                                     $em->persist($anagrafica);
  5217.                                     $utente $this->servizi->doctrine->getRepository(User::class)->findOneBy(array('codiceCliente' => $data[0]));
  5218.                                     if ($utente) ;
  5219.                                     {
  5220.                                         $utente->setEnabled(false);
  5221.                                         $em->persist($utente);
  5222.                                         $query_eseguite++;
  5223.                                     }
  5224.                                     $query_eseguite++;
  5225.                                 }
  5226.                             }
  5227.                             if (!$anagrafica) {
  5228.                                 $anagrafica = new Anagrafiche();
  5229.                                 $nuova true;
  5230.                             }
  5231.                             $anagrafica->setCodice($data[0]);
  5232.                             $anagrafica->setRagioneSociale($data[1]);
  5233.                             $anagrafica->setIndirizzo($data[2]);
  5234.                             $anagrafica->setComune($data[4]);
  5235.                             $anagrafica->setProvincia($data[5]);
  5236.                             $anagrafica->setCap($data[3]);
  5237.                             $anagrafica->setNazione($data[6]);
  5238.                             $anagrafica->setCodiceZona($data[7]);
  5239.                             $anagrafica->setDescrizioneZona($data[8]);
  5240.                             $anagrafica->setTelefono($data[9]);
  5241.                             $anagrafica->setFax($data[10]);
  5242.                             $anagrafica->setCellulare($data[11]);
  5243.                             $anagrafica->setSitoWeb($data[12]);
  5244.                             $anagrafica->setIndirizziMail($data[13]);
  5245.                             $anagrafica->setCodiceFiscale($data[14]);
  5246.                             $anagrafica->setPartitaIva($data[15]);
  5247.                             $anagrafica->setCodiceAssoggettamentoFiscale($data[16]);
  5248.                             $anagrafica->setDescrizioneAssoggettamentoFiscale($data[17]);
  5249.                             $anagrafica->setCodiceAbi($data[18]);
  5250.                             $anagrafica->setCodiceCab($data[19]);
  5251.                             $anagrafica->setIban($data[20]);
  5252.                             $anagrafica->setCodicePagamento($data[21]);
  5253.                             $anagrafica->setDescrizionePagamento($data[22]);
  5254.                             $anagrafica->setScontoCommerciale(str_replace(',''.'$data[23] ? $data[23] : "0"));
  5255.                             $anagrafica->setScontoPagamento(str_replace(',''.'$data[24] ? $data[24] : "0"));
  5256.                             $anagrafica->setCodiceRiclassificaAmministrativa1($data[25]);
  5257.                             $anagrafica->setDescrizioneRiclassificaAmministrativa1($data[26]);
  5258.                             $anagrafica->setCodiceSpedizione($data[27]);
  5259.                             $anagrafica->setDescrizioneSpedizione($data[28]);
  5260.                             $anagrafica->setCodiceConsegna($data[29]);
  5261.                             $anagrafica->setDescrizioneConsegna($data[30]);
  5262.                             $anagrafica->setCodiceAgente($data[31]);
  5263.                             $anagrafica->setDescrizioneAgente($data[32]);
  5264.                             $anagrafica->setCodiceCanaleCommerciale($data[33]);
  5265.                             $anagrafica->setDescrizioneCanaleCommerciale($data[34]);
  5266.                             $anagrafica->setLatitudine(str_replace(',''.'$data[35] ? $data[35] : "0"));
  5267.                             $anagrafica->setLongitudine(str_replace(',''.'$data[36] ? $data[36] : "0"));
  5268.                             if($data[35] != '' && $data[35] != && $data[36] != '' && $data[36] != && $this->imp->ritornaImpostazioneDaNome('GoogleMapsAPIAttiva') == '1' && $this->imp->ritornaImpostazioneDaNome('GoogleMapsAPIRecuperaInAutomaticoImportAnagrafiche') == '1'){
  5269.                                 $gogl = new GoogleMapsAPI($this->imp$this->servizi);
  5270.                                 $latLon $gogl->OttieniLatitudineLongitudine($anagrafica->getIndirizzo() . ' ' $anagrafica->getComune() . ' ' $anagrafica->getProvincia() . ' ' $anagrafica->getCap() . ' ' $anagrafica->getNazione());
  5271.                                 $anagrafica->setLatitudine($latLon['latitudine']);
  5272.                                 $anagrafica->setLongitudine($latLon['longitudine']);
  5273.                             }
  5274.                             $anagrafica->setNoteAnagrafica($data[37]);
  5275.                             $anagrafica->setCodiceListinoVendita($data[39]);
  5276.                             $anagrafica->setDescrizioneListinoVendita($data[40]);
  5277.                             $anagrafica->setAttivo(true);
  5278.                             if(isset($data[43]))
  5279.                                 $anagrafica->setValoreAliquotaIva(str_replace(',''.'$data[43] ? $data[43] : "0"));
  5280.                             if(isset($data[44]))
  5281.                                 $anagrafica->setCodiceAliquotaIva($data[44]);
  5282.                             if(isset($data[45])) {
  5283.                                 $tipo strtoupper($data[44]);
  5284.                                 if(!in_array($tipo, ['COMMERCIALE''AGENTE''CLIENTE''FORNITORE'])){
  5285.                                     $tipo 'CLIENTE';
  5286.                                 }
  5287.                                 $anagrafica->setTipo($tipo);
  5288.                             }
  5289.                             if (isset($data[47])){
  5290.                                 $anagrafica->setAndamentoGeneraleFatturato(str_replace(',''.'$data[47] ? $data[43] : "0"));
  5291.                             }
  5292.                             if(!$anagrafica->getTipo())
  5293.                                 $anagrafica->setTipo('CLIENTE');
  5294.                             $now = new \DateTime('now');
  5295.                             if ($nuova)
  5296.                                 $anagrafica->setDataCreazione($now);
  5297.                             $anagrafica->setDataModifica($now);
  5298.                             $em->persist($anagrafica);
  5299.                             $query_eseguite++;
  5300.                             if ($data[41] == "1") { //devo attivarlo online
  5301.                                 $clienteOnline $repoFosUser->findOneBy(array('codiceCliente' => $anagrafica->getCodice()));
  5302.                                 if (!$clienteOnline) {
  5303.                                     $newPass $this->randomString(8);
  5304.                                     /** @var $clienteOnline User */
  5305.                                     $clienteOnline = new User();
  5306.                                     $clienteOnline->setCodiceCliente($data[0]);
  5307.                                     $clienteOnline->setRagioneSociale($data[1]);
  5308.                                     $clienteOnline->setEmail($data[42]);
  5309.                                     $clienteOnline->setIndirizzo($data[2]);
  5310.                                     $clienteOnline->setCap($data[3]);
  5311.                                     $clienteOnline->setCitta($data[4]);
  5312.                                     $clienteOnline->setProvincia($data[5]);
  5313.                                     $clienteOnline->setNazione($data[6]);
  5314.                                     $clienteOnline->setTelefono($data[9]);
  5315.                                     $clienteOnline->setCodiceFiscale($data[14]);
  5316.                                     $clienteOnline->setPartitaIva($data[15]);
  5317.                                     $clienteOnline->setCodiceListinoVendita($data[39]);
  5318.                                     $clienteOnline->setPassword($this->passwordHasher->hashPassword($clienteOnline$newPass));
  5319.                                     $clienteOnline->setUsername($data[0]);
  5320.                                     $clienteOnline->setEnabled(true);
  5321.                                     $clienteOnline->setRoles(array('ROLE_USER'));
  5322.                                     $clienteOnline->setAgente(false);
  5323.                                     $clienteOnline->setUtenteComune(false);
  5324.                                     $clienteOnline->setPrivato(false);
  5325.                                     $clienteOnline->setCommerciale(false);
  5326.                                     $clienteOnline->setCodiceAssoggettamentoFiscale($data[16]);
  5327.                                     if(isset($data[43]))
  5328.                                         $clienteOnline->setValoreAliquotaIva(str_replace(',''.'$data[43] ? $data[43] : "0"));
  5329.                                     if(isset($data[44]))
  5330.                                         $clienteOnline->setCodiceAliquotaIva($data[44]);
  5331.                                     if (isset($data[48]))
  5332.                                         $clienteOnline->setImportoImponibileMinimoOrdine(str_replace(',''.'$data[48] ? $data[48] : "-1"));
  5333.                                     $anagraficaDaMail $this->servizi->doctrine->getRepository(User::class)->findOneBy(array('email' => strtolower($data[42])));
  5334.                                     //Controllo esistenza di un'account con lo stesso indirizzo mail se Ã¨ presente annullo la registrazione e passo ad un altra riga
  5335.                                     if (!$anagraficaDaMail) {
  5336.                                         $em $this->servizi->doctrine->getManager();
  5337.                                         $em->persist($clienteOnline);
  5338.                                         $em->flush();
  5339.                                     } else {
  5340.                                         $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Anagrafica con codice: ' $data[0] . ' ----  indirizzo email: ' $data[42] . " già presente!"null);
  5341.                                         continue;
  5342.                                     }
  5343.                                     $adresses explode(";"$data[13]);
  5344.                                     $mailSecondarie $this->servizi->doctrine->getRepository(MailSecondarieUtenti::class);
  5345.                                     array_push($adresses$ccMail);
  5346.                                     foreach ($adresses as $item) {
  5347.                                         $ms = new MailSecondarieUtenti();
  5348.                                         $ms->setInviaConfermaOrdine(false);
  5349.                                         $ms->setUtenteModifica(null);
  5350.                                         $ms->setAzienda($clienteOnline);
  5351.                                         $ms->setDataModifica($now);
  5352.                                         $ms->setDataCreazione($now);
  5353.                                         $ms->setRuolo("");
  5354.                                         $ms->setNominativo("");
  5355.                                         $ms->setIndirizzoMail($item);
  5356.                                         $em->persist($ms);
  5357.                                     }
  5358.                                     $em->flush();
  5359.                                     unset($adresses[0]);
  5360.                                     //Associo il ruolo corretto e i vari codici agente associati
  5361.                                     if(count($data) > 46){
  5362.                                         if(strtoupper($data[45]) == 'AGENTE'){
  5363.                                             $clienteOnline->setRoles(array("ROLE_AGENTE"));
  5364.                                             $clienteOnline->setAgente(true);
  5365.                                             $em->persist($clienteOnline);
  5366.                                             $em->flush();
  5367.                                             if(isset($data[46])){
  5368.                                                 $elenco explode(','$data[46]);
  5369.                                                 if($elenco){
  5370.                                                     $assAg $this->servizi->doctrine->getRepository(AssociazioneCodiciAgentiUtente::class);
  5371.                                                     foreach ($elenco as $i){
  5372.                                                         $entitaAssAg = new AssociazioneCodiciAgentiUtente();
  5373.                                                         $entitaAssAg->setCodice($i);
  5374.                                                         $entitaAssAg->setDataCreazione(new \DateTime());
  5375.                                                         $entitaAssAg->setDataModifica(new \DateTime());
  5376.                                                         $entitaAssAg->setUtente($clienteOnline);
  5377.                                                         $em->persist($entitaAssAg);
  5378.                                                     }
  5379.                                                     $em->flush();
  5380.                                                 }
  5381.                                             }
  5382.                                         }
  5383.                                         elseif(strtoupper($data[45]) == 'COMMERCIALE'){
  5384.                                             $clienteOnline->setRoles(array("ROLE_COMMERCIALE"));
  5385.                                             $clienteOnline->setCommerciale(true);
  5386.                                             $em->persist($clienteOnline);
  5387.                                             $em->flush();
  5388.                                         }
  5389.                                         elseif (strtoupper($data[45] == "FORNITORE")){
  5390.                                             $clienteOnline->setRoles(array("ROLE_FORNITORE"));
  5391.                                             $clienteOnline->setCommerciale(false);
  5392.                                             $clienteOnline->setAgente(false);
  5393.                                             if(count($data) > 47) {
  5394.                                                 $clienteOnline->setCodiceFornitore($data[46]);
  5395.                                             }
  5396.                                             $em->persist($clienteOnline);
  5397.                                             $em->flush();
  5398.                                         }
  5399.                                     }
  5400.                                     $translator $this->translating;
  5401.                                     /** @var $clienteOnline User */
  5402.                                     if ($clienteOnline->getNazione() != 'IT') {
  5403.                                         $translator->CaricaTraduzioniDaFamiglia('mail_benvenuto''en');
  5404.                                     }else{
  5405.                                         $translator->CaricaTraduzioniDaFamiglia('mail_benvenuto''it');
  5406.                                     }
  5407.                                     try {
  5408.                                         if ($inviaMail) {
  5409.                                             $header $translator->OttieniElementoDizionario('mail_benvenuto_header_mail''mail_benvenuto')->valoreUscita;
  5410.                                             $mailer $this->mailer;
  5411.                                             $mailer->SendMail(
  5412.                                                 $header " " $nomeShop,
  5413.                                                 $this->renderView(
  5414.                                                     'email/registrazione/nuovo_inserimento.html.twig',
  5415.                                                     array(
  5416.                                                         'utente' => $clienteOnline,
  5417.                                                         'password' => $newPass
  5418.                                                     )
  5419.                                                 ),
  5420.                                                 $clienteOnline->getEmail(),
  5421.                                                 $adresses,
  5422.                                                 $from,
  5423.                                                 "text/html"
  5424.                                             );
  5425.                                         }
  5426.                                     } catch (\Exception|\Throwable $e) {
  5427.                                         $this->logger->critical("Errore invio mail: " $e->getMessage());
  5428.                                         $this->ScriviRegistroAttivita($em$request->getClientIp(), $e->getMessage(), true'Errore invio mail conferma inserimento nuova azienda ' $clienteOnline->getCodiceCliente() . '  -  ' $clienteOnline->getRagioneSociale() . ' all\'indirizzo ' $clienteOnline->getEmail() . " --- Errore: " $e->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5429.                                         $query_eseguite++;
  5430.                                     }
  5431.                                     $indirizzo_mail $data[13];
  5432.                                     if (!strpos($indirizzo_mail";") === false) {
  5433.                                         $indirizzi explode(";"$indirizzo_mail);
  5434.                                         $mailSecondarie $this->servizi->doctrine->getRepository(MailSecondarieUtenti::class);
  5435.                                         foreach ($indirizzi as $item) {
  5436.                                             if (!$mailSecondarie->findOneBy(array('azienda' => $clienteOnline'indirizzoMail' => $item))) {
  5437.                                                 $ms = new MailSecondarieUtenti();
  5438.                                                 $ms->setInviaConfermaOrdine(true);
  5439.                                                 $ms->setUtenteModifica(null);
  5440.                                                 $ms->setAzienda($clienteOnline);
  5441.                                                 $ms->setDataModifica($now);
  5442.                                                 $ms->setDataCreazione($now);
  5443.                                                 $ms->setRuolo("");
  5444.                                                 $ms->setNominativo("");
  5445.                                                 $ms->setIndirizzoMail($item);
  5446.                                                 $em->persist($ms);
  5447.                                             }
  5448.                                         }
  5449.                                         $indirizzo_mail $indirizzi[0];
  5450.                                     }
  5451.                                 }else{
  5452.                                     $clienteOnline->setRagioneSociale($data[1]);
  5453.                                     $clienteOnline->setIndirizzo($data[2]);
  5454.                                     $clienteOnline->setCap($data[3]);
  5455.                                     $clienteOnline->setCitta($data[4]);
  5456.                                     $clienteOnline->setProvincia($data[5]);
  5457.                                     $clienteOnline->setNazione($data[6]);
  5458.                                     $clienteOnline->setTelefono($data[9]);
  5459.                                     $clienteOnline->setCodiceFiscale($data[14]);
  5460.                                     $clienteOnline->setPartitaIva($data[15]);
  5461.                                     $clienteOnline->setCodiceListinoVendita($data[39]);
  5462.                                     $em->persist($clienteOnline);
  5463.                                 }
  5464.                                 if ($data[27] != "" && $data[29] != "") {
  5465.                                     $sped $repoSpedizione->findOneBy(array('codice' => $data[27]));
  5466.                                     $cons $repoConsegna->findOneBy(array('codice' => $data[29]));
  5467.                                     if (!$sped) {
  5468.                                         $sped = new Spedizione();
  5469.                                         $sped->setCodice($data[27]);
  5470.                                         $sped->setDescrizione($data[28]);
  5471.                                         $em->persist($sped);
  5472.                                         $query_eseguite++;
  5473.                                         $query_eseguite++;
  5474.                                         $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Spedizione con codice ' $sped->getCodice() . ' creata perchè inesistente!' $rownull$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5475.                                     }
  5476.                                     if (!$cons) {
  5477.                                         $cons = new Consegna();
  5478.                                         $cons->setCodice($data[29]);
  5479.                                         $cons->setDescrizione($data[30]);
  5480.                                         $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Consegna con codice ' $cons->getCodice() . ' creata perchè inesistente!' $rownull$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5481.                                         $em->persist($cons);
  5482.                                         $query_eseguite++;
  5483.                                         $query_eseguite++;
  5484.                                     }
  5485.                                     $ass $this->servizi->doctrine->getRepository(AssociazioneSpedizioniClienti::class)->findOneBy(['consegna' => $cons'spedizione' => $sped'azienda' => $clienteOnline]);
  5486.                                     if(!$ass){
  5487.                                         $ass = new AssociazioneSpedizioniClienti();
  5488.                                         $ass->setAzienda($clienteOnline);
  5489.                                         $ass->setConsegna($cons);
  5490.                                         $ass->setSpedizione($sped);
  5491.                                         $ass->setPrimaria(true);
  5492.                                         $em->persist($ass);
  5493.                                         $query_eseguite++;
  5494.                                     }
  5495.                                 }
  5496.                             }
  5497.                         } catch (\PDOException $ex) {
  5498.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5499.                         } catch (\Exception|\Throwable $exception) {
  5500.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5501.                         }
  5502.                         $row++;
  5503.                         $em->flush();
  5504.                     }
  5505.                 }else{
  5506.                     $errori .= "Impossibile aprire il file!";
  5507.                 }
  5508.                 $em->flush();
  5509.                 $row $contatore $row 1;
  5510.                 if ($errori == "") {
  5511.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5512.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  5513.                 } else {
  5514.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5515.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  5516.                 }
  5517.             } catch (\Exception|\Throwable $ex) {
  5518.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5519.                 return new Response('Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage());
  5520.             }
  5521.         } else {
  5522.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaAnagrafiche');
  5523.             return new Response("ERRORE PERMESSO");
  5524.         }
  5525.     } //OK
  5526.     /**
  5527.      * @Route("/caricaListiniVendita/{svuota}", name="carica_listini_vendita", defaults={"svuota"="0"})
  5528.      */
  5529.     public function caricaListiniVendita(Request $request$svuota)
  5530.     {
  5531.         $collegamentoRnd $this->servizi->randomString2();
  5532.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  5533.             ini_set('max_execution_time', -1);
  5534.             ini_set('memory_limit''4G');
  5535.             $start microtime(true);
  5536.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  5537.             $em $this->servizi->doctrine->getManager();
  5538.             $repo $this->servizi->doctrine->getRepository(ListiniVendita::class);
  5539.             $repoMappe $this->servizi->doctrine->getRepository(MappaCategorieArticoli::class);
  5540.             $repoVarianti $this->servizi->doctrine->getRepository(Varianti::class);
  5541.             $errori "";
  5542.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  5543.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  5544.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  5545.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  5546.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaListiniVendita/' $svuota ' --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5547.             $connection $this->servizi->doctrine->getConnection();
  5548.             if($svuota == "1"){
  5549.                 $em $this->servizi->doctrine->getManager();
  5550.                 $connection->beginTransaction();
  5551.                 try {
  5552.                     $connection->executeQuery("SET FOREIGN_KEY_CHECKS=0;");
  5553.                     $connection->executeQuery("TRUNCATE `listini_vendita`;");
  5554.                     $connection->executeQuery("SET FOREIGN_KEY_CHECKS=1;");
  5555.                     $connection->commit();
  5556.                 }catch (\Exception|\Throwable $ex){
  5557.                     $this->servizi->DebuggaException($ex"Errore pulizia listini vendita"falsenull$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5558.                 }
  5559.             }
  5560.             $errori "";
  5561.             $root_path $pathFileBase "articoli_listini_vendita.csv";
  5562.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  5563.             $contatore 0;
  5564.             $row 0;
  5565.             $query_eseguite 0;
  5566.             $batch_size 50;
  5567.             /*
  5568.              *  0    codice listino
  5569.                 1    descrizione listino
  5570.                 2    codice_anagrafica
  5571.                 3    codice articolo
  5572.                 4    codice variante
  5573.                 5    prezzo
  5574.                 6    operazione
  5575.                 7    flag_prezzo_netto
  5576.                 8    codice_cat_1
  5577.                 9    codice_cat_2
  5578.                 10    codice_cat_3
  5579.                 11    codice_cat_4
  5580.                 12    codice_cat_5
  5581.                 13    marca
  5582.                 14  costo
  5583.                 15  codice_tipo_ordine
  5584.                 16  chiave_esterna
  5585.              */
  5586.             $indici = array(
  5587.                 'codiceListino' => 0,
  5588.                 'descrizioneListino' => 1,
  5589.                 'codiceAnagrafica' => 2,
  5590.                 'codiceArticolo' => 3,
  5591.                 'codiceVariante' => 4,
  5592.                 'prezzo' => 5,
  5593.                 'flagPrezzoNetto' => 7,
  5594.                 'operazione' => 6,
  5595.                 'cat1' => 8,
  5596.                 'cat2' => 9,
  5597.                 'cat3' => 10,
  5598.                 'cat4' => 11,
  5599.                 'cat5' => 12,
  5600.                 'marca' => 13,
  5601.                 'costo' => 14,
  5602.                 'codiceTipoOrdine' => 15,
  5603.                 'chiaveEsterna' => 16
  5604.             );
  5605.             try {
  5606.                 if (($handle fopen($root_path"r")) !== false) {
  5607.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  5608.                         if ($row == 0) {
  5609.                             $row 1;
  5610.                             continue;
  5611.                         }
  5612.                         if ($query_eseguite >= $batch_size) {
  5613.                             $contatore $contatore $row 1;
  5614.                             $row 1;
  5615.                             $query_eseguite 0;
  5616.                             $em->flush();
  5617.                             $em->clear();
  5618.                         }
  5619.                         $now = new \DateTime('now');
  5620.                         try {
  5621.                             $listaMappe $repoMappe->createQueryBuilder('mappa_categorie_articoli')
  5622.                                 ->leftJoin('mappa_categorie_articoli.articolo''articolo')
  5623.                                 ->leftJoin('mappa_categorie_articoli.categoria1''cat1')
  5624.                                 ->leftJoin('mappa_categorie_articoli.categoria2''cat2')
  5625.                                 ->leftJoin('mappa_categorie_articoli.categoria3''cat3')
  5626.                                 ->leftJoin('mappa_categorie_articoli.categoria4''cat4')
  5627.                                 ->leftJoin('mappa_categorie_articoli.categoria5''cat5')
  5628.                                 ->where('articolo.codice = :cod')->setParameter('cod'$data[$indici['codiceArticolo']]);
  5629.                             if ($data[$indici['cat1']] != '') {
  5630.                                 $listaMappe->andWhere('cat1.codice = :cat1')->setParameter('cat1'$data[$indici['cat1']]);
  5631.                             }
  5632.                             if ($data[$indici['cat2']] != '') {
  5633.                                 $listaMappe->andWhere('cat2.codice = :cat2')->setParameter('cat2'$data[$indici['cat2']]);
  5634.                             }
  5635.                             if ($data[$indici['cat3']] != '') {
  5636.                                 $listaMappe->andWhere('cat3.codice = :cat3')->setParameter('cat3'$data[$indici['cat3']]);
  5637.                             }
  5638.                             if ($data[$indici['cat4']] != '') {
  5639.                                 $listaMappe->andWhere('cat4.codice = :cat4')->setParameter('cat4'$data[$indici['cat4']]);
  5640.                             }
  5641.                             if ($data[$indici['cat5']] != '') {
  5642.                                 $listaMappe->andWhere('cat5.codice = :cat5')->setParameter('cat5'$data[$indici['cat5']]);
  5643.                             }
  5644.                             if ($data[$indici['marca']] != '') {
  5645.                                 $listaMappe->andWhere('mappa_categorie_articoli.marca = :marca')->setParameter('marca'$data[$indici['marca']]);
  5646.                             }
  5647.                             $listaMappe $listaMappe->getQuery()->getResult();
  5648.                             if (count($listaMappe) > 0) {
  5649.                                 /** @var MappaCategorieArticoli $mappa */
  5650.                                 $mappa $listaMappe[0];
  5651.                                 $codiceTipoOrdine null;
  5652.                                 if (count($data) > $indici['codiceTipoOrdine'] && $data[$indici['codiceTipoOrdine']] != '')
  5653.                                 {
  5654.                                     $codiceTipoOrdine $this->servizi->doctrine->getRepository(TipoOrdine::class)->findOneBy(array('codice' => $data[$indici['codiceTipoOrdine']]));
  5655.                                     if(!$codiceTipoOrdine)
  5656.                                     {
  5657.                                         $errori .= ('Errore importazione listino (RIGA: ' $contatore ') : - Codice Listino: ' $data[$indici['codiceListino']] . ' - Codice Articolo: ' $data[$indici['codiceArticolo']] . ' - Codice Variante: ' $data[$indici['codiceVariante']] . ' - Tipo ordine: ' $data[$indici['codiceTipoOrdine']] . '  ERRORE: TIPO ORDINE NON TROVATO<br/>');
  5658.                                         continue;
  5659.                                     }
  5660.                                 }
  5661.                                 if ($data[$indici['codiceVariante']] != '') {
  5662.                                     $listaVarianti $repoVarianti->createQueryBuilder('varianti')
  5663.                                         ->where('varianti.mappa = :mappa')->setParameter('mappa'$mappa)
  5664.                                         ->andWhere('varianti.codiceVariante = :codvar')->setParameter('codvar'$data[$indici["codiceVariante"]])
  5665.                                         ->getQuery()->getResult();
  5666.                                     if (count($listaVarianti) > 0) {
  5667.                                         $variante $listaVarianti[0];
  5668.                                         $array = array(
  5669.                                             'variante' => $variante,
  5670.                                             'codiceListino' => $data[$indici['codiceListino']],
  5671.                                             'mappaCategorieArticoli' => $mappa,
  5672.                                             'tipoOrdine' => $codiceTipoOrdine
  5673.                                         );
  5674.                                         if ($data[$indici['codiceAnagrafica']] != '') {
  5675.                                             $array['codiceAnagrafica'] = $data[$indici['codiceAnagrafica']];
  5676.                                         }
  5677.                                         /** @var ListiniVendita $listino */
  5678.                                         $listino $repo->findOneBy($array);
  5679.                                         if ($listino) {
  5680.                                             if ($data[$indici['operazione']] == 'E') {
  5681.                                                 $em->remove($listino);
  5682.                                                 $query_eseguite++;
  5683.                                             } else {
  5684.                                                 $listino->setPrezzo(ServiziController::convertiInNumero($data[$indici["prezzo"]]));
  5685.                                                 $listino->setFlagPrezzoNetto($data[$indici['flagPrezzoNetto']]);
  5686.                                                 $listino->setCodiceAnagrafica($data[$indici["codiceAnagrafica"]]);
  5687.                                                 $listino->setTipoOrdine($codiceTipoOrdine);
  5688.                                                 if(count($data) > $indici['costo'] && $data[$indici['costo']] != '') {
  5689.                                                     $listino->setCosto(ServiziController::convertiInNumero($data[$indici["costo"]]));
  5690.                                                 }
  5691.                                                 if (count($data) > $indici['chiaveEsterna'])
  5692.                                                     $listino->setChiaveEsterna($data[$indici['chiaveEsterna']]);
  5693.                                                 $listino->setDataModifica($now);
  5694.                                                 $em->persist($listino);
  5695.                                                 $query_eseguite++;
  5696.                                             }
  5697.                                         } else {
  5698.                                             $listino = new ListiniVendita();
  5699.                                             $listino->setVariante($variante);
  5700.                                             $listino->setCodiceListino($data[$indici["codiceListino"]]);
  5701.                                             $listino->setPrezzo(ServiziController::convertiInNumero($data[$indici["prezzo"]]));
  5702.                                             $listino->setFlagPrezzoNetto($data[$indici['flagPrezzoNetto']]);
  5703.                                             $listino->setMappaCategorieArticoli($mappa);
  5704.                                             $listino->setTipoOrdine($codiceTipoOrdine);
  5705.                                             $listino->setCodiceAnagrafica($data[$indici["codiceAnagrafica"]]);
  5706.                                             $listino->setDataCreazione($now);
  5707.                                             $listino->setDataModifica($now);
  5708.                                             if(count($data) > $indici['costo'] && $data[$indici['costo']] != '') {
  5709.                                                 $listino->setCosto(ServiziController::convertiInNumero($data[$indici["costo"]]));
  5710.                                             }
  5711.                                             if (count($data) > $indici['chiaveEsterna'])
  5712.                                                 $listino->setChiaveEsterna($data[$indici['chiaveEsterna']]);
  5713.                                             $em->persist($listino);
  5714.                                             $query_eseguite++;
  5715.                                         }
  5716.                                     } else {
  5717.                                         $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione listino - Codice Listino: ' $data[$indici['codiceListino']] . ' - Codice Articolo: ' $data[$indici['codiceArticolo']] . ' - Codice Variante: ' $data[$indici['codiceVariante']] . ' ERRORE: VARIANTE NON TROVATA'null$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5718.                                     }
  5719.                                 } else {
  5720.                                     /** @var  $listino ListiniVendita */
  5721.                                     $array = array(
  5722.                                         'variante' => null,
  5723.                                         'codiceListino' => $data[$indici['codiceListino']],
  5724.                                         'mappaCategorieArticoli' => $mappa,
  5725.                                         'tipoOrdine' => $codiceTipoOrdine
  5726.                                     );
  5727.                                     if ($data[$indici['codiceAnagrafica']] != '') {
  5728.                                         $array['codiceAnagrafica'] = $data[$indici['codiceAnagrafica']];
  5729.                                     }
  5730.                                     $listino $repo->findOneBy($array);
  5731.                                     if ($listino) {
  5732.                                         if ($data[$indici['operazione']] == "E") {
  5733.                                             $em->remove($listino);
  5734.                                             $query_eseguite++;
  5735.                                         } else {
  5736.                                             $listino->setPrezzo(ServiziController::convertiInNumero($data[$indici["prezzo"]]));
  5737.                                             $listino->setFlagPrezzoNetto($data[$indici['flagPrezzoNetto']]);
  5738.                                             $listino->setCodiceAnagrafica($data[$indici["codiceAnagrafica"]]);
  5739.                                             $listino->setDataModifica($now);
  5740.                                             $listino->setTipoOrdine($codiceTipoOrdine);
  5741.                                             if(count($data) > $indici['costo']){
  5742.                                                 $listino->setCosto(ServiziController::convertiInNumero($data[$indici["costo"]]));
  5743.                                             }
  5744.                                             if (count($data) > $indici['chiaveEsterna'])
  5745.                                                 $listino->setChiaveEsterna($data[$indici['chiaveEsterna']]);
  5746.                                             $em->persist($listino);
  5747.                                             $query_eseguite++;
  5748.                                         }
  5749.                                     } else {
  5750.                                         $listino = new ListiniVendita();
  5751.                                         $listino->setVariante(null);
  5752.                                         $listino->setCodiceListino($data[$indici["codiceListino"]]);
  5753.                                         $listino->setPrezzo(ServiziController::convertiInNumero($data[$indici["prezzo"]]));
  5754.                                         $listino->setFlagPrezzoNetto($data[$indici['flagPrezzoNetto']]);
  5755.                                         $listino->setMappaCategorieArticoli($mappa);
  5756.                                         $listino->setTipoOrdine($codiceTipoOrdine);
  5757.                                         $listino->setCodiceAnagrafica($data[$indici["codiceAnagrafica"]]);
  5758.                                         $listino->setDataCreazione($now);
  5759.                                         $listino->setDataModifica($now);
  5760.                                         if(count($data) > $indici['costo']){
  5761.                                             $listino->setCosto(ServiziController::convertiInNumero($data[$indici["costo"]]));
  5762.                                         }
  5763.                                         if (count($data) > $indici['chiaveEsterna'])
  5764.                                             $listino->setChiaveEsterna($data[$indici['chiaveEsterna']]);
  5765.                                         $em->persist($listino);
  5766.                                         $query_eseguite++;
  5767.                                     }
  5768.                                 }
  5769.                             } else {
  5770.                                 $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione listino (RIGA: ' . ($contatore $row) . ') : - Codice Listino: ' $data[$indici['codiceListino']] . ' - Codice Articolo: ' $data[$indici['codiceArticolo']] . ' - Codice Variante: ' $data[$indici['codiceVariante']] . ' ERRORE: MAPPA NON TROVATA'null$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5771.                                 $errori .= 'Errore importazione listino (RIGA: ' . ($contatore $row)  . ') : - Codice Listino: ' $data[$indici['codiceListino']] . ' - Codice Articolo: ' $data[$indici['codiceArticolo']] . ' - Codice Variante: ' $data[$indici['codiceVariante']] . ' ERRORE: MAPPA NON TROVATA<br/>';
  5772.                             }
  5773.                         } catch (\PDOException $ex) {
  5774.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5775.                         } catch (\Exception|\Throwable $exception) {
  5776.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5777.                         }
  5778.                         $row++;
  5779.                         $em->flush();
  5780.                     }
  5781.                 }else{
  5782.                     $errori .= "Impossibile aprire il file!";
  5783.                 }
  5784.                 $em->flush();
  5785.                 $row $contatore $row 1;
  5786.                 if ($errori == "") {
  5787.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5788.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  5789.                 } else {
  5790.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5791.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  5792.                 }
  5793.             } catch (\Exception|\Throwable $ex) {
  5794.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5795.                 return new Response('Errore importazione: ' $ex->getMessage() . '<br/>' $ex->getTraceAsString());
  5796.             }
  5797.         } else {
  5798.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaListiniVendita');
  5799.             return new Response("ERRORE PERMESSO");
  5800.         }
  5801.     } //OK
  5802.     /**
  5803.      * @Route("/caricaOfferte", name="carica_offerte")
  5804.      */
  5805.     public function caricaOfferte(Request $request)
  5806.     {
  5807.         $collegamentoRnd $this->servizi->randomString2();
  5808.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  5809.             ini_set('max_execution_time'1200);
  5810.             ini_set('memory_limit''4G');
  5811.             $start microtime(true);
  5812.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  5813.             $em $this->servizi->doctrine->getManager();
  5814.             $repo $this->servizi->doctrine->getRepository(Offerte::class);
  5815.             $repoAnagrafica $this->servizi->doctrine->getRepository(Anagrafiche::class);
  5816.             $errori "";
  5817.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  5818.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  5819.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  5820.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  5821.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaOfferte --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaOfferte');
  5822.             $errori "";
  5823.             $root_path $pathFileBase "offerte.csv";
  5824.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  5825.             $contatore 0;
  5826.             $row 0;
  5827.             $query_eseguite 0;
  5828.             $batch_size 50;
  5829.             /*
  5830.              *  0    codice_cliente
  5831.                 1    ragione_sociale
  5832.                 2    descrizione_breve
  5833.                 3    descrizione_lunga
  5834.                 4    data_documento
  5835.                 5    importo
  5836.                 6    stato
  5837.                 7    documento
  5838.                 8    numero
  5839.                 9    anno
  5840.                 10    moneta
  5841.                 11    importante
  5842.                 12    path_pdf_originale
  5843.                 13    operazione
  5844.              */
  5845.             $indici = array(
  5846.                 'codiceCliente' => 0,
  5847.                 'ragioneSociale' => 1,
  5848.                 'descrizioneBreve' => 2,
  5849.                 'descrizioneLunga' => 3,
  5850.                 'dataDocumento' => 4,
  5851.                 'importo' => 5,
  5852.                 'stato' => 6,
  5853.                 'documento' => 7,
  5854.                 'numero' => 8,
  5855.                 'anno' => 9,
  5856.                 'moneta' => 10,
  5857.                 'importante' => 11,
  5858.                 'pathPdfOriginale' => 12,
  5859.                 'operazione' => 13
  5860.             );
  5861.             try {
  5862.                 if (($handle fopen($root_path"r")) !== false) {
  5863.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  5864.                         if ($row == 0) {
  5865.                             $row 1;
  5866.                             continue;
  5867.                         }
  5868.                         if ($query_eseguite >= $batch_size) {
  5869.                             $contatore $contatore $row 1;
  5870.                             $row 1;
  5871.                             $query_eseguite 0;
  5872.                             $em->flush();
  5873.                             $em->clear();
  5874.                         }
  5875.                         $now = new \DateTime('now');
  5876.                         try {
  5877.                             //Verifico se presente già un offerte
  5878.                             $offerta $repo->findOneBy(array('documento' => $data[$indici['documento']], 'numero' => $data[$indici['numero']], 'anno' => $data[$indici['anno']]));
  5879.                             if($offerta){
  5880.                                 if($data[$indici['operazione']] == 'E'){
  5881.                                     foreach ($offerta->getAllegati() as $all)
  5882.                                         $em->remove($all);
  5883.                                     foreach ($offerta->getContattiClienti() as $cont)
  5884.                                         $em->remove($cont);
  5885.                                     foreach ($offerta->getRegistroEventi() as $reg)
  5886.                                         $em->remove($reg);
  5887.                                     $em->remove($offerta);
  5888.                                     $query_eseguite++;
  5889.                                 }else if ($data[$indici['operazione']] != 'E'){
  5890.                                     $offerta->setDataModifica($now);
  5891.                                 }
  5892.                             }else if ($data[$indici['operazione']] != 'E'){
  5893.                                 $offerta = new Offerte();
  5894.                                 $offerta->setDataCreazione($now);
  5895.                                 $offerta->setDataModifica($now);
  5896.                                 $offerta->setDocumento($data[$indici['documento']]);
  5897.                                 $offerta->setNumero($data[$indici['numero']]);
  5898.                                 $offerta->setAnno($data[$indici['anno']]);
  5899.                             }
  5900.                             if($data[$indici['operazione']] != 'E'){
  5901.                                 $offerta->setCodiceCliente($data[$indici['codiceCliente']]);
  5902.                                 $offerta->setRagioneSociale($data[$indici['ragioneSociale']]);
  5903.                                 $offerta->setDescrizioneBreve($data[$indici['descrizioneBreve']]);
  5904.                                 $offerta->setDescrizioneLunga($data[$indici['descrizioneLunga']]);
  5905.                                 $offerta->setDataDocumento(ServiziController::convertiInDatetime($data[$indici['dataDocumento']], false'Y-m-d'));
  5906.                                 $offerta->setImporto(ServiziController::convertiInNumero($data[$indici['importo']]));
  5907.                                 $offerta->setStato($data[$indici['stato']]);
  5908.                                 $collegamentoAnagrafica $repoAnagrafica->findOneBy(array('codice' => $offerta->getCodiceCliente()));
  5909.                                 $offerta->setCollegamentoAnagrafica($collegamentoAnagrafica);
  5910.                                 $offerta->setMoneta($data[$indici['moneta']]);
  5911.                                 $offerta->setImportante($data[$indici['importante']] == true false);
  5912.                                 $offerta->setPathPdfOriginale($data[$indici['pathPdfOriginale']]);
  5913.                                 $em->persist($offerta);
  5914.                                 $query_eseguite++;
  5915.                             }
  5916.                         } catch (\PDOException $ex) {
  5917.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferte');
  5918.                         } catch (\Exception|\Throwable $exception) {
  5919.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferte');
  5920.                         }
  5921.                         $row++;
  5922.                     }
  5923.                 }else{
  5924.                     $errori .= "Impossibile aprire il file!";
  5925.                 }
  5926.                 $em->flush();
  5927.                 $row $contatore $row 1;
  5928.                 if ($errori == "") {
  5929.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaOfferte');
  5930.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  5931.                 } else {
  5932.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaOfferte');
  5933.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  5934.                 }
  5935.             } catch (\Exception|\Throwable $ex) {
  5936.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferte');
  5937.                 return new Response('Errore importazione: ' $ex->getMessage());
  5938.             }
  5939.         } else {
  5940.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaOfferte');
  5941.             return new Response("ERRORE PERMESSO");
  5942.         }
  5943.     } //OK
  5944.     /**
  5945.      * @Route("/caricaDocumenti/{svuota}", name="carica_documenti", defaults={"svuota"="0"})
  5946.      */
  5947.     public function caricaDocumenti(Request $request$svuota "0")
  5948.     {
  5949.         $collegamentoRnd $this->servizi->randomString2();
  5950.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  5951.             ini_set('max_execution_time', -1);
  5952.             ini_set('memory_limit''4G');
  5953.             $start microtime(true);
  5954.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  5955.             $em $this->servizi->doctrine->getManager();
  5956.             $repo $this->servizi->doctrine->getRepository(Documenti::class);
  5957.             $repoAnagrafiche $this->servizi->doctrine->getRepository(Anagrafiche::class);
  5958.             $errori "";
  5959.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  5960.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  5961.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  5962.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaDocumenti/' $svuota ' --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaDocumenti');
  5963.             $connection $this->servizi->doctrine->getConnection();
  5964.             if($svuota == "1"){
  5965.                 $em $this->servizi->doctrine->getManager();
  5966.                 $connection->beginTransaction();
  5967.                 try {
  5968.                     $connection->query("SET FOREIGN_KEY_CHECKS=0;");
  5969.                     $connection->executeUpdate("TRUNCATE `documenti`;");
  5970.                     $connection->executeUpdate("TRUNCATE `documenti_righe`;");
  5971.                     $connection->query("SET FOREIGN_KEY_CHECKS=1;");
  5972.                     $connection->commit();
  5973.                 }catch (\Exception|\Throwable $ex){
  5974.                     $this->servizi->DebuggaException($ex"Errore pulizia documenti e documenti_righe DB"falsenull$collegamentoRnd'ImportazioneController''caricaDocumenti');
  5975.                 }
  5976.             }
  5977.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  5978.             $errori "";
  5979.             $root_path $pathFileBase "documenti.csv";
  5980.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  5981.             $contatore 0;
  5982.             $row 0;
  5983.             $query_eseguite 0;
  5984.             $batch_size 50;
  5985.             /*
  5986.             0    identificativo    Identificativo univoco documento
  5987.             1    documento
  5988.             2    anno
  5989.             3    data_documento    2021-12-31
  5990.             4    numero
  5991.             5    numero_fattura
  5992.             6    data_fattura    2021-12-31
  5993.             7    numero_ddt
  5994.             8    data_ddt    2021-12-31
  5995.             9    agente
  5996.             10    codice_anagrafica
  5997.             11    tipo_anagrafica    cliente/fornitore/agente/altro
  5998.             12    ragione_sociale
  5999.             13    indirizzo
  6000.             14    citta
  6001.             15    provincia
  6002.             16    cap
  6003.             17    regione
  6004.             18    codice_fiscale
  6005.             19    partita_iva
  6006.             20    modalita_pagamento
  6007.             21    modalita_spedizione
  6008.             22    modalita_consegna
  6009.             23    totale_documento_netto    decimal(18,5)
  6010.             24    totale_costo_netto    decimal(18,5)
  6011.             25    zona
  6012.             26    mercato
  6013.             27    sub_agente
  6014.             28    capo_area
  6015.             29    nome_file_pdf_documento
  6016.             30    nome_file_pdf_fattura
  6017.             31    nome_file_pdf_ddt
  6018.             32    stato_avanzamento
  6019.             33    indirizzo_tracking_corriere
  6020.             34    utente
  6021.             35    data_consegna    2021-12-31
  6022.             36    operazione    E=Elimina - A=Aggiorna - N=Aggiungi
  6023.             37  codice_agente
  6024.             38    variabile stringa 1
  6025.             39    variabile stringa 2
  6026.             40    variabile stringa 3
  6027.             41    variabile stringa 4
  6028.             42    variabile stringa 5
  6029.             43    variabile decimale 1
  6030.             44    variabile decimale 2
  6031.             45    variabile decimale 3
  6032.             46    variabile decimale 4
  6033.             47    variabile decimale 5
  6034.             48    variabile data ora 1
  6035.             49    variabile data ora 2
  6036.             50    variabile data ora 3
  6037.             51    variabile booleana 1
  6038.             52    variabile booleana 2
  6039.             53    variabile booleana 3
  6040.             54  codice_fornitore
  6041.             55  tipo_documento
  6042.             56  identificativo_utente
  6043.              */
  6044.             $indici = array(
  6045.                 'identificativo' => 0,
  6046.                 'documento' => 1,
  6047.                 'anno' => 2,
  6048.                 'dataDocumento' => 3,
  6049.                 'numero' => 4,
  6050.                 'numeroFattura' => 5,
  6051.                 'dataFattura' => 6,
  6052.                 'numeroDdt' => 7,
  6053.                 'dataDdt' => 8,
  6054.                 'agente' => 9,
  6055.                 'codiceAnagrafica' => 10,
  6056.                 'tipoAnagrafica' => 11,
  6057.                 'ragioneSociale' => 12,
  6058.                 'indirizzo' => 13,
  6059.                 'citta' => 14,
  6060.                 'provincia' => 15,
  6061.                 'cap' => 16,
  6062.                 'regione' => 17,
  6063.                 'codiceFiscale' => 18,
  6064.                 'partitaIva' => 19,
  6065.                 'modalitaPagamento' => 20,
  6066.                 'modalitaSpedizione' => 21,
  6067.                 'modalitaConsegna' => 22,
  6068.                 'totaleDocumentoNetto' => 23,
  6069.                 'totaleCostoNetto' => 24,
  6070.                 'zona' => 25,
  6071.                 'mercato' => 26,
  6072.                 'subAgente' => 27,
  6073.                 'capoArea' => 28,
  6074.                 'nomeFilePdfDocumento' => 29,
  6075.                 'nomeFilePdfFattura' => 30,
  6076.                 'nomeFilePdfDdt' => 31,
  6077.                 'statoAvanzamento' => 32,
  6078.                 'indirizzoTrackingCorriere' => 33,
  6079.                 'utente' => 34,
  6080.                 'dataConsegna' => 35,
  6081.                 'operazione' => 36,
  6082.                 'codiceAgente' => 37,
  6083.                 'variabileStringa1' => 38,
  6084.                 'variabileStringa2' => 39,
  6085.                 'variabileStringa3' => 40,
  6086.                 'variabileStringa4' => 41,
  6087.                 'variabileStringa5' => 42,
  6088.                 'variabileDecimale1' => 43,
  6089.                 'variabileDecimale2' => 44,
  6090.                 'variabileDecimale3' => 45,
  6091.                 'variabileDecimale4' => 46,
  6092.                 'variabileDecimale5' => 47,
  6093.                 'variabileDataora1' => 48,
  6094.                 'variabileDataora2' => 49,
  6095.                 'variabileDataora3' => 50,
  6096.                 'variabileBooleana1' => 51,
  6097.                 'variabileBooleana2' => 52,
  6098.                 'variabileBooleana3' => 53,
  6099.                 'codiceFornitore' => 54,
  6100.                 'tipoDocumento' => 55,
  6101.                 'identificativoUtente' => 56
  6102.             );
  6103.             try {
  6104.                 if (($handle fopen($root_path"r")) !== false) {
  6105.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  6106.                         if ($row == 0) {
  6107.                             $row 1;
  6108.                             continue;
  6109.                         }
  6110.                         if ($query_eseguite >= $batch_size) {
  6111.                             $contatore $contatore $row 1;
  6112.                             $row 1;
  6113.                             $query_eseguite 0;
  6114.                             $em->flush();
  6115.                             $em->clear();
  6116.                         }
  6117.                         $now = new \DateTime('now');
  6118.                         try {
  6119.                             //Verifico se presente già un offerte
  6120.                             $doc $repo->findOneBy(array('identificativo' => $data[$indici['identificativo']]));
  6121.                             if($doc){
  6122.                                 if($data[$indici['operazione']] == 'E'){
  6123.                                     foreach ($doc->getRighe() as $all)
  6124.                                         $em->remove($all);
  6125.                                     $em->remove($doc);
  6126.                                     $query_eseguite++;
  6127.                                 } else if ($data[$indici['operazione']] != 'E'){
  6128.                                     $doc->setDataModifica($now);
  6129.                                 }
  6130.                             } else if ($data[$indici['operazione']] != 'E'){
  6131.                                 $doc = new Documenti();
  6132.                                 $doc->setDataCreazione(new \DateTime());
  6133.                                 $doc->setIdentificativo($data[$indici['identificativo']]);
  6134.                             }
  6135.                             if($data[$indici['operazione']] != 'E'){
  6136.                                 $doc->setDocumento($data[$indici['documento']]);
  6137.                                 $doc->setAnno($data[$indici['anno']]);
  6138.                                 $doc->setDataDocumento(self::OttieniDataDaStringa($data[$indici['dataDocumento']], false));
  6139.                                 $doc->setNumero($data[$indici['numero']]);
  6140.                                 $doc->setNumeroDdt($data[$indici['numeroDdt']]);
  6141.                                 $doc->setDataDdt(self::OttieniDataDaStringa($data[$indici['dataDdt']], false));
  6142.                                 $doc->setNumeroFattura($data[$indici['numeroFattura']]);
  6143.                                 $doc->setDataFattura(self::OttieniDataDaStringa($data[$indici['dataFattura']], false));
  6144.                                 $doc->setAgente($data[$indici['agente']]);
  6145.                                 $doc->setCodiceAnagrafica($data[$indici['codiceAnagrafica']]);
  6146.                                 $doc->setTipoAnagrafica($data[$indici['tipoAnagrafica']]);
  6147.                                 $doc->setRagioneSociale($data[$indici['ragioneSociale']]);
  6148.                                 $doc->setIndirizzo($data[$indici['indirizzo']]);
  6149.                                 $doc->setCitta($data[$indici['citta']]);
  6150.                                 $doc->setProvincia($data[$indici['provincia']]);
  6151.                                 $doc->setCap($data[$indici['cap']]);
  6152.                                 $doc->setRegione($data[$indici['regione']]);
  6153.                                 $doc->setCodiceFiscale($data[$indici['codiceFiscale']]);
  6154.                                 $doc->setPartitaIva($data[$indici['partitaIva']]);
  6155.                                 $doc->setModalitaPagamento($data[$indici['modalitaPagamento']]);
  6156.                                 $doc->setModalitaSpedizione($data[$indici['modalitaSpedizione']]);
  6157.                                 $doc->setModalitaConsegna($data[$indici['modalitaConsegna']]);
  6158.                                 $doc->setTotaleDocumentoNetto(str_replace(',','.'$data[$indici['totaleDocumentoNetto']]));
  6159.                                 $doc->setTotaleCostoNetto(str_replace(',','.',$data[$indici['totaleCostoNetto']]));
  6160.                                 $doc->setZona($data[$indici['zona']]);
  6161.                                 $doc->setMercato($data[$indici['mercato']]);
  6162.                                 $doc->setSubAgente($data[$indici['subAgente']]);
  6163.                                 $doc->setCapoArea($data[$indici['capoArea']]);
  6164.                                 $doc->setNomeFilePdfDocumento($data[$indici['nomeFilePdfDocumento']]);
  6165.                                 $doc->setNomeFilePdfFattura($data[$indici['nomeFilePdfFattura']]);
  6166.                                 $doc->setNomefilePdfDdt($data[$indici['nomeFilePdfDdt']]);
  6167.                                 $doc->setStatoAvanzamento($data[$indici['statoAvanzamento']]);
  6168.                                 $doc->setIndirizzoTrackingCorriere($data[$indici['indirizzoTrackingCorriere']]);
  6169.                                 $doc->setUtente($data[$indici['utente']]);
  6170.                                 $doc->setDataConsegna(self::OttieniDataDaStringa($data[$indici['dataConsegna']], false));
  6171.                                 $doc->setCodiceAgente($data[$indici['codiceAgente']]);
  6172.                                 $doc->setDataModifica(new \DateTime());
  6173.                                 $doc->setVariabileStringa1($data[$indici['variabileStringa1']]);
  6174.                                 $doc->setVariabileStringa2($data[$indici['variabileStringa2']]);
  6175.                                 $doc->setVariabileStringa3($data[$indici['variabileStringa3']]);
  6176.                                 $doc->setVariabileStringa4($data[$indici['variabileStringa4']]);
  6177.                                 $doc->setVariabileStringa5($data[$indici['variabileStringa5']]);
  6178.                                 $doc->setVariabileDecimale1(ServiziController::convertiInNumero($data[$indici['variabileDecimale1']]));
  6179.                                 $doc->setVariabileDecimale2(ServiziController::convertiInNumero($data[$indici['variabileDecimale2']]));
  6180.                                 $doc->setVariabileDecimale3(ServiziController::convertiInNumero($data[$indici['variabileDecimale3']]));
  6181.                                 $doc->setVariabileDecimale4(ServiziController::convertiInNumero($data[$indici['variabileDecimale4']]));
  6182.                                 $doc->setVariabileDecimale5(ServiziController::convertiInNumero($data[$indici['variabileDecimale5']]));
  6183.                                 $doc->setVariabileDataora1(self::OttieniDataDaStringa($data[$indici['variabileDataora1']], true));
  6184.                                 $doc->setVariabileDataora2(self::OttieniDataDaStringa($data[$indici['variabileDataora2']], true));
  6185.                                 $doc->setVariabileDataora3(self::OttieniDataDaStringa($data[$indici['variabileDataora3']], true));
  6186.                                 $doc->setVariabileBooleana1(ServiziController::convertiInBoolean($data[$indici['variabileBooleana1']]));
  6187.                                 $doc->setVariabileBooleana2(ServiziController::convertiInBoolean($data[$indici['variabileBooleana2']]));
  6188.                                 $doc->setVariabileBooleana3(ServiziController::convertiInBoolean($data[$indici['variabileBooleana3']]));
  6189.                                 if(count($data) > $indici['codiceFornitore'])
  6190.                                     $doc->setCodiceFornitore($data[$indici['codiceFornitore']]);
  6191.                                 if(count($data) > $indici['tipoDocumento'])
  6192.                                     $doc->setTipoDocumento($data[$indici['tipoDocumento']]);
  6193.                                 if(count($data) > $indici['identificativoUtente'])
  6194.                                     $doc->setVincolaIdentificativoUtente($data[$indici['identificativoUtente']]);
  6195.                                 $em->persist($doc);
  6196.                                 $query_eseguite++;
  6197.                             }
  6198.                         } catch (\PDOException $ex) {
  6199.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione (RIGA: ' . ($contatore $row) . ') : ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaDocumenti');
  6200.                         } catch (\Exception|\Throwable $exception) {
  6201.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: (RIGA: ' . ($contatore $row) . ') : ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaDocumenti');
  6202.                         }
  6203.                         $row++;
  6204.                     }
  6205.                 }else{
  6206.                     $errori .= "Impossibile aprire il file!";
  6207.                 }
  6208.                 $em->flush();
  6209.                 $row $contatore $row 1;
  6210.                 if ($errori == "") {
  6211.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaDocumenti');
  6212.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  6213.                 } else {
  6214.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaDocumenti');
  6215.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  6216.                 }
  6217.             } catch (\Exception|\Throwable $ex) {
  6218.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaDocumenti');
  6219.                 return new Response('Errore importazione: ' $ex->getMessage());
  6220.             }
  6221.         } else {
  6222.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaDocumenti');
  6223.             return new Response("ERRORE PERMESSO");
  6224.         }
  6225.     } //OK
  6226.     /**
  6227.      * @Route("/caricaRigheDocumenti/{svuota}", name="carica_documenti_righe", defaults={"svuota"="0"})
  6228.      */
  6229.     public function caricaRigheDocumenti(Request $request$svuota "0")
  6230.     {
  6231.         $collegamentoRnd $this->servizi->randomString2();
  6232.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  6233.             ini_set('max_execution_time'1200);
  6234.             ini_set('memory_limit''4G');
  6235.             $start microtime(true);
  6236.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  6237.             $em $this->servizi->doctrine->getManager();
  6238.             $repo $this->servizi->doctrine->getRepository(DocumentiRighe::class);
  6239.             $repoDoc $this->servizi->doctrine->getRepository(Documenti::class);
  6240.             $errori "";
  6241.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  6242.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  6243.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  6244.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaDocumentiRighe/' $svuota ' --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaRigheDocumenti');
  6245.             $connection $this->servizi->doctrine->getConnection();
  6246.             if($svuota == "1"){
  6247.                 $em $this->servizi->doctrine->getManager();
  6248.                 $connection->beginTransaction();
  6249.                 try {
  6250.                     $connection->query("SET FOREIGN_KEY_CHECKS=0;");
  6251.                     $connection->executeUpdate("TRUNCATE `documenti_righe`;");
  6252.                     $connection->query("SET FOREIGN_KEY_CHECKS=1;");
  6253.                     $connection->commit();
  6254.                 }catch (\Exception|\Throwable $ex){
  6255.                     $this->servizi->DebuggaException($ex"Errore pulizia documenti_righe DB"falsenull$collegamentoRnd'ImportazioneController''caricaRigheDocumenti');
  6256.                 }
  6257.             }
  6258.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  6259.            $errori "";
  6260.             $root_path $pathFileBase "righe_documenti.csv";
  6261.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  6262.             $contatore 0;
  6263.             $row 0;
  6264.             $query_eseguite 0;
  6265.             $batch_size 50;
  6266.             /*
  6267.                 0    identificativo_documento    Collegamento con documento
  6268.                 1    numero_riga    intero che identifica la riga (Chiave univoca)
  6269.                 2    codice_articolo
  6270.                 3    descrizione_articolo
  6271.                 4    marca
  6272.                 5    um
  6273.                 6    data_consegna    2021-12-31
  6274.                 7    quantita    decimal(18,5)
  6275.                 8    prezzo_netto_totale    decimal(18,5)
  6276.                 9    prezzo_netto_cad    decimal(18,5)
  6277.                 10    prezzo_lordo_totale    decimal(18,5)
  6278.                 11    prezzo_lordo_cad    decimal(18,5)
  6279.                 12    sconti_maggiorazioni    -0.00#-3.00#+10.00#-0.00#-0.00#-0.00
  6280.                 13    descrizione_articolo_agg1
  6281.                 14    descrizione_articolo_agg2
  6282.                 15    variabile_1
  6283.                 16    variabile_2
  6284.                 17    variabile_3
  6285.                 18    variabile_4
  6286.                 19    variabile_5
  6287.                 20    qta_alt_1
  6288.                 21    qta_alt_2
  6289.                 22    qta_alt_3
  6290.                 23    costo_cad    decimal(18,5)
  6291.                 24    costo_totale    decimal(18,5)
  6292.                 25    stato_avanzamento
  6293.                 26    numero_riga_alternativo    intero
  6294.                 27    operazione    E=Elimina - A=Aggiorna - N=Aggiungi
  6295.                 28    variabile stringa 1
  6296.                 29    variabile stringa 2
  6297.                 30    variabile stringa 3
  6298.                 31    variabile stringa 4
  6299.                 32    variabile stringa 5
  6300.                 33    variabile decimale 1
  6301.                 34    variabile decimale 2
  6302.                 35    variabile decimale 3
  6303.                 36    variabile decimale 4
  6304.                 37    variabile decimale 5
  6305.                 38    variabile data ora 1
  6306.                 39    variabile data ora 2
  6307.                 40    variabile data ora 3
  6308.                 41    variabile booleana 1
  6309.                 42    variabile booleana 2
  6310.                 43    variabile booleana 3
  6311.                 44  stato
  6312.              */
  6313.             $indici = array(
  6314.                 'identificativoDocumento' => 0,
  6315.                 'numeroRiga' => 1,
  6316.                 'codiceArticolo' => 2,
  6317.                 'descrizioneArticolo' => 3,
  6318.                 'marca' => 4,
  6319.                 'um' => 5,
  6320.                 'dataConsegna' => 6,
  6321.                 'quantita' => 7,
  6322.                 'prezzoNettoTotale' => 8,
  6323.                 'prezzoNettoCad' => 9,
  6324.                 'prezzoLordoTotale' => 10,
  6325.                 'prezzoLordoCad' => 11,
  6326.                 'scontiMaggiorazioni' => 12,
  6327.                 'descrizioneArticoloAgg1' => 13,
  6328.                 'descrizioneArticoloAgg2' => 14,
  6329.                 'variabile1' => 15,
  6330.                 'variabile2' => 16,
  6331.                 'variabile3' => 17,
  6332.                 'variabile4' => 18,
  6333.                 'variabile5' => 19,
  6334.                 'qtaAlt1' => 20,
  6335.                 'qtaAlt2' => 21,
  6336.                 'qtaAlt3' => 22,
  6337.                 'costoCad' => 23,
  6338.                 'costoTotale' => 24,
  6339.                 'statoAvanzamento' => 25,
  6340.                 'numeroRigaAlternativo' => 26,
  6341.                 'operazione' => 27,
  6342.                 'variabileStringa1' => 28,
  6343.                 'variabileStringa2' => 29,
  6344.                 'variabileStringa3' => 30,
  6345.                 'variabileStringa4' => 31,
  6346.                 'variabileStringa5' => 32,
  6347.                 'variabileDecimale1' => 33,
  6348.                 'variabileDecimale2' => 34,
  6349.                 'variabileDecimale3' => 35,
  6350.                 'variabileDecimale4' => 36,
  6351.                 'variabileDecimale5' => 37,
  6352.                 'variabileDataora1' => 38,
  6353.                 'variabileDataora2' => 39,
  6354.                 'variabileDataora3' => 40,
  6355.                 'variabileBooleana1' => 41,
  6356.                 'variabileBooleana2' => 42,
  6357.                 'variabileBooleana3' => 43,
  6358.                 'stato' => 44
  6359.             );
  6360.             try {
  6361.                 if (($handle fopen($root_path"r")) !== false) {
  6362.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  6363.                         if ($row == 0) {
  6364.                             $row 1;
  6365.                             continue;
  6366.                         }
  6367.                         if ($query_eseguite >= $batch_size) {
  6368.                             $contatore $contatore $row 1;
  6369.                             $row 1;
  6370.                             $query_eseguite 0;
  6371.                             $em->flush();
  6372.                             $em->clear();
  6373.                         }
  6374.                         $now = new \DateTime('now');
  6375.                         try {
  6376.                             $doc $repoDoc->findOneBy(array('identificativo' => $data[$indici['identificativoDocumento']]));
  6377.                             if($doc) {
  6378.                                 //Verifico se presente già un offerte
  6379.                                 $rigaDoc $repo->findOneBy(array('identificativoDocumento' => $data[$indici['identificativoDocumento']], 'numeroRiga' => $data[$indici['numeroRiga']]));
  6380.                                 if ($rigaDoc) {
  6381.                                     if ($data[$indici['operazione']] == 'E') {
  6382.                                         $em->remove($rigaDoc);
  6383.                                         $query_eseguite++;
  6384.                                     } else if ($data[$indici['operazione']] != 'E') {
  6385.                                         $rigaDoc->setDataModifica($now);
  6386.                                     }
  6387.                                 } else if ($data[$indici['operazione']] != 'E') {
  6388.                                     $rigaDoc = new DocumentiRighe();
  6389.                                     $rigaDoc->setDataCreazione(new \DateTime());
  6390.                                     $rigaDoc->setIdentificativoDocumento($doc);
  6391.                                     $rigaDoc->setNumeroRiga($data[$indici['numeroRiga']]);
  6392.                                 }
  6393.                                 if ($data[$indici['operazione']] != 'E') {
  6394.                                     $rigaDoc->setCodiceArticolo($data[$indici['codiceArticolo']]);
  6395.                                     $rigaDoc->setDescrizioneArticolo($data[$indici['descrizioneArticolo']]);
  6396.                                     $rigaDoc->setMarca($data[$indici['marca']]);
  6397.                                     $rigaDoc->setUm($data[$indici['um']]);
  6398.                                     $rigaDoc->setDataConsegna(self::OttieniDataDaStringa($data[$indici['dataConsegna']], false));
  6399.                                     $rigaDoc->setQuantita(ServiziController::convertiInNumero($data[$indici['quantita']]));
  6400.                                     $rigaDoc->setPrezzoNettoTotale(ServiziController::convertiInNumero($data[$indici['prezzoNettoTotale']]));
  6401.                                     $rigaDoc->setPrezzoNettoCad(ServiziController::convertiInNumero($data[$indici['prezzoNettoCad']]));
  6402.                                     $rigaDoc->setPrezzoLordoTotale(ServiziController::convertiInNumero($data[$indici['prezzoLordoTotale']]));
  6403.                                     $rigaDoc->setPrezzoLordoCad(ServiziController::convertiInNumero($data[$indici['prezzoLordoCad']]));
  6404.                                     $rigaDoc->setScontiMaggiorazioni($data[$indici['scontiMaggiorazioni']]);
  6405.                                     $rigaDoc->setDescrizioneArticoloAgg1($data[$indici['descrizioneArticoloAgg1']]);
  6406.                                     $rigaDoc->setDescrizioneArticoloAgg2($data[$indici['descrizioneArticoloAgg2']]);
  6407.                                     $rigaDoc->setVariabile1($data[$indici['variabile1']]);
  6408.                                     $rigaDoc->setVariabile2($data[$indici['variabile2']]);
  6409.                                     $rigaDoc->setVariabile3($data[$indici['variabile3']]);
  6410.                                     $rigaDoc->setVariabile4($data[$indici['variabile4']]);
  6411.                                     $rigaDoc->setVariabile5($data[$indici['variabile5']]);
  6412.                                     $rigaDoc->setQtaAlt1(ServiziController::convertiInNumero($data[$indici['qtaAlt1']]));
  6413.                                     $rigaDoc->setQtaAlt2(ServiziController::convertiInNumero($data[$indici['qtaAlt2']]));
  6414.                                     $rigaDoc->setQtaAlt3(ServiziController::convertiInNumero($data[$indici['qtaAlt3']]));
  6415.                                     $rigaDoc->setCostoCad(ServiziController::convertiInNumero($data[$indici['costoCad']]));
  6416.                                     $rigaDoc->setCostoTotale(ServiziController::convertiInNumero($data[$indici['costoTotale']]));
  6417.                                     $rigaDoc->setStatoAvanzamento($data[$indici['statoAvanzamento']]);
  6418.                                     $rigaDoc->setNumeroRigaAlternativo(ServiziController::convertiInNumero($data[$indici['numeroRigaAlternativo']]));
  6419.                                     $rigaDoc->setDataModifica(new \DateTime());
  6420.                                     $rigaDoc->setVariabileStringa1($data[$indici['variabileStringa1']]);
  6421.                                     $rigaDoc->setVariabileStringa2($data[$indici['variabileStringa2']]);
  6422.                                     $rigaDoc->setVariabileStringa3($data[$indici['variabileStringa3']]);
  6423.                                     $rigaDoc->setVariabileStringa4($data[$indici['variabileStringa4']]);
  6424.                                     $rigaDoc->setVariabileStringa5($data[$indici['variabileStringa5']]);
  6425.                                     $rigaDoc->setVariabileDecimale1(ServiziController::convertiInNumero($data[$indici['variabileDecimale1']]));
  6426.                                     $rigaDoc->setVariabileDecimale2(ServiziController::convertiInNumero($data[$indici['variabileDecimale2']]));
  6427.                                     $rigaDoc->setVariabileDecimale3(ServiziController::convertiInNumero($data[$indici['variabileDecimale3']]));
  6428.                                     $rigaDoc->setVariabileDecimale4(ServiziController::convertiInNumero($data[$indici['variabileDecimale4']]));
  6429.                                     $rigaDoc->setVariabileDecimale5(ServiziController::convertiInNumero($data[$indici['variabileDecimale5']]));
  6430.                                     $rigaDoc->setVariabileDataora1(self::OttieniDataDaStringa($data[$indici['variabileDataora1']], true));
  6431.                                     $rigaDoc->setVariabileDataora2(self::OttieniDataDaStringa($data[$indici['variabileDataora2']], true));
  6432.                                     $rigaDoc->setVariabileDataora3(self::OttieniDataDaStringa($data[$indici['variabileDataora3']], true));
  6433.                                     $rigaDoc->setVariabileBooleana1(ServiziController::convertiInBoolean($data[$indici['variabileBooleana1']]));
  6434.                                     $rigaDoc->setVariabileBooleana2(ServiziController::convertiInBoolean($data[$indici['variabileBooleana2']]));
  6435.                                     $rigaDoc->setVariabileBooleana3(ServiziController::convertiInBoolean($data[$indici['variabileBooleana3']]));
  6436.                                     if (count($data) >= $indici['stato'] - 1){
  6437.                                         $rigaDoc->setStato($data[$indici['stato']]);
  6438.                                     }
  6439.                                     $em->persist($rigaDoc);
  6440.                                     $query_eseguite++;
  6441.                                 }
  6442.                             }else{
  6443.                                 $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione (RIGA: ' . ($row $contatore) . ') : Documento non trovato!' null$collegamentoRnd'ImportazioneController''caricaRigheDocumenti');
  6444.                                 $errori .= ('Errore importazione (RIGA: ' $contatore ') : Documento non trovato!');
  6445.                             }
  6446.                         } catch (\PDOException $ex) {
  6447.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione (RIGA: ' . ($row $contatore) . ') : ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaRigheDocumenti');
  6448.                         } catch (\Exception|\Throwable $exception) {
  6449.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: (RIGA: ' . ($row $contatore) . ') : ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaRigheDocumenti');
  6450.                         }
  6451.                         $row++;
  6452.                     }
  6453.                 }else{
  6454.                     $errori .= "Impossibile aprire il file!";
  6455.                 }
  6456.                 $em->flush();
  6457.                 $row $contatore $row 1;
  6458.                 if ($errori == "") {
  6459.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaRigheDocumenti');
  6460.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  6461.                 } else {
  6462.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaRigheDocumenti');
  6463.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  6464.                 }
  6465.             } catch (\Exception|\Throwable $ex) {
  6466.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaRigheDocumenti');
  6467.                 return new Response('Errore importazione: ' $ex->getMessage());
  6468.             }
  6469.         } else {
  6470.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaRigheDocumenti');
  6471.             return new Response("ERRORE PERMESSO");
  6472.         }
  6473.     } //OK
  6474.     /**
  6475.      * @Route("/caricaOfferteRighe", name="carica_offerte_righe")
  6476.      */
  6477.     public function caricaOfferteRighe(Request $request)
  6478.     {
  6479.         $collegamentoRnd $this->servizi->randomString2();
  6480.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  6481.             ini_set('max_execution_time'1200);
  6482.             ini_set('memory_limit''4G');
  6483.             $start microtime(true);
  6484.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  6485.             $em $this->servizi->doctrine->getManager();
  6486.             $repo $this->servizi->doctrine->getRepository(OfferteRighe::class);
  6487.             $repoOfferte $this->servizi->doctrine->getRepository(Offerte::class);
  6488.             $errori "";
  6489.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  6490.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  6491.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  6492.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  6493.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaOfferteRighe --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaOfferteRighe');
  6494.             $errori "";
  6495.             $root_path $pathFileBase "offerte_righe.csv";
  6496.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  6497.             $contatore 0;
  6498.             $row 0;
  6499.             $query_eseguite 0;
  6500.             $batch_size 50;
  6501.             /*
  6502.                 0    documento
  6503.                 1    numero
  6504.                 2    anno
  6505.                 3    macro_categoria_articolo
  6506.                 4    codice_articolo
  6507.                 5    marca_articolo
  6508.                 6    descrizione_articolo
  6509.                 7    descrizione_seconaria_articolo
  6510.                 8    um
  6511.                 9    stringa_sconti
  6512.                 10    qta
  6513.                 11    nota_riga
  6514.                 12    netto_cad
  6515.                 13    lordo_cad
  6516.                 14    netto_totale
  6517.                 15    lordo_totale
  6518.                 16    imposta
  6519.                 17    imponibile
  6520.                 18    operazione
  6521.                 19  numeroRiga
  6522.                 20  stato
  6523.              */
  6524.             $indici = array(
  6525.                 'documento' => 0,
  6526.                 'numero' => 1,
  6527.                 'anno' => 2,
  6528.                 'macroCategoriaArticolo' => 3,
  6529.                 'codiceArticolo' => 4,
  6530.                 'marcaArticolo' => 5,
  6531.                 'descrizioneArticolo' => 6,
  6532.                 'descrizioneSecondariaArticolo' => 7,
  6533.                 'um' => 8,
  6534.                 'stringaSconti' => 9,
  6535.                 'qta' => 10,
  6536.                 'notaRiga' => 11,
  6537.                 'nettoCad' => 12,
  6538.                 'lordoCad' => 13,
  6539.                 'nettoTotale' => 14,
  6540.                 'lordoTotale' => 15,
  6541.                 'imposta' => 16,
  6542.                 'imponibile' => 17,
  6543.                 'operazione' => 18,
  6544.                 'numeroRiga' => 19,
  6545.                 'stato' => 20
  6546.             );
  6547.             try {
  6548.                 if (($handle fopen($root_path"r")) !== false) {
  6549.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  6550.                         if ($row == 0) {
  6551.                             $row 1;
  6552.                             continue;
  6553.                         }
  6554.                         if ($query_eseguite >= $batch_size) {
  6555.                             $contatore $contatore $row 1;
  6556.                             $row 1;
  6557.                             $query_eseguite 0;
  6558.                             $em->flush();
  6559.                             $em->clear();
  6560.                         }
  6561.                         $now = new \DateTime('now');
  6562.                         try {
  6563.                             //Recupero l'offerta
  6564.                             $offerta $repoOfferte->findOneBy(array('documento' => $data[$indici['documento']], 'numero' => $data[$indici['numero']], 'anno' => $data[$indici['anno']]));
  6565.                             if($offerta){
  6566.                                 /** @var OfferteRighe $riga */
  6567.                                 $riga $offerta->RitornaRigaDaNumero($data[$indici['numeroRiga']]);
  6568.                                 if($riga && $data[$indici['operazione']] == 'E'){
  6569.                                     $em->remove($riga);
  6570.                                     $query_eseguite++;
  6571.                                 }
  6572.                                 if($data[$indici['operazione']] != "E"){
  6573.                                     if(!$riga) {
  6574.                                         $riga = new OfferteRighe();
  6575.                                         $riga->setDataCreazione($now);
  6576.                                         $riga->setOfferta($offerta);
  6577.                                     }
  6578.                                     $riga->setDataModifica($now);
  6579.                                     $riga->setMacroCategoria($data[$indici['macroCategoriaArticolo']]);
  6580.                                     $riga->setCodiceArticolo($data[$indici['codiceArticolo']]);
  6581.                                     $riga->setDescrizioneArticolo($data[$indici['descrizioneArticolo']]);
  6582.                                     $riga->setDescrizioneSecondariaArticolo($data[$indici['descrizioneSecondariaArticolo']]);
  6583.                                     $riga->setMarca($data[$indici['marcaArticolo']]);
  6584.                                     $riga->setNumeroRiga($data[$indici['numeroRiga']]);
  6585.                                     $riga->setUm($data[$indici['um']]);
  6586.                                     $riga->setStringaSconti($data[$indici['stringaSconti']]);
  6587.                                     $riga->setQta(ServiziController::convertiInNumero($data[$indici['qta']]));
  6588.                                     $riga->setNotaRiga($data[$indici['notaRiga']]);
  6589.                                     $riga->setNettoCad(ServiziController::convertiInNumero($data[$indici['nettoCad']]));
  6590.                                     $riga->setLordoCad(ServiziController::convertiInNumero($data[$indici['lordoCad']]));
  6591.                                     $riga->setNettoTotale(ServiziController::convertiInNumero($data[$indici['nettoTotale']]));
  6592.                                     $riga->setLordoTotale(ServiziController::convertiInNumero($data[$indici['lordoTotale']]));
  6593.                                     $riga->setImposta(ServiziController::convertiInNumero($data[$indici['imposta']]));
  6594.                                     $riga->setImponibile(ServiziController::convertiInNumero($data[$indici['imponibile']]));
  6595.                                     if (count($data) >= $indici['stato'] - 1){
  6596.                                         $riga->setStato($data[$indici['stato']]);
  6597.                                     }
  6598.                                     //Vedo se presente un collegamento con una mappa articolo dell'ecommerce
  6599.                                     $articoloTrovato $this->servizi->doctrine->getRepository(MappaCategorieArticoli::class)->createQueryBuilder('mappa_categorie_articoli')
  6600.                                         ->leftJoin('mappa_categorie_articoli.articolo''articolo')
  6601.                                         ->where('articolo.codice = :cod')->setParameter('cod'$data[$indici['codiceArticolo']])
  6602.                                         ->andWhere('articolo.macroCategoria = :macro')->setParameter('macro'$data[$indici['macroCategoriaArticolo']])
  6603.                                         ->andWhere('mappa_categorie_articoli.marca = :marca')->setParameter('marca'$data[$indici['marcaArticolo']])
  6604.                                         ->setMaxResults(1)
  6605.                                         ->getQuery()->getResult();
  6606.                                     if(count($articoloTrovato) > 0)
  6607.                                         $riga->setCollegamentoMappaCategorieArticoli($articoloTrovato[0]);
  6608.                                     $em->persist($riga);
  6609.                                     $query_eseguite++;
  6610.                                 }
  6611.                             }else {
  6612.                                 $errori .= ("Riga: " $contatore " -- Offerta non trovata con Documento: " $data[$indici['documento']] . " - Numero: " $data[$indici['numero']] . " - Anno: " $data[$indici['anno']] . "\n");
  6613.                             }
  6614.                         } catch (\PDOException $ex) {
  6615.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferteRighe');
  6616.                         } catch (\Exception|\Throwable $exception) {
  6617.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferteRighe');
  6618.                         }
  6619.                         $row++;
  6620.                     }
  6621.                 }else{
  6622.                     $errori .= "Impossibile aprire il file!";
  6623.                 }
  6624.                 $em->flush();
  6625.                 $row $contatore $row 1;
  6626.                 if ($errori == "") {
  6627.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaOfferteRighe');
  6628.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  6629.                 } else {
  6630.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaOfferteRighe');
  6631.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  6632.                 }
  6633.             } catch (\Exception|\Throwable $ex) {
  6634.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferteRighe');
  6635.                 return new Response('Errore importazione: ' $ex->getMessage());
  6636.             }
  6637.         } else {
  6638.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaOfferteRighe');
  6639.             return new Response("ERRORE PERMESSO");
  6640.         }
  6641.     } //OK
  6642.     /**
  6643.      * @Route("/caricaOfferteRegistroEventi", name="carica_offerte_registro_eventi")
  6644.      */
  6645.     public function caricaOfferteRegistroEventi(Request $request)
  6646.     {
  6647.         $collegamentoRnd $this->servizi->randomString2();
  6648.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  6649.             ini_set('max_execution_time'1200);
  6650.             ini_set('memory_limit''4G');
  6651.             $start microtime(true);
  6652.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  6653.             $em $this->servizi->doctrine->getManager();
  6654.             $repo $this->servizi->doctrine->getRepository(OfferteRegistroEventi::class);
  6655.             $repoOfferte $this->servizi->doctrine->getRepository(Offerte::class);
  6656.             $errori "";
  6657.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  6658.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  6659.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  6660.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  6661.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaOfferteRegistroEventi --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaOfferteRegistroEventi');
  6662.             $errori "";
  6663.             $root_path $pathFileBase "offerte_registro_eventi.csv";
  6664.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  6665.             $contatore 0;
  6666.             $row 0;
  6667.             $query_eseguite 0;
  6668.             $batch_size 50;
  6669.             /*
  6670.                 0    documento
  6671.                 1    numero
  6672.                 2    anno
  6673.                 3    titolo
  6674.                 4    descrizione
  6675.                 5    operazione
  6676.                 6    identificativo
  6677.                 7   data_ora
  6678.              */
  6679.             $indici = array(
  6680.                 'documento' => 0,
  6681.                 'numero' => 1,
  6682.                 'anno' => 2,
  6683.                 'titolo' => 3,
  6684.                 'descrizione' => 4,
  6685.                 'operazione' => 5,
  6686.                 'identificativo' => 6,
  6687.                 'dataOra' => 7
  6688.             );
  6689.             try {
  6690.                 if (($handle fopen($root_path"r")) !== false) {
  6691.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  6692.                         if ($row == 0) {
  6693.                             $row 1;
  6694.                             continue;
  6695.                         }
  6696.                         if ($query_eseguite >= $batch_size) {
  6697.                             $contatore $contatore $row 1;
  6698.                             $row 1;
  6699.                             $query_eseguite 0;
  6700.                             $em->flush();
  6701.                             $em->clear();
  6702.                         }
  6703.                         $now = new \DateTime('now');
  6704.                         try {
  6705.                             //Recupero l'offerta
  6706.                             $offerta $repoOfferte->findOneBy(array('documento' => $data[$indici['documento']], 'numero' => $data[$indici['numero']], 'anno' => $data[$indici['anno']]));
  6707.                             if($offerta){
  6708.                                 /** @var OffertaRegistroEventi $reg */
  6709.                                 $reg $offerta->RitornaRegistroEventoDaIdentificativo($data[$indici['identificativo']]);
  6710.                                 if($reg && $data[$indici['operazione']] == 'E'){
  6711.                                     $em->remove($reg);
  6712.                                     $query_eseguite++;
  6713.                                 }
  6714.                                 if($data[$indici['operazione']] != "E"){
  6715.                                     if(!$reg){
  6716.                                         $reg = new OfferteRegistroEventi();
  6717.                                         $reg->setDataCreazione($now);
  6718.                                         $reg->setOfferta($offerta);
  6719.                                     }
  6720.                                     if(count($data) >= 8){
  6721.                                         $reg->setDataModifica(self::OttieniDataDaStringa($data[$indici['dataOra']], true));
  6722.                                     }else {
  6723.                                         $reg->setDataModifica($now);
  6724.                                     }
  6725.                                     if($data[$indici['identificativo']] != ''){
  6726.                                         $reg->setIdentificativo($data[$indici['identificativo']]);
  6727.                                     }else {
  6728.                                         $reg->setIdentificativo($this->servizi->generaStringaCasuale(20));
  6729.                                     }
  6730.                                     $reg->setTitolo($data[$indici['titolo']]);
  6731.                                     $reg->setDescrizione($data[$indici['descrizione']]);
  6732.                                     $em->persist($reg);
  6733.                                     $query_eseguite++;
  6734.                                 }
  6735.                             }else {
  6736.                                 $errori .= ("RIGA: " $contatore " -- Offerta non trovata con Documento: " $data[$indici['documento']] . " - Numero: " $data[$indici['numero']] . " - Anno: " $data[$indici['anno']] . "\n");
  6737.                             }
  6738.                         } catch (\PDOException $ex) {
  6739.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferteRegistroEventi');
  6740.                         } catch (\Exception|\Throwable $exception) {
  6741.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferteRegistroEventi');
  6742.                         }
  6743.                         $row++;
  6744.                     }
  6745.                 }else{
  6746.                     $errori .= "Impossibile aprire il file!";
  6747.                 }
  6748.                 $em->flush();
  6749.                 $row $contatore $row 1;
  6750.                 if ($errori == "") {
  6751.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaOfferteRegistroEventi');
  6752.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  6753.                 } else {
  6754.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaOfferteRegistroEventi');
  6755.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  6756.                 }
  6757.             } catch (\Exception|\Throwable $ex) {
  6758.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferteRegistroEventi');
  6759.                 return new Response('Errore importazione: ' $ex->getMessage());
  6760.             }
  6761.         } else {
  6762.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaOfferteRegistroEventi');
  6763.             return new Response("ERRORE PERMESSO");
  6764.         }
  6765.     } //OK
  6766.     /**
  6767.      * @Route("/caricaOfferteAllegati", name="carica_offerte_allegati")
  6768.      */
  6769.     public function caricaOfferteAllegati(Request $request)
  6770.     {
  6771.         $collegamentoRnd $this->servizi->randomString2();
  6772.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  6773.             ini_set('max_execution_time'1200);
  6774.             ini_set('memory_limit''4G');
  6775.             $start microtime(true);
  6776.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  6777.             $em $this->servizi->doctrine->getManager();
  6778.             $repo $this->servizi->doctrine->getRepository(OfferteAllegati::class);
  6779.             $repoOfferte $this->servizi->doctrine->getRepository(Offerte::class);
  6780.             $errori "";
  6781.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  6782.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  6783.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  6784.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  6785.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /caricaOfferteAllegati--- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''caricaOfferteAllegati');
  6786.             $errori "";
  6787.             $root_path $pathFileBase "offerte_allegati.csv";
  6788.             $separator $this->imp->ritornaImpostazioneDaNome("ImportazioniFileCsvSeparatore");
  6789.             $contatore 0;
  6790.             $row 0;
  6791.             $query_eseguite 0;
  6792.             $batch_size 50;
  6793.             /*
  6794.                 0    documento
  6795.                 1    numero
  6796.                 2    anno
  6797.                 3    nome
  6798.                 4    file finale
  6799.                 5    tipo_file
  6800.                 6    operazione
  6801.                 7    identificativo
  6802.              */
  6803.             $indici = array(
  6804.                 'documento' => 0,
  6805.                 'numero' => 1,
  6806.                 'anno' => 2,
  6807.                 'nome' => 3,
  6808.                 'tipoFile' => 4,
  6809.                 'operazione' => 5,
  6810.                 'identificativo' => 6
  6811.             );
  6812.             try {
  6813.                 if (($handle fopen($root_path"r")) !== false) {
  6814.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  6815.                         if ($row == 0) {
  6816.                             $row 1;
  6817.                             continue;
  6818.                         }
  6819.                         if ($query_eseguite >= $batch_size) {
  6820.                             $contatore $contatore $row 1;
  6821.                             $row 1;
  6822.                             $query_eseguite 0;
  6823.                             $em->flush();
  6824.                             $em->clear();
  6825.                         }
  6826.                         $now = new \DateTime('now');
  6827.                         try {
  6828.                             //Recupero l'offerta
  6829.                             $offerta $repoOfferte->findOneBy(array('documento' => $data[$indici['documento']], 'numero' => $data[$indici['numero']], 'anno' => $data[$indici['anno']]));
  6830.                             if($offerta){
  6831.                                 /** @var OfferteAllegati $all */
  6832.                                 $all $offerta->RitornaAllegatoDaIdentificativo($data[$indici['identificativo']]);
  6833.                                 if($all && $data[$indici['operazione']] == 'E'){
  6834.                                     $em->remove($all);
  6835.                                     $query_eseguite++;
  6836.                                 }
  6837.                                 if($data[$indici['operazione']] != "E"){
  6838.                                     if(!$all){
  6839.                                         $all = new OfferteAllegati();
  6840.                                         $all->setDataCaricamento($now);
  6841.                                         $all->setOfferta($offerta);
  6842.                                     }
  6843.                                     $all->setNome($data[$indici['nome']]);
  6844.                                     $all->setTipoFile($data[$indici['tipoFile']]);
  6845.                                     $all->setIdentificativo($this->servizi->generaStringaCasuale(20));
  6846.                                     $pathFile $pathFileBase $all->getNome();
  6847.                                     if(file_exists($pathFile)){
  6848.                                         $all->setFile(file_get_contents($pathFile));
  6849.                                         if(!unlink($pathFile)){
  6850.                                             $errori .= ("RIGA: " $contatore " --- il file non può essere eliminato dal disco!");
  6851.                                         }
  6852.                                     }else{
  6853.                                         $errori .= ("RIGA: " $contatore " --- Il file " $pathFile " non esiste!");
  6854.                                     }
  6855.                                     $em->persist($all);
  6856.                                     $query_eseguite++;
  6857.                                 }
  6858.                             }else {
  6859.                                 $errori .= ("RIGA: " $contatore " -- Offerta non trovata con Documento: " $data[$indici['documento']] . " - Numero: " $data[$indici['numero']] . " - Anno: " $data[$indici['anno']] . "\n");
  6860.                             }
  6861.                         } catch (\PDOException $ex) {
  6862.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione (RIGA: ' $contatore ') : ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferteAllegati');
  6863.                         } catch (\Exception|\Throwable $exception) {
  6864.                             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""false'Errore importazione: ' $exception->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferteAllegati');
  6865.                         }
  6866.                         $row++;
  6867.                     }
  6868.                 }else{
  6869.                     $errori .= "Impossibile aprire il file!";
  6870.                 }
  6871.                 $em->flush();
  6872.                 $row $contatore $row 1;
  6873.                 if ($errori == "") {
  6874.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaOfferteAllegati');
  6875.                     return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  6876.                 } else {
  6877.                     $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''caricaOfferteAllegati');
  6878.                     return new Response('Importazione completata con errori in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row "</br>Lista Errori:</br>" $errori);
  6879.                 }
  6880.             } catch (\Exception|\Throwable $ex) {
  6881.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''caricaOfferteAllegati');
  6882.                 return new Response('Errore importazione: ' $ex->getMessage());
  6883.             }
  6884.         } else {
  6885.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''caricaOfferteAllegati');
  6886.             return new Response("ERRORE PERMESSO");
  6887.         }
  6888.     } //OK
  6889.     /**
  6890.      * @Route("/importaImmaginiPicard", name="carica_immagini_picard")
  6891.      */
  6892.     public function importaImmaginiPicard(Request $request)
  6893.     {
  6894.         $collegamentoRnd $this->servizi->randomString2();
  6895.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  6896.             ini_set('max_execution_time'21600); // 4 ore
  6897.             ini_set('memory_limit''4G');
  6898.             $start microtime(true);
  6899.             $this->imp->caricaCacheImpostazioniDaFamiglie(['Importazioni']);
  6900.             //IMPORTO LE IMMAGINI
  6901.                 try {
  6902.                     $usr $this->imp->ritornaImpostazioneDaNome('ImportazioniPicardUsername');
  6903.                     $psw $this->imp->ritornaImpostazioneDaNome('ImportazioniPicardPassword');
  6904.                     $file_contents file_get_contents("http://" $usr ":" $psw "@stock.picard.de/bmecat/bilder.zip");
  6905.                     $pathTemp tempnam(sys_get_temp_dir(), 'imgPicard');
  6906.                     $zp = new \ZipArchive;
  6907.                     if($file_contents){
  6908.                         $res $zp->open($pathTemp);
  6909.                             if($res === true){
  6910.                                 $zp->extractTo("uploads/PK/");
  6911.                                 $zp->close();
  6912.                             }
  6913.                     }
  6914.                 }catch (\Exception|\Throwable $ex){
  6915.                     $this->servizi->DebuggaException($ex''falsenull$collegamentoRnd'ImportazioneController''importaImmaginiPicard');
  6916.                     return new Response('Errore importazione: ' $ex->getMessage());
  6917.                 }
  6918.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>'null$collegamentoRnd'ImportazioneController''importaImmaginiPicard');
  6919.             return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' );
  6920.         } else {
  6921.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''importaImmaginiPicard');
  6922.             return new Response("ERRORE PERMESSO");
  6923.         }
  6924.     }
  6925.     /**
  6926.      * @Route("/importaGiacenzeArticoliPicardXML", name="carica_giacenze_lista_articoli_picard")
  6927.      */
  6928.     public function importaGiacenzePicardXML(Request $request)
  6929.     {
  6930.         $collegamentoRnd $this->servizi->randomString2();
  6931.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  6932.             ini_set('max_execution_time'21600); // 4 ore
  6933.             ini_set('memory_limit''4G');
  6934.             $start microtime(true);
  6935.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  6936.             $em $this->servizi->doctrine->getManager();
  6937.             $repo $this->servizi->doctrine->getRepository(MagazzinoSecondarioDisponibilita::class);
  6938.             $repoMappa $this->servizi->doctrine->getRepository(MappaCategorieArticoli::class);
  6939.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  6940.             $this->imp->caricaCacheImpostazioniDaFamiglie(['Importazioni']);
  6941.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  6942.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  6943.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  6944.             $categorieEscluseDaImportazione explode(','$this->imp->ritornaImpostazioneDaNome('ImportazioniPicardCategorieEscluseImportazione'));
  6945.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /importaGiacenzaArticoliPicardXML --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''importaGiacenzaArticoliPicardXML');
  6946.             try {
  6947.                 $filesystem = new Filesystem();
  6948.                 //Verifico che esista la cartella pk
  6949.                 if (!$filesystem->exists($pathFileBase 'pk/')) {
  6950.                     $filesystem->mkdir($pathFileBase 'pk/'0777);
  6951.                 }
  6952.                 // set up basic connection
  6953.                 $conn_id ftp_connect($this->imp->ritornaImpostazioneDaNome('ImportazioniPicardIndirizzoServerFtp'));
  6954.                 // login with username and password
  6955.                 $login_result ftp_login($conn_id$this->imp->ritornaImpostazioneDaNome('ImportazioniPicardUsername'), $this->imp->ritornaImpostazioneDaNome('ImportazioniPicardPassword'));
  6956.                 //Set passive mode
  6957.                 ftp_pasv($conn_idtrue);
  6958.                 // try to download $server_file and save to $local_file
  6959.                 ftp_get($conn_id$pathFileBase 'pk/bestand.csv''/OUT/bestand.csv'FTP_BINARY);
  6960.                 // close the connection
  6961.                 ftp_close($conn_id);
  6962.             } catch (\Exception|\Throwable $ex) {
  6963.                 $this->servizi->DebuggaException($ex''falsenull$collegamentoRnd'ImportazioneController''importaGiacenzaArticoliPicardXML');
  6964.                 die('Errore ' $ex->getMessage());
  6965.             }
  6966.             $root_path $pathFileBase 'pk/bestand.csv';
  6967.             $separator ";";
  6968.             $contatore 0;
  6969.             $row 0;
  6970.             $query_eseguite 0;
  6971.             $batch_size 50;
  6972.             $magazzinoSecondario $this->servizi->doctrine->getRepository(MagazziniSecondari::class)->findOneBy(array('nome' => 'PICARD'));
  6973.             if (!$magazzinoSecondario) {
  6974.                 $magazzinoSecondario = new MagazziniSecondari();
  6975.                 $magazzinoSecondario->setNome('PICARD');
  6976.                 $magazzinoSecondario->setApprovvigionamentoStimato('4/5 gg lavorativi');
  6977.                 $magazzinoSecondario->setAttivo(true);
  6978.                 $magazzinoSecondario->setDataCreazione(new \DateTime());
  6979.                 $magazzinoSecondario->setDataModifica(new \DateTime());
  6980.                 $magazzinoSecondario->setPercentualeDecremento(0);
  6981.                 $magazzinoSecondario->setPercentualeIncremento(0);
  6982.                 $magazzinoSecondario->setMetodoAcquisizioneDati('');
  6983.                 $magazzinoSecondario->setFondiCategorie(false);
  6984.                 $magazzinoSecondario->setImportazioneInCorso(false);
  6985.                 $em->persist($magazzinoSecondario);
  6986.                 $em->flush();
  6987.                 $magazzinoSecondario $this->servizi->doctrine->getRepository(MagazziniSecondari::class)->findOneBy(array('nome' => 'PICARD'));
  6988.             }
  6989.             try {
  6990.                 if (($handle fopen($root_path"r")) !== false) {
  6991.                     while (($data fgetcsv($handle0$separator$this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEnclosure"), $this->imp->ritornaImpostazioneDaNome("ImportazioneFileCsvEscape"))) !== false) {
  6992.                         if ($query_eseguite >= $batch_size) {
  6993.                             $contatore $contatore $row 1;
  6994.                             $row 1;
  6995.                             $query_eseguite 0;
  6996.                             $em->flush();
  6997.                         }
  6998.                         $mappa $repoMappa->createQueryBuilder('mappa')
  6999.                             ->leftJoin('mappa.articolo''articolo')
  7000.                             ->where('articolo.codiceImportazione = :cod')->setParameter('cod'$data[0])
  7001.                             ->setMaxResults(1)
  7002.                             ->getQuery()->getResult();
  7003.                         if ($mappa) {
  7004.                             $mappa $mappa[0];
  7005.                             $disp $repo->findOneBy(array('mappaCategorieArticoli' => $mappa'magazzinoSecondario' => $magazzinoSecondario));
  7006.                             if (!$disp) {
  7007.                                 $disp = new MagazzinoSecondarioDisponibilita();
  7008.                                 $disp->setDataCreazione(new \DateTime());
  7009.                                 $disp->setMagazzinoSecondario($magazzinoSecondario);
  7010.                                 $disp->setMappaCategorieArticoli($mappa);
  7011.                             }
  7012.                             $disp->setDisponibilita($data[1]);
  7013.                             $disp->setDataModifica(new \DateTime());
  7014.                             $em->merge($disp);
  7015.                             $query_eseguite++;
  7016.                         } else {
  7017.                             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Articolo con codice importazione: ' $data[0] . ' non trovato!'null$collegamentoRnd'ImportazioneController''importaGiacenzaArticoliPicardXML');
  7018.                         }
  7019.                     }
  7020.                 }else{
  7021.                     $errori .= "Impossibile aprire il file!";
  7022.                 }
  7023.                 $em->flush();
  7024.                 $em->clear();
  7025.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''importaGiacenzaArticoliPicardXML');
  7026.                 return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  7027.             } catch (\Exception|\Throwable $ex) {
  7028.                 $this->servizi->DebuggaException($ex''falsenull$collegamentoRnd'ImportazioneController''importaGiacenzaArticoliPicardXML');
  7029.                 return new Response('Errore importazione: ' $ex->getMessage());
  7030.             }
  7031.         } else {
  7032.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''importaGiacenzaArticoliPicardXML');
  7033.             return new Response("ERRORE PERMESSO");
  7034.         }
  7035.     }
  7036.     /**
  7037.      * @Route("/importaArticoliPicardXML", name="carica_lista_articoli_picard")
  7038.      */
  7039.     public function importaPicardXML(Request $request)
  7040.     {
  7041.         $collegamentoRnd $this->servizi->randomString2();
  7042.         if ($this->servizi->verificaSeIpAutorizzatoChiamateImportExport($request->getClientIp())) {
  7043.             ini_set('max_execution_time'21600); // 4 ore
  7044.             ini_set('memory_limit''4G');
  7045.             $start microtime(true);
  7046.             $this->servizi->doctrine->getConnection()->getConfiguration()->setSQLLogger(null);
  7047.             $em $this->servizi->doctrine->getManager();
  7048.             $conn $this->servizi->doctrine->getConnection();
  7049.             $repoListini $this->servizi->doctrine->getRepository(ListiniVendita::class);
  7050.             $repoCategorie $this->servizi->doctrine->getRepository(Categorie::class);
  7051.             $repoAttributi $this->servizi->doctrine->getRepository(Attributi::class);
  7052.             $repoAssociazioneAttributi $this->servizi->doctrine->getRepository(AssociazioneAttributi::class);
  7053.             $repoArticoli $this->servizi->doctrine->getRepository(Articoli::class);
  7054.             $codiceListinoBase $this->imp->ritornaImpostazioneDaNome('CodiceListinoShopComune');
  7055.             $this->imp->caricaCacheImpostazioniDaFamiglie(['Importazioni']);
  7056.             $pathFileBase $this->imp->ritornaImpostazioneDaNome('PathFileBaseScambioDati');
  7057.             if (!$this->endsWith($pathFileBaseDIRECTORY_SEPARATOR))
  7058.                 $pathFileBase .= DIRECTORY_SEPARATOR;
  7059.             $pathFileBase .= ('IN' DIRECTORY_SEPARATOR);
  7060.             $cacheUmEsistenti = array();
  7061.             $stmt $conn->prepare('SELECT DISTINCT codice FROM unita_misura');
  7062.             $rst $stmt->executeQuery();
  7063.             $umEsis $rst->fetchAllAssociative();
  7064.             foreach ($umEsis as $it) {
  7065.                 array_push($cacheUmEsistenti$it['codice']);
  7066.             }
  7067.             $categorieEscluseDaImportazione explode(','$this->imp->ritornaImpostazioneDaNome('ImportazioniPicardCategorieEscluseImportazione'));
  7068.             $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Chiamata effettuata a /importaArticoliPicardXML --- Inizio l\' importazione dei dati'null$collegamentoRnd'ImportazioneController''importaArticoliPicardXML');
  7069.             try {
  7070.                 $filesystem = new Filesystem();
  7071.                 //Verifico che esista la cartella pk
  7072.                 if (!$filesystem->exists($pathFileBase 'pk/')) {
  7073.                     $filesystem->mkdir($pathFileBase 'pk/'0777);
  7074.                 }
  7075.                 // set up basic connection
  7076.                 $conn_id ftp_connect($this->imp->ritornaImpostazioneDaNome('ImportazioniPicardIndirizzoServerFtp'));
  7077.                 // login with username and password
  7078.                 $login_result ftp_login($conn_id$this->imp->ritornaImpostazioneDaNome('ImportazioniPicardUsername'), $this->imp->ritornaImpostazioneDaNome('ImportazioniPicardPassword'));
  7079.                 //Set passive mode
  7080.                 ftp_pasv($conn_idtrue);
  7081.                 // try to download $server_file and save to $local_file
  7082.                 ftp_get($conn_id$pathFileBase 'pk/picard_bmecat_it.zip''/OUT/picard_bmecat_it.zip'FTP_BINARY);
  7083.                 // close the connection
  7084.                 ftp_close($conn_id);
  7085.                 $zp = new \ZipArchive;
  7086.                 $res $zp->open($pathFileBase 'pk/picard_bmecat_it.zip');
  7087.                 if ($res === true) {
  7088.                     $zp->extractTo($pathFileBase 'pk/');
  7089.                     $zp->close();
  7090.                     chmod($pathFileBase 'pk/picard_bmecat_it.xml'0755);
  7091.                 }
  7092.             } catch (\Exception|\Throwable $ex) {
  7093.                 $this->servizi->DebuggaException($ex''falsenull$collegamentoRnd'ImportazioneController''importaArticoliPicardXML');
  7094.                 die('Errore ' $ex->getMessage());
  7095.             }
  7096.             $root_path $pathFileBase 'pk/picard_bmecat_it.xml';
  7097.             $contatore 0;
  7098.             $row 0;
  7099.             $query_eseguite 0;
  7100.             $batch_size 50;
  7101.             $cacheAttributi = array(); // Chiave codice identificativo
  7102.             if (!in_array('NR'$cacheUmEsistenti)) {
  7103.                 $sql "INSERT INTO unita_misura(codice, descrizione, fattore_conversione, numero_decimali, data_creazione, data_modifica, attivo) VALUES (?,?,?,?,NOW(), NOW(), 1)";
  7104.                 $stmt $conn->prepare($sql);
  7105.                 $stmt->bindValue(1'NR');
  7106.                 $stmt->bindValue(2'Numero');
  7107.                 $stmt->bindValue(31);
  7108.                 $stmt->bindValue(40);
  7109.                 $stmt->execute();
  7110.                 array_push($cacheUmEsistenti'NR');
  7111.             }
  7112.             $umNR $this->servizi->doctrine->getRepository(UnitaMisura::class)->findOneBy(array('codice' => 'NR'));
  7113.             if (!in_array('KG'$cacheUmEsistenti)) {
  7114.                 $sql "INSERT INTO unita_misura(codice, descrizione, fattore_conversione, numero_decimali, data_creazione, data_modifica, attivo) VALUES (?,?,?,?,NOW(), NOW(), 1)";
  7115.                 $stmt $conn->prepare($sql);
  7116.                 $stmt->bindValue(1'KG');
  7117.                 $stmt->bindValue(2'Chilogrammi');
  7118.                 $stmt->bindValue(31);
  7119.                 $stmt->bindValue(43);
  7120.                 $stmt->execute();
  7121.                 array_push($cacheUmEsistenti'KG');
  7122.             }
  7123.             $strutturaCategorie = array(); //array di array con dentro le varie categorie come chiave ho il group id
  7124.             $listaArticoli = array(); //array di array con chiave il supplier_pid
  7125.             try {
  7126.                 $xmlReader = new \XMLReader();
  7127.                 if (!$xmlReader->open($root_pathnull<< 19)) {
  7128.                     $this->ScriviRegistroAttivita($em$request->getClientIp(), ""true'Impossibile aprire il file: ' $root_pathnull);
  7129.                     die('Failed to open file');
  7130.                 }
  7131.                 while ($xmlReader->read()) {
  7132.                     if ($xmlReader->nodeType == \XMLReader::ELEMENT && $xmlReader->name == 'CATALOG_STRUCTURE') {
  7133.                         $nodo = new \SimpleXMLElement($xmlReader->readOuterXml());
  7134.                         $img '';
  7135.                         if (isset($nodo->MIME_INFO) && isset($nodo->MIME_INFO->MIME) && isset($nodo->MIME_INFO->MIME->MIME_SOURCE)) {
  7136.                             $img '/uploads/PK/' strval($nodo->MIME_INFO->MIME->MIME_SOURCE);
  7137.                         }
  7138.                         $strutturaCategorie[strval($nodo->GROUP_ID)] = array(strval($nodo->GROUP_ID), strval($nodo->GROUP_NAME), strval($nodo->PARENT_ID));
  7139.                         if (!in_array(strval($nodo->GROUP_ID), $categorieEscluseDaImportazione)) {
  7140.                             //Salvo categoria db se inesistente altrimenti la aggiorno
  7141.                             $cat $repoCategorie->findOneBy(array('codiceOriginale' => strval($nodo->GROUP_ID), 'codice' => ('PKR_' strval($nodo->GROUP_ID))));
  7142.                             if ($cat) {
  7143.                                 //Categoria esistente aggiorno nome
  7144.                                 $cat->setNome(strval($nodo->GROUP_NAME));
  7145.                                 $cat->setDataModifica(new \DateTime());
  7146.                                 $em->persist($cat);
  7147.                                 $query_eseguite++;
  7148.                             } else {
  7149.                                 //Nuova categoria la creo
  7150.                                 $cat = new Categorie();
  7151.                                 $cat->setNome(strval($nodo->GROUP_NAME));
  7152.                                 $cat->setCodiceOriginale(strval($nodo->GROUP_ID));
  7153.                                 $cat->setImmagine($img);
  7154.                                 $cat->setCodice('PKR_' strval($nodo->GROUP_ID));
  7155.                                 $cat->setNomeUnivoco($cat->getCodiceOriginale());
  7156.                                 $cat->setDataCreazione(new \DateTime());
  7157.                                 $cat->setDataModifica(new \DateTime());
  7158.                                 $cat->setAttivo(true);
  7159.                                 $em->persist($cat);
  7160.                                 $query_eseguite++;
  7161.                             }
  7162.                             $query_eseguite 0;
  7163.                             $em->flush();
  7164.                         }
  7165.                         unset($nodo);
  7166.                     } else if ($xmlReader->nodeType == \XMLReader::ELEMENT && $xmlReader->name == 'PRODUCT') {
  7167.                         //Dettaglio prodotti
  7168.                         $nodo = new \SimpleXMLElement($xmlReader->readOuterXml());
  7169.                         $articolo null;
  7170.                         $articolo $repoArticoli->findOneBy(array('codiceImportazione' => strval($nodo->SUPPLIER_PID)));
  7171.                         if ($articolo) {
  7172.                             $articolo->setDataModifica(new \DateTime());
  7173.                             $articolo->setNome(strval($nodo->MIME_INFO->MIME->MIME_ALT));
  7174.                             $articolo->setDescrizioneBreve(strval($nodo->PRODUCT_DETAILS->DESCRIPTION_SHORT));
  7175.                         } else {
  7176.                             $articolo = new Articoli();
  7177.                             $articolo->setUm($umNR);
  7178.                             $articolo->setUsaTipologiePreimpostate(false);
  7179.                             $articolo->setMacroCategoria('PK');
  7180.                             $articolo->setNome(strval($nodo->MIME_INFO->MIME->MIME_ALT));
  7181.                             $articolo->setDescrizioneBreve(strval($nodo->PRODUCT_DETAILS->DESCRIPTION_SHORT));
  7182.                             $articolo->setCodice(strval($nodo->PRODUCT_DETAILS->MANUFACTURER_PID));
  7183.                             $articolo->setCodiceImportazione(strval($nodo->SUPPLIER_PID));
  7184.                             $articolo->setDataCreazione(new \DateTime());
  7185.                             $articolo->setDataModifica(new \DateTime());
  7186.                         }
  7187.                         $listaAttributi = array(); //Ricordarsi di iterare alla fine ed associare i vari attributi agli articoli
  7188.                         if (isset($nodo->PRODUCT_FEATURES)) {
  7189.                             foreach ($nodo->PRODUCT_FEATURES->FEATURE as $feature) {
  7190.                                 if (strval($feature->FNAME) == 'Peso') {
  7191.                                     if (strval($feature->FUNIT) == 'kg') {
  7192.                                         $articolo->setPesoLordo(floatval($feature->FVALUE));
  7193.                                         if (!$articolo->getUmPeso())
  7194.                                             $articolo->setUmPeso($this->servizi->doctrine->getRepository(UnitaMisura::class)->findOneBy(array('codice' => 'KG')));
  7195.                                     }
  7196.                                 } else {
  7197.                                     $listaAttributi[strval($feature->FNAME)] = strval($feature->FVALUE);
  7198.                                 }
  7199.                             }
  7200.                         }
  7201.                         $em->merge($articolo);
  7202.                         $query_eseguite++;
  7203.                         $prezzo 0;
  7204.                         $costo 0;
  7205.                         if (isset($nodo->PRODUCT_PRICE_DETAILS->PRODUCT_PRICE->PRICE_AMOUNT)) {
  7206.                             foreach ($nodo->PRODUCT_PRICE_DETAILS->PRODUCT_PRICE as $price) {
  7207.                                 $att $price->attributes();
  7208.                                 if ($att['price_type'] && $att['price_type'] == 'nrp') {
  7209.                                     $prezzo strval($price->PRICE_AMOUNT);
  7210.                                 } else if ($att['price_type'] && $att['price_type'] == 'net_list') {
  7211.                                     $costo strval($price->PRICE_AMOUNT);
  7212.                                 }
  7213.                             }
  7214.                         }
  7215.                         $listaArticoli[strval($nodo->SUPPLIER_PID)] = array(strval($nodo->SUPPLIER_PID), strval($nodo->PRODUCT_DETAILS->MANUFACTURER_PID), strval($nodo->PRODUCT_DETAILS->MANUFACTURER_NAME), $listaAttributi$prezzo$costo);
  7216.                         if ($query_eseguite >= $batch_size) {
  7217.                             $query_eseguite 0;
  7218.                             $em->flush();
  7219.                         }
  7220.                         unset($nodo);
  7221.                     } else if ($xmlReader->nodeType == \XMLReader::ELEMENT && $xmlReader->name == 'PRODUCT_TO_CATALOGGROUP_MAP') {
  7222.                         $nodo = new \SimpleXMLElement($xmlReader->readOuterXml());
  7223.                         $prodId strval($nodo->PROD_ID);
  7224.                         $catGrId strval($nodo->CATALOG_GROUP_ID); //riferimento alla categoria
  7225.                         //qui creo le varie categorie, mappe e associo il valore attributi
  7226.                         if (!in_array($catGrId$categorieEscluseDaImportazione)) {
  7227.                             //Ottengo le categorie
  7228.                             $arraySequenzaCategorie $this->ritornaCategoria($catGrId$strutturaCategorie, array());
  7229.                             if (count($arraySequenzaCategorie) >= 5) {
  7230.                                 $cat1 = isset($arraySequenzaCategorie[4]) ? $arraySequenzaCategorie[4] : null;
  7231.                                 $cat2 = isset($arraySequenzaCategorie[3]) ? $arraySequenzaCategorie[3] : null;
  7232.                                 $cat3 = isset($arraySequenzaCategorie[2]) ? $arraySequenzaCategorie[2] : null;
  7233.                                 $cat4 = isset($arraySequenzaCategorie[1]) ? $arraySequenzaCategorie[1] : null;
  7234.                                 $cat5 = isset($arraySequenzaCategorie[0]) ? $arraySequenzaCategorie[0] : null;
  7235.                             } else if (count($arraySequenzaCategorie) == 4) {
  7236.                                 $cat1 = isset($arraySequenzaCategorie[3]) ? $arraySequenzaCategorie[3] : null;
  7237.                                 $cat2 = isset($arraySequenzaCategorie[2]) ? $arraySequenzaCategorie[2] : null;
  7238.                                 $cat3 = isset($arraySequenzaCategorie[1]) ? $arraySequenzaCategorie[1] : null;
  7239.                                 $cat4 = isset($arraySequenzaCategorie[0]) ? $arraySequenzaCategorie[0] : null;
  7240.                                 $cat5 null;
  7241.                             } else if (count($arraySequenzaCategorie) == 3) {
  7242.                                 $cat1 = isset($arraySequenzaCategorie[2]) ? $arraySequenzaCategorie[2] : null;
  7243.                                 $cat2 = isset($arraySequenzaCategorie[1]) ? $arraySequenzaCategorie[1] : null;
  7244.                                 $cat3 = isset($arraySequenzaCategorie[0]) ? $arraySequenzaCategorie[0] : null;
  7245.                                 $cat4 null;
  7246.                                 $cat5 null;
  7247.                             } else if (count($arraySequenzaCategorie) == 2) {
  7248.                                 $cat1 = isset($arraySequenzaCategorie[1]) ? $arraySequenzaCategorie[1] : null;
  7249.                                 $cat2 = isset($arraySequenzaCategorie[0]) ? $arraySequenzaCategorie[0] : null;
  7250.                                 $cat3 null;
  7251.                                 $cat4 null;
  7252.                                 $cat5 null;
  7253.                             } else if (count($arraySequenzaCategorie) == 1) {
  7254.                                 $cat1 = isset($arraySequenzaCategorie[0]) ? $arraySequenzaCategorie[0] : null;
  7255.                                 $cat2 null;
  7256.                                 $cat3 null;
  7257.                                 $cat4 null;
  7258.                                 $cat5 null;
  7259.                             } else {
  7260.                                 $cat1 null;
  7261.                                 $cat2 null;
  7262.                                 $cat3 null;
  7263.                                 $cat4 null;
  7264.                                 $cat5 null;
  7265.                             }
  7266.                             //Ottengo l'articolo
  7267.                             $articolo $repoArticoli->findOneBy(array('codiceImportazione' => $prodId'macroCategoria' => 'PK'));
  7268.                             $art $listaArticoli[$prodId];
  7269.                             $marca '';
  7270.                             if ($art && count($art) > 3) {
  7271.                                 $marca $art[2];
  7272.                             }
  7273.                             $mappa $this->servizi->doctrine->getRepository(MappaCategorieArticoli::class)
  7274.                                 ->findOneBy(array(
  7275.                                     'articolo' => $articolo,
  7276.                                     'marca' => $marca,
  7277.                                     'categoria1' => $cat1,
  7278.                                     'categoria2' => $cat2,
  7279.                                     'categoria3' => $cat3,
  7280.                                     'categoria4' => $cat4,
  7281.                                     'categoria5' => $cat5));
  7282.                             if ($articolo && $art) {
  7283.                                 if (!$mappa) {
  7284.                                     $mappa = new MappaCategorieArticoli();
  7285.                                     $mappa->setArticolo($articolo);
  7286.                                     $mappa->setCategoria1($cat1);
  7287.                                     $mappa->setCategoria2($cat2);
  7288.                                     $mappa->setCategoria3($cat3);
  7289.                                     $mappa->setCategoria4($cat4);
  7290.                                     $mappa->setCategoria5($cat5);
  7291.                                     $mappa->setMarca($marca);
  7292.                                     $mappa->setDisponibile(0);
  7293.                                     $mappa->setVariantiPresenti(false);
  7294.                                     $mappa->setDataCreazione(new \DateTime());
  7295.                                     $mappa->setDataModifica(new \DateTime());
  7296.                                     $em->merge($mappa);
  7297.                                     $em->flush();
  7298.                                     $mappa $this->servizi->doctrine->getRepository(MappaCategorieArticoli::class)
  7299.                                         ->findOneBy(array(
  7300.                                             'articolo' => $articolo,
  7301.                                             'marca' => $marca,
  7302.                                             'categoria1' => $cat1,
  7303.                                             'categoria2' => $cat2,
  7304.                                             'categoria3' => $cat3,
  7305.                                             'categoria4' => $cat4,
  7306.                                             'categoria5' => $cat5));
  7307.                                 }
  7308.                                 if ($art[4] && $art[4] != '0' && floatval($art[4]) > 0) {
  7309.                                     $listino $repoListini->findOneBy(array('mappaCategorieArticoli' => $mappa'codiceListino' => $codiceListinoBase'codiceAnagrafica' => null));
  7310.                                     if (!$listino) {
  7311.                                         $listino = new ListiniVendita();
  7312.                                         $listino->setDataCreazione(new \DateTime());
  7313.                                         $listino->setMappaCategorieArticoli($mappa);
  7314.                                         $listino->setCodiceListino($codiceListinoBase);
  7315.                                     }
  7316.                                     $listino->setDataModifica(new \DateTime());
  7317.                                     $listino->setFlagPrezzoNetto(false);
  7318.                                     $listino->setPrezzo($art[4]);
  7319.                                     $listino->setCosto($art[5]);
  7320.                                     $em->persist($listino);
  7321.                                     $query_eseguite++;
  7322.                                 }
  7323.                                 //Gestisco gli attributi
  7324.                                 foreach ($art[3] as $key => $val) {
  7325.                                     $value $art[3][$key];
  7326.                                     /** @var Attributi $attributo */
  7327.                                     $attributo null;
  7328.                                     if ($value != '' && $value !== false) {
  7329.                                         if (!array_key_exists($key$cacheAttributi)) {
  7330.                                             $attributo $repoAttributi->findOneBy(array('codiceIdentificativo' => $key));
  7331.                                             if (!$attributo) {
  7332.                                                 $attributo = new Attributi();
  7333.                                                 $attributo->setNome($key);
  7334.                                                 $attributo->setTestoVisualizzato($key);
  7335.                                                 $attributo->setDataCreazione(new \DateTime());
  7336.                                                 $attributo->setDataModifica(new \DateTime());
  7337.                                                 $attributo->setCodiceIdentificativo($key);
  7338.                                                 $em->persist($attributo);
  7339.                                                 $em->flush();
  7340.                                                 $attributo $repoAttributi->findOneBy(array('codiceIdentificativo' => $key));
  7341.                                                 $cacheAttributi[$key] = $attributo;
  7342.                                             }
  7343.                                         } else {
  7344.                                             $attributo $cacheAttributi[$key];
  7345.                                         }
  7346.                                         if ($attributo) {
  7347.                                             $associazione $repoAssociazioneAttributi->findOneBy(array('articolo' => $articolo'mappaCategoriaArticolo' => $mappa'attributo' => $attributo));
  7348.                                             if (!$associazione) {
  7349.                                                 $associazione = new AssociazioneAttributi();
  7350.                                                 $associazione->setArticolo($articolo);
  7351.                                                 $associazione->setMappaCategoriaArticolo($mappa);
  7352.                                                 $associazione->setAttributo($attributo);
  7353.                                                 $associazione->setDataCreazione(new \DateTime());
  7354.                                             }
  7355.                                             $associazione->setDataModifica(new \DateTime());
  7356.                                             $associazione->setValore($value);
  7357.                                             $em->persist($associazione);
  7358.                                             $query_eseguite++;
  7359.                                         }
  7360.                                     }
  7361.                                 }
  7362.                             } else {
  7363.                                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Errore articolo: ' $prodId ' - GroupId: ' $catGrId ' non trvoato!'null$collegamentoRnd'ImportazioneController''importaArticoliPicardXML');
  7364.                             }
  7365.                         }
  7366.                         if ($query_eseguite >= $batch_size) {
  7367.                             $query_eseguite 0;
  7368.                             $em->flush();
  7369.                         }
  7370.                         unset($nodo);
  7371.                     }
  7372.                 }
  7373.                 $em->flush();
  7374.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""true'Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $rownull$collegamentoRnd'ImportazioneController''importaArticoliPicardXML');
  7375.                 return new Response('Importazione completata in ' $time_elapsed_secs microtime(true) - $start ' seconds</br>' $row);
  7376.             } catch (\Exception|\Throwable $ex) {
  7377.                 $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ' $ex->getMessage(), null$collegamentoRnd'ImportazioneController''importaArticoliPicardXML');
  7378.                 //unlink($root_path); //Elimino il file temporaneo
  7379.                 return new Response('Errore importazione: ' $ex->getMessage() . '<br/>' $this->servizi->DebuggaException($ex''true$collegamentoRnd'ImportazioneController''importaArticoliPicardXML'));
  7380.             }
  7381.         } else {
  7382.             $this->ScriviRegistroAttivita(null$request->getClientIp(), ""false'Errore importazione: ERRORE_PERMESSO'null$collegamentoRnd'ImportazioneController''importaArticoliPicardXML');
  7383.             return new Response("ERRORE PERMESSO");
  7384.         }
  7385.     }
  7386.     function ritornaCategoria($catalogGroupId$strutturaCategorie$arrayCategorie = array())
  7387.     {
  7388.         if(isset($strutturaCategorie[$catalogGroupId])) {
  7389.             $elemento $strutturaCategorie[$catalogGroupId];
  7390.             if ($elemento) {
  7391.                 $categoria $this->servizi->doctrine->getRepository(Categorie::class)->findOneBy(array('codice' => ('PKR_' $catalogGroupId)));
  7392.                 if ($categoria) {
  7393.                     array_push($arrayCategorie$categoria);
  7394.                     if ($elemento[2] != '0') {
  7395.                         $arrayCategorie self::ritornaCategoria($elemento[2], $strutturaCategorie$arrayCategorie);
  7396.                     }
  7397.                 }
  7398.             }
  7399.         }
  7400.         return $arrayCategorie;
  7401.     }
  7402. }