Premium check in new modal file updated

Author: gcclinux

screenshots/banner.png

@@ -3226,7 +3226,7 @@ const App = () => {
               }}
               onUpgradeClick={() => {
                 setShowEasyNotesSidebar(false);
-                setAboutOpen(true);
+                setLicenseOpen(true);
               }}
             />
           )

src/App.tsx

@@ -102,7 +102,12 @@ const EasyNotesSidebar: React.FC<EasyNotesSidebarProps> = ({
   // Load notes and provider status on component mount
   useEffect(() => {
     if (showEasyNotesSidebar) {
-      console.log('[EasyNotesSidebar] Sidebar opened, checking for post-redirect authentication...');
+      // Re-check license state when sidebar opens (in case it changed while
+      // the sidebar was hidden, e.g. user activated license in LicenseModal)
+      const currentLicenseState = LicenseManager.hasActiveLicense();
+      console.log('[EasyNotesSidebar] Sidebar opened, license active:', currentLicenseState);
+      setHasLicense(currentLicenseState);
+
       checkPostRedirectAuth();
       loadNotesAndProviders();
     }

src/components/EasyNotesSidebar.tsx

@@ -159,11 +159,16 @@ export function LicenseModal({ open, onClose, showToast }: LicenseModalProps) {
 
   const handleSaveLicense = async () => {
     localStorage.setItem('easyeditor-user-name', name);
+    console.log('[LicenseModal] Checking license for email:', email);
     await LicenseManager.setLicenseData(email, licenseKey);
     const valid = LicenseManager.hasActiveLicense();
+    const licType = LicenseManager.getType();
+    console.log('[LicenseModal] License check result: valid=', valid, ', type=', licType);
     setIsLicenseValid(valid);
-    setType(LicenseManager.getType());
-    if (!valid && showToast) {
+    setType(licType);
+    if (valid && showToast) {
+      showToast(`License activated: ${licType || 'Premium'}`, 'success');
+    } else if (!valid && showToast) {
       showToast(t('about.invalid_license') || 'Invalid license or email', 'error');
     }
   };

src/components/LicenseModal.tsx

@@ -12,7 +12,11 @@ class LicenseManager {
   private STORAGE_KEY_TYPE = 'easyeditor-user-type';
   private STORAGE_KEY_LICENSE_KEY = 'easyeditor-user-license-key';
 
-  private constructor() { }
+  private constructor() {
+    // Immediately restore cached license state so components get the right
+    // value on their very first render (before the async API check completes).
+    this.restoreFromCache();
+  }
 
   public static getInstance(): LicenseManager {
     if (!LicenseManager.instance) {
@@ -32,12 +36,22 @@ class LicenseManager {
     const cachedValid = localStorage.getItem(this.STORAGE_KEY_CACHED_LICENSE);
     const storedType = this.getStoredType();
 
+    const oldStatus = this.activeLicense;
+    const oldType = this.type;
+
     if (email && licenseKey && cachedValid === 'true') {
       this.activeLicense = true;
       this.type = storedType || '';
+      console.log('[LicenseManager] Restored from cache: active=true, type=', this.type);
     } else {
       this.activeLicense = false;
       this.type = '';
+      console.log('[LicenseManager] No cached license found (email:', !!email, ', key:', !!licenseKey, ', cached:', cachedValid, ')');
+    }
+
+    // Notify listeners if state changed (so already-mounted components update)
+    if (oldStatus !== this.activeLicense || oldType !== this.type) {
+      this.notifyListeners();
     }
   }
 
@@ -99,11 +113,14 @@ class LicenseManager {
     const email = this.getStoredEmail();
     const licenseKey = this.getStoredLicenseKey();
 
+    console.log('[LicenseManager] checkLicenseStatus: email=', !!email, ', key=', !!licenseKey);
+
     if (!email || !licenseKey) {
       const oldStatus = this.activeLicense;
       this.activeLicense = false;
       this.type = '';
       localStorage.removeItem(this.STORAGE_KEY_CACHED_LICENSE);
+      console.log('[LicenseManager] No email/key stored, license cleared');
       if (oldStatus !== this.activeLicense) {
         this.notifyListeners();
       }
@@ -135,6 +152,8 @@ class LicenseManager {
         const data = await response.json();
         const isLicenseActive = data.hasActiveLicense === true || data.hasActiveLicense === 'True';
 
+        console.log('[LicenseManager] API response: active=', isLicenseActive, ', email match=', data.email === email, ', key match=', data.linkedUserId === licenseKey);
+
         // Match user's email and licenseKey against the returned linkedUserId
         if (isLicenseActive && data.email === email && data.linkedUserId === licenseKey) {
           this.activeLicense = true;
@@ -153,33 +172,39 @@ class LicenseManager {
           if (data.purchaseDate) {
             localStorage.setItem(this.STORAGE_KEY_DATE, data.purchaseDate.toString());
           }
+          console.log('[LicenseManager] License validated: type=', this.type);
         } else {
           this.activeLicense = false;
           this.type = '';
           localStorage.removeItem(this.STORAGE_KEY_CACHED_LICENSE);
+          console.log('[LicenseManager] License validation failed');
         }
       } else {
         this.activeLicense = false;
         this.type = '';
         localStorage.removeItem(this.STORAGE_KEY_CACHED_LICENSE);
+        console.error('[LicenseManager] API returned non-ok status:', response.status);
       }
 
       if (oldStatus !== this.activeLicense || oldType !== this.type) {
         this.notifyListeners();
       }
     } catch (error) {
-      console.error('Error checking license status:', error);
-      const oldStatus = this.activeLicense;
-      this.activeLicense = false;
-      localStorage.removeItem(this.STORAGE_KEY_CACHED_LICENSE);
-      // We keep the plan locally if we fail to check? Better to clear it to be safe or keep it cached?
-      // For safety/validity, if check fails, we assume no license.
-      // But maybe we should keep the cached values if network error?
-      // Current implementation clears it. I'll stick to that.
-      this.type = '';
-
-      if (oldStatus !== this.activeLicense) {
-        this.notifyListeners();
+      console.error('[LicenseManager] Error checking license status:', error);
+      // On network failure, preserve the cached license state rather than
+      // invalidating a genuine license just because the user is offline.
+      const cachedValid = localStorage.getItem(this.STORAGE_KEY_CACHED_LICENSE);
+      if (cachedValid === 'true') {
+        console.log('[LicenseManager] Network error but cached license exists — keeping cached state');
+        // Don't clear the license; keep the cached state so offline users
+        // can still use premium features until the next successful check.
+      } else {
+        const oldStatus = this.activeLicense;
+        this.activeLicense = false;
+        this.type = '';
+        if (oldStatus !== this.activeLicense) {
+          this.notifyListeners();
+        }
       }
     }
   }