Source de lessons.inc

<?

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.',
        'KEYWORDS'
      ),

      '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=\"$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="/cours.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) != 0 )
    {
      $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","/cours.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 = '';
    }
  }
}

?>
| Retour aux sources du site |
| Haut de page |