vendor/memo_development/contao-foundation-bundle/src/Service/ToolboxService.php line 133

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. /**
  4.  * @package   Memo\MemoFoundationBundle
  5.  * @author    Media Motion AG
  6.  * @license   LGPL-3.0+
  7.  * @copyright Media Motion AG
  8.  */
  10. namespace Memo\FoundationBundle\Service;
  12. use Contao\CoreBundle\DataContainer\PaletteManipulator;
  13. use Contao\CoreBundle\Routing\ResponseContext\HtmlHeadBag\HtmlHeadBag;
  14. use Contao\CoreBundle\Routing\ResponseContext\JsonLd\JsonLdManager;
  15. use Contao\CoreBundle\Routing\ResponseContext\ResponseContext;
  16. use Spatie\SchemaOrg\Graph;
  17. use Spatie\SchemaOrg\JobPosting;
  18. use Spatie\SchemaOrg\Organization;
  19. use Spatie\SchemaOrg\Place;
  20. use Spatie\SchemaOrg\PostalAddress;
  21. use Contao\FilesModel;
  22. use Contao\System;
  23. use Ivory\GoogleMap\Service\Geocoder\GeocoderService;
  24. use Http\Adapter\Guzzle6\Client;
  25. use Http\Message\MessageFactory\GuzzleMessageFactory;
  27. class ToolboxService
  28. {
  29.     /**
  30.      * On Save Callback for coordinates
  31.      * @param DataContainer $dc
  32.      */
  33.     public function setCoordinates(\DataContainer $dc)
  34.     {
  35.         $strTable = $dc->table;
  37.         if($strTable == ''){
  38.             return;
  39.         }
  41.         \Controller::loadDataContainer($strTable);
  42.         $strModel = $GLOBALS['TL_MODELS'][$strTable];
  44.         if($strModel == ''){
  45.             return;
  46.         }
  48.         $objItem = $strModel::findOneById($dc->activeRecord->id);
  50.         if(($dc->activeRecord->lat == '' || $dc->activeRecord->long == '') && $dc->activeRecord->address != ''){
  52.             $arrCoordinates = false;
  54.             if(class_exists('\delahaye\GeoCode')){
  56.                 $strKey = \Config::get('dlh_googlemaps_apikey');
  57.                 $strCoordinates = \delahaye\GeoCode::getCoordinates($dc->activeRecord->address . $dc->activeRecord->object_location, 'ch', 'de', $strKey);
  58.                 $arrCoordinates = explode(',', $strCoordinates);
  60.             } elseif(class_exists('\Spatie\Geocoder\Geocoder')){
  62.                 $strKey = \Config::get('googlemaps_apiKey') ?? \Config::get('dlh_googlemaps_apikey');
  63.                 $client = new \GuzzleHttp\Client();
  64.                 $geocoder = new \Spatie\Geocoder\Geocoder($client);
  65.                 $geocoder->setApiKey($strKey);
  66.                 $geocoder->setCountry('CH');
  67.                 $response = $geocoder->getCoordinatesForAddress($dc->activeRecord->address . $dc->activeRecord->object_location);
  68.                 $arrCoordinates = array($response['lat'], $response['lng']);
  69.             }
  71.             if ($arrCoordinates && is_array($arrCoordinates)){
  73.                 if(!is_null($arrCoordinates[0])){
  74.                     $objItem->lat = $arrCoordinates[0];
  75.                 }
  77.                 if(!is_null($arrCoordinates[1])){
  78.                     $objItem->long = $arrCoordinates[1];
  79.                 }
  81.                 $objItem->save();
  82.             }
  83.         }
  84.     }
  86.     /**
  87.      * Format Date for DCA-View
  88.      * @param $value
  89.      * @return false|int
  90.      */
  91.     public function loadDate($value)
  92.     {
  93.         return strtotime(date('Y-m-d', (int)$value) . ' 00:00:00');
  94.     }
  96.     public static function setJsonLd($JsonLdItem){
  98.         // Get Response Context and check it
  99.         $objResponseContext = \System::getContainer()->get('contao.routing.response_context_accessor')->getResponseContext();
  100.         if (!$objResponseContext || !$objResponseContext->has(JsonLdManager::class)) {
  101.             return;
  102.         }
  104.         // Get JsonLdManager
  105.         $objJsonLdManager = $objResponseContext->get(JsonLdManager::class);
  107.         // Check Input Parameter and transform (auto) if needed
  108.         if(is_object($JsonLdItem)){
  109.             $objJsonLdItem = $JsonLdItem;
  110.         } elseif(is_array($JsonLdItem)){
  111.             $objJsonLdItem = $objJsonLdManager->createSchemaOrgTypeFromArray($JsonLdItem);
  112.         }
  114.         // Add the Schema to the Graph (Response)
  115.         $objJsonLdManager->getGraphForSchema(JsonLdManager::SCHEMA_ORG)->set($objJsonLdItem, Graph::IDENTIFIER_DEFAULT);
  117.     }
  119.     /**
  120.      * Toggle alias and seo-fields, if no detail-page is set on the parent-archive
  121.      * @param $strTablename
  122.      */
  123.     public static function toggleDetailFieldsFromPalette($strTablename)
  124.     {
  125.         $arrDetailPageIds = array();
  127.         // Get the archive details
  128.         if(array_key_exists('ptable', $GLOBALS['TL_DCA'][$strTablename]['config'])){
  129.             $strArchiveTable = $GLOBALS['TL_DCA'][$strTablename]['config']['ptable'];
  130.             $strArchiveModel = $GLOBALS['TL_MODELS'][$strArchiveTable];
  132.             // Try to get the jumpTo page ids
  133.             $arrDetailPageIds = $strArchiveModel::getDetailPages(false);
  134.         }
  136.         // If no ids were found, there are now detailpages to be expected - so we can cleanup the palette
  137.         if(count($arrDetailPageIds) == 0){
  139.             $objLanguageService = \System::getContainer()->get('memo.foundation.language');
  141.             $arrLanguages = $objLanguageService->getAllLanguages(true);
  143.             foreach($arrLanguages as $strLanguage)
  144.             {
  145.                 $strPostfix = $objLanguageService->getLanguagePostfix($strLanguage);
  147.                 if($strPostfix == ''){
  149.                     $arrFieldsToRemove = array(
  150.                         array('general_legend', 'alias'),
  151.                         array('meta_legend', 'seo_title'),
  152.                         array('meta_legend', 'seo_description'),
  153.                         array('meta_legend', 'serpPreview'),
  154.                     );
  156.                 } else {
  158.                     $arrFieldsToRemove = array(
  159.                         array('translation' . $strPostfix, 'alias'. $strPostfix),
  160.                         array('translation' . $strPostfix, 'seo_title'. $strPostfix),
  161.                         array('translation' . $strPostfix, 'seo_description'. $strPostfix),
  162.                     );
  164.                 }
  166.                 foreach($GLOBALS['TL_DCA'][$strTablename]['palettes'] as $strKey => $strPalette){
  167.                     if ($strKey == '__selector__') {
  168.                         continue;
  169.                     }
  171.                     foreach($arrFieldsToRemove as $arrFields)
  172.                     {
  173.                         PaletteManipulator::create()
  174.                             ->removeField($arrFields[1], $arrFields[0])
  175.                             ->applyToPalette($strKey, $strTablename)
  176.                         ;
  177.                     }
  178.                 }
  179.             }
  180.         }
  181.     }
  183.     public static function collectionToArray($objCollection, $bolResetKeys=false, $strField='title')
  184.     {
  185.         $arrCollection = array();
  187.         if($objCollection != null)
  188.         {
  189.             foreach($objCollection as $objItem)
  190.             {
  191.                 if($bolResetKeys){
  192.                     $arrCollection[] = $objItem->$strField;
  193.                 } else {
  194.                     $arrCollection[$objItem->id] = $objItem->$strField;
  195.                 }
  196.             }
  197.         }
  199.         return $arrCollection;
  200.     }
  202.     public static function convertOrderString($strOrderBy, $strTable)
  203.     {
  204.         $strSQL = '';
  206.         switch($strOrderBy)
  207.         {
  208.             case 'order_title':
  209.                 $strSQL = "$strTable.title";
  210.                 break;
  211.             case 'order_title_desc':
  212.                 $strSQL = "$strTable.title DESC";
  213.                 break;
  214.             case 'order_sorting':
  215.                 $strSQL = "$strTable.sorting";
  216.                 break;
  217.             case 'order_sorting_desc':
  218.                 $strSQL = "$strTable.sorting DESC";
  219.                 break;
  220.             case 'order_date':
  221.                 $strSQL = "$strTable.date";
  222.                 break;
  223.             case 'order_date_desc':
  224.                 $strSQL = "$strTable.date DESC";
  225.                 break;
  226.         }
  228.         return $strSQL;
  229.     }
  231.     /**
  232.      * Set page header meta by associative array.
  233.      * @param array $arr
  234.      * @return void
  235.      */
  236.     public static function setPageHeaderMeta(array $arr): void
  237.     {
  238.         if (System::getContainer()->has('contao.routing.response_context_accessor')) {
  239.             $responseContext = System::getContainer()->get('contao.routing.response_context_accessor')->getResponseContext();
  240.             $htmlHeadBag = $responseContext->get(HtmlHeadBag::class);
  242.             if ($responseContext && $responseContext->has(HtmlHeadBag::class)) {
  243.                 foreach ($arr as $tag => $value) {
  244.                     switch ($tag) {
  245.                         case 'robots':
  246.                             $htmlHeadBag->setMetaRobots($value);
  247.                             break;
  248.                         case 'title':
  249.                             $htmlHeadBag->setTitle($value);
  250.                             break;
  251.                         case 'description':
  252.                             $htmlHeadBag->setMetaDescription($value);
  253.                             break;
  254.                         case 'canonical':
  255.                             $htmlHeadBag->setCanonicalUri($value);
  256.                             break;
  257.                     }
  258.                 }
  259.             }
  260.         } else {
  261.             global $objPage;
  263.             foreach ($arr as $tag => $value) {
  264.                 $objPage->{$tag} = $value;
  265.             }
  266.         }
  267.     }
  269.     public static function generateMarker(\DataContainer $dc)
  270.     {
  271.         // Get & Check Table
  272.         $strTable = $dc->table;
  273.         if($strTable == ''){
  274.             \System::log('No table given for marker generation', __METHOD__, TL_ERROR);
  276.             return;
  277.         }
  279.         // Get and check Class/Model
  280.         \Controller::loadDataContainer($strTable);
  281.         $strModel = $GLOBALS['TL_MODELS'][$strTable];
  283.         if($strModel == '' || !class_exists($strModel)){
  284.             \System::log('No model found for table ' . $strTable, __METHOD__, TL_ERROR);
  285.             return;
  286.         }
  288.         // Get Item
  289.         $objItem = $strModel::findOneById($dc->activeRecord->id);
  291.         if(!$objItem){
  292.             \System::log('No item found for table ' . $strTable . ' with id ' . $dc->activeRecord->id, __METHOD__, TL_ERROR);
  293.             return;
  294.         }
  296.         // Get Parent / Archive
  297.         $objArchive = $objItem->getRelated('pid');
  299.         if(!$objArchive){
  300.             \System::log('No archive found for table ' . $strTable . ' with id ' . $dc->activeRecord->id, __METHOD__, TL_ERROR);
  301.             return;
  302.         }
  304.         // Check data
  305.         if(!$objArchive->addMarker || !$objArchive->markerSRC || $objArchive->markerSRC == ''){
  306.             \System::log('No marker found for table ' . $strTable . ' with id ' . $dc->activeRecord->id, __METHOD__, TL_ERROR);
  307.             return;
  308.         }
  310.         if(!$objItem->singleSRC || $objItem->singleSRC == ''){
  311.             \System::log('No image found for item: table ' . $strTable . ' with id ' . $dc->activeRecord->id, __METHOD__, TL_ERROR);
  312.             return;
  313.         }
  315.         // Get Item Image
  316.         $objItemImage = \FilesModel::findByUuid($objItem->singleSRC);
  318.         // Check File
  319.         if(!$objItemImage || file_exists($objItemImage->path) === false){
  320.             \System::log('Defined image not found for item: table ' . $strTable . ' with id ' . $dc->activeRecord->id, __METHOD__, TL_ERROR);
  321.             return;
  322.         }
  324.         // Get Template Image
  325.         $objTemplateImage = \FilesModel::findByUuid($objArchive->markerSRC);
  327.         // Check File
  328.         if(!$objTemplateImage || file_exists($objTemplateImage->path) === false){
  329.             \System::log('Defined marker background image not found for item: table ' . $strTable . ' with id ' . $dc->activeRecord->id, __METHOD__, TL_ERROR);
  330.             return;
  331.         }
  333.         // Check the destination
  334.         $objMarkerFolder = FilesModel::findByUuid($objArchive->markerFolder);
  336.         if(!$objMarkerFolder || file_exists($objMarkerFolder->path) === false){
  337.             \System::log('Defined marker folder not found', __METHOD__, TL_ERROR);
  338.             return;
  339.         }
  341.         // Create Base from Original Image
  342.         switch($objItemImage->extension){
  343.             case 'jpeg':
  344.             case 'jpg':
  345.                 $objItemImageSource = imagecreatefromjpeg($objItemImage->path);
  346.                 break;
  347.             case 'png':
  348.                 $objItemImageSource = imagecreatefrompng($objItemImage->path);
  349.                 break;
  350.             case 'gif':
  351.                 $objItemImageSource = imagecreatefromgif($objItemImage->path);
  352.                 break;
  353.             default:
  354.                 \System::log('Image type not supported for marker generation: ' . $objItemImage->extension, __METHOD__, TL_ERROR);
  355.                 return;
  356.         }
  358.         // Define  filename, path etc.
  359.         if($objItem->alias != ''){
  360.             $strFilename = 'marker-' . $objItem->alias . '-'.$objItem->id.'.png';
  361.         } else {
  362.             $strFilename = 'marker-' . $objItem->id.'.png';
  363.         }
  364.         $strFilename = $objItem->alias . '-'.$objItem->id.'.png';
  365.         $strFilepath = $objMarkerFolder->path . '/' . $strFilename;
  367.         // Get Image Size
  368.         list($intSourceWidth, $intSourceHeight) = getimagesize($objItemImage->path);
  370.         // Load Marker Template
  371.         switch($objTemplateImage->extension){
  372.             case 'jpeg':
  373.             case 'jpg':
  374.                 $objMarker = imagecreatefromjpeg($objTemplateImage->path);
  375.                 break;
  376.             case 'png':
  377.                 $objMarker = imagecreatefrompng($objTemplateImage->path);
  378.                 break;
  379.             case 'gif':
  380.                 $objMarker = imagecreatefromgif($objTemplateImage->path);
  381.                 break;
  382.             default:
  383.                 \System::log('Image type not supported for marker generation: ' . $objTemplateImage->extension, __METHOD__, TL_ERROR);
  384.                 return;
  385.         }
  386.         imagesavealpha($objMarker, true);
  388.         // Get Marker Sizes
  389.         $intMarkerWidth = imagesx( $objMarker );
  390.         $intMarkerHeight = imagesy( $objMarker );
  392.         // Create new Image and crop on Item Image
  393.         $objMarkerImage = imagecreatetruecolor($intMarkerWidth,$intMarkerHeight);
  394.         imagealphablending( $objMarkerImage, false );
  395.         imagecopyresampled( $objMarkerImage, $objItemImageSource, 0, 0, 0, 0, $intMarkerWidth - $objArchive->markerWidthTrim, $intMarkerHeight - $objArchive->markerHeightTrim, $intSourceWidth, $intSourceHeight);
  397.         // Merge Item Image into Marker Image with offset (for border)
  398.         imagecopyresampled( $objMarker, $objMarkerImage , $objArchive->markerOffsetX, $objArchive->markerOffsetY, 0, 0, $intMarkerWidth - $objArchive->markerWidthTrim, $intMarkerHeight - $objArchive->markerHeightTrim, $intMarkerWidth - $objArchive->markerWidthTrim, $intMarkerHeight - $objArchive->markerHeightTrim);
  400.         // Write Marker to Folder
  401.         imagepng( $objMarker,$strFilepath );
  403.         if(!file_exists($strFilepath)){
  404.             \System::log('Marker could not be created', __METHOD__, TL_ERROR);
  405.             return;
  406.         }
  408.         \Dbafs::addResource($strFilepath);
  410.         // Get Marker Object
  411.         $objMarkerFile = \FilesModel::findByPath($strFilepath);
  413.         // Check Marker Object
  414.         if(!$objMarkerFile){
  415.             \System::log('Marker could not be added to database', __METHOD__, TL_ERROR);
  416.             return;
  417.         }
  419.         // Update Item
  420.         $objItem->markerSRC = $objMarkerFile->uuid;
  421.         $objItem->save();
  423.     }
  424. }