source: spip-zone/_plugins_/medias_nettoyage/trunk/medias_nettoyage_fonctions.php

Last change on this file was 104409, checked in by teddy.spip@…, 22 months ago
  • Compatibilité SPIP 3.2 ;
  • Up de z.
  • Property svn:executable set to *
File size: 27.9 KB
Line 
1<?php
2
3/**
4 * Fonctions utilitaires du plugin "Nettoyer la médiathèque".
5 *
6 * @plugin     Nettoyer la médiathèque
7 *
8 * @copyright  2014-2017
9 * @author     Teddy Payet
10 * @licence    GNU/GPL
11 */
12if (!defined('_ECRIRE_INC_VERSION')) {
13    return;
14}
15include_spip('base/abstract_sql');
16include_spip('inc/documents');
17include_spip('inc/chercher_logo');
18
19/**
20 * Lister les extensions enregistrées dans la table spip_documents.
21 *
22 * @return array
23 *         Tableau des extensions uniques
24 */
25function medias_lister_extensions_documents()
26{
27    $extensions = array();
28    $extensions_cibles = sql_allfetsel('DISTINCT extension', 'spip_documents');
29    // On vérifie bien qu'on reçoit un tableau.
30    if (is_array($extensions_cibles) and count($extensions_cibles) > 0) {
31        foreach ($extensions_cibles as $extension) {
32            $extensions[] = $extension['extension'];
33        }
34    }
35    // On rajoute le répertoire "vignettes"
36    $extensions[] = 'vignettes';
37    // Sécurité, on enlève les valeurs vides du tableau d'extensions.
38    $extensions = array_filter($extensions);
39    sort($extensions);
40
41    return $extensions;
42}
43
44/**
45 * Créer les répertoires des extensions des documents enregistrés en BDD.
46 *
47 * @uses medias_lister_extensions_documents()
48 * @uses _DIR_IMG
49 *
50 * @param  string $repertoire_img
51 *         Par défaut, on prend _DIR_IMG en référence.
52 *         On peut l'utiliser aussi pour le répertoire IMG/orphelins
53 */
54function medias_creer_extensions_repertoires($repertoire_img = _DIR_IMG)
55{
56    $extensions = medias_lister_extensions_documents();
57
58    if (is_array($extensions) and count($extensions) > 0) {
59        foreach ($extensions as $extension) {
60            if (!is_dir($repertoire_img.$extension)) {
61                @mkdir($repertoire_img.$extension, _SPIP_CHMOD);
62            }
63        }
64    }
65
66    return;
67}
68
69/**
70 * Créer le répertoire "IMG/orphelins".
71 * Plus pratique d'avoir une fonction qu'on appellera en cas de besoin.
72 *
73 * @uses _MEDIAS_NETTOYAGE_REP_ORPHELINS
74 */
75function medias_creer_repertoires_orphelins()
76{
77    if (!is_dir(_MEDIAS_NETTOYAGE_REP_ORPHELINS)) {
78        @mkdir(_MEDIAS_NETTOYAGE_REP_ORPHELINS, _SPIP_CHMOD);
79    }
80
81    return;
82}
83
84/**
85 * Lister les répertoires présents dans IMG/ sans les sous-répertoires.
86 *
87 * @param  string $repertoire_img
88 *         Par défaut, on prend _DIR_IMG en référence.
89 *         On peut l'utiliser aussi pour le répertoire IMG/orphelins ou tout autre nom de répertoire.
90 *
91 * @return array
92 */
93function medias_lister_repertoires($repertoire_img = _DIR_IMG)
94{
95    $repertoires = array();
96    // On vérifie que $repertoire_img passé en paramètre est bien un répertoire existant.
97    // cf. ../IMG/orphelins qui ne serait pas encore créé.
98    if (is_dir($repertoire_img)) {
99        // Avec la fonction scandir, on liste le contenu (existant) du répertoire cible.
100        $rep_img = array_diff(scandir($repertoire_img), array('..', '.', '.svn')); // On ne liste pas le répertoire .svn
101        foreach ($rep_img as $repertoire) {
102            // On vérifie que c'est un répertoire et non un fichier.
103            if (is_dir($repertoire_img.$repertoire)) {
104                $repertoires[] = $repertoire_img.$repertoire;
105            }
106        }
107    }
108    // Sécurité, on enlève les éventuelles valeurs vides du tableau
109    $repertoires = array_filter($repertoires);
110
111    return (array) $repertoires;
112}
113
114/**
115 * Lister tous les fichiers non distants enregistrés en BDD.
116 *
117 * @uses get_spip_doc()
118 *
119 * @return array
120 *         Tableau contenant les urls des fichiers
121 */
122function medias_lister_documents_bdd()
123{
124    $docs_fichiers = array();
125
126    $docs_bdd = sql_allfetsel('fichier', 'spip_documents', "distant='non' AND fichier!=''");
127    // On vérifie que nous avons au moins un élément dans le tableau
128    if (count($docs_bdd) > 0) {
129        foreach ($docs_bdd as $doc) {
130            /*
131             * On formate par rapport au répertoire ../IMG/
132             * On évite les doubles // qu'il peut y avoir
133             */
134            $docs_fichiers[] = get_spip_doc($doc['fichier']);
135        }
136    }
137
138    // On enlève les éventuels doubles slash dans les valeurs du tableau.
139    $docs_fichiers = preg_replace("/\/\//", '/', $docs_fichiers);
140    // Sécurité, on enlève les valeurs vides du tableau
141    $docs_fichiers = array_filter($docs_fichiers);
142    // On trie dans l'ordre alphabétique :
143    sort($docs_fichiers);
144
145    return (array) $docs_fichiers;
146}
147
148/**
149 * Donner la taille en octets des documents non-distants enregistrés en BDD.
150 *
151 * @return int
152 */
153function medias_lister_documents_bdd_taille()
154{
155    $docs_bdd = sql_fetsel('SUM(taille) AS taille_totale', 'spip_documents', "distant='non' AND fichier!=''");
156
157    return $docs_bdd['taille_totale'];
158}
159
160/**
161 * Afficher le nombre de documents enregistrés en BDD.
162 *
163 * @return int|string
164 */
165function medias_lister_documents_bdd_complet_compteur()
166{
167    return sql_countsel('spip_documents');
168}
169
170/**
171 * Donner la taille en octets de tous les documents enregistrés en BDD.
172 *
173 * @return int|string
174 */
175function medias_lister_documents_bdd_complet_taille()
176{
177    $docs_bdd = sql_fetsel('SUM(taille) AS taille_totale', 'spip_documents', 'id_document > 0');
178
179    return $docs_bdd['taille_totale'];
180}
181
182/**
183 * Lister les documents enregistrés en BDD
184 * mais n'ayant plus de fichiers physiques dans IMG/.
185 *
186 * @uses medias_lister_documents_bdd()
187 * @uses medias_lister_documents_repertoire()
188 *
189 * @return array
190 */
191function medias_lister_documents_bdd_orphelins()
192{
193    $docs_bdd = array_unique(array_diff(medias_lister_documents_bdd(), medias_lister_documents_repertoire()));
194    sort($docs_bdd);
195
196    return (array) $docs_bdd;
197}
198
199/**
200 * Donner la taille en octets des documents enregistrés en BDD.
201 *
202 * @uses medias_lister_documents_bdd_orphelins()
203 * @uses _DIR_IMG
204 * @uses get_spip_doc()
205 *
206 * @return int
207 */
208function medias_lister_documents_bdd_orphelins_taille()
209{
210    $docs_orphelins = medias_lister_documents_bdd_orphelins();
211    $taille = 0;
212    $pattern_img = '/'.preg_replace("/\//", "\/", _DIR_IMG).'/';
213
214    if (count($docs_orphelins) > 0) {
215        $docs_bdd = sql_allfetsel(
216            'fichier,taille',
217            'spip_documents',
218            "fichier IN ('"
219            .implode("','", preg_replace($pattern_img, '', $docs_orphelins))."')"
220        );
221        if (is_array($docs_bdd) and count($docs_bdd) > 0) {
222            foreach ($docs_bdd as $document_bdd) {
223                if (!file_exists(get_spip_doc($document_bdd['fichier']))) {
224                    $taille = $taille + ($document_bdd['taille'] / 1000);
225                    // On divise par 1000 pour éviter la limite de l'integer php.
226                }
227            }
228        }
229    }
230
231    return $taille * 1000;
232}
233
234/**
235 * Lister les documents présents dans le répertoire des extensions de IMG/
236 * Ne pas prendre en compte les fichiers 'index.html' et 'robots.txt' qui peuvent être présent.
237 *
238 * @uses medias_lister_extensions_documents()
239 * @uses medias_lister_logos_fichiers()
240 *
241 * @param string $repertoire_img
242 *        On peut passer un nom de répertoire/chemin en paramètre.
243 *        Par défaut, on prend le répertoire IMG/
244 *
245 * @return array
246 */
247function medias_lister_documents_repertoire($repertoire_img = _DIR_IMG)
248{
249    $docs_fichiers = array();
250    // On exclu certains fichiers du traitement
251    $white_list = array($repertoire_img.'index.html', $repertoire_img.'robots.txt');
252
253    // On va parcourir chaque répertoire d'extension de IMG/
254    foreach (medias_lister_extensions_documents() as $extension) {
255        // Par sécurité, on vérifie que l'extension a bel
256        // et bien un répertoire physique
257        if (is_dir($repertoire_img.$extension)) {
258            // On va chercher dans IMG/$extension/*.*
259            $fichiers = glob($repertoire_img."$extension/*.*");
260            // On exclu certains fichiers du répertoire $extension du traitement
261            $white_list[] = $repertoire_img."$extension/index.html";
262            $white_list[] = $repertoire_img."$extension/robots.txt";
263            // On vérifie que c'est bien un tableau, avec au moins un élément.
264            if (is_array($fichiers) and count($fichiers) > 0) {
265                // On ajoute ce qui a été trouvé au tableau $docs_fichiers
266                $docs_fichiers = array_merge($docs_fichiers, $fichiers);
267            }
268        }
269    }
270    // On va chercher dans IMG/*.*
271    $fichiers = glob($repertoire_img.'*.*');
272    // On vérifie que c'est bien un tableau, avec au moins un élément.
273    if (is_array($fichiers) and count($fichiers) > 0) {
274        // On ajoute ce qui a été trouvé au tableau $docs_fichiers
275        $docs_fichiers = array_merge($docs_fichiers, $fichiers);
276    }
277    // La fonction preg_replace peut s'appliquer à un tableau.
278    // Il retournera le tableau nettoyé.
279    $docs_fichiers = preg_replace("/\/\//", '/', $docs_fichiers);
280    $docs_fichiers = array_unique(
281        array_diff(
282            $docs_fichiers,
283            medias_lister_logos_fichiers()
284        )
285    );
286    // On sort du tableau les fichiers qui n'ont pas à être contrôlés.
287    $docs_fichiers = array_diff($docs_fichiers, $white_list);
288    // Sécurité, on enlève les valeurs vides du tableau
289    $docs_fichiers = array_filter($docs_fichiers);
290    sort($docs_fichiers);
291
292    return (array) $docs_fichiers;
293}
294
295/**
296 * Retourner la taille en octets des fichiers physiques présents
297 * dans les répertoires d'extensions de IMG.
298 *
299 * @uses medias_lister_documents_repertoire()
300 * @uses medias_calculer_taille_fichiers()
301 *
302 * @return int
303 */
304function medias_lister_documents_repertoire_taille()
305{
306    return medias_calculer_taille_fichiers(medias_lister_documents_repertoire());
307}
308
309/**
310 * Lister les fichiers physiques présents dans IMG/ mais qui ne sont plus dans la BDD.
311 *
312 * @uses medias_lister_documents_repertoire()
313 * @uses medias_lister_documents_bdd()
314 *
315 * @return array
316 */
317function medias_lister_documents_repertoire_orphelins()
318{
319    $docs_fichiers = array_unique(array_diff(medias_lister_documents_repertoire(), medias_lister_documents_bdd()));
320    sort($docs_fichiers);
321
322    return (array) $docs_fichiers;
323}
324
325/**
326 * Retourner la taille en octets des fichiers physiques orphelins
327 * présents dans les répertoires d'extensions de IMG.
328 *
329 * @uses medias_lister_documents_repertoire_orphelins()
330 * @uses medias_calculer_taille_fichiers()
331 *
332 * @return int
333 */
334function medias_lister_documents_repertoire_orphelins_taille()
335{
336    return medias_calculer_taille_fichiers(medias_lister_documents_repertoire_orphelins());
337}
338
339/**
340 * Lister tous les fichiers contenus dans le répertoire IMG/
341 * y compris les logos.
342 *
343 * @param string $repertoire_img
344 *        On peut passer un nom de répertoire/chemin en paramètre.
345 *        Par défaut, on prend le répertoire IMG/
346 *
347 * @return array
348 */
349function medias_lister_documents_repertoire_complet($repertoire_img = _DIR_IMG)
350{
351    $docs_fichiers = array();
352
353    // On va chercher dans IMG/distant/*/*.*
354    // Exemple : IMG/distant/jpg/nom_fichier.jpg
355    $fichiers = glob($repertoire_img.'*/*/*.*');
356    if (is_array($fichiers) and count($fichiers) > 0) {
357        // On ajoute ce qui a été trouvé au tableau $docs_fichiers
358        $docs_fichiers = array_merge($docs_fichiers, $fichiers);
359    }
360
361    // On va chercher dans IMG/*/*.*
362    // Exemple : IMG/pdf/nom_fichier.pdf
363    $fichiers = glob($repertoire_img.'*/*.*');
364    if (is_array($fichiers) and count($fichiers) > 0) {
365        $docs_fichiers = array_merge($docs_fichiers, $fichiers);
366    }
367
368    // On va chercher dans IMG/*.*
369    // Exemple : IMG/arton4.png
370    $fichiers = glob($repertoire_img.'*.*');
371    if (is_array($fichiers) and count($fichiers) > 0) {
372        $docs_fichiers = array_merge($docs_fichiers, $fichiers);
373    }
374
375    // La fonction preg_replace peut s'appliquer à un tableau.
376    // Il retournera le tableau nettoyé.
377    $docs_fichiers = preg_replace("/\/\//", '/', $docs_fichiers);
378    $docs_fichiers = array_unique($docs_fichiers);
379    sort($docs_fichiers);
380
381    return (array) $docs_fichiers;
382}
383
384/**
385 * Retourner la taille en octets des fichiers physiques présents
386 * dans IMG/.
387 *
388 * @uses medias_lister_documents_repertoire_complet()
389 * @uses medias_calculer_taille_fichiers()
390 *
391 * @param string $repertoire_img
392 *        On peut passer un nom de répertoire/chemin en paramètre.
393 *        Par défaut, on prend le répertoire IMG/
394 *
395 * @return int
396 */
397function medias_lister_documents_repertoire_complet_taille($repertoire_img = _DIR_IMG)
398{
399    return medias_calculer_taille_fichiers(medias_lister_documents_repertoire_complet($repertoire_img));
400}
401
402/**
403 * Lister les logos des objets éditoriaux
404 * Prend en compte les cas particuliers suivants :
405 * - articles (art)
406 * - rubriques (rub)
407 * - sites syndiqués (site)
408 * - auteurs (aut).
409 *
410 * @uses lister_tables_principales()
411 *       liste en spip 3 les tables principales reconnues par SPIP
412 * @uses id_table_objet()
413 *       retourne la clé primiare de l'objet
414 * @uses type_du_logo()
415 *       retourne le type de logo tel que `art` depuis le nom de la clé primaire de l'objet
416 *
417 * @param null|string $mode
418 *        + `null` : stockera dans le tableau tous les logos,
419 *        quelque soit le mode du logo
420 *        + `on` : stockera dans le tableau tous les logos du mode "on"
421 *        + `off` : stockera dans le tableau tous les logos du mode "off"
422 * @param string $repertoire_img
423 *        On peut passer un nom de répertoire/chemin en paramètre.
424 *        Par défaut, on prend le répertoire IMG/
425 *
426 * @return array
427 */
428function medias_lister_logos_fichiers($mode = null, $repertoire_img = _DIR_IMG)
429{
430    include_spip('inc/chercher_logo');
431    include_spip('base/abstract_sql');
432
433    if (intval(spip_version()) == 2) {
434        include_spip('base/connect_sql');
435        $tables_objets = (isset($GLOBALS['tables_principales']))
436        ? array_keys($GLOBALS['tables_principales'])
437        : array('spip_articles',
438            'spip_rubriques',
439            'spip_auteurs',
440            'spip_breves',
441            'spip_documents',
442            'spip_syndic',
443            'spip_mots',
444            'spip_forum',
445            'spip_groupes_mots', );
446    } elseif (intval(spip_version()) == 3) {
447        include_spip('base/objets');
448        $tables_objets = array_keys(lister_tables_principales());
449    }
450    sort($tables_objets);
451
452    global $formats_logos;
453    $docs_fichiers_on = array();
454    $docs_fichiers_off = array();
455
456    // On va chercher toutes les tables principales connues de SPIP
457    foreach ($tables_objets as $table) {
458        // On cherche son type d'objet.
459        // Il y a aussi dans ces objets la référence à `article`,
460        // `rubrique` et `auteur`
461        // Grâce à la fonction `id_table_objet()`, on retrouve le nom de la clé primaire de l'objet.
462        // `type_du_logo()` retourne le type de logo tel que `art` depuis le nom de la clé primaire de l'objet
463        $type_du_logo = type_du_logo(id_table_objet($table));
464
465        // On va chercher dans IMG/$type_du_logo(on|off)*.*
466        // On fait un foreach pour ne pas avoir de
467        // "Pattern exceeds the maximum allowed length of 260 characters"
468        // sur glob()
469        $liste = glob($repertoire_img.'{'.$type_du_logo.'}{on,off}*.*', GLOB_BRACE);
470
471        // Il faut avoir au moins un élément dans le tableau de fichiers.
472        if (is_array($liste) and count($liste) > 0) {
473            foreach ($liste as $fichier) {
474                // ... Donc on fait une regex plus poussée avec un preg_match
475                if (preg_match(
476                    '/('
477                    .$type_du_logo
478                    .")on(\d+).("
479                    .implode('|', $formats_logos)
480                    .')$/',
481                    $fichier,
482                    $r
483                )) {
484                    // On fait une requête sql pour savoir si ce logo a toujours un objet référencé en bdd.
485                    $requete = sql_fetsel('*', $table, id_table_objet($table).'='.$r[2]);
486                    if ($requete) {
487                        $docs_fichiers_on[] = preg_replace("/\/\//", '/', $fichier);
488                    }
489                }
490                if (preg_match(
491                    '/('
492                    .$type_du_logo
493                    .")off(\d+).("
494                    .implode('|', $formats_logos)
495                    .')$/',
496                    $fichier,
497                    $r
498                )) {
499                    $requete = sql_fetsel('*', $table, id_table_objet($table).'='.$r[2]);
500                    if ($requete) {
501                        $docs_fichiers_off[] = preg_replace("/\/\//", '/', $fichier);
502                    }
503                }
504            }
505        }
506    }
507
508    // On va chercher le logo du site.
509    // On force la recherche sur cet élément même si la recherche "classique"
510    // devrait gérer cela initialement…
511    $logos_site = glob($repertoire_img.'{site}{on,off}0.*', GLOB_BRACE);
512    // On évite d'utiliser la fonction `glob()` directement dans le `if` car ça peut créer un bug pour PHP <5.4
513    // S'il n'y a pas de siteon0.ext, `glob()` va retourner un `false`. Donc, on regarde si c'est bien un tableau.
514    // cf. https://contrib.spip.net/Nettoyer-la-mediatheque#forum475712
515    if (is_array($logos_site) and count($logos_site) > 0) {
516        foreach ($logos_site as $logo_site) {
517            if (preg_match(
518                "/(siteon)(\d).("
519                .implode('|', $formats_logos)
520                .')$/',
521                $logo_site
522            )) {
523                $docs_fichiers_on[] = preg_replace("/\/\//", '/', $logo_site);
524            }
525            if (preg_match(
526                "/(siteoff)(\d).("
527                .implode('|', $formats_logos)
528                .')$/',
529                $logo_site
530            )) {
531                $docs_fichiers_off[] = preg_replace("/\/\//", '/', $logo_site);
532            }
533        }
534    }
535
536    // On va lister le logo standard des rubriques : rubon0.ext et ruboff0.ext
537    // cf. https://contrib.spip.net/Nettoyer-la-mediatheque#forum475870
538    $logos_rub_racine = glob($repertoire_img.'{rub}{on,off}0.*', GLOB_BRACE);
539    if (is_array($logos_rub_racine) and count($logos_rub_racine) > 0) {
540        foreach ($logos_rub_racine as $logo_rub_racine) {
541            if (preg_match(
542                "/(rubon)(\d).("
543                .implode('|', $formats_logos)
544                .')$/',
545                $logo_rub_racine
546            )) {
547                $docs_fichiers_on[] = preg_replace("/\/\//", '/', $logo_rub_racine);
548            }
549            if (preg_match(
550                "/(ruboff)(\d).("
551                .implode('|', $formats_logos)
552                .')$/',
553                $logo_rub_racine
554            )) {
555                $docs_fichiers_off[] = preg_replace("/\/\//", '/', $logo_rub_racine);
556            }
557        }
558    }
559    // Sécurité, on enlève les valeurs vides du tableau
560    $docs_fichiers_on = array_filter($docs_fichiers_on);
561    $docs_fichiers_off = array_filter($docs_fichiers_off);
562
563    switch ($mode) {
564        case 'on':
565            $docs_fichiers_on = array_unique($docs_fichiers_on);
566            sort($docs_fichiers_on); // On trie dans l'ordre alphabétique
567            return $docs_fichiers_on;
568            break;
569
570        case 'off':
571            $docs_fichiers_off = array_unique($docs_fichiers_off);
572            sort($docs_fichiers_off); // On trie dans l'ordre alphabétique
573            return $docs_fichiers_off;
574            break;
575
576        default:
577            $docs_fichiers = array_unique(array_merge($docs_fichiers_on, $docs_fichiers_off));
578            sort($docs_fichiers); // On trie dans l'ordre alphabétique
579            return $docs_fichiers;
580            break;
581    }
582}
583
584/**
585 * Retourner la taille en octets des logos présents
586 * dans IMG/.
587 *
588 * @uses medias_lister_logos_fichiers()
589 * @uses medias_calculer_taille_fichiers()
590 *
591 * @param null|string $mode
592 *        + `null` : calculera le poids de tous les logos,
593 *        quelque soit le mode du logo
594 *        + `on` : calculera le poids de tous les logos du mode "on"
595 *        + `off` : calculera le poids de tous les logos du mode "off"
596 *
597 * @return int|string
598 */
599function medias_lister_logos_fichiers_taille($mode = null)
600{
601    return medias_calculer_taille_fichiers(medias_lister_logos_fichiers($mode));
602}
603
604/**
605 * Fonction qui retourne l'id_objet et l'objet à partir du nom du fichier de logo.
606 * C'est un peu le chemin inverse de quete_logo().
607 *
608 * @example
609 *         - logo_vers_objet('arton51.png')
610 *         - [(#LOGO_OBJET|basename|logo_vers_objet)]
611 *
612 * @param  string $fichier
613 *         Nom du fichier du logo sans chemin.
614 *
615 * @return mixed
616 *         - void : s'il n'y a pas de fichier, on ne renvoie rien
617 *         - string : si $info == objet
618 *         - integer : si $info == id_objet
619 *         - array : si $info == null
620 */
621function logo_vers_objet($fichier = null, $info = null)
622{
623    $logo_type_raccourcis = array(
624        'art' => 'article',
625        'rub' => 'rubrique',
626        'aut' => 'auteur',
627        'groupe' => 'groupe',
628    );
629    global $formats_logos;
630
631    if (is_null($fichier)) {
632        return;
633    }
634
635    if (preg_match("/(\w+)(on|off)(\d+).(".implode('|', $formats_logos).')$/', $fichier, $res)) {
636        $id_objet = $res[3];
637        if (array_key_exists($res[1], $logo_type_raccourcis)) {
638            $objet = $logo_type_raccourcis[$res[1]];
639        } else {
640            $objet = $res[1];
641        }
642
643        switch ($info) {
644            case 'objet':
645                return $objet;
646                break;
647
648            case 'id_objet':
649                return $id_objet;
650                break;
651
652            default:
653                return array('objet' => $objet, 'id_objet' => $id_objet);
654                break;
655        }
656    } else {
657        return;
658    }
659}
660/**
661 * Retourne le lien `<a>` vers l'objet, avec le titre.
662 * Fonction basée sur `lien_objet` du plugin médiathèque,
663 * remodelée pour prendre la particularité des logos.
664 *
665 * @param  null|string  $fichier
666 * @param  int $longueur
667 * @param  null|string  $connect
668 *
669 * @return string
670 */
671function logo_generer_url_ecrire_objet_titre($fichier = null, $longueur = 80, $connect = null)
672{
673    if (is_null($fichier)) {
674        return;
675    }
676    $version_spip = intval(spip_version());
677
678    include_spip('inc/liens');
679    $info_objet = logo_vers_objet($fichier);
680    $type = $info_objet['objet'];
681    $id = $info_objet['id_objet'];
682
683    // Si l'id_objet == 0, on est dans un cas particulier.
684    // Nativement, on regarde si objet est une rubrique ou un site.
685    // Si c'est une rubrique, on est sur le logo standard des rubriques
686    // Si c'est un site, on est sur le logo du site SPIP.
687    if ($id == 0) {
688        switch ($type) {
689            case 'rubrique':
690                $exec = ($version_spip == 2) ? 'naviguer' : 'rubriques';
691                $url = generer_url_ecrire($exec);
692                $titre = _T('ecrire:logo_standard_rubrique');
693                break;
694            case 'site':
695                $exec = ($version_spip == 2) ? 'configuration' : 'configurer_identite';
696                $url = generer_url_ecrire($exec);
697                $type = 'site_spip';
698                $titre = _T('ecrire:logo_site');
699                break;
700        }
701    } else {
702        $titre = traiter_raccourci_titre($id, $type, $connect);
703        $titre = typo($titre['titre']);
704        if (!strlen($titre)) {
705            $titre = _T('info_sans_titre');
706        }
707        $url = generer_url_entite($id, $type);
708    }
709
710    return "<a href='$url' class='$type'>".couper($titre, $longueur).'</a>';
711}
712
713/**
714 * Générer l'url de vue d'un objet à partir de son fichier de logo.
715 *
716 * @param  string $fichier
717 *         Nom du fichier du logo sans chemin.
718 *
719 * @return string
720 */
721function logo_generer_url_ecrire_objet($fichier = null)
722{
723    if (is_null($fichier)) {
724        return;
725    }
726    $version_spip = intval(spip_version());
727
728    if ($version_spip == 2) {
729        include_spip('base/connect_sql');
730    } elseif ($version_spip == 3) {
731        include_spip('base/objets');
732    }
733
734    include_spip('inc/urls');
735
736    $info_objet = logo_vers_objet($fichier);
737
738    // Si l'id_objet == 0, on est dans un cas particulier.
739    // Nativement, on regarde si objet est une rubrique ou un site.
740    // Si c'est une rubrique, on est sur le logo standard des rubriques
741    // Si c'est un site, on est sur le logo du site SPIP.
742    if ($info_objet['id_objet'] == 0) {
743        switch ($info_objet['objet']) {
744            case 'rubrique':
745                $exec = ($version_spip == 2) ? 'naviguer' : 'rubriques';
746
747                return generer_url_ecrire($exec);
748                break;
749            case 'site':
750                $exec = ($version_spip == 2) ? 'configuration' : 'configurer_identite';
751
752                return generer_url_ecrire($exec);
753                break;
754        }
755    } else {
756        return generer_url_ecrire(
757            $info_objet['objet'],
758            id_table_objet($info_objet['objet'])
759            .'='
760            .intval($info_objet['id_objet'])
761        );
762    }
763}
764
765/**
766 * Fonction générique pour calculer la taille des fichiers passés en paramètre.
767 *
768 * @param  array  $fichiers
769 *         Tableau contenant l'url des fichiers physiques
770 *
771 * @return int
772 *         On multiplie par 1000 la variable $taille pour avoir le chiffre réel
773 *         C'est un hack pour contourner la limite d'integer (4 bytes => 0xefffffff).
774 *         Au dessus de 4026531839, il passe à float négatif.
775 *         // a vérifier tout de même selon l'OS 32bit ou 64bit.
776 */
777function medias_calculer_taille_fichiers($fichiers = array())
778{
779    $taille = 0;
780    if (count($fichiers) > 0) {
781        foreach ($fichiers as $fichier) {
782            if (file_exists($fichier)) {
783                $taille += filesize($fichier) / 1000;
784            }
785        }
786        if (is_float($taille) or $taille > 0) {
787            return $taille * 1000;
788        } else {
789            return $taille;
790        }
791    } else {
792        return $taille;
793    }
794}
795
796/**
797 * Lister les répertoires à la racine de IMG/orphelins.
798 * Cette fonction vérifie l'existence du répertoire IMG/orphelins
799 * avant de lister les répertoires.
800 *
801 * @uses medias_lister_repertoires()
802 * @uses _MEDIAS_NETTOYAGE_REP_ORPHELINS
803 *
804 * @return array
805 */
806function medias_lister_repertoires_orphelins()
807{
808    if (is_dir(_MEDIAS_NETTOYAGE_REP_ORPHELINS)) {
809        return medias_lister_repertoires(_MEDIAS_NETTOYAGE_REP_ORPHELINS);
810    } else {
811        return array();
812    }
813}
814
815/**
816 * Lister le contenu du répertoire IMG/orphelins.
817 *
818 * @uses medias_lister_documents_repertoire_complet()
819 * @uses _MEDIAS_NETTOYAGE_REP_ORPHELINS
820 *
821 * @return array
822 */
823function medias_lister_repertoires_orphelins_fichiers()
824{
825    $repertoire_orphelins = _MEDIAS_NETTOYAGE_REP_ORPHELINS;
826    $docs_fichiers = array();
827
828    if (is_dir($repertoire_orphelins)) {
829        $docs_fichiers = medias_lister_documents_repertoire_complet($repertoire_orphelins);
830    }
831
832    return (array) $docs_fichiers;
833}
834
835/**
836 * Lister le contenu du répertoire IMG/orphelins.
837 *
838 * @uses medias_calculer_taille_fichiers()
839 * @uses medias_lister_documents_repertoire_complet()
840 * @uses _MEDIAS_NETTOYAGE_REP_ORPHELINS
841 *
842 * @return int
843 */
844function medias_lister_repertoires_orphelins_fichiers_taille()
845{
846    $repertoire_orphelins = _MEDIAS_NETTOYAGE_REP_ORPHELINS;
847    $taille = 0;
848
849    if (is_dir($repertoire_orphelins)) {
850        return medias_calculer_taille_fichiers(medias_lister_documents_repertoire_complet($repertoire_orphelins));
851    } else {
852        return intval($taille);
853    }
854}
855
856/**
857 * Fonction 'bidon' pour tester une fonction rapidement sur la page ?exec=test_medias.
858 *
859 * @return array
860 */
861function test_medias()
862{
863    $test = array();
864    $test = medias_lister_documents_bdd();
865
866    return $test;
867}
868
869/**
870 * Cette fonction vérifie si le fichier est une image ou pas.
871 * On fait un test selon l'existence des fonctions PHP qui peuvent nous aider.
872 * On évite ainsi une alerte PHP.
873 *
874 * @param  string $fichier
875 *         url relative du fichier.
876 *
877 * @return bool
878 */
879function medias_est_image($fichier)
880{
881    $image = false;
882    if (function_exists('exif_imagetype')) {
883        if (is_numeric(exif_imagetype($fichier))) {
884            $image = true;
885        }
886    } elseif (function_exists('getimagesize')) {
887        if (is_array(getimagesize($fichier))) {
888            $image = true;
889        }
890    }
891
892    return $image;
893}
Note: See TracBrowser for help on using the repository browser.