feat: add auth and data providers with mock data hooks

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/hooks/use-campaigns.ts

@@ -0,0 +1,37 @@
+import { useMemo } from 'react';
+
+import type { Campaign, Ad, CampaignStatus } from '@/types/entities';
+import { useData } from '@/providers/data-provider';
+
+type UseCampaignsFilters = {
+    status?: CampaignStatus;
+};
+
+type UseCampaignsResult = {
+    campaigns: Campaign[];
+    ads: Ad[];
+};
+
+export const useCampaigns = (filters: UseCampaignsFilters = {}): UseCampaignsResult => {
+    const { campaigns, ads } = useData();
+    const { status } = filters;
+
+    const filteredCampaigns = useMemo(() => {
+        if (status === undefined) {
+            return campaigns;
+        }
+
+        return campaigns.filter((campaign) => campaign.campaignStatus === status);
+    }, [campaigns, status]);
+
+    const filteredAds = useMemo(() => {
+        const campaignIds = new Set(filteredCampaigns.map((campaign) => campaign.id));
+
+        return ads.filter((ad) => ad.campaignId !== null && campaignIds.has(ad.campaignId));
+    }, [ads, filteredCampaigns]);
+
+    return {
+        campaigns: filteredCampaigns,
+        ads: filteredAds,
+    };
+};

src/hooks/use-follow-ups.ts

@@ -0,0 +1,42 @@
+import { useMemo } from 'react';
+
+import type { FollowUp } from '@/types/entities';
+import { useData } from '@/providers/data-provider';
+
+type UseFollowUpsResult = {
+    followUps: FollowUp[];
+    overdue: FollowUp[];
+    upcoming: FollowUp[];
+};
+
+export const useFollowUps = (): UseFollowUpsResult => {
+    const { followUps } = useData();
+
+    const now = useMemo(() => new Date(), []);
+
+    const overdue = useMemo(() => {
+        return followUps.filter((followUp) => {
+            if (followUp.followUpStatus === 'OVERDUE') {
+                return true;
+            }
+
+            if (followUp.followUpStatus === 'PENDING' && followUp.scheduledAt !== null) {
+                return new Date(followUp.scheduledAt) < now;
+            }
+
+            return false;
+        });
+    }, [followUps, now]);
+
+    const upcoming = useMemo(() => {
+        return followUps.filter((followUp) => {
+            return followUp.followUpStatus === 'PENDING' && followUp.scheduledAt !== null && new Date(followUp.scheduledAt) >= now;
+        });
+    }, [followUps, now]);
+
+    return {
+        followUps,
+        overdue,
+        upcoming,
+    };
+};

src/hooks/use-leads.ts

@@ -0,0 +1,56 @@
+import { useMemo } from 'react';
+
+import type { Lead, LeadSource, LeadStatus } from '@/types/entities';
+import { useData } from '@/providers/data-provider';
+
+type UseLeadsFilters = {
+    source?: LeadSource;
+    status?: LeadStatus;
+    search?: string;
+};
+
+type UseLeadsResult = {
+    leads: Lead[];
+    total: number;
+    updateLead: (id: string, updates: Partial<Lead>) => void;
+};
+
+export const useLeads = (filters: UseLeadsFilters = {}): UseLeadsResult => {
+    const { leads, updateLead } = useData();
+    const { source, status, search } = filters;
+
+    const filteredLeads = useMemo(() => {
+        return leads.filter((lead) => {
+            if (source !== undefined && lead.leadSource !== source) {
+                return false;
+            }
+
+            if (status !== undefined && lead.leadStatus !== status) {
+                return false;
+            }
+
+            if (search !== undefined && search.trim() !== '') {
+                const query = search.trim().toLowerCase();
+                const firstName = lead.contactName?.firstName?.toLowerCase() ?? '';
+                const lastName = lead.contactName?.lastName?.toLowerCase() ?? '';
+                const fullName = `${firstName} ${lastName}`.trim();
+                const phones = (lead.contactPhone ?? []).map((p) => p.number.toLowerCase());
+
+                const matchesName = firstName.includes(query) || lastName.includes(query) || fullName.includes(query);
+                const matchesPhone = phones.some((phone) => phone.includes(query));
+
+                if (!matchesName && !matchesPhone) {
+                    return false;
+                }
+            }
+
+            return true;
+        });
+    }, [leads, source, status, search]);
+
+    return {
+        leads: filteredLeads,
+        total: filteredLeads.length,
+        updateLead,
+    };
+};

src/providers/auth-provider.tsx

@@ -0,0 +1,68 @@
+import type { ReactNode } from 'react';
+import { createContext, useContext, useState } from 'react';
+
+export type Role = 'executive' | 'admin';
+
+type User = {
+    name: string;
+    initials: string;
+    role: Role;
+    email: string;
+};
+
+type AuthContextType = {
+    user: User;
+    setRole: (role: Role) => void;
+    isAdmin: boolean;
+    isAuthenticated: boolean;
+    login: () => void;
+    logout: () => void;
+};
+
+const USERS: Record<Role, User> = {
+    admin: {
+        name: 'Admin User',
+        initials: 'AU',
+        role: 'admin',
+        email: 'admin@ramaiah.com',
+    },
+    executive: {
+        name: 'Sanjay M.',
+        initials: 'SM',
+        role: 'executive',
+        email: 'sanjay@ramaiah.com',
+    },
+};
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+export const useAuth = (): AuthContextType => {
+    const context = useContext(AuthContext);
+
+    if (context === undefined) {
+        throw new Error('useAuth must be used within an AuthProvider');
+    }
+
+    return context;
+};
+
+interface AuthProviderProps {
+    children: ReactNode;
+}
+
+export const AuthProvider = ({ children }: AuthProviderProps) => {
+    const [role, setRole] = useState<Role>('executive');
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
+
+    const user = USERS[role];
+    const isAdmin = role === 'admin';
+
+    const login = () => setIsAuthenticated(true);
+    const logout = () => setIsAuthenticated(false);
+
+    return (
+        <AuthContext.Provider value={{ user, setRole, isAdmin, isAuthenticated, login, logout }}>
+            {children}
+        </AuthContext.Provider>
+    );
+};

src/providers/data-provider.tsx

@@ -0,0 +1,52 @@
+import type { ReactNode } from 'react';
+import { createContext, useContext, useState } from 'react';
+
+import type { Lead, Campaign, Ad, LeadActivity, FollowUp, WhatsAppTemplate, Agent } from '@/types/entities';
+import { mockLeads, mockCampaigns, mockAds, mockFollowUps, mockLeadActivities, mockTemplates, mockAgents } from '@/mocks';
+
+type DataContextType = {
+    leads: Lead[];
+    campaigns: Campaign[];
+    ads: Ad[];
+    followUps: FollowUp[];
+    leadActivities: LeadActivity[];
+    templates: WhatsAppTemplate[];
+    agents: Agent[];
+    updateLead: (id: string, updates: Partial<Lead>) => void;
+};
+
+const DataContext = createContext<DataContextType | undefined>(undefined);
+
+export const useData = (): DataContextType => {
+    const context = useContext(DataContext);
+
+    if (context === undefined) {
+        throw new Error('useData must be used within a DataProvider');
+    }
+
+    return context;
+};
+
+interface DataProviderProps {
+    children: ReactNode;
+}
+
+export const DataProvider = ({ children }: DataProviderProps) => {
+    const [leads, setLeads] = useState<Lead[]>(mockLeads);
+    const [campaigns] = useState<Campaign[]>(mockCampaigns);
+    const [ads] = useState<Ad[]>(mockAds);
+    const [followUps] = useState<FollowUp[]>(mockFollowUps);
+    const [leadActivities] = useState<LeadActivity[]>(mockLeadActivities);
+    const [templates] = useState<WhatsAppTemplate[]>(mockTemplates);
+    const [agents] = useState<Agent[]>(mockAgents);
+
+    const updateLead = (id: string, updates: Partial<Lead>) => {
+        setLeads((prev) => prev.map((lead) => (lead.id === id ? { ...lead, ...updates } : lead)));
+    };
+
+    return (
+        <DataContext.Provider value={{ leads, campaigns, ads, followUps, leadActivities, templates, agents, updateLead }}>
+            {children}
+        </DataContext.Provider>
+    );
+};