folder structure

src/controller/admin/settings/awardController.ts

@@ -0,0 +1,83 @@
+import { Request, Response } from "express";
+import AwardService from "../../../service/settings/awardService";
+import AwardFactory from "../../../factory/admin/settings/award";
+import { CreateAwardCommand, DeleteAwardCommand, UpdateAwardCommand } from "../../../command/settings/award/awardCommand";
+import AwardCommandHandler from "../../../command/settings/award/awardCommandHandler";
+
+/**
+ * @description get all awards
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllAwards(req: Request, res: Response): Promise<any> {
+  let awards = await AwardService.getAll();
+
+  res.json(AwardFactory.mapToBase(awards));
+}
+
+/**
+ * @description get award by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAwardById(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  let award = await AwardService.getById(id);
+
+  res.json(AwardFactory.mapToSingle(award));
+}
+
+/**
+ * @description create new award
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createAward(req: Request, res: Response): Promise<any> {
+  const award = req.body.award;
+
+  let createAward: CreateAwardCommand = {
+    award: award,
+  };
+  await AwardCommandHandler.create(createAward);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update award
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateAward(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  const award = req.body.award;
+
+  let updateAward: UpdateAwardCommand = {
+    id: id,
+    award: award,
+  };
+  await AwardCommandHandler.update(updateAward);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete award
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteAward(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let deleteAward: DeleteAwardCommand = {
+    id: id,
+  };
+  await AwardCommandHandler.delete(deleteAward);
+
+  res.sendStatus(204);
+}

src/controller/admin/settings/communicationTypeController.ts

@@ -0,0 +1,103 @@
+import { Request, Response } from "express";
+import CommunicationTypeService from "../../../service/settings/communicationTypeService";
+import CommunicationTypeFactory from "../../../factory/admin/settings/communicationType";
+import CommunicationService from "../../../service/club/member/communicationService";
+import {
+  CreateCommunicationTypeCommand,
+  DeleteCommunicationTypeCommand,
+  UpdateCommunicationTypeCommand,
+} from "../../../command/settings/communicationType/communicationTypeCommand";
+import CommunicationTypeCommandHandler from "../../../command/settings/communicationType/communicationTypeCommandHandler";
+
+/**
+ * @description get all communicationTypes
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllCommunicationTypes(req: Request, res: Response): Promise<any> {
+  let types = await CommunicationTypeService.getAll();
+
+  res.json(CommunicationTypeFactory.mapToBase(types));
+}
+
+/**
+ * @description get communicationType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getCommunicationTypeById(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  let type = await CommunicationTypeService.getById(id);
+
+  res.json(CommunicationTypeFactory.mapToSingle(type));
+}
+
+/**
+ * @description get columns available to communicationType
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getCommunicationTypeAvailableColumns(req: Request, res: Response): Promise<any> {
+  let columns = CommunicationService.getAvailableColumnsForCommunication();
+  res.json(columns);
+}
+
+/**
+ * @description create new communicationType
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createCommunicationType(req: Request, res: Response): Promise<any> {
+  const communicationType = req.body.communicationType;
+  const useColumns = req.body.fields;
+
+  let createCommunicationType: CreateCommunicationTypeCommand = {
+    type: communicationType,
+    useColumns: useColumns,
+  };
+  await CommunicationTypeCommandHandler.create(createCommunicationType);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update communicationType
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateCommunicationType(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  const communicationType = req.body.communicationType;
+  const useColumns = req.body.fields;
+
+  let updateCommunicationType: UpdateCommunicationTypeCommand = {
+    id: id,
+    type: communicationType,
+    useColumns: useColumns,
+  };
+  await CommunicationTypeCommandHandler.update(updateCommunicationType);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete communicationType
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteCommunicationType(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let deleteCommunicationType: DeleteCommunicationTypeCommand = {
+    id: id,
+  };
+  await CommunicationTypeCommandHandler.delete(deleteCommunicationType);
+
+  res.sendStatus(204);
+}

src/controller/admin/settings/executivePositionController.ts

@@ -0,0 +1,87 @@
+import { Request, Response } from "express";
+import ExecutivePositionService from "../../../service/settings/executivePositionService";
+import ExecutivePositionFactory from "../../../factory/admin/settings/executivePosition";
+import {
+  CreateExecutivePositionCommand,
+  DeleteExecutivePositionCommand,
+  UpdateExecutivePositionCommand,
+} from "../../../command/settings/executivePosition/executivePositionCommand";
+import ExecutivePositionCommandHandler from "../../../command/settings/executivePosition/executivePositionCommandHandler";
+
+/**
+ * @description get all executivePositions
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllExecutivePositions(req: Request, res: Response): Promise<any> {
+  let positions = await ExecutivePositionService.getAll();
+
+  res.json(ExecutivePositionFactory.mapToBase(positions));
+}
+
+/**
+ * @description get executivePosition by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getExecutivePositionById(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  let position = await ExecutivePositionService.getById(id);
+
+  res.json(ExecutivePositionFactory.mapToSingle(position));
+}
+
+/**
+ * @description create new executivePosition
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createExecutivePosition(req: Request, res: Response): Promise<any> {
+  const executivePosition = req.body.executivePosition;
+
+  let createExecutivePosition: CreateExecutivePositionCommand = {
+    position: executivePosition,
+  };
+  await ExecutivePositionCommandHandler.create(createExecutivePosition);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update executivePosition
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateExecutivePosition(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  const executivePosition = req.body.executivePosition;
+
+  let updateExecutivePosition: UpdateExecutivePositionCommand = {
+    id: id,
+    position: executivePosition,
+  };
+  await ExecutivePositionCommandHandler.update(updateExecutivePosition);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete executivePosition
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteExecutivePosition(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let deleteExecutivePosition: DeleteExecutivePositionCommand = {
+    id: id,
+  };
+  await ExecutivePositionCommandHandler.delete(deleteExecutivePosition);
+
+  res.sendStatus(204);
+}

src/controller/admin/settings/membershipStatusController.ts

@@ -0,0 +1,87 @@
+import { Request, Response } from "express";
+import MembershipStatusService from "../../../service/settings/membershipStatusService";
+import MembershipStatusFactory from "../../../factory/admin/settings/membershipStatus";
+import {
+  CreateMembershipStatusCommand,
+  DeleteMembershipStatusCommand,
+  UpdateMembershipStatusCommand,
+} from "../../../command/settings/membershipStatus/membershipStatusCommand";
+import MembershipStatusCommandHandler from "../../../command/settings/membershipStatus/membershipStatusCommandHandler";
+
+/**
+ * @description get all membershipStatus
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllMembershipStatus(req: Request, res: Response): Promise<any> {
+  let status = await MembershipStatusService.getAll();
+
+  res.json(MembershipStatusFactory.mapToBase(status));
+}
+
+/**
+ * @description get membershipStatus by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getMembershipStatusById(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  let status = await MembershipStatusService.getById(id);
+
+  res.json(MembershipStatusFactory.mapToSingle(status));
+}
+
+/**
+ * @description create new membershipStatus
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createMembershipStatus(req: Request, res: Response): Promise<any> {
+  const membershipStatus = req.body.membershipStatus;
+
+  let createMembershipStatus: CreateMembershipStatusCommand = {
+    status: membershipStatus,
+  };
+  await MembershipStatusCommandHandler.create(createMembershipStatus);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update membershipStatus
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateMembershipStatus(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  const membershipStatus = req.body.membershipStatus;
+
+  let updateMembershipStatus: UpdateMembershipStatusCommand = {
+    id: id,
+    status: membershipStatus,
+  };
+  await MembershipStatusCommandHandler.update(updateMembershipStatus);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete membershipStatus
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteMembershipStatus(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let deleteMembershipStatus: DeleteMembershipStatusCommand = {
+    id: id,
+  };
+  await MembershipStatusCommandHandler.delete(deleteMembershipStatus);
+
+  res.sendStatus(204);
+}

src/controller/admin/settings/newsletterConfigController.ts

@@ -0,0 +1,66 @@
+import { Request, Response } from "express";
+import NewsletterConfigService from "../../../service/settings/newsletterConfigService";
+import NewsletterConfigFactory from "../../../factory/admin/settings/newsletterConfig";
+import NewsletterConfigCommandHandler from "../../../command/settings/newsletterConfig/newsletterConfigCommandHandler";
+import { DeleteNewsletterConfigCommand, SetNewsletterConfigCommand } from "../../../command/settings/newsletterConfig/newsletterConfigCommand";
+
+/**
+ * @description get all newsletterConfigs
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllNewsletterConfigs(req: Request, res: Response): Promise<any> {
+  let newsletterConfigs = await NewsletterConfigService.getAll();
+
+  res.json(NewsletterConfigFactory.mapToBase(newsletterConfigs));
+}
+
+/**
+ * @description get newsletterConfig by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterConfigById(req: Request, res: Response): Promise<any> {
+  let comId = parseInt(req.params.comId);
+  let newsletterConfig = await NewsletterConfigService.getByComId(comId);
+
+  res.json(NewsletterConfigFactory.mapToSingle(newsletterConfig));
+}
+
+/**
+ * @description set newsletterConfig
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function setNewsletterConfig(req: Request, res: Response): Promise<any> {
+  let comTypeId = req.body.comTypeId;
+  let config = req.body.config;
+
+  let createNewsletterConfig: SetNewsletterConfigCommand = {
+    comTypeId,
+    config,
+  };
+  let id = await NewsletterConfigCommandHandler.set(createNewsletterConfig);
+
+  res.send(id);
+}
+
+/**
+ * @description delete award
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteNewsletterConfig(req: Request, res: Response): Promise<any> {
+  const comTypeId = parseInt(req.params.comTypeId);
+
+  let deleteNewsletterConfig: DeleteNewsletterConfigCommand = {
+    comTypeId: comTypeId,
+  };
+  await NewsletterConfigCommandHandler.delete(deleteNewsletterConfig);
+
+  res.sendStatus(204);
+}

src/controller/admin/settings/qualificationController.ts

@@ -0,0 +1,91 @@
+import { Request, Response } from "express";
+import QualificationService from "../../../service/settings/qualification";
+import QualificationFactory from "../../../factory/admin/settings/qualification";
+import {
+  CreateQualificationCommand,
+  DeleteQualificationCommand,
+  UpdateQualificationCommand,
+} from "../../../command/settings/qualification/qualificationCommand";
+import QualificationCommandHandler from "../../../command/settings/qualification/qualificationCommandHandler";
+
+/**
+ * @description get all qualifications
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllQualifications(req: Request, res: Response): Promise<any> {
+  let qualifications = await QualificationService.getAll();
+
+  res.json(QualificationFactory.mapToBase(qualifications));
+}
+
+/**
+ * @description get qualification by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getQualificationById(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  let qualification = await QualificationService.getById(id);
+
+  res.json(QualificationFactory.mapToSingle(qualification));
+}
+
+/**
+ * @description create new qualification
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createQualification(req: Request, res: Response): Promise<any> {
+  const qualification = req.body.qualification;
+  const description = req.body.description;
+
+  let createQualification: CreateQualificationCommand = {
+    qualification: qualification,
+    description: description,
+  };
+  await QualificationCommandHandler.create(createQualification);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update qualification
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateQualification(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  const qualification = req.body.qualification;
+  const description = req.body.description;
+
+  let updateQualification: UpdateQualificationCommand = {
+    id: id,
+    qualification: qualification,
+    description: description,
+  };
+  await QualificationCommandHandler.update(updateQualification);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete qualification
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteQualification(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let deleteQualification: DeleteQualificationCommand = {
+    id: id,
+  };
+  await QualificationCommandHandler.delete(deleteQualification);
+
+  res.sendStatus(204);
+}

src/controller/admin/settings/queryStoreController.ts

@@ -0,0 +1,93 @@
+import { Request, Response } from "express";
+import QueryStoreFactory from "../../../factory/admin/settings/queryStore";
+import QueryStoreService from "../../../service/settings/queryStoreService";
+import {
+  CreateQueryStoreCommand,
+  DeleteQueryStoreCommand,
+  UpdateQueryStoreCommand,
+} from "../../../command/settings/queryStore/queryStoreCommand";
+import QueryStoreCommandHandler from "../../../command/settings/queryStore/queryStoreCommandHandler";
+
+/**
+ * @description get all queryStores
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllQueryStores(req: Request, res: Response): Promise<any> {
+  let queryStores = await QueryStoreService.getAll();
+
+  res.json(QueryStoreFactory.mapToBase(queryStores));
+}
+
+/**
+ * @description get queryStore by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getQueryStoreById(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let queryStore = await QueryStoreService.getById(id);
+
+  res.json(QueryStoreFactory.mapToSingle(queryStore));
+}
+
+/**
+ * @description create new queryStore
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createQueryStore(req: Request, res: Response): Promise<any> {
+  const query = req.body.query;
+  const title = req.body.title;
+
+  let createQueryStore: CreateQueryStoreCommand = {
+    title: title,
+    query: query,
+  };
+
+  let id = await QueryStoreCommandHandler.create(createQueryStore);
+
+  res.status(200).send(id);
+}
+
+/**
+ * @description update queryStore
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateQueryStore(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  const query = req.body.query;
+
+  let updateQueryStore: UpdateQueryStoreCommand = {
+    id: id,
+    query: query,
+  };
+
+  await QueryStoreCommandHandler.update(updateQueryStore);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete queryStore
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteQueryStore(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let deleteQueryStore: DeleteQueryStoreCommand = {
+    id: id,
+  };
+
+  await QueryStoreCommandHandler.delete(deleteQueryStore);
+
+  res.sendStatus(204);
+}

src/controller/admin/settings/templateController.ts

@@ -0,0 +1,120 @@
+import { Request, Response } from "express";
+import TemplateService from "../../../service/settings/templateService";
+import TemplateFactory from "../../../factory/admin/settings/template";
+import { CreateTemplateCommand, DeleteTemplateCommand, UpdateTemplateCommand } from "../../../command/settings/template/templateCommand";
+import TemplateCommandHandler from "../../../command/settings/template/templateCommandHandler";
+
+/**
+ * @description get all templates
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllTemplates(req: Request, res: Response): Promise<any> {
+  let templates = await TemplateService.getAll();
+
+  res.json(TemplateFactory.mapToBase(templates));
+}
+
+/**
+ * @description get template by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getTemplateById(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  let template = await TemplateService.getById(id);
+
+  res.json(TemplateFactory.mapToSingle(template));
+}
+
+/**
+ * @description create new template
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createTemplate(req: Request, res: Response): Promise<any> {
+  const template = req.body.template;
+  const description = req.body.description;
+
+  let createTemplate: CreateTemplateCommand = {
+    template: template,
+    description: description,
+  };
+  let id = await TemplateCommandHandler.create(createTemplate);
+
+  res.status(200).send(id);
+}
+
+/**
+ * @description clone template
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function cloneTemplate(req: Request, res: Response): Promise<any> {
+  const cloneId = req.body.cloneId;
+
+  const { template, description, design, html } = await TemplateService.getById(cloneId);
+
+  let createTemplate: CreateTemplateCommand = {
+    template: "",
+    description: "",
+  };
+  let id = await TemplateCommandHandler.create(createTemplate);
+
+  let updateTemplate: UpdateTemplateCommand = {
+    id: id,
+    template: template + " - Kopie",
+    description: description,
+    design: design,
+    html: html,
+  };
+  await TemplateCommandHandler.update(updateTemplate);
+
+  res.status(200).send(id);
+}
+
+/**
+ * @description update template
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateTemplate(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  const template = req.body.template;
+  const description = req.body.description;
+  const design = req.body.design;
+  const html = req.body.html;
+
+  let updateTemplate: UpdateTemplateCommand = {
+    id: id,
+    template: template,
+    description: description,
+    design: design,
+    html: html,
+  };
+  await TemplateCommandHandler.update(updateTemplate);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete template
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteTemplate(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let deleteTemplate: DeleteTemplateCommand = {
+    id: id,
+  };
+  await TemplateCommandHandler.delete(deleteTemplate);
+
+  res.sendStatus(204);
+}

src/controller/admin/settings/templateUsageController.ts

@@ -0,0 +1,95 @@
+import { Request, Response } from "express";
+import TemplateUsageService from "../../../service/settings/templateUsageService";
+import TemplateUsageFactory from "../../../factory/admin/settings/templateUsage";
+import { UpdateTemplateUsageCommand } from "../../../command/settings/templateUsage/templateUsageCommand";
+import TemplateUsageCommandHandler from "../../../command/settings/templateUsage/templateUsageCommandHandler";
+import PermissionHelper from "../../../helpers/permissionHelper";
+import ForbiddenRequestException from "../../../exceptions/forbiddenRequestException";
+import { PermissionModule } from "../../../type/permissionTypes";
+import { PdfExport } from "../../../helpers/pdfExport";
+import { DemoDataHelper } from "../../../helpers/demoDataHelper";
+
+/**
+ * @description get all templateUsages
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllTemplateUsages(req: Request, res: Response): Promise<any> {
+  let templateUsages = await TemplateUsageService.getAll();
+
+  if (!req.isOwner) {
+    templateUsages = templateUsages.filter((tu) => {
+      return (
+        PermissionHelper.can(req.permissions, "update", "settings", tu.scope.split(".")[0] as PermissionModule) ||
+        PermissionHelper.can(req.permissions, "update", "club", tu.scope.split(".")[0] as PermissionModule)
+      );
+    });
+  }
+
+  res.json(TemplateUsageFactory.mapToBase(templateUsages));
+}
+
+/**
+ * @description print demo of templateUsage
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function printTemplateUsageDemo(req: Request, res: Response): Promise<any> {
+  const scope = req.params.scope as PermissionModule;
+
+  let demoData = DemoDataHelper.getData(scope);
+  let pdf = await PdfExport.renderFile({
+    template: scope,
+    saveToDisk: false,
+    data: demoData,
+  });
+
+  let pdfbuffer = Buffer.from(pdf);
+
+  res.setHeader("Content-Type", "application/pdf");
+  res.setHeader("Content-Length", pdfbuffer.byteLength);
+  res.setHeader("Content-Disposition", "inline; filename=preview.pdf");
+
+  res.send(pdfbuffer);
+}
+
+/**
+ * @description update templateUsage
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateTemplateUsage(req: Request, res: Response): Promise<any> {
+  const scope = req.params.scope;
+  let allowedSettings = PermissionHelper.can(
+    req.permissions,
+    "update",
+    "settings",
+    req.params.scope as PermissionModule
+  );
+  let allowedClub = PermissionHelper.can(req.permissions, "update", "club", req.params.scope as PermissionModule);
+
+  if (!(req.isOwner || allowedSettings || allowedClub)) {
+    throw new ForbiddenRequestException(`missing permission for editing scope ${req.params.scope}`);
+  }
+
+  const headerId = req.body.headerId ?? null;
+  const bodyId = req.body.bodyId ?? null;
+  const footerId = req.body.footerId ?? null;
+  const headerHeight = req.body.headerHeight ?? null;
+  const footerHeight = req.body.footerHeight ?? null;
+
+  let updateTemplateUsage: UpdateTemplateUsageCommand = {
+    scope: scope,
+    headerId: headerId,
+    bodyId: bodyId,
+    footerId: footerId,
+    headerHeight: headerHeight,
+    footerHeight: footerHeight,
+  };
+  await TemplateUsageCommandHandler.update(updateTemplateUsage);
+
+  res.sendStatus(204);
+}