@mostajs/licensing-ui-react 0.1.0

package/src/react/EnhancedLicenseGate.tsx

@@ -0,0 +1,488 @@
+"use client";
+import { useEffect, useState, useCallback } from "react";
+import { Shield, CheckCircle, XCircle, AlertTriangle, RefreshCw, Loader2, ExternalLink, ToggleLeft, ToggleRight } from "lucide-react";
+import LicenseActivationForm from "./LicenseActivationForm";
+import { useLicenseUi } from "./LicenseProvider";
+import SimpleLicenseActivation from "./SimpleLicenseActivation";
+import PendingLicenseActivation from "./PendingLicenseActivation";
+
+interface Props {
+  children: React.ReactNode;
+  project?: string;
+  version?: string;
+  gracePeriod?: number; // Jours de grâce offline
+}
+
+interface LicenseInfo {
+  valid: boolean;
+  reason?: string;
+  license?: {
+    key: string;
+    email: string;
+    project: string;
+    expires_at: string;
+    activations: number;
+    max_activations: number;
+  };
+  remaining_days?: number;
+}
+
+export default function EnhancedLicenseGate({
+  children,
+  project: projectProp,
+  version = "1.0.0",
+  gracePeriod = 3
+}: Props) {
+  const { serverUrl, project: ctxProject } = useLicenseUi(); // config .env (createLicenseUiFromEnv)
+  const project = projectProp ?? ctxProject ?? "app";
+  const [status, setStatus] = useState<"checking" | "valid" | "invalid" | "activation" | "expired" | "warning" | "pending">("checking");
+  const [error, setError] = useState<string | null>(null);
+  const [licenseInfo, setLicenseInfo] = useState<LicenseInfo | null>(null);
+  const [isOffline, setIsOffline] = useState(false);
+  const [lastOnlineCheck, setLastOnlineCheck] = useState<Date | null>(null);
+  const [retryCount, setRetryCount] = useState(0);
+  const [useSimpleActivation, setUseSimpleActivation] = useState(true);
+  const [pendingLicenseData, setPendingLicenseData] = useState<any>(null);
+  const [pendingActivationCode, setPendingActivationCode] = useState<string | null>(null);
+
+  // Vérification de la connectivité
+  const checkConnectivity = useCallback(async () => {
+    try {
+      const response = await fetch("/api/license/ping", { 
+        method: "GET",
+        cache: "no-cache"
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }, []);
+
+  // Vérification offline (cache local + période de grâce)
+  const checkOfflineLicense = useCallback(() => {
+    const offlineData = localStorage.getItem("license_cache");
+    if (!offlineData) return false;
+
+    try {
+      const cached = JSON.parse(offlineData);
+      const cacheDate = new Date(cached.timestamp);
+      const now = new Date();
+      const diffDays = Math.floor((now.getTime() - cacheDate.getTime()) / (1000 * 60 * 60 * 24));
+      
+      if (diffDays <= gracePeriod && cached.valid) {
+        setLicenseInfo(cached.licenseInfo);
+        setLastOnlineCheck(cacheDate);
+        return true;
+      }
+    } catch (e) {
+      console.warn("Cache licence corrompu :", e);
+      localStorage.removeItem("license_cache");
+    }
+    return false;
+  }, [gracePeriod]);
+
+  const verifyLicense = useCallback(async (force = false) => {
+    try {
+      const isOnline = await checkConnectivity();
+      
+      if (!isOnline && !force) {
+        setIsOffline(true);
+        if (checkOfflineLicense()) {
+          setStatus("warning"); // Mode offline avec licence valide
+          return;
+        } else {
+          setStatus("invalid");
+          setError("Aucune connexion et licence locale expirée");
+          return;
+        }
+      }
+
+      setIsOffline(false);
+      
+      // Vérification via l'API locale (qui vérifie le fichier local)
+      const response = await fetch("/api/license/verify");
+      const data: LicenseInfo = await response.json();
+      
+      setLicenseInfo(data);
+      
+      if (data.valid) {
+        setStatus("valid");
+        // Mise à jour du cache local
+        localStorage.setItem("license_cache", JSON.stringify({
+          licenseInfo: data,
+          timestamp: new Date().toISOString(),
+          valid: true
+        }));
+        setLastOnlineCheck(new Date());
+      } else {
+        setStatus("invalid");
+        localStorage.removeItem("license_cache");
+        
+        if (data.reason === "expired") {
+          setStatus("expired");
+          setError(`Licence expirée depuis ${data.remaining_days ? Math.abs(data.remaining_days) : '?'} jours`);
+        } else if (data.reason === "signature") {
+          setError("Signature invalide - Fichier de licence corrompu");
+        } else if (data.reason === "not_found") {
+          setError("Aucune licence trouvée - Activation requise");
+          setStatus("activation");
+        } else {
+          setError(data.reason || "Licence invalide");
+          setStatus("activation");
+        }
+      }
+    } catch (e) {
+      console.error("Erreur vérification licence :", e);
+      
+      // Tentative offline en cas d'erreur réseau
+      if (checkOfflineLicense()) {
+        setStatus("warning");
+        setIsOffline(true);
+      } else {
+        setStatus("activation");
+        setError("Licence non trouvée - Activation requise");
+      }
+    }
+  }, [checkConnectivity, checkOfflineLicense]);
+
+  useEffect(() => {
+    // Vérifier d'abord s'il y a une licence en attente
+    const pendingLicense = localStorage.getItem('pending_license');
+    if (pendingLicense) {
+      try {
+        const pending = JSON.parse(pendingLicense);
+        setPendingLicenseData(pending.licenseData);
+        setPendingActivationCode(pending.activationCode);
+        setLicenseInfo({
+          valid: false,
+          license: {
+            ...pending.licenseInfo,
+            pendingData: pending
+          },
+          reason: 'pending_activation'
+        });
+        setStatus("pending");
+        return; // Ne pas vérifier la licence normale
+      } catch (e) {
+        console.error('Erreur lecture licence en attente:', e);
+        localStorage.removeItem('pending_license');
+      }
+    }
+    
+    // Sinon, vérification normale
+    verifyLicense();
+    
+    // Vérification périodique (toutes les 24h)
+    const interval = setInterval(() => {
+      verifyLicense();
+    }, 24 * 60 * 60 * 1000);
+
+    return () => clearInterval(interval);
+  }, [verifyLicense]);
+
+  const handleRetry = () => {
+    setRetryCount(prev => prev + 1);
+    setError(null);
+    verifyLicense(true);
+  };
+
+  const handleActivationSuccess = (licenseInfo: any) => {
+    // Vérifier si c'est une licence en attente (PENDING)
+    if (licenseInfo.status === 'PENDING' && licenseInfo.pendingData) {
+      // Stocker les données pour l'activation différée
+      setPendingLicenseData(licenseInfo.pendingData.licenseData);
+      setPendingActivationCode(licenseInfo.pendingData.activationCode);
+      setLicenseInfo({
+        valid: false,
+        license: licenseInfo,
+        reason: 'pending_activation'
+      });
+      setStatus("pending");
+      setError(null);
+    } else {
+      // Activation normale (pour compatibilité)
+      setLicenseInfo({
+        valid: true,
+        license: licenseInfo
+      });
+      setStatus("valid");
+      setError(null);
+      
+      // Vérification immédiate après activation
+      setTimeout(() => {
+        verifyLicense(true);
+      }, 1000);
+    }
+  };
+  
+  const handlePendingActivation = (result: any) => {
+    // La licence a été activée avec succès
+    setLicenseInfo({
+      valid: true,
+      license: result.activationInfo
+    });
+    setStatus("valid");
+    setPendingLicenseData(null);
+    setPendingActivationCode(null);
+    
+    // Recharger la page pour appliquer la licence
+    setTimeout(() => {
+      window.location.reload();
+    }, 2000);
+  };
+  
+  const handleCancelPending = () => {
+    // Annuler l'activation en attente
+    setPendingLicenseData(null);
+    setPendingActivationCode(null);
+    setStatus("activation");
+    localStorage.removeItem('pending_license');
+  };
+
+  // États d'affichage
+  if (status === "checking") {
+    return (
+      <div className="flex items-center justify-center min-h-screen bg-gray-50">
+        <div className="text-center">
+          <Loader2 className="w-8 h-8 animate-spin text-blue-500 mx-auto mb-4" />
+          <p className="text-lg text-gray-700">Vérification de la licence...</p>
+          <p className="text-sm text-gray-500 mt-2">Connexion au système de licences</p>
+        </div>
+      </div>
+    );
+  }
+
+  // Formulaire d'activation
+  if (status === "activation" || status === "invalid") {
+    return (
+      <div className="flex items-center justify-center min-h-screen bg-gray-50">
+        <div className="w-full max-w-4xl p-6">
+          {/* En-tête avec informations */}
+          <div className="text-center mb-8">
+            <h1 className="text-3xl font-bold text-gray-800 mb-4">
+              Activation de Licence - {project}
+            </h1>
+            
+            {/* Toggle pour changer de mode */}
+            <div className="flex items-center justify-center mb-6">
+              <button
+                onClick={() => setUseSimpleActivation(!useSimpleActivation)}
+                className="flex items-center space-x-3 px-4 py-2 rounded-lg bg-gray-100 hover:bg-gray-200 transition-colors"
+              >
+                <span className={`text-sm font-medium ${!useSimpleActivation ? 'text-gray-700' : 'text-gray-500'}`}>
+                  Activation manuelle
+                </span>
+                {useSimpleActivation ? (
+                  <ToggleRight className="w-8 h-8 text-blue-500" />
+                ) : (
+                  <ToggleLeft className="w-8 h-8 text-gray-400" />
+                )}
+                <span className={`text-sm font-medium ${useSimpleActivation ? 'text-gray-700' : 'text-gray-500'}`}>
+                  Activation rapide
+                </span>
+              </button>
+            </div>
+
+            {!useSimpleActivation && (
+              <div className="bg-blue-50 border border-blue-200 rounded-lg p-4 mb-6">
+                <div className="flex items-start">
+                  <AlertTriangle className="w-5 h-5 text-blue-500 mr-3 mt-0.5 flex-shrink-0" />
+                  <div className="text-left">
+                    <h3 className="text-blue-800 font-medium mb-2">Activation manuelle</h3>
+                    <div className="text-sm text-blue-700 space-y-2">
+                      <div className="flex items-start">
+                        <span className="font-bold mr-2">1.</span>
+                        <div>
+                          Rendez-vous sur <a href={serverUrl} target="_blank" rel="noopener noreferrer" className="text-blue-600 hover:text-blue-800 font-medium inline-flex items-center">
+                            licences.amia.fr <ExternalLink className="w-3 h-3 ml-1" />
+                          </a> pour télécharger votre fichier de licence
+                        </div>
+                      </div>
+                      <div className="flex items-start">
+                        <span className="font-bold mr-2">2.</span>
+                        <div>Récupérez votre code d'activation fourni par email lors de l'achat</div>
+                      </div>
+                      <div className="flex items-start">
+                        <span className="font-bold mr-2">3.</span>
+                        <div>Utilisez le formulaire ci-dessous pour activer votre licence</div>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            )}
+          </div>
+
+          {error && (
+            <div className="max-w-lg mx-auto mb-6">
+              <div className="bg-red-50 border border-red-200 rounded-lg p-4">
+                <div className="flex items-center">
+                  <XCircle className="w-5 h-5 text-red-500 mr-2 flex-shrink-0" />
+                  <p className="text-red-700 text-sm">{error}</p>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Afficher le formulaire approprié */}
+          {useSimpleActivation ? (
+            <SimpleLicenseActivation
+              onActivationSuccess={handleActivationSuccess}
+              onSwitchToManual={() => setUseSimpleActivation(false)}
+            />
+          ) : (
+            <LicenseActivationForm 
+              onActivationSuccess={handleActivationSuccess}
+            />
+          )}
+
+          {/* Actions supplémentaires */}
+          <div className="max-w-lg mx-auto mt-6 text-center">
+            <button
+              onClick={handleRetry}
+              className="text-sm text-gray-500 hover:text-gray-700 inline-flex items-center"
+            >
+              <RefreshCw className="w-4 h-4 mr-1" />
+              Vérifier à nouveau ({retryCount + 1})
+            </button>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  // Mode warning (offline avec licence valide)
+  if (status === "warning") {
+    return (
+      <div className="relative">
+        {/* Bandeau d'avertissement */}
+        <div className="bg-yellow-50 border-l-4 border-yellow-400 p-4">
+          <div className="flex items-center">
+            <AlertTriangle className="w-5 h-5 text-yellow-400 mr-3" />
+            <div className="flex-1">
+              <p className="text-sm text-yellow-700">
+                Mode hors ligne - Licence valide localement
+                {lastOnlineCheck && (
+                  <span className="block text-xs text-yellow-600">
+                    Dernière vérification : {lastOnlineCheck.toLocaleDateString()}
+                  </span>
+                )}
+              </p>
+            </div>
+            <button
+              onClick={() => verifyLicense(true)}
+              className="text-yellow-600 hover:text-yellow-800"
+              title="Tenter une reconnexion"
+            >
+              <RefreshCw className="w-4 h-4" />
+            </button>
+          </div>
+        </div>
+        {children}
+      </div>
+    );
+  }
+
+  // Mode licence en attente d'activation (PENDING)
+  if (status === "pending" && pendingLicenseData && pendingActivationCode) {
+    return (
+      <div className="flex items-center justify-center min-h-screen bg-gray-50">
+        <PendingLicenseActivation
+          licenseInfo={licenseInfo?.license}
+          verificationInfo={licenseInfo?.license?.pendingData?.verificationInfo}
+          activationCode={pendingActivationCode}
+          licenseData={pendingLicenseData}
+          onActivate={handlePendingActivation}
+          onCancel={handleCancelPending}
+        />
+      </div>
+    );
+  }
+
+  // Mode licence expirée
+  if (status === "expired") {
+    return (
+      <div className="flex items-center justify-center min-h-screen bg-gray-50">
+        <div className="max-w-lg p-8 bg-white rounded-xl shadow-lg border border-red-200">
+          <div className="text-center mb-6">
+            <XCircle className="w-16 h-16 text-red-500 mx-auto mb-4" />
+            <h2 className="text-2xl font-bold text-red-600 mb-2">Licence expirée</h2>
+            <p className="text-gray-600">{error}</p>
+          </div>
+
+          {licenseInfo?.license && (
+            <div className="bg-red-50 p-4 rounded-lg mb-6">
+              <h3 className="font-semibold text-red-800 mb-2">Informations de licence</h3>
+              <div className="text-sm text-red-700 space-y-1">
+                <p><strong>Email :</strong> {licenseInfo.license.email}</p>
+                <p><strong>Projet :</strong> {licenseInfo.license.project}</p>
+                <p><strong>Clé :</strong> {licenseInfo.license.key}</p>
+                <p><strong>Expiré le :</strong> {new Date(licenseInfo.license.expires_at).toLocaleDateString()}</p>
+              </div>
+            </div>
+          )}
+
+          <div className="space-y-4">
+            <button
+              onClick={() => setStatus("activation")}
+              className="w-full px-4 py-3 bg-blue-500 text-white rounded-md hover:bg-blue-600 focus:outline-none focus:ring-2 focus:ring-blue-500 font-medium"
+            >
+              Renouveler la licence
+            </button>
+            <button
+              onClick={handleRetry}
+              className="w-full px-4 py-2 border border-gray-300 text-gray-700 rounded-md hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-gray-500"
+            >
+              <RefreshCw className="w-4 h-4 inline mr-2" />
+              Vérifier à nouveau
+            </button>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  // Licence valide - Afficher l'application avec bandeau en bas
+  return (
+    <div className="relative min-h-screen flex flex-col">
+      {/* Contenu principal */}
+      <div className="flex-1">
+        {children}
+      </div>
+      
+      {/* Bandeau de licence en bas de page */}
+      {licenseInfo?.license && (
+        <div className="fixed bottom-0 left-0 right-0 bg-green-50 border-t-4 border-green-400 p-3 text-sm shadow-lg z-50">
+          <div className="container mx-auto flex items-center justify-between">
+            <div className="flex items-center">
+              <CheckCircle className="w-4 h-4 text-green-400 mr-2" />
+              <span className="text-green-700">
+                <strong>Licence valide</strong> • {licenseInfo.license.email} • {licenseInfo.license.project}
+                {licenseInfo.remaining_days !== undefined && (
+                  <span className={`ml-2 ${licenseInfo.remaining_days < 30 ? 'text-yellow-600' : 'text-green-600'}`}>
+                    {licenseInfo.remaining_days < 30 
+                      ? `⚠️ Expire dans ${licenseInfo.remaining_days} jours`
+                      : `✅ ${licenseInfo.remaining_days} jours restants`
+                    }
+                  </span>
+                )}
+              </span>
+            </div>
+            <div className="flex items-center space-x-3">
+              <span className="text-xs text-green-600">
+                Activations: {licenseInfo.license.activations}/{licenseInfo.license.max_activations}
+              </span>
+              <button
+                onClick={() => verifyLicense(true)}
+                className="text-green-600 hover:text-green-800 p-1 rounded transition-colors"
+                title="Actualiser la licence"
+              >
+                <RefreshCw className="w-4 h-4" />
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}