Merge branch 'main' into org_announcements

Author: ashrit-ram-anala

backend/app.ts

@@ -63,7 +63,7 @@ app.use('/api/blogs', blogRoutes);
 app.use('/api/notifications', inAppNotificationRoutes);
 app.use('/api/email-notifications', notificationRoutes);
 app.use('/api/contact', contactRoutes);
-app.use('/api/uploads', fileUploadRoutes);
+app.use('/api/files', fileUploadRoutes);
 app.use('/api/page-content', pageContentRoutes);
 app.use('/api/map', mapRoutes);
 

backend/controllers/adminController.ts

@@ -148,6 +148,253 @@ export const deleteAdmin = async (req: AuthenticatedRequest, res: Response) => {
  * @route   POST /api/admins/promote
  * @access  Admin only
  */
+
+/**
+ * @desc    Get dashboard statistics
+ * @route   GET /api/admins/stats
+ * @access  Admin only
+ */
+export const getDashboardStats = async (req: AuthenticatedRequest, res: Response) => {
+  try {
+    if (!isAdmin(req.user?.role)) {
+      return res.status(403).json({ error: 'Access denied. Admin privileges required.' });
+    }
+
+    const [
+      totalOrganizations,
+      pendingOrganizations,
+      approvedOrganizations,
+      totalAnnouncements,
+      totalBlogs,
+      totalSurveys,
+      activeSurveys,
+      totalEmailSubscribers,
+      totalAlerts,
+      recentActivity,
+      organizationsWithLocation,
+      upcomingSurveyDeadlines,
+      recentSurveyResponses,
+
+      orgGrowthData,
+      subscriptionGrowthData,
+
+      allSurveys,
+    ] = await Promise.all([
+      prisma.organization.count(),
+      prisma.organization.count({ where: { status: 'PENDING' } }),
+      prisma.organization.count({ where: { status: 'ACTIVE' } }),
+
+      prisma.announcements.count(),
+      prisma.blog.count(),
+      prisma.survey.count(),
+      prisma.survey.count({ where: { isActive: true } }),
+      prisma.emailSubscription.count(),
+      prisma.alert.count(),
+
+      Promise.all([
+        prisma.organization.findMany({
+          take: 5,
+          orderBy: { createdAt: 'desc' },
+          select: { id: true, name: true, createdAt: true, status: true },
+        }),
+        prisma.announcements.findMany({
+          take: 5,
+          orderBy: { createdAt: 'desc' },
+          select: { id: true, title: true, createdAt: true },
+        }),
+        prisma.survey.findMany({
+          take: 5,
+          orderBy: { createdAt: 'desc' },
+          select: { id: true, title: true, createdAt: true },
+        }),
+      ]),
+
+      prisma.organization.findMany({
+        where: {
+          status: 'ACTIVE',
+          latitude: { not: null },
+          longitude: { not: null },
+        },
+        select: {
+          id: true,
+          name: true,
+          latitude: true,
+          longitude: true,
+          address: true,
+          city: true,
+          website: true,
+        },
+      }),
+
+      prisma.survey.findMany({
+        where: {
+          isActive: true,
+          dueDate: {
+            gte: new Date(),
+            lte: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+          },
+        },
+        take: 5,
+        orderBy: { dueDate: 'asc' },
+        select: { id: true, title: true, dueDate: true },
+      }),
+
+      prisma.surveyResponse.findMany({
+        where: {
+          submittedDate: {
+            gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+          },
+        },
+        take: 10,
+        orderBy: { submittedDate: 'desc' },
+        select: {
+          id: true,
+          submittedDate: true,
+          survey: { select: { id: true, title: true } },
+          organization: { select: { id: true, name: true } },
+        },
+      }),
+
+      prisma.organization.findMany({
+        where: {
+          createdAt: {
+            gte: new Date(Date.now() - 6 * 30 * 24 * 60 * 60 * 1000),
+          },
+        },
+        select: { createdAt: true },
+        orderBy: { createdAt: 'asc' },
+      }),
+
+      prisma.emailSubscription.findMany({
+        where: {
+          createdAt: {
+            gte: new Date(Date.now() - 6 * 30 * 24 * 60 * 60 * 1000),
+          },
+        },
+        select: { createdAt: true },
+        orderBy: { createdAt: 'asc' },
+      }),
+
+      prisma.survey.findMany({
+        where: { isPublished: true },
+        select: {
+          id: true,
+          title: true,
+          _count: {
+            select: { surveyResponses: true },
+          },
+        },
+      }),
+    ]);
+
+    const aggregateByMonth = (items: { createdAt: Date }[]) => {
+      const months: Record<string, number> = {};
+      const now = new Date();
+
+      for (let i = 5; i >= 0; i--) {
+        const date = new Date(now.getFullYear(), now.getMonth() - i, 1);
+        const key = date.toLocaleString('default', { month: 'short', year: '2-digit' });
+        months[key] = 0;
+      }
+
+      items.forEach(item => {
+        const date = new Date(item.createdAt);
+        const key = date.toLocaleString('default', { month: 'short', year: '2-digit' });
+        if (months[key] !== undefined) {
+          months[key]++;
+        }
+      });
+
+      let cumulative = 0;
+      return Object.entries(months).map(([month, count]) => {
+        cumulative += count;
+        return { month, count: cumulative };
+      });
+    };
+
+    const growthData = {
+      organizations: aggregateByMonth(orgGrowthData),
+      subscriptions: aggregateByMonth(subscriptionGrowthData),
+    };
+
+    const totalActiveOrgs = approvedOrganizations;
+    const surveyResponseRates = allSurveys.map((survey: any) => ({
+      id: survey.id,
+      title: survey.title,
+      totalSent: totalActiveOrgs,
+      totalResponded: survey._count.surveyResponses,
+      responseRate:
+        totalActiveOrgs > 0
+          ? Math.round((survey._count.surveyResponses / totalActiveOrgs) * 100)
+          : 0,
+    }));
+
+    const [recentOrgs, recentAnnouncements, recentSurveys] = recentActivity;
+    const formattedActivity = [
+      ...recentOrgs.map((org: any) => ({
+        id: org.id,
+        type: 'organization',
+        title: org.name,
+        description:
+          org.status === 'PENDING' ? 'New registration (pending)' : 'Organization registered',
+        createdAt: org.createdAt,
+      })),
+      ...recentAnnouncements.map((ann: any) => ({
+        id: ann.id,
+        type: 'announcement',
+        title: ann.title,
+        description: 'Announcement created',
+        createdAt: ann.createdAt,
+      })),
+      ...recentSurveys.map((survey: any) => ({
+        id: survey.id,
+        type: 'survey',
+        title: survey.title,
+        description: 'Survey created',
+        createdAt: survey.createdAt,
+      })),
+    ]
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+      .slice(0, 10);
+
+    res.json({
+      stats: {
+        totalOrganizations,
+        pendingOrganizations,
+        approvedOrganizations,
+        totalAnnouncements,
+        totalBlogs,
+        totalSurveys,
+        activeSurveys,
+        totalEmailSubscribers,
+        totalAlerts,
+      },
+      recentActivity: formattedActivity,
+      organizationsWithLocation,
+      actionItems: {
+        pendingOrganizations,
+        upcomingSurveyDeadlines: upcomingSurveyDeadlines.map((s: any) => ({
+          id: s.id,
+          title: s.title,
+          endDate: s.dueDate,
+        })),
+        recentSurveyResponses: recentSurveyResponses.map((r: any) => ({
+          id: r.id,
+          surveyId: r.survey.id,
+          surveyTitle: r.survey.title,
+          organizationName: r.organization.name,
+          submittedDate: r.submittedDate,
+        })),
+      },
+      growthData,
+      surveyResponseRates,
+    });
+  } catch (error) {
+    console.error('Error fetching dashboard stats:', error);
+    res.status(500).json({ error: 'Failed to fetch dashboard statistics' });
+  }
+};
+
 export const promoteToAdmin = async (req: AuthenticatedRequest, res: Response) => {
   try {
     if (!isAdmin(req.user?.role)) {

backend/controllers/blogController.ts

@@ -148,10 +148,26 @@ export const createBlog = async (req: AuthenticatedRequest, res: Response) => {
     if (!req.user) return res.status(401).json({ error: 'Not authenticated' });
     if (!isAdmin(req.user.role)) return res.status(403).json({ error: 'Admin only' });
 
-    const { title, content, author, tags, tagIds, featuredImageUrl, isPublished, publishedDate } =
-      req.body;
-
-    console.log('createBlog - Received data:', { title, author, tags, tagIds, isPublished });
+    const {
+      title,
+      content,
+      author,
+      tags,
+      tagIds,
+      featuredImageUrl,
+      isPublished,
+      publishedDate,
+      attachmentUrls,
+    } = req.body;
+
+    console.log('createBlog - Received data:', {
+      title,
+      author,
+      tags,
+      tagIds,
+      isPublished,
+      attachmentUrls,
+    });
 
     if (!title || !content || !author) {
       return res.status(400).json({ error: 'title, content, and author are required' });
@@ -166,6 +182,7 @@ export const createBlog = async (req: AuthenticatedRequest, res: Response) => {
         featuredImageUrl: featuredImageUrl || null,
         isPublished: isPublished || false,
         publishedDate: isPublished ? publishedDate || new Date() : null,
+        attachmentUrls: attachmentUrls || [],
       },
     });
 
@@ -214,13 +231,14 @@ export const updateBlog = async (req: AuthenticatedRequest, res: Response) => {
     });
     if (!blogToUpdate) return res.status(404).json({ error: 'Blog not found' });
 
-    const { title, content, author, tags, tagIds, featuredImageUrl } = req.body;
+    const { title, content, author, tags, tagIds, featuredImageUrl, attachmentUrls } = req.body;
 
     const updateData: any = {
       ...(title && { title }),
       ...(content && { content }),
       ...(author && { author }),
       ...(featuredImageUrl !== undefined && { featuredImageUrl }),
+      ...(attachmentUrls !== undefined && { attachmentUrls }),
     };
 
     // Handle tags update if provided (accept both 'tags' and 'tagIds')