src/Services/CommonTools.php line 59

Open in your IDE?
  1. <?php
  2. //----------------------------------------------------------------------
  3. // src/Services/CommonTools.php
  4. //----------------------------------------------------------------------
  5. namespace App\Services;
  7. use Doctrine\Persistence\ManagerRegistry;
  8. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  9. use Symfony\Component\HttpFoundation\RequestStack;
  10. use Symfony\Component\PropertyAccess\PropertyAccess;
  12. use App\Entity\Access;
  13. use App\Entity\AccessClient\AccessClient;
  14. use App\Entity\Client\Client;
  15. use App\Entity\Client\Title;
  16. use App\Entity\Common\Attachment;
  17. use App\Entity\SocietyGroup;
  18. use App\Entity\Config\Config;
  19. use App\Entity\Config\Module;
  20. use App\Entity\Config\OptionConfig;
  21. use App\Entity\Ikea\ServiceOrder as IkeaServiceOrder;
  22. use App\Entity\Ikea\Product as IkeaProduct;
  23. use App\Entity\Ikea\Template as IkeaTemplate;
  24. use App\Entity\Ikea\TemplateProduct as IkeaTemplateProduct;
  25. use App\Entity\Log\ChangeLog;
  26. use App\Entity\Mission\Mission;
  27. use App\Entity\Mission\MissionOrigin;
  28. use App\Entity\Mission\MissionProject;
  29. use App\Entity\Mission\MissionStatus;
  30. use App\Entity\Mission\MissionType;
  31. use App\Entity\Planning\PlanningResource;
  32. use App\Entity\Planning\TaskStatus;
  33. use App\Entity\Planning\TaskType;
  34. use App\Entity\Platform\Devis\Devis;
  35. use App\Entity\Platform\Origin;
  36. use App\Entity\Platform\PaymentDeadline;
  37. use App\Entity\Platform\SocietyGroup\SocietyGroupFavorite;
  38. use App\Entity\Product\Product;
  39. use App\Entity\Product\Template;
  40. use App\Entity\Webapp\Components\AnomalyAction;
  41. use App\Entity\Webapp\Components\AnomalyCharge;
  42. use App\Entity\Webapp\Components\AnomalyProduct;
  43. use App\Entity\Webapp\Components\AnomalyReason;
  44. use App\Entity\Webapp\Components\AnomalyState;
  45. use App\Entity\Webapp\Components\InterventionType;
  46. use App\Entity\Webapp\Components\ReportType;
  47. use App\Entity\Webapp\Components\Satisfaction;
  48. use App\Services\LogTools;
  49. use App\Services\AccessClient\AccessClientTools;
  50. use App\Services\Config\ModuleTools;
  52. class CommonTools
  53. {
  54.     public function __construct(ManagerRegistry $doctrine, RequestStack $requestStack, UrlGeneratorInterface $router,
  55.     LogTools $logTools, ModuleTools $moduleTools, AccessClientTools $accessClientTools)
  56.     {
  57.         $this->em = $doctrine->getManager();
  58.         $this->requestStack = $requestStack;
  59.         $this->router = $router;
  60.         $this->logTools = $logTools;
  61.         $this->moduleTools = $moduleTools;
  62.         $this->accessClientTools = $accessClientTools;
  63.     }
  65.     // Plan.io Task #4412
  66.     // Only use 10, 25, 50, 100
  67.     const dtDisplayLinesDefault = 100;
  68.     const dtDisplayLines = [
  69.         'command'            => 50,
  70.         'cost'              => 50,
  71.         'devis'                => 50,
  72.         'individual'        => 50,
  73.         'installment'        => 50,
  74.         'invoice'            => 50,
  75.         'itask'                => 50,
  76.         'mission'            => 50,
  77.         'prospect'            => 50,
  78.         'store'                => 50,
  79.         'webapp_document'   => 50,
  80.     ];
  82.     public function getClientIp()
  83.     {
  84.         $request = $this->requestStack->getCurrentRequest();
  85.         if ($request)
  86.         {
  87.             $clientIp = $request->getClientIp();
  88.             return $clientIp;
  89.         }
  90.         return null;
  91.     }    
  93.     // Plan.io Task #3801
  94.     // Pour la 5.4 faudrait essayer d'utiliser ça partout ou on a besoin de créer un url
  95.     public function craftUrl(string $routeName, $args = []): string
  96.     {
  97.         $config = $this->em->getRepository(Config::class)->findOneByName(Config::URL);
  98.         $url = $config->getValue();
  99.         $route = $this->router->generate($routeName, $args);
  100.         return $url.$route;
  101.     }
  103.     // Plan.io Task #4518
  104.     // But also impacts emails and many other things
  106.     // Get the SocietyGroup of the Object triggering an Event (Notification, Email, other...)
  107.     // This one is tricky, since it needs to take into account the Mission of the Object
  108.     // Is it shared or not ?
  109.     //    1. Not shared => Easy, take the SocietyGroup from the Mission
  110.     //        it is the same as the object's, and the object's client's
  111.     //     2. Shared => The object and the client do not have the same SocietyGroup
  112.     //        The TriggerEvents / EmailConfigs etc must be the ones from the SocietyGroup handling the Mission
  113.     //        ie. Mission.societyGroupOwner    
  114.     public function getSocietyGroup($object)
  115.     {
  116.         $error = null;
  117.         $societyGroup = null;
  119.         $debugMsgInfo = "[".$object->displayForLog()."] ";
  121.         if (!method_exists($object, "getMission"))
  122.         {
  123.             $error = $debugMsgInfo."[Die.Hard] Object has no Mission ".$object->displayForLog();
  124.             $this->logTools->errorlog($error);
  125.             return null;
  126.         }
  128.         // Get the Mission from the object
  129.         // Exception => Ikea ServiceOrders may not have Missions
  130.         if ($object instanceof IkeaServiceOrder)
  131.         {
  132.             return $object->getSocietyGroup();
  133.         }
  135.         $mission = $object->getMission();
  136.         if ($mission === null)
  137.         {
  138.             $error = $debugMsgInfo."[Die.Hard] Mission is null for ".$object->displayForLog();
  139.             $this->logTools->errorlog($error);
  140.             return null;
  141.         }
  143.         // Get the SocietyGroup Owner from the Mission
  144.         $societyGroup = $mission->getSocietyGroupOwner();
  145.         if ($societyGroup === null)
  146.         {
  147.             $error = $debugMsgInfo."[Die.Hard] SocietyGroupOwner is null for Mission ".$mission->displayForLog();
  148.             $this->logTools->errorlog($error);
  149.             return null;
  150.         }
  152.         return $societyGroup;
  153.     }    
  155.     // Plan.io Task #4412
  156.     public function getDtDisplayLines($key)
  157.     {
  158.         if (array_key_exists($key, self::dtDisplayLines))
  159.         {
  160.             return self::dtDisplayLines[$key];
  161.         }
  162.         return self::dtDisplayLinesDefault;
  163.     }
  165.     //--------------------------------------------------------------------------
  166.     // Plan.io Task #4327
  167.     // We need the following methods here, so we can call them in twig
  168.     public function clientHasAccessClient(Client $client)
  169.     {
  170.         return $this->accessClientTools->clientHasAccessClient($client);
  171.     }
  172.     public function missionHasAccessClient(Mission $mission)
  173.     {
  174.         return $this->accessClientTools->missionHasAccessClient($mission);
  175.     }
  176.     public function canBeMadeVisible($object, SocietyGroup $societyGroup)
  177.     {
  178.         return $this->accessClientTools->canBeMadeVisible($object, $societyGroup);
  179.     }
  181.     public function isActiveJcaf()
  182.     {
  183.         $config = $this->em->getRepository(Config::class)->findOneByName(Config::JCAF_STATE);
  184.         if ($config === null)
  185.         {
  186.             return false;
  187.         }
  188.         return boolval($config->getValue());
  189.     }
  190.     //--------------------------------------------------------------------------
  192.     public function bubbleSortObjects($array, $fieldToCompare)
  193.     {
  194.         $propertyAccessor = PropertyAccess::createPropertyAccessor();
  196.         if (!$length = count($array))
  197.         {
  198.             return $array;
  199.         }
  200.         for ($outer = 0; $outer < $length; $outer++)
  201.         {
  202.             for ($inner = 0; $inner < $length; $inner++)
  203.             {
  204.                 $outerValue = $propertyAccessor->getValue($array[$outer], $fieldToCompare);
  205.                 $innerValue = $propertyAccessor->getValue($array[$inner], $fieldToCompare);
  207.                 if ($outerValue < $innerValue)
  208.                 {
  209.                     $tmp = $array[$outer];
  210.                     $array[$outer] = $array[$inner];
  211.                     $array[$inner] = $tmp;
  212.                 }
  213.             }
  214.         }
  215.         return $array;
  216.     }
  218.     public function isNotFavorite($societyGroup, $candidate)
  219.     {
  220.         return !$this->isFavorite($societyGroup, $candidate);
  221.     }
  223.     public function isFavorite($societyGroup, $candidate)
  224.     {
  225.         $item = $this->em->getRepository(SocietyGroupFavorite::class)
  226.             ->findOneBy(array(
  227.                 'societyGroup'        =>    $societyGroup,
  228.                 'favorite'            =>    $candidate,
  229.             ));
  230.         if ($item !== null)
  231.         {
  232.             return true;
  233.         }
  234.         return false;
  235.     }
  237.     public function getFavorite($societyGroup, $candidate)
  238.     {
  239.         $item = $this->em->getRepository(SocietyGroupFavorite::class)
  240.             ->findOneBy(array(
  241.                 'societyGroup'        =>    $societyGroup,
  242.                 'favorite'            =>    $candidate,
  243.             ));
  244.         return $item;
  245.     }
  247.     public function copyFile($rootDir, $source, $destination)
  248.     {
  249.         if ($rootDir !== null)
  250.         {
  251.             // Does the path to the destination folder exists ?
  252.             // copy() requires the destination folder to exist
  253.             $do = true;
  254.             if (file_exists($rootDir) === false)
  255.             {
  256.                 $do = mkdir($rootDir, 0755, true);
  258.                 if ($do === false)
  259.                 {
  260.                     // Something went wrong
  261.                     $this->logTools->errorlog("Error mkdir for path = ".$rootDir);
  263.                     // Skip to the next file
  264.                     return false;
  265.                 }
  266.             }
  267.         }
  269.         // If we are here it means that we have the destination folder
  270.         // (or that we don't care)
  271.         // Copy the actual files
  272.         $do = copy($source, $destination);
  273.         if ($do === false)
  274.         {
  275.             // Something went wrong
  276.             $this->logTools->errorlog("Error copy for source = ".$source." and destination = ".$destination);
  278.             // Skip to next file
  279.             return false;
  280.         }
  281.         return true;
  282.     }
  284.     public function moveFile($source, $destination)
  285.     {
  286.         // If we are here it means that we have the destination folder
  287.         // (or that we don't care)
  288.         // Copy the actual files
  289.         $do = rename($source, $destination);
  290.         if ($do === false)
  291.         {
  292.             // Something went wrong
  293.             $this->logTools->errorlog("Error move for source = ".$source." and destination = ".$destination);
  295.             // Skip to next file
  296.             return false;
  297.         }
  298.         return true;
  299.     }
  301.     // For RHForms, the attachments are attached to the child (rhFormLeave for example)
  302.     // but need to be created and linked for the pareny ($rhFormLeave->getParent())
  303.     // So pass directly the JSON from the form to this method
  304.     public function handleAttachments($object, $files = null)
  305.     {
  306.         $attachments = array();
  308.         // Either fetch the files from the arguments, or from the object itself
  309.         if ($files === null) $files = $object->getFiles();
  311.         if ($files !== null)
  312.         {
  313.             $files = json_decode($files, true);
  315.             $attachmentRepository = $this->em->getRepository(Attachment::class);
  317.             foreach ($files as $uuid)
  318.             {
  319.                 $attachment = $attachmentRepository->findOneByUuid($uuid);
  320.                 if ($attachment !== null)
  321.                 {
  322.                     $object->addAttachment($attachment);
  323.                     $attachments[] = $attachment;
  324.                 }
  325.             }
  326.         }
  328.         return $attachments;
  329.     }
  331.     public function displayMultipleSocieties(SocietyGroup $societyGroup)
  332.     {
  333.         // If the society group has more than one society,
  334.         // we mult display them all
  335.         // without taking the config into account
  337.         if ($societyGroup->getSocieties()->count() > 1)
  338.         {
  339.             return true;
  340.         }
  342.         // If a single society in the group, check to see if the society module is activated
  343.         $societyModuleActivated = false;
  344.         if ($this->moduleTools->isActiveByCode($societyGroup, Module::MODULE_SOCIETY))
  345.         {
  346.             $societyModuleActivated = true;
  347.         }
  349.         if ($societyModuleActivated === true)
  350.         {
  351.             // Display multiple societies
  352.             return true;
  353.         }
  354.         else
  355.         {
  356.             // Don't display the society notion
  357.             return false;
  358.         }
  359.     }
  361.     public function displayOneSociety(SocietyGroup $societyGroup)
  362.     {
  363.         return !$this->displayMultipleSocieties($societyGroup);
  364.     }
  366.     public function getCssFile(SocietyGroup $societyGroup)
  367.     {
  368.         if($societyGroup == null)
  369.         {
  370.             return 'variables.css';
  371.         }
  372.         else
  373.         {
  374.             // ROOT/public/theme/css/
  375.             $path = $this->logTools->getCssDir();
  376.             $filename = 'variables_' . $societyGroup->getId() . '.css';
  377.             $file = $path . $filename;
  379.             if(file_exists($file))
  380.             {
  381.                 return $filename;
  382.             }
  383.             else
  384.             {
  385.                 return 'variables.css';
  386.             }
  387.         }
  388.     }
  390.     // Plan.io Task #4327
  391.     // This code needs to be in this service to be used by Twig
  392.     public function getCssFileForAccessClient(AccessClient $accessClient)
  393.     {
  394.         $accessClientRecords = $accessClient->getAccessClientRecords();
  395.         if (count($accessClientRecords) < 1)
  396.         {
  397.             return 'variables.css';
  398.         }
  400.         $societyGroup = $accessClientRecords[0]->getSocietyGroup();
  401.         if ($societyGroup === null)
  402.         {
  403.             return 'variables.css';
  404.         }
  406.         return $this->getCssFile($societyGroup);
  407.     }
  409.     // Plan.io Task #4455
  410.     // This code needs to be in this service to be used by Twig
  411.     public function getLogoHeaderForAccessClient(AccessClient $accessClient)
  412.     {
  413.         $logos = array();
  415.         $accessClientRecords = $accessClient->getAccessClientRecords();
  416.         foreach ($accessClientRecords as $record)
  417.         {
  418.             $societyGroup = $record->getSocietyGroup();
  419.             if ($societyGroup === null)
  420.             {
  421.                 continue;
  422.             }
  423.             $logo = $societyGroup->getLogo();
  424.             if ($logo === null)
  425.             {
  426.                 continue;
  427.             }
  429.             $logos[] = $logo->getUrlForDisplay();
  430.         }
  432.         if (empty($logos))
  433.         {
  434.             $logos[] = 'assets/logo-rekapp.png';
  435.         }
  437.         return $logos;
  438.     }
  440.     public function getStorageInfo($societyGroup)
  441.     {
  442.         $cloudSize = 0;        $cloudSizeMb = 0;        $cloudSizeGb = 0;        $cloudPercentage = 0;
  443.         $platformSize = 0;    $platformSizeMb = 0;    $platformSizeGb = 0;    $platformPercentage = 0;
  444.         $webappSize = 0;    $webappSizeMb = 0;        $webappSizeGb = 0;        $webappPercentage = 0;
  446.         $used = 0;
  447.         $usedPercentage = 0;
  449.         $maxStorageSizePerAccess = $this->em->getRepository(OptionConfig::class)
  450.             ->findOneBy(array(
  451.                 'code'                =>    OptionConfig::MAX_STORAGE_SIZE_FOR_ACCESS_CODE,
  452.                 'societyGroup'        =>    $societyGroup,
  453.             ));
  454.         if ($maxStorageSizePerAccess === null)
  455.         {
  456.             // This should not happen, but just in case
  457.             $maxStorageSizePerAccess = $this->em->getRepository(Config::class)
  458.                 ->findOneBy(array(
  459.                     'name'                =>    Config::DEFAULT_MAX_STORAGE_SIZE_FOR_ACCESS,
  460.                 ));
  461.             if ($maxStorageSizePerAccess === null)
  462.             {
  463.                 return null;
  464.             }
  465.         }
  467.         $activeUsers = $this->em->getRepository(Access::class)
  468.             ->getActiveForSocietyGroup($societyGroup);
  470.         $maxStorageSizePerAccess = $maxStorageSizePerAccess->getValue();
  471.         $maxStorageSize = $maxStorageSizePerAccess * count($activeUsers);
  473.         $path = str_replace("src/Services/CommonTools.php", "", __FILE__);
  474.         $path = $path . "DMS/";
  476.         $cloudPath = $path . "Cloud/".$societyGroup->getId();
  477.         $platformPath = $path . "Platform/".$societyGroup->getId();
  478.         $webappPath = $path . "Webapp/Images/".$societyGroup->getId();
  480.         if (is_dir($cloudPath))
  481.         {
  482.             $cloudSize = $this->folderSize($cloudPath) / 1024;
  483.             $cloudSizeMb = $cloudSize / 1024;
  484.             $cloudSizeGb = $cloudSizeMb / 1024;
  486.             if ($maxStorageSize == 0)
  487.                 $cloudPercentage = 0;
  488.             else
  489.                 $cloudPercentage = (100 * $cloudSizeMb) / $maxStorageSize;
  491.             $used += $cloudSize;
  492.             $usedPercentage += $cloudPercentage;
  493.         }
  494.         if (is_dir($platformPath))
  495.         {
  496.             $platformSize = $this->folderSize($platformPath) / 1024;
  497.             $platformSizeMb = $platformSize / 1024;
  498.             $platformSizeGb = $platformSizeMb / 1024;
  500.             if ($maxStorageSize == 0)
  501.                 $platformPercentage = 0;
  502.             else
  503.                 $platformPercentage = (100 * $platformSizeMb) / $maxStorageSize;
  505.             $used += $platformSize;
  506.             $usedPercentage += $platformPercentage;
  507.         }
  508.         if (is_dir($webappPath))
  509.         {
  510.             $webappSize = $this->folderSize($webappPath) / 1024;
  511.             $webappSizeMb = $webappSize / 1024;
  512.             $webappSizeGb = $webappSizeMb / 1024;
  514.             if ($maxStorageSize == 0)
  515.                 $webappPercentage = 0;
  516.             else
  517.                 $webappPercentage = (100 * $webappSizeMb) / $maxStorageSize;
  519.             $used += $webappSize;
  520.             $usedPercentage += $webappPercentage;
  521.         }
  523.         // Format numbers
  525.         $maxStorageSizePerAccess = number_format($maxStorageSizePerAccess, 2, ".", "");
  526.         $maxStorageSizePerAccessGb = number_format($maxStorageSizePerAccess / 1024, 2, ".", "");
  528.         $maxStorageSize = number_format($maxStorageSize, 2, ".", "");
  529.         $maxStorageSizeGb = number_format($maxStorageSize / 1024, 2, ".", "");
  531.         $used = number_format($used, 2, ".", "");
  532.         $usedMb = number_format($used / 1024, 2, ".", "");
  533.         $usedGb = number_format($usedMb / 1024, 2, ".", "");
  534.         $usedPercentage = number_format($usedPercentage, 2, ".", "");
  536.         $cloudSize = number_format($cloudSize, 2, ".", "");
  537.         $cloudSizeMb = number_format($cloudSizeMb, 2, ".", "");
  538.         $cloudSizeGb = number_format($cloudSizeGb, 2, ".", "");
  539.         $cloudPercentage = number_format($cloudPercentage, 2, ".", "");
  541.         $platformSize = number_format($platformSize, 2, ".", "");
  542.         $platformSizeMb = number_format($platformSizeMb, 2, ".", "");
  543.         $platformSizeGb = number_format($platformSizeGb, 2, ".", "");
  544.         $platformPercentage = number_format($platformPercentage, 2, ".", "");
  546.         $webappSize = number_format($webappSize, 2, ".", "");
  547.         $webappSizeMb = number_format($webappSizeMb, 2, ".", "");
  548.         $webappSizeGb = number_format($webappSizeGb, 2, ".", "");
  549.         $webappPercentage = number_format($webappPercentage, 2, ".", "");
  551.         $sizes = array(
  552.             'maxStorageSizePerAccess'        =>    $maxStorageSizePerAccess,
  553.             'maxStorageSizePerAccessGb'        =>    $maxStorageSizePerAccessGb,
  555.             'maxStorageSize'                =>    $maxStorageSize,
  556.             'maxStorageSizeGb'                =>    $maxStorageSizeGb,
  558.             'used'                    =>    array(
  560.                 'size'                =>    $used,
  561.                 'size_mb'            =>    $usedMb,
  562.                 'size_gb'            =>    $usedGb,
  563.                 'percentage'        =>    $usedPercentage,
  564.             ),
  566.             'data'                    =>    array(
  568.                 'cloud'                =>    array(
  569.                     'size'            =>    $cloudSize,
  570.                     'size_mb'        =>    $cloudSizeMb,
  571.                     'size_gb'        =>    $cloudSizeGb,
  572.                     'percentage'    =>    $cloudPercentage,
  573.                 ),
  574.                 'platform'            =>    array(
  575.                     'size'            =>    $platformSize,
  576.                     'size_mb'        =>    $platformSizeMb,
  577.                     'size_gb'        =>    $platformSizeGb,
  578.                     'percentage'    =>    $platformPercentage,
  579.                 ),
  580.                 'webapp'            =>    array(
  581.                     'size'            =>    $webappSize,
  582.                     'size_mb'        =>    $webappSizeMb,
  583.                     'size_gb'        =>    $webappSizeGb,
  584.                     'percentage'    =>    $webappPercentage,
  585.                 ),
  586.             ),
  587.         );
  589.         return $sizes;
  590.     }
  592.     function folderSize($dir)
  593.     {
  594.         $size = 0;
  596.         foreach (glob(rtrim($dir, '/').'/*', GLOB_NOSORT) as $each)
  597.         {
  598.             //$tmp = filesize($each);
  599.             $tmp = stat($each)['blocks'] * 512;
  600.             //$tmp = ceil(stat($each)['size']/1024);
  601.             $size += is_file($each) ? $tmp : $this->folderSize($each);
  602.         }
  604.         return $size;
  605.     }
  607.     // This method sort two array of object according to 'position' field
  608.     // (Main case if for Devis => DevisTitle and DevisProduct)
  609.     public function sortByPosition(array $firtArray, array $secondArray)
  610.     {
  611.         $elementsMerged = array_merge($firtArray, $secondArray);
  613.         // Sort on position
  614.         if (count($elementsMerged))
  615.         {
  616.             $iterator = $elementsMerged;
  617.             uasort($elementsMerged,function ($first, $second)
  618.             {
  619.                 return (int) $first->getPosition() > (int) $second->getPosition() ? 1 : -1;
  620.             });
  621.         }
  623.         return $elementsMerged;
  624.     }
  626.     public function deleteDir($src)
  627.     {
  628.         if (is_dir($src))
  629.         {
  630.             $dir = opendir($src);
  631.             while(false !== ( $file = readdir($dir)) )
  632.             {
  633.                 if (( $file != '.' ) && ( $file != '..' ))
  634.                 {
  635.                     if ( is_dir($src . '/' . $file) )
  636.                     {
  637.                         $this->deleteDir($src . '/' . $file);
  638.                     }
  639.                     else
  640.                     {
  641.                         unlink($src . '/' . $file);
  642.                     }
  643.                 }
  644.             }
  645.             closedir($dir);
  646.             rmdir($src);
  647.         }
  648.     }
  650.     public function isSuperadmin(Access $access, $societyGroup = null)
  651.     {
  652.         if ($societyGroup !== null)
  653.         {
  654.             if ($societyGroup->getAdmin() !== null && $societyGroup->getAdmin()->equals($access))
  655.             {
  656.                 return true;
  657.             }
  658.             return false;
  659.         }
  660.         else
  661.         {
  662.             $groups = $this->em->getRepository(SocietyGroup::class)
  663.                 ->findAll();
  664.             foreach ($groups as $societyGroup)
  665.             {
  666.                 if ($societyGroup->getAdmin() !== null && $societyGroup->getAdmin()->equals($access))
  667.                 {
  668.                     return true;
  669.                 }
  670.             }
  671.             return false;
  672.         }
  673.     }
  675.     public function checkPaySettings($societyGroup)
  676.     {
  677.         $paymentDeadline = $this->em->getRepository(PaymentDeadline::class);
  679.         $missing = array();
  681.         $objects = $paymentDeadline->findBySocietyGroup($societyGroup);
  683.         if (count($objects) < 1)
  684.             $missing[] = 'payment_deadline';
  686.         return $missing;
  687.     }
  689.     public function checkIndividualSettings($societyGroup)
  690.     {
  691.         $originRep = $this->em->getRepository(Origin::class);
  692.         $titleRep = $this->em->getRepository(Title::class);
  694.         $missing = array();
  696.         $objects = $originRep->findBySocietyGroup($societyGroup);
  698.         if (count($objects) < 1)
  699.             $missing[] = 'origin';
  701.         $objects = $titleRep->findBySocietyGroup($societyGroup);
  703.         if (count($objects) < 1)
  704.             $missing[] = 'title';
  706.         return $missing;
  707.     }
  709.     public function checkRfiSettings($societyGroup)
  710.     {
  711.         $typeRep = $this->em->getRepository(InterventionType::class);
  712.         $satisfactionRep = $this->em->getRepository(Satisfaction::class);
  714.         $missing = array();
  716.         $objects = $typeRep->findBySocietyGroup($societyGroup);
  718.         if (count($objects) < 1)
  719.             $missing[] = 'intervention_type';
  721.         $objects = $satisfactionRep->findBySocietyGroup($societyGroup);
  723.         if (count($objects) < 1)
  724.             $missing[] = 'satisfaction';
  726.         return $missing;
  727.     }
  729.     public function checkAnomalySettings($societyGroup)
  730.     {
  731.         $actionRep = $this->em->getRepository(AnomalyAction::class);
  732.         $productRep = $this->em->getRepository(AnomalyProduct::class);
  733.         $chargeRep = $this->em->getRepository(AnomalyCharge::class);
  734.         $reasonRep = $this->em->getRepository(AnomalyReason::class);
  735.         $stateRep = $this->em->getRepository(AnomalyState::class);
  737.         $missing = array();
  739.         $objects = $actionRep->findBySocietyGroup($societyGroup);
  741.         if (count($objects) < 1)
  742.             $missing[] = 'anomaly_action_label';
  744.         $objects = $productRep->findBySocietyGroup($societyGroup);
  746.         if (count($objects) < 1)
  747.             $missing[] = 'anomaly_product_label';
  749.         $objects = $chargeRep->findBySocietyGroup($societyGroup);
  751.         if (count($objects) < 1)
  752.             $missing[] = 'anomaly_charge_label';
  754.         $objects = $reasonRep->findBySocietyGroup($societyGroup);
  756.         if (count($objects) < 1)
  757.             $missing[] = 'anomaly_reason_label';
  759.         $objects = $stateRep->findBySocietyGroup($societyGroup);
  761.         if (count($objects) < 1)
  762.             $missing[] = 'anomaly_state_label';
  764.         return $missing;
  765.     }
  767.     public function checkReportSettings($societyGroup)
  768.     {
  769.         $typeRep = $this->em->getRepository(ReportType::class);
  771.         $missing = array();
  773.         $objects = $typeRep->findBySocietyGroup($societyGroup);
  775.         if (count($objects) < 1)
  776.             $missing[] = 'report_type';
  778.         return $missing;
  779.     }
  781.     public function missionTypeHasMissions($type)
  782.     {
  783.         $mission = $this->em->getRepository(Mission::class)
  784.             ->findOneByType($type);
  785.         if ($mission !== null)
  786.         {
  787.             return true;
  788.         }
  789.         return false;
  790.     }
  792.     public function getLastChangelog()
  793.     {
  794.         $changeLogRepo = $this->em->getRepository(ChangeLog::class);
  795.         $changeLog = $changeLogRepo->findOneBy(
  796.             array('published' => true),
  797.             array('effectiveDate'=>'DESC'),
  798.         );
  800.         $version = "";
  801.         if($changeLog !== null)
  802.         {
  803.             $version = $changeLog->getVersion();
  804.         }
  806.         return $version;
  807.     }
  809.     public function isBool($value)
  810.     {
  811.         // Strict check to avoid "true", "false"
  812.         if ($value === false || $value === true)
  813.         {
  814.             return true;
  815.         }
  817.         if ($value == 0 || $value == 1)
  818.         {
  819.             return true;
  820.         }
  822.         return false;
  823.     }
  825.     // This method will get the last position from the repository ($repositoryName)
  826.     // and update '$object' with the right position
  827.     public function handleLastPositionLabel($object, string $repositoryName, SocietyGroup $societyGroup)
  828.     {
  829.         $repository = $this->em->getRepository($repositoryName);
  830.         $objectsPosition = $repository->getLastPositionObject($societyGroup);
  832.         $lastPosition = 0;
  834.         if (sizeof($objectsPosition) > 0)
  835.         {
  836.             $lastPosition = $objectsPosition[0]->getPosition();
  837.         }
  839.         $object->setPosition($lastPosition + 1);
  841.         $this->em->persist($object);
  842.     }
  844.     public function handlePositionAfterDeleteLabel($oldPos, string $repositoryName, SocietyGroup $societyGroup)
  845.     {
  846.         $repository = $this->em->getRepository($repositoryName);
  847.         $objectsPositions = $repository->findBy(
  848.             array(
  849.                 'societyGroup' => $societyGroup,
  850.             ),array(
  851.                 'position' => 'ASC',
  852.             ));
  854.         foreach($objectsPositions as $obj)
  855.         {
  856.             if ($obj->getPosition() > $oldPos)
  857.             {
  858.                 $obj->setPosition($obj->getPosition() - 1);
  859.                 $this->em->persist($obj);
  860.             }
  861.         }
  862.     }
  864.     public function getBannerMaintenance()
  865.     {
  866.         $session = $this->requestStack->getSession();
  868.         // check session
  869.         $banner = $session->get('_banner_maintenance');
  871.         // if '_banner_maintenance' is not null return void to don't show the banner
  872.         if ($banner == 1)
  873.         {
  874.              return null;
  875.         }
  877.         return $this->getBannerMaintenanceConfig();
  878.     }
  880.     public function getBannerMaintenanceConfig()
  881.     {
  882.         $repoConfig = $this->em->getRepository(Config::class);
  883.         $configBanner = $repoConfig->findOneByName(Config::MAINTENANCE_INFO_BANNER);
  885.         if ($configBanner === null)
  886.         {
  887.              return null;
  888.         }
  890.         if ($configBanner->getValue() == 0)
  891.         {
  892.              return null;
  893.         }
  895.         return $configBanner;
  896.     }
  898.     /**
  899.      * Set maintenance mode on the whole platforme :
  900.      * - No access for non super admin
  901.      * - Display maintenance banner
  902.      * - Stop ikea import
  903.      *
  904.      *
  905.      *
  906.      * @param  string $mode = up | down
  907.      * @return array
  908.      */
  909.     public function setMaintenanceMode(string $mode): array
  910.     {
  911.         $maintenance = $this->em->getRepository(Config::class)->findOneByName(Config::MAINTENANCE);
  913.         if ($maintenance === null)
  914.         {
  915.             $maintenance = new Config();
  916.             $maintenance->setName(Config::MAINTENANCE);
  917.             $this->em->persist($maintenance);
  918.         }
  921.         // Get Config Ikea import in progress
  922.         $configIkeaImportInProgress = $this->em->getRepository(Config::class)->findOneByName(Config::IKEA_IMPORT_IN_PROGRESS);
  924.         $lockFile = dirname(__FILE__, 3). "/icod.lock";
  926.         // Try to put on the banner and disable ikea import
  927.         if($mode == 'up')
  928.         {
  929.             if ($configIkeaImportInProgress === null)
  930.             {
  931.                 return array('status' => 'error', 'msg' => 'Ikea Config not found');
  932.             }
  933.             if ($configIkeaImportInProgress !== null && $configIkeaImportInProgress->getValue())
  934.             {
  935.                 // Do not allow the banner if Ikea import is in progress
  936.                 return array('status' => 'error', 'msg' => 'Ikea Import in Progress');
  937.             }
  939.             // Enable Banner
  940.             $maintenance->setValue(1);
  941.             // Disable Ikea Import (ikea import is in progress = no more action)
  942.             $configIkeaImportInProgress->setValue(1);
  944.             // Create file icod.lock to stop loadBalancer replication in Prod
  945.             $file = fopen($lockFile, 'w');
  946.             fclose($file);
  947.         }
  948.         else if( $mode = 'down' ) // put down maintenance mode
  949.         {
  950.             // Disable Banner
  951.             $maintenance->setValue(0);
  952.             // Enable Ikea Import (ikea import is not in progress = ne import can be started)
  953.             $configIkeaImportInProgress->setValue(0);
  955.             // Remove file icod.lock to restart loadBalancer replication in Prod
  956.             if(file_exists($lockFile))
  957.                 unlink($lockFile);
  958.         }
  960.         return array('status' => 'success', 'msg' => '');
  961.     }
  963.     // Input : Array of objects
  964.     // Output : String "(idObject1, idObject2, ...)" or "(0)", if empty array
  965.     public function objectsToString($objects)
  966.     {
  967.         if (!is_array($objects))
  968.         {
  969.             return "(0)";
  970.         }
  972.         $in = "";
  973.         foreach ($objects as $object)
  974.         {
  975.             if (!method_exists($object, 'getId'))
  976.             {
  977.                 continue;
  978.             }
  980.             $in .= $object->getId();
  981.             $in .= ",";
  982.         }
  983.         if ($in != "")
  984.         {
  985.             $in = substr($in, 0, -1);
  986.             $in = "(".$in.")";
  987.         }
  988.         else
  989.         {
  990.             $in = "(0)";
  991.         }
  992.         return $in;
  993.     }
  995.     // Input : Array of objects
  996.     // Output : String "(id1, id2, ...)" or "(0)", if empty array
  997.     public function arrayToString($ids)
  998.     {
  999.         if (!is_array($ids) || empty($ids))
  1000.         {
  1001.             return "(0)";
  1002.         }
  1004.         $in = "";
  1005.         foreach ($ids as $id)
  1006.         {
  1007.             $in .= $id;
  1008.             $in .= ",";
  1009.         }
  1010.         if ($in != "")
  1011.         {
  1012.             $in = substr($in, 0, -1);
  1013.             $in = "(".$in.")";
  1014.         }
  1015.         else
  1016.         {
  1017.             $in = "(0)";
  1018.         }
  1019.         return $in;
  1020.     }
  1022.     // Input : String link of image
  1023.     // Output : String base64 encoded image
  1024.     // Updated by : Plan.io #4132
  1025.     public function imageToBase64(string $img): string
  1026.     {
  1027.         $type = pathinfo($img, PATHINFO_EXTENSION);
  1028.         $data = file_get_contents($img);
  1029.         return 'data:image/' . $type . ';base64,' . base64_encode($data);
  1030.     }
  1032.     // Input : String link of image
  1033.     // Output : String base64 encoded image
  1034.     // Updated by : Plan.io #4132
  1035.     public function imageToBase64FromRoot(string $img): string
  1036.     {
  1037.         $basePath = $this->logTools->getRootDir() . "/";
  1038.         $img = $basePath . $img;
  1039.         return $this->imageToBase64($img);
  1040.     }
  1042.     // Input : String link of image
  1043.     // Output : String base64 encoded image
  1044.     // Updated by : Plan.io #4132
  1045.     public function imageToBase64FromPublic(string $img): string
  1046.     {
  1047.         $basePath = $this->logTools->getPublicDir();
  1048.         $img = $basePath . $img;
  1049.         return $this->imageToBase64($img);
  1050.     }
  1052.     // Task plan.io #3690
  1053.     public function getNumberPlanningResource(SocietyGroup $societyGroup)
  1054.     {
  1055.         $countPlanningResourceResult = $this->em
  1056.             ->getRepository(PlanningResource::class)
  1057.             ->countPlanningResource($societyGroup);
  1059.         return $countPlanningResourceResult;
  1060.     }
  1062.     // Plan.io Task #3664
  1063.     public function getIkeaTemplateProduct(IkeaTemplate $ikeaTemplate, Template $productTemplate, IkeaProduct $ikeaProduct)
  1064.     {
  1065.         $object =  $this->em->getRepository(IkeaTemplateProduct::class)
  1066.             ->findOneBy(array(
  1067.                 "ikeaTemplate"         => $ikeaTemplate,
  1068.                 "ikeaProduct"        => $ikeaProduct,
  1069.                 "platformTemplate"    => $productTemplate,
  1070.             ));
  1072.         return $object;
  1073.     }
  1075.     // Plan.io Task #4561
  1076.     public function ikeaTemplateProductExists(Product $product, IkeaProduct $ikeaProduct)
  1077.     {
  1078.         $object =  $this->em->getRepository(IkeaTemplateProduct::class)
  1079.             ->findOneBy(array(                
  1080.                 "ikeaProduct"        => $ikeaProduct,
  1081.                 "platformProduct"    => $product,
  1082.             ));
  1084.         return $object;
  1085.     }
  1086. }