ALwrity + Wordpress + Wix + GSC integration

frontend/src/hooks/useWordPressConnection.ts

@@ -0,0 +1,249 @@
+/**
+ * WordPress Connection Hook
+ * Manages WordPress site connections and publishing state.
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+import { wordpressAPI, WordPressSite, WordPressStatusResponse } from '../api/wordpress';
+import { useAuth } from '@clerk/clerk-react';
+
+export interface UseWordPressConnectionReturn {
+  // Connection state
+  connected: boolean;
+  sites: WordPressSite[];
+  totalSites: number;
+  isLoading: boolean;
+  
+  // Connection actions
+  addSite: (siteData: {
+    site_url: string;
+    site_name: string;
+    username: string;
+    app_password: string;
+  }) => Promise<boolean>;
+  disconnectSite: (siteId: number) => Promise<boolean>;
+  testConnection: (siteData: {
+    site_url: string;
+    site_name: string;
+    username: string;
+    app_password: string;
+  }) => Promise<boolean>;
+  
+  // Publishing actions
+  publishContent: (publishData: {
+    site_id: number;
+    title: string;
+    content: string;
+    excerpt?: string;
+    featured_image_path?: string;
+    categories?: string[];
+    tags?: string[];
+    status?: 'draft' | 'publish' | 'private';
+    meta_description?: string;
+  }) => Promise<{ success: boolean; post_id?: number; error?: string }>;
+  
+  // Utility functions
+  validateSiteUrl: (url: string) => boolean;
+  formatSiteUrl: (url: string) => string;
+  refreshStatus: () => Promise<void>;
+}
+
+export const useWordPressConnection = (): UseWordPressConnectionReturn => {
+  const { getToken } = useAuth();
+  const [connected, setConnected] = useState(false);
+  const [sites, setSites] = useState<WordPressSite[]>([]);
+  const [totalSites, setTotalSites] = useState(0);
+  const [isLoading, setIsLoading] = useState(false);
+
+  // Set up authentication
+  useEffect(() => {
+    const setupAuth = async () => {
+      try {
+        wordpressAPI.setAuthTokenGetter(async () => {
+          try {
+            return await getToken();
+          } catch (e) {
+            return null;
+          }
+        });
+      } catch (error) {
+        console.error('Error setting up WordPress API auth:', error);
+      }
+    };
+
+    setupAuth();
+  }, [getToken]);
+
+  // Check connection status on mount
+  useEffect(() => {
+    checkStatus();
+  }, []);
+
+  const checkStatus = async () => {
+    try {
+      setIsLoading(true);
+      const status: WordPressStatusResponse = await wordpressAPI.getStatus();
+      
+      setConnected(status.connected);
+      setSites(status.sites || []);
+      setTotalSites(status.total_sites);
+      
+      console.log('WordPress status checked:', status);
+    } catch (error) {
+      console.error('Error checking WordPress status:', error);
+      setConnected(false);
+      setSites([]);
+      setTotalSites(0);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const addSite = async (siteData: {
+    site_url: string;
+    site_name: string;
+    username: string;
+    app_password: string;
+  }): Promise<boolean> => {
+    try {
+      setIsLoading(true);
+      
+      // Format the site URL
+      const formattedUrl = wordpressAPI.formatSiteUrl(siteData.site_url);
+      
+      const site = await wordpressAPI.addSite({
+        ...siteData,
+        site_url: formattedUrl
+      });
+      
+      // Update local state
+      setSites(prev => [site, ...prev]);
+      setTotalSites(prev => prev + 1);
+      setConnected(true);
+      
+      console.log('WordPress site added successfully:', site);
+      return true;
+    } catch (error) {
+      console.error('Error adding WordPress site:', error);
+      return false;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const disconnectSite = async (siteId: number): Promise<boolean> => {
+    try {
+      setIsLoading(true);
+      
+      const result = await wordpressAPI.disconnectSite(siteId);
+      
+      if (result.success) {
+        // Update local state
+        setSites(prev => prev.filter(site => site.id !== siteId));
+        setTotalSites(prev => Math.max(0, prev - 1));
+        
+        // Check if we still have any connected sites
+        const remainingSites = sites.filter(site => site.id !== siteId);
+        setConnected(remainingSites.length > 0);
+        
+        console.log('WordPress site disconnected successfully');
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error('Error disconnecting WordPress site:', error);
+      return false;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const testConnection = async (siteData: {
+    site_url: string;
+    site_name: string;
+    username: string;
+    app_password: string;
+  }): Promise<boolean> => {
+    try {
+      setIsLoading(true);
+      
+      // Format the site URL
+      const formattedUrl = wordpressAPI.formatSiteUrl(siteData.site_url);
+      
+      const success = await wordpressAPI.testConnection({
+        ...siteData,
+        site_url: formattedUrl
+      });
+      
+      console.log('WordPress connection test result:', success);
+      return success;
+    } catch (error) {
+      console.error('Error testing WordPress connection:', error);
+      return false;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const publishContent = async (publishData: {
+    site_id: number;
+    title: string;
+    content: string;
+    excerpt?: string;
+    featured_image_path?: string;
+    categories?: string[];
+    tags?: string[];
+    status?: 'draft' | 'publish' | 'private';
+    meta_description?: string;
+  }): Promise<{ success: boolean; post_id?: number; error?: string }> => {
+    try {
+      setIsLoading(true);
+      
+      const result = await wordpressAPI.publishContent(publishData);
+      
+      console.log('WordPress content published:', result);
+      return result;
+    } catch (error) {
+      console.error('Error publishing WordPress content:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const validateSiteUrl = useCallback((url: string): boolean => {
+    return wordpressAPI.validateSiteUrl(url);
+  }, []);
+
+  const formatSiteUrl = useCallback((url: string): string => {
+    return wordpressAPI.formatSiteUrl(url);
+  }, []);
+
+  const refreshStatus = useCallback(async (): Promise<void> => {
+    await checkStatus();
+  }, []);
+
+  return {
+    // Connection state
+    connected,
+    sites,
+    totalSites,
+    isLoading,
+    
+    // Connection actions
+    addSite,
+    disconnectSite,
+    testConnection,
+    
+    // Publishing actions
+    publishContent,
+    
+    // Utility functions
+    validateSiteUrl,
+    formatSiteUrl,
+    refreshStatus
+  };
+};