update

2025-10-08 13:46:46 +03:00
parent d48c54e2c5
commit 18ae8b9f88
94 changed files with 8882 additions and 1682 deletions
--- a/gnx-react/lib/hooks/useBlog.ts
+++ b/gnx-react/lib/hooks/useBlog.ts
@@ -0,0 +1,250 @@
+import { useState, useEffect } from 'react';
+import { 
+  blogService, 
+  BlogPost, 
+  BlogPostListResponse,
+  BlogCategory,
+  BlogTag,
+  BlogAuthor 
+} from '../api/blogService';
+
+// Hook for fetching all blog posts
+export const useBlogPosts = (params?: {
+  category?: string;
+  tag?: string;
+  author?: number;
+  search?: string;
+  featured?: boolean;
+  ordering?: string;
+  page?: number;
+  page_size?: number;
+}) => {
+  const [posts, setPosts] = useState<BlogPost[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+  const [pagination, setPagination] = useState<{
+    count: number;
+    next: string | null;
+    previous: string | null;
+  }>({ count: 0, next: null, previous: null });
+
+  useEffect(() => {
+    const fetchPosts = async () => {
+      try {
+        setLoading(true);
+        const data = await blogService.getPosts(params);
+        setPosts(data.results);
+        setPagination({
+          count: data.count,
+          next: data.next,
+          previous: data.previous
+        });
+        setError(null);
+      } catch (err) {
+        setError(err as Error);
+        setPosts([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchPosts();
+  }, [params?.category, params?.tag, params?.author, params?.search, params?.page, params?.page_size]);
+
+  return { posts, loading, error, pagination, totalCount: pagination.count };
+};
+
+// Hook for fetching a single blog post by slug
+export const useBlogPost = (slug: string | null) => {
+  const [post, setPost] = useState<BlogPost | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    if (!slug) {
+      setLoading(false);
+      return;
+    }
+
+    const fetchPost = async () => {
+      try {
+        setLoading(true);
+        const data = await blogService.getPostBySlug(slug);
+        setPost(data);
+        setError(null);
+      } catch (err) {
+        setError(err as Error);
+        setPost(null);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchPost();
+  }, [slug]);
+
+  return { post, loading, error };
+};
+
+// Hook for fetching featured blog posts
+export const useFeaturedPosts = () => {
+  const [posts, setPosts] = useState<BlogPost[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchFeaturedPosts = async () => {
+      try {
+        setLoading(true);
+        const data = await blogService.getFeaturedPosts();
+        setPosts(data);
+        setError(null);
+      } catch (err) {
+        setError(err as Error);
+        setPosts([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchFeaturedPosts();
+  }, []);
+
+  return { posts, loading, error };
+};
+
+// Hook for fetching latest blog posts
+export const useLatestPosts = (limit: number = 5) => {
+  const [posts, setPosts] = useState<BlogPost[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchLatestPosts = async () => {
+      try {
+        setLoading(true);
+        const data = await blogService.getLatestPosts(limit);
+        setPosts(data);
+        setError(null);
+      } catch (err) {
+        setError(err as Error);
+        setPosts([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchLatestPosts();
+  }, [limit]);
+
+  return { posts, loading, error };
+};
+
+// Hook for fetching popular blog posts
+export const usePopularPosts = (limit: number = 5) => {
+  const [posts, setPosts] = useState<BlogPost[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchPopularPosts = async () => {
+      try {
+        setLoading(true);
+        const data = await blogService.getPopularPosts(limit);
+        setPosts(data);
+        setError(null);
+      } catch (err) {
+        setError(err as Error);
+        setPosts([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchPopularPosts();
+  }, [limit]);
+
+  return { posts, loading, error };
+};
+
+// Hook for fetching blog categories
+export const useBlogCategories = () => {
+  const [categories, setCategories] = useState<BlogCategory[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchCategories = async () => {
+      try {
+        setLoading(true);
+        const data = await blogService.getCategories();
+        setCategories(data);
+        setError(null);
+      } catch (err) {
+        setError(err as Error);
+        setCategories([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchCategories();
+  }, []);
+
+  return { categories, loading, error };
+};
+
+// Hook for fetching blog tags
+export const useBlogTags = () => {
+  const [tags, setTags] = useState<BlogTag[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchTags = async () => {
+      try {
+        setLoading(true);
+        const data = await blogService.getTags();
+        setTags(data);
+        setError(null);
+      } catch (err) {
+        setError(err as Error);
+        setTags([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchTags();
+  }, []);
+
+  return { tags, loading, error };
+};
+
+// Hook for fetching blog authors
+export const useBlogAuthors = () => {
+  const [authors, setAuthors] = useState<BlogAuthor[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchAuthors = async () => {
+      try {
+        setLoading(true);
+        const data = await blogService.getAuthors();
+        setAuthors(data);
+        setError(null);
+      } catch (err) {
+        setError(err as Error);
+        setAuthors([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchAuthors();
+  }, []);
+
+  return { authors, loading, error };
+};
+
--- a/gnx-react/lib/hooks/useCaseStudy.ts
+++ b/gnx-react/lib/hooks/useCaseStudy.ts
@@ -0,0 +1,351 @@
+import { useState, useEffect } from 'react';
+import caseStudyService, {
+  CaseStudy,
+  CaseStudyCategory,
+  Client,
+  CaseStudyListResponse,
+} from '../api/caseStudyService';
+
+// Hook to fetch all case studies
+export const useCaseStudies = (params?: {
+  category?: string;
+  client?: string;
+  search?: string;
+  featured?: boolean;
+  ordering?: string;
+  page?: number;
+  page_size?: number;
+}) => {
+  const [caseStudies, setCaseStudies] = useState<CaseStudy[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+  const [pagination, setPagination] = useState<{
+    count: number;
+    next: string | null;
+    previous: string | null;
+  } | null>(null);
+
+  useEffect(() => {
+    const fetchCaseStudies = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getCaseStudies(params);
+        setCaseStudies(data.results);
+        setPagination({
+          count: data.count,
+          next: data.next,
+          previous: data.previous,
+        });
+      } catch (err) {
+        setError(err as Error);
+        console.error('Error fetching case studies:', err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchCaseStudies();
+  }, [
+    params?.category,
+    params?.client,
+    params?.search,
+    params?.featured,
+    params?.ordering,
+    params?.page,
+    params?.page_size,
+  ]);
+
+  return { caseStudies, loading, error, pagination };
+};
+
+// Hook to fetch a single case study by slug
+export const useCaseStudy = (slug: string | null) => {
+  const [caseStudy, setCaseStudy] = useState<CaseStudy | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    if (!slug) {
+      setLoading(false);
+      return;
+    }
+
+    const fetchCaseStudy = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getCaseStudyBySlug(slug);
+        setCaseStudy(data);
+      } catch (err) {
+        setError(err as Error);
+        console.error(`Error fetching case study ${slug}:`, err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchCaseStudy();
+  }, [slug]);
+
+  return { caseStudy, loading, error };
+};
+
+// Hook to fetch featured case studies
+export const useFeaturedCaseStudies = () => {
+  const [featuredCaseStudies, setFeaturedCaseStudies] = useState<CaseStudy[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchFeaturedCaseStudies = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getFeaturedCaseStudies();
+        setFeaturedCaseStudies(data);
+      } catch (err) {
+        setError(err as Error);
+        console.error('Error fetching featured case studies:', err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchFeaturedCaseStudies();
+  }, []);
+
+  return { featuredCaseStudies, loading, error };
+};
+
+// Hook to fetch latest case studies
+export const useLatestCaseStudies = (limit: number = 6) => {
+  const [latestCaseStudies, setLatestCaseStudies] = useState<CaseStudy[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchLatestCaseStudies = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getLatestCaseStudies(limit);
+        setLatestCaseStudies(data);
+      } catch (err) {
+        setError(err as Error);
+        console.error('Error fetching latest case studies:', err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchLatestCaseStudies();
+  }, [limit]);
+
+  return { latestCaseStudies, loading, error };
+};
+
+// Hook to fetch popular case studies
+export const usePopularCaseStudies = (limit: number = 6) => {
+  const [popularCaseStudies, setPopularCaseStudies] = useState<CaseStudy[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchPopularCaseStudies = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getPopularCaseStudies(limit);
+        setPopularCaseStudies(data);
+      } catch (err) {
+        setError(err as Error);
+        console.error('Error fetching popular case studies:', err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchPopularCaseStudies();
+  }, [limit]);
+
+  return { popularCaseStudies, loading, error };
+};
+
+// Hook to fetch related case studies
+export const useRelatedCaseStudies = (slug: string | null) => {
+  const [relatedCaseStudies, setRelatedCaseStudies] = useState<CaseStudy[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    if (!slug) {
+      setLoading(false);
+      return;
+    }
+
+    const fetchRelatedCaseStudies = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getRelatedCaseStudies(slug);
+        setRelatedCaseStudies(data);
+      } catch (err) {
+        setError(err as Error);
+        console.error(`Error fetching related case studies for ${slug}:`, err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchRelatedCaseStudies();
+  }, [slug]);
+
+  return { relatedCaseStudies, loading, error };
+};
+
+// Hook to fetch case study categories
+export const useCaseStudyCategories = () => {
+  const [categories, setCategories] = useState<CaseStudyCategory[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchCategories = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getCategories();
+        setCategories(data);
+      } catch (err) {
+        setError(err as Error);
+        console.error('Error fetching case study categories:', err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchCategories();
+  }, []);
+
+  return { categories, loading, error };
+};
+
+// Hook to fetch categories with case studies
+export const useCategoriesWithCaseStudies = () => {
+  const [categories, setCategories] = useState<CaseStudyCategory[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchCategories = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getCategoriesWithCaseStudies();
+        setCategories(data);
+      } catch (err) {
+        setError(err as Error);
+        console.error('Error fetching categories with case studies:', err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchCategories();
+  }, []);
+
+  return { categories, loading, error };
+};
+
+// Hook to fetch all clients
+export const useClients = () => {
+  const [clients, setClients] = useState<Client[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const fetchClients = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getClients();
+        setClients(data);
+      } catch (err) {
+        setError(err as Error);
+        console.error('Error fetching clients:', err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchClients();
+  }, []);
+
+  return { clients, loading, error };
+};
+
+// Hook to fetch a single client by slug
+export const useClient = (slug: string | null) => {
+  const [client, setClient] = useState<Client | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    if (!slug) {
+      setLoading(false);
+      return;
+    }
+
+    const fetchClient = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getClientBySlug(slug);
+        setClient(data);
+      } catch (err) {
+        setError(err as Error);
+        console.error(`Error fetching client ${slug}:`, err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchClient();
+  }, [slug]);
+
+  return { client, loading, error };
+};
+
+// Hook to fetch case studies for a specific client
+export const useClientCaseStudies = (slug: string | null) => {
+  const [caseStudies, setCaseStudies] = useState<CaseStudy[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    if (!slug) {
+      setLoading(false);
+      return;
+    }
+
+    const fetchClientCaseStudies = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const data = await caseStudyService.getClientCaseStudies(slug);
+        setCaseStudies(data.results);
+      } catch (err) {
+        setError(err as Error);
+        console.error(`Error fetching case studies for client ${slug}:`, err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchClientCaseStudies();
+  }, [slug]);
+
+  return { caseStudies, loading, error };
+};
+