SwipeLive - Application de Live Shopping

📱 À propos

SwipeLive était une application mobile innovante de live shopping, permettant aux vendeurs de présenter leurs produits en direct et aux acheteurs d'interagir et d'acheter en temps réel. Le projet combinait l'expérience immersive du streaming en direct avec la simplicité du commerce électronique.

État du projet : Application fonctionnelle, levée de fonds signée (250k €), arrêt du projet avec l'arrivée de TikTok Shop en France.

Composants du projet :

• Backend : API RESTful & WebSocket développée avec Symfony 6.4 (github.com/juuulienr/swipelive)
• Frontend mobile : Application développée avec Capacitor et Vue.js 3 (github.com/juuulienr/swipelive-app)

🚀 Fonctionnalités

• Live Streaming

  • Diffusion en direct via Agora
  • Chat en temps réel avec Pusher
  • Interactions vendeur-acheteur en direct

• Gestion des Produits

  • Catalogue de produits
  • Gestion des stocks en temps réel
  • Présentation des produits pendant le live

• Paiements Sécurisés

  • Intégration Stripe
  • Transactions sécurisées
  • Historique des commandes

• Authentification et Sécurité

  • JWT pour l'authentification API
  • Firebase pour l'authentification utilisateur
  • Gestion des rôles (acheteurs, vendeurs, administrateurs)

• Gestion des Médias

  • Cloudinary pour la gestion des médias
  • Traitement vidéo avec FFmpeg
  • Stockage AWS S3

🛠 Technologies Utilisées

• Backend

  • Symfony 6.4
  • PHP 8.2
  • Doctrine ORM
  • JWT Authentication
  • PostgreSQL

• Services Cloud

  • AWS S3 pour le stockage
  • Cloudinary pour les médias
  • Firebase pour l'authentification
  • Pusher pour le temps réel
  • Stripe pour les paiements
  • Agora pour le streaming vidéo

• Monitoring

  • Bugsnag pour le suivi des erreurs
  • Logs personnalisés

📋 Prérequis

Installation Classique

• PHP 8.2 ou supérieur
• Composer
• PostgreSQL
• FFmpeg

Installation avec Docker (Recommandée)

• Docker
• Docker Compose

🚀 Installation

Option 1 : Installation avec Docker (Recommandée)

1. Cloner le projet

   git clone https://github.com/votre-username/swipelive.git
   cd swipelive

2. Créer le fichier d'environnement

   # Créez un fichier .env avec la configuration suivante :
   DATABASE_URL="postgresql://symfony:symfony@database:5432/swipelive?serverVersion=15&charset=utf8"
   APP_ENV=dev
   APP_SECRET=your-secret-key-here

3. Générer les certificats SSL (pour HTTPS)

   cd docker/nginx/ssl
   ./generate-ssl.sh
   cd ../../..

4. Lancer les conteneurs Docker

   docker-compose up -d --build

5. Installer les dépendances

   docker-compose exec app composer install

6. Créer la base de données et exécuter les migrations

   docker-compose exec app php bin/console doctrine:database:create
   docker-compose exec app php bin/console doctrine:migrations:migrate

7. Accéder à l'application

   • Site web HTTPS : https://127.0.0.1:8000 (recommandé pour les requêtes API)
   • Site web HTTP : http://localhost:8080 (redirigé vers HTTPS)
   • Base de données PostgreSQL : localhost:5433

   Note : Les certificats SSL sont auto-signés. Lors de la première connexion HTTPS, vous devrez accepter l'avertissement de sécurité dans votre navigateur ou votre client HTTP.

Commandes Docker utiles

# Voir les logs en temps réel
docker-compose logs -f

# Accéder au conteneur de l'application
docker-compose exec app bash

# Exécuter des commandes Symfony
docker-compose exec app php bin/console [commande]

# Arrêter les conteneurs
docker-compose down

# Redémarrer les conteneurs
docker-compose up -d

Option 2 : Installation Classique

1. Cloner le projet

   git clone https://github.com/votre-username/swipelive.git
   cd swipelive

2. Installer les dépendances

   composer install
   npm install # ou yarn install

3. Configuration de l'environnement

   cp .env.example .env
   # Configurez les variables d'environnement dans .env

4. Configuration de la base de données

   php bin/console doctrine:database:create
   php bin/console doctrine:migrations:migrate

5. Générer les clés JWT

   mkdir -p config/jwt
   openssl genpkey -out config/jwt/private.pem -aes256 -algorithm rsa -pkeyopt rsa_keygen_bits:4096
   openssl pkey -in config/jwt/private.pem -out config/jwt/public.pem -pubout

6. Compiler les assets

   npm run build # ou yarn build

7. Démarrer le serveur

   symfony server:start

⚙️ Configuration des Services

Services Requis

1. Firebase

   • Créer un projet Firebase
   • Télécharger le fichier de configuration
   • Placer le fichier dans config/firebase/

2. Stripe

   • Créer un compte Stripe
   • Configurer les clés API dans .env

3. AWS S3

   • Créer un bucket S3
   • Configurer les credentials AWS

4. Cloudinary

   • Créer un compte Cloudinary
   • Configurer l'URL Cloudinary dans .env

5. Pusher

   • Créer un compte Pusher
   • Configurer les clés dans .env

6. Agora

   • Créer un compte Agora
   • Configurer l'App ID et le certificat

🏗 Architecture

graph TD
    A[Client Mobile] -->|API Requests| B[API Symfony]
    B -->|Push Notifications| C[Firebase]
    B -->|Media Storage| D[AWS S3]
    B -->|Image Processing| E[Cloudinary]
    B -->|Real-time Events| F[Pusher]
    B -->|Live Streaming| G[Agora]
    B -->|Payments| H[Stripe]
    B -->|Database| I[(MySQL)]

Loading

Structure du Backend

src/
├── Controller/     # Contrôleurs API REST
├── Entity/         # Entités Doctrine
├── Service/        # Services métier
├── Repository/     # Repositories Doctrine
└── EventListener/  # Listeners d'événements

🔄 Améliorations Architecturales Potentielles

Cette section présente les améliorations architecturales qui auraient pu être implémentées avec le recul pour rendre le projet plus robuste, plus performant et maintenable.

Domain-Driven Design (DDD)

• Implémentation d'une architecture en couches (Layered Architecture)

  src/
  ├── Domain/          # Entités, Value Objects, Events
  ├── Application/     # Use Cases, Services applicatifs
  ├── Infrastructure/  # Persistence, External Services
  └── Presentation/   # Controllers, DTOs
  

• Définition de Bounded Contexts clairs (ex: Streaming, Marketplace, Authentication)
• Utilisation d'Aggregates pour maintenir la cohérence des données
• Implémentation d'Event Sourcing pour le suivi des changements d'état

Clean Architecture

• Séparation stricte des responsabilités avec le principe des cercles concentriques
• Inversion des dépendances (interfaces dans le domaine)
• Use Cases isolés et testables
• Mappers dédiés entre les couches

Microservices

Décomposition potentielle en services autonomes :

• Service de Streaming (Agora)
• Service de Paiement (Stripe)
• Service de Gestion des Produits
• Service de Chat
• Service de Notification
• Service d'Authentication

Améliorations Techniques

• Tests

  • Tests unitaires plus exhaustifs
  • Tests d'intégration avec TestContainers
  • Tests de performance avec K6
  • Tests E2E avec Cypress
  • Fixtures plus complètes avec Alice

• Patterns & Pratiques

  • Command Query Responsibility Segregation (CQRS)
  • Implementation du pattern Mediator (ex: symfony/messenger)
  • Circuit Breaker pour les appels aux services externes
  • Cache distribué avec Redis
  • File d'attente avec RabbitMQ pour les opérations asynchrones

• Monitoring & Observabilité

  • Distributed Tracing avec Jaeger
  • Métriques détaillées avec Prometheus
  • Dashboards Grafana
  • Log aggregation avec ELK Stack

• CI/CD

  • Pipeline de déploiement blue/green
  • Tests de sécurité automatisés
  • Quality Gates avec SonarQube
  • Analyse statique du code plus poussée

Ces améliorations démontrent une compréhension approfondie des pratiques modernes de développement et d'architecture logicielle, tout en maintenant un équilibre entre complexité et maintenabilité.

📝 License

Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.