×

Créé une application mobile CRUD avec Python kivy et MySQL

Programmation

Créé une application mobile CRUD avec Python kivy et MySQL

Dans ce tutoriel, on vas mettre en place une application mobile CRUD (Create, Read, Update, Delete) avec Kivy et MySQL. Kivy est une bibliothèque Python puissante pour le développement d’applications multiplateformes, tandis que MySQL est un système de gestion de base de données relationnelle. Ce tutoriel vous guidera à travers les étapes nécessaires pour créer une application mobile CRUD de base en utilisant ces technologies.

Pour suivre ce tutoriel, vous devez avoir Python installé sur votre système et avoir une base de données MySQL configurée et prête à l’emploi. Nous utiliserons également le module mysql.connector pour la communication avec la base de données. Assurez vous de l’installer en utilisant pip install mysql-connector-python.

Étape 1 : Configuration de la Base de Données MySQL

Créez une base de données MySQL avec une table que nous utiliserons pour stocker les données. Par exemple, voici un script SQL pour créer une table « tasks » avec les colonnes « id » (clé primaire), « task_name », et « task_description ».

CREATE DATABASE crud_app;
USE crud_app;

CREATE TABLE tasks (
    id INT AUTO_INCREMENT PRIMARY KEY,
    task_name VARCHAR(255),
    task_description TEXT
);

Étape 2 : Installation de Kivy

Vous devez installer Kivy sur votre système. Vous pouvez le faire en utilisant pip :

pip install kivy

Étape 3 : Création de l’Interface Utilisateur avec Kivy

Créez un fichier Python (par exemple, main.py) pour votre application mobile CRUD. Dans ce fichier, nous allons définir l’interface utilisateur en utilisant Kivy. Voici un exemple de code pour une interface utilisateur simple :

from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button

class CRUDApp(App):
    def build(self):
        layout = BoxLayout(orientation='vertical', padding=20, spacing=10)  # Ajout de padding et d'espacement
        
        self.task_name = TextInput(hint_text='Nom de la tâche', font_size=20)  # Modification de la taille de la police
        self.task_description = TextInput(hint_text='Description de la tâche', font_size=16)
        
        add_button = Button(text='Ajouter une tâche', font_size=18, background_color=(0.2, 0.7, 0.2, 1))  # Couleur de fond du bouton
        
        layout.add_widget(self.task_name)
        layout.add_widget(self.task_description)
        layout.add_widget(add_button)
        
        self.output_label = Label(font_size=18, color=(0, 0, 1, 1))  # Couleur du texte de l'étiquette
        layout.add_widget(self.output_label)
        
        return layout

    def add_task(self, instance):
        # Fonction pour ajouter une tâche à la base de données
        # Utilisez la bibliothèque mysql.connector pour effectuer l'opération d'ajout

if __name__ == '__main__':
    CRUDApp().run()

Dans le code ci-dessus, nous avons créé une interface utilisateur avec des champs de texte pour le nom et la description de la tâche, ainsi qu’un bouton « Ajouter une tâche ». La fonction add_task sera appelée lorsque le bouton est pressé, et elle devra être remplie pour ajouter une tâche à la base de données MySQL.

Étape 4 : Communication avec MySQL

Utilisez le module mysql.connector pour établir une connexion à votre base de données MySQL et effectuer des opérations CRUD. Voici un exemple de code pour ajouter une tâche à la base de données dans la fonction add_task :

import mysql.connector

def add_task(self, instance):
    # Récupérez les données des champs de texte
    task_name = self.task_name.text
    task_description = self.task_description.text

    # Connexion à la base de données MySQL
    db = mysql.connector.connect(
        host='localhost',
        user='root',
        password='',
        database='crud_app'
    )

    cursor = db.cursor()

    # Requête SQL pour insérer la tâche dans la base de données
    insert_query = "INSERT INTO tasks (task_name, task_description) VALUES (%s, %s)"
    data = (task_name, task_description)

    cursor.execute(insert_query, data)
    db.commit()

    self.output_label.text = "Tâche ajoutée avec succès !"

    # Fermez la connexion à la base de données
    cursor.close()
    db.close()

Assurez-vous de bien choisir 'localhost', 'votre_utilisateur_mysql', et 'votre_mot_de_passe_mysql' selon les valeurs appropriées pour votre configuration MySQL.

Étape 5 : Lecture des Tâches depuis la Base de Données

Pour afficher les tâches depuis la base de données, nous pouvons ajouter une nouvelle interface utilisateur pour les lister. Voici comment vous pouvez modifier le code Python de votre application pour le faire :

from kivy.uix.label import Label
from kivy.uix.scrollview import ScrollView

# ...

class CRUDApp(App):
    # ...

    def show_tasks(self):
        # Fonction pour afficher les tâches depuis la base de données
        db = mysql.connector.connect(
            host='localhost',
            user='root',
            password='',
            database='crud_app'
        )
        cursor = db.cursor()

        cursor.execute("SELECT * FROM tasks")
        tasks = cursor.fetchall()

        task_list = ScrollView()
        layout = BoxLayout(orientation='vertical', spacing=10, size_hint_y=None)
        layout.bind(minimum_height=layout.setter('height'))

        for task in tasks:
            task_label = Label(text=f"Nom de la tâche : {task[1]}\nDescription : {task[2]}", size_hint_y=None, height=100)
            layout.add_widget(task_label)

        task_list.add_widget(layout)
        self.root.add_widget(task_list)

        cursor.close()
        db.close()

if __name__ == '__main__':
    CRUDApp().run()

Dans cette étape, nous avons ajouté une nouvelle méthode show_tasks qui récupère toutes les tâches depuis la base de données et les affiche dans une liste déroulante. Nous utilisons un ScrollView pour afficher la liste des tâches, ce qui permet aux utilisateurs de faire défiler la liste si elle devient longue.

Étape 6 : Mettre à Jour et Supprimer des Tâches

Pour mettre à jour et supprimer des tâches, vous pouvez ajouter des boutons « Modifier » et « Supprimer » à côté de chaque tâche dans la liste. Lorsque l’utilisateur appuie sur le bouton « Modifier », vous pouvez afficher un formulaire prérempli avec les détails de la tâche, ce qui permet à l’utilisateur de les modifier. Lorsque l’utilisateur appuie sur le bouton « Supprimer », vous pouvez supprimer la tâche correspondante de la base de données.

– Ajout de Boutons Modifier et Supprimer

Modifiez votre interface utilisateur pour ajouter des boutons « Modifier » et « Supprimer » à côté de chaque tâche dans la liste. Voici comment vous pouvez modifier la fonction show_tasks pour inclure ces boutons :

class CRUDApp(App):
    # ...

    def show_tasks(self):
        # ...

        for task in tasks:
            task_label = Label(text=f"Nom de la tâche : {task[1]}\nDescription : {task[2]}", size_hint_y=None, height=100)

            edit_button = Button(text="Modifier")
            edit_button.bind(on_release=lambda btn, task_id=task[0]: self.edit_task(task_id))

            delete_button = Button(text="Supprimer")
            delete_button.bind(on_release=lambda btn, task_id=task[0]: self.delete_task(task_id))

            task_layout = BoxLayout(orientation='horizontal')
            task_layout.add_widget(task_label)
            task_layout.add_widget(edit_button)
            task_layout.add_widget(delete_button)

            layout.add_widget(task_layout)

Dans ce code, nous avons créé des boutons « Modifier » et « Supprimer » pour chaque tâche, en utilisant des fonctions edit_task et delete_task respectivement. Les boutons sont associés à des actions en utilisant la fonction bind.

– Fonction de Modification

Créez la fonction edit_task pour permettre à l’utilisateur de modifier une tâche existante. Cette fonction devrait afficher un formulaire pré-rempli avec les détails de la tâche sélectionnée et permettre à l’utilisateur de mettre à jour ces détails. Voici un exemple de code :

class CRUDApp(App):
    # ...

    def edit_task(self, task_id):
        # Récupérez les détails de la tâche à modifier depuis la base de données
        db = mysql.connector.connect(
            host='localhost',
            user='root',
            password='',
            database='crud_app'
        )
        cursor = db.cursor()

        cursor.execute("SELECT * FROM tasks WHERE id = %s", (task_id,))
        task = cursor.fetchone()

        cursor.close()
        db.close()

        # Créez une nouvelle interface utilisateur pour la modification
        edit_layout = BoxLayout(orientation='vertical')

        task_name_input = TextInput(text=task[1], hint_text='Nom de la tâche')
        task_description_input = TextInput(text=task[2], hint_text='Description de la tâche')

        save_button = Button(text='Enregistrer')
        save_button.bind(on_release=lambda btn: self.save_task(task_id, task_name_input.text, task_description_input.text))

        edit_layout.add_widget(task_name_input)
        edit_layout.add_widget(task_description_input)
        edit_layout.add_widget(save_button)

        # Remplacez la vue actuelle par la vue de modification
        self.root.clear_widgets()
        self.root.add_widget(edit_layout)

Dans cette fonction, nous récupérons les détails de la tâche à modifier depuis la base de données et créons une nouvelle interface utilisateur pour la modification. Lorsque l’utilisateur appuie sur le bouton « Enregistrer », nous appelons la fonction save_task pour effectuer la mise à jour dans la base de données.

– Fonction de Suppression

Créez la fonction delete_task pour permettre à l’utilisateur de supprimer une tâche existante. Voici un exemple de code :

class CRUDApp(App):
    # ...

    def delete_task(self, task_id):
        # Supprimez la tâche de la base de données
        db = mysql.connector.connect(
            host='localhost',
            user='root',
            password='',
            database='crud_app'
        )
        cursor = db.cursor()

        cursor.execute("DELETE FROM tasks WHERE id = %s", (task_id,))
        db.commit()

        cursor.close()
        db.close()

        # Actualisez la liste des tâches après la suppression
        self.show_tasks()

Dans cette fonction, nous supprimons la tâche correspondante de la base de données et actualisons la liste des tâches pour refléter la suppression.

En ajoutant ces fonctionnalités de modification et de suppression, votre application mobile CRUD devrait permettre aux utilisateurs de gérer leurs tâches de manière plus complète. Assurez-vous de tester soigneusement ces fonctionnalités pour vous assurer qu’elles fonctionnent comme prévu.

Étape 7 : Ajout de Fonctionnalités Avancées

Vous pouvez également ajouter des fonctionnalités avancées à votre application, telles que l’authentification des utilisateurs, la gestion de plusieurs listes de tâches, des filtres, des rappels, et bien plus encore.

Étape 8 : Publication de l’Application

Une fois que votre application mobile CRUD est terminée, vous pouvez la publier sur les app stores (Google Play Store pour Android et Apple App Store pour iOS) en utilisant des outils tels que KivyMD pour obtenir une interface utilisateur plus native et Buildozer pour créer des packages d’installation pour Android.

N’oubliez pas que la sécurité est importante lors du développement d’applications qui interagissent avec une base de données. Assurez-vous de mettre en œuvre des mesures de sécurité appropriées, telles que la validation des données utilisateur, l’utilisation de requêtes préparées pour éviter les injections SQL, et l’utilisation de mots de passe sécurisés.

Ce tutoriel vous donne une base solide pour créer une application mobile CRUD avec Kivy et MySQL. Vous pouvez maintenant personnaliser et étendre l’application en fonction de vos besoins spécifiques et des fonctionnalités que vous souhaitez offrir à vos utilisateurs.

Related Posts

107 commentaires