Add entry log service

api/routes/events/entry-log.ts

@@ -1,20 +1,9 @@
 import {
   EventType,
 } from "../../../components/student/event-status";
-import {
-  queryEventLogEntriesCreate,
-  queryEventLogEntriesGetAll,
-  queryEventLogEntriesGetByEvent,
-} from "../../../db/helpers/eventLogEntries";
-import {
-  Client,
-} from "../../../db/methods";
 import {
   dotGet,
 } from "../../../helpers/data";
-import {
-  keysFromSnakeToCamelCase,
-} from "../../../helpers/object";
 import {
   sendCsv,
 } from "../../helpers/csv";
@@ -34,6 +23,13 @@ import {
   Router,
 } from "../../helpers/route";
 import CompanyEventsService from "../../services/company-events-service";
+import type {
+  Company,
+} from "../../services/company-service";
+import EntryLogService from "../../services/entry-log-service";
+import type {
+  EventLogEntry,
+} from "../../services/entry-log-service";
 import ResumeService from "../../services/resume-service";
 import {
   requireGateGuardian,
@@ -67,9 +63,7 @@ router.post("/", requireAuth({ fullUserData: true }), requireGateGuardian, async
     scannerId: authUser.id,
   };
 
-  const data = await Client.queryOneOnce(queryEventLogEntriesCreate(payload));
-
-  return keysFromSnakeToCamelCase(data);
+  return await EntryLogService.create(payload);
 });
 
 router.get("/:eventType/-?:eventId(\\d+)", requireAuth({ fullUserData: true }), requireGateGuardian, async ({ params }) => {
@@ -94,11 +88,11 @@ router.get("/:eventType/-?:eventId(\\d+)", requireAuth({ fullUserData: true }),
     );
   }
 
-  const userIds = new Set();
+  const userIds = new Set<EventLogEntry["userId"]>();
 
-  const logEntries = await Client.queryOnce(queryEventLogEntriesGetByEvent({ eventId, eventType })) as any;
+  const logEntries = await EntryLogService.forEvent(eventId, eventType);
 
-  for (const { user_id: userId } of logEntries) {
+  for (const { userId } of logEntries) {
     userIds.add(userId);
   }
 
@@ -130,28 +124,22 @@ router.post("/manual", requireAuth({ fullUserData: true }), requireGateGuardian,
     eventId,
     eventType,
     scannerId: authUser.id,
-    scannedAt: new Date(eventDate),
+    scannedAt: eventDate,
   };
 
-  const data = await Client.queryOneOnce(queryEventLogEntriesCreate(payload));
-
-  return keysFromSnakeToCamelCase(data);
+  return await EntryLogService.create(payload);
 });
 
 const moderatorRouter = AuthRouter.boundToRouter(router, {
   role: RoleNames.MODERATOR,
 });
 
 moderatorRouter.get("/all", async () => {
-  const list = await Client.queryOnce(queryEventLogEntriesGetAll());
-
-  return keysFromSnakeToCamelCase(list);
+  return await EntryLogService.list();
 });
 
 moderatorRouter.get("/for-event/:eventType/:eventId(\\d+)", async ({ params }) => {
-  const list = await Client.queryOnce(queryEventLogEntriesGetByEvent(params));
-
-  return keysFromSnakeToCamelCase(list);
+  return await EntryLogService.forEvent(params.eventId, params.eventType);
 });
 
 const csvEventsExport = (res, data, fileName = "Svi") => {
@@ -268,18 +256,12 @@ const exportEntryLogToCsv = (res, eventList, scanned, resumes, fileName) => {
 };
 
 moderatorRouter.getRaw("/export/all.csv", async ({ authHeader }, res) => {
-  const auth = {
-    headers: {
-      Authorization: authHeader,
-    },
-  };
-
   const [
-    { data: scanned },
+    scanned,
     { companies: rawCompanies, ...rawEventList },
     resumes,
   ] = await Promise.all([
-    internalRequest("get", "/events/entry-log/all", auth),
+    EntryLogService.list(),
     CompanyEventsService.listAll(),
     ResumeService.list(authHeader),
   ]);
@@ -295,13 +277,13 @@ moderatorRouter.getRaw("/export/all.csv", async ({ authHeader }, res) => {
     }
   };
 
-  const companies = Object.fromEntries(rawCompanies.map((c) => [ c.id, c ]));
+  const companies: Record<Company["id"], Company> = Object.fromEntries(rawCompanies.map((c) => [ c.id, c ]));
 
   const eventList =
     Object
       .entries(rawEventList)
       .map(([ type, eventList ]) =>
-          (eventList as any[])
+          (eventList)
             .map(
               ({
                  id,

api/services/entry-log-service.ts

@@ -0,0 +1,51 @@
+import type {
+  CamelCasedPropertiesDeep,
+  SetOptional,
+} from "type-fest";
+import {
+  queryEventLogEntriesCreate,
+  queryEventLogEntriesGetAll,
+  queryEventLogEntriesGetByEvent,
+} from "../../db/helpers/eventLogEntries";
+import type {
+  EventLogEntry as DbEventLogEntry,
+} from "../../db/helpers/eventLogEntries";
+import {
+  Client,
+} from "../../db/methods";
+import {
+  keysFromSnakeToCamelCase,
+} from "../../helpers/object";
+
+export type EventLogEntry = SetOptional<CamelCasedPropertiesDeep<DbEventLogEntry>, "scannedAt">;
+
+export default class EntryLogService {
+  public static async create(entry: EventLogEntry): Promise<EventLogEntry | null> {
+    const data = await Client.queryOneOnce<DbEventLogEntry>(queryEventLogEntriesCreate(entry));
+
+    return keysFromSnakeToCamelCase(data);
+  }
+
+  public static async list(): Promise<EventLogEntry[]> {
+    const list = await Client.queryOnce<DbEventLogEntry>(queryEventLogEntriesGetAll());
+
+    if (!list) {
+      return [];
+    }
+
+    return keysFromSnakeToCamelCase(list);
+  }
+
+  public static async forEvent(eventId: EventLogEntry["eventId"], eventType: EventLogEntry["eventType"]): Promise<EventLogEntry[]> {
+    const list = await Client.queryOnce<DbEventLogEntry>(queryEventLogEntriesGetByEvent({
+      eventId,
+      eventType,
+    }));
+
+    if (!list) {
+      return [];
+    }
+
+    return keysFromSnakeToCamelCase(list);
+  }
+}

db/helpers/eventLogEntries.ts

@@ -1,20 +1,34 @@
+import type {
+  CamelCasedPropertiesDeep,
+  SetOptional,
+} from "type-fest";
 import {
   User,
 } from "../../api/graphql/types";
+import {
+  EventType,
+} from "../../components/student/event-status";
 import {
   Query,
 } from "../methods";
 import {
   generateInsertQuery,
 } from "../query";
 
-interface Data {
-  userId: User["id"];
-  eventId: number;
-  eventType: string;
-  scannerId: User["id"];
+/* eslint-disable camelcase */
+
+export interface EventLogEntry {
+  user_id: User["id"];
+  event_id: number;
+  event_type: EventType;
+  scanner_id: User["id"];
+  scanned_at: string;
 }
 
+/* eslint-enable camelcase */
+
+type Data = CamelCasedPropertiesDeep<EventLogEntry>;
+
 export const queryEventLogEntriesGetByUserAndEvent =
   (
     {
@@ -89,14 +103,16 @@ export const queryEventLogEntriesCreate =
       eventId,
       eventType,
       scannerId,
-    }: Pick<Data, "userId" | "eventId" | "eventType" | "scannerId">,
+      scannedAt,
+    }: SetOptional<Data, "scannedAt">,
   ): Query => generateInsertQuery({
     table: "event_log_entries",
     data: {
       userId,
       eventId,
       eventType,
       scannerId,
+      scannedAt,
     },
   })
 ;