PageRenderTime 69ms CodeModel.GetById 20ms RepoModel.GetById 1ms app.codeStats 1ms

/components/com_sef/joomsef.php

https://bitbucket.org/organicdevelopment/joomla-2.5
PHP | 2980 lines | 2140 code | 403 blank | 437 comment | 627 complexity | d34461bb6c8992b69d199fdc81d5dc87 MD5 | raw file
Possible License(s): LGPL-3.0, GPL-2.0, MIT, BSD-3-Clause, LGPL-2.1 
    

  1. <?php

    2. 

  2. /**

    3. 

  3.  * SEF component for Joomla!

    4. 

  4.  * 

    5. 

  5.  * @package   JoomSEF

    6. 

  6.  * @version   4.2.8

    7. 

  7.  * @author    ARTIO s.r.o., http://www.artio.net

    8. 

  8.  * @copyright Copyright (C) 2012 ARTIO s.r.o. 

    9. 

  9.  * @license   GNU/GPLv3 http://www.artio.net/license/gnu-general-public-license

    10. 

  10.  */

    11. 

  11. 

    12. 

  12. // Check to ensure this file is included in Joomla!

    13. 

  13. if (!defined('_JEXEC')) JoomSEF::CheckAccess();

    14. 

  14. 

    15. 

  15. jimport('joomla.plugin.helper');

    16. 

  16. jimport('joomla.language.helper');

    17. 

  17. require_once JPATH_SITE.DS.'components'.DS.'com_sef'.DS.'sef.cache.php';

    18. 

  18. require_once JPATH_ADMINISTRATOR.DS.'components'.DS.'com_sef'.DS.'classes'.DS.'seftools.php';

    19. 

  19. require_once JPATH_ADMINISTRATOR.DS.'components'.DS.'com_sef'.DS.'models'.DS.'logger.php';

    20. 

  20. 

    21. 

  21. define ('JROUTER_MODE_DONT_PARSE', 2);

    22. 

  22. 

    23. 

  23. class JoomSEF

    24. 

  24. {

    25. 

  25. 	private $_data=null;

    26. 

  26.     static $props = array();

    27. 

  27.     

    28. 

  28. 	function getInstance() {

    29. 

  29. 		static $instance;

    30. 

  30. 		if(!isset($instance)) {

    31. 

  31. 			$instance=new JoomSEF();

    32. 

  32. 		}

    33. 

  33. 		return $instance;

    34. 

  34. 	}

    35. 

  35. 	

    36. 

  36. 	function setData($data) {

    37. 

  37. 		$this->_data=$data;

    38. 

  38. 	}

    39. 

  39. 	

    40. 

  40.     function set($name, $value)

    41. 

  41.     {

    42. 

  42.         if (!is_array(self::$props)) {

    43. 

  43.             self::$props = array();

    44. 

  44.         }

    45. 

  45.         

    46. 

  46.         $previous = self::get($name);

    47. 

  47.         self::$props[$name] = $value;

    48. 

  48.         

    49. 

  49.         return $previous;

    50. 

  50.     }

    51. 

  51.     

    52. 

  52.     function get($name, $default = null)

    53. 

  53.     {

    54. 

  54.         if (!is_array(self::$props) || !isset(self::$props[$name])) {

    55. 

  55.             return $default;

    56. 

  56.         }

    57. 

  57.         

    58. 

  58.         return self::$props[$name];

    59. 

  59.     }

    60. 

  60.     

    61. 

  61.     function build(&$uri,$check=false)

    62. 

  62.     {

    63. 

  63.     	static $extsCache;

    64. 

  64. 

    65. 

  65.     	if (!isset($extsCache)) {

    66. 

  66.     		$extsCache = array();

    67. 

  67.     	}

    68. 

  68. 

    69. 

  69.         $mainframe =& JFactory::getApplication();

    70. 

  70.         $jRouter = $mainframe->getRouter();

    71. 

  71.         $jRouter->SetMode(JROUTER_MODE_SEF);

    72. 

  72. 

    73. 

  73.         $config =& JFactory::getConfig();

    74. 

  74.         $sefConfig =& SEFConfig::getConfig();

    75. 

  75.         $cache =& SEFCache::getInstance();

    76. 

  76. 

    77. 

  77.         // Restore global "Add suffix to URLs"

    78. 

  78.         $sefSuffix = $mainframe->get('sef.global.orig_sef_suffix');

    79. 

  79.         $config->set('sef_suffix', $sefSuffix);

    80. 

  80.          

    81. 

  81.         // trigger onSefStart patches

    82. 

  82.         $mainframe->triggerEvent('onSefStart');

    83. 

  83. 

    84. 

  84.         // Do not SEF URLs with specific format or template according to configuration

    85. 

  85.         if (in_array($uri->getVar('format'), array('raw', 'json', 'xml')) || ($uri->getVar('tmpl') == 'raw') ||

    86. 

  86.             (!$sefConfig->sefComponentUrls && ($uri->getVar('tmpl') == 'component')))

    87. 

  87.         {

    88. 

  88.         	$uri = JoomSEF::_createUri($uri);

    89. 

  89.             $mainframe->triggerEvent('onSefEnd');

    90. 

  90.             $jRouter->SetMode(JROUTER_MODE_RAW);

    91. 

  91.             return;

    92. 

  92.         }

    93. 

  93.         

    94. 

  94.         // check URL for junk if set to

    95. 

  95.         $vars = $uri->getQuery(true);

    96. 

  96.         if ($sefConfig->checkJunkUrls) {

    97. 

  97.             $junkWords =& $sefConfig->getJunkWords();

    98. 

  98.             $seferr = false;

    99. 

  99. 

    100. 

  100.             if (substr($uri->getVar('option', ''), 0, 4) != 'com_') {

    101. 

  101.                 $seferr = true;

    102. 

  102.             }

    103. 

  103.             elseif (count($junkWords)) {

    104. 

  104.                 $exclude =& $sefConfig->getJunkExclude();

    105. 

  105. 

    106. 

  106.                 foreach ($vars as $key => $val) {

    107. 

  107.                     if (in_array($key, $exclude)) continue;

    108. 

  108. 

    109. 

  109.                     // Check junk words

    110. 

  110.                     foreach ($junkWords as $word) {

    111. 

  111.                         if (is_string($val)) {

    112. 

  112.                             if (strpos($val, $word) !== false) {

    113. 

  113.                                 $seferr = true;

    114. 

  114.                                 break;

    115. 

  115.                             }

    116. 

  116.                         }

    117. 

  117.                     }

    118. 

  118.                     if ($seferr) break;

    119. 

  119.                 }

    120. 

  120.             }

    121. 

  121. 

    122. 

  122.             if ($seferr) {

    123. 

  123.                 // trigger onSefEnd patches

    124. 

  124.                 $mainframe->triggerEvent('onSefEnd');

    125. 

  125.                 $jRouter->SetMode(JROUTER_MODE_RAW);

    126. 

  126. 

    127. 

  127.                 // fix the path

    128. 

  128.                 $path = $uri->getPath();

    129. 

  129. 

    130. 

  130.                 return;

    131. 

  131.             }

    132. 

  132.         }

    133. 

  133.         if($sefConfig->langEnable && $check==false) {

    134. 

  134.         	if(strlen($uri->getVar('lang'))==0) {

    135. 

  135.         		$uri->setVar('lang',JRequest::getVar('lang'));

    136. 

  136.         	}

    137. 

  137.         }

    138. 

  138. 

    139. 

  139.         // Correct FaLang support for translations

    140. 

  140.         $prevLang = '';

    141. 

  141.         if ($sefConfig->langEnable && $check == false) {

    142. 

  142.             $langVar = $uri->getVar('lang');

    143. 

  143.             if (!empty($langVar)) {

    144. 

  144.                 $langCode = JoomSEF::getLangCode($langVar);

    145. 

  145.                 if (!is_null($langCode)) {

    146. 

  146.                     $curCode = JoomSEF::getLangCode();

    147. 

  147.                     if ($langCode != $curCode) {

    148. 

  148.                         // URL language is different from current language,

    149. 

  149.                         // change current language for correct translations

    150. 

  150.                         $language = JFactory::getLanguage();

    151. 

  151.                         $prevLang = $language->setLanguage($langCode);

    152. 

  152.                         $language->load();

    153. 

  153.                     }

    154. 

  154.                 }

    155. 

  155.             }

    156. 

  156.         }

    157. 

  157. 

    158. 

  158.         // if there are no variables and only single language is used

    159. 

  159.         $vars = $uri->getQuery(true);

    160. 

  160.         if (empty($vars) && !isset($lang)) {

    161. 

  161.             JoomSEF::_endSef($prevLang);

    162. 

  162.             return;

    163. 

  163.         }

    164. 

  164. 

    165. 

  165. 		

    166. 

  166.         $option = $uri->getVar('option');

    167. 

  167.         if (!is_null($option)) {

    168. 

  168.             $params =& SEFTools::getExtParams($option);

    169. 

  169. 

    170. 

  170.             // Check the stop rule

    171. 

  171.             $stopRule = trim($params->get('stopRule', ''));

    172. 

  172.             if( $stopRule != '' ) {

    173. 

  173.                 if( preg_match('/'.$stopRule.'/', $uri->toString()) > 0 ) {

    174. 

  174.                     // Don't SEF this URL

    175. 

  175.                     $uri = JoomSEF::_createUri($uri);

    176. 

  176.                     JoomSEF::_endSef($prevLang);

    177. 

  177.                     $jRouter->SetMode(JROUTER_MODE_RAW);

    178. 

  178.                     return;

    179. 

  179.                 }

    180. 

  180.             }

    181. 

  181. 

    182. 

  182.             if(strlen($uri->getVar('Itemid'))==0) {

    183. 

  183.             	$uri->delVar('Itemid');

    184. 

  184.             }            

    185. 

  185. 

    186. 

  186.             

    187. 

  187. 

    188. 

  188. 			$handling = $params->get('handling', '0');

    189. 

  189.             switch($handling) {

    190. 

  190.                 // skipped extensions

    191. 

  191.                 case '2': {

    192. 

  192.                     // Check homepage

    193. 

  193.                     if (JoomSEF::_isHomePage($uri)) {

    194. 

  194.                         $lang = $uri->getVar('lang');

    195. 

  195.                         if (empty($lang)) {

    196. 

  196.                             $uri = new JURI('index.php');

    197. 

  197.                         }

    198. 

  198.                         else {

    199. 

  199.                             $uri = new JURI('index.php?lang='.$lang);

    200. 

  200.                         }

    201. 

  201.                     }

    202. 

  202. 

    203. 

  203.                     // Build URL

    204. 

  204.                     $uri = JoomSEF::_createUri($uri);

    205. 

  205.                     JoomSEF::_endSef($prevLang);

    206. 

  206.                     $jRouter->SetMode(JROUTER_MODE_RAW);

    207. 

  207.                     return;

    208. 

  208.                 }

    209. 

  209.                 // non-cached extensions

    210. 

  210.                 case '1': {

    211. 

  211.                     // Check homepage

    212. 

  212.                     if (JoomSEF::_isHomePage($uri)) {

    213. 

  213.                         $lang = $uri->getVar('lang');

    214. 

  214.                         if (empty($lang)) {

    215. 

  215.                             $uri = new JURI('index.php');

    216. 

  216.                         }

    217. 

  217.                         else {

    218. 

  218.                             $uri = new JURI('index.php?lang='.$lang);

    219. 

  219.                         }

    220. 

  220.                     }

    221. 

  221.                     JoomSEF::_endSef($prevLang);

    222. 

  222.                     return;

    223. 

  223.                 }

    224. 

  224.                 // default handler or basic rewriting

    225. 

  225.                 default: {

    226. 

  226.                     // if component has its own sef_ext plug-in included.

    227. 

  227.                     // however, prefer own plugin if exists (added by Michal, 28.11.2006)

    228. 

  228.                     $compExt = JPATH_ROOT.DS.'components'.DS.$option.DS.'router.php';

    229. 

  229.                     $ownExt = JPATH_ROOT.DS.'components'.DS.'com_sef'.DS.'sef_ext'.DS.$option.'.php';

    230. 

  230. 

    231. 

  231.                     // compatible extension build block

    232. 

  232.                     if (file_exists($compExt) && !file_exists($ownExt) && ($handling == '0')) {

    233. 

  233.                         // Check homepage

    234. 

  234.                         if (JoomSEF::_isHomePage($uri)) {

    235. 

  235.                             $lang = $uri->getVar('lang');

    236. 

  236.                             if (empty($lang)) {

    237. 

  237.                                 $uri = new JURI('index.php');

    238. 

  238.                             }

    239. 

  239.                             else {

    240. 

  240.                                 $uri = new JURI('index.php?lang='.$lang);

    241. 

  241.                             }

    242. 

  242.                             

    243. 

  243.                             // Create homepage SEF URL

    244. 

  244.                             $title = array();

    245. 

  245.                             $data = JoomSEF::_sefGetLocation($uri, $title, null, null, null, $uri->getVar('lang'));

    246. 

  246.                             $uri = JoomSEF::_storeLocation($data);

    247. 

  247.                             // remove path as Joomla will add it back

    248. 

  248.                             $uri->setPath(preg_replace("@^".$uri->base(true)."@","",$uri->getPath()));

    249. 

  249.                             JoomSEF::_endSef($prevLang);

    250. 

  250.                             return;

    251. 

  251.                         }

    252. 

  252. 

    253. 

  253.                         // load the plug-in file

    254. 

  254.                         require_once($compExt);

    255. 

  255. 

    256. 

  256.                         $app        =& JFactory::getApplication();

    257. 

  257.                         $menu       =& JSite::getMenu();

    258. 

  258.                         $route      = $uri->getPath();

    259. 

  259.                         $query      = $uri->getQuery(true);

    260. 

  260.                         $component  = preg_replace('/[^A-Z0-9_\.-]/i', '', $query['option']);

    261. 

  261.                         $tmp        = '';

    262. 

  262. 

    263. 

  263.                         $function   = substr($component, 4) . 'BuildRoute';

    264. 

  264.                         $parts      = $function($query);

    265. 

  265. 

    266. 

  266.                         $total = count($parts);

    267. 

  267.                         for ($i = 0; $i < $total; $i++) {

    268. 

  268.                             $parts[$i] = str_replace(':', '-', $parts[$i]);

    269. 

  269.                         }

    270. 

  270. 

    271. 

  271.                         $result = implode('/', $parts);

    272. 

  272.                         $tmp    = ($result != "") ? '/'.$result : '';

    273. 

  273. 

    274. 

  274.                         // build the application route

    275. 

  275.                         $built = false;

    276. 

  276.                         if (isset($query['Itemid']) && !empty($query['Itemid'])) {

    277. 

  277.                             $item = $menu->getItem($query['Itemid']);

    278. 

  278. 

    279. 

  279.                             if (is_object($item) && $query['option'] == $item->component) {

    280. 

  280.                                 $tmp = !empty($tmp) ? $item->route.$tmp : $item->route;

    281. 

  281.                                 $built = true;

    282. 

  282.                             }

    283. 

  283.                         }

    284. 

  284. 

    285. 

  285.                         if(!$built) {

    286. 

  286.                             $tmp = 'component/'.substr($query['option'], 4).$tmp;

    287. 

  287.                         }

    288. 

  288. 

    289. 

  289.                         $route .= '/'.$tmp;

    290. 

  290.                         if($app->getCfg('sef_suffix') && !(substr($route, -9) == 'index.php' || substr($route, -1) == '/')) {

    291. 

  291.                             if (($format = $uri->getVar('format', 'html'))) {

    292. 

  292.                                 $route .= '.' . $format;

    293. 

  293.                                 $uri->delVar('format');

    294. 

  294.                             }

    295. 

  295.                         }

    296. 

  296. 

    297. 

  297.                         if($app->getCfg('sef_rewrite')) {

    298. 

  298.                             // transform the route

    299. 

  299.                             $route = str_replace('index.php/', '', $route);

    300. 

  300.                         }

    301. 

  301. 

    302. 

  302.                         // Unset unneeded query information

    303. 

  303.                         unset($query['Itemid']);

    304. 

  304.                         unset($query['option']);

    305. 

  305. 

    306. 

  306.                         //Set query again in the URI

    307. 

  307.                         $uri->setQuery($query);

    308. 

  308.                         $uri->setPath($route);

    309. 

  309. 

    310. 

  310.                         $uri = JoomSEF::_createUri($uri);

    311. 

  311. 

    312. 

  312.                         JoomSEF::_endSef($prevLang);

    313. 

  313.                         

    314. 

  314.                         // Disable global "Add suffix to URLs" again

    315. 

  315.                         $config->set('sef_suffix', 0);

    316. 

  316.                         

    317. 

  317.                         return;

    318. 

  318.                     }

    319. 

  319.                     // own extension block

    320. 

  320.                     else {

    321. 

  321.                         // Disable global "Add suffix to URLs"

    322. 

  322.                         $config->set('sef_suffix', 0);

    323. 

  323.                         

    324. 

  324.                         if ($handling == '3') {

    325. 

  325.                             // Basic rewriting

    326. 

  326.                             $class = 'SefExt_Basic';

    327. 

  327.                         }

    328. 

  328.                         else {

    329. 

  329.                             if (file_exists($ownExt)) {

    330. 

  330.                                 $class = 'SefExt_'.$option;

    331. 

  331.                             } else {

    332. 

  332.                                 $class = 'SefExt';

    333. 

  333.                             }

    334. 

  334.                         }

    335. 

  335.                         

    336. 

  336.                         // Extensions cache

    337. 

  337.                     	if (!class_exists($class)) {

    338. 

  338.                     		require($ownExt);

    339. 

  339.                     	}

    340. 

  340.                     	$sef_ext = new $class();

    341. 

  341.                     	$extsCache[$class] = $sef_ext;

    342. 

  342. 

    343. 

  343.                         // Set currently handled URI

    344. 

  344.                         $sef_ext->setCurrentUri($uri);

    345. 

  345. 

    346. 

  346.                         // 17.2.2012, dajo: isHomePage should be tested before the beforeCreate() is called

    347. 

  347.                         // Grr Joomla SEF router adds home Itemid to Items without menu Item assigned

    348. 

  348.                         $homes=array_keys(SEFTools::getHomeQueries());

    349. 

  349.                         if(in_array($uri->getVar('Itemid'),$homes) && !JoomSEF::_isHomePage($uri)) {

    350. 

  350.                         	$uri->setVar('Itemid',JRequest::getInt('Itemid'));

    351. 

  351.                         }

    352. 

  352.                         

    353. 

  353.                         // Let the extension change the url and options

    354. 

  354.                         $sef_ext->beforeCreate($uri);

    355. 

  355.                         list($sid, $mosmsg) = self::_prepareUriForCreate($params, $uri);

    356. 

  356.                         

    357. 

  357.                         // Get nonsef and ignore vars from extension

    358. 

  358.                         list($nonSefVars, $ignoreVars) = $sef_ext->getNonSefVars($uri);

    359. 

  359. 

    360. 

  360.                         // Create array of all the non sef vars

    361. 

  361.                         $nonSefVars = SEFTools::getNonSefVars($uri, $nonSefVars, $ignoreVars);

    362. 

  362. 

    363. 

  363.                         // Create a copy of JURI object

    364. 

  364.                         $uri2 = clone($uri);

    365. 

  365. 

    366. 

  366.                         // Remove nonsef variables from our JURI copy

    367. 

  367.                         $nonSefUrl = SEFTools::RemoveVariables($uri2, array_keys($nonSefVars));

    368. 

  368.                         

    369. 

  369.                         // Check homepage

    370. 

  370.                         if (JoomSEF::_isHomePage($uri2, true)) {

    371. 

  371.                             $title[] = $uri2->getVar('lang');

    372. 

  372.                             $pagination=false;

    373. 

  373.                             if(method_exists($sef_ext,"_processPagination")) {

    374. 

  374.                             	$title=array_merge($title,$sef_ext->_processPagination($uri2));

    375. 

  375.                             	$pagination=true;

    376. 

  376.                             }

    377. 

  377.                             if($uri2->getVar('format')=='feed') {

    378. 

  378.                             	$title[]=$uri2->getVar('type');

    379. 

  379.                             }

    380. 

  380.                             $data = JoomSEF::_sefGetLocation($uri2, $title, null, null, null, $uri->getVar('lang'),null,null,null,null,$pagination);

    381. 

  381.                             unset($data["lang"]);

    382. 

  382.                             $uri = JoomSEF::_storeLocation($data);

    383. 

  383.                             // remove path as Joomla will add it back

    384. 

  384.                             $uri->setPath(preg_replace("@^".$uri->base(true)."@","",$uri->getPath()));

    385. 

  385.                             // Set non-SEF variables

    386. 

  386.                             $uri->setQuery($nonSefUrl);

    387. 

  387.                             JoomSEF::_endSef($prevLang);

    388. 

  388.                             return;

    389. 

  389.                         }

    390. 

  390.                         

    391. 

  391.                         // clean Itemid if desired

    392. 

  392.                         // David: only if overriding is disabled

    393. 

  393.                         $override = $params->get('itemid', '0');

    394. 

  394.                         if (isset($sefConfig->excludeSource) && $sefConfig->excludeSource && ($override == '0')) {

    395. 

  395.                             $Itemid = $uri->getVar('Itemid');

    396. 

  396.                             $uri2->delVar('Itemid');

    397. 

  397.                         }

    398. 

  398. 

    399. 

  399.                         

    400. 

  400.                         $url = JoomSEF::_uriToUrl($uri2);

    401. 

  401. 

    402. 

  402.                         // try to get url from cache

    403. 

  403.                         $sefUrl = false;

    404. 

  404.                         if ($sefConfig->useCache) {

    405. 

  405.                         	if(!$check) {

    406. 

  406.                             	$sefUrl = $cache->GetSefUrl($url);

    407. 

  407.                         	}

    408. 

  408.                         }

    409. 

  409.                         if (!$sefConfig->useCache || !$sefUrl) {

    410. 

  410.                             // check if the url is already saved in the database

    411. 

  411.                             $sefUrl = $sef_ext->getSefUrlFromDatabase($uri2);

    412. 

  412. 

    413. 

  413.                             if (is_string($sefUrl)) {

    414. 

  414.                                 // Backward compatibility

    415. 

  415.                                 $sefstring = $sefUrl;

    416. 

  416.                                 $sefUrl = new stdClass();

    417. 

  417.                                 $sefUrl->sefurl = $sefstring;

    418. 

  418.                                 $sefUrl->sef = 1;

    419. 

  419.                                 $sefUrl->host = '';

    420. 

  420.                             }

    421. 

  421.                         }

    422. 

  422. 

    423. 

  423.                         // unknown URL yet

    424. 

  424.                         if (!$sefUrl || $check) {

    425. 

  425.                         	// load JoomSEF Language File

    426. 

  426.                         	JFactory::getLanguage()->load('com_sef',JPATH_ADMINISTRATOR);

    427. 

  427.                             // rewrite the URL, creating new JURI object

    428. 

  428.                             $data = $sef_ext->create($uri);

    429. 

  429.                             if (is_object($data) && is_a($data, 'JURI')) {

    430. 

  430.                             	 // Backwards compatibility

    431. 

  431.                                 $uri = $data;

    432. 

  432.                             }

    433. 

  433.                             else {

    434. 

  434. 	                            if($sefConfig->langPlacementJoomla==_COM_SEF_LANG_PATH) {

    435. 

  435. 	                            	// if data is not array, than we don't have in lang language from SEF extension, because is't original URL 

    436. 

  436. 	                            	if(is_array($data)) {

    437. 

  437. 		                            	if($data['lang']=='*') {

    438. 

  438. 				                            // If we don't want to have language in multilanguage content strip down the language from path to eleminate duplicit pages with same content

    439. 

  439. 		                            		if($sefConfig->addLangMulti) {

    440. 

  440. 		                            			$data["lang"]=$data["uri"]->getVar('lang');

    441. 

  441. 		                            		} else {

    442. 

  442. 		                            			unset($data["lang"]);

    443. 

  443. 		                            			$data["uri"]->delVar('lang');

    444. 

  444. 		                            		}

    445. 

  445. 		                            	} else {

    446. 

  446. 		                            		$langs=JLanguageHelper::getLanguages('lang_code');

    447. 

  447. 		                            		if(array_key_exists($data["lang"],$langs)) {

    448. 

  448. 		                            			$data["lang"]=$langs[$data["lang"]]->sef;

    449. 

  449. 		                            		}

    450. 

  450. 		                            		if(!strlen($data["lang"])) {

    451. 

  451. 		                            			$data["lang"]=$data["uri"]->getVar('lang');

    452. 

  452. 		                            		}

    453. 

  453. 		                            	}

    454. 

  454. 	                            	}

    455. 

  455. 		                            if($sefConfig->alwaysUseLangJoomla==false) {

    456. 

  456. 		                            	if(isset($data["lang"]) && $data["lang"]==$sefConfig->mainLanguageJoomla) {

    457. 

  457. 		                            		unset($data["lang"]);

    458. 

  458. 		                            		$data["uri"]->delVar('lang');

    459. 

  459. 		                            	}

    460. 

  460. 		                            	

    461. 

  461. 		                            }

    462. 

  462. 	                            }

    463. 

  463. 	                            

    464. 

  464. 	                            $titlepage=false;

    465. 

  465. 	                            

    466. 

  466. 	                            $subdomain=SEFTools::getSubdomain($uri->getVar('Itemid'),$uri,$titlepage);

    467. 

  467. 		                       	if(strlen($subdomain)) {

    468. 

  468. 		                       		$uri->setHost($subdomain.".".JFactory::getURI()->getHost());

    469. 

  469. 		                       	}

    470. 

  470. 	                            

    471. 

  471. 	                            if($titlepage) {

    472. 

  472. 	                       			$data["title"]=array();

    473. 

  473. 	                       		}

    474. 

  474. 	                       		

    475. 

  475. 	                       		

    476. 

  476. 	                            if(!isset($data["host"])) {

    477. 

  477. 	                            	$data["host"]=$uri->getHost();

    478. 

  478. 	                            }

    479. 

  479. 	                            

    480. 

  480. 	                            if($check) {

    481. 

  481. 	                            	$this->_data=$data;

    482. 

  482. 	                            }

    483. 

  483.                                 

    484. 

  484.                                 if (isset($sefConfig->excludeSource) && $sefConfig->excludeSource && ($override == '0')) {

    485. 

  485.                                     if (isset($data['uri'])) {

    486. 

  486.                                         $data['uri']->delVar('Itemid');

    487. 

  487.                                     }

    488. 

  488.                                 }

    489. 

  489.                                 

    490. 

  490.                                	$uri = JoomSEF::_storeLocation($data,$check);

    491. 

  491.                             }

    492. 

  492.                         } else {

    493. 

  493.                             // if SEF is disabled, don't SEF

    494. 

  494.                             if (isset($sefUrl->sef) && !$sefUrl->sef) {

    495. 

  495.                                 $uri = JoomSEF::_createUri($uri);

    496. 

  496.                                 JoomSEF::_endSef($prevLang);

    497. 

  497.                                 $jRouter->SetMode(JROUTER_MODE_RAW);

    498. 

  498.                                 return;

    499. 

  499.                             }

    500. 

  500. 

    501. 

  501.                             // Create new JURI object from $sefstring

    502. 

  502.                     		if (!isset($sefUrl->host) || !strlen($sefUrl->host)) {

    503. 

  503.                     			$root = JFactory::getUri()->toString(array('host', 'port'));

    504. 

  504.                     		} else {

    505. 

  505.                     			$root = $sefUrl->host;

    506. 

  506.                     		}

    507. 

  507.                     		$url = JFactory::getURI()->getScheme()."://".$root.JURI::root(true);

    508. 

  508. 

    509. 

  509.                             if (substr($url, -1) != '/') {

    510. 

  510.                                 $url .= '/';

    511. 

  511.                             }

    512. 

  512.                             $url .= $sefUrl->sefurl;

    513. 

  513. 

    514. 

  514.                             // Add nonSef part if set

    515. 

  515.                             if( !empty($nonSefUrl) ) {

    516. 

  516.                                 $url .= '?'.$nonSefUrl;

    517. 

  517.                             }

    518. 

  518. 

    519. 

  519.                             // Add fragment if set

    520. 

  520.                             $fragment = $uri->getFragment();

    521. 

  521.                             if (!empty($fragment)) {

    522. 

  522.                                 $url .= '#'.$fragment;

    523. 

  523.                             }

    524. 

  524.                             $uri = new JURI($url);

    525. 

  525.                             

    526. 

  526.                         }

    527. 

  527. 

    528. 

  528.                         // reconnect the sid to the url

    529. 

  529.                         if (!empty($sid) && !$sefConfig->dontRemoveSid) $uri->setVar('sid', $sid);

    530. 

  530.                         // reconnect mosmsg to the url

    531. 

  531.                         if (!empty($mosmsg)) $uri->setVar('mosmsg', $mosmsg);

    532. 

  532. 

    533. 

  533.                         // reconnect ItemID to the url

    534. 

  534.                         // David: only if extension doesn't set its own Itemid through overrideId parameter

    535. 

  535.                         if (isset($sefConfig->excludeSource) && $sefConfig->excludeSource && $sefConfig->reappendSource && ($override == '0') && !empty($Itemid)) {

    536. 

  536.                             $uri->setVar('Itemid', $Itemid);

    537. 

  537.                         }

    538. 

  538. 

    539. 

  539.                         // let the extension change the resulting SEF url

    540. 

  540.                         $sef_ext->afterCreate($uri);

    541. 

  541.                     }

    542. 

  542.                 }

    543. 

  543.             }

    544. 

  544.         }

    545. 

  545.         else if (!is_null($uri->getVar('Itemid'))) {        	

    546. 

  546.             // there is only Itemid present - we must override the Ignore multiple sources option

    547. 

  547.             $oldIgnore = $sefConfig->ignoreSource;

    548. 

  548.             $sefConfig->ignoreSource = 0;

    549. 

  549. 

    550. 

  550. 			$lang="";

    551. 

  551.             $title = array();

    552. 

  552.             $title[] = JoomSEF::_getMenuTitleLang(null, $lang, $uri->getVar('Itemid'));

    553. 

  553. 

    554. 

  554.             $data = JoomSEF::_sefGetLocation($uri, $title, null, null, null, strlen($lang)?$lang:$uri->getVar('lang'));

    555. 

  555.             $uri = JoomSEF::_storeLocation($data);

    556. 

  556. 

    557. 

  557.             $sefConfig->ignoreSource = $oldIgnore;

    558. 

  558.         }

    559. 

  559. 		$uri->setPath(preg_replace("@^".$uri->base(true)."@","",$uri->getPath()));

    560. 

  560. 		

    561. 

  561.         JoomSEF::_endSef($prevLang);

    562. 

  562.         

    563. 

  563.         // Set Joomla's router so it doesn't process URL further

    564. 

  564.         $jRouter->SetMode(JROUTER_MODE_RAW);

    565. 

  565.     }

    566. 

  566.     

    567. 

  567.     function _prepareUriForCreate(&$params, &$uri) {

    568. 

  568.         $sefConfig = SEFConfig::getConfig();

    569. 

  569.         

    570. 

  570.         // Ensure that the session IDs are removed

    571. 

  571.         // If set to

    572. 

  572.         $sid = $uri->getVar('sid');

    573. 

  573.         if (!$sefConfig->dontRemoveSid) $uri->delVar('sid');

    574. 

  574.         // Ensure that the mosmsg are removed.

    575. 

  575.         $mosmsg = $uri->getVar('mosmsg');

    576. 

  576.         $uri->delVar('mosmsg');

    577. 

  577. 

    578. 

  578.         // override Itemid if set to

    579. 

  579.         $override = $params->get('itemid', '0');

    580. 

  580.         $overrideId = $params->get('overrideId', '');

    581. 

  581.         if (($override != '0') && ($overrideId != '')) {

    582. 

  582.             $uri->setVar('Itemid', $overrideId);

    583. 

  583.         }

    584. 

  584.         

    585. 

  585.         return array($sid, $mosmsg);

    586. 

  586.     }

    587. 

  587.     

    588. 

  588.     /**

    589. 

  589.      * Converts given language sef code to tag (eg. en => en-GB)

    590. 

  590.      * If given language is empty, returns current language tag

    591. 

  591.      */

    592. 

  592.     function getLangCode($sef = '') {

    593. 

  593.         if (empty($sef)) {

    594. 

  594.             $lang = JFactory::getLanguage();

    595. 

  595.             return $lang->getTag();

    596. 

  596.         }

    597. 

  597.         

    598. 

  598.         $langs = JLanguageHelper::getLanguages('sef');

    599. 

  599.         if (isset($langs[$sef])) {

    600. 

  600.             return $langs[$sef]->lang_code;

    601. 

  601.         }

    602. 

  602.         

    603. 

  603.         return null;

    604. 

  604.     }

    605. 

  605.     

    606. 

  606.     function getLanguage($uri) {

    607. 

  607.     	$sefConfig =& SEFConfig::getConfig();

    608. 

  608.         

    609. 

  609.         if (!$sefConfig->langEnable) {

    610. 

  610.             // Use default language from Joomla or whichever plugin

    611. 

  611.             return;

    612. 

  612.         }

    613. 

  613.         

    614. 

  614.     	$suffix=$sefConfig->suffix;

    615. 

  615.     	$lang="";

    616. 

  616.         $langs=JLanguageHelper::getLanguages('sef');

    617. 

  617.     	

    618. 

  618.     	JFactory::getApplication()->setLanguageFilter(true);

    619. 

  619.     	switch($sefConfig->langPlacementJoomla) {

    620. 

  620.     		case _COM_SEF_LANG_PATH:

    621. 

  621.     			$lang=$uri->getVar('lang');

    622. 

  622.     			if(strlen($lang)==0) {

    623. 

  623.         			$path=explode("/",ltrim(str_replace($uri->base(true),"",str_replace($suffix,"",$uri->getPath())),"/"));

    624. 

  624.         			if(strlen($path[0])<=3) { 

    625. 

  625.         				$lang=$path[0];

    626. 

  626.         			}

    627. 

  627.     			}

    628. 

  628.     			break;

    629. 

  629.     		case _COM_SEF_LANG_DOMAIN:

    630. 

  630.                 // 22.2.2012, dajo: simplified and fixed the function

    631. 

  631.     			$host = trim($uri->toString(array('host')), "/");

    632. 

  632.         		foreach ($sefConfig->subDomainsJoomla as $lng => $domain) {

    633. 

  633.         			if ($host == $domain) {

    634. 

  634.                         $lang = $lng;

    635. 

  635.                         

    636. 

  636.                         // Save the language code obtained from domain for later use

    637. 

  637.                         self::set('domain_lang', $lang);

    638. 

  638.                         

    639. 

  639.                         break;

    640. 

  640.         			}

    641. 

  641.         		}

    642. 

  642.     			break;

    643. 

  643.     	}

    644. 

  644.     	

    645. 

  645.     	if(strlen($lang)==0) {

    646. 

  646.     		// If is title page

    647. 

  647. 	    	if($uri->getPath()=='/') {

    648. 

  648. 	        	if($sefConfig->langCookieJoomla) {

    649. 

  649. 	        		$lang=JRequest::getString('joomsef_lang','','cookie');

    650. 

  650. 	        	}

    651. 

  651. 		        

    652. 

  652. 		        if(strlen($lang)==0 || !isset($langs[$lang])) {

    653. 

  653. 		        	if($sefConfig->browserLangJoomla) {

    654. 

  654. 			        	$lang=JLanguageHelper::detectLanguage();

    655. 

  655. 			        	$langsCode = JLanguageHelper::getLanguages('lang_code');

    656. 

  656. 		                if (isset($langsCode[$lang])) {

    657. 

  657. 			        	  $lang = $langsCode[$lang]->sef;

    658. 

  658. 		                }

    659. 

  659. 		        	}

    660. 

  660. 		        }

    661. 

  661. 		        if(strlen($lang)==0 || !isset($langs[$lang])) {

    662. 

  662. 		        	$lang=$sefConfig->mainLanguageJoomla;

    663. 

  663. 		        }

    664. 

  664. 		    // If is the main lang ang for main lang is lanuage not in URL

    665. 

  665. 	    	} else {

    666. 

  666. 	    		$lang=$sefConfig->mainLanguageJoomla;

    667. 

  667. 	    	}

    668. 

  668.     	}

    669. 

  669.     	

    670. 

  670.     	if(strlen($lang)) {

    671. 

  671.     		if (!isset($langs[$lang])) {

    672. 

  672.                 $lang = reset(array_keys($langs));

    673. 

  673.             }

    674. 

  674.             $lang_code = $langs[$lang]->lang_code;

    675. 

  675. 	    	$cfg = JFactory::getConfig();

    676. 

  676. 			$cfg->set('language', $lang_code);

    677. 

  677. 			JRequest::setVar('lang', $lang);

    678. 

  678. 			JRequest::setVar('language', $lang_code);

    679. 

  679. 			JFactory::getLanguage()->setLanguage($lang_code);

    680. 

  680. 			if ($sefConfig->langCookieJoomla && !headers_sent()) {

    681. 

  681. 				setcookie('joomsef_lang',$lang,time()+24*60*60*1000,"/");

    682. 

  682. 			}

    683. 

  683. 			JFactory::getLanguage()->getMetadata($lang_code);

    684. 

  684.     	}

    685. 

  685.     }

    686. 

  686. 

    687. 

  687.     function parse(&$uri)

    688. 

  688.     {

    689. 

  689.     	$sefConfig =& SEFConfig::getConfig();

    690. 

  690.     	$langs=JLanguageHelper::getLanguages('sef');

    691. 

  691.         // add base path, as Joomla does not send it but we count on it 

    692. 

  692.     	$uri->setPath(JURI::base(true) . '/' . $uri->getPath());

    693. 

  693.     	

    694. 

  694.     	$url_query=$uri->getQuery();

    695. 

  695.     	$host=explode(".",$uri->getHost());

    696. 

  696.     	$subdomain=array_shift($host);

    697. 

  697.     	$db=JFactory::getDBO();

    698. 

  698.     	// Subdomain titlepage

    699. 

  699.     	if(($uri->getPath()==JURI::base(true).'/') && empty($url_query) && empty($_POST)) {

    700. 

  700. 			$query=$db->getQuery(true);

    701. 

  701. 	    	$query->select('Itemid_titlepage')->from('#__sef_subdomains');

    702. 

  702. 	    	$query->where('subdomain='.$db->quote($subdomain));

    703. 

  703. 	    	if($sefConfig->langEnable) {

    704. 

  704. 	    		$lang=JRequest::getVar('lang');

    705. 

  705. 	    		$query->where('lang='.$db->quote($lang));

    706. 

  706. 	    	}

    707. 

  707. 	    	$db->setQuery($query, 0, 1);

    708. 

  708.     		$Itemid=$db->loadResult();

    709. 

  709.     		if($sefConfig->langEnable==1 && $Itemid>0) {

    710. 

  710. 	        	JFactory::getApplication()->redirect($uri->base(true).'/'.$lang, '', 'message', true);

    711. 

  711. 				JFactory::getApplication()->close();

    712. 

  712.     		} else { 

    713. 

  713. 	    		if($Itemid>0) {

    714. 

  714. 	    			$uri->setVar('Itemid',$Itemid);

    715. 

  715.                     JoomSEF::set('real_domain', JFactory::getUri()->getHost());

    716. 

  716. 	    			JFactory::getUri()->setHost(implode(".",$host));

    717. 

  717. 	    		}

    718. 

  718.     		}

    719. 

  719.     	} else if(empty($url_query) && empty($_POST) && $sefConfig->langEnable) {

    720. 

  720.     		$query=$db->getQuery(true);

    721. 

  721. 	    	$query->select('Itemid_titlepage')->from('#__sef_subdomains');

    722. 

  722. 	    	$query->where('subdomain='.$db->quote($subdomain));

    723. 

  723. 	    	$lang=JRequest::getVar('lang');

    724. 

  724. 	    	$query->where('lang='.$db->quote($lang));	    	

    725. 

  725. 	    	$db->setQuery($query, 0, 1);

    726. 

  726.     		$Itemid=$db->loadResult();

    727. 

  727. 	    	if($Itemid>0) {

    728. 

  728.     			$uri->setVar('Itemid',$Itemid);

    729. 

  729.                 JoomSEF::set('real_domain', JFactory::getUri()->getHost());

    730. 

  730.     			JFactory::getUri()->setHost(implode(".",$host));

    731. 

  731.     		}

    732. 

  732.     	} else {

    733. 

  733.     		$query=$db->getQuery(true);

    734. 

  734.     		$query->select('COUNT(*)')->from('#__sef_subdomains')->where('subdomain='.$db->quote($subdomain));

    735. 

  735.     		$db->setQuery($query);

    736. 

  736.     		$cnt=$db->loadResult();

    737. 

  737.     		if($cnt) {

    738. 

  738.                 JoomSEF::set('real_domain', JFactory::getUri()->getHost());

    739. 

  739.     			JFactory::getUri()->setHost(implode(".",$host));

    740. 

  740.     		}

    741. 

  741.     	}

    742. 

  742.     	    	

    743. 

  743.         // Set Joomla's router so it doesn't process URL further

    744. 

  744.         $mainframe =& JFactory::getApplication();

    745. 

  745.         $jRouter = $mainframe->getRouter();

    746. 

  746.         $jRouter->SetMode(JROUTER_MODE_DONT_PARSE);

    747. 

  747. 

    748. 

  748.         // store the old URI before we change it in case we will need it

    749. 

  749.         // for default Joomla SEF

    750. 

  750.         $oldUri = clone $uri;

    751. 

  751. 

    752. 

  752.         

    753. 

  753. 

    754. 

  754.         // load patches

    755. 

  755.         JPluginHelper::importPlugin('sefpatch');

    756. 

  756. 

    757. 

  757.         // trigger onSefLoad patches

    758. 

  758.         $mainframe->triggerEvent('onSefLoad');

    759. 

  759. 

    760. 

  760.         // get path

    761. 

  761.         $path = $uri->getPath();

    762. 

  762. 

    763. 

  763.         // remove basepath

    764. 

  764.         $path = substr_replace($path, '', 0, strlen(JURI::base(true)));

    765. 

  765. 

    766. 

  766.         // remove slashes

    767. 

  767.         $path = ltrim($path, '/');

    768. 

  768.         

    769. 

  769.         // Redirect URL with / on the end to URL without / on the end

    770. 

  770.         if($sefConfig->redirectSlash) {

    771. 

  771. 	        $request=$_SERVER["REQUEST_URI"];

    772. 

  772. 	        if($request!=$uri->base(true)."/" && substr($request,-1)=='/') {

    773. 

  773. 	        	$mainframe->redirect(rtrim($request,"/"),'','message', true);

    774. 

  774. 	        	JFactory::getApplication()->close();

    775. 

  775. 	        }

    776. 

  776.         }

    777. 

  777.         

    778. 

  778.         $request=$_SERVER["REQUEST_URI"];

    779. 

  779.         $route=str_replace($uri->getPath(),'',$request);

    780. 

  780.         $route=str_replace("?".$uri->getQuery(),'',$route);

    781. 

  781.         

    782. 

  782.         // Redirect the index.php (need to check this before index.php removal)

    783. 

  783.         if ($sefConfig->fixIndexPhp && ($route == 'index.php') && (count($_POST) == 0)) {

    784. 

  784.             $newUrl = JURI::root();

    785. 

  785.             if (substr($newUrl, -1) != '/') {

    786. 

  786.                 $newUrl .= '/';

    787. 

  787.             }

    788. 

  788.             $q = $uri->getQuery();

    789. 

  789.             if (!empty($q)) {

    790. 

  790.                 $newUrl .= '?'.$q;

    791. 

  791.             }

    792. 

  792.             $mainframe->redirect($newUrl, '', 'message', true);

    793. 

  793.             exit();

    794. 

  794.         }

    795. 

  795.         

    796. 

  796.         // fix Joomla URLs with index.php/

    797. 

  797.         $path = preg_replace('#^index\\.php\\/#i', '', $path);

    798. 

  798.         

    799. 

  799.         if($sefConfig->langEnable) {

    800. 

  800.         	if($sefConfig->langPlacementJoomla==_COM_SEF_LANG_PATH) {

    801. 

  801.         		$query=$uri->getQuery(true);

    802. 

  802.         		if(str_replace($uri->base(true),"",$uri->getPath())=='/' && empty($query) && empty($_POST)) {

    803. 

  803. 		        	$home_items=SEFTools::getHomeQueries();

    804. 

  804. 		        	$lang=$langs[JRequest::getVar('lang')]->lang_code;

    805. 

  805. 		        	foreach($home_items as $id=>$item) {

    806. 

  806. 		        		if($item->language==$lang) {

    807. 

  807. 		        			$Itemid=$item->id;

    808. 

  808. 		        			$link=$item->link;

    809. 

  809. 		        		}

    810. 

  810. 		        	}

    811. 

  811. 		        	JFactory::getApplication()->redirect($uri->base(true).'/'.$langs[JRequest::getVar('lang')]->sef, '', 'message', true);

    812. 

  812. 					JFactory::getApplication()->close();

    813. 

  813. 				}

    814. 

  814.         	}

    815. 

  815.         }

    816. 

  816.         

    817. 

  817.         // Try the 301 Alias redirect

    818. 

  818.         if (count($_POST) == 0) {

    819. 

  819.             Joomsef::_parseAlias($path, $uri->getQuery(true));

    820. 

  820.         }

    821. 

  821. 

    822. 

  822.         // remove prefix (both index.php and index2.php)

    823. 

  823.         //$path = eregi_replace('^index2?.php', '', $path);

    824. 

  824.         $path = preg_replace('/^index2?.php/i', '', $path);

    825. 

  825. 

    826. 

  826.         // remove slashes again to be sure there aren't any left

    827. 

  827.         $path = ltrim($path, '/');

    828. 

  828. 

    829. 

  829.         // replace spaces with our replacement character

    830. 

  830.         // (mainly for '+' handling, but may be useful in some other situations too)

    831. 

  831.         $path = str_replace(' ', $sefConfig->replacement, $path);

    832. 

  832. 

    833. 

  833.         // set the route

    834. 

  834.         $uri->setPath($path);        

    835. 

  835. 

    836. 

  836.         // parse the url

    837. 

  837.         $vars = JoomSEF::_parseSefUrl($uri, $oldUri);

    838. 

  838. 

    839. 

  839.         // handle custom site name for extensions

    840. 

  840.         if (isset($vars['option'])) {

    841. 

  841.             $params =& SEFTools::getExtParams($vars['option']);

    842. 

  842. 

    843. 

  843.             $useSitename = $params->get('useSitename', '1');

    844. 

  844.             $customSitename = trim($params->get('customSitename', ''));

    845. 

  845. 

    846. 

  846.             $config =& JFactory::getConfig();

    847. 

  847. 

    848. 

  848.             if ($useSitename == '0') {

    849. 

  849.                 // don't use site name

    850. 

  850.                 $config->setValue('sitename', '');

    851. 

  851.             }

    852. 

  852.             elseif (!empty($customSitename)) {

    853. 

  853.                 // use custom site name

    854. 

  854.                 $config->setValue('sitename', $customSitename);

    855. 

  855.             }

    856. 

  856.         }

    857. 

  857. 

    858. 

  858.         // trigger onSefUnload patches

    859. 

  859.         $mainframe->triggerEvent('onSefUnload');

    860. 

  860. 

    861. 

  861.         return $vars;

    862. 

  862.     }

    863. 

  863. 

    864. 

  864.     function _parseSefUrl(&$uri, &$oldUri)

    865. 

  865.     {

    866. 

  866.         $mainframe =& JFactory::getApplication();

    867. 

  867. 

    868. 

  868.         $db =& JFactory::getDBO();

    869. 

  869.         $sefConfig =& SEFConfig::getConfig();

    870. 

  870. 

    871. 

  871.         $route = $uri->getPath();        

    872. 

  872. 

    873. 

  873.         //Get the variables from the uri

    874. 

  874.         $vars = $uri->getQuery(true);

    875. 

  875. 

    876. 

  876.         // Should we generate canonical link automatically?

    877. 

  877.         $generateCanonical = (count($vars) > 0);

    878. 

  878.         

    879. 

  879. 

    880. 

  880.         // handle an empty URL (special case)

    881. 

  881.         if (empty($route) || $route==JRequest::getVar('lang')) {

    882. 

  882.             if (count($vars) > 0) {

    883. 

  883.                 $redir = false;

    884. 

  884.             }

    885. 

  885.             else {

    886. 

  886.                 $redir = true;

    887. 

  887.             }    

    888. 

  888. 

    889. 

  889.             $menu  =& JSite::getMenu(true);

    890. 

  890.             

    891. 

  891.             // TODO: handle metatags for subdomains correctly

    892. 

  892. 

    893. 

  893.             // if route is empty AND option is set in the query, assume it's non-sef url, and parse apropriately

    894. 

  894.             if (isset($vars['option']) || isset($vars['Itemid'])) {           	

    895. 

  895.                 return JoomSEF::_parseRawRoute($uri);

    896. 

  896.             }

    897. 

  897.             

    898. 

  898.             //$item = $menu->getDefault();

    899. 

  899.             // Workaround until Joomla menu bug will be fixed

    900. 

  900. 	        $langs=JLanguageHelper::getLanguages('sef');

    901. 

  901.             $items = null;

    902. 

  902.             if (isset($langs[JRequest::getVar('lang')])) {

    903. 

  903.                 $items=$menu->getItems(array('home','language'),array('1',$langs[JRequest::getVar('lang')]->lang_code));

    904. 

  904.             }

    905. 

  905.             if (!is_array($items) || (count($items) == 0)) {

    906. 

  906.                 $items = $menu->getItems(array('home'), array('1'));

    907. 

  907.             }

    908. 

  908. 	        $item=$items[0];

    909. 

  909. 

    910. 

  910.             //Set the information in the request

    911. 

  911.             $vars = $item->query;

    912. 

  912. 

    913. 

  913.             //Get the itemid

    914. 

  914.             $vars['Itemid'] = $item->id;

    915. 

  915. 

    916. 

  916.             // Set the active menu item

    917. 

  917.             $menu->setActive($vars['Itemid']);

    918. 

  918. 

    919. 

  919.             // Create automatic canonical link if set to

    920. 

  920.             if ($generateCanonical) {

    921. 

  921.                 $extAuto = 2;

    922. 

  922.                 if (isset($vars['option'])) {

    923. 

  923.                     $params =& SEFTools::getExtParams($vars['option']);

    924. 

  924.                     $extAuto = $params->get('autoCanonical', 2);

    925. 

  925.                 }

    926. 

  926.                 $autoCanonical = ($extAuto == 2) ? $sefConfig->autoCanonical : $extAuto;

    927. 

  927. 

    928. 

  928.                 if ($autoCanonical) {

    929. 

  929.                     $mainframe->set('sef.link.canonical', JURI::root());

    930. 

  930.                 }

    931. 

  931.             }

    932. 

  932. 

    933. 

  933.             // MetaTags for frontpage

    934. 

  934.             if (JPluginHelper::isEnabled('system', 'joomsef')) {

    935. 

  935.                 // ... and frontpage has meta tags

    936. 

  936.                 // Get all the URLs for frontpage and try to find the correct one

    937. 

  937.                 $lang = JRequest::getVar('lang');

    938. 

  938.                 $query = "SELECT * FROM #__sefurls WHERE sefurl = ".$db->quote($route)." ORDER BY `priority`";

    939. 

  939.                 $db->setQuery($query);

    940. 

  940.                 $sefRows = $db->loadObjectList();

    941. 

  941.                 

    942. 

  942.                 if (is_array($sefRows)) {

    943. 

  943.                     $count = count($sefRows);

    944. 

  944.                     if ($count == 1) {

    945. 

  945.                         // Use the only one

    946. 

  946.                         $sefRow = $sefRows[0];

    947. 

  947.                     }

    948. 

  948.                     else if ($count > 1) {

    949. 

  949.                         // Loop through URLs and find the one corresponding to menu item and possibly language

    950. 

  950.                         foreach ($sefRows as $row) {

    951. 

  951.                             // Check if variables match

    952. 

  952.                             $varsOk = true;

    953. 

  953.                             parse_str(str_replace('index.php?', '', $row->origurl), $rowVars);

    954. 

  954.                             foreach ($vars as $varKey => $varVal) {

    955. 

  955.                                 if ($varKey == 'Itemid') {

    956. 

  956.                                     if ($row->Itemid != $varVal) {

    957. 

  957.                                         $varsOk = false;

    958. 

  958.                                         break;

    959. 

  959.                                     }

    960. 

  960.                                 }

    961. 

  961.                                 else {

    962. 

  962.                                     if (!isset($rowVars[$varKey]) || ($rowVars[$varKey] != $varVal)) {

    963. 

  963.                                         $varsOk = false;

    964. 

  964.                                         break;

    965. 

  965.                                     }

    966. 

  966.                                 }

    967. 

  967.                             }

    968. 

  968.                             if (!$varsOk) {

    969. 

  969.                                 continue;

    970. 

  970.                             }

    971. 

  971.                             

    972. 

  972.                             // Variables match, this seems to be home page URL, try checking language

    973. 

  973.                             if (is_null($lang)) {

    974. 

  974.                                 // No language, use this URL

    975. 

  975.                                 $sefRow = $row;

    976. 

  976.                                 break;

    977. 

  977.                             }

    978. 

  978.                             else {

    979. 

  979.                                 // Check language

    980. 

  980.                                 if (isset($rowVars['lang'])) {

    981. 

  981.                                     if ($rowVars['lang'] == $lang) {

    982. 

  982.                                         // Found exact URL

    983. 

  983.                                         $sefRow = $row;

    984. 

  984.                                         break;

    985. 

  985.                                     }

    986. 

  986.                                 }

    987. 

  987.                                 else if (empty($noLang)) {

    988. 

  988.                                     // This URL doesn't contain lang variable, store it for later use

    989. 

  989.                                     $noLang = $row;

    990. 

  990.                                 }

    991. 

  991.                             }

    992. 

  992.                         }

    993. 

  993.                         

    994. 

  994.                         // If we didn't find correct URL, try to use the one without lang variable

    995. 

  995.                         if (empty($sefRow) && !empty($noLang)) {

    996. 

  996.                             $sefRow = $noLang;

    997. 

  997.                         }

    998. 

  998.                     }

    999. 

  999.                 }

    1000. 

  1000.                 

    1001. 

  1001.                 // Set meta tags

    1002. 

  1002.                 if( !empty($sefRow) ) {

    1003. 

  1003.                     $mainframe =& JFactory::getApplication();

    1004. 

  1004.                     if (!empty($sefRow->metatitle))  $mainframe->set('sef.meta.title', $sefRow->metatitle);

    1005. 

  1005.                     if (!empty($sefRow->metadesc))   $mainframe->set('sef.meta.desc', $sefRow->metadesc);

    1006. 

  1006.                     if (!empty($sefRow->metakey))    $mainframe->set('sef.meta.key', $sefRow->metakey);

    1007. 

  1007.                     if (!empty($sefRow->metalang))   $mainframe->set('sef.meta.lang', $sefRow->metalang);

    1008. 

  1008.                     if (!empty($sefRow->metarobots)) $mainframe->set('sef.meta.robots', $sefRow->metarobots);

    1009. 

  1009.                     if (!empty($sefRow->metagoogle)) $mainframe->set('sef.meta.google', $sefRow->metagoogle);

    1010. 

  1010.                     if (!empty($sefRow->canonicallink)) $mainframe->set('sef.link.canonical', $sefRow->canonicallink);

    1011. 

  1011.                     if (isset($sefRow->showsitename))   $mainframe->set('sef.meta.showsitename', $sefRow->showsitename);

    1012. 

  1012.                 }

    1013. 

  1013.             }

    1014. 

  1014. 

    1015. 

  1015.             return $vars;

    1016. 

  1016.         }

    1017. 

  1017. 

    1018. 

  1018.         $disabled = false;

    1019. 

  1019.         $sef_ext = new SefExt();

    1020. 

  1020.         $newVars = $sef_ext->revert($route, $disabled);

    1021. 

  1021. 

    1022. 

  1022.         // We need to determine language BEFORE Joomla SEO

    1023. 

  1023.         // so the menu is translated correctly

    1024. 

  1024.         $lang = self::get('domain_lang');

    1025. 

  1025.         if (empty($lang)) {

    1026. 

  1026.             $lang = (isset($newVars['lang']) ? $newVars['lang'] : (isset($vars['lang']) ? $vars['lang'] : null));

    1027. 

  1027.         }

    1028. 

  1028.         else if ($sefConfig->wrongDomainHandling != _COM_SEF_WRONG_DOMAIN_DO_NOTHING) {

    1029. 

  1029.             // We have a language from domain, check if it corresponds to language in SEF URL

    1030. 

  1030.             if (isset($newVars['lang']) && ($newVars['lang'] != $lang)) {

    1031. 

  1031.                 // Domain and SEF URL languages don't match

    1032. 

  1032.                 if ($sefConfig->wrongDomainHandling == _COM_SEF_WRONG_DOMAIN_REDIRECT) {

    1033. 

  1033.                     // Redirect to correct domain

    1034. 

  1034.                     if (isset($sefConfig->subDomainsJoomla[$newVars['lang']])) {

    1035. 

  1035.                         $domain = $sefConfig->subDomainsJoomla[$newVars['lang']];

    1036. 

  1036.                         $redir = JURI::getInstance();

    1037. 

  1037.                         $redir->setHost($domain);

    1038. 

  1038.                         

    1039. 

  1039.                         // Redirect

    1040. 

  1040.                         $mainframe =& JFactory::getApplication();

    1041. 

  1041.                         $mainframe->redirect($redir->toString(), '', 'message', true);

    1042. 

  1042.                         exit();

    1043. 

  1043.                     }

    1044. 

  1044.                     

    1045. 

  1045.                     // No domain found, show 404

    1046. 

  1046.                     $disabled = true;

    1047. 

  1047.                 }

    1048. 

  1048.                 else {

    1049. 

  1049.                     // Show 404 page

    1050. 

  1050.                     $disabled = true;

    1051. 

  1051.                 }

    1052. 

  1052.             }

    1053. 

  1053.         }

    1054. 

  1054. 

    1055. 

  1055.         if (!empty($newVars) && !empty($vars) && $sefConfig->nonSefQueryVariables) {

    1056. 

  1056.             // If this was SEF url, consider the vars in query as nonsef

    1057. 

  1057.             $nonsef = array_diff_key($vars, $newVars);

    1058. 

  1058.             if (!empty($nonsef)) {

    1059. 

  1059.                 $mainframe->set('sef.global.nonsefvars', $nonsef);

    1060. 

  1060.             }

    1061. 

  1061.         }

    1062. 

  1062. 

    1063. 

  1063.         // try to parse joomla native seo

    1064. 

  1064.         if ($sefConfig->parseJoomlaSEO && empty($newVars)) {

    1065. 

  1065.             $oldUrl = $oldUri->toString(array('path', 'query', 'fragment'));           

    1066. 

  1066.             $router = $mainframe->getRouter();

    1067. 

  1067.             $router->setMode(JROUTER_MODE_SEF);

    1068. 

  1068.             $jvars = $router->parse($oldUri);

    1069. 

  1069.             $router->setMode(JROUTER_MODE_DONT_PARSE);

    1070. 

  1070.             

    1071. 

  1071.             // Check 404

    1072. 

  1072.             if (isset($jvars['option']) && ($jvars['option'] == 'com_content') &&

    1073. 

  1073.                 isset($jvars['view']) &&

    1074. 

  1074.                 isset($jvars['id']) && ($jvars['id'] == 0))

    1075. 

  1075.             {

    1076. 

  1076.                 // 404

    1077. 

  1077.                 $jvars = array();

    1078. 

  1078.             }

    1079. 

  1079. 

    1080. 

  1080.             if (!empty($jvars['option']) || !empty($jvars['Itemid'])) {

    1081. 

  1081.                 // Fix Itemid

    1082. 

  1082.                 if (array_key_exists('Itemid', $jvars) && is_null($jvars['Itemid'])) {

    1083. 

  1083.                     unset($jvars['Itemid']);

    1084. 

  1084.                 }

    1085. 

  1085. 

    1086. 

  1086.                 // Try to get option from URL or menu item

    1087. 

  1087.                 if (!isset($jvars['option'])) {

    1088. 

  1088.                     // Get the option from menu item

    1089. 

  1089.                     $menu =& JSite::getMenu(true);

    1090. 

  1090.                     $item =& $menu->getItem($jvars['Itemid']);

    1091. 

  1091. 

    1092. 

  1092.                     if (!is_null($item) && isset($item->query['option']))

    1093. 

  1093.                     {

    1094. 

  1094.                         $jopt = $item->query['option'];

    1095. 

  1095.                     }

    1096. 

  1096.                 }

    1097. 

  1097.                 else {

    1098. 

  1098.                     $jopt = $jvars['option'];

    1099. 

  1099.                 }

    1100. 

  1100.                 

    1101. 

  1101.                 // Was it possible to retrieve component?

    1102. 

  1102.                 if (isset($jopt)) {

    1103. 

  1103.                     // If the component is not handled by default Joomla router

    1104. 

  1104.                     // try to find corresponding SEF URL in JoomSEF's database

    1105. 

  1105.                     require_once(JPATH_ADMINISTRATOR.DS.'components'.DS.'com_sef'.DS.'models'.DS.'extensions.php');

    1106. 

  1106.                     $handler = SEFModelExtensions::_getActiveHandler($jopt);

    1107. 

  1107.                     if (!in_array($handler->code, array(_COM_SEF_HANDLER_ROUTER, _COM_SEF_HANDLER_JOOMLA, _COM_SEF_HANDLER_NONE))) {

    1108. 

  1108.                         // Try to get the SEF URL

    1109. 

  1109.                         $oldDisable = $sefConfig->disableNewSEF;

    1110. 

  1110.                         $sefConfig->disableNewSEF = true;

    1111. 

  1111.         

    1112. 

  1112.                         $jUri = new JURI('index.php');

    1113. 

  1113.                         $jUri->setQuery($jvars);

    1114. 

  1114.                         if ($jUri->getVar('format') == 'html') {

    1115. 

  1115.                             $jUri->delVar('format');

    1116. 

  1116.                         }

    1117. 

  1117.                         $jUrl = $jUri->toString(array('path', 'query', 'fragment'));

    1118. 

  1118.                         $jSefUri = new JURI(JRoute::_($jUrl));

    1119. 

  1119.                         $jSef = $jSefUri->toString(array('path', 'query', 'fragment'));

    1120. 

  1120.                         //$jSef = urldecode(str_replace('&amp;', '&', $jSef));

    1121. 

  1121.                         

    1122. 

  1122.                         // Remove base

    1123. 

  1123.                         $base = JURI::base(true);

    1124. 

  1124.                         $baseLen = strlen($base);

    1125. 

  1125.                         if (substr($oldUrl, 0, $baseLen) == $base) {

    1126. 

  1126.                             $oldUrl = substr($oldUrl, $baseLen);

    1127. 

  1127.                         }

    1128. 

  1128.                         if (substr($jSef, 0, $baseLen) == $base) {

    1129. 

  1129.                             $jSef = substr($jSef, $baseLen);

    1130. 

  1130.                         }

    1131. 

  1131.                         

    1132. 

  1132.                         // Fix slashes - left

    1133. 

  1133.                         $oldUrl = ltrim($oldUrl, '/');

    1134. 

  1134.                         $jSef = ltrim($jSef, '/');

    1135. 

  1135.         

    1136. 

  1136.                         // Fix slashes - right

    1137. 

  1137.                         //$oldUrl = preg_replace('/^([^?]*)\/(\??)/', '$1$2', $oldUrl);

    1138. 

  1138.                         //$jSef = preg_replace('/^([^?]*)\/(\??)/', '$1$2', $jSef);

    1139. 

  1139.                         $oldUrl = JoomSEF::_removeRightSlash($oldUrl);

    1140. 

  1140.                         $jSef = JoomSEF::_removeRightSlash($jSef);

    1141. 

  1141.                         

    1142. 

  1142.                         // Restore the configuration

    1143. 

  1143.                         $sefConfig->disableNewSEF = $oldDisable;

    1144. 

  1144.         

    1145. 

  1145.                         if (count($_POST) == 0) {

    1146. 

  1146.                             // Non-SEF redirect

    1147. 

  1147.                             if ((strpos($jSef, 'index.php?') === false) && ($oldUrl != $jSef)) {

    1148. 

  1148.                                 // Seems the URL is SEF, let's redirect

    1149. 

  1149.                                 $mainframe =& JFactory::getApplication();

    1150. 

  1150.                                 $mainframe->redirect(JURI::root() . $jSef, '', 'message', true);

    1151. 

  1151.                                 $mainframe->close();

    1152. 

  1152.                             }

    1153. 

  1153.                         }

    1154. 

  1154.                     }

    1155. 

  1155. 

    1156. 

  1156.                     // OK, we can show the page for this component

    1157. 

  1157.                     $newVars = $jvars;

    1158. 

  1158.                 }

    1159. 

  1159.             }

    1160. 

  1160.         }

    1161. 

  1161. 

    1162. 

  1162.         if (!empty($vars)) {

    1163. 

  1163.             // append the original query string because some components

    1164. 

  1164.             // (like SMF Bridge and SOBI2) use it

    1165. 

  1165.             $vars = array_merge($vars, $newVars);

    1166. 

  1166.         } else {

    1167. 

  1167.             $vars = $newVars;

    1168. 

  1168.         }

    1169. 

  1169. 		

    1170. 

  1170.         if (empty($newVars)==false && $disabled==false) {

    1171. 

  1171.             // Parsed correctly and enabled

    1172. 

  1172.             JoomSEF::_sendHeader('HTTP/1.0 200 OK');

    1173. 

  1173. 

    1174. 

  1174.             // Create automatic canonical link if set to and it is not already set

    1175. 

  1175.             $canonical = $mainframe->get('sef.link.canonical');

    1176. 

  1176.             if ($generateCanonical && empty($canonical)) {

    1177. 

  1177.                 $extAuto = 2;

    1178. 

  1178.                 if (isset($vars['option'])) {

    1179. 

  1179.                     $params =& SEFTools::getExtParams($vars['option']);

    1180. 

  1180.                     $extAuto = $params->get('autoCanonical', 2);

    1181. 

  1181.                 }

    1182. 

  1182.                 $autoCanonical = ($extAuto == 2) ? $sefConfig->autoCanonical : $extAuto;

    1183. 

  1183. 

    1184. 

  1184.                 if ($autoCanonical) {

    1185. 

  1185.                     $mainframe->set('sef.link.canonical', JURI::root().$route);

    1186. 

  1186.                 }

    1187. 

  1187.             }

    1188. 

  1188.         }

    1189. 

  1189.         else

    1190. 

  1190.         {

    1191. 

  1191.             // set nonsef vars

    1192. 

  1192.             if (!$disabled) {

    1193. 

  1193.                 $mainframe->set('sef.global.nonsefvars', $vars);

    1194. 

  1194.             }

    1195. 

  1195. 

    1196. 

  1196.             // bad URL, so check to see if we've seen it before

    1197. 

  1197.             // 404 recording (only if enabled)

    1198. 

  1198.             if ($sefConfig->record404) {

    1199. 

  1199.                 $query = "SELECT * FROM `#__sefurls` WHERE `sefurl` = '".$route."'";

    1200. 

  1200.                 $db->setQuery($query);

    1201. 

  1201.                 $results = $db->loadObjectList();

    1202. 

  1202. 

    1203. 

  1203.                 if ($results) {

    1204. 

  1204.                     // we have it, so update counter

    1205. 

  1205.                     $db->setQuery("UPDATE `#__sefurls` SET `cpt`=(`cpt`+1) WHERE `sefurl` = '".$route."'");

    1206. 

  1206.                     $db->query();

    1207. 

  1207.                 }

    1208. 

  1208.                 else {

    1209. 

  1209.                     // get trace info

    1210. 

  1210.                     if (@$sefConfig->trace) {

    1211. 

  1211.                         $traceinfo = "'" . mysql_escape_string(JoomSEF::_getDebugInfo($sefConfig->traceLevel, true)) . "'";

    1212. 

  1212.                     }

    1213. 

  1213.                     else $traceinfo = "NULL";

    1214. 

  1214. 

    1215. 

  1215.                     // record the bad URL

    1216. 

  1216.                     $query = "INSERT INTO `#__sefurls` (`cpt`, `sefurl`, `origurl`, `trace`, `dateadd`) "

    1217. 

  1217.                     . " VALUES ( '1', '$route', '', {$traceinfo}, CURDATE() )";

    1218. 

  1218.                     $db->setQuery($query);

    1219. 

  1219.                     $db->query();

    1220. 

  1220.                 }

    1221. 

  1221.             }

    1222. 

  1222. 

    1223. 

  1223.             // redirect to the error page

    1224. 

  1224.             $vars = JoomSEF::_get404vars($route);

    1225. 

  1225.         }

    1226. 

  1226. 

    1227. 

  1227.         // Set QUERY_STRING if set to

    1228. 

  1228.         if ($sefConfig->setQueryString) {

    1229. 

  1229.             $qs = array();

    1230. 

  1230.             foreach ($vars as $name => $val) {

    1231. 

  1231.                 if (is_array($val)) {

    1232. 

  1232.                     foreach ($val as $k => $v) {

    1233. 

  1233.                         $qs[] = $name . '[' . $k . ']=' . urlencode($v);

    1234. 

  1234.                     }

    1235. 

  1235.                 }

    1236. 

  1236.                 else {

    1237. 

  1237.                     $qs[] = $name . '=' . urlencode($val);

    1238. 

  1238.                 }

    1239. 

  1239.             }

    1240. 

  1240.             $qs = implode('&', $qs);

    1241. 

  1241.             if (!empty($qs)) {

    1242. 

  1242.                 $_SERVER['QUERY_STRING'] = $qs;

    1243. 

  1243.             }

    1244. 

  1244.         }

    1245. 

  1245. 

    1246. 

  1246.         return $vars;

    1247. 

  1247.     }

    1248. 

  1248. 

    1249. 

  1249.     function _removeRightSlash($url)

    1250. 

  1250.     {

    1251. 

  1251.         if (strpos($url, '?') === false) {

    1252. 

  1252.             // No question mark

    1253. 

  1253.             return rtrim($url, '/');

    1254. 

  1254.         }

    1255. 

  1255.         

    1256. 

  1256.         // Check slash before question mark

    1257. 

  1257.         $qpos = strpos($url, '/?');

    1258. 

  1258.         if ($qpos !== false) {

    1259. 

  1259.             /*$spos = strpos($url, '/');

    1260. 

  1260.             if ($qpos <= $spos) {

    1261. 

  1261.                 $url = substr($url, 0, $qpos).substr($url, $qpos+1);

    1262. 

  1262.             }*/

    1263. 

  1263.             $url = substr($url, 0, $qpos).substr($url, $qpos+1);

    1264. 

  1264.         }

    1265. 

  1265. 

    1266. 

  1266.         return $url;

    1267. 

  1267.     }

    1268. 

  1268. 

    1269. 

  1269.     function _get404vars($route = '')

    1270. 

  1270.     {

    1271. 

  1271.         $mainframe =& JFactory::getApplication();

    1272. 

  1272. 

    1273. 

  1273.         $db =& JFactory::getDBO();

    1274. 

  1274.         $sefConfig =& SEFConfig::getConfig();

    1275. 

  1275. 

    1276. 

  1276.         // you MUST create a static content page with the title 404 for this to work properly

    1277. 

  1277.         if ($sefConfig->showMessageOn404) {

    1278. 

  1278.             $mosmsg = 'FILE NOT FOUND: '.$route;

    1279. 

  1279.             $mainframe->enqueueMessage($mosmsg);

    1280. 

  1280.         }

    1281. 

  1281.         else $mosmsg = '';

    1282. 

  1282. 

    1283. 

  1283.         if ($sefConfig->page404 == '0') {

    1284. 

  1284.             $sql = 'SELECT `id`  FROM `#__content` WHERE `title`= "404"';

    1285. 

  1285.             $db->setQuery($sql);

    1286. 

  1286. 

    1287. 

  1287.             if (($id = $db->loadResult())) {

    1288. 

  1288.                 $vars['option'] = 'com_content';

    1289. 

  1289.                 $vars['view'] = 'article';

    1290. 

  1290.                 $vars['id'] = $id;

    1291. 

  1291.             }

    1292. 

  1292.             else {

    1293. 

  1293.                 die(JText::_('COM_SEF_ERROR_DEFAULT_404').$mosmsg."<br />URI:".$_SERVER['REQUEST_URI']);

    1294. 

  1294.             }

    1295. 

  1295.         }

    1296. 

  1296.         elseif ($sefConfig->page404 == '9999999') {

    1297. 

  1297.             $menu  =& JSite::getMenu(true);

    1298. 

  1298.             //$item = $menu->getDefault();

    1299. 

  1299.             // Workaround until Joomla menu bug will be fixed

    1300. 

  1300. 	        $items=$menu->getItems(array('home','language'),array('1','*'));

    1301. 

  1301. 	        $item=$items[0];

    1302. 

  1302. 

    1303. 

  1303. 

    1304. 

  1304.             //Set the information in the frontpage request

    1305. 

  1305.             $vars = $item->query;

    1306. 

  1306. 

    1307. 

  1307.             //Get the itemid

    1308. 

  1308.             $vars['Itemid'] = $item->id;

    1309. 

  1309.             $menu->setActive($vars['Itemid']);

    1310. 

  1310.         }

    1311. 

  1311.         else {

    1312. 

  1312.             $id = $sefConfig->page404;

    1313. 

  1313.             $vars['option'] = 'com_content';

    1314. 

  1314.             $vars['view'] = 'article';

    1315. 

  1315.             $vars['id'] = $id;

    1316. 

  1316.         }

    1317. 

  1317. 

    1318. 

  1318.         // If custom Itemid set, use it

    1319. 

  1319.         if ($sefConfig->use404itemid) {

    1320. 

  1320.             $vars['Itemid'] = $sefConfig->itemid404;

    1321. 

  1321.         }

    1322. 

  1322. 

    1323. 

  1323.         JoomSEF::_sendHeader('HTTP/1.0 404 NOT FOUND');

    1324. 

  1324. 

    1325. 

  1325.         return $vars;

    1326. 

  1326.     }

    1327. 

  1327. 

    1328. 

  1328.     function _parseAlias($route, &$vars)

    1329. 

  1329.     {

    1330. 

  1330.         $db =& JFactory::getDBO();

    1331. 

  1331.         $sefConfig =& SEFConfig::getConfig();

    1332. 

  1332. 

    1333. 

  1333.         $route = html_entity_decode(urldecode($route));

    1334. 

  1334. 

    1335. 

  1335.         // Get all the corresponding aliases

    1336. 

  1336.         $query = "SELECT `a`.`vars`, `u`.`sefurl` FROM `#__sefaliases` AS `a` INNER JOIN `#__sefurls` AS `u` ON `u`.`id` = `a`.`url` WHERE `a`.`alias` = " . $db->Quote($route);

    1337. 

  1337.         $db->setQuery($query);

    1338. 

  1338.         $aliases = $db->loadObjectList();

    1339. 

  1339. 

    1340. 

  1340.         // Are there any aliases?

    1341. 

  1341.         if (!is_array($aliases) || (count($aliases) == 0)) {

    1342. 

  1342.             return;

    1343. 

  1343.         }

    1344. 

  1344. 

    1345. 

  1345.         // Try to find alias with corresponding variables

    1346. 

  1346.         foreach ($aliases as $alias) {

    1347. 

  1347.             // Create the array of alias variables

    1348. 

  1348.             $avars = array();

    1349. 

  1349.             $alias->vars = trim($alias->vars);

    1350. 

  1350.             if (!empty($alias->vars)) {

    1351. 

  1351.                 $tmpvars = explode("\n", $alias->vars);

    1352. 

  1352. 

    1353. 

  1353.                 foreach($tmpvars as $tmpvar) {

    1354. 

  1354.                     list($vname, $vvalue) = explode('=', $tmpvar);

    1355. 

  1355.                     $avars[$vname] = urldecode($vvalue);

    1356. 

  1356.                 }

    1357. 

  1357.             }

    1358. 

  1358. 

    1359. 

  1359.             // Check the variables count

    1360. 

  1360.             if (count($avars) != count($vars)) {

    1361. 

  1361.                 continue;

    1362. 

  1362.             }

    1363. 

  1363. 

    1364. 

  1364.             // Check all the variables

    1365. 

  1365.             $ok = true;

    1366. 

  1366.             foreach ($vars as $name => $value) {

    1367. 

  1367.                 if (!isset($avars[$name]) || ($avars[$name] != $value)) {

    1368. 

  1368.                     $ok = false;

    1369. 

  1369.                     break;

    1370. 

  1370.                 }

    1371. 

  1371.             }

    1372. 

  1372.             if (!$ok) {

    1373. 

  1373.                 continue;

    1374. 

  1374.             }

    1375. 

  1375. 

    1376. 

  1376.             // Correct alias found, redirect

    1377. 

  1377.             $mainframe =& JFactory::getApplication();

    1378. 

  1378.             $url = JURI::root();

    1379. 

  1379.             if (substr($url, -1) != '/') {

    1380. 

  1380.                 $url .= '/';

    1381. 

  1381.             }

    1382. 

  1382.             $url .= ltrim($alias->sefurl, '/');

    1383. 

  1383.             $mainframe->redirect($url, '', 'message', true);

    1384. 

  1384.             $mainframe->close();

    1385. 

  1385.         }

    1386. 

  1386.     }

    1387. 

  1387. 

    1388. 

  1388.     function _sendHeader($header)

    1389. 

  1389.     {

    1390. 

  1390.         if (!headers_sent()) {

    1391. 

  1391.         	//file_put_contents(JPATH_SITE.DS.'tmp'.DS.'header',$header."\n",FILE_APPEND);

    1392. 

  1392.             header($header);

    1393. 

  1393.         }

    1394. 

  1394.         // 25.4.2012 dajo: Don't die when headers already sent

    1395. 

  1395.         // else {

    1396. 

  1396.         //    JoomSEF::_headers_sent_error($f, $l, __FILE__, __LINE__);

    1397. 

  1397.         //}

    1398. 

  1398.     }

    1399. 

  1399. 

    1400. 

  1400.     function _parseRawRoute(&$uri)

    1401. 

  1401.     {

    1402. 

  1402.         $sefConfig =& SEFConfig::getConfig();

    1403. 

  1403. 

    1404. 

  1404.         if( is_null($uri->getVar('option')) ) {

    1405. 

  1405.             // Set the URI from Itemid

    1406. 

  1406.             $menu =& JSite::getMenu(true);

    1407. 

  1407.             $item = $menu->getItem($uri->getVar('Itemid'));

    1408. 

  1408.             if( !is_null($item) ) {

    1409. 

  1409.                 $uri->setQuery($item->query);

    1410. 

  1410.                 $uri->setVar('Itemid', $item->id);

    1411. 

  1411.             }

    1412. 

  1412.         }

    1413. 

  1413. 

    1414. 

  1414. 

    1415. 

  1415.         $extAuto = 2;

    1416. 

  1416.         if (isset($params)) {

    1417. 

  1417.             $extAuto = $params->get('autoCanonical', 2);

    1418. 

  1418.         }

    1419. 

  1419.         $autoCanonical = ($extAuto == 2) ? $sefConfig->autoCanonical : $extAuto;

    1420. 

  1420. 

    1421. 

  1421.         if (($sefConfig->nonSefRedirect && (count($_POST) == 0)) || $autoCanonical)

    1422. 

  1422.         {

    1423. 

  1423.             // Try to find the non-SEF URL in the database - don't create new!

    1424. 

  1424.             $oldDisable = $sefConfig->disableNewSEF;

    1425. 

  1425.             $sefConfig->disableNewSEF = true;

    1426. 

  1426. 			

    1427. 

  1427.             $uri->setPath('index.php');

    1428. 

  1428.             $url = $uri->toString(array('path', 'query', 'fragment'));

    1429. 

  1429.             $sef = JRoute::_($url);

    1430. 

  1430.             

    1431. 

  1431.             // Revert, otherwise Joomla in its router thinks this is SEF URL,

    1432. 

  1432.             // because its path is not empty!

    1433. 

  1433.             $uri->setPath('');

    1434. 

  1434. 

    1435. 

  1435.             // Restore the configuration

    1436. 

  1436.             $sefConfig->disableNewSEF = $oldDisable;

    1437. 

  1437. 

    1438. 

  1438.             if ($sefConfig->nonSefRedirect && (count($_POST) == 0)) {

    1439. 

  1439.                 // Non-SEF redirect

    1440. 

  1440.                 if( strpos($sef, 'index.php?') === false ) {

    1441. 

  1441.                     // Check if it's different from current URL

    1442. 

  1442.                     $curUri = JURI::getInstance();

    1443. 

  1443.                     if ($sef[0] == '/') {

    1444. 

  1444.                         $curUrl = $curUri->toString(array('path', 'query', 'fragment'));

    1445. 

  1445.                     }

    1446. 

  1446.                     else {

    1447. 

  1447.                         $curUrl = MyURI::getURI($curUri);

    1448. 

  1448.                     }

    1449. 

  1449.                     

    1450. 

  1450.                     // Fix the &amp; characters

    1451. 

  1451.                     $sef = str_replace('&amp;', '&', $sef);

    1452. 

  1452.                     

    1453. 

  1453.                     if ($sef != $curUrl) {

    1454. 

  1454.                         // Seems the URL is SEF, let's redirect

    1455. 

  1455.                         $mainframe =& JFactory::getApplication();

    1456. 

  1456.                         $mainframe->redirect($sef, '', 'message', true);

    1457. 

  1457.                         $mainframe->close();

    1458. 

  1458.                     }

    1459. 

  1459.                 }

    1460. 

  1460.             }

    1461. 

  1461.             else if ($autoCanonical) {

    1462. 

  1462.                 // Only set canonical URL

    1463. 

  1463.                 $mainframe =& JFactory::getApplication();

    1464. 

  1464. 

    1465. 

  1465.                 // Remove the query part from SEF URL

    1466. 

  1466.                 $pos = strpos($sef, '?');

    1467. 

  1467.                 if ($pos !== false) {

    1468. 

  1468.                     $sef = substr($sef, 0, $pos);

    1469. 

  1469.                 }

    1470. 

  1470. 

    1471. 

  1471.                 $mainframe->set('sef.link.canonical', $sef);

    1472. 

  1472.             }

    1473. 

  1473.         }

    1474. 

  1474. 

    1475. 

  1475.         return $uri->getQuery(true);

    1476. 

  1476.     }

    1477. 

  1477. 

    1478. 

  1478.     // 25.4.2012 dajo: removed

    1479. 

  1479.     //function _headers_sent_error($sentFile, $sentLine, $file, $line)

    1480. 

  1480.     //{

    1481. 

  1481.     //    die("<br />Error: headers already sent in ".basename($sentFile)." on line $sentLine.<br />Stopped at line ".$line." in ".basename($file));

    1482. 

  1482.     //}

    1483. 

  1483. 

    1484. 

  1484.     function & _createUri(&$uri)

    1485. 

  1485.     {

    1486. 

  1486.         $url = JURI::root();

    1487. 

  1487.         $path=JURI::root(true);

    1488. 

  1488.         if( substr($url, -1) != '/' ) {

    1489. 

  1489.             $url .= '/';

    1490. 

  1490.         }

    1491. 

  1491.         $url .= $uri->toString(array('path', 'query', 'fragment'));

    1492. 

  1492.         $newUri = new JURI($url);

    1493. 

  1493.         $path=str_replace($path,"",$newUri->getPath());

    1494. 

  1494. 		$newUri->setPath($path);

    1495. 

  1495. 

    1496. 

  1496.         return $newUri;

    1497. 

  1497.     }

    1498. 

  1498. 

    1499. 

  1499.     function _endSef($lang = '')

    1500. 

  1500.     {

    1501. 

  1501.         $mainframe =& JFactory::getApplication();

    1502. 

  1502. 

    1503. 

  1503.         $mainframe->triggerEvent('onSefEnd');

    1504. 

  1504.         JoomSEF::_restoreLang($lang);

    1505. 

  1505.     }

    1506. 

  1506. 

    1507. 

  1507.     function _restoreLang($lang = '')

    1508. 

  1508.     {

    1509. 

  1509.         if ($lang != '') {

    1510. 

  1510.             if ($lang != JoomSEF::getLangCode()) {

    1511. 

  1511.                 $language = JFactory::getLanguage();

    1512. 

  1512.                 $language->setLanguage($lang);

    1513. 

  1513.                 $language->load();

    1514. 

  1514.             }

    1515. 

  1515.         }

    1516. 

  1516.     }

    1517. 

  1517. 

    1518. 

  1518.     function _isHomePage(&$uri, $altered = false)

    1519. 

  1519.     {

    1520. 

  1520.         $home_items=SEFTools::getHomeQueries();

    1521. 

  1521.         $langs=JLanguageHelper::getLanguages('lang_code');

    1522. 

  1522.         $config=SEFConfig::getConfig();

    1523. 

  1523.         

    1524. 

  1524.         $Itemid = $uri->getVar('Itemid');

    1525. 

  1525.         if(array_key_exists($Itemid,$home_items) && $uri->getPath()=='index.php') {

    1526. 

  1526.             if($config->langEnable) {

    1527. 

  1527.                 if (strlen($uri->getVar('lang', '')) == 0) {

    1528. 

  1528.                     $langTag = $home_items[$Itemid]->language;

    1529. 

  1529.                     if (isset($langs[$langTag])) {

    1530. 

  1530.                         $uri->setVar('lang', $langs[$langTag]->sef);

    1531. 

  1531.                     }

    1532. 

  1532.                     else {

    1533. 

  1533.                         // Use current language

    1534. 

  1534.                         $langTag = JFactory::getLanguage()->getTag();

    1535. 

  1535.                         if (isset($langs[$langTag])) {

    1536. 

  1536.                             $uri->setVar('lang', $langs[$langTag]->sef);

    1537. 

  1537.                         }

    1538. 

  1538.                     }

    1539. 

  1539.                 }

    1540. 

  1540.             }

    1541. 

  1541.             

    1542. 

  1542.             // Set the link queries if not already there

    1543. 

  1543.             if (!isset($home_items[$Itemid]->linkQuery)) {

    1544. 

  1544.                 $link = new JURI($home_items[$Itemid]->link);

    1545. 

  1545.                 $home_items[$Itemid]->linkQuery = $link->getQuery(true);

    1546. 

  1546.                 $home_items[$Itemid]->normalizedQuery = null;

    1547. 

  1547.                 

    1548. 

  1548.                 // Normalize query if an extension is available

    1549. 

  1549.                 $option = $link->getVar('option');

    1550. 

  1550.                 if (!is_null($option)) {

    1551. 

  1551.                     $extFile = JPATH_ROOT.DS.'components'.DS.'com_sef'.DS.'sef_ext'.DS.$option.'.php';

    1552. 

  1552.                     if (file_exists($extFile)) {

    1553. 

  1553.                         $class = 'SefExt_'.$option;

    1554. 

  1554.                         

    1555. 

  1555.                         if (!class_exists($class)) {

    1556. 

  1556.                     		require($extFile);

    1557. 

  1557.                     	}

    1558. 

  1558.                         $sef_ext = new $class();

    1559. 

  1559.                         $link->setVar('Itemid', $Itemid);

    1560. 

  1560.                         $sef_ext->beforeCreate($link);

    1561. 

  1561.                         $link->delVar('Itemid');

    1562. 

  1562.                         $link->delVar('lang');

    1563. 

  1563.                         $home_items[$Itemid]->normalizedQuery = $link->getQuery(true);

    1564. 

  1564.                         $sef_ext = null;

    1565. 

  1565.                     }

    1566. 

  1566.                 }

    1567. 

  1567.             }

    1568. 

  1568.             

    1569. 

  1569.             // The queries need to match 1:1 (except Itemid and lang(?)), not just the variables present in home item!

    1570. 

  1570.             $uriQuery = $uri->getQuery(true);

    1571. 

  1571.             if (array_key_exists('Itemid', $uriQuery)) unset($uriQuery['Itemid']);

    1572. 

  1572.             if (array_key_exists('lang', $uriQuery)) unset($uriQuery['lang']);

    1573. 

  1573.             

    1574. 

  1574.             // Check base link

    1575. 

  1575.             $same = ($uriQuery == $home_items[$Itemid]->linkQuery);

    1576. 

  1576.             if (!$same && is_array($home_items[$Itemid]->normalizedQuery)) {

    1577. 

  1577.                 // Check normalized link

    1578. 

  1578.                 $same = ($uriQuery == $home_items[$Itemid]->normalizedQuery);

    1579. 

  1579.             }

    1580. 

  1580.             

    1581. 

  1581.             return $same;

    1582. 

  1582.         }

    1583. 

  1583.         

    1584. 

  1584.         return false;

    1585. 

  1585.     }

    1586. 

  1586. 

    1587. 

  1587.     function _getMenuTitle($option, $lang, $id = null, $string = null)

    1588. 

  1588.     {

    1589. 

  1589.         return self::_getMenuTitleLang($option, $lang, $id, $string);

    1590. 

  1590.     }

    1591. 

  1591.     

    1592. 

  1592.     function _getMenuTitleLang($option, &$lang, $id = null, $string = null)

    1593. 

  1593.     {

    1594. 

  1594.         $db =& JFactory::getDBO();

    1595. 

  1595.         $sefConfig =& SEFConfig::getConfig();

    1596. 

  1596. 

    1597. 

  1597.         if ($title = JoomSEF::_getCustomMenuTitle($option)) {

    1598. 

  1598.             return $title;

    1599. 

  1599.         }

    1600. 

  1600. 

    1601. 

  1601.         // Which column to use?

    1602. 

  1602.         $column = 'title';

    1603. 

  1603.         if ($sefConfig->useAlias) {

    1604. 

  1604.             $column = 'alias';

    1605. 

  1605.         }

    1606. 

  1606. 

    1607. 

  1607.         // Translate URLs?

    1608. 

  1608.         if ($sefConfig->translateItems) {

    1609. 

  1609.             $jfTranslate = '`id`, ';

    1610. 

  1610.         }

    1611. 

  1611.         else {

    1612. 

  1612.             $jfTranslate = '';

    1613. 

  1613.         }

    1614. 

  1614. 

    1615. 

  1615.         if (isset($string)) {

    1616. 

  1616.             $sql = "SELECT {$jfTranslate}`$column` AS `name`, `language` FROM `#__menu` WHERE `link` = '$string' AND `published` > 0";

    1617. 

  1617.         }

    1618. 

  1618.         elseif (isset($id) && $id != 0) {

    1619. 

  1619.             $sql = "SELECT {$jfTranslate}`$column` AS `name`, `language` FROM `#__menu` WHERE `id` = '$id' AND `published` > 0";

    1620. 

  1620.         }

    1621. 

  1621.         else {

    1622. 

  1622.             // Search for direct link to component only

    1623. 

  1623.             $sql = "SELECT {$jfTranslate}`$column` AS `name`, `language` FROM `#__menu` WHERE `link` = 'index.php?option=$option' AND `published` > 0";

    1624. 

  1624.         }

    1625. 

  1625. 

    1626. 

  1626.         $db->setQuery($sql);

    1627. 

  1627.         $row = $db->loadObject();

    1628. 

  1628. 

    1629. 

  1629.         if ($row && !empty($row->name)) {

    1630. 

  1630.             $title = $row->name;

    1631. 

  1631.             $lang = $row->language;

    1632. 

  1632.         }

    1633. 

  1633.         else {

    1634. 

  1634.             $title = str_replace('com_', '', $option);

    1635. 

  1635. 

    1636. 

  1636.             if (!isset($string) && !isset($id)) {

    1637. 

  1637.                 // Try to extend the search for any link to component

    1638. 

  1638.                 $sql = "SELECT {$jfTranslate}`$column` AS `name`, `language` FROM `#__menu` WHERE `link` LIKE 'index.php?option=$option%' AND `published` > 0";

    1639. 

  1639.                 $db->setQuery($sql);

    1640. 

  1640.                 $row = $db->loadObject();

    1641. 

  1641.                 if (!empty($row)) {

    1642. 

  1642.                     if (!empty($row->name)) $title = $row->name;

    1643. 

  1643.                     $lang = $row->language;

    1644. 

  1644.                 }

    1645. 

  1645.             }

    1646. 

  1646.         }

    1647. 

  1647. 

    1648. 

  1648.         return $title;

    1649. 

  1649.     }

    1650. 

  1650. 

    1651. 

  1651.     function _getMenuItemInfo($option, $task, $id = null, $string = null)

    1652. 

  1652.     {

    1653. 

  1653.         $db =& JFactory::getDBO();

    1654. 

  1654.         $sefConfig =& SEFConfig::getConfig();

    1655. 

  1655. 

    1656. 

  1656.         // JF translate extension.

    1657. 

  1657.         $jfTranslate = $sefConfig->translateNames ? ', `id`' : '';

    1658. 

  1658. 

    1659. 

  1659.         $item->title = JoomSEF::_getCustomMenuTitle($option);

    1660. 

  1660. 

    1661. 

  1661.         // Which column to use?

    1662. 

  1662.         $column = 'title';

    1663. 

  1663.         if ($sefConfig->useAlias) $column = 'alias';

    1664. 

  1664. 

    1665. 

  1665.         // first test Itemid

    1666. 

  1666.         if (isset($id) && $id != 0) {

    1667. 

  1667.             $sql = "SELECT `$column` AS `name`, `params`$jfTranslate FROM `#__menu` WHERE `id` = $id AND `published` > 0";

    1668. 

  1668.         }

    1669. 

  1669.         elseif (isset($string)) {

    1670. 

  1670.             $sql = "SELECT `$column`AS `name`, `params` $jfTranslate FROM `#__menu` WHERE `link` = '$string' AND `published` > 0";

    1671. 

  1671.         }

    1672. 

  1672.         else {

    1673. 

  1673.             // Search for direct link to component only

    1674. 

  1674.             $sql = "SELECT `$column` AS `name`, `params` $jfTranslate FROM `#__menu` WHERE `link` = 'index.php?option=$option' AND `published` > 0";

    1675. 

  1675.         }

    1676. 

  1676. 

    1677. 

  1677.         $db->setQuery($sql);

    1678. 

  1678.         $row = $db->loadObject();

    1679. 

  1679. 

    1680. 

  1680.         if (!empty($row)) {

    1681. 

  1681.             if (!empty($row->name) && !$item->title) $item->title = $row->name;

    1682. 

  1682.             $item->params = new JParameter($row->params);

    1683. 

  1683.         }

    1684. 

  1684.         else {

    1685. 

  1685.             $item->title = str_replace('com_', '', $option);

    1686. 

  1686. 

    1687. 

  1687.             if (!isset($string) && !isset($id)) {

    1688. 

  1688.                 // Try to extend the search for any link to component

    1689. 

  1689.                 $sql = "SELECT `$column`, `params` AS `name`$jfTranslate FROM `#__menu` WHERE `link` LIKE 'index.php?option=$option%' AND `published` > 0";

    1690. 

  1690.                 $db->setQuery($sql);

    1691. 

  1691.                 $row = $db->loadObject();

    1692. 

  1692.                 if (!empty($row)) {

    1693. 

  1693.                     if (!empty($row->name) && !$item->title) $item->title = $row->name;

    1694. 

  1694.                     $item->params = new JParameter($row->params);

    1695. 

  1695.                 }

    1696. 

  1696.             }

    1697. 

  1697.         }

    1698. 

  1698. 

    1699. 

  1699.         return $item;

    1700. 

  1700.     }

    1701. 

  1701. 

    1702. 

  1702.     function _getCustomMenuTitle($option)

    1703. 

  1703.     {

    1704. 

  1704.         $db =& JFactory::getDBO();

    1705. 

  1705.         $sefConfig =& SEFConfig::getConfig();

    1706. 

  1706.         $lang=JFactory::getConfig()->get('language');

    1707. 

  1707.         $element=str_replace('com_','ext_joomsef4_',$option);

    1708. 

  1708. 

    1709. 

  1709.         static $titles;

    1710. 

  1710. 

    1711. 

  1711.         $jfTranslate = $sefConfig->translateNames ? ', `id`' : '';

    1712. 

  1712. 

    1713. 

  1713.         if( !isset($titles) ) {

    1714. 

  1714.             $titles = array();

    1715. 

  1715.         }

    1716. 

  1716. 

    1717. 

  1717.         if( !isset($titles[$lang]) ) {

    1718. 

  1718.             $titles[$lang] = array();

    1719. 

  1719.             

    1720. 

  1720.         	$query=$db->getQuery(true);

    1721. 

  1721.         	$query->select('params, element')->from('#__extensions')->where('state>=0')->where('enabled=1')->where('type='.$db->quote('sef_ext'));

    1722. 

  1722.         	$db->setQuery($query);

    1723. 

  1723.             $data = $db->loadObjectList();

    1724. 

  1724.             

    1725. 

  1725.             foreach ($data as $val) {

    1726. 

  1726.                 $params = new JRegistry($val->params);

    1727. 

  1727.                 $titles[$lang][$val->element] = $params->get('customMenuTitle');

    1728. 

  1728.             }

    1729. 

  1729.         }

    1730. 

  1730.         

    1731. 

  1731.         if (isset($titles[$lang][$element])) {

    1732. 

  1732.         	return $titles[$lang][$element];

    1733. 

  1733.         }

    1734. 

  1734.         

    1735. 

  1735.         return null;

    1736. 

  1736.     }

    1737. 

  1737. 

    1738. 

  1738.     /**

    1739. 

  1739.      * Convert title to URL name.

    1740. 

  1740.      *

    1741. 

  1741.      * @param  string $title

    1742. 

  1742.      * @return string

    1743. 

  1743.      */

    1744. 

  1744.     function _titleToLocation(&$title)

    1745. 

  1745.     {

    1746. 

  1746.         $sefConfig =& SEFConfig::getConfig();

    1747. 

  1747. 

    1748. 

  1748.         // remove accented characters

    1749. 

  1749.         // $title = strtr($title,

    1750. 

  1750.         // replace non-ASCII characters.

    1751. 

  1751.         $title = strtr($title, $sefConfig->getReplacements());

    1752. 

  1752. 

    1753. 

  1753.         // remove quotes, spaces, and other illegal characters

    1754. 

  1754.         if( $sefConfig->allowUTF ) {

    1755. 

  1755.             $title = preg_replace(array('/\'/', '/[\s"\?\:\/\\\\]/', '/(^_|_$)/'), array('', $sefConfig->replacement, ''), $title);

    1756. 

  1756.         }

    1757. 

  1757.         else {

    1758. 

  1758.             $title = preg_replace(array('/\'/', '/[^a-zA-Z0-9\-!.,+]+/', '/(^_|_$)/'), array('', $sefConfig->replacement, ''), $title);

    1759. 

  1759.         }

    1760. 

  1760. 

    1761. 

  1761.         // Handling lower case

    1762. 

  1762.         if( $sefConfig->lowerCase ) {

    1763. 

  1763.             $title = JoomSEF::_toLowerCase($title);

    1764. 

  1764.         }

    1765. 

  1765. 

    1766. 

  1766.         return $title;

    1767. 

  1767.     }

    1768. 

  1768. 

    1769. 

  1769.     /**

    1770. 

  1770.      * Tries to correctly handle conversion to lowercase even for UTF-8 string

    1771. 

  1771.      *

    1772. 

  1772.      * @param unknown_type $str

    1773. 

  1773.      */

    1774. 

  1774.     function _toLowerCase($str)

    1775. 

  1775.     {

    1776. 

  1776.         $sefConfig =& SEFConfig::getConfig();

    1777. 

  1777. 

    1778. 

  1778.         if( $sefConfig->allowUTF ) {

    1779. 

  1779.             if( function_exists('mb_convert_case') ) {

    1780. 

  1780.                 $str = mb_convert_case($str, MB_CASE_LOWER, 'UTF-8');

    1781. 

  1781.             }

    1782. 

  1782.         }

    1783. 

  1783.         else {

    1784. 

  1784.             $str = strtolower($str);

    1785. 

  1785.         }

    1786. 

  1786. 

    1787. 

  1787.         return $str;

    1788. 

  1788.     }

    1789. 

  1789. 

    1790. 

  1790.     function _utf8LowerCase($str)

    1791. 

  1791.     {

    1792. 

  1792.         if( function_exists('mb_convert_case') ) {

    1793. 

  1793.             $str = mb_convert_case($str, MB_CASE_LOWER, 'UTF-8');

    1794. 

  1794.         }

    1795. 

  1795.         else {

    1796. 

  1796.             $str = strtolower($str);

    1797. 

  1797.         }

    1798. 

  1798. 

    1799. 

  1799.         return $str;

    1800. 

  1800.     }

    1801. 

  1801. 

    1802. 

  1802.     /**

    1803. 

  1803.      * Stores the given parameters in an array and returns it

    1804. 

  1804.      *

    1805. 

  1805.      * @param JURI $uri

    1806. 

  1806.      * @param array $title

    1807. 

  1807.      * @param string $task

    1808. 

  1808.      * @param int $limit

    1809. 

  1809.      * @param int $limitstart

    1810. 

  1810.      * @param string $lang

    1811. 

  1811.      * @param array $nonSefVars

    1812. 

  1812.      * @param array $ignoreSefVars

    1813. 

  1813.      * @param array $metadata List of metadata to be stored. (metakeywords, metadesc, ..., canonicallink)

    1814. 

  1814.      * @param boolean $priority

    1815. 

  1815.      * @param boolean $pageHandled Set to true if the extension handles its pagination on its own

    1816. 

  1816.      * @return string

    1817. 

  1817.      */

    1818. 

  1818.     function _sefGetLocation(&$uri, &$title, $task = null, $limit = null, $limitstart = null, $lang = null, $nonSefVars = null, $ignoreSefVars = null, $metadata = null, $priority = null, $pageHandled = false,$host=null, $sitemapParams = null)

    1819. 

  1819.     {

    1820. 

  1820.         $data = compact('uri', 'title', 'task', 'limit', 'limitstart', 'lang', 'nonSefVars', 'ignoreSefVars', 'metadata', 'priority', 'pageHandled', 'host', 'sitemapParams');

    1821. 

  1821.         return $data;

    1822. 

  1822.     }

    1823. 

  1823. 

    1824. 

  1824.     /**

    1825. 

  1825.      * Find existing or create new SEO URL.

    1826. 

  1826.      *

    1827. 

  1827.      * @param array $data

    1828. 

  1828.      * @return string

    1829. 

  1829.      */

    1830. 

  1830.     function _storeLocation(&$data,$check=false)

    1831. 

  1831.     {

    1832. 

  1832.         $mainframe =& JFactory::getApplication();

    1833. 

  1833. 

    1834. 

  1834.         $db =& JFactory::getDBO();

    1835. 

  1835.         $sefConfig =& SEFConfig::getConfig();

    1836. 

  1836.         $cache =& SEFCache::getInstance();

    1837. 

  1837.         

    1838. 

  1838.         // Extract variables

    1839. 

  1839.         $defaults = array('uri' => null, 'title' => null, 'task' => null, 'limit' => null, 'limitstart' => null, 'lang' => null, 'nonSefVars' => null, 'ignoreSefVars' => null, 'metadata' => null, 'priority' => null, 'pageHandled' => false,'host'=>false, 'sitemapParams' => null);

    1840. 

  1840.         foreach ($defaults as $varName => $value) {

    1841. 

  1841.             if (is_array($data) && isset($data[$varName])) {

    1842. 

  1842.                 $$varName = $data[$varName];

    1843. 

  1843.             }

    1844. 

  1844.             else {

    1845. 

  1845.                 $$varName = $value;

    1846. 

  1846.             }

    1847. 

  1847.         }

    1848. 

  1848.         $origUri = clone($uri);

    1849. 

  1849. 

    1850. 

  1850.         // Get the default priority if not set

    1851. 

  1851.         if( is_null($priority) ) {

    1852. 

  1852.             $priority = JoomSEF::_getPriorityDefault($uri);

    1853. 

  1853.         }

    1854. 

  1854. 

    1855. 

  1855.         // Get the parameters for this component

    1856. 

  1856.         if( !is_null($uri->getVar('option')) ) {

    1857. 

  1857.             $params =& SEFTools::getExtParams($uri->getVar('option'));

    1858. 

  1858.         }

    1859. 

  1859. 

    1860. 

  1860.         // remove the menu title if set to for this component

    1861. 

  1861.         if( isset($params) && ($params->get('showMenuTitle', '1') == '0') ) {

    1862. 

  1862.             if ((count($title) > 1) &&

    1863. 

  1863.             ((count($title) != 2) || ($title[1] != '/')) &&

    1864. 

  1864.             ($title[0] == JoomSEF::_getMenuTitle(@$uri->getVar('option'), @$uri->getVar('task'), @$uri->getVar('Itemid')))) {

    1865. 

  1865.                 array_shift($title);

    1866. 

  1866.             }

    1867. 

  1867.         }

    1868. 

  1868. 

    1869. 

  1869.         // add the page number if the extension does not handle it

    1870. 

  1870.         if( !$pageHandled && !is_null($uri->getVar('limitstart')) ) {

    1871. 

  1871.             $limit = $uri->getVar('limit');

    1872. 

  1872.             if( is_null($limit) ) {

    1873. 

  1873.                 if( !is_null($uri->getVar('option')) ) {

    1874. 

  1874.                     $limit = intval($params->get('pageLimit', ''));

    1875. 

  1875.                     if( $limit == 0 ) {

    1876. 

  1876.                         $limit = 5;

    1877. 

  1877.                     }

    1878. 

  1878.                 }

    1879. 

  1879.                 else {

    1880. 

  1880.                     $limit = 5;

    1881. 

  1881.                 }

    1882. 

  1882.             }

    1883. 

  1883.             $pageNum = intval($uri->getVar('limitstart') / $limit) + 1;

    1884. 

  1884.             $pagetext = strval($pageNum);

    1885. 

  1885.             if (($cnfPageText = $sefConfig->getPageText())) {

    1886. 

  1886.                 $pagetext = str_replace('%s', $pageNum, $cnfPageText);

    1887. 

  1887.             }

    1888. 

  1888.             $title[] = $pagetext;

    1889. 

  1889.         }

    1890. 

  1890. 

    1891. 

  1891.         // get all the titles ready for urls.

    1892. 

  1892.         $location = array();

    1893. 

  1893.         foreach ($title as $titlePart) {

    1894. 

  1894.             if (strlen($titlePart) == 0) continue;

    1895. 

  1895.             $location[] = JoomSEF::_titleToLocation($titlePart);

    1896. 

  1896.         }

    1897. 

  1897. 

    1898. 

  1898.         // remove unwanted characters.

    1899. 

  1899.         $finalstrip = explode('|', $sefConfig->stripthese);

    1900. 

  1900.         $takethese = str_replace('|', '', $sefConfig->friendlytrim);

    1901. 

  1901.         if (strstr($takethese, $sefConfig->replacement) === FALSE) {

    1902. 

  1902.             $takethese .= $sefConfig->replacement;

    1903. 

  1903.         }

    1904. 

  1904. 

    1905. 

  1905.         $imptrim = implode('/', $location);

    1906. 

  1906. 

    1907. 

  1907.         if (!is_null($task)) {

    1908. 

  1908.             $task = str_replace($sefConfig->replacement.'-'.$sefConfig->replacement, $sefConfig->replacement, $task);

    1909. 

  1909.             $task = str_replace($finalstrip, '', $task);

    1910. 

  1910.             $task = trim($task,$takethese);

    1911. 

  1911.         }

    1912. 

  1912. 

    1913. 

  1913.         $imptrim = str_replace($sefConfig->replacement.'-'.$sefConfig->replacement, $sefConfig->replacement, $imptrim);

    1914. 

  1914.         $suffixthere = 0;

    1915. 

  1915.         $regexSuffix = str_replace('.', '\.', $sefConfig->suffix);

    1916. 

  1916.         $pregSuffix = addcslashes($regexSuffix, '/');

    1917. 

  1917.         //if (eregi($regexSuffix.'$', $imptrim)) {

    1918. 

  1918.         if (preg_match('/'.$pregSuffix.'$/i', $imptrim)) {

    1919. 

  1919.             $suffixthere = strlen($sefConfig->suffix);

    1920. 

  1920.         }

    1921. 

  1921. 

    1922. 

  1922.         $imptrim = str_replace($finalstrip, $sefConfig->replacement, substr($imptrim, 0, strlen($imptrim) - $suffixthere));

    1923. 

  1923.         $imptrim = str_replace($sefConfig->replacement.$sefConfig->replacement, $sefConfig->replacement, $imptrim);

    1924. 

  1924. 

    1925. 

  1925.         $suffixthere = 0;

    1926. 

  1926.         //if (eregi($regexSuffix.'$', $imptrim)) {

    1927. 

  1927.         if (preg_match('/'.$pregSuffix.'$/i', $imptrim)) {

    1928. 

  1928.             $suffixthere = strlen($sefConfig->suffix);

    1929. 

  1929.         }

    1930. 

  1930. 

    1931. 

  1931.         $imptrim = trim(substr($imptrim, 0, strlen($imptrim) - $suffixthere), $takethese);

    1932. 

  1932. 

    1933. 

  1933.         // add the task if set

    1934. 

  1934.         $imptrim .= (!is_null($task) ? '/'.$task.$sefConfig->suffix : '');

    1935. 

  1935. 

    1936. 

  1936.         // remove all the -/

    1937. 

  1937.         $imptrim = SEFTools::ReplaceAll($sefConfig->replacement.'/', '/', $imptrim);

    1938. 

  1938. 

    1939. 

  1939.         // remove all the /-

    1940. 

  1940.         $imptrim = SEFTools::ReplaceAll('/'.$sefConfig->replacement, '/', $imptrim);

    1941. 

  1941. 

    1942. 

  1942.         // Remove all the //

    1943. 

  1943.         $location = SEFTools::ReplaceAll('//', '/', $imptrim);

    1944. 

  1944. 

    1945. 

  1945.         // check if the location isn't too long for database storage and truncate it in that case

    1946. 

  1946.         $suffixthere = 0;

    1947. 

  1947.         //if (eregi($regexSuffix.'$', $location)) {

    1948. 

  1948.         if (preg_match('/'.$pregSuffix.'$/i', $location)) {

    1949. 

  1949.             $suffixthere = strlen($sefConfig->suffix);

    1950. 

  1950.         }

    1951. 

  1951.         $suffixLen = strlen($sefConfig->suffix);

    1952. 

  1952.         $maxlen = 240 + $suffixthere - $suffixLen;  // Leave some space for language and numbers

    1953. 

  1953.         if (strlen($location) > $maxlen) {

    1954. 

  1954.             // Temporarily remove the suffix

    1955. 

  1955.             //$location = ereg_replace($regexSuffix.'$', '', $location);

    1956. 

  1956.             $location = preg_replace('/'.$pregSuffix.'$/', '', $location);

    1957. 

  1957. 

    1958. 

  1958.             // Explode the location to parts

    1959. 

  1959.             $parts = explode('/', $location);

    1960. 

  1960.             do {

    1961. 

  1961.                 // Find the key of the longest part

    1962. 

  1962.                 $key = 0;

    1963. 

  1963.                 $len = strlen($parts[0]);

    1964. 

  1964.                 for( $i = 1, $n = count($parts); $i < $n; $i++ ) {

    1965. 

  1965.                     $tmpLen = strlen($parts[$i]);

    1966. 

  1966.                     if( $tmpLen > $len ) {

    1967. 

  1967.                         $key = $i;

    1968. 

  1968.                         $len = $tmpLen;

    1969. 

  1969.                     }

    1970. 

  1970.                 }

    1971. 

  1971. 

    1972. 

  1972.                 // Truncate the longest part

    1973. 

  1973.                 $truncBy = strlen($location) - $maxlen;

    1974. 

  1974.                 if( $truncBy > 10 ) {

    1975. 

  1975.                     $truncBy = 10;

    1976. 

  1976.                 }

    1977. 

  1977.                 $parts[$key] = substr($parts[$key], 0, -$truncBy);

    1978. 

  1978. 

    1979. 

  1979.                 // Implode to location again

    1980. 

  1980.                 $location = implode('/', $parts);

    1981. 

  1981. 

    1982. 

  1982.                 // Add suffix if was there

    1983. 

  1983.                 if( $suffixthere > 0 ) {

    1984. 

  1984.                     $location .= $sefConfig->suffix;

    1985. 

  1985.                 }

    1986. 

  1986.             } while(strlen($location) > $maxlen);

    1987. 

  1987.         }

    1988. 

  1988. 

    1989. 

  1989.         // remove variables we don't want to be included in non-SEF URL

    1990. 

  1990.         // and build the non-SEF part of our SEF URL

    1991. 

  1991.         $nonSefUrl = '';

    1992. 

  1992. 

    1993. 

  1993.         // load the nonSEF vars from option parameters

    1994. 

  1994.         $paramNonSef = array();

    1995. 

  1995.         if( isset($params) ) {

    1996. 

  1996.             $nsef = $params->get('customNonSef', '');

    1997. 

  1997. 

    1998. 

  1998.             if( !empty($nsef) ) {

    1999. 

  1999.                 // Some variables are set, let's explode them

    2000. 

  2000.                 $paramNonSef = explode(';', $nsef);

    2001. 

  2001.             }

    2002. 

  2002.         }

    2003. 

  2003. 

    2004. 

  2004.         // get globally configured nonSEF vars

    2005. 

  2005.         $configNonSef = array();

    2006. 

  2006.         if( !empty($sefConfig->customNonSef) ) {

    2007. 

  2007.             $configNonSef = explode(';', $sefConfig->customNonSef);

    2008. 

  2008.         }

    2009. 

  2009. 

    2010. 

  2010. 

    2011. 

  2011.         // combine all the nonSEF vars arrays

    2012. 

  2012.         $nsefvars = array_merge($paramNonSef, $configNonSef);

    2013. 

  2013.         if (!empty($nsefvars)) {

    2014. 

  2014.             foreach($nsefvars as $nsefvar) {

    2015. 

  2015.                 // add each variable, that isn't already set, and that is present in our URL

    2016. 

  2016.                 if( !isset($nonSefVars[$nsefvar]) && !is_null($uri->getVar($nsefvar)) ) {

    2017. 

  2017.                     $nonSefVars[$nsefvar] = $uri->getVar($nsefvar);

    2018. 

  2018.                 }

    2019. 

  2019.             }

    2020. 

  2020.         }

    2021. 

  2021. 

    2022. 

  2022.         // nonSefVars - variables to exclude only if set to in configuration

    2023. 

  2023.         if ($sefConfig->appendNonSef && isset($nonSefVars)) {

    2024. 

  2024.             $vars = array_keys($nonSefVars);

    2025. 

  2025.             $q = SEFTools::RemoveVariables($uri, $vars);

    2026. 

  2026.             if ($q != '') {

    2027. 

  2027.                 if ($nonSefUrl == '') {

    2028. 

  2028.                     $nonSefUrl = '?'.$q;

    2029. 

  2029.                 }

    2030. 

  2030.                 else {

    2031. 

  2031.                     $nonSefUrl .= '&amp;'.$q;

    2032. 

  2032.                 }

    2033. 

  2033.             }

    2034. 

  2034.             // if $nonSefVars mixes with $GLOBALS['JOOMSEF_NONSEFVARS'], exclude the mixed vars

    2035. 

  2035.             // this is important to prevent duplicating params by adding JOOMSEF_NONSEFVARS to

    2036. 

  2036.             // $ignoreSefVars

    2037. 

  2037.             $gNonSef = $mainframe->get('sef.global.nonsefvars');

    2038. 

  2038.             if (!empty($gNonSef)) {

    2039. 

  2039.                 foreach (array_keys($gNonSef) as $key) {

    2040. 

  2040.                     if (in_array($key, array_keys($nonSefVars))) unset($gNonSef[$key]);

    2041. 

  2041.                 }

    2042. 

  2042.                 $mainframe->set('sef.global.nonsefvars', $gNonSef);

    2043. 

  2043.             }

    2044. 

  2044.         }

    2045. 

  2045. 

    2046. 

  2046.         // if there are global variables to exclude, add them to ignoreSefVars array

    2047. 

  2047.         $gNonSef = $mainframe->get('sef.global.nonsefvars');

    2048. 

  2048.         if (!empty($gNonSef)) {

    2049. 

  2049.             if (!empty($ignoreSefVars)) {

    2050. 

  2050.                 $ignoreSefVars = array_merge($gNonSef, $ignoreSefVars);

    2051. 

  2051.             } else {

    2052. 

  2052.                 $ignoreSefVars = $gNonSef;

    2053. 

  2053.             }

    2054. 

  2054.         }

    2055. 

  2055. 

    2056. 

  2056.         // ignoreSefVars - variables to exclude allways

    2057. 

  2057.         if (isset($ignoreSefVars)) {

    2058. 

  2058.             $vars = array_keys($ignoreSefVars);

    2059. 

  2059.             $q = SEFTools::RemoveVariables($uri, $vars);

    2060. 

  2060.             if ($q != '') {

    2061. 

  2061.                 if ($nonSefUrl == '') {

    2062. 

  2062.                     $nonSefUrl = '?'.$q;

    2063. 

  2063.                 }

    2064. 

  2064.                 else {

    2065. 

  2065.                     $nonSefUrl .= '&amp;'.$q;

    2066. 

  2066.                 }

    2067. 

  2067.             }

    2068. 

  2068.         }

    2069. 

  2069. 

    2070. 

  2070.         // If the component requests strict accept variables filtering, remove the ones that don't match

    2071. 

  2071.         if( isset($params) && ($params->get('acceptStrict', '0') == '1') ) {

    2072. 

  2072.             $acceptVars =& SEFTools::getExtAcceptVars($uri->getVar('option'));

    2073. 

  2073.             $uriVars = $uri->getQuery(true);

    2074. 

  2074.             if( (count($acceptVars) > 0) && (count($uriVars) > 0) ) {

    2075. 

  2075.                 foreach($uriVars as $name => $value) {

    2076. 

  2076.                     // Standard Joomla variables

    2077. 

  2077.                     if (in_array($name, $sefConfig->globalAcceptVars)) {

    2078. 

  2078.                         continue;

    2079. 

  2079.                     }

    2080. 

  2080.                     // Accepted variables

    2081. 

  2081.                     if( in_array($name, $acceptVars) ) {

    2082. 

  2082.                         continue;

    2083. 

  2083.                     }

    2084. 

  2084. 

    2085. 

  2085.                     // Variable not accepted, add it to non-SEF part of the URL

    2086. 

  2086.                     $value = urlencode($value);

    2087. 

  2087.                     if (strlen($nonSefUrl) > 0) {

    2088. 

  2088.                         $nonSefUrl .= '&amp;'.$name.'='.$value;

    2089. 

  2089.                     } else {

    2090. 

  2090.                         $nonSefUrl = '?'.$name.'='.$value;

    2091. 

  2091.                     }

    2092. 

  2092.                     $uri->delVar($name);

    2093. 

  2093.                 }

    2094. 

  2094.             }

    2095. 

  2095.         }

    2096. 

  2096. 

    2097. 

  2097.         // always remove Itemid and store it in a separate column

    2098. 

  2098.         if (!is_null($uri->getVar('Itemid'))) {

    2099. 

  2099.             $Itemid = $uri->getVar('Itemid');

    2100. 

  2100.             $uri->delVar('Itemid');

    2101. 

  2101.         }

    2102. 

  2102. 

    2103. 

  2103.         // check for non-sef url first and avoid repeative lookups

    2104. 

  2104.         // we only want to look for title variations when adding new

    2105. 

  2105.         // this should also help eliminate duplicates.

    2106. 

  2106. 

    2107. 

  2107.         // David (284): ignore Itemid if set to

    2108. 

  2108.         if( isset($params) ) {

    2109. 

  2109.             $extIgnore = $params->get('ignoreSource', 2);

    2110. 

  2110.         } else {

    2111. 

  2111.             $extIgnore = 2;

    2112. 

  2112.         }

    2113. 

  2113.         $ignoreSource = ($extIgnore == 2 ? $sefConfig->ignoreSource : $extIgnore);

    2114. 

  2114. 

    2115. 

  2115.         // If Itemid is set as ignored for the component, set ignoreSource to 1

    2116. 

  2116.         $itemidIgnored = false;

    2117. 

  2117.         if (isset($Itemid) && !is_null($uri->getVar('option'))) {

    2118. 

  2118.             $itemidIgnored = SEFTools::isItemidIgnored($uri->getVar('option'), $Itemid);

    2119. 

  2119.             if ($itemidIgnored) {

    2120. 

  2120.                 $ignoreSource = 1;

    2121. 

  2121.             }

    2122. 

  2122.         }

    2123. 

  2123. 

    2124. 

  2124.         $where = '';

    2125. 

  2125.         if (!$ignoreSource && isset($Itemid)) {

    2126. 

  2126.             $where .= " AND (`Itemid` = '".$Itemid."' OR `Itemid` IS NULL)";

    2127. 

  2127.         }

    2128. 

  2128.         $url = JoomSEF::_uriToUrl($uri);

    2129. 

  2129. 

    2130. 

  2130.         // if cache is activated, search in cache first

    2131. 

  2131.         if ($sefConfig->useCache) {

    2132. 

  2132.         	if(!$check) {        		

    2133. 

  2133.             	$realloc = $cache->GetSefUrl($url, @$Itemid);

    2134. 

  2134.         	}

    2135. 

  2135.         }

    2136. 

  2136.         // search if URL exists, if we do not use cache or URL was not cached

    2137. 

  2137.         if (!$sefConfig->useCache || !$realloc) {

    2138. 

  2138.             $query = "SELECT * FROM `#__sefurls` WHERE `origurl` = '" . addslashes(html_entity_decode(urldecode($url))) . "'" . $where . ' LIMIT 2';

    2139. 

  2139.             $db->setQuery($query);

    2140. 

  2140.             $sefurls = $db->loadObjectList('Itemid');

    2141. 

  2141. 

    2142. 

  2142.             if (!$ignoreSource && isset($Itemid)) {

    2143. 

  2143.                 if (isset($sefurls[$Itemid])) {

    2144. 

  2144.                     $realloc = $sefurls[$Itemid];

    2145. 

  2145.                 }

    2146. 

  2146.                 else if (isset($sefurls[''])) {

    2147. 

  2147.                 	

    2148. 

  2148.                     // We've found one of the ignored Itemids, update it with the current and return

    2149. 

  2149.                     $realloc = $sefurls[''];

    2150. 

  2150.                     $realloc->Itemid = $Itemid;

    2151. 

  2151.                     $query = "UPDATE `#__sefurls` SET `Itemid` = '{$Itemid}' WHERE `id` = '{$realloc->id}' LIMIT 1";

    2152. 

  2152.                     $db->setQuery($query);

    2153. 

  2153.                     $db->query();

    2154. 

  2154.                 }

    2155. 

  2155.                 else {

    2156. 

  2156.                     $realloc = reset($sefurls);

    2157. 

  2157.                 }

    2158. 

  2158.             }

    2159. 

  2159.             else {

    2160. 

  2160.                 $realloc = reset($sefurls);

    2161. 

  2161.             }

    2162. 

  2162.             /*

    2163. 

  2163.             // removed - causing problems, ignore multiple sources not working correctly

    2164. 

  2164.             // test if current Itemid record exists, if YES, use it, if NO, use first found

    2165. 

  2165.             $curId = isset($Itemid) ? $Itemid : '';

    2166. 

  2166.             $active = isset($sefurls[$curId]) ? $sefurls[$curId] : reset($sefurls);

    2167. 

  2167.             $realloc = $active;

    2168. 

  2168.             */

    2169. 

  2169.         }

    2170. 

  2170.         // if not found, try to find the url without lang variable     

    2171. 

  2171.         if (!$realloc && ($sefConfig->langPlacement == _COM_SEF_LANG_DOMAIN)) {

    2172. 

  2172.             $url = JoomSEF::_uriToUrl($uri, 'lang');

    2173. 

  2173. 

    2174. 

  2174.             if ($sefConfig->useCache) {

    2175. 

  2175.                 $realloc = $cache->GetSefUrl($url, @$Itemid);

    2176. 

  2176.             }

    2177. 

  2177.             if (!$sefConfig->useCache || !$realloc) {

    2178. 

  2178.                 $query = "SELECT * FROM `#__sefurls` WHERE `origurl` = '".addslashes(html_entity_decode(urldecode($url)))."'" . $where . ' LIMIT 2';

    2179. 

  2179.                 $db->setQuery($query);

    2180. 

  2180.                 $sefurls = $db->loadObjectList('Itemid');

    2181. 

  2181. 

    2182. 

  2182.                 if (!$ignoreSource && isset($Itemid)) {

    2183. 

  2183.                     if (isset($sefurls[$Itemid])) {

    2184. 

  2184.                         $realloc = $sefurls[$Itemid];

    2185. 

  2185.                     }

    2186. 

  2186.                     else if (isset($sefurls[''])) {

    2187. 

  2187.                         // We've found one of the ignored Itemids, update it with the current and return

    2188. 

  2188.                         $realloc = $sefurls[''];

    2189. 

  2189.                         $realloc->Itemid = $Itemid;

    2190. 

  2190.                         $query = "UPDATE `#__sefurls` SET `Itemid` = '{$Itemid}' WHERE `id` = '{$realloc->id}' LIMIT 1";

    2191. 

  2191.                         $db->setQuery($query);

    2192. 

  2192.                         $db->query();

    2193. 

  2193.                     }

    2194. 

  2194.                     else {

    2195. 

  2195.                         $realloc = reset($sefurls);

    2196. 

  2196.                     }

    2197. 

  2197.                 }

    2198. 

  2198.                 else {

    2199. 

  2199.                     $realloc = reset($sefurls);

    2200. 

  2200.                 }

    2201. 

  2201.                 /*

    2202. 

  2202.                 // removed - causing problems, ignore multiple sources not working correctly

    2203. 

  2203.            		// test if current Itemid record exists, if YES, use it, if NO, use first found

    2204. 

  2204.            		$curId = isset($Itemid) ? $Itemid : '';

    2205. 

  2205.             	$active = isset($sefurls[$curId]) ? $sefurls[$curId] : reset($sefurls);

    2206. 

  2206.             	$realloc = $active;

    2207. 

  2207.             	*/

    2208. 

  2208.             }

    2209. 

  2209.         }

    2210. 

  2210. 

    2211. 

  2211.         // found a match, so we are done

    2212. 

  2212.         if (is_object($realloc) && !$check) {

    2213. 

  2213.             // return the original URL if SEF is disabled

    2214. 

  2214.             if (!$realloc->sef) {

    2215. 

  2215.                 return $origUri;

    2216. 

  2216.             }

    2217. 

  2217. 

    2218. 

  2218.             // return found URL with non-SEF part appended

    2219. 

  2219.             if (($nonSefUrl != '') && (strstr($realloc->sefurl, '?'))) {

    2220. 

  2220.                 $nonSefUrl = str_replace('?', '&amp;', $nonSefUrl);

    2221. 

  2221.             }

    2222. 

  2222. 

    2223. 

  2223.             if(!strlen($host)) {

    2224. 

  2224. 				$root=JFactory::getURI()->getHost();

    2225. 

  2225. 			} else {

    2226. 

  2226. 				$root=$host;

    2227. 

  2227. 			}

    2228. 

  2228. 			$url=JFactory::getURI()->getScheme()."://".$root;

    2229. 

  2229. 

    2230. 

  2230.             if (substr($url, -1) != '/') $url .= '/';

    2231. 

  2231.             $url .= $realloc->sefurl.$nonSefUrl;

    2232. 

  2232.             $fragment = $uri->getFragment();

    2233. 

  2233.             if (!empty($fragment)) $url .= '#'.$fragment;

    2234. 

  2234. 

    2235. 

  2235.             return new JURI($url);

    2236. 

  2236.         }

    2237. 

  2237.         // URL not found, so lets create it

    2238. 

  2238.         else if(!is_object($realloc)||$check) {

    2239. 

  2239.             // return the original URL if we don't want to save new URLs

    2240. 

  2240.             if ($sefConfig->disableNewSEF) return $origUri;

    2241. 

  2241. 

    2242. 

  2242.             $realloc = null;

    2243. 

  2243. 

    2244. 

  2244.             $suffixMust = false;

    2245. 

  2245.             if (!isset($suffix)) {

    2246. 

  2246.                 $suffix = $sefConfig->suffix;

    2247. 

  2247.             }

    2248. 

  2248. 

    2249. 

  2249.             $addFile = $sefConfig->addFile;

    2250. 

  2250.             if (($pos = strrpos($addFile, '.')) !== false) {

    2251. 

  2251.                 $addFile = substr($addFile, 0, $pos);

    2252. 

  2252.             }

    2253. 

  2253. 

    2254. 

  2254.             // in case the created SEF URL is already in database for different non-SEF URL,

    2255. 

  2255.             // we need to distinguish them by using numbers, so let's find the first unused URL

    2256. 

  2256. 

    2257. 

  2257.             $leftPart = '';   // string to be searched before page number

    2258. 

  2258.             $rightPart = '';  // string to be searched after page number

    2259. 

  2259.             if (substr($location, -1) == '/' || strlen($location) == 0) {

    2260. 

  2260.                 if (($pagetext = $sefConfig->getPageText())) {

    2261. 

  2261.                     // use global limit if NULL and set in globals

    2262. 

  2262.                     if (is_null($limit) && isset($_REQUEST['limit']) && $_REQUEST['limit'] > 0) $limit = $_REQUEST['limit'];

    2263. 

  2263.                     // if we are using pagination, try to calculate page number

    2264. 

  2264.                     if (!is_null($limitstart) && $limitstart > 0) {

    2265. 

  2265.                         // make sure limit is not 0

    2266. 

  2266.                         if ($limit == 0) {

    2267. 

  2267.                             $config =& JFactory::getConfig();

    2268. 

  2268.                             $listLimit = $config->getValue('list_limit');

    2269. 

  2269.                             $limit = ($listLimit > 0) ? $listLimit : 20;

    2270. 

  2270.                         }

    2271. 

  2271.                         $pagenum = $limitstart / $limit;

    2272. 

  2272.                         $pagenum++;

    2273. 

  2273.                     }

    2274. 

  2274.                     else $pagenum = 1;

    2275. 

  2275. 

    2276. 

  2276.                     if (strpos($pagetext, '%s') !== false) {

    2277. 

  2277.                         $page = str_replace('%s', $pagenum == 1 ? $addFile : $pagenum, $pagetext) . $suffix;

    2278. 

  2278. 

    2279. 

  2279.                         $pages = explode('%s', $pagetext);

    2280. 

  2280.                         $leftPart = $location . $pages[0];

    2281. 

  2281.                         $rightPart = $pages[1] . $suffix;

    2282. 

  2282.                     }

    2283. 

  2283.                     else {

    2284. 

  2284.                         $page = $pagetext.($pagenum == 1 ? $addFile : $sefConfig->pagerep . $pagenum) . $suffix;

    2285. 

  2285. 

    2286. 

  2286.                         $leftPart = $location . $pagetext . $sefConfig->pagerep;

    2287. 

  2287.                         $rightPart = $suffix;

    2288. 

  2288.                     }

    2289. 

  2289. 

    2290. 

  2290.                     $temploc = $location . ($pagenum == 1 && !$suffixMust ? '' : $page);

    2291. 

  2291.                 }

    2292. 

  2292.                 else {

    2293. 

  2293.                     $temploc = $location . ($suffixMust ? $sefConfig->pagerep.$suffix : '');

    2294. 

  2294. 

    2295. 

  2295.                     $leftPart = $location . $sefConfig->pagerep;

    2296. 

  2296.                     $rightPart = $suffix;

    2297. 

  2297.                 }

    2298. 

  2298.             }

    2299. 

  2299.             elseif ($suffix) {

    2300. 

  2300.                 if ($sefConfig->suffix != '/') {

    2301. 

  2301.                     //if (eregi($regexSuffix, $location)) {

    2302. 

  2302.                     if (preg_match('/'.$pregSuffix.'/i', $location)) {

    2303. 

  2303.                         $temploc = preg_replace('/' . $pregSuffix . '/', '', $location) . $suffix;

    2304. 

  2304. 

    2305. 

  2305.                         $leftPart = preg_replace('/' . $pregSuffix . '/', '', $location) . $sefConfig->pagerep;

    2306. 

  2306.                         $rightPart = $suffix;

    2307. 

  2307.                     }

    2308. 

  2308.                     else {

    2309. 

  2309.                         $temploc = $location . $suffix;

    2310. 

  2310. 

    2311. 

  2311.                         $leftPart = $location . $sefConfig->pagerep;

    2312. 

  2312.                         $rightPart = $suffix;

    2313. 

  2313.                     }

    2314. 

  2314.                 }

    2315. 

  2315.                 else {

    2316. 

  2316.                     $temploc = $location . $suffix;

    2317. 

  2317. 

    2318. 

  2318.                     $leftPart = $location . $sefConfig->pagerep;

    2319. 

  2319.                     $rightPart = $suffix;

    2320. 

  2320.                 }

    2321. 

  2321.             }

    2322. 

  2322.             else {

    2323. 

  2323.                 $temploc = $location . ($suffixMust ? $sefConfig->pagerep . $suffix : '');

    2324. 

  2324. 

    2325. 

  2325.                 $leftPart = $location . $sefConfig->pagerep;

    2326. 

  2326.                 $rightPart = $suffix;

    2327. 

  2327.             }

    2328. 

  2328. 

    2329. 

  2329.             // add language to path

    2330. 

  2330.             if($sefConfig->langEnable && isset($lang) && $sefConfig->langPlacementJoomla==_COM_SEF_LANG_PATH) {

    2331. 

  2331.             	if($sefConfig->mainLanguageJoomla==0 || ($lang!=$sefCnfig->mainLanguageJoomla)) {

    2332. 

  2332.             		$slash = ($temploc != '' && $temploc[0] == '/');

    2333. 

  2333. 	            	$temploc = $lang . ($slash || strlen($temploc) > 0  ? '/' : '') . $temploc;

    2334. 

  2334. 	            	$leftPart = $lang . '/' . $leftPart;

    2335. 

  2335.             	}

    2336. 

  2336.             }

    2337. 

  2337. 

    2338. 

  2338.             if ($sefConfig->addFile) {

    2339. 

  2339.                 //if (!eregi($regexSuffix . '$', $temploc) && substr($temploc, -1) == '/') {

    2340. 

  2340.                 if (!preg_match('/'.$pregSuffix . '$/i', $temploc) && substr($temploc, -1) == '/') {

    2341. 

  2341.                     $temploc .= $sefConfig->addFile;

    2342. 

  2342.                 }

    2343. 

  2343.             }

    2344. 

  2344. 

    2345. 

  2345.             // convert to lowercase if set to

    2346. 

  2346.             if ($sefConfig->lowerCase) {

    2347. 

  2347.                 $temploc = JoomSEF::_toLowerCase($temploc);

    2348. 

  2348.                 $leftPart = JoomSEF::_toLowerCase($leftPart);

    2349. 

  2349.                 $rightPart = JoomSEF::_toLowerCase($rightPart);

    2350. 

  2350.             }

    2351. 

  2351. 

    2352. 

  2352.             $url = JoomSEF::_uriToUrl($uri);

    2353. 

  2353.             

    2354. 

  2354. 

    2355. 

  2355.             // see if we have a result for this location

    2356. 

  2356.             $sql = "SELECT `id`, `origurl`, `Itemid`, `sefurl` FROM `#__sefurls` WHERE `sefurl` = '$temploc' AND `origurl` != ''";

    2357. 

  2357.             $db->setQuery($sql);

    2358. 

  2358.             $row = $db->loadObject();

    2359. 

  2359. 

    2360. 

  2360.             if ($itemidIgnored) {

    2361. 

  2361.                 $Itemid = null;

    2362. 

  2362.             }

    2363. 

  2363.             $realloc = JoomSEF::_checkRow($row, $ignoreSource, @$Itemid, $url, $metadata, $temploc, $priority, $uri->getVar('option'),$check,$host, $sitemapParams);

    2364. 

  2364. 

    2365. 

  2365.             // the correct URL could not be used, we must find the first free number

    2366. 

  2366.             if( is_null($realloc) ) {

    2367. 

  2367.                 // let's get all the numbered pages

    2368. 

  2368.                 $sql = "SELECT `id`, `origurl`, `Itemid`, `sefurl` FROM `#__sefurls` WHERE `sefurl` LIKE '{$leftPart}%{$rightPart}'";

    2369. 

  2369.                 $db->setQuery($sql);

    2370. 

  2370.                 $pages = $db->loadObjectList();

    2371. 

  2371. 

    2372. 

  2372.                 // create associative array of form number => URL info

    2373. 

  2373.                 $urls = array();

    2374. 

  2374.                 if (!empty($pages)) {

    2375. 

  2375.                     $leftLen = strlen($leftPart);

    2376. 

  2376.                     $rightLen = strlen($rightPart);

    2377. 

  2377. 

    2378. 

  2378.                     foreach ($pages as $page) {

    2379. 

  2379.                         $sefurl = $page->sefurl;

    2380. 

  2380. 

    2381. 

  2381.                         // separate URL number

    2382. 

  2382.                         $urlnum = substr($sefurl, $leftLen, strlen($sefurl) - $leftLen - $rightLen);

    2383. 

  2383. 

    2384. 

  2384.                         // use only if it's really numeric

    2385. 

  2385.                         if (is_numeric($urlnum)) {

    2386. 

  2386.                             $urls[intval($urlnum)] = $page;

    2387. 

  2387.                         }

    2388. 

  2388.                     }

    2389. 

  2389.                 }

    2390. 

  2390. 

    2391. 

  2391.                 $i = 2;

    2392. 

  2392.                 do {

    2393. 

  2393.                     $temploc = $leftPart . $i . $rightPart;

    2394. 

  2394.                     $row = null;

    2395. 

  2395.                     if (isset($urls[$i])) {

    2396. 

  2396.                         $row = $urls[$i];

    2397. 

  2397.                     }

    2398. 

  2398. 

    2399. 

  2399.                     $realloc = JoomSEF::_checkRow($row, $ignoreSource, @$Itemid, $url, $metadata, $temploc, $priority, $uri->getVar('option'),false,$host,$sitemapParams);

    2400. 

  2400. 

    2401. 

  2401.                     $i++;

    2402. 

  2402.                 } while( is_null($realloc) );

    2403. 

  2403.             }

    2404. 

  2404.         }

    2405. 

  2405. 

    2406. 

  2406.         // return found URL with non-SEF part appended

    2407. 

  2407.         if (($nonSefUrl != '') && (strstr($realloc, '?'))) {

    2408. 

  2408.             $nonSefUrl = str_replace('?', '&amp;', $nonSefUrl);

    2409. 

  2409.         }

    2410. 

  2410. 

    2411. 

  2411. 		if (!strlen($host)) {

    2412. 

  2412. 			$root = JFactory::getUri()->toString(array('host', 'port'));

    2413. 

  2413. 		} else {

    2414. 

  2414. 			$root = $host;

    2415. 

  2415. 		}

    2416. 

  2416. 		$url = JFactory::getURI()->getScheme()."://".$root.JURI::root(true);

    2417. 

  2417.         

    2418. 

  2418.         if (substr($url, -1) != '/') $url .= '/';

    2419. 

  2419.         $url .= $realloc.$nonSefUrl;

    2420. 

  2420.         $fragment = $uri->getFragment();

    2421. 

  2421.         if (!empty($fragment)) {

    2422. 

  2422.             $url .= '#'.$fragment;

    2423. 

  2423.         }

    2424. 

  2424. 		

    2425. 

  2425.         return new JURI($url);

    2426. 

  2426.     }

    2427. 

  2427. 

    2428. 

  2428.     function enabled(&$plugin)

    2429. 

  2429.     {

    2430. 

  2430.         $mainframe =& JFactory::getApplication();

    2431. 

  2431. 

    2432. 

  2432.         $cosi = 'file';

    2433. 

  2433.         $cosi = implode($cosi(JPATH_ROOT.DS.'administrator'.DS.'components'.DS.'com_sef'.DS.'sef.xml'));

    2434. 

  2434.         $cosi = md5($cosi);

    2435. 

  2435. 

    2436. 

  2436.         if ($mainframe->get('sef.global.meta', '') == $cosi) return true;

    2437. 

  2437.         else $plugin = $plugin;

    2438. 

  2438. 

    2439. 

  2439.         $doc =& JFactory::getDocument();

    2440. 

  2440.         $cacheBuf =& $doc->getBuffer('component');

    2441. 

  2441. 

    2442. 

  2442.         $cacheBuf2 = 

    2443. 

  2443.         '<div><a href="http://www.artio'.

    2444. 

  2444.         '.net" style="font-size: 8px; v'.

    2445. 

  2445.         'isibility: visible; display: i'.

    2446. 

  2446.         'nline;" title="Web development'.

    2447. 

  2447.         ', Joomla, CMS, CRM, Online sho'.

    2448. 

  2448.         'p software, databases">Joomla '.

    2449. 

  2449.         'SEF URLs by Artio</a></div>';

    2450. 

  2450. 

    2451. 

  2451.         if (JRequest::getCmd('format') != 'raw')

    2452. 

  2452.         $doc->setBuffer($cacheBuf . $cacheBuf2, 'component');

    2453. 

  2453. 

    2454. 

  2454.         return true;

    2455. 

  2455.     }

    2456. 

  2456. 

    2457. 

  2457.     /**

    2458. 

  2458.      * Checks the found row

    2459. 

  2459.      *

    2460. 

  2460.      */

    2461. 

  2461.     function _checkRow(&$row, $ignoreSource, $Itemid, $url, &$metadata, $temploc, $priority, $option,$check=false,$host, $sitemapParams = null)

    2462. 

  2462.     {

    2463. 

  2463.         $realloc = null;

    2464. 

  2464. 

    2465. 

  2465.         $db =& JFactory::getDBO();

    2466. 

  2466.         $sefConfig =& SEFConfig::getConfig();

    2467. 

  2467. 

    2468. 

  2468.         $numberDuplicates = $sefConfig->numberDuplicates;

    2469. 

  2469. 

    2470. 

  2470.         if( !empty($option) ) {

    2471. 

  2471.             $params =& SEFTools::getExtParams($option);

    2472. 

  2472.             $extDuplicates = $params->get('numberDuplicates', '2');

    2473. 

  2473.             if( $extDuplicates != '2' ) {

    2474. 

  2474.                 $numberDuplicates = $extDuplicates;

    2475. 

  2475.             }

    2476. 

  2476.         }

    2477. 

  2477. 

    2478. 

  2478.         if( ($row != false) && !is_null($row) ) {

    2479. 

  2479.             if ($ignoreSource || (!$ignoreSource && (empty($Itemid) || $row->Itemid == $Itemid))) {

    2480. 

  2480.                 // ... check that it matches original URL

    2481. 

  2481.                 if ($row->origurl == $url) {

    2482. 

  2482.                     // found the matching object

    2483. 

  2483.                     // it probably should have been found sooner

    2484. 

  2484.                     // but is checked again here just for CYA purposes

    2485. 

  2485.                     // and to end the loop

    2486. 

  2486.                     $realloc = $row->sefurl;

    2487. 

  2487.                 }

    2488. 

  2488.                 else if ($sefConfig->langPlacement == _COM_SEF_LANG_DOMAIN) {

    2489. 

  2489.                     // check if the urls differ only by lang variable

    2490. 

  2490.                     if (SEFTools::removeVariable($row->origurl, 'lang') == SEFTools::removeVariable($url, 'lang')) {

    2491. 

  2491.                         $db->setQuery("UPDATE `#__sefurls` SET `origurl` = '".SEFTools::removeVariable($row->origurl, 'lang')."' WHERE `id` = '".$row->id."' LIMIT 1");

    2492. 

  2492. 

    2493. 

  2493.                         // if error occured.

    2494. 

  2494.                         if (!$db->query()) {

    2495. 

  2495.                             JError::raiseError('JoomSEF Error', JText::_('COM_SEF_ERROR_SEF_URL_UPDATE') . $db->getErrorMsg());

    2496. 

  2496.                         }

    2497. 

  2497. 

    2498. 

  2498.                         $realloc = $row->sefurl;

    2499. 

  2499.                     }

    2500. 

  2500.                 }

    2501. 

  2501.             }

    2502. 

  2502. 

    2503. 

  2503.             // The found URL is not the same

    2504. 

  2504.             if( !$numberDuplicates ) {

    2505. 

  2505.                 // But duplicates management is turned on

    2506. 

  2506.                 // so we can save the same SEF URL for different non-SEF URL

    2507. 

  2507.                 if(!$check) {

    2508. 

  2508.                 	JoomSEF::_saveNewURL($Itemid, $metadata, $priority, $temploc, $url,$host, $sitemapParams);

    2509. 

  2509.                 }

    2510. 

  2510.                 $realloc = $temploc;

    2511. 

  2511.             }

    2512. 

  2512.         }

    2513. 

  2513.         // URL not found

    2514. 

  2514.         else {

    2515. 

  2515.             // first, try to search among 404s

    2516. 

  2516.             $query = "SELECT `id` FROM `#__sefurls` WHERE `sefurl` = '$temploc' AND `origurl` = ''";

    2517. 

  2517.             $db->setQuery($query);

    2518. 

  2518.             $id = $db->loadResult();

    2519. 

  2519. 

    2520. 

  2520.             // if 404 exists, rewrite it to the new URL

    2521. 

  2521.             if (!is_null($id)) {

    2522. 

  2522.                 $sqlId = (!empty($Itemid) ? ", `Itemid` = '$Itemid'" : '');

    2523. 

  2523.                 $query = "UPDATE `#__sefurls` SET `origurl` = '" . mysql_escape_string(html_entity_decode(urldecode($url)))."'$sqlId, `priority` = '$priority' WHERE `id` = '$id' LIMIT 1";

    2524. 

  2524.                 $db->setQuery($query);

    2525. 

  2525. 

    2526. 

  2526.                 // if error occured

    2527. 

  2527.                 if (!$db->query()) {

    2528. 

  2528.                     JError::raiseError('JoomSEF Error', JText::_('COM_SEF_ERROR_SEF_URL_UPDATE') . $db->getErrorMsg());

    2529. 

  2529.                 }

    2530. 

  2530.             }

    2531. 

  2531.             // else save URL in the database as new record

    2532. 

  2532.             else {

    2533. 

  2533.             	if(!$check) {

    2534. 

  2534.                 	JoomSEF::_saveNewURL($Itemid, $metadata, $priority, $temploc, $url,$host, $sitemapParams);

    2535. 

  2535.             	}

    2536. 

  2536.             }

    2537. 

  2537.             $realloc = $temploc;

    2538. 

  2538.         }

    2539. 

  2539. 

    2540. 

  2540.         return $realloc;

    2541. 

  2541.     }

    2542. 

  2542. 

    2543. 

  2543.     /**

    2544. 

  2544.      * Inserts new SEF URL to database

    2545. 

  2545.      *

    2546. 

  2546.      */

    2547. 

  2547.     function _saveNewURL($Itemid, &$metadata, $priority, $temploc, $url,$host, $sitemapParams)

    2548. 

  2548.     {

    2549. 

  2549.         $db =& JFactory::getDBO();

    2550. 

  2550. 

    2551. 

  2551.         $col = $val = '';

    2552. 

  2552.         if( !empty($Itemid) ) {

    2553. 

  2553.             $col = ', `Itemid`';

    2554. 

  2554.             $val = ", '$Itemid'";

    2555. 

  2555.         }

    2556. 

  2556. 

    2557. 

  2557.         $metakeys = $metavals = '';

    2558. 

  2558.         if (is_array($metadata) && count($metadata) > 0) {

    2559. 

  2559.             foreach($metadata as $metakey => $metaval) {

    2560. 

  2560.                 $metakeys .= ", `$metakey`";

    2561. 

  2561.                 $metavals .= ", '".str_replace(array("\\", "'", ';'), array("\\\\", "\\'", "\\;"), $metaval)."'";

    2562. 

  2562.             }

    2563. 

  2563.         }

    2564. 

  2564. 

    2565. 

  2565.         // get trace information if set to

    2566. 

  2566.         $sefConfig =& SEFConfig::getConfig();

    2567. 

  2567.         if (@$sefConfig->trace) {

    2568. 

  2568.         	$traceinfo = "'" . mysql_escape_string(JoomSEF::_getDebugInfo($sefConfig->traceLevel)) . "'";

    2569. 

  2569.         }

    2570. 

  2570.         else $traceinfo = "NULL";

    2571. 

  2571. 

    2572. 

  2572.         // Sitemap default values

    2573. 

  2573.         $sm_indexed = (isset($sitemapParams['indexed']) ? $sitemapParams['indexed'] : ($sefConfig->sitemap_indexed ? 1 : 0));

    2574. 

  2574.         $sm_date = date('Y-m-d');

    2575. 

  2575.         $sm_frequency = (isset($sitemapParams['frequency']) ? $sitemapParams['frequency'] : $sefConfig->sitemap_frequency);

    2576. 

  2576.         $sm_priority = (isset($sitemapParams['priority']) ? $sitemapParams['priority'] : $sefConfig->sitemap_priority);

    2577. 

  2577.         

    2578. 

  2578.         $autolock=(int)$sefConfig->autolock_urls;

    2579. 

  2579. 

    2580. 

  2580.         $query = 'INSERT INTO `#__sefurls` (`sefurl`, `origurl`, `priority`' . $col . $metakeys . ', `trace`, `sm_indexed`, `sm_date`, `sm_frequency`, `sm_priority`,`locked`,`host`) ' .

    2581. 

  2581.         "VALUES ('".$temploc."', '" . mysql_escape_string(html_entity_decode(urldecode($url)))."', '$priority'" . $val . $metavals . ", " . $traceinfo . ", '{$sm_indexed}', '{$sm_date}', '{$sm_frequency}', '{$sm_priority}',".$autolock.",'".$host."')";

    2582. 

  2582.         $db->setQuery($query);

    2583. 

  2583. 

    2584. 

  2584.         // if error occured

    2585. 

  2585.         if (!$db->query()) {

    2586. 

  2586.             JError::raiseError('JoomSEF Error', JText::_('COM_SEF_ERROR_SEF_URL_STORE') . $db->getErrorMsg());

    2587. 

  2587.         }

    2588. 

  2588.     }

    2589. 

  2589.     

    2590. 

  2590.     function _checkURLs($option,$item) {

    2591. 

  2591.     	$db=JFactory::getDBO();

    2592. 

  2592.     	$sefConfig =& SEFConfig::getConfig();

    2593. 

  2593.     	$cache=SEFCache::getInstance();

    2594. 

  2594.         

    2595. 

  2595.     	if ($sefConfig->update_urls == false) {

    2596. 

  2596.     		return;

    2597. 

  2597.     	}

    2598. 

  2598.     	

    2599. 

  2599.         $file = JPATH_ROOT.DS.'components'.DS.'com_sef'.DS.'sef_ext'.DS.$option.'.php';

    2600. 

  2600.         if (!file_exists($file)) {

    2601. 

  2601.             return;

    2602. 

  2602.         }

    2603. 

  2603.         

    2604. 

  2604.     	require_once ($file);

    2605. 

  2605.     	$class = 'SefExt_'.$option;

    2606. 

  2606.         if (!class_exists($class)) {

    2607. 

  2607.             return;

    2608. 

  2608.         }

    2609. 

  2609.     	$sef_ext = new $class();

    2610. 

  2610.     	

    2611. 

  2611.     	if (!method_exists($sef_ext, 'getURLPatterns')) {

    2612. 

  2612.             return;

    2613. 

  2613.     	}

    2614. 

  2614.         

    2615. 

  2615.         $urls = $sef_ext->getURLPatterns($item);

    2616. 

  2616.         

    2617. 

  2617.     	/*echo "<pre>";

    2618. 

  2618.     	print_r($item->language);

    2619. 

  2619.     	echo "</pre>";*/

    2620. 

  2620.     	

    2621. 

  2621.     	/*$langs=array();

    2622. 

  2622.     	if($sefConfig->langEnable) {

    2623. 

  2623. 	    	if($sefConfig->langPlacementJoomla==_COM_SEF_LANG_PATH) {

    2624. 

  2624. 	    		$sefs=JLanguageHelper::getLanguages('sef');

    2625. 

  2625. 	    		$codes=JLanguageHelper::getLanguages('lang_code');

    2626. 

  2626. 	    		$langs=array_keys($sefs);

    2627. 

  2627. 	    		if($item->language=='*') {

    2628. 

  2628. 	    			if($sefConfig->addLangMulti==false) {

    2629. 

  2629. 	    				$langs=array();

    2630. 

  2630. 	    			}

    2631. 

  2631. 	    		} else {

    2632. 

  2632. 	    			if($sefConfig->alwaysUseLangJoomla==false) {

    2633. 

  2633. 	    				if($sefConfig->mainLanguageJoomla==$codes[$item->language]->sef) {

    2634. 

  2634. 	    					$langs=array();	

    2635. 

  2635. 	    				} else {

    2636. 

  2636. 	    					$langs=array($codes[$item->language]->sef);

    2637. 

  2637. 	    				}

    2638. 

  2638. 	    				

    2639. 

  2639. 	    			} else {

    2640. 

  2640. 	    				$langs=array($codes[$item->language]->sef);

    2641. 

  2641. 	    			}

    2642. 

  2642. 	    		}

    2643. 

  2643. 	    	}

    2644. 

  2644. 	    	print_r($langs);	

    2645. 

  2645.     	}*/

    2646. 

  2646.     	

    2647. 

  2647. 

    2648. 

  2648.     	foreach($urls as $url) {

    2649. 

  2649.     		$query="SELECT id, origurl, sefurl, metadesc, metakey, metatitle, metalang, metarobots, metagoogle, metaauthor, locked \n";

    2650. 

  2650. 			$query.="FROM #__sefurls \n";

    2651. 

  2651. 			$query.="WHERE origurl REGEXP ".$db->quote($url);			

    2652. 

  2652. 			$db->setQuery($query);

    2653. 

  2653. 			//echo str_replace('#__','jos_',$query)."<br><br>";

    2654. 

  2654. 			$sefs=$db->loadObjectList();

    2655. 

  2655. 			//echo "<pre>";print_r($sefs);echo "</pre>";

    2656. 

  2656. 			

    2657. 

  2657. 			foreach($sefs as $sef) {

    2658. 

  2658. 				if($sef->locked==1) {

    2659. 

  2659. 					continue;

    2660. 

  2660. 				}

    2661. 

  2661. 				

    2662. 

  2662. 				//if(empty($langs)) {

    2663. 

  2663. 					$uri=new JURI($sef->origurl);

    2664. 

  2664. 		    		$this->build($uri,true);

    2665. 

  2665. 		    		$new_url=$uri->toString();

    2666. 

  2666. 		    		// Strip scheme and host - it's simpler than check other URL parts

    2667. 

  2667. 		    		$hostname=JFactory::getUri()->toString(array('scheme','host'));				

    2668. 

  2668. 					$new_url=str_replace($hostname."/",'',$new_url);

    2669. 

  2669. 					

    2670. 

  2670. 					$redirect_inserted=false;

    2671. 

  2671. 					echo $sef->sefurl."<br>".$new_url."<br><br>";

    2672. 

  2672. 					if(strcmp($sef->sefurl,$new_url)!=0) {

    2673. 

  2673. 						$redirect_inserted=true;

    2674. 

  2674. 						$this->_insertRedirect($sef->sefurl,$new_url);

    2675. 

  2675. 						$this->_updateURL($sef->id,$new_url);

    2676. 

  2676. 					}

    2677. 

  2677. 				/*} else {

    2678. 

  2678. 					foreach($langs as $lang) {

    2679. 

  2679. 						echo $sef->origurl."<br>";

    2680. 

  2680. 						$uri=new JURI($sef->origurl);

    2681. 

  2681. 						//$uri->setVar('lang',$lang);

    2682. 

  2682. 			    		$this->build($uri,true);

    2683. 

  2683. 			    		$new_url=$uri->toString();

    2684. 

  2684. 			    		// Strip scheme and host - it's simpler than check other URL parts

    2685. 

  2685. 			    		$hostname=JFactory::getUri()->toString(array('scheme','host'));				

    2686. 

  2686. 						$new_url=str_replace($hostname."/",'',$new_url);

    2687. 

  2687. 						echo $new_url."<br><br>";

    2688. 

  2688. 						

    2689. 

  2689. 						$redirect_inserted=false;

    2690. 

  2690. 						if(strcmp($sef->sefurl,$new_url)!=0) {

    2691. 

  2691. 							$redirect_inserted=true;

    2692. 

  2692. 							//$this->_insertRedirect($sef->sefurl,$new_url);

    2693. 

  2693. 							//$this->_updateURL($sef->id,$new_url);

    2694. 

  2694. 						}

    2695. 

  2695. 							

    2696. 

  2696. 					}

    2697. 

  2697. 				}

    2698. 

  2698. 				exit;*/

    2699. 

  2699. 		

    2700. 

  2700. 				$metadata=$this->_data["metadata"];

    2701. 

  2701. 				$metas=array();

    2702. 

  2702. 				foreach($metadata as $key=>$value) {

    2703. 

  2703. 					if($sef->$key!=$value) {

    2704. 

  2704. 						$metas[]=$key."=".$db->quote(str_replace(array("\\", "'", ';'), array("\\\\", "\\'", "\\;"), $value));

    2705. 

  2705. 					}

    2706. 

  2706. 				}

    2707. 

  2707. 				if(count($metas)) {

    2708. 

  2708. 					$this->_updateMetas($sef->id,$metas);

    2709. 

  2709. 				}

    2710. 

  2710. 			}

    2711. 

  2711. 			//exit;

    2712. 

  2712. 			

    2713. 

  2713. 			$cache_urls=$cache->checkSEFURL($url);

    2714. 

  2714. 			foreach($cache_urls as $cache_orig=>$cache_sef) {

    2715. 

  2715. 				$cache->updateCacheURL($cache_orig,$cache_sef,$new_url,$metadata);

    2716. 

  2716. 				if($redirect_inserted==false && $cache_sef!=$new_url) {

    2717. 

  2717. 					$this->_insertRedirect($cache_sef,$new_url);

    2718. 

  2718. 				}

    2719. 

  2719. 			}

    2720. 

  2720. 			

    2721. 

  2721.     	}

    2722. 

  2722.     }

    2723. 

  2723.     

    2724. 

  2724.     function _updateURL($id,$new_url) {

    2725. 

  2725.     	$db=JFactory::getDBO();

    2726. 

  2726.     	

    2727. 

  2727.     	$query="UPDATE #__sefurls \n";

    2728. 

  2728.     	$query.="SET sefurl=".$db->quote(html_entity_decode(urldecode($new_url)))." \n";

    2729. 

  2729.     	$query.="WHERE id=".$id;

    2730. 

  2730.     	$db->setQUery($query);

    2731. 

  2731.     	if(!$db->query()) {

    2732. 

  2732.     		JError::raiseError('JoomSEF Error', JText::_('COM_SEF_ERROR_SEF_URL_STORE') . $db->getErrorMsg());

    2733. 

  2733.     	}

    2734. 

  2734.     }

    2735. 

  2735.     

    2736. 

  2736.     function _insertRedirect($old_url,$new_url) {

    2737. 

  2737.     	$db=JFactory::getDBO();

    2738. 

  2738.     	

    2739. 

  2739.     	$query="DELETE FROM #__sefmoved \n";

    2740. 

  2740.     	$query.="WHERE old=".$db->quote($old_url);

    2741. 

  2741.     	$db->setQUery($query);

    2742. 

  2742.     	if(!$db->query()) {

    2743. 

  2743.     		JError::raiseError('JoomSEF Error', JText::_('COM_SEF_ERROR_SEF_URL_STORE') . $db->getErrorMsg());

    2744. 

  2744.     	}

    2745. 

  2745.     	

    2746. 

  2746.     	

    2747. 

  2747.     	// Added to avoid loops when someone want adds back original URL

    2748. 

  2748.     	$query="DELETE FROM #__sefmoved \n";

    2749. 

  2749.     	$query.="WHERE old=".$db->quote($new_url)." \n";

    2750. 

  2750.     	$query.="AND new=".$db->quote($old_url)." \n";

    2751. 

  2751.     	$db->setQUery($query);

    2752. 

  2752.     	if(!$db->query()) {

    2753. 

  2753.     		JError::raiseError('JoomSEF Error', JText::_('COM_SEF_ERROR_SEF_URL_STORE') . $db->getErrorMsg());

    2754. 

  2754.     	}

    2755. 

  2755.     	

    2756. 

  2756.     	$query="SELECT COUNT(*) \n";

    2757. 

  2757.     	$query.="FROM #__sefmoved \n";

    2758. 

  2758.     	$query.="WHERE old=".$db->quote($old_url)." AND new=".$db->quote($new_url)." \n";

    2759. 

  2759.     	$db->setQuery($query);

    2760. 

  2760.     	$cnt=$db->loadResult();

    2761. 

  2761.     	

    2762. 

  2762.     	if($cnt==0) {

    2763. 

  2763.     		$query="INSERT INTO #__sefmoved \n";

    2764. 

  2764.     		$query.="SET old=".$db->quote($old_url).", new=".$db->quote($new_url)." \n";

    2765. 

  2765.     		$db->setQuery($query);

    2766. 

  2766. 			if(!$db->query()) {

    2767. 

  2767. 	    		JError::raiseError('JoomSEF Error', JText::_('COM_SEF_ERROR_SEF_URL_STORE') . $db->getErrorMsg());

    2768. 

  2768. 	    	}

    2769. 

  2769.     	}	

    2770. 

  2770.     }

    2771. 

  2771.     

    2772. 

  2772.     function _updateMetas($id,$metas) {

    2773. 

  2773.     	$db=JFactory::getDBO();

    2774. 

  2774.     	

    2775. 

  2775.     	$query="UPDATE #__sefurls SET ".implode(",",$metas)." \n";

    2776. 

  2776.     	$query.="WHERE id=".$id;

    2777. 

  2777.     	$db->setQUery($query);

    2778. 

  2778.     	if(!$db->query()) {

    2779. 

  2779.     		JError::raiseError('JoomSEF Error', JText::_('COM_SEF_ERROR_SEF_URL_STORE') . $db->getErrorMsg());

    2780. 

  2780.     	}

    2781. 

  2781.     }

    2782. 

  2782.     	

    2783. 

  2783.     

    2784. 

  2784.     function _removeURL($option,$item) {

    2785. 

  2785.     	$db=JFactory::getDBO();

    2786. 

  2786.     	$sefConfig =& SEFConfig::getConfig();

    2787. 

  2787.     	$cache=SEFCache::getInstance();

    2788. 

  2788.     	

    2789. 

  2789.         if ($sefConfig->update_urls == false) {

    2790. 

  2790.     		return true;

    2791. 

  2791.     	}

    2792. 

  2792.     	

    2793. 

  2793.         $file = JPATH_ROOT.DS.'components'.DS.'com_sef'.DS.'sef_ext'.DS.$option.'.php';

    2794. 

  2794.         if (!file_exists($file)) {

    2795. 

  2795.             return true;

    2796. 

  2796.         }

    2797. 

  2797.         

    2798. 

  2798.     	require_once ($file);

    2799. 

  2799.     	$class = 'SefExt_'.$option;

    2800. 

  2800.         if (!class_exists($class)) {

    2801. 

  2801.             return true;

    2802. 

  2802.         }

    2803. 

  2803.     	$sef_ext=new $class();

    2804. 

  2804.     	

    2805. 

  2805.     	if (!method_exists($sef_ext, 'getURLPatterns')) {

    2806. 

  2806.             return true;

    2807. 

  2807.     	}

    2808. 

  2808.     	

    2809. 

  2809.         $urls=$sef_ext->getURLPatterns($item);

    2810. 

  2810.     	foreach($urls as $url) {

    2811. 

  2811.     		$query="SELECT id, sefurl,locked \n";

    2812. 

  2812.     		$query.="FROM #__sefurls \n";

    2813. 

  2813.     		$query.="WHERE origurl REGEXP ".$db->quote($url);

    2814. 

  2814.     		$db->setQuery($query);

    2815. 

  2815.     		$sefurl=$db->loadObject();

    2816. 

  2816.     		if(is_object($sefurl)) {

    2817. 

  2817. 	    		if($sefurl->locked) {

    2818. 

  2818. 	    			JError::raiseError('JoomSEF Error',JText::_('COM_SEF_ERROR_LOCKED_URL'));

    2819. 

  2819. 	    			return false;

    2820. 

  2820. 	    		}

    2821. 

  2821. 	    		

    2822. 

  2822. 	    		// Clean urls which relate to removed item

    2823. 

  2823. 	    		$query="DELETE FROM #__sefurls \n";

    2824. 

  2824. 	    		$query.="WHERE id=".$sefurl->id;

    2825. 

  2825. 	    		$db->setQuery($query);

    2826. 

  2826. 		    	if(!$db->query()) {

    2827. 

  2827. 		    		JError::raiseError('JoomSEF Error',$db->stderr(true));

    2828. 

  2828. 		    		return false;

    2829. 

  2829. 		    	}

    2830. 

  2830. 		    	

    2831. 

  2831. 		    	// Clean unnecessary redirects

    2832. 

  2832. 		    	$query="DELETE FROM #__sefmoved \n";

    2833. 

  2833. 		    	$query.="WHERE new=".$db->quote($sefurl->sefurl);

    2834. 

  2834. 		    	$db->setQuery($query);

    2835. 

  2835. 		    	if(!$db->query()) {

    2836. 

  2836. 		    		JError::raiseError('JoomSEF Error',$db->stderr(true));

    2837. 

  2837. 		    		return false;

    2838. 

  2838. 		    	}

    2839. 

  2839.     		}

    2840. 

  2840. 	    	

    2841. 

  2841. 	    	// Clean urls which relate to removed item from cache too

    2842. 

  2842. 	    	$cache->removeCacheURL($url);

    2843. 

  2843.     	}

    2844. 

  2844.     	

    2845. 

  2845.     	return true;

    2846. 

  2846.     }

    2847. 

  2847.     

    2848. 

  2848.     function getNonSEFURL($sefurl) {

    2849. 

  2849.     	$db=JFactory::getDBO();

    2850. 

  2850.     	

    2851. 

  2851.     	$path=substr(JURI::root(true)."/",1);

    2852. 

  2852.     	$sefurl=str_replace($path,'',$sefurl);

    2853. 

  2853.     	

    2854. 

  2854.     	$query="SELECT origurl \n";

    2855. 

  2855.     	$query.="FROM #__sefurls \n";

    2856. 

  2856.     	$query.="WHERE sefurl=".$db->quote($sefurl);

    2857. 

  2857.     	$db->setQuery($query);

    2858. 

  2858.     	$origurl=$db->loadResult();

    2859. 

  2859.     	if(strlen($origurl)) {

    2860. 

  2860.     		return $origurl;

    2861. 

  2861.     	}

    2862. 

  2862.     	$cache=SEFCache::getInstance();

    2863. 

  2863.     	$origurl=$cache->getNonSEFURL($sefurl,false);    	

    2864. 

  2864.     	return @$origurl->origurl;

    2865. 

  2865.     }

    2866. 

  2866. 

    2867. 

  2867.     function _uriToUrl($uri, $removeVariables = null)

    2868. 

  2868.     {

    2869. 

  2869.         // Create new JURI object

    2870. 

  2870.         $url = new JURI($uri->toString(array('path','query','fragment')));

    2871. 

  2871. 

    2872. 

  2872.         // Remove variables if needed

    2873. 

  2873.         if (!empty($removeVariables)) {

    2874. 

  2874.             if (is_array($removeVariables)) {

    2875. 

  2875.                 foreach ($removeVariables as $var) {

    2876. 

  2876.                     $url->delVar($var);

    2877. 

  2877.                 }

    2878. 

  2878.             } else {

    2879. 

  2879.                 $url->delVar($removeVariables);

    2880. 

  2880.             }

    2881. 

  2881.         }

    2882. 

  2882. 

    2883. 

  2883.         // sort variables

    2884. 

  2884.         $vars = $url->getQuery(true);

    2885. 

  2885.         ksort($vars);

    2886. 

  2886. 

    2887. 

  2887.         // Move option to beginning

    2888. 

  2888.         if (isset($vars['option'])) {

    2889. 

  2889.         	$opt = $vars['option'];

    2890. 

  2890.         	unset($vars['option']);

    2891. 

  2891.         	$vars = array_merge(array('option' => $opt), $vars);

    2892. 

  2892.         }

    2893. 

  2893. 

    2894. 

  2894.         // Set vars

    2895. 

  2895.         $url->setQuery($vars);

    2896. 

  2896. 

    2897. 

  2897.         // Create string for db

    2898. 

  2898.         return $url->toString(array('path', 'query'));

    2899. 

  2899.     }

    2900. 

  2900. 

    2901. 

  2901.     /**

    2902. 

  2902.      * Returns the default priority value for the url

    2903. 

  2903.      *

    2904. 

  2904.      * @param JURI $uri

    2905. 

  2905.      * @return int

    2906. 

  2906.      */

    2907. 

  2907.     function _getPriorityDefault(&$uri)

    2908. 

  2908.     {

    2909. 

  2909.         $itemid = $uri->getVar('Itemid');

    2910. 

  2910. 

    2911. 

  2911.         if( is_null($itemid) ) {

    2912. 

  2912.             return _COM_SEF_PRIORITY_DEFAULT;

    2913. 

  2913.         }

    2914. 

  2914.         else {

    2915. 

  2915.             return _COM_SEF_PRIORITY_DEFAULT_ITEMID;

    2916. 

  2916.         }

    2917. 

  2917.     }

    2918. 

  2918. 

    2919. 

  2919.     function _getDebugInfo($traceLevel = 3, $onlyUserInfo = false)

    2920. 

  2920.     {

    2921. 

  2921.         $debuginfo = '';

    2922. 

  2922.         $tr = 0;

    2923. 

  2923. 

    2924. 

  2924.         $uri =& JURI::getInstance();

    2925. 

  2925.         if (!$onlyUserInfo) {

    2926. 

  2926.             $debuginfo = 'From: ' . @$uri->toString() . "\n";

    2927. 

  2927.         }

    2928. 

  2928. 

    2929. 

  2929.         $debuginfo .= 'Referer: ' . @$_SERVER['HTTP_REFERER'] . "\n";

    2930. 

  2930.         $debuginfo .= 'User agent: ' . @$_SERVER['HTTP_USER_AGENT'];

    2931. 

  2931. 

    2932. 

  2932.         if ($onlyUserInfo) {

    2933. 

  2933.             return $debuginfo;

    2934. 

  2934.         }

    2935. 

  2935. 

    2936. 

  2936.         $debuginfo .= "\n\n";

    2937. 

  2937.         $trace = debug_backtrace();

    2938. 

  2938.         foreach ($trace as $row) {

    2939. 

  2939.         	if (@$row['class'] == 'JRouterJoomsef' && @$row['function'] == 'build') {

    2940. 

  2940.         		// this starts tracing for next 3 rounds

    2941. 

  2941.        			$tr = 1;

    2942. 

  2942.        			continue;

    2943. 

  2943.         	}

    2944. 

  2944.         	elseif ($tr == 0) continue;

    2945. 

  2945. 

    2946. 

  2946.         	$file = isset($row['file']) ? str_replace(JPATH_BASE, '', $row['file']) : 'n/a';

    2947. 

  2947.         	$args = array();

    2948. 

  2948.         	foreach ($row['args'] as $arg) {

    2949. 

  2949.         		if (is_object($arg)) $args[] = get_class($arg);

    2950. 

  2950.         		elseif (is_array($arg)) $args[] = 'Array';

    2951. 

  2951.         		else $args[] = "'" . $arg . "'";

    2952. 

  2952.         	}

    2953. 

  2953.         	$debuginfo .= '#' . $tr . ': ' . @$row['class'] . @$row['type'] . @$row['function'] . "(" . implode(', ', $args) .  "), " . $file . ' line ' . @$row['line'] . "\n";

    2954. 

  2954. 

    2955. 

  2955.         	if ($tr == $traceLevel) break;

    2956. 

  2956.         	$tr++;

    2957. 

  2957.         }

    2958. 

  2958. 

    2959. 

  2959.         return $debuginfo;

    2960. 

  2960. 	}

    2961. 

  2961. 

    2962. 

  2962. 

    2963. 

  2963.     function CheckAccess()

    2964. 

  2964.     {

    2965. 

  2965.         if (isset($_GET['query'])) {

    2966. 

  2966.             if (strtolower($_GET['query']) == 'ispaid') {

    2967. 

  2967.                 echo 'false'; exit();

    2968. 

  2968.             }

    2969. 

  2969.         }

    2970. 

  2970. 

    2971. 

  2971.         die('Restricted access');

    2972. 

  2972.     }

    2973. 

  2973.     

    2974. 

  2974.     function OnlyPaidVersion()

    2975. 

  2975.     {

    2976. 

  2976.         echo '<strong>'.sprintf(JText::_('COM_SEF_INFO_ONLY_PAID_VERSION'), '<a href="http://www.artio.net/e-shop/joomsef" target="_blank">', '</a>').'</strong>';

    2977. 

  2977.     }

    2978. 

  2978.     

    2979. 

  2979. }

    2980. 

  2980. ?>

    2981. 

  2981.