Source de cours/lessons.inc

<?

define
('LESSONS_DIR','cours');
define('WITH_ICONS'0);

class 
LessonInfo
{
  var 
$title;
  var 
$url;
  var 
$level;
  var 
$abbr;
  var 
$category;
  var 
$audience;
  var 
$pre;
  var 
$goal;
  var 
$description;
  var 
$keywords;
  var 
$creationDate;
  
  function 
LessonInfo($title$category$url$level$abbr$audience$goal$pre$creationDate$description$keywords)
  {
    
$this->title $title;
    
$this->category $category;
    
$this->url $url;
    
$this->level $level;
    if (
$abbr != "")
    {
      
$this->abbr $abbr;
    }
    else
    {
      
$this->abbr $title;
    }
    
$this->audience $audience;
    
$this->pre $pre;
    
$this->goal $goal;
    
$this->creationDate $creationDate;
    
$this->description $description;
    
$this->keywords $keywords;
  }
}

class 
CategoryInfo
{
  var 
$name;
  var 
$title;
  var 
$icon;
  var 
$abbr;
  var 
$forum;

  function 
CategoryInfo($name$title$icon$forum$abbr "")
  {
    
$this->name $name;
    
$this->title $title;
    
$this->icon $icon;
    
$this->forum $forum;
    if (
$abbr != "")
    {
      
$this->abbr $abbr;
    }
    else
    {
      
$this->abbr $title;
    }    
  }
}

class 
Lessons
{
  var 
$lessonsList;
  var 
$categoriesList;

  function 
Lessons()
  {
    
$this->lessonsList = array (

      
'reseau' => new LessonInfo(
        
'Concepts réseaux',
        
'info',
        
'reseau.php',
        
'*',
        
'',
        
'Utilisateur débutant d\'Internet.',
        
'Permettre de mieux comprendre certains concepts réseaux régissant l\'Internet.',
        array(),
        
'2002-12-01',
        
'Explications sur les concepts réseaux : Principes de base, adresse IP, les ports, DNS.',
        
'concepts, réseau, TCP, IP, client, serveur, port, adresse, DNS, pile, segment, datagramme, routage, TTL, défragmentation, defragmentation, acquittement, timeout, fenêtrage, fenetrage, broadcast, firewall, pare, feu, filtrage, sécurité, securite, REJECT, DROP, ACCEPT, autorité, domaine, hiérarchique, hierarchique, root, server, in-addr.arpa, MTU, FAI, FTP, HTTP, IRC, MX'
      
),

      
'systemes_exploitation' => new LessonInfo(
        
'Systèmes d\'exploitation',
        
'info',
        
'systemes_exploitation.php',
        
'*',
        
'',
        
'Tout utilisateur d\'un ordinateur.',
        
'Expliquer le fonctionnement et les principes d\'un système d\'exploitation.',
        array(),
        
'2002-12-03',
        
'Explications sur les systèmes d\'exploitation : Gestion de la mémoire, du multitâche, interfaces graphiques, pilotes de périphériques.',
        
'système, systeme, exploitation, os, mémoire, memoire, informatique, multitâche, multitache, interface, graphique, pilote, périphérique, peripherique, driver, virtuel, fichier, échange, echange, swap, processeur, ordinateur, time, slice, pc, programme, contexte, coopératif, cooperatif, préemptif, preemptif, gestionnaire, fenêtre, fenetre, bureau, vidéo, video, hardware, abstraction, layer, mode, réel, reel, protégé, protege'
      
),

      
'bases_donnees' => new LessonInfo(
        
'Bases de données',
        
'info',
        
'bases_donnees.php',
        
'*',
        
'',
        
'Non-programmeur ou programmeur débutant.',
        
'Expliquer en quoi consistent les bases de données, leur utilité et la manière de les mettre en oeuvre.',
        array(
'programmation'),
        
'2003-04-17',
        
'Décrire les bases de données et leurs principaux concepts.',
        
'base, donnée, donnee, informatique, programmation, utilisation, intégrité, integrite, table, enregistrement, champ, type, clé, cle, primaire, étrangère, etrangere, relation, relationnel, contrainte, modèle, modele, client, serveur, sql'
      
),

      
'programmation' => new LessonInfo(
        
'Présentation de la programmation',
        
'prog',
        
'programmation.php',
        
'*',
        
'La programmation',
        
'Non-programmeur se demandant en quoi consiste la programmation.',
        
'Expliquer les concepts de base de la programmation. Ne permet pas d\'apprendre à programmer.',
        array(),
        
'2003-01-13',
        
'Explication des concepts de la programmation : Déroulement du développement, les différents types de langages, l\'utilisation des librairies.',
        
'programmation, programmeur, concepts, programmer, informatique, développement, developpement, développer, developper, compilation, compiler, langage, interprété, interprete, compilé, compile, librairie, statique, dynamique, mot, clé, cle, symbole, instruction, fichier, source, cahier, charge, recette, modélisation, modelisation, test, unitaire, projet, régression, regression, coopératif, cooperatif, cvs, uml, assembleur, bug, débuggage, debuggage, déverminage, deverminage, script, .lib, .dll, .so, .a, elf, php, tcl'
      
),

      
'scripts' => new LessonInfo(
        
'Ecrire un shell-script bash sous GNU/Linux',
        
'prog',
        
'scripts.php',
        
'***',
        
'Ecrire un shell-script bash',
        
'Utilisateur avancé de GNU/Linux.',
        
'Expliquer comment écrire des scripts bash qui regrouperont des commandes utiles pour des tâches courantes.',
        array(
'bash'),
        
'2002-12-10',
        
'Ecrire un shell-script bash : La syntaxe, les variables spéciales, la mise en place de tests, de boucles et de fonctions, manipuler les paramètres et les signaux.',
        
'script, shell, bash, gnu, linux, commande, variable, spéciales, speciale, test, structure, contrôle, controle, paramètres, parametre, signal, signaux, fichier, texte, interpréteur, interpreteur, chmod, commentaire, exit, #!, $$, $?, $*, $#, positionnel, positionnelle, expression, if, then, else, fi, elif, instruction, bloc, case, in, esac, boucle, while, until, do, done, tant, que, jusqu, for, shift, décaler, decaler, getopts, paramètre, parametre, kill, trap, parenthèse, parenthese, accolade, fonction, function, return, code, retour, PID, identifiant, processus'
      
),

      
'regexp' => new LessonInfo(
        
'Les expressions régulières',
        
'prog',
        
'regexp.php',
        
'***',
        
'',
        
'Utilisateur ou programmeur GNU/Linux.',
        
'Faire connaître les expressions régulières qui sont très utilisées dans le monde Unix.',
        array(),
        
'2003-01-05',
        
'Explications sur les expressions régulières : Leur fonctionnement, leur syntaxe, l\'utilisation des quantificateurs, classes de caractères et sous-expressions.',
        
'expression, régulière, reguliere, gnu, linux, unix, quantificateur, classe, caractère, caractere, sous, rationnelle, chaîne, chaine, correspond, motif, ou, répété, repete, répétition, repetition, parenthèse, parenthese, accolade, crochet, classe, intervalle, alphanumérique, alphanumerique, alphabétique, alphabetique, espace, tabulation, chiffre, imprimable, minuscule, majuscule, contrôle, controle, ponctuation, espacement, hexadécimal, hexadecimal, variable, positionnelle, ASCII'
      
),

      
'web' => new LessonInfo(
        
'Les langages de programmation pour le web',
        
'prog',
        
'web.php',
        
'*',
        
'Les langages du web',
        
'Tout utilisateur d\'internet.',
        
'Comprendre ce qui se passe pour qu\'une page web puisse s\'afficher.',
        array(
'reseau''programmation'),
        
'2003-05-30',
        
'Description des langages du web : Les différents types, différences entre client et serveur, la mise en forme, les normes.',
        
''
      
),

      
'iptables' => new LessonInfo(
        
'Filtrage réseau et pare-feu avec Netfilter et iptables',
        
'admin',
        
'iptables.php',
        
'***',
        
'Filtrage réseau et pare-feu',
        
'Administrateur réseau GNU/Linux.',
        
'Donner les moyens de configurer un pare-feu Linux en filtrant notamment les ports.',
        array(
'reseau'),
        
'2003-03-28',
        
'Le filtrage réseau avec un noyau Linux 2.4 ou supérieur afin de configurer un pare-feu : Présentation des différents concepts et de l\'outil iptables, exemples pratiques.',
        
'linux, gnu, filtrage, réseau, reseau, pare, feu, firewall, netfilter, iptables, table, chaîne, chaine, cible, test, concordance, exemple, point, accès, acces, hook, fonction, rappel, callback, traitement, module, filter, nat, mangle, règle, regle, prerouting, input, forward, output, postrouting, accept, drop, reject, log, masquerade, dnat, snat, return, utilisateur, politique, défaut, defaut, source, destination, interface, entrée, entree, sortie, paquet, port, état, etat, new, established, related, invalid, icmp, tcp, ip, udp, connexion, ipv4, http, smtp'
      
),

      
'partage_connexion' => new LessonInfo(
        
'Partager une connexion avec iptables et route',
        
'admin',
        
'partage_connexion.php',
        
'***',
        
'Partager une connexion',
        
'Utilisateur moyen de GNU/Linux avec un noyau 2.4 ou supérieur.',
        
'Expliquer comment mettre en place le partage d\'une connexion Internet pour plusieurs machines GNU/Linux.',
        array(
'reseau''iptables'),
        
'2003-03-28',
        
'Comment partager une connexion entre plusieurs machines : Configurer la passerelle et les machines internes.',
        
'partager, partage, connexion, linux, gnu, iptables, passerelle, gateway, internet, machine, serveur, interne, réseau, reseau, adresse, ip, nat, translation, masquerading, masquerade, route, routage, netstat, interface, entrée, entree, sortie, postrouting, prerouting, source, destination, snat, dnat'
      
),

      
'demarrage' => new LessonInfo(
        
'Démarrage d\'un système GNU/Linux',
        
'admin',
        
'demarrage.php',
        
'**',
        
'Démarrage de GNU/Linux',
        
'Utilisateur moyen de GNU/Linux souhaitant mieux contrôler son système.',
        
'Permettre de comprendre et d\'adapter à ses besoins le processus de démarrage d\'un système GNU/Linux.',
        array(
'fichiers''systemes_exploitation''processus'),
        
'2004-12-02',
        
'Le processus de démarrage GNU/Linux : Des explications pour le comprendre et apprendre à personnaliser son système.',
        
'linux, demarrage, démarrage, connexion, niveau, execution, exécution, runlevel, init, noyau, mode, graphique, texte, utilisateur, inittab, chargeur, multiboot, lilo, grub, system v, login, bureau'
      
),

      
'utilisateurs' => new LessonInfo(
        
'Gestion des utilisateurs',
        
'admin',
        
'utilisateurs.php',
        
'**',
        
'',
        
'Administrateur d\'un système multi-utilisateur ou simple utilisateur voulant mieux connaître les mécanismes internes.',
        
'Savoir comment les utilisateurs sont gérés sur un système GNU/Linux.',
        array(
'systemes_exploitation'),
        
'2006-03-03',
        
'La gestion des utilisateurs GNU/Linux : Comprendre leurs rôles et comment les administrer.',
        
'linux, utilisateur, utilisateurs, root, administrer, administrateur, personnel, su, /etc/passwd, /etc/group, useradd, mot, passe, /etc/shadow, identifiant, groupe, nom, shell, fichier, système'
      
),

      
'bash' => new LessonInfo(
        
'Utiliser bash',
        
'linux',
        
'bash.php',
        
'**',
        
'',
        
'Utilisateur de GNU/Linux.',
        
'Présenter bash, le shell par défaut GNU/Linux, et indiquer comment l\'utiliser.',
        array(),
        
'2002-12-05',
        
'Comment utiliser le shell bash : Exécuter une commande, utiliser l\'historique, les variables d\'environnement, les guillemets, les expressions arithmétiques et les redirections.',
        
'bash, linux, gnu, shell, exécuter, executer, commande, historique, variable, environnement, guillemet, simple, double, inversé, inverse, instruction, système, systeme, alias, fonction, positionnelle, intégré, integre, path, type, histfile, histsize, histfilesize, parcourir, haut, bas, rechercher, emacs, touche, flèche, fleche, fléché, affecter, affectation, valeur, echo, export, tableau, pwd, arithmétique, arithmetique, calcul, assignation, entrée, entree, sortie, standard, erreur, redirection, fichier, cat, pipe, tube, tee, flux'
      
),

      
'fichiers' => new LessonInfo(
        
'Gestion des fichiers et permissions',
        
'linux',
        
'fichiers.php',
        
'*',
        
'Gestion des fichiers',
        
'Utilisateur débutant de GNU/Linux.',
        
'Comprendre et manipuler ce qui touche au système de fichiers sous GNU/Linux.',
        array(
'bash'),
        
'2003-05-27',
        
'Gestion des fichiers avec GNU/Linux : Naviguer, manipuler les fichiers et répertoires, comprendre et modifier les permissions, utiliser les liens symboliques et physiques.',
        
'gnu, linux, fichier, gestion, systeme, système, manipuler, naviguer, navigation, arborescence, répertoire, repertoire, permission, lien, physique, symbolique, journalisation, journalisé, journalise, journal, cd, absolu, relatif, relative, courant, CDPATH, pushd, popd, mkdir, rmdir, cp, mv, rm, chown, chgrp, lire, ecrire, écrire, exécuter, executer, ls, notation, symbolique, octale, passwd, sticky, bit, chmod, compteur, référence, reference, ln, ext2fs, ext3fs, utilisateur, propriétaire, proprietaire, groupe, autre, SUID, SGID'
      
),

      
'gnu' => new LessonInfo(
        
'Les outils GNU',
        
'linux',
        
'gnu.php',
        
'**',
        
'',
        
'Utilisateur de GNU/Linux.',
        
'Indiquer quel outil GNU peut correspondre à un besoin.',
        array(
'bash''regexp'),
        
'2003-02-05',
        
'Utiliser les outils GNU pour différents besoins : Rechercher ou modifier une chaîne, traiter des colonnes, parcourir des répertoires, transmettre des paramètres.',
        
'gnu, linux, outil, motif, rechercher, modifier, chaîne, chaine, traiter, colonne, parcourir, répertoire, repertoire, paramètre, parametre, grep, sensible, casse, option, sed, commande, remplacer, cut, séparateur, separateur, champ, tabulation, gawk, interpréteur, interpreteur, FS, tube, pipe, print, BEGIN, END, enregistrement, find, type, user, maxdepth, name, regex, exec, caractère, caractere, accolade, xargs'
      
),

      
'processus' => new LessonInfo(
        
'Gestion des processus',
        
'linux',
        
'processus.php',
        
'**',
        
'',
        
'Utilisateur débutant de GNU/Linux.',
        
'Gérer le multitâche et interagir avec les processus sous GNU/Linux.',
        array(
'systemes_exploitation''bash'),
        
'2003-10-04',
        
'Les processus Linux : les différents types et les moyens d\'interagir avec ceux-ci',
        
'gnu, linux, processus, gestion, intéragir, interagir, état, etat, liste, lister, job, jobs, instance, programme, multitâche, multitache, contexte, environnement, PID, propriétaire, hiérarchie, hierarchie, père, parent, fils, enfant, racine, init, démon, demon, daemon, actif, exécutable, executable, endormi, zombie, ps, top, signal, numéro, signaux, gestionnaire, handler, kill, bash, Running, Stopped, fg, bg, &amp;, %, +, -'
      
)
    );

    
$this->categoriesList = array (
      
'info' => new CategoryInfo('info''Informatique générale''/images/mini_info.png''informatique'),
      
'prog' => new CategoryInfo('prog''Programmation''/images/mini_prog.png''programmation'),
      
'admin' => new CategoryInfo('admin''Administration de GNU/Linux''/images/mini_admin.png''administration''GNU/Linux'),
      
'linux' => new CategoryInfo('linux''Utilisation de GNU/Linux''/images/mini_linux.png''linux''GNU/Linux')
    );
  }

  function 
lessonExists($lessonId)
  {
    return 
array_key_exists($lessonId$this->lessonsList);
  }

  function 
categoryExists($catId)
  {
    return 
array_key_exists($catId$this->categoriesList);
  }

  function 
setSectionContent(&$page)
  {
    if (
WITH_ICONS)
    {
      
$sectionContent = array(
        
"<img class=\"icon\" src=\"/images/mini_blank.png\" alt=\"[Informations]\" />Notations et références" => "references.php"
      
);
    }
    else
    {
      
$sectionContent = array(
        
"Notations et références" => "references.php"
      
);

    }

    
reset($this->lessonsList);
    while (list(
$item$pageDetails) = each($this->lessonsList))
    {
      
$catDetails $this->categoriesList[$pageDetails->category];
      if (
WITH_ICONS)
      {
        
$itemTitle '<img class="icon" src="'.$catDetails->icon.'" alt="['.$catDetails->title.']" />'.$pageDetails->abbr;
      }
      else
      {
        
$itemTitle $pageDetails->abbr;
      }
      
$sectionContent[$itemTitle] = $pageDetails->url;
    }
    
$page->setSectionContent("Cours"$sectionContent);
  }

  function 
getCategoryTitle()
  {
    
$result "";
    if (isset(
$_GET['category']))
    {
      
$category $_GET['category'];
      if (
$category != "all")
      {
        if (
$this->categoryExists($category))
        {
          
$result $this->categoriesList[$category]->title;
        }
        else
        {
          
$result "";
        }
      }
    }
    return 
$result;
  }

  function 
getCategoriesList()
  {
    
$result "";
    while (list(
$catName$catDetails) = each($this->categoriesList))
    {
      
$result .= " <li><a href=\"#$catName\">$catDetails->title</a></li>\n";
    }

    return 
$result;
  }

  function 
getLessonsTOC(&$page)
  {
    
$sortedLessons = array();

    
reset($this->lessonsList);
    while (list(
$item$pageDetails) = each($this->lessonsList))
    {
      
$sortedLessons[$pageDetails->category][$pageDetails->url] = " <dt><a href=\"$pageDetails->url\">$pageDetails->title</a> <span class=\"access-star\">$pageDetails->level</span></dt>\n<dd>$pageDetails->description</dd>\n";
    }

    while (list(
$categoryName$catList) = each($sortedLessons))
    {
      
$category $this->categoriesList[$categoryName];
      if (
WITH_ICONS)
      {
        
$title "<img class=\"icon\" alt=\"\" src=\"$category->icon\" /> $category->title";
      }
      else
      {
        
$title "$category->title";
      }
      
$content '<dl>'."\n";
      while (list(
$lessonUrl$lessonItem) = each($catList))
      {
        
$content .= $lessonItem;
      }
      
$content .= '</dl>'."\n";
      
$page->addChapter($categoryName$title$content);
    }
  }

  function 
getLessonsList()
  {
    
$result "";
    
reset($this->lessonsList);
    while (list(
$item$pageDetails) = each($this->lessonsList))
    {
      
$result .= '     <li><a href="/'.LESSONS_DIR.'/'.$pageDetails->url."\">$pageDetails->title</a></li>\n";
    }
    return 
$result;    
  }
}

class 
LessonHeader
{
  var 
$index;
  var 
$categoryName;
  var 
$categoryTitle;
  var 
$level;
  var 
$audience;
  var 
$pre;
  var 
$goal;

  function 
LessonHeader($index "")
  {
    
$this->index $index;
    
$this->categoryName "";
    
$this->categoryTitle "";
    
$this->level "";
    
$this->audience "";
    
$this->pre = array();
    
$this->goal "";
  }

  function 
setCategory($name$title)
  {
    
$this->categoryName $name;
    
$this->categoryTitle $title;
  }
  function 
setLevel($value)
  {
    
$this->level $value;
  }
  function 
setAudience($value)
  {
    
$this->audience $value;
  }
  function 
addPreReadings($title$href)
  {
    
$this->pre[$title] = $href;
  }
  function 
setGoal($value)
  {
    
$this->goal $value;
  }

  function 
format()
  {
    
$result "";
    
    
$result .= '
  <div class="lesson-header-spacer">
   <table id="lesson-header" summary="Présentation rapide de l\'article permettant de connaître le niveau et les lectures préalables requis">
    <caption>Présentation de ce cours</caption>'
;

    
$result .= '
    <tr>
     <th scope="row" abbr="Rubrique">
      Rubrique&nbsp;:
     </th>
     <td>
      '
;
    
$result .= '<a href="'.$this->index.'#'.$this->categoryName.'" title="Voir les autres articles de la même rubrique">'.$this->categoryTitle.'</a>';
    
$result .= '
     </td>
    </tr>'
;

    
$result .= '
    <tr>
     <th scope="row" abbr="Niveau">
      <a href="index.php#access-legend" title="Explications sur les différents niveaux">Niveau</a>&nbsp;: 
     </th>
     <td>
      <span class="access-star">'
;
    
$result .= $this->level;
    
$result .= '</span>
     </td>
    </tr>'
;

    
$result .= '
    <tr>
     <th scope="row" abbr="Audience">
      Audience&nbsp;: 
     </th>
     <td>
      '
;
    
$result .= $this->audience;
    
$result .= '
     </td>
    </tr>'
;

    
$result .= '
    <tr>
     <th scope="row" abbr="Articles">
      Lectures préalables&nbsp;: 
     </th>
     <td>'
."\n";
    if (
count($this->pre) != )
    {
      
$result .= "      <ul>\n";
      while (list(
$title$href) = each($this->pre))
      {
        
$result .= '       <li><a href="'.$href.'">'.$title.'</a></li>'."\n";
      }
      
$result .= "      </ul>\n";
    }
    else
    {
      
$result .= "      Aucune.\n";
    }
    
$result .= '     </td>
    </tr>'
;

    
$result .= '
    <tr>
     <th scope="row" abbr="But">
      But&nbsp;: 
     </th>
      <td>
       '
;
    
$result .= $this->goal;
    
$result .= '
      </td>
     </tr>'
;

    
$result .= '
    </table>
   </div>
'
;

    return 
$result;
  }
}

class 
LessonPage extends Page {

  var 
$lessons;
  var 
$lessonHeader;
  var 
$info;
  var 
$category;
  
  function 
LessonPage($name)
  {
    
$this->Page();

    
$this->lessons = new Lessons();  

    
$this->setPrintable(true);
    
$this->setHomePage("Retour aux cours","index.php");

    
$this->lessons->setSectionContent($this);

    
$this->info $this->lessons->lessonsList[$name];
    
$this->category $this->lessons->categoriesList[$this->info->category];

    
$this->setDescription($this->info->description);
    
$this->setKeywords($this->info->keywords);

    
$this->setTitle($this->info->title);
    
$this->setCreationDate($this->info->creationDate);

    
$this->lessonHeader = new LessonHeader($this->homePageHref);

    
$this->lessonHeader->setCategory($this->category->name$this->category->title);
    
$this->lessonHeader->setLevel($this->info->level);
    
$this->lessonHeader->setAudience($this->info->audience);
    
$this->lessonHeader->setGoal($this->info->goal);
    foreach (
$this->info->pre as $pre)
    {
      
$lessonInfo $this->lessons->lessonsList[$pre];
      
$this->lessonHeader->addPreReadings($lessonInfo->abbr$lessonInfo->url);
    }

    
$this->setPageTitle($this->info->title);
    
$this->setIntroduction($this->lessonHeader->format());
    
$this->setExtra('<div id="forum-link">Si vous vous posez des questions suite à la lecture de cet article, vous pouvez utiliser le <a href="/forums/'.$this->category->forum.'/">forum '.$this->category->title.'</a></div>');
  }

  function 
displayTitle()
  {
    
$title $this->titlePrefix.$this->title.' - ['.$this->category->abbr.']';
    echo 
' <title> '.$title." </title>\n";
  }

  function 
setContent($newcontent)
  {
    if (
$newcontent != '')
    {
      
$this->content '<h1 id="top">'.$this->info->title."</h1>\n"
      
$this->content .= $this->lessonHeader->format();
      
$this->content .= $newcontent;
      
$this->content .= "<div id=\"forum-link\">Si vous vous posez des questions suite à la lecture de cet article, vous pouvez utiliser le <a href=\"/forums/".$this->category->forum."/\">forum ".$this->category->title."</a></div>\n";
    }
    else
    {
      
$this->content '';
    }
  }
}

?>