synt_backend/database/reminders.js

Synt light-weight node backend service

import * as db from "../mysql/models/index";
import { jobReminderManager } from "../helpers/JobReminderManager";
import { parse } from "../helpers/parser";
import { getTranslation, handleLabelTranslations } from "./labelTranslations";

export async function getVMEReminderById({ reminderId, vmeId }) {
  const reminder = await db.Reminder.findOne({
    where: { id: reminderId, VMEId: vmeId },
    include: [{ model: db.Label, include: [{ model: db.Translation }] }],
  });

  return reminder;
}

export async function getVMEReminders({ vmeId }) {
  const reminders = await db.Reminder.findAll({
    where: { VMEId: vmeId },
    include: [{ model: db.Label, include: [{ model: db.Translation }] }],
  });

  return reminders;
}

export async function setupRemindersForVME(t, vmeId) {
  const defaultReminders = await db.DefaultReminder.findAll({
    include: [{ model: db.Label, include: [{ model: db.Translation }] }],
  });

  await Promise.all(
    defaultReminders.map((dr) =>
      postIfExistsVMEReminder({
        dateOfReceiving: dr.dateOfReceiving,
        Label: {
          Translations: dr.Label.Translations.map((t) => ({
            language: t.language,
            value: t.value,
          })),
        },
        recipient: dr.recipient,
        vmeId: vmeId,
      })
    )
  );
}

async function postIfExistsVMEReminder({
  vmeId,
  reminderId,
  Label,
  recipient,
  dateOfReceiving,
  active = true,
}) {
  if (reminderId) {
    return await postVMEReminder({
      vmeId,
      reminderId,
      Label,
      recipient,
      dateOfReceiving,
      active,
    });
  }

  const reminder = await db.Reminder.findOne({
    where: { VMEId: vmeId, dateOfReceiving, recipient },
    include: [{ model: db.Label, include: [{ model: db.Translation }] }],
  });

  if (reminder) {
    return reminder;
  }

  return await postVMEReminder({
    vmeId,
    reminderId,
    Label,
    recipient,
    dateOfReceiving,
    active,
  });
}

export async function postVMEReminder({
  vmeId,
  reminderId,
  Label,
  recipient,
  dateOfReceiving,
  users,
  active = true,
  type,
}) {
  let label;
  if (type === "message") {
    label = await handleLabelTranslations(Label);
  }

  const Data = {
    VMEId: vmeId,
    LabelId: label?.id,
    recipient,
    dateOfReceiving,
    users,
    active,
    type,
  };

  if (reminderId) {
    const reminder = await db.Reminder.findOne({ where: { id: reminderId } });

    if (reminder) {
      return await reminder.update(Data);
    }
  }

  return await db.Reminder.create(Data);
}

// this function should be called once, after we start the server
export async function initializeReminderJobs() {
  const reminders = await db.Reminder.findAll({
    include: [{ model: db.Label, include: [{ model: db.Translation }] }],
  });
  const parsedReminders = reminders
    .map((r) => r.toJSON())
    .map((r) => ({
      ...r,
      dateOfReceiving: parse(r.dateOfReceiving),
      message: getTranslation(r.Label, "en"),
    }));

  jobReminderManager.scheduleReminders(parsedReminders);
}