Création d'un site d'hébergement de fichiers avec CodeIgniter

J'ai vu quelques tutoriels d'introduction à Codeigniter et j'espérais vous montrer quelque chose d'un peu plus avancé. Ce tutoriel vous montrera comment créer une application Web puissante pour l'hébergement d'images, en utilisant la flexibilité de Codeigniter. Ce didacticiel devrait vous expliquer la philosophie de codage MVC, essentielle à la production d’applications réparables..

Étape 1: Configuration

Avant de nous rapprocher du code, nous devons faire quelques réglages. Lancez votre éditeur de base de données préféré (j'utiliserai SQLBuddy) et créez une nouvelle base de données appelée "uploadr". À l'intérieur de celui-ci, créez deux tableaux: «utilisateurs» et «fichiers». Configurez les utilisateurs pour qu'ils aient une colonne "id" à clé primaire et à numérotation automatique, ainsi que deux colonnes varchar: "mot de passe" et "nom d'utilisateur". La table des fichiers nécessite une autre colonne 'id' (toujours une clé primaire et une numérotation automatique), ainsi qu'une colonne entière 'propriétaire' et une colonne varchar 'nom'.

Comme ce tutoriel est axé sur l’apprentissage de la programmation Codeigniter et sur MVC, nous allons renoncer à tout ce qui concerne le style (comme CSS, photoshop). À cette fin, j'ai créé une installation Codeigniter personnalisée pour vous, avec tous les fichiers créés et les vues (principalement) HTML-d et CSS-d. Les deux éléments à modifier sont les paramètres de configuration et de base de données. J'ai même inclus un timbre "Beta", donc ça ressemblerait encore plus à un web-startup!

Étape 2: Inscription

Maintenant sur le premier morceau de viande! Ouvrez le contrôleur 'login.php' et créez une fonction appelée 'register'. Cela va contrôler tout le processus d'inscription. Tout d’abord, nous devons vérifier si des demandes POST ont été envoyées au serveur. Dans ce cas, cela signifiera que quelqu'un essaie de s'inscrire. Nous pouvons le faire en vérifiant si $ _POST ['nom d'utilisateur'] est défini. Si tel est le cas, nous savons que quelqu'un a essayé de s'enregistrer et peut le saisir dans la base de données..

 function register () if (isset ($ _PART ['nomutilisateur']])) // l'utilisateur a essayé de s'enregistrer, insérez-les dans la base de données. $ username = $ _POST ['username']; $ password = $ _POST ['password']; $ this-> users-> register ($ nom d'utilisateur, $ mot de passe); redirect ('login');  else // L'utilisateur n'a pas essayé de s'inscrire, affiche les informations d'enregistrement. $ this-> load-> view ('register'); 

Si l'utilisateur n'a pas encore essayé de s'enregistrer, il le détecte et les envoie automatiquement à la vue "Registre" que j'ai codée pour vous. Vous remarquerez la ligne:

$ this-> users-> register ($ nom d'utilisateur, $ mot de passe);

Ceci appelle la fonction 'register' dans le modèle 'users'. Pour le moment, cela ne fonctionnera pas car nous n’avons pas chargé le modèle. Nous procédons de la même manière que lors du chargement de vues, mais comme nous allons utiliser ce modèle de manière extensive dans toute cette classe, nous le chargerons dans la fonction constructeur (la fonction portant le même nom que la classe), de sorte qu'elle toujours chargé et disponible:

fonction Login () parent :: Controller (); $ this-> load-> model ('utilisateurs'); 

Vous êtes probablement intéressé par le contenu de la fonction d'enregistrement. Eh bien, il utilise simplement quelques fonctions d'enregistrement actives de Codeigniter, qui permettent la manipulation de bases de données. Le principal avantage de l'utilisation des fonctions d'enregistrement actives intégrées de Codeigniter (outre le fait qu'elles sont simples et agréables) est qu'elles sont indépendantes de la base de données: vous pouvez facilement basculer entre différents types de base de données (par exemple, mySQL, SQLite). Fichier de configuration DB sans affecter l'application. Dans le cas de notre inscription, nous ajoutons une entrée à la table des utilisateurs. Créez cette fonction dans le modèle 'users.php':

fonction register ($ nom d'utilisateur, $ mot de passe) $ nouveau_utilisateur = array ('nom d'utilisateur' => $ nom d'utilisateur, 'mot de passe' => $ mot de passe); $ this-> db-> insert ('utilisateurs', $ new_user); retourne vrai; 

Les seules choses à noter dans la vue d'enregistrement sont les fonctions site_url () et base_url (). Ceux-ci donnent respectivement l'URL de votre site avec et sans le suffixe index.php. Leur plus grand avantage est que vous pouvez modifier la structure des URL de votre site sans avoir à passer par tous les liens: il suffit d’un changement dans votre fichier de configuration..

Une fois que tout cela est configuré, nous pouvons essayer d’enregistrer un compte. La fonction de notre contrôleur doit nous rediriger vers la page de connexion après la création de notre compte..

Étape 3: Connexion

Maintenant que nous avons quelques utilisateurs configurés, nous avons besoin d’un moyen de les laisser entrer sur le site. Pour cela, nous allons utiliser la classe sessions de Codeigniter. Bien que cela utilise en fait des cookies, cela fonctionne de manière très similaire aux sessions PHP normales, mais avec plus d'options (je vous recommande de consulter le guide d'utilisation)..

Pour commencer, nous devons créer la fonction sur laquelle le bouton de connexion pointe actuellement, «Go». Cette fonction devra collecter les informations que le formulaire a soumises, puis les comparer à la base de données à l'aide d'un modèle. Si tout est correct, il va commencer une session et rediriger l'utilisateur vers leurs fichiers. S'ils ont mal saisi leurs informations, ils seront redirigés vers la page de connexion.

fonction go () $ username = $ _POST ['username']; $ password = $ _POST ['password']; // Renvoie l'ID utilisateur en cas de succès, false en cas d'échec. $ Results = $ this-> users-> login ($ username, $ password); if ($ results == false) redirect ('login'); else $ this-> session-> set_userdata (array ('userid' => $ results)); redirect ('profil'); 

Certaines parties de cette fonction doivent vous paraître très familières à partir de la fonction register: celle-ci recueille $ username et $ password, avant de les soumettre à un modèle (cette fois-ci 'login'). Après cela cependant, les différences commencent à apparaître.

Il vérifie ensuite si la connexion a échoué. Si tel est le cas, l'utilisateur est redirigé vers la page de connexion. Toutefois, si la connexion aboutit, le script crée une session en définissant "ID utilisateur" sur l'identifiant de l'utilisateur. Tout ce dont nous avons besoin maintenant pour que le script de connexion fonctionne est le modèle. Ajoutez cette fonction au modèle 'utilisateurs' utilisé précédemment:

login de fonction ($ nom d'utilisateur, $ mot de passe) $ requête = $ ceci-> db-> get_where ('utilisateurs', array ('nom d'utilisateur' => $ nom d'utilisateur, 'mot de passe' => $ mot de passe)); if ($ query-> num_rows () == 0) renvoie false; else $ result = $ query-> result (); $ first_row = $ result [0]; $ userid = $ first_row-> id; return $ userid; 

Un bref aperçu: tout d'abord, il interroge la base de données à la recherche d'utilisateurs possédant exactement le même nom d'utilisateur et le même mot de passe. S'il n'en trouve pas, le nombre de lignes sera 0 et la fonction renvoie false. Si quelqu'un a été trouvé, il utilise une autre fonction d'enregistrement active de Codeigniter pour le charger en tant qu'objet. Cet objet se présente sous la forme d'un tableau de lignes de base de données, chacune contenant un objet contenant les informations de cette ligne. Puisque nous voulons la première et unique ligne, nous la retirons de $ result, puis nous lui renvoyons l'identifiant.

Nous devrons vérifier si l'utilisateur est connecté depuis la page de profil. Pour ce faire, nous insérons simplement deux lignes de code dans le constructeur du contrôleur de profil. Cela vérifiera que la session contient un ID utilisateur. Si ce n'est pas le cas, redirigez-vous vers la page de connexion. Si c'est le cas, tout va bien, et cela devient une variable publique. Pendant que nous changeons le constructeur, nous allons charger les deux modèles dont nous aurons besoin pour la page de profil:

fonction Profile () parent :: Controller (); $ this-> load-> model ('utilisateurs'); $ this-> load-> model ('fichiers'); $ this-> userid = $ this-> session-> userdata ('userid'); if (! isset ($ this-> userid) ou $ this-> userid == ") redirect ('login');

La dernière chose à faire est de permettre la déconnexion. Ceci est réalisé en définissant simplement l'ID utilisateur à rien, en le supprimant. Une seule fonction suffit:

fonction logout () $ this-> session-> set_userdata (array ('userid' => ")); redirect ('login');

Étape 4: Visualiser et télécharger des fichiers

À ce moment-là, nous venons de nous connecter pour la première fois. Avec quoi sommes-nous accueillis?

Pas mal, pas mal, bien que cet exemple de fichier ne soit pas généré à partir de notre base de données, il est statique. Nous allons bientôt corriger cela, mais nous devons d'abord modifier les autorisations du dossier 'fichier' afin que Codeigniter puisse lire et écrire dessus. Je l'ai changé en 777 Permissions:

Maintenant que c'est réglé, revenons au codage! Nous devons charger tous les fichiers des utilisateurs en dehors de la base de données, et pour ce faire, nous aurons besoin de…

… un modèle! Cependant, cette fois, nous allons le créer dans le modèle 'files.php', nous allons donc séparer notre table utilisateur et notre table fichier. Insérer cette fonction:

fonction get ($ userid) $ query = $ this-> db-> get_where ('files', array ('propriétaire' => $ userid)); return $ query-> result (); 

Cela s’appuie à nouveau sur les sections précédentes de ce didacticiel. Vous devriez donc pouvoir le comprendre. En gros, il récupère toutes les lignes où le propriétaire = l'identifiant de l'utilisateur et les renvoie dans un joli tableau d'objets. Créons quelque chose dans le contrôleur 'profiles' pour s'y connecter et transmettre les informations à la vue. Modifier la fonction index avec ceci:

function index () $ data ['files'] = $ this-> files-> get ($ this-> userid); $ this-> load-> view ('profil', $ data); 

Encore une fois, une fonction très simple. Il prend les résultats qui lui sont transmis à partir du modèle de fichiers et les empaquetera dans la vue. Codeigniter transmet les données à la vue généralement via un tableau (dans ce cas, les données). Le tableau sera alors automatiquement éclaté en un grand nombre de variables. Ainsi, lorsque vous accéderez à la vue, il pourra accéder aux résultats de la base de données via $ file plutôt que $ data ['fichier']. Mettons cette belle base de données dans la vue! Collez ceci dans 'profile.php', en remplaçant le code que le commentaire HTML vous indique de.

 
 nom?> 
 des dossiers/name?> "> Voir id)?> "> Supprimer 
 
 

La boucle foreach charge chaque ligne du tableau et la rend accessible via l’objet $ file. Nous utilisons ensuite l'exemple de "section" comme modèle pour renseigner tous les liens et le nom avec les informations relatives au nouvel objet $ file. Nous verrons plus tard comment la fonction de suppression fonctionne et comment fonctionne le lien de vue après avoir téléchargé quelque chose..

Si vous ouvrez ceci dans votre navigateur maintenant, vous ne verrez rien. C'est parce que nous n'avons aucun fichier téléchargé! Eh bien, nous devons rectifier cela, nous devrons donc créer un formulaire de téléchargement. Faisons le contrôleur en premier; ouvrez 'profile.php' et ajoutez cette fonction:

function upload () if (isset ($ _FICHIERS ['fichier']))) $ file = read_file ($ _FILES ['fichier'] ['nom_mpc']]); $ name = nom_base ($ _FICHIERS ['fichier'] ['nom']); write_file ('files /'.$ name, $ file); $ this-> files-> add ($ name); redirect ('profil');  else $ this-> load-> view ('upload'); 

Cette fonction ajoute de nombreuses nouveautés: notamment la gestion des fichiers de Codeigniter. Cela commence tout simplement en vérifiant si un formulaire a été soumis en recherchant un fichier. Si le fichier n'existe pas, il affiche simplement la vue de téléchargement (que nous mettrons à jour ensuite). Si le fichier existe, alors il extrait lit le fichier temporaire que le serveur a généré. Le répertoire du fichier temporaire peut être trouvé à $ _FILES ['votre_fichier'] [' tmp_name '], et le fichier peut être lu à partir de ce répertoire par le read_file de Codeigniter. Cela charge toutes les informations sur les fichiers dans la variable $ file.

La ligne suivante obtient le nom du fichier à partir de la variable globale $ _FILES de la même manière que pour obtenir le répertoire temporaire. Armé de ces deux informations, codeigniter écrit le fichier dans le dossier files du même répertoire que son fichier d’index. Enfin, le fichier doit être ajouté à la base de données. Encore une fois, nous y allons avec un modèle, cette fois, la fonction "ajouter" dans les "fichiers". Nous verrons comment cela fonctionnera dans quelques minutes, mais nous devons maintenant créer le formulaire de téléchargement dans la vue. Ajoutez ceci là où le commentaire HTML de 'upload.php vous indique de:

 
 
 Fichier:  
 
 
Avant de télécharger, consultez
les conditions d'utilisation.
 
  
 
 

Remplacez le code HTML actuel par ceci. La chose importante à noter ici est que lorsque nous téléchargeons des fichiers, nous utilisons un type d'entrée = fichier, ce qui nous permet de choisir un fichier à télécharger. De plus, nous devons spécifier un enctype dans notre balise de formulaire, afin que le serveur sache qu'il reçoit un fichier et le sauvegarde. Pas très intéressant pour nous, mais toujours crucial! Regardons rapidement ce que nous avons créé:

Nous passons maintenant au dernier élément du script de téléchargement de fichier, le modèle. Cela ajoute le fichier à la base de données, avec son nom et son propriétaire, afin que le serveur sache quels fichiers appartiennent à qui. Nous allons jeter un coup d'oeil; ajoutez ceci à votre modèle 'fichiers':

fonction add ($ file) $ this-> db-> insert ('files', array ('propriétaire' => $ this-> session-> userdata ('userid'), 'name' => $ file)) ; 

En utilisant à nouveau la fonctionnalité d'enregistrement actif de Codeigniter, nous ajoutons une ligne à la base de données avec le nom du fichier et le propriétaire. Nous obtenons le propriétaire en trouvant l'ID utilisateur à partir des données de session que nous avons enregistrées précédemment lors de la connexion. En résumé, une fonction très simple. Essayons de télécharger une belle photo, hein?

Et voilà!

En regardant dans le dossier 'files', nous voyons que le fichier que nous avons chargé y est apparu, comme par magie (Codeigniter magic!), Et nous voyons pourquoi le lien de vue fonctionne, puisqu'il pointe simplement directement sur le fichier dans le répertoire . Ceci fait, il ne reste plus que ce fichier à supprimer des fichiers..

Étape 5: Suppression de fichiers

Ok, le dernier bit. Cela ne devrait pas prendre trop de temps, car vous pourrez utiliser les idées que vous avez apprises plus tôt pour comprendre cela. Nous allons d'abord ajouter ce code à notre contrôleur 'profiles':

function delete ($ id) // Ceci supprime le fichier de la base de données avant de renvoyer le nom du fichier. $ name = $ this-> files-> delete ($ id); unlink ('files /'.$ name); redirect ('profil'); 

Et ce code à notre modèle 'fichiers':

function delete ($ fileid) $ query = $ this-> db-> get_where ('files', array ('id' => $ fileid)); $ result = $ query-> result (); $ query = $ this-> db-> delete ('files', array ('id' => $ fileid)); return $ result [0] -> name; 

Le premier contrôleur devrait être très facile à comprendre. Il appelle la fonction delete du modèle de fichiers (que nous avons défini en même temps), qui génère le nom du fichier. Il utilise ensuite une fonction PHP de base pour supprimer le fichier portant ce nom dans le répertoire files. Enfin, il renvoie au profil des utilisateurs (qui est maintenant moins un fichier).

Le modèle est légèrement plus complexe. Il doit renvoyer le nom du fichier et le supprimer. Il interroge donc la base de données pour obtenir les détails du fichier. Il charge ceci dans la variable $ result, puis supprime le fichier. Il renvoie ensuite la colonne 'name' de la première ligne du tableau (la seule ligne renvoyée par la requête), qui est ensuite utilisée dans le contrôleur ci-dessus..

Essayons de supprimer une fonction:

Et cliquez sur supprimer…

Hourra! Ça a marché. Je suppose que nous avons tous fini alors!

Dernières pensées

Supprimer les fichiers

Bien sûr, ce code ne devrait pas être exécuté sur un serveur sans quelques améliorations sérieuses. Voici quelques problèmes majeurs avec cela:

• Les mots de passe ne sont pas cryptés. Cela signifie que si quelqu'un devait pénétrer dans votre base de données, il serait capable de voler toutes les données de vos utilisateurs avec un minimum d'effort. Comme je suis sûr que vous serez tous d'accord: pas bien. Cela pourrait facilement être résolu en ajoutant un simple hachage aux mots de passe.
• Les fichiers ne sont pas privés. Un utilisateur peut vouloir s'assurer que les fichiers qu'il télécharge ne sont visibles que par lui, et non par quelqu'un qui devine simplement un tas d'URL. Cela nécessiterait probablement un autre contrôleur pour servir les fichiers (qui vérifie les données de session).
• Le script ne vérifie pas que des fichiers existent avant d'écrire des fichiers. Cela pourrait provoquer des conflits avec vos fichiers ou entraîner l’écrasement des données de fichier. Quoi qu'il en soit: pas bon. Cela pourrait être résolu avec une simple vérification de base de données pour s'assurer que le fichier n'a pas été pris, et pourrait être minimisé en donnant aux utilisateurs leurs propres répertoires dans le dossier de fichiers..
• Aucune erreur n'est générée. Cela n’aide pas exactement l’utilisateur à découvrir ce qu’il fait mal, et bien que ce ne soit pas (trop) un problème sur un site aussi petit avec des actions aussi limitées, il pourrait encore être amélioré.

Globalement, vous avez créé une petite application Web assez puissante, en raison notamment de la petite quantité de code que vous avez dû écrire. En raison de la nature de Codeigniter, il est assez facile de l'étendre, à la fois pour résoudre les problèmes ci-dessus et pour ajouter de nouvelles fonctionnalités, telles que le changement de nom de fichiers. J'espère également que ce tutoriel vous a appris à utiliser les concepts MVC et leur puissance: en ajustant simplement les modèles de notre application, nous pouvons échanger notre base de données contre des fichiers texte, XML ou autre, et en modifiant les vues , nous pouvons complètement re-thème sans casser la fonctionnalité. Incroyable!

• Abonnez-vous au flux RSS NETTUTS pour plus de commentaires et d'articles sur le développement Web au quotidien.