src/Event/EasyAdminSubscriber.php line 172

Open in your IDE?
  1. <?php
  4. namespace App\Event;
  6. use App\Entity\Algorithm;
  7. use App\Entity\AlgorithmCondition;
  8. use App\Entity\App;
  9. use App\Entity\AppTranslations;
  10. use App\Entity\Category;
  11. use App\Entity\Disease;
  12. use App\Entity\Drug;
  13. use App\Entity\Flow;
  14. use App\Entity\Import;
  15. use App\Entity\Language;
  16. use App\Entity\ObjectType;
  17. use App\Entity\Page;
  18. use App\Entity\Test;
  19. use App\Entity\TestDefinition;
  20. use App\Entity\Therapy;
  21. use App\Entity\User;
  22. use App\Service\AlgorithmService;
  23. use App\Service\EntityUsageService;
  24. use App\Service\ImportService;
  25. use App\Service\PageGeneratorService;
  26. use App\Service\SlugService;
  27. use App\Service\TestService;
  28. use Doctrine\ORM\EntityManagerInterface;
  29. use EasyCorp\Bundle\EasyAdminBundle\Event\EasyAdminEvents;
  30. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  31. use Symfony\Component\EventDispatcher\GenericEvent;
  32. use Symfony\Component\Filesystem\Filesystem;
  33. use Symfony\Component\HttpFoundation\RequestStack;
  34. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  35. use Symfony\Component\HttpKernel\KernelInterface;
  36. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  39. class EasyAdminSubscriber implements EventSubscriberInterface {
  41.     private $entity_manager;
  43.     public function __construct( EntityManagerInterface $entity_manager, EntityUsageService $entityUsageService,  AlgorithmService $algorithmService, TokenStorageInterface $token_storage, SlugService $slugService, TestService $testService, KernelInterface $kernel, ImportService $importService, RequestStack $request, SessionInterface $session, PageGeneratorService $pageGeneratorService) {
  44.         $this->entity_manager = $entity_manager;
  45.         $this->token_storage = $token_storage;
  46.         $this->testService = $testService;
  47.         $this->kernel = $kernel;
  48.         $this->importService = $importService;
  49.         $this->request = $request;
  50.         $this->session = $session;
  51.         $this->pageGeneratorService = $pageGeneratorService;
  52.         $this->slugService = $slugService;
  53.         $this->algorithmService = $algorithmService;
  54.         $this->entityUsageService = $entityUsageService;
  55.     }
  57.     public static function getSubscribedEvents(): ?array {
  59.         return [
  60.             EasyAdminEvents::POST_UPDATE => 'onPostUpdate',
  61.             EasyAdminEvents::POST_PERSIST => 'onPostPersist',
  62.             EasyAdminEvents::PRE_PERSIST => 'onPrePersist',
  63.             EasyAdminEvents::PRE_UPDATE => 'onPreUpdate',
  64.             EasyAdminEvents::POST_EDIT => 'onPostEdit',
  66.                 ];
  67.     }
  70.     public function onPreUpdate(GenericEvent $event) {
  72.         $entity = $event->getSubject();
  74.         if ($entity instanceof App) {
  76.             $id = $entity->getId();
  78.             // query manager to get the old entity, before update
  79.             $qb = $this->entity_manager->createQueryBuilder();
  80.             $qb->select('a.Settings')
  81.                 ->from('App:App', 'a')
  82.                 ->where('a.id = :id')->setParameter('id', $id);
  83.             $qb->setMaxResults(1);
  84.             $oldSettingsVar = $qb->getQuery()->getSingleResult();
  85.             $oldSettings = $oldSettingsVar['Settings'];
  86.             $Settings = $entity->getSettings();
  89.             $primaryColor = $Settings['primaryColor'];
  90.             $oldPrimaryColor = isset($oldSettings['primaryColor']) ? $oldSettings['primaryColor'] : '';
  92.             $secondaryColor = $Settings['secondaryColor'];
  93.             $oldSecondaryColor = isset($oldSettings['secondaryColor']) ? $oldSettings['secondaryColor'] : '';
  95.             $infoColor = $Settings['infoColor'];
  96.             $oldInfoColor = isset($oldSettings['infoColor']) ? $oldSettings['infoColor'] : '';
  98.             $successColor = $Settings['successColor'];
  99.             $oldSuccessColor = isset($oldSettings['successColor']) ? $oldSettings['successColor'] : '';
  101.             $dangerColor = $Settings['dangerColor'];
  102.             $oldDangerColor = isset($oldSettings['dangerColor']) ? $oldSettings['dangerColor'] : '';
  104.             $warningColor = $Settings['warningColor'];
  105.             $oldWarningColor = isset($oldSettings['warningColor']) ? $oldSettings['warningColor'] : '';
  107.             $request = $this->request->getCurrentRequest();
  108.             $baseurl = $request->getScheme() . '://' . $request->getHttpHost() . $request->getBasePath();
  109.             $output = null;
  111.             if (($primaryColor!=$oldPrimaryColor) || ($secondaryColor!=$oldSecondaryColor) || ($infoColor!=$oldInfoColor) || ($successColor!=$oldSuccessColor) || ($dangerColor!=$oldDangerColor) || ($warningColor!=$oldWarningColor)) { // if colors changes update the css
  113.                 $output = $this->pageGeneratorService->compileCss($entity);
  114.                 $Settings['cssUpdatedAt'] = time();
  116.             }
  117.             $this->pageGeneratorService->storeCustomCssJs($entity);
  119.             $Web = $entity->getWeb();
  121.             if ($Web) {
  122.                 $apiUserId =  isset($Settings['ApiUser']) ? $Settings['ApiUser'] : 0;
  123.                 $User = $this->entity_manager->getRepository(User::class)->find($apiUserId);
  125.                 if (!empty($User->getApiToken())) {
  126.                     $webapp = $this->pageGeneratorService->updateWebApp($entity, $User->getApiToken());
  127.                 }
  128.             }
  129.        }
  130.     }
  132.     public function onPostEdit(GenericEvent $event) {
  134.         $token = $this->token_storage->getToken();
  135.         $User = $token->getUser();
  136.         $Customer = $User->getCustomer();
  138.         $entity = $event->getSubject();
  139.         $entityName = (isset($entity['name'])) ? $entity['name']  : null;
  141.         if ($entityName == 'Algorithm') {
  143.             $request = $this->request->getCurrentRequest();
  144.             $id = $request->query->get('id');
  145.             $Algorithm = $this->entity_manager->getRepository(Algorithm::class)->find($id);
  147.             $errors = $this->algorithmService->checkAlgorithm($Algorithm, $Customer);
  149.             if (!empty($errors)) {
  151.                 foreach ($errors as $error) {
  153.                     $this->session->getFlashBag()->add('danger',$error);
  154.                 }
  155.             }
  156.         }
  157.     }
  159.     public function onPrePersist(GenericEvent $event) {
  161.         $entity = $event->getSubject();
  162.         if ($entity instanceof TestDefinition) {
  165.         }
  167.     }
  172.     public function onPostPersist(GenericEvent $event) {
  174.         $entity = $event->getSubject();
  176.         $token = $this->token_storage->getToken();
  177.         $User = $token->getUser();
  178.         $Customer = $User->getCustomer();
  179.         $lang = $Customer->getDefaultLanguageCode();
  182.         if ($entity instanceof Page) {
  184.             // save tree
  185.             $parent_id=$entity->getParent();
  189.             $Parent = ($parent_id>0) ? $this->entity_manager->getRepository(Page::class)->find($parent_id) : null;
  191.             if (!empty($Parent)) {
  192.                 $entity->setChildNodeOf($Parent);
  193.                 $this->entity_manager->persist($Parent);
  194.                 $this->entity_manager->flush();
  195.             } else {
  196.                 $entity->setMaterializedPath('');
  197.             }
  199.             $translations = $entity->getTranslations();
  203.             $imagesArray = preg_match_all('/<img[^>]+>/i',$entity->get, $result);
  205.             $this->entity_manager->persist($entity);
  206.             $this->entity_manager->flush();
  209.         }
  212.         if ($entity instanceof Algorithm) {
  215.             $algorithmType = $entity->getType();
  216.             $algorithmObjectType  = $entity->getObjectType();
  218.             if (!empty($algorithmObjectType)) {
  220.                 $Taxonomy = $algorithmObjectType->getSlug();
  222.                 if ($algorithmType == "modifier") {
  224.                     $ObjectId = $entity->getObjectId();
  226.                     if (($Taxonomy == "test") && ($ObjectId > 0)) {
  228.                         $Test = $this->entity_manager->getRepository(Test::class)->find($ObjectId);
  230.                         $tesDefinitions = $this->testService->getAllVariables($Test);
  232.                         foreach ($tesDefinitions as $tesDefinition) {
  234.                             $algorithmCondition = new AlgorithmCondition();
  235.                             $algorithmCondition->setFormula($tesDefinition->getSlug());
  236.                             $algorithmCondition->setActive(true);
  237.                             $algorithmCondition->setObjectId($tesDefinition->getId());
  239.                             $entity->addAlgorithmCondition($algorithmCondition);
  241.                         }
  242.                     }
  243.                 }
  244.             }
  245.         }
  246.     }
  250.     public function onPostUpdate(GenericEvent $event) {
  252.         $entity = $event->getSubject();
  254.         $token = $this->token_storage->getToken();
  255.         $User = $token->getUser();
  256.         $Customer = $User->getCustomer();
  257.         $lang = $Customer->getDefaultLanguageCode();
  258.         $Settings = $Customer->getSettings();
  259.         $languages = (isset($Settings['languages'])) ? $Settings['languages'] : array();
  261.         foreach ($languages as $languageId) {
  262.             $Language = $this->entity_manager->getRepository(Language::class)->find($languageId);
  263.             $usedLanguagesArray[] = $Language->getCode();
  264.         }
  267.         if ($entity instanceof Category) {
  269.             $this->entity_manager->persist($entity);
  270.             $this->entity_manager->flush();
  272.         }
  274.         if ($entity instanceof Import) {
  276.             $projectRoot = $this->kernel->getProjectDir();
  277.             $fileName = urldecode($entity->getFilename());
  278.             $type = urldecode($entity->getType());
  279.             $Taxonomy=$entity->getTaxonomy();
  280.             $Worksheet=$entity->getWorksheet();
  281.             $ObjectId=$entity->getObjectType()->getId();
  282.             $taxonomyName = $Taxonomy->getSlug();
  283.             $fullPath = $projectRoot.'/public'.$fileName;
  285.             $importSettings = $entity->getSettings();
  286.             $importStatus = $entity->getStatus();
  288.             if (file_exists($fullPath)) {
  290.                 if ($taxonomyName == 'country') {
  293.                     $str = file_get_contents($fullPath);
  294.                     $this->importService->importCountriesJson($str, $ObjectId);
  295.                     $entity->setStatus('finished');
  296.                     $importSettings = array('stage'=>2);
  297.                     $entity->setSettings($importSettings);
  299.                     $this->entity_manager->persist($entity);
  300.                     $this->entity_manager->flush();
  302.                 } elseif ($taxonomyName == 'test') {
  304.                     $stage = (isset($importSettings['stage'])) ? $importSettings['stage'] : 1;
  305.                     $startFrom = (isset($importSettings['startFrom'])) ? $importSettings['startFrom'] : 0;
  307.                     if (($importStatus=='initial') && (empty($Worksheet))) {
  309.                         $worksheets = $this->importService->importIcd9Xls($fullPath, $stage, $ObjectId, 0,1000, $Taxonomy, $Worksheet);
  310.                         $importSettings = array('stage'=>1, 'worksheet'=>'', 'worksheets'=>$worksheets);
  311.                         $entity->setSettings($importSettings);
  313.                     } elseif (!empty($Worksheet)) {
  315.                         $importedArray = $this->importService->importIcd9Xls($fullPath, $stage, $ObjectId, $startFrom,1000, $Taxonomy,$Worksheet);
  316.                         $imported = $importedArray[0];
  317.                         $totalRows = $importedArray[1];
  319.                         $importSettings['stage'] = 2;
  320.                         $importSettings['worksheet'] = $Worksheet;
  321.                         $importSettings['ObjectId'] = $ObjectId;
  322.                         $importSettings['imported'] = $imported;
  323.                         $importSettings['totalRows'] =$totalRows;
  325.                         $entity->setStatus('finished');
  326.                         $entity->setSettings($importSettings);
  328.                     }
  330.                     $this->entity_manager->persist($entity);
  331.                     $this->entity_manager->flush();
  334.                 } elseif ($taxonomyName == 'disease') {
  336.                     $stage = (isset($importSettings['stage'])) ? $importSettings['stage'] : 1;
  337.                     $startFrom = (isset($importSettings['startFrom'])) ? $importSettings['startFrom'] : 0;
  339.                     if ($type == 'xlsx') {
  341.                         $importedArray = $this->importService->importIcd10($fullPath, $ObjectId, $startFrom, 100);
  342.                         $imported = $importedArray[0];
  343.                         $totalRows = $importedArray[1];
  345.                         $stage = 1;
  346.                         $importSettings['stage'] = $stage;
  347.                         $importSettings['ObjectId'] = $ObjectId;
  348.                         $importSettings['imported'] = $imported;
  349.                         $importSettings['totalRows'] = $totalRows;
  350.                         $importSettings['startFrom'] = $startFrom + 100;
  352.                         if ($imported == 101) {
  353.                             $entity->setStatus('partial');
  354.                         } else {
  355.                             $entity->setStatus('finished');
  356.                         }
  358.                         $entity->setStatus('finished');
  359.                         $entity->setSettings($importSettings);
  361.                     } elseif ($type == 'json') {
  363.                         if ($ObjectId == 19) {
  364.                             $importedArray = $this->importService->importInteractions($fullPath, $ObjectId, 0, 2000);
  365.                         }
  367.                         $imported = $importedArray[0];
  368.                         $totalRows = $importedArray[1];
  370.                         $stage = 1;
  371.                         $importSettings['stage'] = $stage;
  372.                         $importSettings['ObjectId'] = $ObjectId;
  373.                         $importSettings['imported'] = $imported;
  374.                         $importSettings['totalRows'] = $totalRows;
  375.                         $importSettings['startFrom'] = $startFrom + 2000;
  377.                         if ($imported == 2001) {
  378.                             $entity->setStatus('partial');
  379.                         } else {
  380.                             $entity->setStatus('finished');
  381.                         }
  383.                         $entity->setSettings($importSettings);
  385.                     }
  387.                     $this->entity_manager->persist($entity);
  388.                     $this->entity_manager->flush();
  390.                 } elseif ($taxonomyName == 'customentity') {
  392.                     $stage = (isset($importSettings['stage'])) ? $importSettings['stage'] : 1;
  393.                     $startFrom = (isset($importSettings['startFrom'])) ? $importSettings['startFrom'] : 0;
  395.                     if ($type == 'xlsx') {
  399.                     } elseif ($type == 'json') {
  401.                         if ($ObjectId == 20) {
  402.                             $importedArray = $this->importService->importInteractionsCustom($fullPath, $ObjectId, 0, 2000);
  403.                         }
  405.                         $imported = $importedArray[0];
  406.                         $totalRows = $importedArray[1];
  408.                         $stage = 1;
  409.                         $importSettings['stage'] = $stage;
  410.                         $importSettings['ObjectId'] = $ObjectId;
  411.                         $importSettings['imported'] = $imported;
  412.                         $importSettings['totalRows'] = $totalRows;
  413.                         $importSettings['startFrom'] = $startFrom + 2000;
  415.                         if ($imported == 2001) {
  416.                             $entity->setStatus('partial');
  417.                         } else {
  418.                             $entity->setStatus('finished');
  419.                         }
  421.                         $entity->setSettings($importSettings);
  423.                     }
  425.                     $this->entity_manager->persist($entity);
  426.                     $this->entity_manager->flush();
  429.                 } elseif ($taxonomyName == 'drug') {
  431.                     $stage = (isset($importSettings['stage'])) ? $importSettings['stage'] : 1;
  432.                     $startFrom = (isset($importSettings['startFrom'])) ? $importSettings['startFrom'] : 0;
  434.                     if (($importStatus=='initial') && (empty($Worksheet))) {
  435.                         if ($type == 'xlsx') {
  436.                             if ($ObjectId == 10) {
  437.                                 $worksheets = $this->importService->importAtcXls($fullPath, $stage, $ObjectId, 0, 1000, $Taxonomy, '');
  438.                             } elseif ($ObjectId == 11) {
  439.                                 $worksheets = $this->importService->importRplXls($fullPath, $stage, $ObjectId, 0, 1000, $Taxonomy, '');
  440.                             }
  442.                             $importSettings = array('stage' => 1, 'worksheet' => '', 'worksheets' => $worksheets);
  443.                             $entity->setSettings($importSettings);
  445.                         } elseif ($type == 'json') {
  447.                             if ($ObjectId == 17) {
  448.                                 $importedArray = $this->importService->importInteractionDrugs($fullPath, $stage, $ObjectId, $Taxonomy);
  449.                             }
  451.                             $imported = $importedArray[0];
  452.                             $totalRows = $importedArray[1];
  454.                             $importSettings['imported'] = $imported;
  455.                             $importSettings['startFrom'] = $startFrom + 1000;
  456.                             $importSettings['totalRows'] = $totalRows;
  458.                             if ($imported != $totalRows) {
  459.                                 $entity->setStatus('partial');
  460.                             } else {
  461.                                 $entity->setStatus('finished');
  462.                             }
  464.                             $entity->setSettings($importSettings);
  467.                         }
  469.                     } elseif (!empty($Worksheet)) {
  471.                         $stage = 2;
  472.                         $importSettings['stage'] = $stage;
  473.                         $importSettings['worksheet'] = $Worksheet;
  474.                         $importSettings['ObjectId'] = $ObjectId;
  476.                         if ($type == 'xlsx') {
  478.                             if ($ObjectId==10) {
  479.                                 $importedArray = $this->importService->importAtcXls($fullPath, $stage, $ObjectId, $startFrom, 1000, $Taxonomy, $Worksheet);
  480.                             } elseif ($ObjectId == 11) {
  481.                                 $importedArray = $this->importService->importRplXls($fullPath, $stage, $ObjectId, $startFrom, 1000, $Taxonomy, $Worksheet);
  482.                             }
  484.                             $imported = $importedArray[0];
  485.                             $totalRows = $importedArray[1];
  487.                             $importSettings['imported'] = $imported;
  488.                             $importSettings['startFrom'] = $startFrom + 1000;
  489.                             $importSettings['totalRows'] = $totalRows;
  491.                             if ($imported == 1001) {
  492.                                 $entity->setStatus('partial');
  493.                             } else {
  494.                                 $entity->setStatus('finished');
  495.                             }
  497.                             $entity->setSettings($importSettings);
  499.                         }
  501.                     }
  504.                     $this->entity_manager->persist($entity);
  505.                     $this->entity_manager->flush();
  507.                 } elseif ($taxonomyName == 'page') {
  509.                 } elseif ($taxonomyName == 'procedure') {
  512.                     $stage = (isset($importSettings['stage'])) ? $importSettings['stage'] : 1;
  513.                     $startFrom = (isset($importSettings['startFrom'])) ? $importSettings['startFrom'] : 0;
  515.                     if (($importStatus=='initial') && (empty($Worksheet))) {
  517.                         $worksheets = $this->importService->importIcd9Xls($fullPath, $stage, $ObjectId,0,1000,$Taxonomy, '');
  518.                         $importSettings = array('stage'=>1, 'worksheet'=>'', 'worksheets'=>$worksheets);
  519.                         $entity->setSettings($importSettings);
  521.                     } elseif (!empty($Worksheet)) {
  523.                         $stage = 2;
  524.                         $importSettings['stage'] = $stage;
  525.                         $importSettings['worksheet'] = $Worksheet;
  526.                         $importSettings['ObjectId'] = $ObjectId;
  529.                         $imported = $this->importService->importIcd9Xls($fullPath, $stage, $ObjectId, $startFrom, 1000,$Taxonomy, $Worksheet);
  530.                         $importSettings['imported'] = $imported;
  531.                         $importSettings['startFrom'] = $startFrom + 1000;
  533.                         if ($imported == 1001) {
  534.                             $entity->setStatus('partial');
  535.                         } else {
  536.                             $entity->setStatus('finished');
  537.                         }
  539.                         $entity->setSettings($importSettings);
  542.                     }
  545.                     $this->entity_manager->persist($entity);
  546.                     $this->entity_manager->flush();
  548.                 }
  551.             }
  553.         }
  555.         if ($entity instanceof TestDefinition) {
  557.             $errors = $this->entityUsageService->checkTestDefinitionStructure($entity, $lang, $usedLanguagesArray, $User);
  558.             $this->entity_manager->persist($entity);
  559.             $this->entity_manager->flush();
  561.         }
  563.         if ($entity instanceof Test) {
  565.             //$entity->generateSlug();
  566.             $this->entity_manager->persist($entity);
  567.             $this->entity_manager->flush();
  569.         }
  571.         if ($entity instanceof Drug) {
  573.             $name = $entity->translate($lang)->getName();
  574.             $slug = $this->slugService->generateSlug($name);
  575.             $entity->setSlug($slug);
  576.             $this->entity_manager->persist($entity);
  577.             $this->entity_manager->flush();
  579.         }
  581.         if ($entity instanceof Disease) {
  583.             $name = $entity->translate($lang)->getName();
  584.             $slug = $this->slugService->generateSlug($name);
  585.             $entity->setSlug($slug);
  586.             $this->entity_manager->persist($entity);
  587.             $this->entity_manager->flush();
  589.         }
  591.         if ($entity instanceof Flow) {
  593.             $entity->generateSlug();
  594.             $this->entity_manager->persist($entity);
  595.             $this->entity_manager->flush();
  597.         }
  599.         if ($entity instanceof Page) {
  601.             $projectRoot = $this->kernel->getProjectDir();
  602.             $translations = $entity->getTranslations();
  603.             $request = $this->request->getCurrentRequest();
  604.             $baseurl = $request->getScheme() . '://' . $request->getHttpHost() . $request->getBasePath();
  606.             foreach ($translations as $translation) { // get array of missing files
  607.                 $missingFilesArray = $this->pageGeneratorService->getAttachmentsFromTranslation($entity, $translation, true);
  608.             }
  610.             $missingFiles = implode(', ',$missingFilesArray);
  611.             $message = 'There are missing files in the page body: '.$missingFiles;
  613.             if (!empty($missingFilesArray)) {
  614.                 $this->session->getFlashBag()->add('danger',$message);
  615.             }
  616.             $now = new \DateTime('now');
  617.             $entity->setUpdatedAt($now);
  619.             $this->entity_manager->persist($entity);
  620.             $this->entity_manager->flush();
  622.             // Update images / attachments array for current page and  whole app files array
  623.             $App = $entity->getApp();
  624.             $AppSettings = $App->getSettings();
  625.             $languages = isset($AppSettings['languages']) ? $AppSettings['languages'] : array();
  627.             $appFilesArray = array();
  629.             foreach ($languages as $languageId) {
  630.                 $Language = $this->entity_manager->getRepository(Language::class)->find($languageId);
  631.                 $appFilesArray[$Language->getCode()]['images'] = array();
  632.                 $appFilesArray[$Language->getCode()]['attachments'] = array();
  633.             }
  635.             if (empty($appFilesArray)) {
  636.                 $appFilesArray['en']['images'] = array();
  637.                 $appFilesArray['en']['attachments'] = array();
  638.             }
  640.             $pages = $this->entity_manager->getRepository(Page::class)->findBy(array('App'=>$App));
  642.             // update pages
  644.             $hasNews = 0;
  645.             $hasCalendar = 0;
  647.             foreach ($pages as $page) {
  649.                 // check for notifications
  650.                 $template = $page->getTemplate();
  653.                 if ($template == 'newsfeed') {
  654.                     $hasNews = 1;
  655.                 } elseif ($template == 'custom') {
  656.                     $pageSettings = $page->getSettings();
  657.                     $customFunction = (isset($pageSettings['customFunction'])) ? $pageSettings['customFunction'] : null;
  658.                     if ($customFunction == 'my_calendar') {
  659.                         $hasCalendar = 1;
  660.                     }
  661.                 }
  663.                 // check translations
  664.                 $translations = $page->getTranslations();
  666.                 foreach ($translations as $translation) {
  668.                     $pageLocale = $translation->getLocale();
  670.                     $translation = $this->pageGeneratorService->getAttachmentsFromTranslation($page, $translation, false);
  672.                     $pageFiles = $translation->getFiles();
  673.                     $pageImagesArray = $pageFiles['images'];
  674.                     $pageAttachmentsArray = $pageFiles['attachments'];
  677.                     if (isset($appFilesArray[$pageLocale]))  {
  678.                         if (!empty($pageImagesArray)) {
  679.                             $appFilesArray[$pageLocale]['images'][] = $pageImagesArray;
  680.                         }
  681.                         if (!empty($pageAttachmentsArray)) {
  682.                             $appFilesArray[$pageLocale]['attachments'][] = $pageAttachmentsArray;
  683.                         }
  684.                     }
  686.                 }
  688.                 //$this->entity_manager->persist($page);
  689.                 //$this->entity_manager->flush();
  690.             }
  692.             // update notifications array
  693.             $notificationsArray = array('newsfeed'=>$hasNews, 'calendar'=>$hasCalendar);
  694.             $App->setNotifications($notificationsArray);
  698.             foreach ($appFilesArray as $locale=>$filesArray) { // rearrange array, make files unique
  700.                $imagesArray = $filesArray['images'];
  701.                $attachmentsArray = $filesArray['attachments'];
  703.                $newImagesArray = array();
  705.                foreach ($imagesArray as $value1) { // merge arrays from different pages
  706.                    $newImagesArray = array_merge($newImagesArray, $value1);
  707.                }
  709.                 $newImagesArray1 = array();
  710.                 foreach ($newImagesArray as $value2) {// create array with paths as keys to make unique data
  711.                     if (is_array($value2)) {
  712.                         $newImagesArray1[$value2['path']] = array('time'=>$value2['time'], 'size'=> $value2['size']);
  713.                     }
  714.                 }
  716.                 $newImagesArray2 = array();
  718.                 foreach ($newImagesArray1 as $imagePath=>$imageData) { // loop through imagesArray1 to make path/time keys back
  719.                     $newImagesArray2[] = array('path'=>(!empty($imagePath)) ? $baseurl.$imagePath : '', 'time'=>$imageData['time'], 'size'=>$imageData['size']);
  720.                 }
  721.                 
  722.                 /// attachments
  723.                 $newattachmentsArray = array();
  724.                 foreach ($attachmentsArray as $value1) { // merge arrays from different pages
  725.                     $newattachmentsArray = array_merge($newattachmentsArray, $value1);
  726.                 }
  727.                 $newattachmentsArray1 = array();
  728.                 foreach ($newattachmentsArray as $value2) {// create array with paths as keys to make unique data
  729.                     if (is_array($value2)) {
  730.                          $newattachmentsArray1[$value2['path']] = array('time'=>$value2['time'], 'size'=> $value2['size'] );
  731.                     }
  732.                 }
  734.                 $newattachmentsArray2 = array();
  735.                 foreach ($newattachmentsArray1 as $imagePath=>$imageData) { // loop through attachmentsArray1 to make path/time keys back
  736.                     $newattachmentsArray2[] = array('path'=>(!empty($imagePath)) ? $baseurl.$imagePath : '', 'time'=>$imageData['time'], 'size'=>$imageData['size']);
  737.                 }
  739.                 $webFiles = $this->pageGeneratorService->returnPageFilesArray($App, $baseurl); // get design files for App
  742.                 $appFilesArray[$locale] = array('images'=>$newImagesArray2, 'attachments'=>$newattachmentsArray2, 'webdesign'=>$webFiles);
  743.             }
  745.             $taxonomyPagesArray = $this->pageGeneratorService->getTaxonomyPagesForApp($App, $lang);
  747.             $App->setTaxonomyPages($taxonomyPagesArray);
  748.             $App->setFiles($appFilesArray);
  749.             $this->entity_manager->persist($App);
  750.             $this->entity_manager->flush();
  752.         }
  754.         if ($entity instanceof App) {
  756.             $appTranslations = $entity->getTranslations();
  757.             $Settings = $entity->getSettings();
  758.             $selectedObjectsIds = isset($Settings['ObjectTypes']) ? $Settings['ObjectTypes'] : [];
  759.             $defaultSearchObjectType = isset($Settings['defaultSearchObjectType']) ? $Settings['defaultSearchObjectType'] : null;
  760.             $firebaseServiceAccount = isset($Settings['firebaseServiceAccount']) ? $Settings['firebaseServiceAccount'] : '';
  761.             $updateEmptyTranslations = $entity->isUpdateEmptyTranslations();
  763.             // update languageCode
  765.             $languageId = $entity->getDefaultLanguage();
  766.             $Language = $this->entity_manager->getRepository(Language::class)->find($languageId);
  767.             if (!empty($Language)) {
  768.                 $defaultLanguageCode = $Language->getCode();
  769.                 $entity->setDefaultLanguageCode($defaultLanguageCode);
  770.             }
  772.             // copy empty translations from default translations
  773.             if ($updateEmptyTranslations) {
  774.                 $usedLanguagesArray = array();
  775.                 $languages = (isset($Settings['languages'])) ? $Settings['languages'] : array();
  776.                 foreach ($languages as $languageId) {
  777.                     $Language = $this->entity_manager->getRepository(Language::class)->find($languageId);
  778.                     $usedLanguagesArray[] = $Language->getCode();
  779.                 }
  781.                 $appTranslationsStrings = $this->entity_manager->getRepository(AppTranslations::class)->findBy(array('App'=>$entity));
  784.                 foreach ($appTranslationsStrings as $AppTranslationString) {
  786.                     foreach ($usedLanguagesArray as $languageCode) {
  787.                         $translation = trim($AppTranslationString->translate($languageCode, false)->getName());
  789.                         if (is_null($translation) || $translation === "") {
  791.                             $defaultTranslationKey = $AppTranslationString->getTranslationKey();
  792.                             $DefaultTranslation = $this->entity_manager->getRepository(AppTranslations::class)->findOneBy(array('App'=>null, 'TranslationKey'=>$defaultTranslationKey));
  793.                             $defaultTranslation = $DefaultTranslation->translate($languageCode, false)->getName();
  796.                             if ((!is_null($translation)) && ($defaultTranslation != "")) {
  798.                                 $AppTranslationString->translate($languageCode)->setName($defaultTranslation);
  800.                             }
  802.                         }
  803.                     }
  804.                     $AppTranslationString->mergeNewTranslations();
  805.                     $this->entity_manager->persist($AppTranslationString);
  806.                     $this->entity_manager->flush();
  807.                 }
  808.             }
  810.             // update translations strings array
  813.             foreach ($appTranslations as $appTranslation) {
  815.                 $appLocaleSettings = $appTranslation->getSettings();
  816.                 $locale = $appTranslation->getLocale();
  817.                 $objectTypesAray = array();
  819.                 foreach($selectedObjectsIds as $selectedObjectId) {
  820.                     $ObjectType = $this->entity_manager->getRepository(ObjectType::class)->find($selectedObjectId);
  821.                     $objectTypeName = $ObjectType->translate($locale)->getName();
  822.                     $objectTypesAray[$selectedObjectId] = array(
  823.                         'name'=>$objectTypeName,
  824.                         'selected'=> ($defaultSearchObjectType == $selectedObjectId) ? true : false,
  825.                         'taxonomy'=>$ObjectType->getTaxonomy()->getId());
  826.                 }
  828.                 $translations = $this->entity_manager->getRepository(AppTranslations::class)->findByTranslationKey('search_form', $entity);
  829.                 foreach ($translations as $translation) {
  830.                     $translatsionsArray[$translation->getTranslationKey()] = $translation->translate($locale)->getName();
  831.                 }
  833.                 $appLocaleSettings['searchObjectTypes'] = $objectTypesAray;
  834.                 $appLocaleSettings['searchFormTranslations'] = $translatsionsArray;
  835.                 $appTranslation->setSettings($appLocaleSettings);
  838.                 $translationsAdmin = $this->entity_manager->getRepository(AppTranslations::class)->findBy(['App'=>null]);
  839.                 foreach ($translationsAdmin as $translationAdmin) {
  840.                     $translationsAdminArray[$translationAdmin->getTranslationKey()] = $translationAdmin->translate($locale)->getName();
  841.                 }
  843.                 $translations = $this->entity_manager->getRepository(AppTranslations::class)->findBy(['App'=>$entity]);
  844.                 foreach ($translations as $translation) {
  845.                     $translationsArray[$translation->getTranslationKey()] = $translation->translate($locale)->getName();
  846.                 }
  848.                 $finalTranslationsArray = array_merge($translationsArray, array_diff_key($translationsAdminArray, $translationsArray)); // merge only translations that are missing in app translations (translationsArray)
  850.                 $appTranslation->setTranslationStrings($finalTranslationsArray);
  852.             }
  858.             // update google assetlinks.json and apple app-site-association.json
  859.             $projectRoot = $this->kernel->getProjectDir();
  861.             $storePath = $projectRoot.'/public';
  862.             $configPath = $projectRoot.'/config/apps/'.$entity->getId().'/';
  864.             $apps = $this->entity_manager->getRepository(App::class)->findAll();
  865.             $appleSiteAssociationArray = array('applinks'=>array('details'=>null));
  866.             $googleAssetlinksArray = array();
  868.             $filesystem = new Filesystem();
  870.             // save firebase service account json
  872.             if (!empty($firebaseServiceAccount)) {
  874.                 $firebaseServiceAccount = trim($firebaseServiceAccount);
  875.                 $filesystem->dumpFile($configPath.'firebase.json', $firebaseServiceAccount);
  877.             }
  879.             foreach ($apps as $App) {
  881.                 $appSettings = $App->getSettings();
  883.                 $appleTeamId = (isset($appSettings['appleTeamId'])) ? $appSettings['appleTeamId'] : '';
  884.                 $appleBundleId = (isset($appSettings['appleBundleId'])) ? $appSettings['appleBundleId'] : '';
  885.                 $googleCertFingerprint = (isset($appSettings['googleCertFingerprint'])) ? $appSettings['googleCertFingerprint'] : '';
  886.                 $googlePackageName = (isset($appSettings['googlePackageName'])) ? $appSettings['googlePackageName'] : '';
  888.                 if (stristr($googleCertFingerprint, ',')) {
  889.                     $googleCertFingerprint = str_replace('"','',$googleCertFingerprint);
  890.                     $googleCertFingerprint = preg_replace('/[\r\n\s]+/', '', $googleCertFingerprint);
  891.                     $certFingerprintArray = explode(',',$googleCertFingerprint);
  892.                 } else {
  893.                     $certFingerprintArray = array($googleCertFingerprint);
  894.                 }
  896.                 if (!empty($appleTeamId) && !empty($appleBundleId)) {
  897.                     $appleSingleSiteAssociationArray = array(
  898.                         'appID'=>$appleTeamId.'.'.$appleBundleId,
  899.                         'components'=>array(array('/'=>'/r/'.$App->getId().'/*',
  900.                                             'comment'=>'comment'))
  901.                     );
  902.                     $appleSiteAssociationArray['applinks']['details'][] = $appleSingleSiteAssociationArray;
  903.                 }
  905.                 if (!empty($googleCertFingerprint) && !empty($googlePackageName)) {
  906.                     $googleSingleSiteAssociationArray = array(
  907.                         'relation'=>array('delegate_permission/common.handle_all_urls'),
  908.                         'target'=>array('namespace'=>'android_app',
  909.                                         'package_name'=>$googlePackageName,
  910.                                         'sha256_cert_fingerprints'=>$certFingerprintArray)
  911.                     );
  912.                     $googleAssetlinksArray[] = $googleSingleSiteAssociationArray;
  913.                 }
  915.             }
  916.             $googleAssetlinksJson = json_encode($googleAssetlinksArray, JSON_PRETTY_PRINT|JSON_UNESCAPED_SLASHES);
  917.             $appleSiteAssociationJson = json_encode($appleSiteAssociationArray, JSON_PRETTY_PRINT|JSON_UNESCAPED_SLASHES);
  921.             $filesystem->dumpFile($storePath.'/.well-known/assetlinks.json', $googleAssetlinksJson);
  922.             $filesystem->dumpFile($storePath.'/.well-known/apple-app-site-association', $appleSiteAssociationJson);
  925.             $this->entity_manager->persist($entity);
  926.             $entity->mergeNewTranslations();
  927.             $this->entity_manager->flush();
  929.         }
  931.         if ($entity instanceof Algorithm) {
  934.             $algorithmType = $entity->getType();
  935.             $algorithmObjectType  = $entity->getObjectType();
  937.             if (!empty($algorithmObjectType)) {
  939.                 $Taxonomy = $algorithmObjectType->getSlug();
  942.                 if ($algorithmType == "modifier") {
  944.                     $ObjectId = $entity->getObjectId();
  946.                     if ($ObjectId > 0) {
  947.                         if ($Taxonomy == "test")  {
  949.                             $Test = $this->entity_manager->getRepository(Test::class)->find($ObjectId);
  950.                             $algorithmConditionRepository = $this->entity_manager->getRepository(AlgorithmCondition::class);
  952.                             $testDefinitions = $this->testService->getAllVariables($Test);
  953.                             $newAlgorithmConditionsArray = array();
  955.                             foreach ($testDefinitions as $testDefinition) {
  957.                                 $algorithmCondition = new AlgorithmCondition();
  958.                                 $algorithmCondition->setFormula($testDefinition->getSlug());
  959.                                 $algorithmCondition->setActive(true);
  960.                                 $algorithmCondition->setObjectId($testDefinition->getId());
  962.                                 $testDefinitionId = $testDefinition->getId();
  964.                                 $storedCondition = $algorithmConditionRepository->findOneBy(array('Algorithm' => $entity->getId(), 'ObjectId' => $testDefinitionId));
  966.                                 if (empty($storedCondition)) {
  967.                                     $entity->addAlgorithmCondition($algorithmCondition);
  968.                                 }
  970.                                 array_push($newAlgorithmConditionsArray, $testDefinitionId); // create array for all new algorithm conditions
  971.                             }
  973.                             $StoredConditions = $entity->getAlgorithmConditions();
  976.                             foreach ($StoredConditions as $storedCondition) {
  978.                                 $storedConditionId = $storedCondition->getObjectId();
  980.                                 if (!in_array($storedConditionId, $newAlgorithmConditionsArray)) { // check if stored conditions are in the $newAlgorithmConditionsArray array. If no, remove them.
  981.                                     $entity->removeAlgorithmCondition($storedCondition);
  982.                                 }
  983.                             }
  985.                             $this->entity_manager->persist($entity);
  986.                             $this->entity_manager->flush();
  989.                         } elseif ($Taxonomy == "therapy")  {
  991.                             $Therapy = $this->entity_manager->getRepository(Therapy::class)->find($ObjectId);
  992.                             $algorithmConditionRepository = $this->entity_manager->getRepository(AlgorithmCondition::class);
  994.                             $therapyDefinitions = $Therapy->getTherapyDefinitions();
  995.                             $newAlgorithmConditionsArray = array();
  997.                             foreach ($therapyDefinitions as $therapyDefinition) {
  999.                                 $algorithmCondition = new AlgorithmCondition();
  1000.                                 $algorithmCondition->setFormula('');
  1001.                                 $algorithmCondition->setActive(false);
  1002.                                 $algorithmCondition->setObjectId($therapyDefinition->getId());
  1004.                                 $therapyDefinitionId = $therapyDefinition->getId();
  1006.                                 $storedCondition = $algorithmConditionRepository->findOneBy(array('Algorithm' => $entity->getId(), 'ObjectId' => $therapyDefinitionId));
  1008.                                 if (empty($storedCondition)) {
  1009.                                     $entity->addAlgorithmCondition($algorithmCondition);
  1010.                                 }
  1012.                                 array_push($newAlgorithmConditionsArray, $therapyDefinitionId); // create array for all new algorithm conditions
  1013.                             }
  1014.                         }
  1016.                         $StoredConditions = $entity->getAlgorithmConditions();
  1019.                         foreach ($StoredConditions as $storedCondition) {
  1021.                             $storedConditionId = $storedCondition->getObjectId();
  1023.                             if (!in_array($storedConditionId, $newAlgorithmConditionsArray)) { // check if stored conditions are in the $newAlgorithmConditionsArray array. If no, remove them.
  1024.                                 $entity->removeAlgorithmCondition($storedCondition);
  1025.                             }
  1026.                         }
  1028.                         $this->entity_manager->persist($entity);
  1029.                         $this->entity_manager->flush();
  1031.                     }
  1032.                 } elseif ($algorithmType == "scoring") {
  1034.                     $Settings = $entity->getSettings();
  1035.                     $ObjectIds = $entity->getObjectIds();
  1037.                     if (empty($ObjectIds)) { // remove conditions if objectsids is empty
  1038.                         $StoredConditions = $entity->getAlgorithmConditions();
  1040.                         foreach ($StoredConditions as $storedCondition) {
  1041.                             $entity->removeAlgorithmCondition($storedCondition);
  1042.                         }
  1044.                         $this->entity_manager->persist($entity);
  1045.                         $this->entity_manager->flush();
  1046.                     }
  1048.                     $SimpleScoring = isset($Settings['SimpleScore']) ? $Settings['SimpleScore'] : false;
  1051.                     if ($SimpleScoring == false) {
  1052.                         $StoredConditions = $entity->getAlgorithmConditions();
  1054.                         foreach ($StoredConditions as $storedCondition) {
  1056.                             $storedCondition->setScore('');
  1057.                         }
  1059.                         $this->entity_manager->persist($entity);
  1060.                         $this->entity_manager->flush();
  1061.                     }
  1063.                 }
  1064.             }
  1068.         }
  1069.     }
  1070. }