Formatting fixes

.github/workflows/deploy.yml

@@ -37,7 +37,12 @@ jobs:
       run: |
         cd backend && yarn install
         cd ../frontend && yarn install
-
+
+    - name: Generate Prisma Client
+      run: |
+        cd backend
+        npx prisma generate
+
     - name: Run backend tests
       run: |
         cd backend

.github/workflows/lint.yml

@@ -0,0 +1,61 @@
+name: Lint codebase
+
+on:
+  push:
+    branches:
+      - dev
+    paths:
+      - "frontend/**"
+      - "backend/**"
+  pull_request:
+    branches:
+      - dev
+    paths:
+      - "frontend/**"
+      - "backend/**"
+
+jobs:
+  run-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Filter changed files
+        uses: dorny/paths-filter@v2
+        id: changes
+        with:
+          filters: |
+            frontend:
+              - "frontend/**"
+            backend:
+              - "backend/**"
+
+      - name: Set up Node.js
+        if: steps.changes.outputs.frontend == 'true' || steps.changes.outputs.backend == 'true'
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18.18.2"
+          cache: "yarn"
+          cache-dependency-path: |
+            frontend/yarn.lock
+            backend/yarn.lock
+
+      - name: Install Node.js dependencies
+        if: steps.changes.outputs.frontend == 'true' || steps.changes.outputs.backend == 'true'
+        run: yarn --cwd ./frontend --prefer-offline && yarn --cwd ./backend --prefer-offline
+
+      - name: Generate Prisma Client
+        if: steps.changes.outputs.backend == 'true'
+        working-directory: ./backend
+        run: npx prisma generate
+
+      - name: Lint frontend
+        if: always() &&steps.changes.outputs.frontend == 'true'
+        working-directory: ./frontend
+        run: yarn lint
+
+      - name: Lint backend
+        if: always() &&steps.changes.outputs.backend == 'true'
+        working-directory: ./backend
+        run: yarn lint

backend/crons/index.ts

@@ -3,7 +3,10 @@ import expireAdminNotes from "./scripts/expireAdminNotes";
 import expireAdminAnnouncements from "./scripts/expireAdminAnnouncements";
 import expireLoginStreak from "./scripts/expireLoginStreak";
 import createAssignedTasks from "./scripts/createAssignedTask";
-import { sendWeeklyReports, sendMonthlyReports } from "./scripts/sendReportEmails";
+import {
+  sendWeeklyReports,
+  sendMonthlyReports,
+} from "./scripts/sendReportEmails";
 
 cron.schedule("0 0 * * * *", async () => {
   const res = await expireAdminNotes();
@@ -32,7 +35,7 @@ cron.schedule("0 0 0 * * *", async () => {
   }
 });
 
-cron.schedule("0 0 * * 1", async () => { 
+cron.schedule("0 0 * * 1", async () => {
   const res = await createAssignedTasks();
   if (res) {
     console.log("Created assigned tasks");
@@ -44,8 +47,10 @@ cron.schedule("0 0 * * 1", async () => {
 // Weekly reports - every Monday at 9 AM
 cron.schedule("0 9 * * 1", async () => {
   const timestamp = new Date().toISOString();
-  console.log(`[${timestamp}] Starting weekly report generation and emailing...`);
-
+  console.log(
+    `[${timestamp}] Starting weekly report generation and emailing...`
+  );
+
   const res = await sendWeeklyReports();
   if (res) {
     console.log(`[${timestamp}] Weekly reports sent successfully`);
@@ -57,8 +62,10 @@ cron.schedule("0 9 * * 1", async () => {
 // Monthly reports - first day of month at 9 AM
 cron.schedule("0 9 1 * *", async () => {
   const timestamp = new Date().toISOString();
-  console.log(`[${timestamp}] Starting monthly report generation and emailing...`);
-
+  console.log(
+    `[${timestamp}] Starting monthly report generation and emailing...`
+  );
+
   const res = await sendMonthlyReports();
   if (res) {
     console.log(`[${timestamp}] Monthly reports sent successfully`);

backend/crons/scripts/createAssignedTask.ts

@@ -1,18 +1,23 @@
+import {
+  TaskType,
+  RecurrenceFrequency,
+  TimeOption,
+  DayOfWeek,
+} from "@prisma/client";
 import prisma from "../../prisma";
-import { TaskType, RecurrenceFrequency, TimeOption, DayOfWeek } from "@prisma/client";
 import { formatDateTime, getToday } from "../../utils/formatDateTime";
 
 async function createAssignedTasks(): Promise<boolean> {
   try {
     const participants = await prisma.participant.findMany({
       where: {
         OR: [{ departure_date: null }, { departure_date: { gt: getToday() } }],
-      }
+      },
     });
 
     const requiredTasks = await prisma.task.findMany({
       where: { task_type: TaskType.REQUIRED },
-    })
+    });
 
     const weekdayOffsets: { [key in DayOfWeek]: number } = {
       MONDAY: 0,
@@ -24,86 +29,102 @@ async function createAssignedTasks(): Promise<boolean> {
       SUNDAY: 6,
     };
 
-    const mondayOfCurrentWeek = new Date(); 
+    const mondayOfCurrentWeek = new Date();
+
+    await Promise.all(
+      participants.map(async (participant) => {
+        return Promise.all(
+          requiredTasks.map(async (task) => {
+            if (
+              task.recurrence_preference ===
+                RecurrenceFrequency.EVERY_SELECTED_DAYS ||
+              task.recurrence_preference === RecurrenceFrequency.DAILY
+            ) {
+              await Promise.all(
+                task.repeat_days.map(async (repeatDay) => {
+                  const offset = weekdayOffsets[repeatDay];
+                  const taskDate = new Date(mondayOfCurrentWeek);
+                  taskDate.setDate(mondayOfCurrentWeek.getDate() + offset);
+                  let startDate: Date;
+                  let endDate: Date;
+                  if (task.time_preference === TimeOption.SPECIFIC) {
+                    startDate = new Date(taskDate);
+                    endDate = new Date(taskDate);
+                    if (task.start_time) {
+                      const [hours, minutes] = task.start_time
+                        .split(":")
+                        .map(Number);
+                      startDate.setHours(hours, minutes, 0, 0);
+                    }
+                    if (task.end_time) {
+                      const [hours, minutes] = task.end_time
+                        .split(":")
+                        .map(Number);
+                      endDate.setHours(hours, minutes, 0, 0);
+                    }
+                  } else {
+                    startDate = new Date(taskDate);
+                    startDate.setHours(0, 0, 0, 0);
+                    endDate = new Date(taskDate);
+                    endDate.setHours(23, 59, 0, 0);
+                  }
+                  const startDateString = formatDateTime(startDate, true);
+                  const endDateString = formatDateTime(endDate, true);
+                  await prisma.assignedTask.create({
+                    data: {
+                      participant_id: participant.participant_id,
+                      task_name: task.task_name,
+                      task_type: task.task_type,
+                      start_date: startDateString,
+                      end_date: endDateString,
+                      marillac_bucks_addition: task.marillac_bucks_addition,
+                      marillac_bucks_deduction: task.marillac_bucks_deduction,
+                      comment: task.comment,
+                    },
+                  });
+                })
+              );
+            } else if (
+              task.recurrence_preference ===
+              RecurrenceFrequency.ANY_SELECTED_DAYS
+            ) {
+              const firstDayOffset = weekdayOffsets[task.repeat_days[0]];
+              const lastDayOffset =
+                weekdayOffsets[task.repeat_days[task.repeat_days.length - 1]];
 
-    for (const participant of participants) {
-      for (const task of requiredTasks) {
-        if (task.recurrence_preference === RecurrenceFrequency.EVERY_SELECTED_DAYS || 
-            task.recurrence_preference === RecurrenceFrequency.DAILY) {
-          for (const repeatDay of task.repeat_days) {
-            const offset = weekdayOffsets[repeatDay]; 
-            const taskDate = new Date(mondayOfCurrentWeek);
-            taskDate.setDate(mondayOfCurrentWeek.getDate() + offset);
-            let startDate: Date;
-            let endDate: Date;
-            if (task.time_preference === TimeOption.SPECIFIC) {
-              startDate = new Date(taskDate);
-              endDate = new Date(taskDate);
-              if (task.start_time) {
-                const [hours, minutes] = task.start_time.split(":").map(Number);
-                startDate.setHours(hours, minutes, 0, 0);
-              }
-              if (task.end_time) {
-                const [hours, minutes] = task.end_time.split(":").map(Number);
-                endDate.setHours(hours, minutes, 0, 0);
-              }
-            } else {
-              startDate = new Date(taskDate);
+              const startDate = new Date(mondayOfCurrentWeek);
+              startDate.setDate(mondayOfCurrentWeek.getDate() + firstDayOffset);
               startDate.setHours(0, 0, 0, 0);
-              endDate = new Date(taskDate);
+
+              const endDate = new Date(mondayOfCurrentWeek);
+              endDate.setDate(mondayOfCurrentWeek.getDate() + lastDayOffset);
               endDate.setHours(23, 59, 0, 0);
-            }
-            const startDateString = formatDateTime(startDate, true);
-            const endDateString = formatDateTime(endDate, true);
-            await prisma.assignedTask.create({
-              data: {
-                participant_id: participant.participant_id,
-                task_name: task.task_name,
-                task_type: task.task_type,
-                start_date: startDateString,
-                end_date: endDateString,
-                marillac_bucks_addition: task.marillac_bucks_addition,
-                marillac_bucks_deduction: task.marillac_bucks_deduction,
-                comment: task.comment,
-              },
-            });
-          }
-        } else if (task.recurrence_preference === RecurrenceFrequency.ANY_SELECTED_DAYS) {
 
-          const firstDayOffset = weekdayOffsets[task.repeat_days[0]];
-          const lastDayOffset = weekdayOffsets[task.repeat_days[task.repeat_days.length - 1]];
-
-          const startDate = new Date(mondayOfCurrentWeek);
-          startDate.setDate(mondayOfCurrentWeek.getDate() + firstDayOffset);
-          startDate.setHours(0, 0, 0, 0);
-
-          const endDate = new Date(mondayOfCurrentWeek);
-          endDate.setDate(mondayOfCurrentWeek.getDate() + lastDayOffset);
-          endDate.setHours(23, 59, 0, 0);
-
-          const startDateString = formatDateTime(startDate, true);
-          const endDateString = formatDateTime(endDate, true);
-
-          await prisma.assignedTask.create({
-            data: {
-              participant_id: participant.participant_id,
-              task_name: task.task_name,
-              task_type: task.task_type,
-              start_date: startDateString,
-              end_date: endDateString,
-              marillac_bucks_addition: task.marillac_bucks_addition,
-              marillac_bucks_deduction: task.marillac_bucks_deduction,
-              comment: task.comment,
-            },
-          });
-        }
-      }
-    }
+              const startDateString = formatDateTime(startDate, true);
+              const endDateString = formatDateTime(endDate, true);
+
+              await prisma.assignedTask.create({
+                data: {
+                  participant_id: participant.participant_id,
+                  task_name: task.task_name,
+                  task_type: task.task_type,
+                  start_date: startDateString,
+                  end_date: endDateString,
+                  marillac_bucks_addition: task.marillac_bucks_addition,
+                  marillac_bucks_deduction: task.marillac_bucks_deduction,
+                  comment: task.comment,
+                },
+              });
+            }
+          })
+        );
+      })
+    );
     return true;
   } catch (err) {
     console.error(err);
     return false;
   }
-};
+}
 
 export default createAssignedTasks;

backend/crons/scripts/generateDataReport.ts

@@ -41,7 +41,7 @@ interface LoginStats {
   login_date: string;
 }
 
-interface DataReport {
+export interface DataReport {
   reportPeriod: string;
   startDate: string;
   endDate: string;
@@ -54,7 +54,7 @@ interface DataReport {
 }
 
 // Main function to generate a json  for data report
-async function generateDataReport(
+export async function generateDataReport(
   params: DataReportParams
 ): Promise<DataReport | null> {
   try {
@@ -287,4 +287,3 @@ export async function generateMonthlyReport(): Promise<boolean> {
 
 // Export the main function for generating a data report by default
 export default generateDataReport;
-

backend/crons/scripts/generateDataReportCSV.ts

@@ -1,16 +1,16 @@
 import path from "path";
 import fs from "fs/promises";
-import generateDataReport from "./generateDataReport";
+import { generateDataReport, DataReport } from "./generateDataReport";
 
 // Convert JSON data to CSV format
-function jsonToCsv(data: any[], headers: string[]): string {
-  if (data.length === 0) return headers.join(",") + "\n";
+function jsonToCsv(data: object[], headers: string[]): string {
+  if (data.length === 0) return `${headers.join(",")}\n`;
 
   const csvRows = [headers.join(",")];
 
-  for (const row of data) {
+  const rows = data.map((row) => {
     const values = headers.map((header) => {
-      const value = row[header];
+      const value = (row as Record<string, unknown>)[header];
       // Escape commas and quotes in CSV
       if (
         typeof value === "string" &&
@@ -20,14 +20,15 @@ function jsonToCsv(data: any[], headers: string[]): string {
       }
       return value ?? "";
     });
-    csvRows.push(values.join(","));
-  }
+    return values.join(",");
+  });
+  csvRows.push(...rows);
 
-  return csvRows.join("\n") + "\n";
+  return `${csvRows.join("\n")}\n`;
 }
 
 // Generate a single comprehensive CSV with all data types
-function generateComprehensiveCSV(report: any): string {
+function generateComprehensiveCSV(report: DataReport): string {
   const csvSections: string[] = [];
 
   // Report header information
@@ -207,4 +208,3 @@ export async function generateMonthlyReportCSV(): Promise<string | null> {
     return null;
   }
 }
-