sogoms/TODO.md

TODO - SOGOMS V1 Minimale

Objectif : valider l'architecture avec 2-3 microservices basiques.

Phase 0 : Infrastructure

• Container gw3 : Alpine sur IN3 (13.23.33.5)
• Config Prokov : routes + scénarios YAML (auth, projects, tasks, tags, statuses)
• Nginx host IN3 : routing /api/ → gw3:8080, / → dva-front

Phase 1 : Protocole IPC

• internal/protocol/message.go : structs Request/Response JSON
• internal/protocol/server.go : listener Unix socket
• internal/protocol/client.go : client pour appeler les services

Phase 2 : Microservice DB

• cmd/sogoms/db/main.go : point d'entrée
• Connexion MariaDB (pool par application)
• Action query : SELECT multi-résultats
• Action query_one : SELECT un résultat
• Action insert : INSERT retourne insert_id
• Action update : UPDATE retourne affected_rows
• Action delete : DELETE retourne affected_rows
• Écoute sur /run/sogoms-db.1.sock
• Test standalone sogoms-db

Phase 3 : Config

• internal/config/config.go : lecture YAML + registry par host
• internal/config/routes.go : parser routes (intégré dans config.go)

Phase 4 : Gateway HTTP

• cmd/sogoway/main.go : serveur HTTP :8080
• Routing par host → charge le bon fichier routes (prokov.yaml)
• internal/auth/jwt.go : génération + validation JWT (HS256)
• internal/auth/password.go : hash + verify password (bcrypt)
• Endpoint POST /api/auth/login : vérifie credentials, retourne JWT
• Endpoint GET /api/auth/me : valide JWT, retourne user
• Endpoint POST /api/auth/register : crée user, retourne JWT
• Communication avec sogoms-db via Unix socket
• Test standalone sogoway

Phase 5 : Superviseur

• cmd/sogoctl/main.go : point d'entrée
• Config config/sogoctl.yaml : services à lancer
• Lancement sogoms-db + sogoway (avec dépendances)
• Health check (socket + HTTP)
• Redémarrage automatique si crash

Phase 6 : Test de validation

# 1. Lancer sogoctl (démarre les services)
./sogoctl

# 2. Login
curl -X POST https://prokov.unikoffice.com/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"test@example.com","password":"secret"}'
# → {"success":true,"data":{"token":"eyJ...","user":{...}}}

# 3. Vérifier le token
curl https://prokov.unikoffice.com/api/auth/me \
  -H "Authorization: Bearer eyJ..."
# → {"success":true,"data":{"user":{...}}}

• Test login OK
• Test /me avec token valide OK
• Test /me sans token → 401

Phase 7 : Microservice Logs

• cmd/sogoms/logs/main.go : point d'entrée
• Écoute sur Unix socket /run/sogoms-logs.1.sock
• Actions log_error, log_event : écriture dans fichiers
• Format fichiers : /var/log/sogoms/{app}-{YYYYMMDD}-{type}.log
• Rotation automatique : suppression des fichiers > 30 jours
• Paramètre retention_days dans config (config/routes/prokov.yaml)
• Intégration avec sogoway et sogoms-db

Phase 8 : Système de Queries YAML

• Structure config/queries/{app}/*.yaml
• Requêtes SQL externalisées (pas de recompilation)
• internal/config/config.go : QueryConfig, GetQuery(), Build()
• Placeholders :user_id, :id, etc.
• Filtres par rôle (default, admin)
• Login enrichi : charge projects, tasks, tags, statuses

Phase 9 : CRUD Générique

• Routing /api/{resource} dans sogoway
• GET list/show avec filtres YAML
• POST create avec fields YAML
• PUT update avec fields + filtres YAML
• DELETE avec filtres YAML
• Config YAML pour projects, tasks, tags, statuses
• Sécurité : filtre user_id automatique

Phase 10 : Améliorations Deploy

• deploy.sh : build sogoms-logs
• deploy.sh : backup archives dans /home/pierre/samba/back/sogoms/
• deploy.sh : redémarrage auto sogoctl
• deploy.sh : kill propre des processus zombies
• Documentation DOCTECH.md
• Version 1.0.1

Phase 11 : Microservice Crypt

• cmd/sogoms/crypt/main.go : point d'entrée
• Écoute sur Unix socket /run/sogoms-crypt.1.sock
• Action encrypt : chiffre une donnée (AES-256-GCM)
• Action decrypt : déchiffre une donnée
• Action hash : hash irréversible (SHA-256)
• Clé de chiffrement par application (/secrets/{app}_crypt_key)
• Intégration avec sogoway pour champs sensibles
• Config YAML : liste des champs à chiffrer par table
• Application Prokov : chiffrement users.email

Phase 12 : Microservices Email

12a. sogoms-smtp (Envoi)

• cmd/sogoms/smtp/main.go : point d'entrée
• Écoute sur Unix socket /run/sogoms-smtp.1.sock
• Action send : envoi email simple (to, subject, body, html)
• Action send_template : envoi avec template YAML
• Action send_bulk : envoi en masse (liste de destinataires)
• Config SMTP par application (config/routes/{app}.yaml)
• Support TLS/STARTTLS
• Templates YAML (config/emails/{app}/*.yaml)
• Queue d'envoi avec retry en cas d'échec

12b. sogoms-imap (Lecture)

• cmd/sogoms/imap/main.go : point d'entrée
• Écoute sur Unix socket /run/sogoms-imap.1.sock
• Action list : liste les emails (folder, limit, offset)
• Action fetch : récupère un email complet (uid)
• Action delete : supprime un email
• Action mark_read : marque comme lu
• Action move : déplace vers un autre dossier
• Config IMAP par application (config/routes/{app}.yaml)
• Support IMAP IDLE pour notifications temps réel

12c. sogoms-mailproc (Traitement)

• cmd/sogoms/mailproc/main.go : point d'entrée
• Écoute sur Unix socket /run/sogoms-mailproc.1.sock
• Action parse : parse un email (headers, body, attachments)
• Action apply_rules : applique des règles configurées
• Config YAML : règles par application (config/mailrules/{app}.yaml)
• Webhooks : notification vers URL externe
• Intégration Prokov : email entrant → création de tâche

Phase 13 : Microservice Cron

• cmd/sogoms/cron/main.go : point d'entrée
• Écoute sur Unix socket /run/sogoms-cron.1.sock
• Config YAML par application (config/cron/{app}.yaml)
• Parser cron schedule (format standard * * * * *)
• Action list : liste les jobs configurés
• Action trigger : déclenche un job manuellement
• Action status : statut des dernières exécutions
• Type service : appel service interne (sogoms-smtp, sogoms-db, etc.)
• Type http : appel HTTP (GET/POST) vers endpoint interne ou externe
• Type query_email : requête DB + envoi email avec résultat
• Logging des exécutions dans sogoms-logs
• Application Prokov : email quotidien tasks_today

Phase 14 : Push Temps Réel (MQTT)

14a. Infrastructure Mosquitto

• Installation Mosquitto sur gw3 (Alpine: apk add mosquitto)
• Config /etc/mosquitto/mosquitto.conf
• Auth par user/password ou plugin JWT
• Port 1883 (MQTT) + 9001 (WebSocket)
• TLS optionnel pour production

14b. sogoms-push

• cmd/sogoms/push/main.go : point d'entrée
• Écoute sur Unix socket /run/sogoms-push.1.sock
• Connexion au broker MQTT
• Config YAML par application (config/push/{app}.yaml)
• Action publish : publie un message sur un topic
• Action notify_user : publie vers {app}/user/{user_id}/{channel}
• Action broadcast : publie vers tous les users d'une app
• Topics : notifications, tasks, projects, comments
• Intégration sogoway : publish auto sur événements CRUD

14c. Intégration Flutter

• Package mqtt_client dans Prokov Flutter
• Service MqttService : connexion, reconnexion auto
• Subscription aux topics user
• Mise à jour state en temps réel
• Notifications in-app

Phase 15 : Schema-Driven API (Socle SOGOMS)

Cette phase transforme SOGOMS en générateur d'API automatique.

15a. Définition du Schema

• Format config/schema/{app}.yaml : tables, fields, relations
• Types supportés : int, string, text, bool, date, datetime, json
• Contraintes : primary, auto, unique, required, default
• Relations : foreign key avec foreign: table.field
• Sécurité : filter: owner pour filtrage auto par user_id
• Auth : auth: login, auth: password pour détection auto
• CRUD : liste des opérations autorisées par table
• Filtres custom : définition de filtres nommés

15b. sogoms-schema (Générateur)

• cmd/sogoms/schema/main.go : outil CLI
• Commande generate {app} : génère queries YAML depuis schema
• Commande validate {app} : valide le schema
• Commande diff {app} : compare schema vs DB réelle
• Commande migrate {app} : génère SQL de migration
• Commande init {app} : crée schema depuis DB existante (reverse)

15c. Runtime Dynamique (sogoway)

• Chargement schema au démarrage
• Routes CRUD auto-générées depuis schema
• Validation des inputs selon types/contraintes
• Filtrage user_id automatique (filter: owner)
• Gestion relations (include, nested)
• Pas de fichiers queries YAML requis (optionnels pour override)

15d. Dictionnaire de Données

• Endpoint /api/_schema : expose le schema (pour admin/debug)
• Endpoint /api/_schema/{table} : détail d'une table
• Documentation auto-générée
• Utilisable par Flutter pour génération de formulaires

Hors scope V1

• sogorch (orchestrateur scénarios)
• sogoms-pdf, sogoms-storage
• Multi-tenant avancé (workspaces, partage)
• Rate limiting
• Rôles utilisateurs (admin, manager, user)