synt_backend/controllers/definitions.js

Synt light-weight node backend service

import { Router } from "express";
const router = Router();
const db = require("./../mysql/models/index");
const userHelper = require("./../helpers/user");
import * as ValidationHelper from "./../helpers/validations";
import { formatSupplier } from "./../helpers/format";
const { Op, literal } = require("sequelize");

router.get("/", getDefinitions);
router.get("/reporttypes/:ReportTypeId", getReportType);
router.get("/document/:DocumentTypeId", getDocumentType);
router.get("/fixedmeetingitem/:FixedMeetingItemId", getFixedMeetingItem);
router.get("/reporttypes", getReportTypes);
router.get("/fixedmeetingitems", getFixedMeetingItems);
router.post("/report", postReportType);
router.post("/document", postDocumentType);
router.post("/fixedmeetingitem", postFixedMeetingItem);
router.get("/generalledgerdefinitions", getGeneralLedgerDefinitions);

router.get("/model/:ModelName", getDefinitionAll);
router.get("/model/:ModelName/:Id", getDefinition);
router.post("/model/:ModelName", postDefinition);

async function getReportType(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    const { ReportTypeId } = req.params;
    if (user) {
      if (user.is_admin) {
        if (!ReportTypeId) {
          return res.json({
            success: false,
            error: t(
              "api.definitions.reportTypes.errors.notificationNotFound",
              "Notification type not found."
            ),
          });
        }
        db.ReportType.findOne({
          where: { id: ReportTypeId },
          attributes: { exclude: ["createdAt", "updatedAt"] },
        }).then((ReportType) => {
          return res.json({
            success: true,
            ReportType,
          });
        });
      } else {
        return res.json({
          success: false,
          error: t(
            "api.definitions.errors.noPermissions",
            "You don't have the right role."
          ),
        });
      }
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function getDefinitionAll(req, res) {
  const { t } = req;

  try {
    let User = await userHelper.getAuthUser(req);
    const { ModelName } = req.params;
    if (
      [
        "Journal",
        "GeneralLedgerDefinition",
        "PaymentCondition",
        "ReportType",
        "DocumentType",
      ].includes(ModelName)
    ) {
      if (User) {
        db[ModelName].findAll({
          attributes: { exclude: ["createdAt", "updatedAt"] },
        }).then((model) => {
          return res.json({
            success: true,
            [ModelName + "s"]: model,
          });
        });
      }
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.definitionNotFound",
          "Definition not found"
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function getDefinition(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    const { ModelName, Id } = req.params;
    if (
      ["Journal", "GeneralLedgerDefinition", "PaymentCondition"].includes(
        ModelName
      )
    ) {
      if (user) {
        if (user.is_admin) {
          if (!Id) {
            return res.json({
              success: false,
              error: t("api.definitions.errors.notFound", {
                defaultValue: "{{modelName}} not found.",
                modelName: ModelName,
              }),
            });
          }
          db[ModelName].findOne({
            where: { id: Id },
            attributes: { exclude: ["createdAt", "updatedAt"] },
          }).then((model) => {
            return res.json({
              success: true,
              [ModelName]: model,
            });
          });
        } else {
          return res.json({
            success: false,
            error: t(
              "api.definitions.errors.noPermissions",
              "You don't have the right role."
            ),
          });
        }
      }
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.definitionNotFound",
          "Definition not found"
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function getDocumentType(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    const { DocumentTypeId } = req.params;
    if (user) {
      if (user.is_admin) {
        if (!DocumentTypeId) {
          return res.json({
            success: false,
            error: t(
              "api.definitions.documentTypes.errors.documentTypeNotFound",
              "Document type not found"
            ),
          });
        }
        db.DocumentType.findOne({
          where: { id: DocumentTypeId },
          attributes: { exclude: ["createdAt", "updatedAt"] },
        }).then((DocumentType) => {
          return res.json({
            success: true,
            DocumentType,
          });
        });
      } else {
        return res.json({
          success: false,
          error: t(
            "api.definitions.errors.noPermissions",
            "You don't have the right role."
          ),
        });
      }
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function getFixedMeetingItem(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    const { FixedMeetingItemId } = req.params;
    if (user) {
      if (user.is_admin) {
        if (!FixedMeetingItemId) {
          return res.json({
            success: false,
            error: t(
              "api.definitions.meetingItems.errors.agendaNotFound",
              "Agenda item not found."
            ),
          });
        }
        db.FixedMeetingItem.findOne({
          where: { id: FixedMeetingItemId },
          attributes: { exclude: ["createdAt", "updatedAt"] },
        }).then((FixedMeetingItem) => {
          return res.json({
            success: true,
            FixedMeetingItem,
          });
        });
      } else {
        return res.json({
          success: false,
          error: t(
            "api.definitions.errors.noPermissions",
            "You don't have the right role."
          ),
        });
      }
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function getGeneralLedgerDefinitions(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    if (user) {
      const GeneralLedgerDefinitions =
        await db.GeneralLedgerDefinition.findAll();
      return res.json({
        success: true,
        GeneralLedgerDefinitions,
      });
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.noPermissions",
          "You don't have the right role."
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function getDefinitions(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    if (user && user.is_admin) {
      const DocumentTypes = await db.DocumentType.findAll({
        attributes: { exclude: ["createdAt", "updatedAt"] },
      });
      const ReportTypes = await db.ReportType.findAll({
        attributes: { exclude: ["createdAt", "updatedAt"] },
      });
      const FixedMeetingItems = await db.FixedMeetingItem.findAll({
        attributes: { exclude: ["createdAt", "updatedAt"] },
      });
      const Journals = await db.Journal.findAll({
        attributes: { exclude: ["createdAt", "updatedAt"] },
      });
      const GeneralLedgerDefinitions = await db.GeneralLedgerDefinition.findAll(
        {
          attributes: { exclude: ["createdAt", "updatedAt"] },
        }
      );
      const PaymentConditions = await db.PaymentCondition.findAll({
        attributes: { exclude: ["createdAt", "updatedAt"] },
      });
      return res.json({
        success: true,
        DocumentTypes,
        ReportTypes,
        FixedMeetingItems,
        Journals,
        GeneralLedgerDefinitions,
        PaymentConditions,
      });
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.noPermissions",
          "You don't have the right role."
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function getReportTypes(req, res) {
  const { t } = req;
  try {
    let 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;

      db.ReportType.findAll({
        attributes: { exclude: ["createdAt", "updatedAt"] },
        where: {
          [Op.or]: [
            {
              category: "other",
            },
            literal("Suppliers.VMEId = " + VME.id),
          ],
        },
        include: [{ model: db.Supplier, include: db.Company }],
      }).then((ReportTypes) => {
        ReportTypes.map((ReportType) => {
          ReportType.Suppliers = ReportType.Suppliers.map((S) =>
            formatSupplier(S)
          );
          return ReportType;
        });
        return res.json({
          success: true,
          ReportTypes: [
            ...ReportTypes.filter((T) => T.category !== "other"),
            ...ReportTypes.filter((T) => T.category === "other"),
          ],
        });
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function getFixedMeetingItems(req, res) {
  try {
    let user = await userHelper.getAuthUser(req);
    if (user) {
      db.FixedMeetingItem.findAll({
        attributes: { exclude: ["createdAt", "updatedAt"] },
      }).then((FixedMeetingItems) => {
        return res.json({
          success: true,
          FixedMeetingItems,
        });
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function postDocumentType(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    if (user && user.is_admin) {
      const { name, category, id } = req.body;
      const DocumentType = { name, category };
      if (!name || name === "") {
        return res.json({
          success: false,
          errors: {
            name: t(
              "api.definitions.documentTypes.errors.nameRequired",
              "Document type name is required."
            ),
          },
        });
      }
      if (!category || category === "") {
        return res.json({
          success: false,
          errors: {
            category: t(
              "api.definitions.documentTypes.errors.categoryRequired",
              "Document type category is required."
            ),
          },
        });
      }
      if (id) {
        db.DocumentType.update(DocumentType, {
          where: { id },
        });
      } else {
        db.DocumentType.create(DocumentType);
      }
      return res.json({ success: true });
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.noPermissions",
          "You don't have the right role."
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function postReportType(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    if (user && user.is_admin) {
      const { name, category, id } = req.body;
      const ReportType = { name, category };
      if (!name || name === "") {
        return res.json({
          success: false,
          errors: {
            name: t(
              "api.definitions.reportTypes.errors.nameRequired",
              "Notification type name is required."
            ),
          },
        });
      }
      if (!category || category === "") {
        return res.json({
          success: false,
          errors: {
            category: t(
              "api.definitions.reportTypes.errors.categoryRequired",
              "Notification type category is required."
            ),
          },
        });
      }
      if (id) {
        db.ReportType.update(ReportType, { where: { id } });
      } else {
        db.ReportType.create(ReportType);
      }
      return res.json({ success: true });
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.noPermissions",
          "You don't have the right role."
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function postFixedMeetingItem(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    if (user && user.is_admin) {
      const { name, description, is_vote_required, majority, template, id } =
        req.body;
      const FixedMeetingItem = {
        name,
        description,
        is_vote_required,
        template,
        majority,
      };
      if (!name || name === "") {
        return res.json({
          success: false,
          errors: {
            name: t(
              "api.definitions.meetingItems.errors.nameRequired",
              "Agenda item name is required."
            ),
          },
        });
      }
      if (!description || description === "") {
        return res.json({
          success: false,
          errors: {
            description: t(
              "api.definitions.meetingItems.errors.descriptionRequired",
              "Description of the agenda item is required."
            ),
          },
        });
      }
      if (id) {
        db.FixedMeetingItem.update(FixedMeetingItem, {
          where: { id },
        });
      } else {
        db.FixedMeetingItem.create(FixedMeetingItem);
      }
      return res.json({ success: true });
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.noPermissions",
          "You don't have the right role."
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function postJournal(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    if (user && user.is_admin) {
      const { code, name, id } = req.body;
      const Journal = {
        name,
        code,
      };
      if (!name || name === "") {
        return res.json({
          success: false,
          errors: {
            name: t(
              "api.definitions.journals.errors.nameRequired",
              "Diary name is required."
            ),
          },
        });
      }
      if (!code || code === "") {
        return res.json({
          success: false,
          errors: {
            description: t(
              "api.definitions.journals.errors.descriptionRequired",
              "Unique code of the diary is required."
            ),
          },
        });
      }
      if (id) {
        db.Journal.update(Journal, {
          where: { id },
        });
      } else {
        db.Journal.create(Journal);
      }
      return res.json({ success: true });
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.noPermissions",
          "You don't have the right role."
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function postGeneralLedgerDefinition(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    if (user && user.is_admin) {
      const { code, name, description, id } = req.body;
      const GeneralLedgerDefinition = {
        name,
        code,
        description,
      };
      if (!name || name === "") {
        return res.json({
          success: false,
          errors: {
            name: t(
              "api.definitions.ledgers.errors.nameRequired",
              "G/L account name is required."
            ),
          },
        });
      }
      if (!code || code === "") {
        return res.json({
          success: false,
          errors: {
            description: t(
              "api.definitions.ledgers.errors.codeRequired",
              "Unique code of the ledger account is required."
            ),
          },
        });
      }
      if (!description || description === "") {
        return res.json({
          success: false,
          errors: {
            description: t(
              "api.definitions.ledgers.errors.descriptionRequired",
              "Description of the ledger account is required."
            ),
          },
        });
      }
      if (id) {
        db.GeneralLedgerDefinition.update(GeneralLedgerDefinition, {
          where: { id },
        });
      } else {
        db.GeneralLedgerDefinition.create(GeneralLedgerDefinition);
      }
      return res.json({ success: true });
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.noPermissions",
          "You don't have the right role."
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function postPaymentCondition(req, res) {
  const { t } = req;

  try {
    let user = await userHelper.getAuthUser(req);
    if (user && user.is_admin) {
      const { name, payment_days, payment_end_of_months, id } = req.body;
      const PaymentCondition = {
        name,
        payment_days,
        payment_end_of_months,
      };
      if (!name || name === "") {
        return res.json({
          success: false,
          errors: {
            name: t(
              "api.definitions.payments.errors.nameRequired",
              "Payment term name is required."
            ),
          },
        });
      }
      if (typeof payment_days === "undefined" || payment_days === "") {
        return res.json({
          success: false,
          errors: {
            description: t(
              "api.definitions.payments.errors.daysRequired",
              "Number of days of the payment term is required."
            ),
          },
        });
      }
      if (
        typeof payment_end_of_months === "undefined" ||
        payment_end_of_months === ""
      ) {
        return res.json({
          success: false,
          errors: {
            description: t(
              "api.definitions.payments.errors.monthsRequired",
              "Number of month ends of the payment term is required."
            ),
          },
        });
      }
      if (id) {
        db.PaymentCondition.update(PaymentCondition, {
          where: { id },
        });
      } else {
        db.PaymentCondition.create(PaymentCondition);
      }
      return res.json({ success: true });
    } else {
      return res.json({
        success: false,
        error: t(
          "api.definitions.errors.noPermissions",
          "You don't have the right role."
        ),
      });
    }
  } catch (error) {
    return res.json({ success: false, error });
  }
}

async function postDefinition(req, res) {
  const { ModelName } = req.params;
  switch (ModelName) {
    case "Journal":
      return postJournal(req, res);
    case "GeneralLedgerDefinition":
      return postGeneralLedgerDefinition(req, res);
    case "PaymentCondition":
      return postPaymentCondition(req, res);
    default:
      break;
  }
}

module.exports = router;