{credentials.map((credential, index) => (
) : (
)}
diff --git a/hooks/profile/__tests__/use-all-time-stats.test.ts b/hooks/profile/__tests__/use-all-time-stats.test.ts
new file mode 100644
index 0000000..634933a
--- /dev/null
+++ b/hooks/profile/__tests__/use-all-time-stats.test.ts
@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+
+vi.mock('@/utils/helpers', () => ({
+ getTenant: vi.fn(() => 'test-tenant'),
+ getUserId: vi.fn(() => 42),
+ getUserName: vi.fn(() => 'test-user'),
+}));
+
+const mockGetUserReportedSkills = vi.fn();
+const mockGetUserDesiredSkills = vi.fn();
+
+vi.mock('@iblai/iblai-js/data-layer', () => ({
+ useLazyGetUserReportedSkillsQuery: vi.fn(() => [mockGetUserReportedSkills, { isError: false }]),
+ useLazyGetUserDesiredSkillsQuery: vi.fn(() => [mockGetUserDesiredSkills, { isError: false }]),
+}));
+
+const mockGetUserCredentials = vi.fn();
+vi.mock('@/services/credentials', () => ({
+ useLazyGetUserCredentialsQuery: vi.fn(() => [mockGetUserCredentials, { isError: false }]),
+}));
+
+const mockGetUserEnrolledCourses = vi.fn();
+vi.mock('@/services/courses', () => ({
+ useLazyGetUserEnrolledCoursesQuery: vi.fn(() => [mockGetUserEnrolledCourses, { isError: false }]),
+}));
+
+import { useAllTimeStats } from '../use-all-time-stats';
+
+describe('useAllTimeStats', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockGetUserReportedSkills.mockResolvedValue({ data: null });
+ mockGetUserDesiredSkills.mockResolvedValue({ data: null });
+ mockGetUserCredentials.mockResolvedValue({ data: null });
+ mockGetUserEnrolledCourses.mockResolvedValue({ data: null });
+ });
+
+ it('returns expected shape with zero defaults', () => {
+ const { result } = renderHook(() => useAllTimeStats());
+ expect(result.current.courses).toBe(0);
+ expect(result.current.credentials).toBe(0);
+ expect(result.current.skills).toBe(0);
+ });
+
+ it('updates skills count from reported and desired skills', async () => {
+ mockGetUserReportedSkills.mockResolvedValue({
+ data: { skills: [{ name: 'Python' }, { name: 'JavaScript' }] },
+ });
+ mockGetUserDesiredSkills.mockResolvedValue({
+ data: { skills: [{ name: 'React' }] },
+ });
+
+ const { result } = renderHook(() => useAllTimeStats());
+
+ await waitFor(() => {
+ expect(result.current.skills).toBe(3);
+ });
+ });
+
+ it('updates credentials count', async () => {
+ mockGetUserCredentials.mockResolvedValue({
+ data: { data: [{ id: 'cred-1' }, { id: 'cred-2' }] },
+ });
+
+ const { result } = renderHook(() => useAllTimeStats());
+
+ await waitFor(() => {
+ expect(result.current.credentials).toBe(2);
+ });
+ });
+
+ it('updates courses count', async () => {
+ mockGetUserEnrolledCourses.mockResolvedValue({
+ data: { count: 5 },
+ });
+
+ const { result } = renderHook(() => useAllTimeStats());
+
+ await waitFor(() => {
+ expect(result.current.courses).toBe(5);
+ });
+ });
+
+ it('keeps counts at 0 on empty responses', async () => {
+ const { result } = renderHook(() => useAllTimeStats());
+
+ await waitFor(() => {
+ expect(mockGetUserEnrolledCourses).toHaveBeenCalled();
+ });
+ expect(result.current.courses).toBe(0);
+ expect(result.current.credentials).toBe(0);
+ expect(result.current.skills).toBe(0);
+ });
+
+ it('keeps counts at 0 when fetches reject', async () => {
+ mockGetUserReportedSkills.mockRejectedValue(new Error('network'));
+ mockGetUserDesiredSkills.mockRejectedValue(new Error('network'));
+ mockGetUserCredentials.mockRejectedValue(new Error('network'));
+ mockGetUserEnrolledCourses.mockRejectedValue(new Error('network'));
+
+ const { result } = renderHook(() => useAllTimeStats());
+
+ await waitFor(() => {
+ expect(mockGetUserEnrolledCourses).toHaveBeenCalled();
+ });
+ expect(result.current.courses).toBe(0);
+ expect(result.current.credentials).toBe(0);
+ expect(result.current.skills).toBe(0);
+ });
+});
diff --git a/hooks/profile/use-all-time-stats.ts b/hooks/profile/use-all-time-stats.ts
new file mode 100644
index 0000000..4b9a507
--- /dev/null
+++ b/hooks/profile/use-all-time-stats.ts
@@ -0,0 +1,109 @@
+import { getTenant, getUserId, getUserName } from '@/utils/helpers';
+import { useState, useEffect } from 'react';
+import {
+ // @ts-ignore
+ useLazyGetUserReportedSkillsQuery,
+ // @ts-ignore
+ useLazyGetUserDesiredSkillsQuery,
+} from '@iblai/iblai-js/data-layer';
+import _ from 'lodash';
+import { useLazyGetUserCredentialsQuery } from '@/services/credentials';
+import { useLazyGetUserEnrolledCoursesQuery } from '@/services/courses';
+
+export const useAllTimeStats = () => {
+ const [getUserReportedSkills, { isError: isErrorGetUserReportedSkills }] =
+ useLazyGetUserReportedSkillsQuery();
+ const [getUserDesiredSkills, { isError: isErrorGetUserDesiredSkills }] =
+ useLazyGetUserDesiredSkillsQuery();
+ const [getUserCredentials, { isError: isErrorGetUserCredentials }] =
+ useLazyGetUserCredentialsQuery();
+ const [getUserEnrolledCourses, { isError: isErrorGetUserEnrolledCourses }] =
+ useLazyGetUserEnrolledCoursesQuery();
+
+ const [courses, setCourses] = useState(0);
+ const [credentials, setCredentials] = useState(0);
+ const [skills, setSkills] = useState(0);
+
+ const handleSkillsStats = async () => {
+ try {
+ const reportedSkills = await getUserReportedSkills(
+ [
+ {
+ userId: getUserId(),
+ username: getUserName(),
+ },
+ ],
+ true,
+ );
+ let skillsCount = 0;
+ if (isErrorGetUserDesiredSkills && isErrorGetUserReportedSkills) {
+ throw new Error();
+ }
+ if (!isErrorGetUserReportedSkills) {
+ skillsCount = reportedSkills?.data?.skills?.length || 0;
+ }
+ const earnedSkills = await getUserDesiredSkills(
+ [
+ {
+ userId: getUserId(),
+ username: getUserName(),
+ },
+ ],
+ true,
+ );
+ if (!isErrorGetUserDesiredSkills) {
+ skillsCount += earnedSkills?.data?.skills?.length || 0;
+ }
+ setSkills(skillsCount);
+ } catch {
+ setSkills(0);
+ }
+ };
+
+ const handleCredentialsStats = async () => {
+ try {
+ const response = await getUserCredentials(
+ {
+ org: getTenant(),
+ username: getUserName(),
+ },
+ true,
+ );
+ if (isErrorGetUserCredentials || _.isEmpty(response?.data)) {
+ throw new Error();
+ }
+ setCredentials(response?.data?.data?.length || 0);
+ } catch {
+ setCredentials(0);
+ }
+ };
+
+ const handleCoursesStats = async () => {
+ try {
+ const response = await getUserEnrolledCourses(
+ {
+ username: getUserName(),
+ },
+ true,
+ );
+ if (isErrorGetUserEnrolledCourses || _.isEmpty(response.data)) {
+ throw new Error();
+ }
+ setCourses(response?.data?.count || 0);
+ } catch {
+ setCourses(0);
+ }
+ };
+
+ useEffect(() => {
+ handleSkillsStats();
+ handleCredentialsStats();
+ handleCoursesStats();
+ }, []);
+
+ return {
+ courses,
+ credentials,
+ skills,
+ };
+};