v1.0.6c - CMS-77 CMS-78 CMS-79 CMS-80 CMS-81 CMS-83 CMS-84 feat: Complete overhaul of all pages, introduce subscription client and newsletter management, new blog post pages, and enhance location features with updated UI components and visuals. Needs further testing, and pricing components from PortalPay docs.

Author: mmfmilton

actions/audit.ts

@@ -8,7 +8,8 @@ export async function logActivityInternal(
     userId: string,
     action: string,
     resource: string,
-    details?: string
+    details?: string,
+    metadata?: Record<string, any>
 ) {
     try {
         await prismadb.systemActivity.create({
@@ -17,6 +18,7 @@ export async function logActivityInternal(
                 action,
                 resource,
                 details,
+                metadata,
             },
         });
     } catch (error) {
@@ -27,13 +29,14 @@ export async function logActivityInternal(
 export async function logActivity(
     action: string,
     resource: string,
-    details?: string
+    details?: string,
+    metadata?: Record<string, any>
 ) {
     try {
         const session = await getServerSession(authOptions);
         if (!session?.user?.id) return;
 
-        await logActivityInternal(session.user.id, action, resource, details);
+        await logActivityInternal(session.user.id, action, resource, details, metadata);
     } catch (error) {
         console.error("Failed to log activity:", error);
     }

actions/cms/generate-blog-post.ts

@@ -59,6 +59,20 @@ export async function generateBlogPost(topic: string) {
             temperature: isReasoningModel(model.modelId) ? undefined : 1,
         });
 
+        // Log Activity
+        const { logActivityInternal } = await import("@/actions/audit");
+        await logActivityInternal(
+            userId,
+            "Generated Blog Post",
+            "Content AI",
+            `Generated draft for topic: "${topic}"`,
+            {
+                title: object.title,
+                category: object.category,
+                slug: object.slug
+            }
+        );
+
         return object;
     } catch (error: any) {
         console.error("Error generating blog post:", {

actions/cms/save-landing-page.ts

@@ -15,7 +15,15 @@ export async function saveLandingPage(id: string, data: any) {
         revalidatePath(`/cms/landing`);
         revalidatePath(`/landing`);
 
-        await logActivity("Update Landing Page", "Landing Page", `Updated content for page ID: ${id}`);
+        await logActivity(
+            "Update Landing Page",
+            "Landing Page",
+            `Updated content for page ID: ${id}`,
+            {
+                pageId: id,
+                sectionsCount: Array.isArray(data) ? data.length : (Array.isArray(data?.content) ? data.content.length : 0)
+            }
+        );
 
         return { success: true };
     } catch (error) {

actions/cms/subscriptions.ts

@@ -1,121 +1,141 @@
 "use server";
 
 import { prismadb } from "@/lib/prisma";
-import { getServerSession } from "next-auth";
-import { authOptions } from "@/lib/auth";
 import { revalidatePath } from "next/cache";
-import { logActivity } from "@/lib/cms/audit";
 
-export async function getSubscribers(page = 1, limit = 20, search = "") {
-    const session = await getServerSession(authOptions);
-    if (!session?.user?.isAdmin) {
-        return { success: false, error: "Unauthorized" };
+export async function getClients(query?: string) {
+    try {
+        const where: any = {
+            assigned_team: {
+                isNot: null
+            }
+        };
+
+        if (query) {
+            where.OR = [
+                { name: { contains: query, mode: "insensitive" } },
+                { email: { contains: query, mode: "insensitive" } },
+                { assigned_team: { name: { contains: query, mode: "insensitive" } } }
+            ];
+        }
+
+        const users = await prismadb.users.findMany({
+            where: {
+                ...where,
+                email: { not: "admin@ledger1.ai" },
+            },
+            include: {
+                assigned_team: {
+                    include: {
+                        assigned_plan: true
+                    }
+                },
+                assigned_role: true
+            },
+            orderBy: { created_on: 'desc' }
+        });
+
+        return users.filter(u => u.assigned_team);
+    } catch (error) {
+        console.error("Failed to get clients:", error);
+        return [];
     }
+}
 
+// Updated to match SubscriptionClient requirement
+export async function getSubscribers(page: number = 1, limit: number = 20, query: string = "") {
     try {
-        const skip = (page - 1) * limit;
-
         const where: any = {};
-        if (search) {
+        if (query) {
             where.OR = [
-                { email: { contains: search, mode: "insensitive" } },
-                { firstName: { contains: search, mode: "insensitive" } },
-                { lastName: { contains: search, mode: "insensitive" } },
+                { email: { contains: query, mode: "insensitive" } },
+                { firstName: { contains: query, mode: "insensitive" } },
+                { lastName: { contains: query, mode: "insensitive" } }
             ];
         }
 
-        const [subscribers, total] = await Promise.all([
-            prismadb.subscriber.findMany({
+        const skip = (page - 1) * limit;
+
+        const [data, total] = await Promise.all([
+            prismadb.newsletterSubscriber.findMany({
                 where,
                 skip,
                 take: limit,
-                orderBy: { createdAt: "desc" },
+                orderBy: { createdAt: 'desc' }
             }),
-            prismadb.subscriber.count({ where }),
+            prismadb.newsletterSubscriber.count({ where })
         ]);
 
         return {
             success: true,
-            data: subscribers,
+            data,
             pagination: {
+                page,
+                limit,
                 total,
-                pages: Math.ceil(total / limit),
-                current: page,
-                limit
+                totalPages: Math.ceil(total / limit)
             }
         };
     } catch (error) {
-        console.error("[GET_SUBSCRIBERS]", error);
+        console.error("Failed to get subscribers:", error);
         return { success: false, error: "Failed to fetch subscribers" };
     }
 }
 
-export async function addSubscriber(data: { email: string; firstName?: string; lastName?: string }) {
-    const session = await getServerSession(authOptions);
-    if (!session?.user?.isAdmin) {
-        return { success: false, error: "Unauthorized" };
-    }
+// Backward compatibility alias if needed, or strictly use getSubscribers
+export async function getNewsletterSubscribers(query?: string) {
+    // Reuse new logic but return array (old behavior)
+    const result = await getSubscribers(1, 1000, query); // Default to first 1000
+    return result.success ? result.data : [];
+}
 
+export async function addSubscriber(data: { email: string, firstName?: string, lastName?: string }) {
     try {
-        const existing = await prismadb.subscriber.findUnique({
-            where: { email: data.email },
+        if (!data.email) return { success: false, error: "Email is required" };
+
+        const existing = await prismadb.newsletterSubscriber.findFirst({
+            where: { email: data.email }
         });
 
         if (existing) {
             return { success: false, error: "Subscriber already exists" };
         }
 
-        const subscriber = await prismadb.subscriber.create({
+        await prismadb.newsletterSubscriber.create({
             data: {
                 email: data.email,
                 firstName: data.firstName,
                 lastName: data.lastName,
-                subscribedToBlog: true,
-                subscribedToCareers: true,
-            },
+                status: "SUBSCRIBED",
+                source: "Admin Manual Add"
+            }
         });
 
-        await logActivity("ADD_SUBSCRIBER", "Subscription", `Added subscriber ${data.email}`);
-        revalidatePath("/cms/subscriptions");
-        return { success: true, data: subscriber };
+        revalidatePath("/cms/subscriptions/newsletter");
+        return { success: true };
     } catch (error) {
-        console.error("[ADD_SUBSCRIBER]", error);
+        console.error("Add subscriber error:", error);
         return { success: false, error: "Failed to add subscriber" };
     }
 }
 
 export async function deleteSubscriber(id: string) {
-    const session = await getServerSession(authOptions);
-    if (!session?.user?.isAdmin) {
-        return { success: false, error: "Unauthorized" };
-    }
-
     try {
-        const sub = await prismadb.subscriber.delete({
-            where: { id },
-        });
-
-        await logActivity("DELETE_SUBSCRIBER", "Subscription", `Deleted subscriber ${sub.email}`);
-        revalidatePath("/cms/subscriptions");
+        await prismadb.newsletterSubscriber.delete({ where: { id } });
+        revalidatePath("/cms/subscriptions/newsletter");
         return { success: true };
     } catch (error) {
         return { success: false, error: "Failed to delete subscriber" };
     }
 }
 
-export async function updateSubscriberPreferences(id: string, updates: { subscribedToBlog?: boolean; subscribedToCareers?: boolean; isActive?: boolean }) {
-    const session = await getServerSession(authOptions);
-    if (!session?.user?.isAdmin) {
-        return { success: false, error: "Unauthorized" };
-    }
-
+export async function updateSubscriberPreferences(id: string, data: { subscribedToBlog?: boolean, subscribedToCareers?: boolean }) {
     try {
-        await prismadb.subscriber.update({
+        await prismadb.newsletterSubscriber.update({
             where: { id },
-            data: updates,
+            data
         });
-
-        revalidatePath("/cms/subscriptions");
+        revalidatePath("/cms/subscriptions/newsletter");
         return { success: true };
     } catch (error) {
         return { success: false, error: "Failed to update preferences" };

actions/cms/users.ts

@@ -3,6 +3,9 @@
 import { prismadb } from "@/lib/prisma";
 import { revalidatePath } from "next/cache";
 import { hash } from "bcryptjs";
+import { logActivityInternal } from "@/actions/audit";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
 
 export async function getUsers(query?: string) {
     const where: any = {};
@@ -78,6 +81,21 @@ export async function upsertUser(data: any) {
             });
         }
 
+        const logSession = await getServerSession(authOptions);
+        logActivityInternal(
+            logSession?.user?.id || "system",
+            id ? "Updated User" : "Created User",
+            "Team Management",
+            `User ${updateData.email} was ${id ? "updated" : "created"}`,
+            {
+                email: updateData.email,
+                roleId: updateData.roleId,
+                status: updateData.userStatus
+            }
+        );
+
+
+
         revalidatePath("/cms/settings/team");
         return { success: true };
     } catch (error: any) {
@@ -98,6 +116,17 @@ export async function deleteUser(id: string) {
         // Delete = Hard Delete.
 
         await prismadb.users.delete({ where: { id } });
+
+        const logSession = await getServerSession(authOptions);
+        logActivityInternal(
+            logSession?.user?.id || "system",
+            "Deleted User",
+            "Team Management",
+            `User ${id} was permanently deleted`,
+            { userId: id }
+        );
+
+
         revalidatePath("/cms/settings/team");
         return { success: true };
     } catch (error: any) {
@@ -111,6 +140,17 @@ export async function toggleUserStatus(id: string, status: "ACTIVE" | "INACTIVE"
             where: { id },
             data: { userStatus: status }
         });
+
+        const logSession = await getServerSession(authOptions);
+        logActivityInternal(
+            logSession?.user?.id || "system",
+            "Updated User Status",
+            "Team Management",
+            `User ${id} status changed to ${status}`,
+            { userId: id, newStatus: status }
+        );
+
+
         revalidatePath("/cms/settings/team");
         return { success: true };
     } catch (error) {
@@ -201,6 +241,17 @@ export async function resetUserPassword(userId: string) {
             data: { password: hashedPassword }
         });
 
+        const logSession = await getServerSession(authOptions);
+        logActivityInternal(
+            logSession?.user?.id || "system",
+            "Reset User Password",
+            "Security",
+            `Admin reset password for user ${user.email}`,
+            { userId: user.id, email: user.email }
+        );
+
+
+
         // Dynamically import sendEmail to avoid top-level issues if any
         const sendEmail = (await import("@/lib/sendmail")).default;