Blog de réflexion : Mon parcours pour créer une API d'annonces immobilières

Introduction

Lorsque j'ai commencé à créer l'API d'annonces immobilières, je ne savais pas vraiment dans quoi je m'embarquais. En tant que développeur de logiciels débutant, l’idée de développer une API à partir de zéro semblait intimidante. Mais j'avais hâte de me mettre au défi et de mettre à l'épreuve mes connaissances en Python et SQL. Maintenant, en repensant à ce voyage, je suis étonné de tout ce que j'ai appris, non seulement sur le codage, mais aussi sur l'importance de la persévérance, la joie de résoudre des problèmes et le plaisir de voir un projet prendre vie. .

Cet article de blog est une réflexion sur mon expérience dans la création de cette application API d'annonces immobilières pour débutants. Je partagerai les hauts et les bas, les moments d'apprentissage clés et quelques informations techniques utiles sur Python et SQL qui ont rendu ce projet à la fois stimulant et gratifiant.

Le début : apprendre les principes fondamentaux de Python

Mon parcours a commencé avec les fondamentaux de Python. J'ai commencé par apprendre les bases : les types de données, le flux de contrôle, les fonctions et la programmation orientée objet. La simplicité et la lisibilité de Python m'ont permis de comprendre rapidement ces concepts. Cependant, le véritable défi est survenu lorsque j'ai dû appliquer ces principes fondamentaux pour résoudre des problèmes du monde réel.

Comprendre la programmation orientée objet (POO) a été une étape importante. J'ai réalisé qu'en utilisant des classes et des objets, je pouvais créer une manière structurée de gérer différentes entités, telles que les utilisateurs et les propriétés, dans mon API d'annonces immobilières. Cela a jeté les bases de mon projet, dans lequel je devais modéliser des entités du monde réel telles que des utilisateurs, des propriétés et des applications.

Par exemple, dans mon API, j'ai défini un modèle utilisateur à l'aide de classes Python, ce qui m'a aidé à comprendre la relation entre différentes entités et comment elles interagissent au sein d'un système. Voici une version simplifiée de mon modèle utilisateur :

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String, nullable=False)
    email = db.Column(db.String, nullable=False, unique=True)
    password = db.Column(db.String, nullable=False)
    role = db.Column(db.Enum('agent', 'property_owner', 'buyer', name='user_roles'), nullable=False)

    properties = db.relationship('Property', backref='owner', lazy=True)
    applications = db.relationship('Application', backref='applicant', lazy=True)
    favorites = db.relationship('Property', secondary='wishlist', backref='favorited_by', lazy='dynamic')

C'était ma première véritable exposition à la façon dont Python pouvait être utilisé pour représenter des objets du monde réel dans du code, et cela m'a ouvert un tout nouveau monde de possibilités.

Plonger plus profondément : créer l'API immobilière

Une fois que j'ai eu une compréhension de base de Python et de la programmation orientée objet, j'ai décidé de commencer à créer l'API d'annonces immobilières. L'objectif était simple : créer une API qui permet aux propriétaires de répertorier leurs propriétés et aux locataires/acheteurs potentiels de parcourir, postuler et gérer leurs propriétés préférées. Cependant, pour atteindre cet objectif, il fallait bien plus que de simples fondamentaux.

Utilisation de Flask pour le développement d'API RESTful

Flask, un framework Web léger pour Python, est devenu mon outil de prédilection pour créer l'API. J'ai adoré la simplicité et la flexibilité de Flask ; il a fourni juste assez de structure pour m'aider à démarrer sans me submerger d'une complexité inutile.

J'ai commencé par configurer des routes pour gérer différentes méthodes HTTP telles que GET, POST, PATCH et DELETE. Cela m'a permis d'implémenter les opérations de base CRUD (Créer, Lire, Mettre à jour, Supprimer) pour les propriétés, les utilisateurs, les applications et les listes de souhaits. L'une des choses que j'ai rapidement apprises a été l'importance de renvoyer les codes d'état HTTP appropriés avec les réponses. Par exemple, une requête POST réussie devrait renvoyer un statut 201 Créé, tandis qu'une requête pour une ressource inexistante devrait renvoyer 404 Not Found.

Voici un exemple d'itinéraire que j'ai créé pour récupérer une propriété par son ID :

@app.route('/properties/', methods=['GET'])
def get_property(id):
    property = Property.query.get(id)
    if property:
        return jsonify(property_schema.dump(property)), 200
    else:
        return jsonify({'error': 'Property not found'}), 404

Cet extrait m'a aidé à comprendre comment gérer différents scénarios et à garantir que l'API fournissait des commentaires significatifs au client.

Implémentation de SQLAlchemy pour les interactions de bases de données

Une autre partie cruciale de la création de cette API consistait à apprendre à interagir avec la base de données à l'aide de SQLAlchemy, un outil ORM (Object-Relational Mapping) qui relie les classes Python et les bases de données SQL. J'ai choisi SQLAlchemy car il s'intègre bien à Flask et simplifie de nombreux aspects complexes de SQL, comme la création et la gestion des relations entre les tables.

L'un des aspects techniques les plus utiles de SQLAlchemy que j'ai utilisé était la création de relations plusieurs-à-plusieurs. Par exemple, dans mon API immobilière, les utilisateurs peuvent mettre plusieurs propriétés en favoris, et chaque propriété peut être favorite par de nombreux utilisateurs. Pour modéliser cela, j'ai utilisé une table de liens appelée Wishlist pour gérer cette relation plusieurs-à-plusieurs :

wishlist_table = db.Table('wishlist',
    db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
    db.Column('property_id', db.Integer, db.ForeignKey('property.id'), primary_key=True)
)

Cet extrait m'a permis de gérer efficacement les relations utilisateur-propriété sans créer de données redondantes. En utilisant les fonctions de relation de SQLAlchemy, j'ai pu facilement interroger et gérer ces connexions.

Sérialisation avec Flask-Marshmallow

Une autre expérience d'apprentissage importante a consisté à utiliser Flask-Marshmallow pour sérialiser mes modèles SQLAlchemy au format JSON. La sérialisation convertit les types de données complexes dans un format pouvant être facilement transféré sur le réseau, ce qui est essentiel pour la création d'API. J'ai utilisé des schémas Marshmallow pour définir comment mes modèles doivent être convertis en JSON. Voici un exemple de schéma pour mon modèle de propriété :

class PropertySchema(ma.SQLAlchemyAutoSchema):
    class Meta:
        model = Property
        load_instance = True

property_schema = PropertySchema()
properties_schema = PropertySchema(many=True)

L'utilisation de Marshmallow a simplifié le processus de conversion de mes modèles en JSON, me permettant ainsi de me concentrer sur la création des fonctionnalités de base de l'API.

Rétrospective : réflexion sur le voyage

Avec le recul, je me rends compte du chemin parcouru en peu de temps. Quand j'ai commencé, je connaissais à peine les bases de Python. Maintenant, j'ai construit une API à part entière qui utilise Flask, SQLAlchemy et Marshmallow, et j'ai une compréhension beaucoup plus approfondie du développement Web.

L'un des aspects les plus gratifiants de ce voyage a été le sentiment de résoudre des problèmes. Chaque message d'erreur, chaque bug et chaque comportement inattendu m'a appris quelque chose de nouveau. Qu'il s'agisse de comprendre pourquoi une route ne fonctionnait pas, de déboguer un problème de connexion à une base de données ou d'apprendre à gérer correctement CORS, chaque défi m'a aidé à grandir en tant que développeur.

Mais la leçon la plus importante que j'ai apprise est peut-être la valeur de la persévérance. Il y a eu des moments où je me sentais coincé ou frustré, mais j’ai continué à avancer. J'ai appris à diviser les problèmes en éléments plus petits et plus faciles à gérer et à les résoudre un par un.

Un aperçu technique utile : configuration Flask CORS

Un aspect technique que j'ai trouvé particulièrement utile était la configuration du partage de ressources cross-origine (CORS) dans mon application Flask. CORS est crucial pour permettre aux applications Web hébergées sur différents domaines de communiquer entre elles. Dans mon cas, cela a permis au frontend (construit avec React) de faire des requêtes à l'API backend sans être bloqué par la politique de même origine du navigateur.

Voici comment configurer CORS dans mon application Flask :

from flask_cors import CORS

app = Flask(__name__)
CORS(app)

En ajoutant simplement CORS(app), j'ai activé les requêtes d'origine croisée pour toutes les routes de mon application, ce qui a rendu l'intégration entre mon frontend et mon backend beaucoup plus fluide. Il s'agit d'une fonctionnalité petite mais puissante que tout développeur Web devrait connaître.

Conclusion

La création de l'API d'annonces immobilières a été une expérience difficile mais extrêmement enrichissante. J'ai beaucoup appris sur Python, SQL et le développement Web, et je me sens beaucoup plus confiant dans mes capacités en tant que développeur. Je suis ravi de continuer à construire, à apprendre et à grandir dans ce domaine, et j'ai hâte de voir ce que l'avenir nous réserve.

Pour tous ceux qui débutent, mon conseil est simple : continuez à apprendre, continuez à expérimenter et n'ayez pas peur de faire des erreurs. Chaque défi est une opportunité de croissance et chaque projet est une étape en avant dans votre parcours en tant que développeur.

https://github.com/migsldev/real-estate-api