folder structure

src/controller/admin/club/calendarController.ts

@@ -0,0 +1,205 @@
+import { Request, Response } from "express";
+import CalendarService from "../../../service/club/calendarService";
+import CalendarFactory from "../../../factory/admin/club/calendar";
+import CalendarTypeService from "../../../service/settings/calendarTypeService";
+import CalendarTypeFactory from "../../../factory/admin/settings/calendarType";
+import { CreateCalendarCommand, DeleteCalendarCommand, UpdateCalendarCommand } from "../../../command/club/calendar/calendarCommand";
+import CalendarCommandHandler from "../../../command/club/calendar/calendarCommandHandler";
+import {
+  CreateCalendarTypeCommand,
+  DeleteCalendarTypeCommand,
+  UpdateCalendarTypeCommand,
+} from "../../../command/settings/calendarType/calendarTypeCommand";
+import CalendarTypeCommandHandler from "../../../command/settings/calendarType/calendarTypeCommandHandler";
+
+/**
+ * @description get all calendar items
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllCalendarItems(req: Request, res: Response): Promise<any> {
+  let items = await CalendarService.getAll();
+
+  res.json(CalendarFactory.mapToBase(items));
+}
+
+/**
+ * @description get calendar item by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getCalendarItemById(req: Request, res: Response): Promise<any> {
+  const id = req.params.id;
+  let item = await CalendarService.getById(id);
+
+  res.json(CalendarFactory.mapToSingle(item));
+}
+
+/**
+ * @description get all calendar types
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllCalendarTypes(req: Request, res: Response): Promise<any> {
+  let types = await CalendarTypeService.getAll();
+
+  res.json(CalendarTypeFactory.mapToBase(types));
+}
+
+/**
+ * @description get calendar type by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getCalendarTypeById(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  let type = await CalendarTypeService.getById(id);
+
+  res.json(CalendarTypeFactory.mapToSingle(type));
+}
+
+/**
+ * @description create calendar item
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createCalendarItem(req: Request, res: Response): Promise<any> {
+  const starttime = req.body.starttime;
+  const endtime = req.body.endtime;
+  const title = req.body.title;
+  const content = req.body.content;
+  const location = req.body.location;
+  const allDay = req.body.allDay;
+  const typeId = req.body.typeId;
+
+  let createItem: CreateCalendarCommand = {
+    starttime,
+    endtime,
+    title,
+    content,
+    location,
+    allDay,
+    typeId,
+  };
+  let id = await CalendarCommandHandler.create(createItem);
+
+  res.send(id);
+}
+
+/**
+ * @description create calendar type
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createCalendarType(req: Request, res: Response): Promise<any> {
+  const type = req.body.type;
+  const nscdr = req.body.nscdr;
+  const color = req.body.color;
+  const passphrase = req.body.passphrase;
+
+  let createType: CreateCalendarTypeCommand = {
+    type,
+    nscdr,
+    color,
+    passphrase,
+  };
+  let id = await CalendarTypeCommandHandler.create(createType);
+
+  res.send(id);
+}
+
+/**
+ * @description update calendar item
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateCalendarItem(req: Request, res: Response): Promise<any> {
+  const id = req.params.id;
+  const starttime = req.body.starttime;
+  const endtime = req.body.endtime;
+  const title = req.body.title;
+  const content = req.body.content;
+  const location = req.body.location;
+  const allDay = req.body.allDay;
+  const typeId = req.body.typeId;
+
+  let updateItem: UpdateCalendarCommand = {
+    id,
+    starttime,
+    endtime,
+    title,
+    content,
+    location,
+    allDay,
+    typeId,
+  };
+  await CalendarCommandHandler.update(updateItem);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update calendar type
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateCalendarType(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+  const type = req.body.type;
+  const nscdr = req.body.nscdr;
+  const color = req.body.color;
+  const passphrase = req.body.passphrase;
+
+  let updateType: UpdateCalendarTypeCommand = {
+    id,
+    type,
+    nscdr,
+    color,
+    passphrase,
+  };
+  await CalendarTypeCommandHandler.update(updateType);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete calendar item
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteCalendarItem(req: Request, res: Response): Promise<any> {
+  const id = req.params.id;
+
+  let deleteItem: DeleteCalendarCommand = {
+    id,
+  };
+  await CalendarCommandHandler.delete(deleteItem);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete calendar type
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteCalendarType(req: Request, res: Response): Promise<any> {
+  const id = parseInt(req.params.id);
+
+  let deleteType: DeleteCalendarTypeCommand = {
+    id,
+  };
+  await CalendarTypeCommandHandler.delete(deleteType);
+
+  res.sendStatus(204);
+}

src/controller/admin/club/memberController.ts

@@ -0,0 +1,716 @@
+import { Request, Response } from "express";
+import MemberService from "../../../service/club/member/memberService";
+import MemberFactory from "../../../factory/admin/club/member/member";
+import MembershipService from "../../../service/club/member/membershipService";
+import MembershipFactory from "../../../factory/admin/club/member/membership";
+import MemberAwardService from "../../../service/club/member/memberAwardService";
+import MemberAwardFactory from "../../../factory/admin/club/member/memberAward";
+import MemberQualificationService from "../../../service/club/member/memberQualificationService";
+import MemberQualificationFactory from "../../../factory/admin/club/member/memberQualification";
+import MemberExecutivePositionService from "../../../service/club/member/memberExecutivePositionService";
+import MemberExecutivePositionFactory from "../../../factory/admin/club/member/memberExecutivePosition";
+import CommunicationService from "../../../service/club/member/communicationService";
+import CommunicationFactory from "../../../factory/admin/club/member/communication";
+import {
+  CreateMemberCommand,
+  DeleteMemberCommand,
+  UpdateMemberCommand,
+  UpdateMemberNewsletterCommand,
+} from "../../../command/club/member/memberCommand";
+import MemberCommandHandler from "../../../command/club/member/memberCommandHandler";
+import {
+  CreateMembershipCommand,
+  DeleteMembershipCommand,
+  UpdateMembershipCommand,
+} from "../../../command/club/member/membershipCommand";
+import MembershipCommandHandler from "../../../command/club/member/membershipCommandHandler";
+import {
+  CreateMemberAwardCommand,
+  DeleteMemberAwardCommand,
+  UpdateMemberAwardCommand,
+} from "../../../command/club/member/memberAwardCommand";
+import MemberAwardCommandHandler from "../../../command/club/member/memberAwardCommandHandler";
+import {
+  CreateMemberExecutivePositionCommand,
+  DeleteMemberExecutivePositionCommand,
+  UpdateMemberExecutivePositionCommand,
+} from "../../../command/club/member/memberExecutivePositionCommand";
+import MemberExecutivePositionCommandHandler from "../../../command/club/member/memberExecutivePositionCommandHandler";
+import {
+  CreateMemberQualificationCommand,
+  DeleteMemberQualificationCommand,
+  UpdateMemberQualificationCommand,
+} from "../../../command/club/member/memberQualificationCommand";
+import MemberQualificationCommandHandler from "../../../command/club/member/memberQualificationCommandHandler";
+import {
+  CreateCommunicationCommand,
+  DeleteCommunicationCommand,
+  UpdateCommunicationCommand,
+} from "../../../command/club/member/communicationCommand";
+import CommunicationCommandHandler from "../../../command/club/member/communicationCommandHandler";
+import {PdfExport} from "../../../helpers/pdfExport";
+import {PermissionModule} from "../../../type/permissionTypes";
+
+/**
+ * @description get all members
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllMembers(req: Request, res: Response): Promise<any> {
+  let offset = parseInt((req.query.offset as string) ?? "0");
+  let count = parseInt((req.query.count as string) ?? "25");
+  let search = (req.query.search as string) ?? "";
+
+  let [members, total] = await MemberService.getAll(offset, count, search);
+
+  res.json({
+    members: MemberFactory.mapToBase(members),
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get member by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getMemberById(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.id);
+  let member = await MemberService.getById(memberId);
+
+  res.json(MemberFactory.mapToSingle(member));
+}
+
+/**
+ * @description get memberships by member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getMembershipsByMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  let memberships = await MembershipService.getAll(memberId);
+
+  res.json(MembershipFactory.mapToBase(memberships));
+}
+
+/**
+ * @description get membership by member and record
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getMembershipByMemberAndRecord(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.id);
+  let membership = await MembershipService.getById(memberId, recordId);
+
+  res.json(MembershipFactory.mapToSingle(membership));
+}
+
+/**
+ * @description get awards by member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAwardsByMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  let awards = await MemberAwardService.getAll(memberId);
+
+  res.json(MemberAwardFactory.mapToBase(awards));
+}
+
+/**
+ * @description get award by member and record
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAwardByMemberAndRecord(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.id);
+  let award = await MemberAwardService.getById(memberId, recordId);
+
+  res.json(MemberAwardFactory.mapToSingle(award));
+}
+
+/**
+ * @description get qualifications by member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getQualificationsByMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  let qualifications = await MemberQualificationService.getAll(memberId);
+
+  res.json(MemberQualificationFactory.mapToBase(qualifications));
+}
+
+/**
+ * @description get qualification by member and record
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getQualificationByMemberAndRecord(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.id);
+  let qualification = await MemberQualificationService.getById(memberId, recordId);
+
+  res.json(MemberQualificationFactory.mapToSingle(qualification));
+}
+
+/**
+ * @description get executive positions by member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getExecutivePositionsByMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  let positions = await MemberExecutivePositionService.getAll(memberId);
+
+  res.json(MemberExecutivePositionFactory.mapToBase(positions));
+}
+
+/**
+ * @description get executive position by member and record
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getExecutivePositionByMemberAndRecord(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.id);
+  let position = await MemberExecutivePositionService.getById(memberId, recordId);
+
+  res.json(MemberExecutivePositionFactory.mapToSingle(position));
+}
+
+/**
+ * @description get communications by member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getCommunicationsByMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  let communications = await CommunicationService.getAll(memberId);
+
+  res.json(CommunicationFactory.mapToBase(communications));
+}
+
+/**
+ * @description get communication by member and record
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getCommunicationByMemberAndRecord(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.id);
+  let communication = await CommunicationService.getById(memberId, recordId);
+
+  res.json(CommunicationFactory.mapToSingle(communication));
+}
+
+/**
+ * @description create member printout list
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createMemberPrintoutList(req: Request, res: Response): Promise<any> {
+  let members = await MemberService.getByRunningMembership()
+
+  let pdf = await PdfExport.renderFile({
+    title: "Mitgliederliste",
+    template: "member.list",
+    saveToDisk: false,
+    data: {
+      member: members
+    },
+  });
+
+  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 create member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createMember(req: Request, res: Response): Promise<any> {
+  const salutation = req.body.salutation;
+  const firstname = req.body.firstname;
+  const lastname = req.body.lastname;
+  const nameaffix = req.body.nameaffix;
+  const birthdate = req.body.birthdate;
+  const internalId = req.body.internalId;
+
+  let createMember: CreateMemberCommand = {
+    salutation,
+    firstname,
+    lastname,
+    nameaffix,
+    birthdate,
+    internalId,
+  };
+  let memberId = await MemberCommandHandler.create(createMember);
+
+  res.status(200).send(memberId);
+}
+
+/**
+ * @description add memberships to member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function addMembershipToMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const start = req.body.start;
+  const statusId = req.body.statusId;
+
+  let createMembership: CreateMembershipCommand = {
+    start,
+    memberId,
+    statusId,
+  };
+  await MembershipCommandHandler.create(createMembership);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description add awards to member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function addAwardToMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const given = req.body.given;
+  const note = req.body.note;
+  const date = req.body.date;
+  const awardId = req.body.awardId;
+
+  let createMemberAward: CreateMemberAwardCommand = {
+    given,
+    note,
+    date,
+    memberId,
+    awardId,
+  };
+  await MemberAwardCommandHandler.create(createMemberAward);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description add qualifications to member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function addQualificationToMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const note = req.body.note;
+  const start = req.body.start;
+  const qualificationId = req.body.qualificationId;
+
+  let createMemberQualification: CreateMemberQualificationCommand = {
+    note,
+    start,
+    memberId,
+    qualificationId,
+  };
+  await MemberQualificationCommandHandler.create(createMemberQualification);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description add executive positions to member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function addExecutivePositionToMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const note = req.body.note;
+  const start = req.body.start;
+  const end = req.body.end || null;
+  const executivePositionId = req.body.executivePositionId;
+
+  let createMemberExecutivePosition: CreateMemberExecutivePositionCommand = {
+    note,
+    start,
+    end,
+    memberId,
+    executivePositionId,
+  };
+  await MemberExecutivePositionCommandHandler.create(createMemberExecutivePosition);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description add communications to member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function addCommunicationToMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const preferred = req.body.preferred;
+  const isSMSAlarming = req.body.isSMSAlarming;
+  const mobile = req.body.mobile;
+  const email = req.body.email;
+  const postalCode = req.body.postalCode;
+  const city = req.body.city;
+  const street = req.body.street;
+  const streetNumber = req.body.streetNumber;
+  const streetNumberAddition = req.body.streetNumberAddition;
+  const typeId = req.body.typeId;
+  const isNewsletterMain = req.body.isNewsletterMain;
+
+  let createCommunication: CreateCommunicationCommand = {
+    preferred,
+    isSMSAlarming,
+    mobile,
+    email,
+    postalCode,
+    city,
+    street,
+    streetNumber,
+    streetNumberAddition,
+    memberId,
+    typeId,
+  };
+  let id = await CommunicationCommandHandler.create(createCommunication);
+
+  if (isNewsletterMain) {
+    let updateNewsletter: UpdateMemberNewsletterCommand = {
+      id: memberId,
+      communicationId: id,
+    };
+    await MemberCommandHandler.updateNewsletter(updateNewsletter);
+  }
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update member by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateMemberById(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.id);
+  const salutation = req.body.salutation;
+  const firstname = req.body.firstname;
+  const lastname = req.body.lastname;
+  const nameaffix = req.body.nameaffix;
+  const birthdate = req.body.birthdate;
+  const internalId = req.body.internalId;
+
+  let updateMember: UpdateMemberCommand = {
+    id: memberId,
+    salutation,
+    firstname,
+    lastname,
+    nameaffix,
+    birthdate,
+    internalId,
+  };
+  await MemberCommandHandler.update(updateMember);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update membership of member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateMembershipOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+  const start = req.body.start;
+  const end = req.body.end || null;
+  const terminationReason = req.body.terminationReason;
+  const statusId = req.body.statusId;
+
+  let updateMembership: UpdateMembershipCommand = {
+    id: recordId,
+    start,
+    end,
+    terminationReason,
+    memberId,
+    statusId,
+  };
+  await MembershipCommandHandler.update(updateMembership);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update award of member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateAwardOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+  const given = req.body.given;
+  const note = req.body.note;
+  const date = req.body.date;
+  const awardId = req.body.awardId;
+
+  let updateMemberAward: UpdateMemberAwardCommand = {
+    id: recordId,
+    given,
+    note,
+    date,
+    memberId,
+    awardId,
+  };
+  await MemberAwardCommandHandler.update(updateMemberAward);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update qualification of member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateQualificationOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+  const note = req.body.note;
+  const start = req.body.start;
+  const end = req.body.end || null;
+  const terminationReason = req.body.terminationReason;
+  const qualificationId = req.body.qualificationId;
+
+  let updateMemberQualification: UpdateMemberQualificationCommand = {
+    id: recordId,
+    note,
+    start,
+    end,
+    terminationReason,
+    memberId,
+    qualificationId,
+  };
+  await MemberQualificationCommandHandler.update(updateMemberQualification);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update executive position of member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateExecutivePositionOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+  const note = req.body.note;
+  const start = req.body.start;
+  const end = req.body.end || null;
+  const executivePositionId = req.body.executivePositionId;
+
+  let updateMemberExecutivePosition: UpdateMemberExecutivePositionCommand = {
+    id: recordId,
+    note,
+    start,
+    end,
+    memberId,
+    executivePositionId,
+  };
+  await MemberExecutivePositionCommandHandler.update(updateMemberExecutivePosition);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description update communication of member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateCommunicationOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+  const preferred = req.body.preferred;
+  const isSMSAlarming = req.body.isSMSAlarming;
+  const mobile = req.body.mobile;
+  const email = req.body.email;
+  const postalCode = req.body.postalCode;
+  const city = req.body.city;
+  const street = req.body.street;
+  const streetNumber = req.body.streetNumber;
+  const streetNumberAddition = req.body.streetNumberAddition;
+  const isNewsletterMain = req.body.isNewsletterMain;
+
+  let updateCommunication: UpdateCommunicationCommand = {
+    id: recordId,
+    preferred,
+    isSMSAlarming,
+    mobile,
+    email,
+    postalCode,
+    city,
+    street,
+    streetNumber,
+    streetNumberAddition,
+    memberId,
+  };
+  await CommunicationCommandHandler.update(updateCommunication);
+
+  let currentUserNewsletterMain = await MemberService.getNewsletterById(memberId);
+
+  if (isNewsletterMain) {
+    let updateNewsletter: UpdateMemberNewsletterCommand = {
+      id: memberId,
+      communicationId: recordId,
+    };
+    await MemberCommandHandler.updateNewsletter(updateNewsletter);
+  } else if (currentUserNewsletterMain.sendNewsletter.id == recordId) {
+    await MemberCommandHandler.unsetNewsletter(memberId);
+  }
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete member by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteMemberById(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.id);
+
+  let deleteMember: DeleteMemberCommand = {
+    id: memberId,
+  };
+  await MemberCommandHandler.delete(deleteMember);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete membership from member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteMembershipOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+
+  let deleteMembership: DeleteMembershipCommand = {
+    id: recordId,
+    memberId,
+  };
+  await MembershipCommandHandler.delete(deleteMembership);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete award from member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteAwardOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+
+  let deleteMemberAward: DeleteMemberAwardCommand = {
+    id: recordId,
+    memberId,
+  };
+  await MemberAwardCommandHandler.delete(deleteMemberAward);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete qualification from member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteQualificationOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+
+  let deleteMemberQualification: DeleteMemberQualificationCommand = {
+    id: recordId,
+    memberId,
+  };
+  await MemberQualificationCommandHandler.delete(deleteMemberQualification);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete executive position from member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteExecutivePositionOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+
+  let deleteMemberExecutivePosition: DeleteMemberExecutivePositionCommand = {
+    id: recordId,
+    memberId,
+  };
+  await MemberExecutivePositionCommandHandler.delete(deleteMemberExecutivePosition);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete communication from member
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteCommunicationOfMember(req: Request, res: Response): Promise<any> {
+  const memberId = parseInt(req.params.memberId);
+  const recordId = parseInt(req.params.recordId);
+
+  let deleteCommunication: DeleteCommunicationCommand = {
+    id: recordId,
+    memberId,
+  };
+  await CommunicationCommandHandler.delete(deleteCommunication);
+
+  res.sendStatus(204);
+}

src/controller/admin/club/newsletterController.ts

@@ -0,0 +1,387 @@
+import { Request, Response } from "express";
+import NewsletterService from "../../../service/club/newsletter/newsletterService";
+import NewsletterFactory from "../../../factory/admin/club/newsletter/newsletter";
+import NewsletterDatesService from "../../../service/club/newsletter/newsletterDatesService";
+import NewsletterDatesFactory from "../../../factory/admin/club/newsletter/newsletterDates";
+import NewsletterRecipientsService from "../../../service/club/newsletter/newsletterRecipientsService";
+import NewsletterRecipientsFactory from "../../../factory/admin/club/newsletter/newsletterRecipients";
+import { FileSystemHelper } from "../../../helpers/fileSystemHelper";
+import { CreateNewsletterCommand, SynchronizeNewsletterCommand } from "../../../command/club/newsletter/newsletterCommand";
+import NewsletterCommandHandler from "../../../command/club/newsletter/newsletterCommandHandler";
+import { SynchronizeNewsletterDatesCommand } from "../../../command/club/newsletter/newsletterDatesCommand";
+import NewsletterDatesCommandHandler from "../../../command/club/newsletter/newsletterDatesCommandHandler";
+import { SynchronizeNewsletterRecipientsCommand } from "../../../command/club/newsletter/newsletterRecipientsCommand";
+import NewsletterRecipientsCommandHandler from "../../../command/club/newsletter/newsletterRecipientsCommandHandler";
+import { NewsletterDatesViewModel } from "../../../viewmodel/admin/club/newsletter/newsletterDates.models";
+import { PdfExport } from "../../../helpers/pdfExport";
+import UserService from "../../../service/user/userService";
+import { TemplateHelper } from "../../../helpers/templateHelper";
+import MailHelper from "../../../helpers/mailHelper";
+import { NewsletterEventType, NewsletterHelper } from "../../../helpers/newsletterHelper";
+import { Salutation } from "../../../enums/salutation";
+
+/**
+ * @description get all newsletters
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllNewsletters(req: Request, res: Response): Promise<any> {
+  let offset = parseInt((req.query.offset as string) ?? "0");
+  let count = parseInt((req.query.count as string) ?? "25");
+  let [newsletters, total] = await NewsletterService.getAll(offset, count);
+
+  res.json({
+    newsletters: NewsletterFactory.mapToBase(newsletters),
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get newsletter by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterById(req: Request, res: Response): Promise<any> {
+  let id = parseInt(req.params.id);
+  let newsletter = await NewsletterService.getById(id);
+
+  res.json(NewsletterFactory.mapToSingle(newsletter));
+}
+
+/**
+ * @description get newsletter dates by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterDatesById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  let dates = await NewsletterDatesService.getAll(newsletterId);
+
+  res.json(NewsletterDatesFactory.mapToBase(dates));
+}
+
+/**
+ * @description get newsletter recipients by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterRecipientsById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  let recipients = await NewsletterRecipientsService.getAll(newsletterId);
+
+  res.json(NewsletterRecipientsFactory.mapToBase(recipients));
+}
+
+/**
+ * @description get newsletter printouts by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterPrintoutsById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  let newsletter = await NewsletterService.getById(newsletterId);
+
+  let filesInFolder = FileSystemHelper.getFilesInDirectory(
+    `newsletter/${newsletter.id}_${newsletter.title.replace(" ", "")}`
+  );
+
+  res.json(filesInFolder);
+}
+
+/**
+ * @description get newsletter printout by id and print
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterPrintoutByIdAndPrint(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+  let filename = req.params.filename;
+
+  let newsletter = await NewsletterService.getById(newsletterId);
+
+  let filepath = FileSystemHelper.formatPath(
+    "newsletter",
+    `${newsletter.id}_${newsletter.title.replace(" ", "")}`,
+    filename
+  );
+
+  res.sendFile(filepath, {
+    headers: {
+      "Content-Type": "application/pdf",
+    },
+  });
+}
+
+/**
+ * @description create newsletter printout preview by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createNewsletterPrintoutPreviewById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+  let newsletter = await NewsletterService.getById(newsletterId);
+  let dates = await NewsletterDatesService.getAll(newsletterId);
+  let recipient = await UserService.getById(parseInt(req.userId));
+
+  let data = NewsletterHelper.buildData(newsletter, dates);
+  data.recipient = {
+    firstname: recipient.firstname,
+    lastname: recipient.lastname,
+    salutation: Salutation.none,
+    nameaffix: "",
+    street: "Straße",
+    streetNumber: "Hausnummer",
+    streetNumberAdd: "Adresszusatz",
+  };
+
+  let pdf = await PdfExport.renderFile({
+    title: "Probedruck Newsletter",
+    template: "newsletter",
+    saveToDisk: false,
+    data: data,
+  });
+
+  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 create newsletter
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createNewsletter(req: Request, res: Response): Promise<any> {
+  let title = req.body.title;
+
+  let createNewsletter: CreateNewsletterCommand = {
+    title,
+  };
+  let id = await NewsletterCommandHandler.create(createNewsletter);
+
+  res.send(id);
+}
+
+/**
+ * @description get newsletter printout progress by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterPrintoutProgressById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+
+  res.flushHeaders();
+
+  const progressHandler = (data: NewsletterEventType) => {
+    if (data.newsletterId == newsletterId && data.kind == "pdf") {
+      res.write(JSON.stringify(data));
+    }
+  };
+
+  const completeHandler = (data: NewsletterEventType) => {
+    if (data.newsletterId == newsletterId && data.kind == "pdf") {
+      res.write(JSON.stringify(data));
+      res.end();
+    }
+  };
+
+  NewsletterHelper.jobStatus.on("progress", progressHandler);
+  NewsletterHelper.jobStatus.on("complete", completeHandler);
+
+  req.on("close", () => {
+    NewsletterHelper.jobStatus.off("progress", progressHandler);
+    NewsletterHelper.jobStatus.off("complete", completeHandler);
+  });
+}
+
+/**
+ * @description create newsletter printouts for each member by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createNewsletterPrintoutById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  await NewsletterHelper.printPdfs(newsletterId);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description create newsletter mail preview by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createNewsletterMailPreviewById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+  let newsletter = await NewsletterService.getById(newsletterId);
+  let dates = await NewsletterDatesService.getAll(newsletterId);
+  let recipient = await UserService.getById(parseInt(req.userId));
+
+  let data = NewsletterHelper.buildData(newsletter, dates);
+  data.recipient = {
+    firstname: recipient.firstname,
+    lastname: recipient.lastname,
+    salutation: Salutation.none,
+    nameaffix: "",
+    street: "Straße",
+    streetNumber: "Hausnummer",
+    streetNumberAdd: "Adresszusatz",
+  };
+
+  const { body } = await TemplateHelper.renderFileForModule({
+    module: "newsletter",
+    bodyData: data,
+    title: "Probeversand Newsletter",
+  });
+
+  await MailHelper.sendMail(recipient.mail, "Probeversand Newsletter", body);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description send newsletter mail and create printouts by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function sendNewsletterById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  await NewsletterHelper.sendMails(newsletterId);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description get newsletter sending progress by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getNewsletterSendingProgressById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+
+  res.flushHeaders();
+
+  const progressHandler = (data: NewsletterEventType) => {
+    if (data.newsletterId == newsletterId && data.kind == "mail") {
+      res.write(JSON.stringify(data));
+    }
+  };
+
+  const completeHandler = (data: NewsletterEventType) => {
+    if (data.newsletterId == newsletterId && data.kind == "mail") {
+      res.write(JSON.stringify(data));
+      res.end();
+    }
+  };
+
+  NewsletterHelper.jobStatus.on("progress", progressHandler);
+  NewsletterHelper.jobStatus.on("complete", completeHandler);
+
+  req.on("close", () => {
+    NewsletterHelper.jobStatus.off("progress", progressHandler);
+    NewsletterHelper.jobStatus.off("complete", completeHandler);
+  });
+}
+
+/**
+ * @description synchronize newsletter by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function synchronizeNewsletterById(req: Request, res: Response): Promise<any> {
+  let id = parseInt(req.params.id);
+  let title = req.body.title;
+  let description = req.body.description;
+  let newsletterTitle = req.body.newsletterTitle;
+  let newsletterText = req.body.newsletterText;
+  let newsletterSignatur = req.body.newsletterSignatur;
+  let recipientsByQueryId = req.body.recipientsByQueryId ?? null;
+
+  let syncNewsletter: SynchronizeNewsletterCommand = {
+    id,
+    title,
+    description,
+    newsletterTitle,
+    newsletterText,
+    newsletterSignatur,
+    recipientsByQueryId,
+  };
+  await NewsletterCommandHandler.sync(syncNewsletter);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description synchronize newsletter dates by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function synchronizeNewsletterDatesById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+  let dates = req.body.dates as Array<NewsletterDatesViewModel>;
+
+  let syncDates: SynchronizeNewsletterDatesCommand = {
+    newsletterId,
+    dates: dates.map((d) => ({
+      calendarId: d.calendarId,
+      diffTitle: d.diffTitle,
+      diffDescription: d.diffDescription,
+    })),
+  };
+  await NewsletterDatesCommandHandler.sync(syncDates);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description synchronize newsletter recipients by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function synchronizeNewsletterRecipientsById(req: Request, res: Response): Promise<any> {
+  let newsletterId = parseInt(req.params.newsletterId);
+  let recipients = req.body.recipients as Array<number>;
+
+  let syncRecipients: SynchronizeNewsletterRecipientsCommand = {
+    newsletterId,
+    recipients: recipients,
+  };
+  await NewsletterRecipientsCommandHandler.sync(syncRecipients);
+
+  res.sendStatus(204);
+}

src/controller/admin/club/protocolController.ts

@@ -0,0 +1,398 @@
+import { Request, Response } from "express";
+import ProtocolService from "../../../service/club/protocol/protocolService";
+import ProtocolFactory from "../../../factory/admin/club/protocol/protocol";
+import ProtocolAgendaService from "../../../service/club/protocol/protocolAgendaService";
+import ProtocolAgendaFactory from "../../../factory/admin/club/protocol/protocolAgenda";
+import ProtocolDecisionService from "../../../service/club/protocol/protocolDecisionService";
+import ProtocolDecisionFactory from "../../../factory/admin/club/protocol/protocolDecision";
+import ProtocolPresenceService from "../../../service/club/protocol/protocolPrecenseService";
+import ProtocolPresenceFactory from "../../../factory/admin/club/protocol/protocolPresence";
+import ProtocolVotingService from "../../../service/club/protocol/protocolVotingService";
+import ProtocolVotingFactory from "../../../factory/admin/club/protocol/protocolVoting";
+import { CreateProtocolCommand, SynchronizeProtocolCommand } from "../../../command/club/protocol/protocolCommand";
+import ProtocolCommandHandler from "../../../command/club/protocol/protocolCommandHandler";
+import { SynchronizeProtocolAgendaCommand } from "../../../command/club/protocol/protocolAgendaCommand";
+import ProtocolAgendaCommandHandler from "../../../command/club/protocol/protocolAgendaCommandHandler";
+import { ProtocolAgendaViewModel } from "../../../viewmodel/admin/club/protocol/protocolAgenda.models";
+import ProtocolDecisionCommandHandler from "../../../command/club/protocol/protocolDecisionCommandHandler";
+import { ProtocolDecisionViewModel } from "../../../viewmodel/admin/club/protocol/protocolDecision.models";
+import ProtocolPresenceCommandHandler from "../../../command/club/protocol/protocolPresenceCommandHandler";
+import { SynchronizeProtocolPresenceCommand } from "../../../command/club/protocol/protocolPresenceCommand";
+import { SynchronizeProtocolDecisionCommand } from "../../../command/club/protocol/protocolDecisionCommand";
+import { SynchronizeProtocolVotingCommand } from "../../../command/club/protocol/protocolVotingCommand";
+import { ProtocolVotingViewModel } from "../../../viewmodel/admin/club/protocol/protocolVoting.models";
+import ProtocolVotingCommandHandler from "../../../command/club/protocol/protocolVotingCommandHandler";
+import { PdfExport } from "../../../helpers/pdfExport";
+import ProtocolPrintoutService from "../../../service/club/protocol/protocolPrintoutService";
+import ProtocolPrintoutFactory from "../../../factory/admin/club/protocol/protocolPrintout";
+import { CreateProtocolPrintoutCommand } from "../../../command/club/protocol/protocolPrintoutCommand";
+import ProtocolPrintoutCommandHandler from "../../../command/club/protocol/protocolPrintoutCommandHandler";
+import { FileSystemHelper } from "../../../helpers/fileSystemHelper";
+import { ProtocolPresenceViewModel } from "../../../viewmodel/admin/club/protocol/protocolPresence.models";
+
+/**
+ * @description get all protocols
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllProtocols(req: Request, res: Response): Promise<any> {
+  let offset = parseInt((req.query.offset as string) ?? "0");
+  let count = parseInt((req.query.count as string) ?? "25");
+  let [protocols, total] = await ProtocolService.getAll(offset, count);
+
+  res.json({
+    protocols: ProtocolFactory.mapToBase(protocols),
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get protocol by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getProtocolById(req: Request, res: Response): Promise<any> {
+  let id = parseInt(req.params.id);
+  let protocol = await ProtocolService.getById(id);
+
+  res.json(ProtocolFactory.mapToSingle(protocol));
+}
+
+/**
+ * @description get protocol agenda by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getProtocolAgendaById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+
+  let agenda = await ProtocolAgendaService.getAll(protocolId);
+
+  res.json(ProtocolAgendaFactory.mapToBase(agenda));
+}
+
+/**
+ * @description get protocol decisions by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getProtocolDecisonsById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+
+  let decisions = await ProtocolDecisionService.getAll(protocolId);
+
+  res.json(ProtocolDecisionFactory.mapToBase(decisions));
+}
+
+/**
+ * @description get protocol precense by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getProtocolPrecenseById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+
+  let presence = await ProtocolPresenceService.getAll(protocolId);
+
+  res.json(ProtocolPresenceFactory.mapToBase(presence));
+}
+
+/**
+ * @description get protocol votings by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getProtocolVotingsById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+
+  let votings = await ProtocolVotingService.getAll(protocolId);
+
+  res.json(ProtocolVotingFactory.mapToBase(votings));
+}
+
+/**
+ * @description get protocol printouts by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getProtocolPrintoutsById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+
+  let printouts = await ProtocolPrintoutService.getAll(protocolId);
+
+  res.json(ProtocolPrintoutFactory.mapToBase(printouts));
+}
+
+/**
+ * @description get protocol printout by id and print
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getProtocolPrintoutByIdAndPrint(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+  let printoutId = parseInt(req.params.printoutId);
+
+  let printout = await ProtocolPrintoutService.getById(printoutId, protocolId);
+
+  let filepath = FileSystemHelper.formatPath("protocol", printout.filename);
+
+  res.sendFile(filepath, {
+    headers: {
+      "Content-Type": "application/pdf",
+    },
+  });
+}
+
+/**
+ * @description create protocol
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createProtocol(req: Request, res: Response): Promise<any> {
+  let title = req.body.title;
+  let date = req.body.date;
+
+  let createProtocol: CreateProtocolCommand = {
+    title,
+    date,
+  };
+  let id = await ProtocolCommandHandler.create(createProtocol);
+
+  res.send(id);
+}
+
+/**
+ * @description create protocol agenda by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createProtocolAgendaById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+
+  let agenda = await ProtocolAgendaCommandHandler.create(protocolId);
+
+  res.send(agenda);
+}
+
+/**
+ * @description create protocol decisions by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createProtocolDecisonsById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+
+  let decision = await ProtocolDecisionCommandHandler.create(protocolId);
+
+  res.send(decision);
+}
+
+/**
+ * @description create protocol votings by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createProtocolVotingsById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+
+  let voting = await ProtocolVotingCommandHandler.create(protocolId);
+
+  res.send(voting);
+}
+
+/**
+ * @description create protocol printout by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createProtocolPrintoutById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+  let protocol = await ProtocolService.getById(protocolId);
+  let agenda = await ProtocolAgendaService.getAll(protocolId);
+  let decisions = await ProtocolDecisionService.getAll(protocolId);
+  let presence = await ProtocolPresenceService.getAll(protocolId);
+  let votings = await ProtocolVotingService.getAll(protocolId);
+  let iteration = await ProtocolPrintoutService.getCount(protocolId);
+
+  let title = `${protocol.title} - ${new Date(protocol.date).toLocaleDateString("de-DE", {
+    day: "2-digit",
+    month: "long",
+    year: "numeric",
+  })}`;
+
+  let filename = `${new Date().toISOString().split("T")[0]}_${iteration + 1}_Protokoll_${protocol.title.replace(
+    /[^a-zA-Z0-9]/g,
+    ""
+  )}`;
+
+  await PdfExport.renderFile({
+    template: "protocol",
+    title,
+    filename,
+    folder: "protocol",
+    data: {
+      title: protocol.title,
+      summary: protocol.summary,
+      iteration: iteration + 1,
+      date: new Date(protocol.date).toLocaleDateString("de-DE", {
+        weekday: "long",
+        day: "2-digit",
+        month: "2-digit",
+        year: "numeric",
+      }),
+      start: protocol.starttime,
+      end: protocol.endtime,
+      agenda,
+      decisions,
+      presence: presence.filter((p) => !p.absent).map((p) => p.member),
+      absent: presence.filter((p) => p.absent).map((p) => p.member),
+      votings,
+    },
+  });
+
+  let printout: CreateProtocolPrintoutCommand = {
+    title,
+    iteration: iteration + 1,
+    filename: `${filename}.pdf`,
+    protocolId,
+  };
+  await ProtocolPrintoutCommandHandler.create(printout);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description synchronize protocol by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function synchronizeProtocolById(req: Request, res: Response): Promise<any> {
+  let id = parseInt(req.params.id);
+  let title = req.body.title;
+  let date = req.body.date;
+  let starttime = req.body.starttime;
+  let endtime = req.body.endtime;
+  let summary = req.body.summary;
+
+  let syncProtocol: SynchronizeProtocolCommand = {
+    id,
+    title,
+    date,
+    starttime,
+    endtime,
+    summary,
+  };
+  await ProtocolCommandHandler.sync(syncProtocol);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description synchronize protocol agenda by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function synchronizeProtocolAgendaById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+  let agenda = req.body.agenda as Array<ProtocolAgendaViewModel>;
+
+  let syncAgenda: Array<SynchronizeProtocolAgendaCommand> = agenda.map(
+    (a: ProtocolAgendaViewModel): SynchronizeProtocolAgendaCommand => ({
+      id: a.id ?? null,
+      topic: a.topic,
+      context: a.context,
+      protocolId,
+    })
+  );
+  await ProtocolAgendaCommandHandler.sync(syncAgenda);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description synchronize protocol decisions by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function synchronizeProtocolDecisonsById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+  let decisions = req.body.decisions as Array<ProtocolDecisionViewModel>;
+
+  let syncDecision: Array<SynchronizeProtocolDecisionCommand> = decisions.map(
+    (d: ProtocolDecisionViewModel): SynchronizeProtocolDecisionCommand => ({
+      id: d.id ?? null,
+      topic: d.topic,
+      context: d.context,
+      protocolId,
+    })
+  );
+  await ProtocolDecisionCommandHandler.sync(syncDecision);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description synchronize protocol votings by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function synchronizeProtocolVotingsById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+  let votings = req.body.votings as Array<ProtocolVotingViewModel>;
+
+  let syncVoting: Array<SynchronizeProtocolVotingCommand> = votings.map(
+    (d: ProtocolVotingViewModel): SynchronizeProtocolVotingCommand => ({
+      id: d.id ?? null,
+      topic: d.topic,
+      context: d.context,
+      favour: d.favour,
+      abstain: d.abstain,
+      against: d.abstain,
+      protocolId,
+    })
+  );
+  await ProtocolVotingCommandHandler.sync(syncVoting);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description synchronize protocol precense by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function synchronizeProtocolPrecenseById(req: Request, res: Response): Promise<any> {
+  let protocolId = parseInt(req.params.protocolId);
+  let presence = req.body.presence as Array<ProtocolPresenceViewModel>;
+
+  let syncPresence: SynchronizeProtocolPresenceCommand = {
+    members: presence.map((p) => ({
+      memberId: p.memberId,
+      absent: p.absent,
+    })),
+    protocolId,
+  };
+  await ProtocolPresenceCommandHandler.sync(syncPresence);
+
+  res.sendStatus(204);
+}

src/controller/admin/club/queryBuilderController.ts

@@ -0,0 +1,108 @@
+import { Request, Response } from "express";
+import DynamicQueryBuilder from "../../../helpers/dynamicQueryBuilder";
+import { dataSource } from "../../../data-source";
+
+/**
+ * @description get all table metas
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllTableMeta(req: Request, res: Response): Promise<any> {
+  let tableMetas = DynamicQueryBuilder.getAllTableMeta();
+
+  res.json(tableMetas);
+}
+
+/**
+ * @description get meta by tablename
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getTableMetaByTablename(req: Request, res: Response): Promise<any> {
+  const tablename = req.params.tablename;
+  let tableMeta = DynamicQueryBuilder.getTableMeta(tablename);
+
+  res.json(tableMeta);
+}
+
+/**
+ * @description execute Query
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function executeQuery(req: Request, res: Response): Promise<any> {
+  let offset = parseInt((req.query.offset as string) ?? "0");
+  let count = parseInt((req.query.count as string) ?? "25");
+  const query = req.body.query;
+
+  if (typeof query == "string") {
+    const upperQuery = query.trim().toUpperCase();
+    if (!upperQuery.startsWith("SELECT") || /INSERT|UPDATE|DELETE|ALTER|DROP|CREATE|TRUNCATE/.test(upperQuery)) {
+      return res.json({
+        stats: "error",
+        sql: query,
+        code: "UNALLOWED",
+        msg: "Not allowed to change rows",
+      });
+    }
+
+    try {
+      let data: Array<any> = [];
+
+      const result = await dataSource
+        .transaction(async (manager) => {
+          data = await manager.query(query);
+
+          throw new Error("AllwaysRollbackQuery");
+        })
+        .catch((error) => {
+          if (error.message === "AllwaysRollbackQuery") {
+            return {
+              stats: "success",
+              rows: data,
+              total: data.length,
+              offset: offset,
+              count: count,
+            };
+          } else {
+            return {
+              stats: "error",
+              sql: error.sql,
+              code: error.code,
+              msg: error.sqlMessage,
+            };
+          }
+        });
+      res.send(result);
+    } catch (error) {
+      res.json({
+        stats: "error",
+        sql: error.sql,
+        code: error.code,
+        msg: error.sqlMessage,
+      });
+    }
+  } else {
+    try {
+      let [rows, total] = await DynamicQueryBuilder.buildQuery(query, offset, count).getManyAndCount();
+
+      res.json({
+        stats: "success",
+        rows: DynamicQueryBuilder.flattenQueryResult(rows),
+        total: total,
+        offset: offset,
+        count: count,
+      });
+    } catch (error) {
+      res.json({
+        stats: "error",
+        sql: error.sql,
+        code: error.code,
+        msg: error.sqlMessage,
+      });
+    }
+  }
+}