Feat/stats (#251)

Author: Logannford

src/actions/answers/answer.ts

@@ -20,7 +20,7 @@ interface AnswerQuestionResponse {
 
 const findOrCreateUserStreak = async (userUid: string) => {
   const streak = await prisma.streaks.findUnique({
-    where: { userUid },
+    where: { userUid }
   });
 
   if (streak) return streak;
@@ -33,14 +33,14 @@ const findOrCreateUserStreak = async (userUid: string) => {
       createdAt: new Date(),
       currentstreakCount: 0,
       longestStreak: 0,
-      updatedAt: new Date(),
-    },
+      updatedAt: new Date()
+    }
   });
 };
 
 const findQuestion = async (questionUid: string) => {
   const question = await prisma.questions.findUnique({
-    where: { uid: questionUid },
+    where: { uid: questionUid }
   });
 
   if (!question) {
@@ -54,8 +54,8 @@ const findExistingAnswer = async (userUid: string, questionUid: string) => {
   return prisma.answers.findFirst({
     where: {
       user: { is: { uid: userUid } },
-      question: { is: { uid: questionUid } },
-    },
+      question: { is: { uid: questionUid } }
+    }
   });
 };
 
@@ -116,8 +116,8 @@ const updateStreakDates = async (
       streakEnd: newStreakEnd,
       currentstreakCount: newCurrentStreak,
       longestStreak: newLongestStreak,
-      updatedAt: new Date(),
-    },
+      updatedAt: new Date()
+    }
   });
 
   await tx.users.update({
@@ -126,8 +126,8 @@ const updateStreakDates = async (
       correctDailyStreak: newCurrentStreak,
       totalDailyStreak:
         currentStreak.totalDailyStreak +
-        (isNextDay || (!isToday && correctAnswer) ? 1 : 0),
-    },
+        (isNextDay || (!isToday && correctAnswer) ? 1 : 0)
+    }
   });
 };
 
@@ -136,7 +136,7 @@ const handleStreakUpdates = async (
   dailyQuestion: boolean,
   {
     userUid,
-    correctAnswer,
+    correctAnswer
   }: {
     userUid: string;
     correctAnswer: boolean;
@@ -158,7 +158,7 @@ const updateOrCreateAnswer = async (
     questionUid,
     answerUid,
     correctAnswer,
-    timeTaken,
+    timeTaken
   }: {
     existingAnswer: any;
     userUid: string;
@@ -178,7 +178,7 @@ const updateOrCreateAnswer = async (
     ) {
       return tx.answers.update({
         where: { uid: existingAnswer.uid },
-        data: { userAnswerUid: answerUid, correctAnswer, timeTaken },
+        data: { userAnswerUid: answerUid, correctAnswer, timeTaken }
       });
     }
     return existingAnswer;
@@ -191,59 +191,80 @@ const updateOrCreateAnswer = async (
       question: { connect: { uid: questionUid } },
       userAnswerUid: answerUid,
       correctAnswer,
-      timeTaken,
-    },
+      timeTaken
+    }
   });
 };
 
+/**
+ * Gets the total number of questions the user has answered.
+ *
+ * @param userUid
+ * @returns
+ */
+export const getTotalQuestionCount = async (userUid: string) => {
+  if (!userUid) {
+    return null;
+  }
+
+  const questions = await prisma.answers.count({
+    where: {
+      userUid
+    }
+  });
+
+  revalidateTag('statistics');
+
+  return questions;
+};
+
 export async function answerQuestion({
   questionUid,
   answerUid,
   userUid,
-  timeTaken,
+  timeTaken
 }: AnswerQuestionInput): Promise<AnswerQuestionResponse> {
-  try {
-    const question = await findQuestion(questionUid);
-    const correctAnswer = question.correctAnswer === answerUid;
-    const existingAnswer = await findExistingAnswer(userUid, questionUid);
-
-    const { userData, userAnswer } = await prisma.$transaction(async (tx) => {
-      // Only update streaks if this is a new answer
-      if (!existingAnswer) {
-        await handleStreakUpdates(tx, question.dailyQuestion, {
-          userUid,
-          correctAnswer,
-        });
-      }
-
-      // Get updated user data
-      const userData = await tx.users.findUnique({
-        where: { uid: userUid },
-      });
+  const question = await findQuestion(questionUid);
+  const correctAnswer = question.correctAnswer === answerUid;
+  const existingAnswer = await findExistingAnswer(userUid, questionUid);
 
-      // Handle answer creation or update
-      const userAnswer = await updateOrCreateAnswer(tx, {
-        existingAnswer,
+  const { userData, userAnswer } = await prisma.$transaction(async (tx) => {
+    // Only update streaks if this is a new answer
+    if (!existingAnswer) {
+      await handleStreakUpdates(tx, question.dailyQuestion, {
         userUid,
-        questionUid,
-        answerUid,
-        correctAnswer,
-        timeTaken,
+        correctAnswer
       });
+    }
 
-      return { userData, userAnswer };
+    // Get updated user data
+    const userData = await tx.users.findUnique({
+      where: { uid: userUid }
     });
 
-    revalidateTag(`leaderboard-${questionUid}`);
-    revalidateTag(`user-has-answered-daily-question-${questionUid}`);
-
-    return {
+    // Handle answer creation or update
+    const userAnswer = await updateOrCreateAnswer(tx, {
+      existingAnswer,
+      userUid,
+      questionUid,
+      answerUid,
       correctAnswer,
-      userAnswer,
-      userData,
-    };
-  } catch (error) {
-    console.error(error);
-    throw error;
-  }
+      timeTaken
+    });
+
+    return { userData, userAnswer };
+  });
+
+  // revalidate leaderboard
+  revalidateTag(`leaderboard-${questionUid}`);
+  // revalidate if the user has answered the streak
+  revalidateTag(`user-has-answered-daily-question-${questionUid}`);
+  // revalidate the user's statistics
+  revalidateTag(`statistics`);
+
+  return {
+    correctAnswer,
+    userAnswer,
+    userData
+  };
 }

src/actions/statistics/analyse-statistics.ts

@@ -0,0 +1,9 @@
+'use server';
+import { openai } from '@/lib/open-ai';
+
+/**
+ *
+ * @param opts
+ * @returns
+ */
+export const analyseCurrentStats = async (opts: {}) => {};

src/actions/statistics/get-stats-chart-data.ts

@@ -0,0 +1,154 @@
+'use server';
+import { StatsChartData } from '@/types/Stats';
+import { prisma } from '@/utils/prisma';
+import { revalidateTag } from 'next/cache';
+
+/**
+ * Method to get all the question data for the user and return it
+ * in a format to display in a chart.
+ *
+ * We return the data in the following format:
+ * [month]: { totalQuestions: number, tags: string[], tagCounts: Record<string, number> }
+ */
+export const getStatsChartData = async (opts: {
+  userUid: string;
+  to: string;
+  from: string;
+}) => {
+  const { userUid, to, from } = opts;
+
+  if (!userUid) {
+    return null;
+  }
+
+  const questions = await prisma.answers.findMany({
+    where: {
+      userUid,
+      createdAt: {
+        gte: new Date(from),
+        lte: new Date(to)
+      }
+    },
+    include: {
+      question: {
+        select: {
+          createdAt: true,
+          tags: {
+            include: {
+              tag: true
+            }
+          }
+        }
+      }
+    }
+  });
+
+  const data: StatsChartData = {};
+
+  questions.forEach((answer) => {
+    const month = answer.question.createdAt.toISOString().slice(0, 7);
+    const tags = answer.question.tags.map((tag) => tag.tag.name);
+
+    if (data[month]) {
+      data[month].totalQuestions++;
+      tags.forEach((tag) => {
+        data[month].tagCounts[tag] = (data[month].tagCounts[tag] || 0) + 1;
+      });
+    } else {
+      const tagCounts: Record<string, number> = {};
+      tags.forEach((tag) => {
+        tagCounts[tag] = 1;
+      });
+      data[month] = { totalQuestions: 1, tagCounts };
+    }
+  });
+
+  revalidateTag('statistics');
+
+  return data;
+};
+
+/**
+ * Gets the total number of questions the user has answered.
+ *
+ * @param userUid
+ * @returns
+ */
+export const getTotalQuestionCount = async (userUid: string) => {
+  if (!userUid) {
+    return null;
+  }
+
+  const questions = await prisma.answers.count({
+    where: {
+      userUid
+    }
+  });
+
+  revalidateTag('statistics');
+
+  return questions;
+};
+
+export const getTotalTimeTaken = async (userUid: string) => {
+  if (!userUid) {
+    return null;
+  }
+
+  const answers = await prisma.answers.findMany({
+    where: {
+      userUid
+    }
+  });
+
+  const totalTime = answers.reduce((acc, answer) => {
+    return acc + (answer.timeTaken || 0);
+  }, 0);
+
+  revalidateTag('statistics');
+
+  return totalTime;
+};
+
+export const getHighestScoringTag = async (userUid: string) => {
+  if (!userUid) {
+    return null;
+  }
+
+  const answers = await prisma.answers.findMany({
+    where: {
+      userUid
+    },
+    include: {
+      question: {
+        include: {
+          tags: {
+            include: {
+              tag: true
+            }
+          }
+        }
+      }
+    }
+  });
+
+  const tagCounts: Record<string, number> = {};
+
+  answers.forEach((answer) => {
+    answer.question.tags.forEach((tag) => {
+      const tagName = tag.tag.name;
+      tagCounts[tagName] = (tagCounts[tagName] || 0) + 1;
+    });
+  });
+
+  const highestScoringTag = Object.keys(tagCounts).reduce((acc, tag) => {
+    return tagCounts[tag] > tagCounts[acc] ? tag : acc;
+  }, '');
+
+  revalidateTag('statistics');
+
+  return {
+    tag: highestScoringTag,
+    count: tagCounts[highestScoringTag]
+  };
+};

src/app/(default_layout)/(questions)/(layout)/previous-questions/page.tsx renamed to src/app/(dashboard)/(default_layout)/(questions)/previous-questions/page.tsx

@@ -0,0 +1,19 @@
+'use client';
+import Hero from '@/components/global/hero';
+
+export default function ClientPage({
+  children
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <div>
+      <Hero
+        heading="All Questions"
+        subheading=" Explore a diverse set of questions across multiple topics to enhance
+          your knowledge."
+      />
+      {children}
+    </div>
+  );
+}