synt_backend/controllers/reminders.js

Synt light-weight node backend service

const express = require("express");
const router = express.Router();

const db = require("./../mysql/models/index");
const userHelper = require("../helpers/user");
import * as ValidationHelper from "../helpers/validations";
import {
  getVMEReminderById,
  getVMEReminders,
  postVMEReminder,
  setupRemindersForVME,
} from "../database/reminders";
import { jobReminderManager } from "../helpers/JobReminderManager";

const notifier = require("./../helpers/notifier");

function validateUserAndVme(next) {
  return async (req, res) => {
    const { t } = req;

    const user = await userHelper.getAuthUser(req);

    if (user) {
      // verify vme and get vme
      let VmeValidation = await ValidationHelper.validateVme(t, user.VMEId); //TODO: Validate user roles
      if (!VmeValidation.success) {
        return res.json(VmeValidation);
      }

      const { VME } = VmeValidation;

      return await next(req, res, { user, VME });
    }

    return res.json({
      success: false,
    });
  };
}

const getReminder = validateUserAndVme(async (req, res, { VME }) => {
  const { ReminderId } = req.params;

  const Reminder = await getVMEReminderById({
    reminderId: ReminderId,
    vmeId: VME.id,
  });

  return res.json({ success: true, Reminder });
});

const getReminders = validateUserAndVme(async (req, res, { VME }) => {
  const Reminders = await getVMEReminders({ vmeId: VME.id });

  return res.json({ success: true, Reminders });
});

const deleteReminder = validateUserAndVme(async (req, res, { VME }) => {
  const { ReminderId } = req.params;

  const Reminder = await getVMEReminderById({
    reminderId: ReminderId,
    vmeId: VME.id,
  });

  if (Reminder) {
    await Reminder.destroy();
  }

  try {
    jobReminderManager.stopReminder(ReminderId);
  } catch (error) {
    console.log(error);
  }

  return res.json({ success: true, Reminder });
});

const postReminder = validateUserAndVme(async (req, res, { VME }) => {
  const { t } = req;
  const { id, Label, dateOfReceiving, users, active = true, type } = req.body;
  let { recipient } = req.body;

  let errors = {};

  if (type === "message" && !Label) {
    errors.name = t(
      "api.reminders.errors.messageRequired",
      "Message is required"
    );
  }

  if (type === "unpaid provision") {
    // set recipients to the owners
    recipient = "owners";
  }

  if (!recipient) {
    errors.recipient = t(
      "api.reminders.errors.recipientRequired",
      "Recipient is required"
    );
  }

  if (!dateOfReceiving) {
    errors.dateOfReceiving = t(
      "api.reminders.errors.dateOfReceivingRequired",
      "Receiving date is required"
    );
  }

  if (recipient === "custom" && !users) {
    errors.users = t(
      "api.reminders.errors.users",
      "Users are required when recipient type is custom"
    );
  }

  if (Object.keys(errors).length > 0) {
    return res.json({
      success: false,
      errors,
    });
  }

  const Reminder = await postVMEReminder({
    dateOfReceiving,
    Label,
    recipient,
    reminderId: id,
    vmeId: VME.id,
    users,
    active,
    type,
  });

  try {
    jobReminderManager.scheduleReminder(Reminder.toJSON());
  } catch (error) {
    console.log(error);
  }

  return res.json({ success: true, Reminder });
});

const setupRemindersForVMEController = validateUserAndVme(async (req, res) => {
  const { t } = req;
  const { vmeId } = req.params;

  await setupRemindersForVME(t, vmeId);

  return res.json({ success: true });
});

const postImmediateReminders = validateUserAndVme(async (req, res, { VME }) => {
  const { t } = req;
  const { type, data } = req.body;

  if (!data) {
    return res.json({
      success: false,
      errors: {
        data: t("api.reminders.errors.remindersRequired"),
      },
    });
  }

  if (!type) {
    return res.json({
      success: false,
      errors: {
        type: t("api.reminders.errors.typeRequired"),
      },
    });
  }

  if (type === "provisions") {
    db.Provision.findAll({
      where: {
        id: data.map((d) => d.id),
      },
      include: [
        {
          model: db.User,
        },
        {
          model: db.Lot,
        },
        {
          model: db.ProvisionFile,
        },
      ],
    }).then((provisions) => {
      provisions.forEach((P) => {
        P.Users.forEach((U) => {
          notifier.notify(U, "remind_provision", {
            Provision: P,
            VME,
          });
        });
      });
    });
  }

  return res.json({ success: true });
});

// routes
router.get("/:ReminderId", getReminder);
router.get("/", getReminders);
router.post("/", postReminder);
router.post("/forVME/:vmeId", setupRemindersForVMEController);
router.delete("/:ReminderId", deleteReminder);
router.post("/immediate", postImmediateReminders);

module.exports = router;