Timetable-V2/server/api/index.js

import Prisma from "@prisma/client";
const prisma = new Prisma.PrismaClient();

export async function getTimetable(req, res) {
  if (!req.query.class) {
    res.status(400).send({
      success: false,
      error: "missing_parameter",
      message: "No class parameter provided",
    });
    return;
  }
  const requestedClass = req.query.class.toLowerCase();
  const timetable = await prisma.timetable.findFirst({
    where: {
      class: requestedClass,
    },
    orderBy: {
      updatedAt: "desc",
    },
  });
  if (!timetable) {
    res.status(400).send({
      success: false,
      error: "no_timetable",
      message: "No timetable was found for this class",
    });
    return;
  }
  res.send(timetable.data);
}

export async function getSubstitutions(req, res) {
  const requestedClass = (req.query.class || "").toLowerCase();
  var from, to, date;
  if (req.query.from && req.query.to) {
    from = new Date(req.query.from).setUTCHours(0, 0, 0, 0);
    to = new Date(req.query.to).setUTCHours(0, 0, 0, 0);
  } else if (req.query.date) {
    date = new Date(req.query.date).setUTCHours(0, 0, 0, 0);
  }

  const prismaOptions = {
    where: {
      removed: false,
    },
    orderBy: {
      lesson: "asc",
    },
  };
  if (requestedClass) {
    prismaOptions.where.class = { has: requestedClass };
  }
  if (from && to) {
    prismaOptions.where.date = {
      gte: new Date(from),
      lte: new Date(to),
    };
  } else if (date) {
    prismaOptions.where.date = new Date(date);
  } else {
    prismaOptions.where.date = {
      gte: new Date(new Date().setUTCHours(0, 0, 0, 0)),
    };
  }

  const rawSubstitutions = await prisma.substitution.findMany(prismaOptions);
  const substitutions = rawSubstitutions.map((element) => {
    const substitution = {
      id: element.id,
      class: element.class,
      type: element.type,
      lesson: element.lesson,
      date: new Date(element.date).getTime(),
      change: {},
    };
    if (element.changedRoom) substitution.change.room = element.changedRoom;
    if (element.changedTeacher)
      substitution.change.teacher = element.changedTeacher;
    if (element.changedSubject)
      substitution.change.subject = element.changedSubject;
    return substitution;
  });
  res.send(substitutions);
}

export async function getHistory(req, res) {
  const requestedClass = (req.query.class || "").toLowerCase();
  var from, to, date;
  if (req.query.from && req.query.to) {
    from = new Date(req.query.from).setUTCHours(0, 0, 0, 0);
    to = new Date(req.query.to).setUTCHours(0, 0, 0, 0);
  } else {
    date = new Date(req.query.date || new Date()).setUTCHours(0, 0, 0, 0);
    console.log(date);
  }

  const prismaOptions = {
    where: {},
    include: {
      substitution: true,
    },
  };
  if (requestedClass) {
    prismaOptions.where.class = { has: requestedClass };
  }
  if (from && to) {
    prismaOptions.where.substitution = {
      date: {
        gte: new Date(from),
        lte: new Date(to),
      },
    };
  } else {
    prismaOptions.where.substitution = { date: new Date(date) };
  }

  const rawChanges = await prisma.substitutionChange.findMany(prismaOptions);
  const changes = rawChanges.map((element) => {
    return {
      id: element.id,
      type: element.type,
      substitutionId: element.substitutionId,
      lesson: element.substitution.lesson,
      updatedAt: new Date(element.createdAt).getTime(),
      date: new Date(element.substitution.date).getTime(),
      change: element.changes,
      parseEventId: element.parseEventId,
    };
  });
  res.send(changes);
}

export async function getClasses(req, res) {
  const classes = await prisma.class.findMany({
    select: {
      name: true,
      regex: false,
    },
    orderBy: {
      name: "asc",
    },
  });
  const classList = classes.map((element) => element.name);
  res.send(classList);
}