feat(tiktok): publier les reels sur les comptes TikTok des magasins

Ajoute la gestion multi-comptes TikTok et permet d'envoyer la même vidéo sur plusieurs pages Facebook ET plusieurs comptes TikTok en une seule publication. Un compte TikTok vit dans social_pages comme une page Facebook : il hérite donc des permissions par utilisateur, de la planification et du calendrier. Trois particularités de l'API TikTok structurent l'implémentation : - pas de jeton saisi à la main : chaque compte passe par OAuth, et l'access token (24h) est renouvelé via le refresh token (1 an) avant chaque publication ; - la publication est asynchrone : l'upload rend un publish_id, et un poller récupère l'identifiant définitif du post ; - creator_info doit être interrogé avant chaque envoi pour ne demander qu'un niveau de confidentialité réellement autorisé sur le compte. Serveur : - service TikTok (OAuth, creator_info, upload FILE_UPLOAD par chunks, suivi de statut) et routes de connexion/configuration - schéma : platform 'tiktok', refresh token et scopes sur social_pages, publish_id/publish_status sur scheduled_posts, table tiktok_config - routage par plateforme dans les deux flux de reels et le planificateur - cron de suivi des publications, token manager et analytics adaptés Client : - connexion et reconnexion des comptes TikTok depuis « Pages gérées » - sélection combinée pages Facebook / comptes TikTok à la publication - configuration de l'application TikTok dans les paramètres (admin) Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_018uUPZ1GNpEkYB1dpXHYPek
2026-10-24 07:28:11 +02:00 · 2026-08-11 14:29:38 +00:00
1 parent 2188fa458d
commit b95cd23ebc
@@ -0,0 +1,226 @@
+/**
+ * Routes de gestion des comptes TikTok.
+ *
+ * Un compte TikTok de magasin se connecte en OAuth (TikTok n'autorise pas la
+ * saisie manuelle d'un token), puis vit dans `social_pages` comme une page
+ * Facebook : mêmes permissions, même planification, même calendrier.
+ */
+
+import crypto from 'crypto';
+import { Router, Request, Response } from 'express';
+import type { User } from '@shared/schema';
+import { storage } from '../storage';
+import { tiktokService } from '../services/tiktok';
+import { insertTiktokConfigSchema, updateTiktokConfigSchema } from '@shared/schema';
+
+export const tiktokRouter = Router();
+
+/** Page vers laquelle on renvoie le navigateur à la fin du flux OAuth. */
+const RETURN_PATH = '/pages';
+
+function isAdmin(req: Request): boolean {
+  const user = req.user as User | undefined;
+  return user?.role === 'admin';
+}
+
+function buildReturnUrl(status: 'success' | 'error', message: string): string {
+  const params = new URLSearchParams({ tiktok: status, message });
+  return `${RETURN_PATH}?${params.toString()}`;
+}
+
+/**
+ * État de la configuration TikTok.
+ * Le client secret n'est jamais renvoyé au client.
+ */
+tiktokRouter.get('/config', async (req: Request, res: Response) => {
+  try {
+    const config = await storage.getTiktokConfig();
+    const configured = await tiktokService.isConfigured();
+
+    // Tout le monde a besoin de savoir si la connexion est possible ; seuls les
+    // admins voient les détails de l'application développeur.
+    if (!isAdmin(req)) {
+      return res.json({ configured });
+    }
+
+    res.json({
+      configured,
+      clientKey: config?.clientKey || (process.env.TIKTOK_CLIENT_KEY ? '(défini par variable d\'environnement)' : ''),
+      hasClientSecret: !!(config?.clientSecret || process.env.TIKTOK_CLIENT_SECRET),
+      redirectUri: tiktokService.getRedirectUri(),
+    });
+  } catch (error) {
+    console.error('❌ [TikTok] Erreur lecture configuration:', error);
+    res.status(500).json({ error: 'Impossible de lire la configuration TikTok' });
+  }
+});
+
+/** Enregistre les identifiants de l'application développeur TikTok (admin). */
+tiktokRouter.put('/config', async (req: Request, res: Response) => {
+  try {
+    if (!isAdmin(req)) {
+      return res.status(403).json({ error: 'Accès refusé. Réservé aux administrateurs.' });
+    }
+
+    const existing = await storage.getTiktokConfig();
+    // Le secret peut être omis lors d'une mise à jour : on garde l'existant
+    const schema = existing ? updateTiktokConfigSchema : insertTiktokConfigSchema;
+    const data = schema.parse(req.body);
+
+    const config = await storage.upsertTiktokConfig(data);
+
+    res.json({
+      success: true,
+      clientKey: config.clientKey,
+      redirectUri: tiktokService.getRedirectUri(),
+    });
+  } catch (error: any) {
+    console.error('❌ [TikTok] Erreur enregistrement configuration:', error);
+    res.status(400).json({
+      error: error?.errors?.[0]?.message || error?.message || 'Configuration TikTok invalide',
+    });
+  }
+});
+
+/**
+ * Démarre la connexion d'un compte TikTok.
+ * À appeler par navigation complète du navigateur (window.location), pas en fetch.
+ */
+tiktokRouter.get('/connect', async (req: Request, res: Response) => {
+  try {
+    if (!(await tiktokService.isConfigured())) {
+      return res.redirect(
+        buildReturnUrl('error', "TikTok n'est pas configuré. Renseignez d'abord le client key et le client secret.")
+      );
+    }
+
+    // Protection CSRF : l'état est vérifié au retour
+    const state = crypto.randomBytes(16).toString('hex');
+    (req.session as any).tiktokOAuthState = state;
+
+    const authUrl = await tiktokService.buildAuthorizationUrl(state);
+
+    // La session doit être écrite avant la redirection, sinon l'état est perdu
+    req.session.save((err) => {
+      if (err) {
+        console.error('❌ [TikTok] Impossible de sauvegarder la session OAuth:', err);
+        return res.redirect(buildReturnUrl('error', 'Erreur de session, réessayez.'));
+      }
+      res.redirect(authUrl);
+    });
+  } catch (error) {
+    console.error('❌ [TikTok] Erreur démarrage OAuth:', error);
+    res.redirect(
+      buildReturnUrl('error', error instanceof Error ? error.message : 'Erreur de connexion TikTok')
+    );
+  }
+});
+
+/**
+ * Retour d'autorisation TikTok : échange le code, puis crée ou met à jour le
+ * compte dans social_pages.
+ */
+tiktokRouter.get('/callback', async (req: Request, res: Response) => {
+  const user = req.user as User;
+  const { code, state, error: oauthError, error_description: oauthErrorDescription } = req.query;
+
+  try {
+    if (oauthError) {
+      const description = (oauthErrorDescription as string) || (oauthError as string);
+      return res.redirect(buildReturnUrl('error', `Autorisation TikTok refusée : ${description}`));
+    }
+
+    const expectedState = (req.session as any)?.tiktokOAuthState;
+    delete (req.session as any)?.tiktokOAuthState;
+
+    if (!state || !expectedState || state !== expectedState) {
+      return res.redirect(buildReturnUrl('error', 'Requête de connexion TikTok invalide (état non reconnu).'));
+    }
+
+    if (!code || typeof code !== 'string') {
+      return res.redirect(buildReturnUrl('error', "Aucun code d'autorisation reçu de TikTok."));
+    }
+
+    const tokens = await tiktokService.exchangeCodeForToken(code);
+    const profile = await tiktokService.getUserInfo(tokens.access_token);
+    const openId = profile.openId || tokens.open_id;
+
+    // Un compte déjà connecté est mis à jour plutôt que dupliqué
+    const existingPages = await storage.getSocialPages(user.id);
+    const existing = existingPages.find(p => p.platform === 'tiktok' && p.pageId === openId);
+
+    if (existing) {
+      await storage.updateSocialPage(existing.id, {
+        pageName: profile.displayName,
+        avatarUrl: profile.avatarUrl || null,
+        isActive: 'true',
+      });
+      await tiktokService.persistTokens(existing.id, tokens);
+
+      console.log(`🔁 [TikTok] Compte reconnecté: ${profile.displayName}`);
+      return res.redirect(buildReturnUrl('success', `Compte TikTok "${profile.displayName}" reconnecté.`));
+    }
+
+    const page = await storage.createSocialPage({
+      userId: user.id,
+      platform: 'tiktok',
+      pageId: openId,
+      pageName: profile.displayName,
+      accessToken: tokens.access_token,
+      tokenExpiresAt: new Date(Date.now() + tokens.expires_in * 1000),
+      refreshToken: tokens.refresh_token,
+      refreshTokenExpiresAt: new Date(Date.now() + tokens.refresh_expires_in * 1000),
+      scopes: tokens.scope,
+      avatarUrl: profile.avatarUrl || null,
+      isActive: 'true',
+    });
+
+    // Les non-admins ne voient que les pages qui leur sont explicitement
+    // attribuées : sans cette permission, ils ne verraient pas leur propre compte.
+    if (user.role !== 'admin') {
+      try {
+        await storage.createPagePermission({ userId: user.id, pageId: page.id });
+      } catch (permissionError) {
+        console.error('⚠️ [TikTok] Impossible de créer la permission de page:', permissionError);
+      }
+    }
+
+    console.log(`✅ [TikTok] Nouveau compte connecté: ${profile.displayName} (${openId})`);
+    res.redirect(buildReturnUrl('success', `Compte TikTok "${profile.displayName}" connecté.`));
+  } catch (error) {
+    console.error('❌ [TikTok] Erreur callback OAuth:', error);
+    res.redirect(
+      buildReturnUrl('error', error instanceof Error ? error.message : 'Connexion TikTok impossible')
+    );
+  }
+});
+
+/**
+ * Options réellement autorisées sur un compte (confidentialité, commentaires,
+ * duo, stitch, durée max). TikTok impose de les afficher avant publication.
+ */
+tiktokRouter.get('/accounts/:id/creator-info', async (req: Request, res: Response) => {
+  try {
+    const user = req.user as User;
+    const page = await storage.getSocialPage(req.params.id);
+
+    if (!page || page.platform !== 'tiktok') {
+      return res.status(404).json({ error: 'Compte TikTok non trouvé' });
+    }
+
+    if (user.role !== 'admin' && page.userId !== user.id) {
+      const accessible = await storage.getUserAccessiblePages(user.id);
+      if (!accessible.some(p => p.id === page.id)) {
+        return res.status(403).json({ error: 'Accès refusé à ce compte' });
+      }
+    }
+
+    const creatorInfo = await tiktokService.getCreatorInfo(page);
+    res.json(creatorInfo);
+  } catch (error) {
+    console.error('❌ [TikTok] Erreur récupération creator info:', error);
+    res.status(502).json({
+      error: error instanceof Error ? error.message : 'Impossible de contacter TikTok',
+    });
+  }
+});