PageRenderTime 54ms CodeModel.GetById 22ms RepoModel.GetById 1ms app.codeStats 0ms

/mondialrelay/classes/MRTools.php

https://github.com/DaveBenNoah/PrestaShop-modules
PHP | 268 lines | 194 code | 18 blank | 56 comment | 26 complexity | 46162629bdf02a5413f5fbc51cf6f3f9 MD5 | raw file
Possible License(s): Apache-2.0, CC-BY-SA-3.0 
    

  1. <?php
    2. 

  2. /*
    3. 

  3. * 2007-2014 PrestaShop
    4. 

  4. *
    5. 

  5. * NOTICE OF LICENSE
    6. 

  6. *
    7. 

  7. * This source file is subject to the Academic Free License (AFL 3.0)
    8. 

  8. * that is bundled with this package in the file LICENSE.txt.
    9. 

  9. * It is also available through the world-wide-web at this URL:
    10. 

  10. * http://opensource.org/licenses/afl-3.0.php
    11. 

  11. * If you did not receive a copy of the license and are unable to
    12. 

  12. * obtain it through the world-wide-web, please send an email
    13. 

  13. * to license@prestashop.com so we can send you a copy immediately.
    14. 

  14. *
    15. 

  15. * DISCLAIMER
    16. 

  16. *
    17. 

  17. * Do not edit or add to this file if you wish to upgrade PrestaShop to newer
    18. 

  18. * versions in the future. If you wish to customize PrestaShop for your
    19. 

  19. * needs please refer to http://www.prestashop.com for more information.
    20. 

  20. *
    21. 

  21. *  @author PrestaShop SA <contact@prestashop.com>
    22. 

  22. *  @copyright  2007-2014 PrestaShop SA
    23. 

  23. *  @license    http://opensource.org/licenses/afl-3.0.php  Academic Free License (AFL 3.0)
    24. 

  24. *  International Registered Trademark & Property of PrestaShop SA
    25. 

  25. */
    26. 

  26. 

  27. /*
    28. 

  28. ** Some tools using used in the module
    29. 

  29. */
    30. 

  30. class MRTools
    31. 

  31. {
    32. 

  32. 	const REGEX_CLEAN_ADDR = '/[^a-zA-Z0-9-\s\'\!\,\|\(\)\.\*\&\#\/\:]/';
    33. 

  33. 

  34. 	const REGEX_CLEAN_PHONE = '/[^0-9+\(\)]*/';
    35. 

  35. 

  36. 	/**
    37. 

  37. 	 * Check if a string could be UTF8 one
    38. 

  38. 	 *
    39. 

  39. 	 * @static
    40. 

  40. 	 * @param $str
    41. 

  41. 	 * @return bool
    42. 

  42. 	 */
    43. 

  43. 	public static function seemsUTF8($str)
    44. 

  44. 	{
    45. 

  45. 		$length = strlen($str);
    46. 

  46. 

  47. 		for($i = 0; $i < $length; $i++)
    48. 

  48. 		{
    49. 

  49. 			$c = ord($str[$i]);
    50. 

  50. 			if ($c < 0x80)
    51. 

  51. 				$n = 0; # 0bbbbbbb
    52. 

  52. 			else if (($c & 0xE0) == 0xC0)
    53. 

  53. 				$n = 1; # 110bbbbb
    54. 

  54. 			else if (($c & 0xF0) == 0xE0)
    55. 

  55. 				$n=2; # 1110bbbb
    56. 

  56. 			else if (($c & 0xF8) == 0xF0)
    57. 

  57. 				$n = 3; # 11110bbb
    58. 

  58. 			else if (($c & 0xFC) == 0xF8)
    59. 

  59. 				$n = 4; # 111110bb
    60. 

  60. 			else if (($c & 0xFE) == 0xFC)
    61. 

  61. 				$n=5; # 1111110b
    62. 

  62. 			else
    63. 

  63. 				return false; # Does not match any model
    64. 

  64. 			for ($j = 0; $j < $n; $j++)
    65. 

  65. 			{
    66. 

  66. 				# n bytes matching 10bbbbbb follow ?
    67. 

  67. 				if ((++$i == $length) || ((ord($str[$i]) & 0xC0) != 0x80))
    68. 

  68. 					return false;
    69. 

  69. 			}
    70. 

  70. 		}
    71. 

  71. 		return true;
    72. 

  72. 	}
    73. 

  73. 

  74. 	/**
    75. 

  75. 	 * Converts all accent characters to ASCII characters.
    76. 

  76. 	 *
    77. 

  77. 	 * If there are no accent characters, then the string given is just returned.
    78. 

  78. 	 *
    79. 

  79. 	 * @param string $string Text that might have accent characters
    80. 

  80. 	 * @return string Filtered string with replaced "nice" characters.
    81. 

  81. 	 */
    82. 

  82. 	public static function removeAccents($string)
    83. 

  83. 	{
    84. 

  84. 		if (!preg_match('/[\x80-\xff]/', $string))
    85. 

  85. 			return $string;
    86. 

  86. 

  87. 		if (MRTools::seemsUTF8($string))
    88. 

  88. 		{
    89. 

  89. 			$chars = array(
    90. 

  90. 				// Decompositions for Latin-1 Supplement
    91. 

  91. 				chr(195).chr(128) => 'A', chr(195).chr(129) => 'A',
    92. 

  92. 				chr(195).chr(130) => 'A', chr(195).chr(131) => 'A',
    93. 

  93. 				chr(195).chr(132) => 'A', chr(195).chr(133) => 'A',
    94. 

  94. 				chr(195).chr(135) => 'C', chr(195).chr(136) => 'E',
    95. 

  95. 				chr(195).chr(137) => 'E', chr(195).chr(138) => 'E',
    96. 

  96. 				chr(195).chr(139) => 'E', chr(195).chr(140) => 'I',
    97. 

  97. 				chr(195).chr(141) => 'I', chr(195).chr(142) => 'I',
    98. 

  98. 				chr(195).chr(143) => 'I', chr(195).chr(145) => 'N',
    99. 

  99. 				chr(195).chr(146) => 'O', chr(195).chr(147) => 'O',
    100. 

  100. 				chr(195).chr(148) => 'O', chr(195).chr(149) => 'O',
    101. 

  101. 				chr(195).chr(150) => 'O', chr(195).chr(153) => 'U',
    102. 

  102. 				chr(195).chr(154) => 'U', chr(195).chr(155) => 'U',
    103. 

  103. 				chr(195).chr(156) => 'U', chr(195).chr(157) => 'Y',
    104. 

  104. 				chr(195).chr(159) => 's', chr(195).chr(160) => 'a',
    105. 

  105. 				chr(195).chr(161) => 'a', chr(195).chr(162) => 'a',
    106. 

  106. 				chr(195).chr(163) => 'a', chr(195).chr(164) => 'a',
    107. 

  107. 				chr(195).chr(165) => 'a', chr(195).chr(167) => 'c',
    108. 

  108. 				chr(195).chr(168) => 'e', chr(195).chr(169) => 'e',
    109. 

  109. 				chr(195).chr(170) => 'e', chr(195).chr(171) => 'e',
    110. 

  110. 				chr(195).chr(172) => 'i', chr(195).chr(173) => 'i',
    111. 

  111. 				chr(195).chr(174) => 'i', chr(195).chr(175) => 'i',
    112. 

  112. 				chr(195).chr(177) => 'n', chr(195).chr(178) => 'o',
    113. 

  113. 				chr(195).chr(179) => 'o', chr(195).chr(180) => 'o',
    114. 

  114. 				chr(195).chr(181) => 'o', chr(195).chr(182) => 'o',
    115. 

  115. 				chr(195).chr(182) => 'o', chr(195).chr(185) => 'u',
    116. 

  116. 				chr(195).chr(186) => 'u', chr(195).chr(187) => 'u',
    117. 

  117. 				chr(195).chr(188) => 'u', chr(195).chr(189) => 'y',
    118. 

  118. 				chr(195).chr(191) => 'y',
    119. 

  119. 				// Decompositions for Latin Extended-A
    120. 

  120. 				chr(196).chr(128) => 'A', chr(196).chr(129) => 'a',
    121. 

  121. 				chr(196).chr(130) => 'A', chr(196).chr(131) => 'a',
    122. 

  122. 				chr(196).chr(132) => 'A', chr(196).chr(133) => 'a',
    123. 

  123. 				chr(196).chr(134) => 'C', chr(196).chr(135) => 'c',
    124. 

  124. 				chr(196).chr(136) => 'C', chr(196).chr(137) => 'c',
    125. 

  125. 				chr(196).chr(138) => 'C', chr(196).chr(139) => 'c',
    126. 

  126. 				chr(196).chr(140) => 'C', chr(196).chr(141) => 'c',
    127. 

  127. 				chr(196).chr(142) => 'D', chr(196).chr(143) => 'd',
    128. 

  128. 				chr(196).chr(144) => 'D', chr(196).chr(145) => 'd',
    129. 

  129. 				chr(196).chr(146) => 'E', chr(196).chr(147) => 'e',
    130. 

  130. 				chr(196).chr(148) => 'E', chr(196).chr(149) => 'e',
    131. 

  131. 				chr(196).chr(150) => 'E', chr(196).chr(151) => 'e',
    132. 

  132. 				chr(196).chr(152) => 'E', chr(196).chr(153) => 'e',
    133. 

  133. 				chr(196).chr(154) => 'E', chr(196).chr(155) => 'e',
    134. 

  134. 				chr(196).chr(156) => 'G', chr(196).chr(157) => 'g',
    135. 

  135. 				chr(196).chr(158) => 'G', chr(196).chr(159) => 'g',
    136. 

  136. 				chr(196).chr(160) => 'G', chr(196).chr(161) => 'g',
    137. 

  137. 				chr(196).chr(162) => 'G', chr(196).chr(163) => 'g',
    138. 

  138. 				chr(196).chr(164) => 'H', chr(196).chr(165) => 'h',
    139. 

  139. 				chr(196).chr(166) => 'H', chr(196).chr(167) => 'h',
    140. 

  140. 				chr(196).chr(168) => 'I', chr(196).chr(169) => 'i',
    141. 

  141. 				chr(196).chr(170) => 'I', chr(196).chr(171) => 'i',
    142. 

  142. 				chr(196).chr(172) => 'I', chr(196).chr(173) => 'i',
    143. 

  143. 				chr(196).chr(174) => 'I', chr(196).chr(175) => 'i',
    144. 

  144. 				chr(196).chr(176) => 'I', chr(196).chr(177) => 'i',
    145. 

  145. 				chr(196).chr(178) => 'IJ',chr(196).chr(179) => 'ij',
    146. 

  146. 				chr(196).chr(180) => 'J', chr(196).chr(181) => 'j',
    147. 

  147. 				chr(196).chr(182) => 'K', chr(196).chr(183) => 'k',
    148. 

  148. 				chr(196).chr(184) => 'k', chr(196).chr(185) => 'L',
    149. 

  149. 				chr(196).chr(186) => 'l', chr(196).chr(187) => 'L',
    150. 

  150. 				chr(196).chr(188) => 'l', chr(196).chr(189) => 'L',
    151. 

  151. 				chr(196).chr(190) => 'l', chr(196).chr(191) => 'L',
    152. 

  152. 				chr(197).chr(128) => 'l', chr(197).chr(129) => 'L',
    153. 

  153. 				chr(197).chr(130) => 'l', chr(197).chr(131) => 'N',
    154. 

  154. 				chr(197).chr(132) => 'n', chr(197).chr(133) => 'N',
    155. 

  155. 				chr(197).chr(134) => 'n', chr(197).chr(135) => 'N',
    156. 

  156. 				chr(197).chr(136) => 'n', chr(197).chr(137) => 'N',
    157. 

  157. 				chr(197).chr(138) => 'n', chr(197).chr(139) => 'N',
    158. 

  158. 				chr(197).chr(140) => 'O', chr(197).chr(141) => 'o',
    159. 

  159. 				chr(197).chr(142) => 'O', chr(197).chr(143) => 'o',
    160. 

  160. 				chr(197).chr(144) => 'O', chr(197).chr(145) => 'o',
    161. 

  161. 				chr(197).chr(146) => 'OE',chr(197).chr(147) => 'oe',
    162. 

  162. 				chr(197).chr(148) => 'R',chr(197).chr(149) => 'r',
    163. 

  163. 				chr(197).chr(150) => 'R',chr(197).chr(151) => 'r',
    164. 

  164. 				chr(197).chr(152) => 'R',chr(197).chr(153) => 'r',
    165. 

  165. 				chr(197).chr(154) => 'S',chr(197).chr(155) => 's',
    166. 

  166. 				chr(197).chr(156) => 'S',chr(197).chr(157) => 's',
    167. 

  167. 				chr(197).chr(158) => 'S',chr(197).chr(159) => 's',
    168. 

  168. 				chr(197).chr(160) => 'S', chr(197).chr(161) => 's',
    169. 

  169. 				chr(197).chr(162) => 'T', chr(197).chr(163) => 't',
    170. 

  170. 				chr(197).chr(164) => 'T', chr(197).chr(165) => 't',
    171. 

  171. 				chr(197).chr(166) => 'T', chr(197).chr(167) => 't',
    172. 

  172. 				chr(197).chr(168) => 'U', chr(197).chr(169) => 'u',
    173. 

  173. 				chr(197).chr(170) => 'U', chr(197).chr(171) => 'u',
    174. 

  174. 				chr(197).chr(172) => 'U', chr(197).chr(173) => 'u',
    175. 

  175. 				chr(197).chr(174) => 'U', chr(197).chr(175) => 'u',
    176. 

  176. 				chr(197).chr(176) => 'U', chr(197).chr(177) => 'u',
    177. 

  177. 				chr(197).chr(178) => 'U', chr(197).chr(179) => 'u',
    178. 

  178. 				chr(197).chr(180) => 'W', chr(197).chr(181) => 'w',
    179. 

  179. 				chr(197).chr(182) => 'Y', chr(197).chr(183) => 'y',
    180. 

  180. 				chr(197).chr(184) => 'Y', chr(197).chr(185) => 'Z',
    181. 

  181. 				chr(197).chr(186) => 'z', chr(197).chr(187) => 'Z',
    182. 

  182. 				chr(197).chr(188) => 'z', chr(197).chr(189) => 'Z',
    183. 

  183. 				chr(197).chr(190) => 'z', chr(197).chr(191) => 's',
    184. 

  184. 				// Euro Sign
    185. 

  185. 				chr(226).chr(130).chr(172) => 'E',
    186. 

  186. 				// GBP (Pound) Sign
    187. 

  187. 				chr(194).chr(163) => '');
    188. 

  188. 

  189. 			$string = strtr($string, $chars);
    190. 

  190. 		}
    191. 

  191. 		else
    192. 

  192. 		{
    193. 

  193. 			// Assume ISO-8859-1 if not UTF-8
    194. 

  194. 			$chars['in'] = chr(128).chr(131).chr(138).chr(142).chr(154).chr(158)
    195. 

  195. 				.chr(159).chr(162).chr(165).chr(181).chr(192).chr(193).chr(194)
    196. 

  196. 				.chr(195).chr(196).chr(197).chr(199).chr(200).chr(201).chr(202)
    197. 

  197. 				.chr(203).chr(204).chr(205).chr(206).chr(207).chr(209).chr(210)
    198. 

  198. 				.chr(211).chr(212).chr(213).chr(214).chr(216).chr(217).chr(218)
    199. 

  199. 				.chr(219).chr(220).chr(221).chr(224).chr(225).chr(226).chr(227)
    200. 

  200. 				.chr(228).chr(229).chr(231).chr(232).chr(233).chr(234).chr(235)
    201. 

  201. 				.chr(236).chr(237).chr(238).chr(239).chr(241).chr(242).chr(243)
    202. 

  202. 				.chr(244).chr(245).chr(246).chr(248).chr(249).chr(250).chr(251)
    203. 

  203. 				.chr(252).chr(253).chr(255);
    204. 

  204. 

  205. 			$chars['out'] = "EfSZszYcYuAAAAAACEEEEIIIINOOOOOOUUUUYaaaaaaceeeeiiiinoooooouuuuyy";
    206. 

  206. 

  207. 			$string = strtr($string, $chars['in'], $chars['out']);
    208. 

  208. 			$double_chars['in'] = array(chr(140), chr(156), chr(198), chr(208), chr(222), chr(223), chr(230), chr(240), chr(254));
    209. 

  209. 			$double_chars['out'] = array('OE', 'oe', 'AE', 'DH', 'TH', 'ss', 'ae', 'dh', 'th');
    210. 

  210. 			$string = str_replace($double_chars['in'], $double_chars['out'], $string);
    211. 

  211. 		}
    212. 

  212. 		return $string;
    213. 

  213. 	}
    214. 

  214. 

  215. 	// Add for 1.3 compatibility and avoid duplicate code
    216. 

  216. 	public static function jsonEncode($result)
    217. 

  217. 	{
    218. 

  218. 		return (method_exists('Tools', 'jsonEncode')) ?
    219. 

  219. 			Tools::jsonEncode($result) : json_encode($result);
    220. 

  220. 	}
    221. 

  221. 	
    222. 

  222. 	/*
    223. 

  223. 	** Fix security and compatibility for PS < 1.4.5
    224. 

  224. 	*/
    225. 

  225. 	static function bqSQL($string)
    226. 

  226. 	{
    227. 

  227. 		return str_replace('`', '\`', pSQL($string));
    228. 

  228. 	}
    229. 

  229. 	
    230. 

  230. 	/*
    231. 

  231. 	** Check zip code by country
    232. 

  232. 	*/
    233. 

  233. 	static public function checkZipcodeByCountry($zipcode, $params)
    234. 

  234. 	{
    235. 

  235. 		$id_country = $params['id_country'];
    236. 

  236. 		
    237. 

  237. 		$zipcodeFormat = Db::getInstance()->getValue('
    238. 

  238. 				SELECT `zip_code_format`
    239. 

  239. 				FROM `'._DB_PREFIX_.'country`
    240. 

  240. 				WHERE `id_country` = '.(int)$id_country);
    241. 

    242. 

  242. 		// -1 to warn user that no layout exist
    243. 

  243. 		if (!$zipcodeFormat)
    244. 

  244. 			return -1;
    245. 

  245. 

  246. 		$regxMask = str_replace(
    247. 

  247. 				array('N', 'C', 'L'),
    248. 

  248. 				array(
    249. 

  249. 					'[0-9]',
    250. 

  250. 					Country::getIsoById((int)$id_country),
    251. 

  251. 					'[a-zA-Z]'),
    252. 

  252. 				$zipcodeFormat);
    253. 

  253. 		if (preg_match('/'.$regxMask.'/', $zipcode))
    254. 

  254. 			return true;
    255. 

  255. 		return false;
    256. 

  256. 	}
    257. 

  257. 

  258. 	static public function getFormatedPhone($phone_number)
    259. 

  259. 	{
    260. 

  260. 		$begin = substr($phone_number, 0, 3);
    261. 

  261. 		$pad_number = (strpos($begin, '+3') !== false) ? 12 :
    262. 

  262. 			(strpos($begin, '00') ? 13 : 10);
    263. 

  263. 

  264. 		return str_pad(substr(preg_replace(MRTools::REGEX_CLEAN_PHONE, '', $phone_number), 0, $pad_number), $pad_number, '0');
    265. 

  265. 	}
    266. 

  266. }
    267. 

  267. 

  268. ?>
    269. 

  269.