vendor/numero2/contao-opengraph3/src/Resources/contao/classes/OpenGraph.php line 39

Open in your IDE?
  1. <?php
  3. /**
  4.  * Contao Open Source CMS
  5.  *
  6.  * Copyright (c) 2005-2021 Leo Feyer
  7.  *
  8.  * @package   Opengraph3
  9.  * @author    Benny Born <benny.born@numero2.de>
  10.  * @author    Michael Bösherz <michael.boesherz@numero2.de>
  11.  * @license   LGPL
  12.  * @copyright 2021 numero2 - Agentur für digitales Marketing GbR
  13.  */
  16. namespace numero2\OpenGraph3;
  18. use Contao\Config;
  19. use Contao\ContentElement;
  20. use Contao\Controller;
  21. use Contao\Environment;
  22. use Contao\File;
  23. use Contao\FilesModel;
  24. use Contao\Frontend;
  25. use Contao\ModuleModel;
  26. use Contao\PageModel;
  27. use Contao\StringUtil;
  28. use Contao\System;
  31. class OpenGraph3 extends Frontend {
  34.     /**
  35.      * Add OpenGraph tags to the current page
  36.      *
  37.      * @param Model $ref
  38.      */
  39.     public static function addTagsToPage( $ref=null ): void {
  41.         Controller::loadDataContainer('opengraph_fields');
  42.         System::loadLanguageFile('opengraph_fields');
  44.         global $objPage;
  46.         $objRef = !$ref ? $objPage : $ref;
  47.         $objRootPage = ($objRef instanceof PageModel) ? PageModel::findById($objPage->rootId) : null;
  49.         self::parseAdditionalProperties( $objRef );
  50.         self::parseAdditionalProperties( $objRootPage );
  52.         // add og tags
  53.         if( !empty($GLOBALS['TL_DCA']['opengraph_fields']['fields']) ) {
  55.             foreach( $GLOBALS['TL_DCA']['opengraph_fields']['fields'] as $fieldName => $field ) {
  57.                 // add tag if missing
  58.                 if( ($objRef->{$fieldName} || $objRootPage->{$fieldName}) && !self::checkTag($field['label'][0]) ) {
  60.                     $tag = $field['label'][0];
  62.                     $value = null;
  63.                     $value = $objRef->{$fieldName} ? $objRef->{$fieldName} : $objRootPage->{$fieldName};
  65.                     // get value based on inputType
  66.                     switch( $field['inputType'] ) {
  68.                         case 'textarea':
  69.                         case 'select':
  70.                         case 'text':
  72.                             switch( $fieldName ) {
  74.                                 case 'og_country_name':
  75.                                 case 'og_business_contact_data_country_name':
  77.                                     $arrCountries = [];
  78.                                     $arrCountries = System::getCountries();
  80.                                     $value = $arrCountries[$value];
  82.                                 break;
  83.                             }
  85.                             if( !empty($field['eval']['rgxp']) ) {
  87.                                 switch( $field['eval']['rgxp'] ) {
  89.                                     case 'datim':
  91.                                         $date = null;
  92.                                         $date = \DateTime::createFromFormat( Config::get('datimFormat'), $value );
  94.                                         $value = $date->format('Y-m-d\TH:i:s');
  96.                                     break;
  97.                                 }
  98.                             }
  100.                         break;
  102.                         case 'fileTree':
  104.                             $objFile = null;
  105.                             $objFile = FilesModel::findByUuid( $value );
  107.                             if( $objFile ) {
  109.                                 $value = Environment::get('base') . System::urlEncode($objFile->path);
  111.                                 $size = Config::get($fieldName.'_size');
  112.                                 if( $size ) {
  114.                                     $oFile = new File($objFile->path);
  116.                                     $size = StringUtil::deserialize($size);
  117.                                     if( is_numeric($size) ){
  118.                                         $size = [0, 0, (int) $size];
  119.                                     } else if( !is_array($size) ) {
  120.                                         $size = [];
  121.                                     }
  123.                                     $size += [0, 0, 'crop'];
  125.                                     if( $oFile && $oFile->exists() && $oFile->isGdImage ) {
  126.                                         try {
  127.                                             $src = System::getContainer()->get('contao.image.image_factory')->create(TL_ROOT . '/' . $objFile->path, $size)->getUrl(TL_ROOT);
  129.                                             if( $src !== $objFile->path ) {
  130.                                                 $value = Environment::get('base') . System::urlEncode($src);
  131.                                             }
  133.                                         } catch( \Exception $e ) {
  134.                                         }
  135.                                     }
  136.                                 }
  137.                             } else {
  138.                                 continue 2;
  139.                             }
  141.                         break;
  143.                         case 'openGraphProperties':
  144.                             continue 2;
  145.                         break;
  147.                         default:
  148.                             throw new \Exception("Unhandled field type ".$field['inputType']);
  149.                         break;
  150.                     }
  152.                     // add og:image:secure_url if applicable
  153.                     if( $tag === 'og:image' && strpos($value,'https:') !== false ) {
  154.                         self::addTag('og:image:secure_url', $value);
  155.                     }
  157.                     self::addTag($tag, $value);
  158.                 }
  159.             }
  161.             // og:locale
  162.             if( !self::checkTag('og:locale') ) {
  164.                 $value = $objRef->og_locale ? $objRef->og_locale : $objRootPage->og_locale;
  166.                 // set default locale based on the page´s language
  167.                 if( !$value ) {
  169.                     switch( $objPage->language ) {
  170.                         case 'en' :
  171.                             $value = 'en_US';
  172.                             break;
  173.                         default :
  174.                             $value = sprintf("%s_%s",$objPage->language,strtoupper($objPage->language));
  175.                             break;
  176.                     }
  177.                 }
  179.                 self::addTag( 'og:locale', $value );
  180.             }
  182.             // og:url added automatically
  183.             if( !self::checkTag('og:url') ) {
  184.                 self::addTag( 'og:url', Environment::get('url') . Environment::get('requestUri') );
  185.             }
  186.         }
  187.     }
  190.     /**
  191.      * Appends a property to the given object
  192.      *
  193.      * @param string $prop
  194.      * @param string $value
  195.      * @param Model $objRef
  196.      */
  197.     public static function addProperty( $prop, $value, $objRef ): void {
  199.         $aProperties = [];
  200.         $aProperties = $objRef->og_properties ? StringUtil::deserialize($objRef->og_properties) : [];
  202.         $aProperties[] = [$prop, $value];
  204.         $objRef->og_properties = serialize($aProperties);
  205.     }
  208.     /**
  209.      * Appends OpenGraph data for the given module
  210.      *
  211.      * @param Model $objRow
  212.      * @param String $strBuffer
  213.      * @param Module $objModule
  214.      *
  215.      * @return String
  216.      */
  217.     public function appendTagsByModule( $objRow, $strBuffer, $objModule ): string {
  219.         $moduleClass = null;
  220.         $moduleClass = get_class($objModule);
  222.         // find and import a matching module to parse the OpenGraph data from
  223.         foreach( $GLOBALS['TL_OG_MODULES'] as $module ) {
  225.             if( $moduleClass === "Contao\ModuleModel" && $objModule->type === $module[0] || $moduleClass === $module[1] ) {
  227.                 $this->import($module[2]);
  228.                 $this->{$module[2]}->addModuleData($objModule);
  229.             }
  230.         }
  232.         return $strBuffer?:'';
  233.     }
  236.     /**
  237.      * Checks if the given Content Element is a module and tries to use it
  238.      * for OpenGraph data
  239.      *
  240.      * @param Model $objRow
  241.      * @param String $strBuffer
  242.      * @param Contao\ContentElement $objElement
  243.      *
  244.      * @return String
  245.      */
  246.     public function findCompatibleModules( $objRow, $strBuffer, $objElement ): string {
  248.         if( get_class($objElement) === "Contao\ContentModule" ) {
  250.             $objModule = null;
  251.             $objModule = ModuleModel::findById($objElement->module);
  253.             if( $objModule ) {
  254.                 self::appendTagsByModule(null, $strBuffer, $objModule);
  255.             }
  256.         }
  258.         return $strBuffer?:'';
  259.     }
  262.     /**
  263.     * Adds the additional og_properties as individual attributes
  264.     *
  265.     * @param Model $ref
  266.     */
  267.     private static function parseAdditionalProperties( $ref ): void {
  269.         if( !empty($ref->og_properties) ) {
  271.             $props = null;
  272.             $props = StringUtil::deserialize($ref->og_properties);
  274.             if( !empty($props) ) {
  276.                 foreach( $props as $p ) {
  277.                     if( !isset($ref->{$p[0]}) || empty($ref->{$p[0]}) ) {
  278.                         $ref->{$p[0]} = $p[1];
  279.                     }
  280.                 }
  281.             }
  282.         }
  283.     }
  286.     /**
  287.     * Adds a specific OpenGraph tag to the head
  288.     *
  289.     * @param String $tagName
  290.     * @param String $tagValue
  291.     *
  292.     * @return bool
  293.     */
  294.     private static function addTag( $tagName=null, $tagValue=null ): bool {
  296.         if( empty($tagName) || empty($tagValue) ) {
  297.             return false;
  298.         }
  300.         $attribute = 'property';
  302.         if( strpos($tagName, 'twitter') === 0 ) {
  303.             $attribute = 'name';
  304.         }
  306.         $GLOBALS['TL_HEAD'][] = sprintf(
  307.             '<meta %s="%s" content="%s" />'
  308.         ,   $attribute
  309.         ,   $tagName
  310.         ,   htmlspecialchars( self::replaceInsertTags($tagValue) )
  311.         );
  313.         return true;
  314.     }
  317.     /**
  318.      * Checks if a specific OpenGraph tag already exists
  319.      *
  320.      * @param String $tagName
  321.      * @param String $tagValue
  322.      *
  323.      * @return bool
  324.      */
  325.     private static function checkTag( $tagName=null ): bool {
  327.         if( empty($tagName) ) {
  328.             return false;
  329.         }
  331.         if( !empty($GLOBALS['TL_HEAD']) && is_array($GLOBALS['TL_HEAD']) ) {
  333.             foreach( $GLOBALS['TL_HEAD'] as $i => $v ) {
  335.                 if( strpos($v, $tagName) !== FALSE ) {
  336.                     return true;
  337.                 }
  338.             }
  339.         }
  341.         return false;
  342.     }
  343. }