You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

417 lines
12 KiB

  1. <?php
  2. /***************************************************************************\
  3. * SPIP, Systeme de publication pour l'internet *
  4. * *
  5. * Copyright (c) 2001-2020 *
  6. * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
  7. * *
  8. * Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
  9. * Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
  10. \***************************************************************************/
  11. /**
  12. * Fonctions utiles pour les squelettes et déclarations de boucle
  13. * pour le compilateur
  14. *
  15. * @package SPIP\Medias\Fonctions
  16. **/
  17. // sécurité
  18. if (!defined('_ECRIRE_INC_VERSION')) {
  19. return;
  20. }
  21. // nettoyer les zip abandonnes par l'utilisateur
  22. if (isset($GLOBALS['visiteur_session']['zip_to_clean'])
  23. and test_espace_prive()
  24. and isset($_SERVER['REQUEST_METHOD'])
  25. and $_SERVER['REQUEST_METHOD'] !== 'POST'
  26. ) {
  27. $zip_to_clean = unserialize($GLOBALS['visiteur_session']['zip_to_clean']);
  28. if ($zip_to_clean) {
  29. foreach ($zip_to_clean as $zip) {
  30. if (@file_exists($zip)) {
  31. @unlink($zip);
  32. }
  33. }
  34. }
  35. session_set('zip_to_clean');
  36. }
  37. // capturer un formulaire POST plus grand que post_max_size
  38. // on genere un minipres car on ne peut rien faire de mieux
  39. if (isset($_SERVER['REQUEST_METHOD'])
  40. and $_SERVER['REQUEST_METHOD'] == 'POST'
  41. and empty($_POST)
  42. and isset($_SERVER['CONTENT_TYPE'])
  43. and strlen($_SERVER['CONTENT_TYPE']) > 0
  44. and strncmp($_SERVER['CONTENT_TYPE'], 'multipart/form-data', 19) == 0
  45. and $_SERVER['CONTENT_LENGTH'] > medias_inigetoctets('post_max_size')
  46. ) {
  47. include_spip('inc/minipres');
  48. echo minipres(_T('medias:upload_limit', array('max' => ini_get('post_max_size'))));
  49. exit;
  50. }
  51. /**
  52. * Styliser le modele media : reroute les <img> <doc> <emb> vers <image>, <audio>, <video>, <file> selon le media du document
  53. * si le document n'est pas trouve c'est <file> qui s'applique
  54. * @param $modele
  55. * @param $id
  56. * @return string
  57. */
  58. function medias_modeles_styliser($modele, $id) {
  59. if (defined('_LEGACY_ACTIVE_IMG_DOC_EMB') and _LEGACY_ACTIVE_IMG_DOC_EMB) {
  60. return $modele;
  61. }
  62. switch($modele) {
  63. case 'img':
  64. case 'doc':
  65. case 'emb':
  66. $m = 'file';
  67. if ($doc = sql_fetsel('id_document,media', 'spip_documents', 'id_document='.intval($id))) {
  68. $m = $doc['media']; // image, audio, video, file
  69. }
  70. if (trouve_modele("{$m}_{$modele}")) {
  71. // on peut decliner file_emb qui sera utilisable soit par <docXX|emb> soit par <embXX>
  72. // permet d'embed explicitement des fichiers exotiques qui sinon seraient de simples liens a telecharger
  73. // tels que text/csv, text/html, text
  74. $m = "{$m}_{$modele}";
  75. }
  76. $modele = $m;
  77. break;
  78. }
  79. return $modele;
  80. }
  81. /**
  82. * Retourne la taille en octet d'une valeur de configuration php
  83. *
  84. * @param string $var
  85. * Clé de configuration ; valeur récupérée par `ini_get()`. Exemple `post_max_size`
  86. * @return int|string
  87. * Taille en octet, sinon chaine vide.
  88. **/
  89. function medias_inigetoctets($var) {
  90. $last = '';
  91. $val = trim(@ini_get($var));
  92. if (is_numeric($val)) {
  93. return $val;
  94. }
  95. // en octet si "32M"
  96. if ($val != '') {
  97. $last = strtolower($val[strlen($val) - 1]);
  98. $val = substr($val, 0, -1);
  99. }
  100. switch ($last) { // The 'G' modifier is available since PHP 5.1.0
  101. case 'g':
  102. $val *= 1024 * 1024 * 1024;
  103. break;
  104. case 'm':
  105. $val *= 1024 * 1024;
  106. break;
  107. case 'k':
  108. $val *= 1024;
  109. break;
  110. }
  111. return $val;
  112. }
  113. /**
  114. * Afficher la puce de statut pour les documents
  115. *
  116. * @param int $id_document
  117. * Identifiant du document
  118. * @param string $statut
  119. * Statut du document
  120. * @return string
  121. * Code HTML de l'image de puce
  122. */
  123. function medias_puce_statut_document($id_document, $statut) {
  124. if ($statut == 'publie') {
  125. $puce = 'puce-verte.gif';
  126. } else {
  127. if ($statut == 'prepa') {
  128. $puce = 'puce-blanche.gif';
  129. } else {
  130. if ($statut == 'poubelle') {
  131. $puce = 'puce-poubelle.gif';
  132. } else {
  133. $puce = 'puce-blanche.gif';
  134. }
  135. }
  136. }
  137. return http_img_pack($puce, $statut, "class='puce'");
  138. }
  139. /**
  140. * Compile la boucle `DOCUMENTS` qui retourne une liste de documents multimédia
  141. *
  142. * `<BOUCLE(DOCUMENTS)>`
  143. *
  144. * @param string $id_boucle
  145. * Identifiant de la boucle
  146. * @param array $boucles
  147. * AST du squelette
  148. * @return string
  149. * Code PHP compilé de la boucle
  150. **/
  151. function boucle_DOCUMENTS($id_boucle, &$boucles) {
  152. $boucle = &$boucles[$id_boucle];
  153. $id_table = $boucle->id_table;
  154. // on ne veut pas des fichiers de taille nulle,
  155. // sauf s'ils sont distants (taille inconnue)
  156. array_unshift($boucle->where, array("'($id_table.taille > 0 OR $id_table.distant=\\'oui\\')'"));
  157. /**
  158. * N'afficher que les modes de documents que l'on accepte
  159. * Utiliser le "pipeline medias_documents_visibles" pour en ajouter
  160. */
  161. if (!isset($boucle->modificateur['criteres']['mode'])
  162. and !isset($boucle->modificateur['tout'])
  163. ) {
  164. $modes = pipeline('medias_documents_visibles', array('image', 'document'));
  165. $f = sql_serveur('quote', $boucle->sql_serveur, true);
  166. $modes = addslashes(join(',', array_map($f, array_unique($modes))));
  167. array_unshift($boucle->where, array("'IN'", "'$id_table.mode'", "'($modes)'"));
  168. }
  169. return calculer_boucle($id_boucle, $boucles);
  170. }
  171. /**
  172. * Pour compat uniquement, utiliser generer_lien_entite
  173. *
  174. * @deprecated
  175. * @uses generer_lien_entite()
  176. *
  177. * @param int $id
  178. * @param string $type
  179. * @param int $longueur
  180. * @param null $connect
  181. * @return string
  182. */
  183. function lien_objet($id, $type, $longueur = 80, $connect = null) {
  184. return generer_lien_entite($id, $type, $longueur, $connect);
  185. }
  186. /**
  187. * critere {orphelins} selectionne les documents sans liens avec un objet editorial
  188. *
  189. * @param string $idb
  190. * @param object $boucles
  191. * @param object $crit
  192. */
  193. function critere_DOCUMENTS_orphelins_dist($idb, &$boucles, $crit) {
  194. $boucle = &$boucles[$idb];
  195. $cond = $crit->cond;
  196. $not = $crit->not ? '' : 'NOT';
  197. $select = sql_get_select('DISTINCT id_document', 'spip_documents_liens as oooo');
  198. $where = "'" . $boucle->id_table . ".id_document $not IN ($select)'";
  199. if ($cond) {
  200. $_quoi = '@$Pile[0]["orphelins"]';
  201. $where = "($_quoi)?$where:''";
  202. }
  203. $boucle->where[] = $where;
  204. }
  205. /**
  206. * critere {portrait} qui selectionne
  207. * - les documents dont les dimensions sont connues
  208. * - les documents dont la hauteur est superieure a la largeur
  209. *
  210. * {!portrait} exclus ces documents
  211. *
  212. * @param string $idb
  213. * @param object $boucles
  214. * @param object $crit
  215. */
  216. function critere_DOCUMENTS_portrait_dist($idb, &$boucles, $crit) {
  217. $boucle = &$boucles[$idb];
  218. $table = $boucle->id_table;
  219. $not = ($crit->not ? 'NOT ' : '');
  220. $boucle->where[] = "'$not($table.largeur>0 AND $table.hauteur > $table.largeur)'";
  221. }
  222. /**
  223. * critere {paysage} qui selectionne
  224. * - les documents dont les dimensions sont connues
  225. * - les documents dont la hauteur est inferieure a la largeur
  226. *
  227. * {!paysage} exclus ces documents
  228. *
  229. * @param string $idb
  230. * @param object $boucles
  231. * @param object $crit
  232. */
  233. function critere_DOCUMENTS_paysage_dist($idb, &$boucles, $crit) {
  234. $boucle = &$boucles[$idb];
  235. $table = $boucle->id_table;
  236. $not = ($crit->not ? 'NOT ' : '');
  237. $boucle->where[] = "'$not($table.largeur>0 AND $table.largeur > $table.hauteur)'";
  238. }
  239. /**
  240. * critere {carre} qui selectionne
  241. * - les documents dont les dimensions sont connues
  242. * - les documents dont la hauteur est egale a la largeur
  243. *
  244. * {!carre} exclus ces documents
  245. *
  246. * @param string $idb
  247. * @param object $boucles
  248. * @param object $crit
  249. */
  250. function critere_DOCUMENTS_carre_dist($idb, &$boucles, $crit) {
  251. $boucle = &$boucles[$idb];
  252. $table = $boucle->id_table;
  253. $not = ($crit->not ? 'NOT ' : '');
  254. $boucle->where[] = "'$not($table.largeur>0 AND $table.largeur = $table.hauteur)'";
  255. }
  256. /**
  257. * Calcule la vignette d'une extension (l'image du type de fichier)
  258. *
  259. * Utile dans une boucle DOCUMENTS pour afficher une vignette du type
  260. * du document (balise `#EXTENSION`) alors que ce document a déjà une vignette
  261. * personnalisée (affichable par `#LOGO_DOCUMENT`).
  262. *
  263. * @example
  264. * `[(#EXTENSION|vignette)]` produit une balise `<img ... />`
  265. * `[(#EXTENSION|vignette{true})]` retourne le chemin de l'image
  266. *
  267. * @param string $extension
  268. * L'extension du fichier, exemple : png ou pdf
  269. * @param bool $get_chemin
  270. * false pour obtenir une balise img de l'image,
  271. * true pour obtenir seulement le chemin du fichier
  272. * @return string
  273. * Balise HTML <img...> ou chemin du fichier
  274. **/
  275. function filtre_vignette_dist($extension = 'defaut', $get_chemin = false) {
  276. static $vignette = false;
  277. static $balise_img = false;
  278. if (!$vignette) {
  279. $vignette = charger_fonction('vignette', 'inc');
  280. $balise_img = charger_filtre('balise_img');
  281. }
  282. $fichier = $vignette($extension, false);
  283. // retourne simplement le chemin du fichier
  284. if ($get_chemin) {
  285. return $fichier;
  286. }
  287. // retourne une balise <img ... />
  288. return $balise_img($fichier);
  289. }
  290. /**
  291. * Determiner les methodes upload en fonction du env de inc-upload_document
  292. *
  293. * @param string|array $env
  294. * @return array
  295. */
  296. function medias_lister_methodes_upload($env) {
  297. if (is_string($env)) {
  298. $env = unserialize($env);
  299. }
  300. $methodes = array();
  301. // méthodes d'upload disponibles
  302. $methodes = array();
  303. $methodes['upload'] = array('label_lien'=>_T('medias:bouton_download_local'),'label_bouton'=>_T('bouton_upload'));
  304. if((isset($env['mediatheque']) and $env['mediatheque'])){
  305. $methodes['mediatheque'] = array('label_lien'=>_T('medias:bouton_download_par_mediatheque'),'label_bouton'=>_T('medias:bouton_attacher_document'));
  306. }
  307. if((isset($env['proposer_ftp']) and $env['proposer_ftp'])){
  308. $methodes['ftp'] = array('label_lien'=>_T('medias:bouton_download_par_ftp'),'label_bouton'=>_T('bouton_choisir'));
  309. }
  310. $methodes['distant'] = array('label_lien'=>_T('medias:bouton_download_sur_le_web'),'label_bouton'=>_T('bouton_choisir'));
  311. // pipeline pour les méthodes d'upload
  312. $objet = isset($env['objet']) ? $env['objet'] : '';
  313. $id_objet = isset($env['id_objet']) ? $env['id_objet'] : '';
  314. $methodes = pipeline('medias_methodes_upload',
  315. array(
  316. 'args' => array('objet' => $objet, 'id_objet' => $id_objet),
  317. 'data' => $methodes
  318. )
  319. );
  320. return $methodes;
  321. }
  322. function duree_en_secondes($duree, $precis = false) {
  323. $out = "";
  324. $heures = $minutes = 0;
  325. if ($duree>3600) {
  326. $heures = intval(floor($duree/3600));
  327. $duree -= $heures * 3600;
  328. }
  329. if ($duree>60) {
  330. $minutes = intval(floor($duree/60));
  331. $duree -= $minutes * 60;
  332. }
  333. if ($heures>0 or $minutes>0) {
  334. $out = _T('date_fmt_heures_minutes', array('h' => $heures, 'm' => $minutes));
  335. if (!$heures) {
  336. $out = preg_replace(',^0[^\d]+,Uims', '', $out);
  337. }
  338. }
  339. if (!$heures or $precis) {
  340. $out .= intval($duree).'s';
  341. }
  342. return $out;
  343. }
  344. /**
  345. * Trouver le fond pour embarquer un document
  346. * - avec une extension
  347. * - avec un mime_type donne
  348. *
  349. * => modeles/{modele_base}_emb_html.html si il existe
  350. * => modeles/{modele_base}_text_html.html si il existe,
  351. * => modeles/{modele_base}_text.html si il existe,
  352. * => modeles/{modele_base}.html sinon
  353. *
  354. * @param $extension
  355. * @param $mime_type
  356. * @return mixed
  357. */
  358. function medias_trouver_modele_emb($extension, $mime_type, $modele_base='file') {
  359. if ($extension and trouve_modele($fond = $modele_base . '_emb_' . $extension)) {
  360. return $fond;
  361. }
  362. $fond = $modele_base . '_emb_' . preg_replace(',\W,', '_', $mime_type);
  363. if (trouve_modele($fond)) {
  364. return $fond;
  365. }
  366. $fond = $modele_base . '_emb_' . preg_replace(',\W.*$,', '', $mime_type);
  367. if (trouve_modele($fond)) {
  368. return $fond;
  369. }
  370. return $modele_base;
  371. }