base structure

.prettierrc.json

@@ -1,5 +1,5 @@
 {
   "trailingComma": "es5",
   "tabWidth": 2,
-  "printWidth": 120
+  "printWidth": 150
 }

README.md

@@ -1,3 +1,60 @@
 # ff-admin-webapi-client
 
-npm package as for managing ff-admin webapi connection
+FF Admin Webapi Client ist ein NPM-Package, welches die Verbindung zu einem FF Admin-Server vereinfacht.
+
+Zur Verfügung gestellt werden Requests mit den benötigten Models, Types und Enums für FF Admin.
+
+Der WebApiClient realisiert den automatischen refresh von Zugangs-Tokens.
+
+Beispiele:\
+1. Verwendung des Clients:
+``` ts
+import { WebApiClient, AdminRequests } from "@ff-admin/webapi-client"
+
+let myClient = new WebApiClient({ 
+  serverAdress: "", 
+  webapiToken: "" 
+});
+
+let data = AdminRequests.MemberRequests.getAllMembers(myClient)
+  .then((res) => {
+    console.log(res)
+  })
+  .catch((err) => {
+    console.log(err)
+  })
+
+let newMemberId = AdminRequests.MemberRequests.updateMember(myClient, {
+    body: {
+      salutationId: 0,
+      firstname: "",
+      lastname: "",
+      nameaffix: "",
+      birthdate: new Date("")
+    }
+  })
+    .then(() => {})
+    .catch(() => {});
+
+AdminRequests.MemberRequests.updateMember(myClient, {
+  params: { id: "123" },
+  body: {
+    salutationId: 0,
+    firstname: "",
+    lastname: "",
+    nameaffix: "",
+    birthdate: new Date(""),
+  },
+})
+  .then(() => {})
+  .catch(() => {});
+```
+
+2. Zugriff auf Typen, Models und Enums:
+``` ts
+import { AdminModels, AdminTypes, AdminEnums } from "@ff-admin/webapi-client"
+
+let model: AdminModels.MemberModels.CreateMemberViewModel;
+let type: AdminTypes.DynamicQueries.DynamicQueryStructure
+let enum = AdminEnums.NewsletterType.NewsletterConfigType.mail
+```

package.json

@@ -15,7 +15,8 @@
   },
   "homepage": "https://forgejo.jk-effects.cloud/Ehrenamt/ff-admin-webapi-client.git#readme",
   "dependencies": {
-    "axios": "^1.6.2"
+    "axios": "^1.6.2",
+    "typeorm": "^0.3.20"
   },
   "devDependencies": {
     "@types/node": "^20.17.16",

src/clients/clientBase.ts

@@ -0,0 +1,20 @@
+import Config from "../config";
+import HTTP from "../http";
+
+export class BaseClient extends Config {
+  protected httpInstance: HTTP;
+  constructor({ serverAdress, webapiToken }: { serverAdress: string; webapiToken: string }) {
+    super({ serverAdress, webapiToken });
+    this.httpInstance = new HTTP(this);
+  }
+
+  get http() {
+    return this.httpInstance.http;
+  }
+
+  public refreshToken(): Promise<void> {
+    return new Promise<void>(async (resolve, reject) => {
+      reject("api token refresh not implemented");
+    });
+  }
+}

src/clients/webapi.client.ts

@@ -0,0 +1,33 @@
+import { BaseClient } from "./clientBase";
+
+export class WebApiClient extends BaseClient {
+  constructor({ serverAdress, webapiToken }: { serverAdress: string; webapiToken: string }) {
+    super({ serverAdress, webapiToken });
+  }
+
+  get http() {
+    return this.httpInstance.http;
+  }
+
+  public refreshToken(): Promise<void> {
+    return new Promise<void>(async (resolve, reject) => {
+      await this.http
+        .get(`/webapi/retrieve`, {
+          headers: {
+            Authorization: `Bearer ${this.webapiToken}`,
+          },
+        })
+        .then(async (response) => {
+          const { accessToken } = response.data;
+
+          this.setAccessToken(accessToken);
+
+          resolve();
+        })
+        .catch((error) => {
+          console.error("Error refreshing webapi token:", error);
+          reject("failed token retrieve");
+        });
+    });
+  }
+}

src/config.ts

@@ -20,7 +20,7 @@ export default class Config {
     return this.access_token;
   }
 
-  public setAccessToken(token: string) {
+  protected setAccessToken(token: string) {
     this.access_token = token;
   }
 }

src/enums/admin.ts

@@ -0,0 +1 @@
+export * as NewsletterType from "./admin/newsletterType";

src/http.ts

@@ -1,14 +1,14 @@
 import axios, { AxiosInstance } from "axios";
-import { WebApiClient } from ".";
+import { BaseClient } from "./clients/clientBase";
 
-export default class http {
+export default class HTTP {
   public http: AxiosInstance;
-  private host: WebApiClient;
+  private client: BaseClient;
 
-  constructor(host: WebApiClient) {
+  constructor(client: BaseClient) {
-    this.host = host;
+    this.client = client;
     this.http = axios.create({
-      baseURL: this.host.accessToken + "/api",
+      baseURL: this.client.serverAdress + "/api",
       headers: {
         "Cache-Control": "no-cache",
         Pragma: "no-cache",
@@ -24,7 +24,7 @@ export default class http {
     this.http.interceptors.request.use(
       (config) => {
         if (config.headers && config.headers.Authorization == "") {
-          config.headers.Authorization = `Bearer ${this.host.accessToken}`;
+          config.headers.Authorization = `Bearer ${this.client.accessToken}`;
         }
 
         return config;
@@ -50,7 +50,8 @@ export default class http {
         // Handle token expiration and retry the request with a refreshed token
         if (error.response && error.response.status === 401 && !originalRequest._retry) {
           originalRequest._retry = true;
-          return await this.refreshToken()
+          return await this.client
+            .refreshToken()
             .then(() => {
               return this.http(originalRequest);
             })
@@ -61,26 +62,4 @@ export default class http {
       }
     );
   }
-
-  private refreshToken(): Promise<void> {
-    return new Promise<void>(async (resolve, reject) => {
-      await this.http
-        .get(`/webapi/retrieve`, {
-          headers: {
-            Authorization: `Bearer ${this.host.webapiToken}`,
-          },
-        })
-        .then(async (response) => {
-          const { accessToken } = response.data;
-
-          this.host.setAccessToken(accessToken);
-
-          resolve();
-        })
-        .catch((error) => {
-          console.error("Error refreshing webapi token:", error);
-          reject("failed token retrieve");
-        });
-    });
-  }
 }

src/index.ts

@@ -1,14 +1,6 @@
-import Config from "./config";
+export { WebApiClient } from "./clients/webapi.client";
-import http from "./http";
 
-export class WebApiClient extends Config {
+export * as AdminRequests from "./requests/admin";
-  private httpInstance: http;
+export * as AdminModels from "./viewmodels/admin";
-  constructor({ serverAdress, webapiToken }: { serverAdress: string; webapiToken: string }) {
+export * as AdminTypes from "./types/admin";
-    super({ serverAdress, webapiToken });
+export * as AdminEnums from "./enums/admin";
-    this.httpInstance = new http(this);
-  }
-
-  get http() {
-    return this.httpInstance.http;
-  }
-}

src/requests/admin.ts

@@ -0,0 +1,9 @@
+export { default as MemberRequests } from "./admin/memberRequests";
+export { default as MemberDataRequests } from "./admin/memberDataRequests";
+export { default as CalendarRequests } from "./admin/calendarRequests";
+export { default as NewsletterRequests } from "./admin/newsletterRequests";
+export { default as ProtocolRequests } from "./admin/protocolRequests";
+export { default as QueryRequests } from "./admin/queryRequests";
+export { default as TemplateRequests } from "./admin/templateRequests";
+export { default as UserRequests } from "./admin/userRequests";
+export { default as RoleRequests } from "./admin/roleRequests";

src/requests/admin/calendarRequests.ts

@@ -0,0 +1,63 @@
+import { AxiosResponse } from "axios";
+import { RequestDefinition, RequestData, ImplementsRequestInterface } from "../requestBase";
+import {
+  CalendarViewModel,
+  CreateCalendarViewModel,
+  UpdateCalendarViewModel,
+  CalendarTypeViewModel,
+  CreateCalendarTypeViewModel,
+  UpdateCalendarTypeViewModel,
+} from "../../viewmodels/admin/calendar.models";
+import { BaseClient } from "../../clients/clientBase";
+
+interface ICalendarRequests {
+  getCalendarEntries: RequestDefinition<void, void, CalendarViewModel[]>;
+  getCalendarEntryById: RequestDefinition<{ id: string }, void, CalendarViewModel>;
+  createCalendarEntry: RequestDefinition<void, CreateCalendarViewModel, string>;
+  updateCalendarEntry: RequestDefinition<{ id: string }, UpdateCalendarViewModel, void>;
+  deleteCalendarEntry: RequestDefinition<{ id: string }, void, void>;
+
+  getCalendarTypes: RequestDefinition<void, void, CalendarTypeViewModel[]>;
+  getCalendarTypeById: RequestDefinition<{ id: number }, void, CalendarTypeViewModel>;
+  createCalendarType: RequestDefinition<void, CreateCalendarTypeViewModel, string>;
+  updateCalendarType: RequestDefinition<{ id: number }, UpdateCalendarTypeViewModel, void>;
+  deleteCalendarType: RequestDefinition<{ id: number }, void, void>;
+}
+
+@ImplementsRequestInterface<ICalendarRequests>()
+export default abstract class CalendarRequests {
+  static async getCalendarEntries({ http }: BaseClient): Promise<AxiosResponse<CalendarViewModel[], any>> {
+    return await http.get("/admin/calendar");
+  }
+  static async getCalendarEntryById({ http }: BaseClient, p: RequestData<{ id: string }, void>): Promise<AxiosResponse<CalendarViewModel, any>> {
+    return await http.get(`/admin/calendar/${p.params.id}`);
+  }
+  static async createCalendarEntry({ http }: BaseClient, p: RequestData<void, CreateCalendarViewModel>): Promise<AxiosResponse<string, any>> {
+    return await http.post("/admin/calendar", p.body);
+  }
+  static async updateCalendarEntry({ http }: BaseClient, p: RequestData<{ id: string }, UpdateCalendarViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/calendar/${p.params.id}`, p.body);
+  }
+  static async deleteCalendarEntry({ http }: BaseClient, p: RequestData<{ id: string }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/calendar/${p.params.id}`);
+  }
+
+  static async getCalendarTypes({ http }: BaseClient): Promise<AxiosResponse<CalendarTypeViewModel[], any>> {
+    return await http.get("/admin/calendartype");
+  }
+  static async getCalendarTypeById({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<CalendarTypeViewModel, any>> {
+    return await http.get(`/admin/calendartype/${p.params.id}`);
+  }
+  static async createCalendarType({ http }: BaseClient, p: RequestData<void, CreateCalendarTypeViewModel>): Promise<AxiosResponse<string, any>> {
+    return await http.post("/admin/calendartype", p.body);
+  }
+  static async updateCalendarType(
+    { http }: BaseClient,
+    p: RequestData<{ id: number }, UpdateCalendarTypeViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/calendartype/${p.params.id}`, p.body);
+  }
+  static async deleteCalendarType({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/calendartype/${p.params.id}`);
+  }
+}

src/requests/admin/memberDataRequests.ts

@@ -0,0 +1,190 @@
+import { AxiosResponse } from "axios";
+import { RequestDefinition, RequestData, ImplementsRequestInterface } from "../requestBase";
+import {
+  AwardViewModel,
+  CreateAwardViewModel,
+  UpdateAwardViewModel,
+  CommunicationTypeViewModel,
+  CreateCommunicationTypeViewModel,
+  UpdateCommunicationTypeViewModel,
+  ExecutivePositionViewModel,
+  CreateExecutivePositionViewModel,
+  UpdateExecutivePositionViewModel,
+  MembershipStatusViewModel,
+  CreateMembershipStatusViewModel,
+  UpdateMembershipStatusViewModel,
+  QualificationViewModel,
+  CreateQualificationViewModel,
+  UpdateQualificationViewModel,
+  SalutationViewModel,
+  CreateSalutationViewModel,
+  UpdateSalutationViewModel,
+} from "../../viewmodels/admin/memberData.models";
+import { BaseClient } from "../../clients/clientBase";
+
+interface IMemberDataRequests {
+  getAwards: RequestDefinition<void, void, AwardViewModel[]>;
+  getAwardById: RequestDefinition<{ id: number }, void, AwardViewModel>;
+  createAward: RequestDefinition<void, CreateAwardViewModel, void>;
+  updateAward: RequestDefinition<{ id: number }, UpdateAwardViewModel, void>;
+  deleteAward: RequestDefinition<{ id: number }, void, void>;
+
+  getCommunicationTypes: RequestDefinition<void, void, CommunicationTypeViewModel[]>;
+  getCommunicationTypeById: RequestDefinition<{ id: number }, void, CommunicationTypeViewModel>;
+  createCommunicationType: RequestDefinition<void, CreateCommunicationTypeViewModel, void>;
+  updateCommunicationType: RequestDefinition<{ id: number }, UpdateCommunicationTypeViewModel, void>;
+  deleteCommunicationType: RequestDefinition<{ id: number }, void, void>;
+
+  getExecutivePositions: RequestDefinition<void, void, ExecutivePositionViewModel[]>;
+  getXxecutivePositionsById: RequestDefinition<{ id: number }, void, ExecutivePositionViewModel>;
+  createExecutivePositions: RequestDefinition<void, CreateExecutivePositionViewModel, void>;
+  updateExecutivePositions: RequestDefinition<{ id: number }, UpdateExecutivePositionViewModel, void>;
+  deleteExecutivePositions: RequestDefinition<{ id: number }, void, void>;
+
+  getMembershipStatus: RequestDefinition<void, void, MembershipStatusViewModel[]>;
+  getMembershipStatusById: RequestDefinition<{ id: number }, void, MembershipStatusViewModel>;
+  createMembershipStatus: RequestDefinition<void, CreateMembershipStatusViewModel, void>;
+  updateMembershipStatus: RequestDefinition<{ id: number }, UpdateMembershipStatusViewModel, void>;
+  deleteMembershipStatus: RequestDefinition<{ id: number }, void, void>;
+
+  getQualifications: RequestDefinition<void, void, QualificationViewModel[]>;
+  getQualificationById: RequestDefinition<{ id: number }, void, QualificationViewModel>;
+  createQualification: RequestDefinition<void, CreateQualificationViewModel, void>;
+  updateQualification: RequestDefinition<{ id: number }, UpdateQualificationViewModel, void>;
+  deleteQualification: RequestDefinition<{ id: number }, void, void>;
+
+  getSalutations: RequestDefinition<void, void, SalutationViewModel[]>;
+  getSalutationById: RequestDefinition<{ id: number }, void, SalutationViewModel>;
+  createSalutation: RequestDefinition<void, CreateSalutationViewModel, void>;
+  updateSalutation: RequestDefinition<{ id: number }, UpdateSalutationViewModel, void>;
+  deleteSalutation: RequestDefinition<{ id: number }, void, void>;
+}
+
+@ImplementsRequestInterface<IMemberDataRequests>()
+export default abstract class MemberDataRequests {
+  static async getAwards({ http }: BaseClient): Promise<AxiosResponse<AwardViewModel[], any>> {
+    return await http.get("/admin/award");
+  }
+  static async getAwardById({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<AwardViewModel, any>> {
+    return await http.get(`/admin/award/${p.params.id}`);
+  }
+  static async createAward({ http }: BaseClient, p: RequestData<void, CreateAwardViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post("/admin/award", p.body);
+  }
+  static async updateAward({ http }: BaseClient, p: RequestData<{ id: number }, UpdateAwardViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/award/${p.params.id}`, p.body);
+  }
+  static async deleteAward({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/award/${p.params.id}`);
+  }
+
+  static async getCommunicationTypes({ http }: BaseClient): Promise<AxiosResponse<CommunicationTypeViewModel[], any>> {
+    return await http.get("/admin/communicationtype");
+  }
+  static async getCommunicationTypeById(
+    { http }: BaseClient,
+    p: RequestData<{ id: number }, void>
+  ): Promise<AxiosResponse<CommunicationTypeViewModel, any>> {
+    return await http.get(`/admin/communicationtype/${p.params.id}`);
+  }
+  static async createCommunicationType(
+    { http }: BaseClient,
+    p: RequestData<void, CreateCommunicationTypeViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post("/admin/communicationtype", p.body);
+  }
+  static async updateCommunicationType(
+    { http }: BaseClient,
+    p: RequestData<{ id: number }, UpdateCommunicationTypeViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/communicationtype/${p.params.id}`, p.body);
+  }
+  static async deleteCommunicationType({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/communicationtype/${p.params.id}`);
+  }
+
+  static async getExecutivePositions({ http }: BaseClient): Promise<AxiosResponse<ExecutivePositionViewModel[], any>> {
+    return await http.get("/admin/executiveposition");
+  }
+  static async getXxecutivePositionsById(
+    { http }: BaseClient,
+    p: RequestData<{ id: number }, void>
+  ): Promise<AxiosResponse<ExecutivePositionViewModel, any>> {
+    return await http.get(`/admin/executiveposition/${p.params.id}`);
+  }
+  static async createExecutivePositions(
+    { http }: BaseClient,
+    p: RequestData<void, CreateExecutivePositionViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post("/admin/executiveposition", p.body);
+  }
+  static async updateExecutivePositions(
+    { http }: BaseClient,
+    p: RequestData<{ id: number }, UpdateExecutivePositionViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/executiveposition/${p.params.id}`, p.body);
+  }
+  static async deleteExecutivePositions({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/executiveposition/${p.params.id}`);
+  }
+
+  static async getMembershipStatus({ http }: BaseClient): Promise<AxiosResponse<MembershipStatusViewModel[], any>> {
+    return await http.get("/admin/membershipstatus");
+  }
+  static async getMembershipStatusById(
+    { http }: BaseClient,
+    p: RequestData<{ id: number }, void>
+  ): Promise<AxiosResponse<MembershipStatusViewModel, any>> {
+    return await http.get(`/admin/membershipstatus/${p.params.id}`);
+  }
+  static async createMembershipStatus(
+    { http }: BaseClient,
+    p: RequestData<void, CreateMembershipStatusViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post("/admin/membershipstatus", p.body);
+  }
+  static async updateMembershipStatus(
+    { http }: BaseClient,
+    p: RequestData<{ id: number }, UpdateMembershipStatusViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/membershipstatus/${p.params.id}`, p.body);
+  }
+  static async deleteMembershipStatus({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/membershipstatus/${p.params.id}`);
+  }
+
+  static async getQualifications({ http }: BaseClient): Promise<AxiosResponse<QualificationViewModel[], any>> {
+    return await http.get("/admin/qualification");
+  }
+  static async getQualificationById({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<QualificationViewModel, any>> {
+    return await http.get(`/admin/qualification/${p.params.id}`);
+  }
+  static async createQualification({ http }: BaseClient, p: RequestData<void, CreateQualificationViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post("/admin/qualification", p.body);
+  }
+  static async updateQualification(
+    { http }: BaseClient,
+    p: RequestData<{ id: number }, UpdateQualificationViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/qualification/${p.params.id}`, p.body);
+  }
+  static async deleteQualification({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/qualification/${p.params.id}`);
+  }
+
+  static async getSalutations({ http }: BaseClient): Promise<AxiosResponse<SalutationViewModel[], any>> {
+    return await http.get("/admin/salutation");
+  }
+  static async getSalutationById({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<SalutationViewModel, any>> {
+    return await http.get(`/admin/salutation/${p.params.id}`);
+  }
+  static async createSalutation({ http }: BaseClient, p: RequestData<void, CreateSalutationViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post("/admin/salutation", p.body);
+  }
+  static async updateSalutation({ http }: BaseClient, p: RequestData<{ id: number }, UpdateSalutationViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/salutation/${p.params.id}`, p.body);
+  }
+  static async deleteSalutation({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/salutation/${p.params.id}`);
+  }
+}

src/requests/admin/memberRequests.ts

@@ -0,0 +1,243 @@
+import { AxiosResponse } from "axios";
+import { RequestDefinition, RequestData, ImplementsRequestInterface } from "../requestBase";
+import {
+  MemberViewModel,
+  MemberStatisticsViewModel,
+  CreateMemberViewModel,
+  UpdateMemberViewModel,
+  MembershipViewModel,
+  MembershipStatisticsViewModel,
+  CreateMembershipViewModel,
+  UpdateMembershipViewModel,
+  MemberAwardViewModel,
+  MemberQualificationViewModel,
+  MemberExecutivePositionViewModel,
+  CommunicationViewModel,
+} from "../../viewmodels/admin/member.models";
+import { BaseClient } from "../../clients/clientBase";
+
+interface IMemberRequests {
+  getAllMembers: RequestDefinition<void, void, MemberViewModel[]>;
+  getMemberById: RequestDefinition<{ id: string }, void, MemberViewModel>;
+  getMemberStatisticsById: RequestDefinition<{ id: string }, void, MemberStatisticsViewModel>;
+  createMember: RequestDefinition<void, CreateMemberViewModel, string>;
+  updateMember: RequestDefinition<{ id: string }, UpdateMemberViewModel, void>;
+  deleteMember: RequestDefinition<{ id: string }, void, void>;
+
+  getMembershipsByMember: RequestDefinition<{ memberId: string }, void, MembershipViewModel[]>;
+  getMembershipStatisticsByMember: RequestDefinition<{ memberId: string }, void, MembershipStatisticsViewModel>;
+  getMembershipByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, MembershipViewModel>;
+  addMembershipByMember: RequestDefinition<{ memberId: string }, CreateMembershipViewModel, void>;
+  updateMembershipByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, UpdateMembershipViewModel, void>;
+  deleteMembershipByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, void>;
+
+  getAwardsByMember: RequestDefinition<{ memberId: string }, void, MemberAwardViewModel[]>;
+  getAwardByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, MemberAwardViewModel>;
+  addAwardByMember: RequestDefinition<{ memberId: string }, CreateMembershipViewModel, void>;
+  updateAwardByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, UpdateMembershipViewModel, void>;
+  deleteAwardByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, void>;
+
+  getQualificationsByMember: RequestDefinition<{ memberId: string }, void, MemberQualificationViewModel[]>;
+  getQualificationByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, MemberQualificationViewModel>;
+  addQualificationByMember: RequestDefinition<{ memberId: string }, CreateMembershipViewModel, void>;
+  updateQualificationByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, UpdateMembershipViewModel, void>;
+  deleteQualificationByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, void>;
+
+  getPositionsByMember: RequestDefinition<{ memberId: string }, void, MemberExecutivePositionViewModel[]>;
+  getPositionByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, MemberExecutivePositionViewModel>;
+  addPositionByMember: RequestDefinition<{ memberId: string }, CreateMembershipViewModel, void>;
+  updatePositionByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, UpdateMembershipViewModel, void>;
+  deletePositionByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, void>;
+
+  getCommunicationsByMember: RequestDefinition<{ memberId: string }, void, CommunicationViewModel[]>;
+  getCommunicationByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, CommunicationViewModel>;
+  addCommunicationsByMember: RequestDefinition<{ memberId: string }, CreateMembershipViewModel, void>;
+  updateCommunicationsByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, UpdateMembershipViewModel, void>;
+  deleteCommunicationsByMemberAndId: RequestDefinition<{ memberId: string; recordId: number }, void, void>;
+}
+
+@ImplementsRequestInterface<IMemberRequests>()
+export default abstract class MemberRequests {
+  static async getAllMembers({ http }: BaseClient): Promise<AxiosResponse<MemberViewModel[], any>> {
+    return await http.get("/admin/member");
+  }
+  static async getMemberById({ http }: BaseClient, p: RequestData<{ id: string }, void>): Promise<AxiosResponse<MemberViewModel, any>> {
+    return await http.get(`/admin/member/${p.params.id}`);
+  }
+  static async getMemberStatisticsById(
+    { http }: BaseClient,
+    p: RequestData<{ id: string }, void>
+  ): Promise<AxiosResponse<MemberStatisticsViewModel, any>> {
+    return await http.get(`/admin/member/${p.params.id}/statistics`);
+  }
+  static async createMember({ http }: BaseClient, p: RequestData<void, CreateMemberViewModel>): Promise<AxiosResponse<string, any>> {
+    return await http.post("/admin/member", p.body);
+  }
+  static async updateMember({ http }: BaseClient, p: RequestData<{ id: string }, UpdateMemberViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/member/${p.params.id}`, p.body);
+  }
+  static async deleteMember({ http }: BaseClient, p: RequestData<{ id: string }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/member/${p.params.id}`);
+  }
+
+  static async getMembershipsByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, void>
+  ): Promise<AxiosResponse<MembershipViewModel[], any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/memberships`);
+  }
+  static async getMembershipStatisticsByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, void>
+  ): Promise<AxiosResponse<MembershipStatisticsViewModel, any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/memberships/statistics`);
+  }
+  static async getMembershipByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<MembershipViewModel, any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/membership/${p.params.recordId}`);
+  }
+  static async addMembershipByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, CreateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/member/${p.params.memberId}/membership`, p.body);
+  }
+  static async updateMembershipByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, UpdateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.put(`/admin/member/${p.params.memberId}/memberships/${p.params.recordId}`, p.body);
+  }
+  static async deleteMembershipByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.delete(`/admin/member/${p.params.memberId}/memberships/${p.params.recordId}`);
+  }
+
+  static async getAwardsByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, void>
+  ): Promise<AxiosResponse<MemberAwardViewModel[], any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/awards`);
+  }
+  static async getAwardByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<MemberAwardViewModel, any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/award/${p.params.recordId}`);
+  }
+  static async addAwardByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, CreateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/member/${p.params.memberId}/award`, p.body);
+  }
+  static async updateAwardByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, UpdateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.put(`/admin/member/${p.params.memberId}/award/${p.params.recordId}`, p.body);
+  }
+  static async deleteAwardByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.delete(`/admin/member/${p.params.memberId}/award/${p.params.recordId}`);
+  }
+
+  static async getQualificationsByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, void>
+  ): Promise<AxiosResponse<MemberQualificationViewModel[], any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/qualifications`);
+  }
+  static async getQualificationByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<MemberQualificationViewModel, any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/qualification/${p.params.recordId}`);
+  }
+  static async addQualificationByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, CreateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/member/${p.params.memberId}/qualification`, p.body);
+  }
+  static async updateQualificationByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, UpdateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.put(`/admin/member/${p.params.memberId}/qualification/${p.params.recordId}`, p.body);
+  }
+  static async deleteQualificationByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.delete(`/admin/member/${p.params.memberId}/qualification/${p.params.recordId}`);
+  }
+
+  static async getPositionsByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, void>
+  ): Promise<AxiosResponse<MemberExecutivePositionViewModel[], any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/positions`);
+  }
+  static async getPositionByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<MemberExecutivePositionViewModel, any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/position/${p.params.recordId}`);
+  }
+  static async addPositionByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, CreateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/member/${p.params.memberId}/position`, p.body);
+  }
+  static async updatePositionByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, UpdateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.put(`/admin/member/${p.params.memberId}/position/${p.params.recordId}`, p.body);
+  }
+  static async deletePositionByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.delete(`/admin/member/${p.params.memberId}/position/${p.params.recordId}`);
+  }
+
+  static async getCommunicationsByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, void>
+  ): Promise<AxiosResponse<CommunicationViewModel[], any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/communications`);
+  }
+  static async getCommunicationByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<CommunicationViewModel, any>> {
+    return await http.get(`/admin/member/${p.params.memberId}/communication/${p.params.recordId}`);
+  }
+  static async addCommunicationsByMember(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string }, CreateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/member/${p.params.memberId}/communication`, p.body);
+  }
+  static async updateCommunicationsByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, UpdateMembershipViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.put(`/admin/member/${p.params.memberId}/communication/${p.params.recordId}`, p.body);
+  }
+  static async deleteCommunicationsByMemberAndId(
+    { http }: BaseClient,
+    p: RequestData<{ memberId: string; recordId: number }, void>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.delete(`/admin/member/${p.params.memberId}/communication/${p.params.recordId}`);
+  }
+}

src/requests/admin/newsletterRequests.ts

@@ -0,0 +1,109 @@
+import { AxiosResponse } from "axios";
+import { RequestDefinition, RequestData, ImplementsRequestInterface } from "../requestBase";
+import {
+  NewsletterViewModel,
+  CreateNewsletterViewModel,
+  SyncNewsletterViewModel,
+  NewsletterConfigViewModel,
+  NewsletterDatesViewModel,
+  NewsletterRecipientsViewModel,
+  SetNewsletterConfigViewModel,
+  SyncNewsletterDatesViewModel,
+  SyncNewsletterRecipientsViewModel,
+} from "../../viewmodels/admin/newsletter.models";
+import { BaseClient } from "../../clients/clientBase";
+
+interface INewsletterRequests {
+  getNewsletters: RequestDefinition<void, void, NewsletterViewModel[]>;
+  getNewsletterById: RequestDefinition<{ id: number }, void, NewsletterViewModel>;
+  getNewsletterDatesByNewsletter: RequestDefinition<{ newsletterId: number }, void, NewsletterDatesViewModel>;
+  getNewsletterRecipientsByNewsletter: RequestDefinition<{ newsletterId: number }, void, NewsletterRecipientsViewModel>;
+  getNewsletterPrintoutsByNewsletter: RequestDefinition<{ newsletterId: number }, void, Array<string>>;
+  getNewsletterPrintoutsByNewsletterAndId: RequestDefinition<{ newsletterId: number; filename: number }, void, File>;
+  createNewsletter: RequestDefinition<void, CreateNewsletterViewModel, number>;
+  syncNewsletter: RequestDefinition<{ id: number }, SyncNewsletterViewModel, void>;
+  syncNewsletterDatesByNewsletter: RequestDefinition<{ newsletterId: number }, SyncNewsletterDatesViewModel, void>;
+  syncNewsletterRecipientsByNewsletter: RequestDefinition<{ newsletterId: number }, SyncNewsletterRecipientsViewModel, void>;
+
+  getNewsletterConfigs: RequestDefinition<void, void, NewsletterConfigViewModel[]>;
+  getNewsletterConfigById: RequestDefinition<{ communicationTypeId: number }, void, NewsletterConfigViewModel>;
+  updateNewsletterConfig: RequestDefinition<void, SetNewsletterConfigViewModel, NewsletterViewModel>;
+  resetNewsletterConfig: RequestDefinition<{ communicationTypeId: number }, void, NewsletterViewModel>;
+}
+
+@ImplementsRequestInterface<INewsletterRequests>()
+export default abstract class NewsletterRequests {
+  static async getNewsletters({ http }: BaseClient): Promise<AxiosResponse<NewsletterViewModel[], any>> {
+    return await http.get("/admin/newsletter");
+  }
+  static async getNewsletterById({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<NewsletterViewModel, any>> {
+    return await http.get(`/admin/newsletter/${p.params.id}`);
+  }
+  static async getNewsletterDatesByNewsletter(
+    { http }: BaseClient,
+    p: RequestData<{ newsletterId: number }, void>
+  ): Promise<AxiosResponse<NewsletterDatesViewModel, any>> {
+    return await http.get(`/admin/newsletter/${p.params.newsletterId}/dates`);
+  }
+  static async getNewsletterRecipientsByNewsletter(
+    { http }: BaseClient,
+    p: RequestData<{ newsletterId: number }, void>
+  ): Promise<AxiosResponse<NewsletterRecipientsViewModel, any>> {
+    return await http.get(`/admin/newsletter/${p.params.newsletterId}/recipients`);
+  }
+  static async getNewsletterPrintoutsByNewsletter(
+    { http }: BaseClient,
+    p: RequestData<{ newsletterId: number }, void>
+  ): Promise<AxiosResponse<Array<string>, any>> {
+    return await http.get(`/admin/newsletter/${p.params.newsletterId}/printouts`);
+  }
+  static async getNewsletterPrintoutsByNewsletterAndId(
+    { http }: BaseClient,
+    p: RequestData<{ newsletterId: number; filename: number }, void>
+  ): Promise<AxiosResponse<File, any>> {
+    return await http.get(`/admin/newsletter/${p.params.newsletterId}/printouts/${p.params.filename}`);
+  }
+  static async createNewsletter({ http }: BaseClient, p: RequestData<void, CreateNewsletterViewModel>): Promise<AxiosResponse<number, any>> {
+    return await http.post("/admin/newsletter", p.body);
+  }
+  static async updateNewsletter({ http }: BaseClient, p: RequestData<{ id: number }, SyncNewsletterViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/newsletter/${p.params.id}`, p.body);
+  }
+  static async syncNewsletter({ http }: BaseClient, p: RequestData<{ id: number }, SyncNewsletterViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/newsletter/${p.params.id}/synchronize`, p.body);
+  }
+  static async syncNewsletterDatesByNewsletter(
+    { http }: BaseClient,
+    p: RequestData<{ newsletterId: number }, SyncNewsletterDatesViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/newsletter/${p.params.newsletterId}/synchronize/dates`, p.body);
+  }
+  static async syncNewsletterRecipientsByNewsletter(
+    { http }: BaseClient,
+    p: RequestData<{ newsletterId: number }, SyncNewsletterRecipientsViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/newsletter/${p.params.newsletterId}/synchronize/recipients`, p.body);
+  }
+
+  static async getNewsletterConfigs({ http }: BaseClient): Promise<AxiosResponse<NewsletterConfigViewModel[], any>> {
+    return await http.get("/admin/newsletterconfig");
+  }
+  static async getNewsletterConfigById(
+    { http }: BaseClient,
+    p: RequestData<{ communicationTypeId: number }, void>
+  ): Promise<AxiosResponse<NewsletterConfigViewModel, any>> {
+    return await http.get(`/admin/newsletterconfig/${p.params.communicationTypeId}`);
+  }
+  static async updateNewsletterConfig(
+    { http }: BaseClient,
+    p: RequestData<void, SetNewsletterConfigViewModel>
+  ): Promise<AxiosResponse<NewsletterViewModel, any>> {
+    return await http.put("/admin/newsletterconfig", p.body);
+  }
+  static async resetNewsletterConfig(
+    { http }: BaseClient,
+    p: RequestData<{ communicationTypeId: number }, void>
+  ): Promise<AxiosResponse<NewsletterViewModel, any>> {
+    return await http.delete(`/admin/newsletterconfig/${p.params.communicationTypeId}`);
+  }
+}

src/requests/admin/protocolRequests.ts

@@ -0,0 +1,114 @@
+import { AxiosResponse } from "axios";
+import { RequestDefinition, RequestData, ImplementsRequestInterface } from "../requestBase";
+import {
+  ProtocolViewModel,
+  CreateProtocolViewModel,
+  SyncProtocolViewModel,
+  ProtocolAgendaViewModel,
+  ProtocolDecisionViewModel,
+  ProtocolPresenceViewModel,
+  ProtocolVotingViewModel,
+  SyncProtocolAgendaViewModel,
+  SyncProtocolDecisionViewModel,
+  SyncProtocolPresenceViewModel,
+  SyncProtocolVotingViewModel,
+} from "../../viewmodels/admin/protocol.models";
+import { BaseClient } from "../../clients/clientBase";
+
+interface IProtocolRequests {
+  getProtocols: RequestDefinition<void, void, ProtocolViewModel[]>;
+  getProtocolById: RequestDefinition<{ id: number }, void, ProtocolViewModel>;
+  getProtocolAgendaByProtocol: RequestDefinition<{ protocolId: number }, void, ProtocolAgendaViewModel>;
+  getProtocolDecisionsByProtocol: RequestDefinition<{ protocolId: number }, void, ProtocolDecisionViewModel>;
+  getProtocolPresenceByProtocol: RequestDefinition<{ protocolId: number }, void, ProtocolPresenceViewModel>;
+  getProtocolVotingsByProtocol: RequestDefinition<{ protocolId: number }, void, ProtocolVotingViewModel>;
+  createProtocol: RequestDefinition<void, CreateProtocolViewModel, number>;
+  createProtocolAgenda: RequestDefinition<{ protocolId: number }, void, number>;
+  createProtocolDescision: RequestDefinition<{ protocolId: number }, void, number>;
+  createProtocolPresence: RequestDefinition<{ protocolId: number }, void, number>;
+  createProtocolVoting: RequestDefinition<{ protocolId: number }, void, number>;
+  syncProtocol: RequestDefinition<{ id: number }, SyncProtocolViewModel, void>;
+  syncProtocolAgendaByProtocol: RequestDefinition<{ protocolId: number }, SyncProtocolAgendaViewModel, void>;
+  syncProtocolDecisionsByProtocol: RequestDefinition<{ protocolId: number }, SyncProtocolDecisionViewModel, void>;
+  syncProtocolPresenceByProtocol: RequestDefinition<{ protocolId: number }, SyncProtocolPresenceViewModel, void>;
+  syncProtocolVotingsByProtocol: RequestDefinition<{ protocolId: number }, SyncProtocolVotingViewModel, void>;
+}
+
+@ImplementsRequestInterface<IProtocolRequests>()
+export default abstract class ProtocolRequests {
+  static async getProtocols({ http }: BaseClient): Promise<AxiosResponse<ProtocolViewModel[], any>> {
+    return await http.get("/admin/protocol");
+  }
+  static async getProtocolById({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<ProtocolViewModel, any>> {
+    return await http.get(`/admin/protocol/${p.params.id}`);
+  }
+  static async getProtocolAgendaByProtocol(
+    { http }: BaseClient,
+    p: RequestData<{ protocolId: number }, void>
+  ): Promise<AxiosResponse<ProtocolAgendaViewModel, any>> {
+    return await http.get(`/admin/protocol/${p.params.protocolId}/agenda`);
+  }
+  static async getProtocolDecisionsByProtocol(
+    { http }: BaseClient,
+    p: RequestData<{ protocolId: number }, void>
+  ): Promise<AxiosResponse<ProtocolDecisionViewModel, any>> {
+    return await http.get(`/admin/protocol/${p.params.protocolId}/decisions`);
+  }
+  static async getProtocolPresenceByProtocol(
+    { http }: BaseClient,
+    p: RequestData<{ protocolId: number }, void>
+  ): Promise<AxiosResponse<ProtocolPresenceViewModel, any>> {
+    return await http.get(`/admin/protocol/${p.params.protocolId}/presence`);
+  }
+  static async getProtocolVotingsByProtocol(
+    { http }: BaseClient,
+    p: RequestData<{ protocolId: number }, void>
+  ): Promise<AxiosResponse<ProtocolVotingViewModel, any>> {
+    return await http.get(`/admin/protocol/${p.params.protocolId}/votings`);
+  }
+  static async createProtocol({ http }: BaseClient, p: RequestData<void, CreateProtocolViewModel>): Promise<AxiosResponse<number, any>> {
+    return await http.post(`/admin/protocol`, p.body);
+  }
+  static async createProtocolAgenda({ http }: BaseClient, p: RequestData<{ protocolId: number }, void>): Promise<AxiosResponse<number, any>> {
+    return await http.post(`/admin/protocol/${p.params.protocolId}/agenda`);
+  }
+  static async createProtocolDescision({ http }: BaseClient, p: RequestData<{ protocolId: number }, void>): Promise<AxiosResponse<number, any>> {
+    return await http.post(`/admin/protocol/${p.params.protocolId}/decision`);
+  }
+  static async createProtocolPresence({ http }: BaseClient, p: RequestData<{ protocolId: number }, void>): Promise<AxiosResponse<number, any>> {
+    return await http.post(`/admin/protocol/${p.params.protocolId}/presence`);
+  }
+  static async createProtocolVoting({ http }: BaseClient, p: RequestData<{ protocolId: number }, void>): Promise<AxiosResponse<number, any>> {
+    return await http.post(`/admin/protocol/${p.params.protocolId}/voting`);
+  }
+  static async updateProtocol({ http }: BaseClient, p: RequestData<{ id: number }, SyncProtocolViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/protocol/${p.params.id}`, p.body);
+  }
+  static async syncProtocol({ http }: BaseClient, p: RequestData<{ id: number }, SyncProtocolViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/protocol/${p.params.id}/synchronize`, p.body);
+  }
+  static async syncProtocolAgendaByProtocol(
+    { http }: BaseClient,
+    p: RequestData<{ protocolId: number }, SyncProtocolAgendaViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/protocol/${p.params.protocolId}/synchronize/agenda`, p.body);
+  }
+  static async syncProtocolDecisionsByProtocol(
+    { http }: BaseClient,
+    p: RequestData<{ protocolId: number }, SyncProtocolDecisionViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/protocol/${p.params.protocolId}/synchronize/decisions`, p.body);
+  }
+  static async syncProtocolPresenceByProtocol(
+    { http }: BaseClient,
+    p: RequestData<{ protocolId: number }, SyncProtocolPresenceViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/protocol/${p.params.protocolId}/synchronize/presence`, p.body);
+  }
+  static async syncProtocolVotingsByProtocol(
+    { http }: BaseClient,
+    p: RequestData<{ protocolId: number }, SyncProtocolVotingViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/protocol/${p.params.protocolId}/synchronize/votings`, p.body);
+  }
+}

src/requests/admin/queryRequests.ts

@@ -0,0 +1,41 @@
+import { AxiosResponse } from "axios";
+import { RequestDefinition, RequestData, ImplementsRequestInterface } from "../requestBase";
+import { CreateQueryViewModel, QueryExecuteResult, QueryViewModel, UpdateQueryViewModel } from "../../viewmodels/admin/query.models";
+import { DynamicQueryStructure } from "../../types/admin/dynamicQueries";
+import { BaseClient } from "../../clients/clientBase";
+
+interface IQueryRequests {
+  getQueries: RequestDefinition<void, void, QueryViewModel[]>;
+  getQueryById: RequestDefinition<{ id: number }, void, QueryViewModel>;
+  createQuery: RequestDefinition<void, CreateQueryViewModel, number>;
+  updateQuery: RequestDefinition<{ id: number }, UpdateQueryViewModel, void>;
+  deleteQuery: RequestDefinition<{ id: number }, void, void>;
+
+  executeQuery: RequestDefinition<void, DynamicQueryStructure | string, QueryExecuteResult>;
+}
+
+@ImplementsRequestInterface<IQueryRequests>()
+export default abstract class QueryDataRequests {
+  static async getQueries({ http }: BaseClient): Promise<AxiosResponse<QueryViewModel[], any>> {
+    return await http.get("/admin/award");
+  }
+  static async getQueryById({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<QueryViewModel, any>> {
+    return await http.get(`/admin/award/${p.params.id}`);
+  }
+  static async createQuery({ http }: BaseClient, p: RequestData<void, CreateQueryViewModel>): Promise<AxiosResponse<number, any>> {
+    return await http.post("/admin/award", p.body);
+  }
+  static async updateQuery({ http }: BaseClient, p: RequestData<{ id: number }, UpdateQueryViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/award/${p.params.id}`, p.body);
+  }
+  static async deleteQuery({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/award/${p.params.id}`);
+  }
+
+  static async executeQuery(
+    { http }: BaseClient,
+    p: RequestData<void, DynamicQueryStructure | string>
+  ): Promise<AxiosResponse<QueryExecuteResult, any>> {
+    return await http.post(`/admin/query`, p.body);
+  }
+}

src/requests/admin/roleRequests.ts

@@ -0,0 +1,39 @@
+import { AxiosResponse } from "axios";
+import { RequestDefinition, RequestData, ImplementsRequestInterface } from "../requestBase";
+import { PermissionObject, PermissionString } from "../../types/admin/permissionTypes";
+import { RoleViewModel, UpdateRolePermissionViewModel, UpdateRoleViewModel } from "../../viewmodels/admin/role.models";
+import { BaseClient } from "../../clients/clientBase";
+
+interface IRoleRequests {
+  getRoles: RequestDefinition<void, void, RoleViewModel[]>;
+  getRoleById: RequestDefinition<{ id: number }, void, RoleViewModel>;
+  getRolePermissionsById: RequestDefinition<{ roleId: number }, void, PermissionObject>;
+  updateRole: RequestDefinition<{ id: number }, UpdateRoleViewModel, void>;
+  updateRolePermissions: RequestDefinition<{ roleId: number }, UpdateRolePermissionViewModel, void>;
+  deleteRole: RequestDefinition<{ id: number }, void, void>;
+}
+
+@ImplementsRequestInterface<IRoleRequests>()
+export default abstract class RoleRequests {
+  static async getRoles({ http }: BaseClient): Promise<AxiosResponse<RoleViewModel[], any>> {
+    return await http.get("/admin/role");
+  }
+  static async getRoleById({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<RoleViewModel, any>> {
+    return await http.get(`/admin/role/${p.params.id}`);
+  }
+  static async getRolePermissionsById({ http }: BaseClient, p: RequestData<{ roleId: number }, void>): Promise<AxiosResponse<PermissionObject, any>> {
+    return await http.get(`/admin/role/${p.params.roleId}/permissions`);
+  }
+  static async updateRole({ http }: BaseClient, p: RequestData<{ id: number }, UpdateRoleViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/role/${p.params.id}`, p.body);
+  }
+  static async updateRolePermissions(
+    { http }: BaseClient,
+    p: RequestData<{ roleId: number }, UpdateRolePermissionViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/role/${p.params.roleId}/permissions`, p.body);
+  }
+  static async deleteRole({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/role/${p.params.id}`);
+  }
+}

src/requests/admin/templateRequests.ts

@@ -0,0 +1,50 @@
+import { AxiosResponse } from "axios";
+import { RequestDefinition, RequestData, ImplementsRequestInterface } from "../requestBase";
+import { CloneTemplateViewModel, CreateTemplateViewModel, TemplateViewModel, UpdateTemplateViewModel } from "../../viewmodels/admin/template.models";
+import { TemplateUsageViewModel, UpdateTemplateUsageViewModel } from "../../viewmodels/admin/template.models";
+import { BaseClient } from "../../clients/clientBase";
+import { PermissionModule } from "../../types/admin/permissionTypes";
+
+interface ITemplateRequests {
+  getTemplates: RequestDefinition<void, void, TemplateViewModel[]>;
+  getTemplateById: RequestDefinition<{ id: number }, void, TemplateViewModel>;
+  createTemplate: RequestDefinition<void, CreateTemplateViewModel, number>;
+  cloneTemplate: RequestDefinition<void, CloneTemplateViewModel, number>;
+  updateTemplate: RequestDefinition<{ id: number }, UpdateTemplateViewModel, void>;
+  deleteTemplate: RequestDefinition<{ id: number }, void, void>;
+
+  getTemplateUsages: RequestDefinition<void, void, TemplateUsageViewModel[]>;
+  updateTemplateUsage: RequestDefinition<{ scope: `${PermissionModule}` | `${PermissionModule}.${string}` }, UpdateTemplateUsageViewModel, void>;
+}
+
+@ImplementsRequestInterface<ITemplateRequests>()
+export default abstract class TemplateRequests {
+  static async getTemplates({ http }: BaseClient): Promise<AxiosResponse<TemplateViewModel[], any>> {
+    return await http.get("/admin/template");
+  }
+  static async getTemplateById({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<TemplateViewModel, any>> {
+    return await http.get(`/admin/template/${p.params.id}`);
+  }
+  static async createTemplate({ http }: BaseClient, p: RequestData<void, CreateTemplateViewModel>): Promise<AxiosResponse<number, any>> {
+    return await http.post("/admin/template", p.body);
+  }
+  static async cloneTemplate({ http }: BaseClient, p: RequestData<void, CloneTemplateViewModel>): Promise<AxiosResponse<number, any>> {
+    return await http.post("/admin/template/clone", p.body);
+  }
+  static async updateTemplate({ http }: BaseClient, p: RequestData<{ id: number }, UpdateTemplateViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/template/${p.params.id}`, p.body);
+  }
+  static async deleteTemplate({ http }: BaseClient, p: RequestData<{ id: number }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/template/${p.params.id}`);
+  }
+
+  static async getTemplateUsages({ http }: BaseClient): Promise<AxiosResponse<TemplateUsageViewModel[], any>> {
+    return await http.get("/admin/templateusage");
+  }
+  static async updateTemplateUsage(
+    { http }: BaseClient,
+    p: RequestData<{ scope: `${PermissionModule}` | `${PermissionModule}.${string}` }, UpdateTemplateUsageViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/templateusage/${p.params.scope}`, p.body);
+  }
+}

src/requests/admin/userRequests.ts

@@ -0,0 +1,72 @@
+import { AxiosResponse } from "axios";
+import { RequestDefinition, RequestData, ImplementsRequestInterface } from "../requestBase";
+import {
+  UpdateUserViewModel,
+  UserViewModel,
+  CreateInviteViewModel,
+  InviteViewModel,
+  UpdateUserPermissionViewModel,
+  UpdateUserRolesViewModel,
+} from "../../viewmodels/admin/user.models";
+import { PermissionObject, PermissionString } from "../../types/admin/permissionTypes";
+import { RoleViewModel } from "../../viewmodels/admin/role.models";
+import { BaseClient } from "../../clients/clientBase";
+
+interface IUserRequests {
+  getUsers: RequestDefinition<void, void, UserViewModel[]>;
+  getUserById: RequestDefinition<{ id: string }, void, UserViewModel>;
+  getUserPermissionsById: RequestDefinition<{ userId: string }, void, PermissionObject>;
+  getUserRolesById: RequestDefinition<{ userId: string }, void, RoleViewModel[]>;
+  updateUser: RequestDefinition<{ id: string }, UpdateUserViewModel, void>;
+  updateUserPermissions: RequestDefinition<{ userId: string }, UpdateUserPermissionViewModel, void>;
+  updateUserRoles: RequestDefinition<{ userId: string }, UpdateUserRolesViewModel, void>;
+  deleteUser: RequestDefinition<{ id: string }, void, void>;
+
+  getInvites: RequestDefinition<void, void, InviteViewModel[]>;
+  createInvite: RequestDefinition<void, CreateInviteViewModel, void>;
+  deleteInvite: RequestDefinition<{ mail: string }, void, void>;
+}
+
+@ImplementsRequestInterface<IUserRequests>()
+export default abstract class UserRequests {
+  static async getUsers({ http }: BaseClient): Promise<AxiosResponse<UserViewModel[], any>> {
+    return await http.get("/admin/user");
+  }
+  static async getUserById({ http }: BaseClient, p: RequestData<{ id: string }, void>): Promise<AxiosResponse<UserViewModel, any>> {
+    return await http.get(`/admin/user/${p.params.id}`);
+  }
+  static async getUserPermissionsById({ http }: BaseClient, p: RequestData<{ userId: string }, void>): Promise<AxiosResponse<PermissionObject, any>> {
+    return await http.get(`/admin/user/${p.params.userId}/permissions`);
+  }
+  static async getUserRolesById({ http }: BaseClient, p: RequestData<{ userId: string }, void>): Promise<AxiosResponse<RoleViewModel[], any>> {
+    return await http.get(`/admin/user/${p.params.userId}/roles`);
+  }
+  static async updateUser({ http }: BaseClient, p: RequestData<{ id: string }, UpdateUserViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/user/${p.params.id}`, p.body);
+  }
+  static async updateUserPermissions(
+    { http }: BaseClient,
+    p: RequestData<{ userId: string }, UpdateUserPermissionViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/user/${p.params.userId}/permissions`, p.body);
+  }
+  static async updateUserRoles(
+    { http }: BaseClient,
+    p: RequestData<{ userId: string }, UpdateUserRolesViewModel>
+  ): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/user/${p.params.userId}/roles`, p.body);
+  }
+  static async deleteUser({ http }: BaseClient, p: RequestData<{ id: string }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.post(`/admin/user/${p.params.id}`);
+  }
+
+  static async getInvites({ http }: BaseClient): Promise<AxiosResponse<InviteViewModel[], any>> {
+    return await http.get("/admin/invite");
+  }
+  static async createInvite({ http }: BaseClient, p: RequestData<void, CreateInviteViewModel>): Promise<AxiosResponse<void, any>> {
+    return await http.post("/admin/invite", p.body);
+  }
+  static async deleteInvite({ http }: BaseClient, p: RequestData<{ mail: string }, void>): Promise<AxiosResponse<void, any>> {
+    return await http.delete(`/admin/invite/${p.params.mail}`);
+  }
+}

src/requests/requestBase.ts

@@ -1,4 +1,5 @@
 import { AxiosInstance, AxiosResponse } from "axios";
+import { BaseClient } from "../clients/clientBase";
 
 export type RequestData<PARAMS, BODY> = PARAMS extends void
   ? BODY extends void
@@ -9,6 +10,12 @@ export type RequestData<PARAMS, BODY> = PARAMS extends void
   : { params: PARAMS; body: BODY };
 
 export type RequestDefinition<PARAMS = void, BODY = void, RESPONSE = void> = (
-  http: AxiosInstance,
+  http: BaseClient,
   params: RequestData<PARAMS, BODY>
 ) => Promise<AxiosResponse<RESPONSE, any>>;
+
+export function ImplementsRequestInterface<T>() {
+  return <U extends T>(constructor: U) => {
+    constructor;
+  };
+}

src/requeststore/admin/club/memberRequests.ts

@@ -1,33 +0,0 @@
-import { AxiosInstance, AxiosResponse } from "axios";
-import {
-  MemberViewModel,
-  CreateMemberViewModel,
-  UpdateMemberViewModel,
-} from "../../../viewmodels/admin/club/member/member.models";
-import { RequestDefinition, RequestData } from "../../requeststore";
-
-abstract class IMemberRequests {
-  static getAllMembers: RequestDefinition<void, void, MemberViewModel[]>;
-  static getMemberById: RequestDefinition<{ id: number }, void, MemberViewModel>;
-  static createMember: RequestDefinition<void, CreateMemberViewModel, number>;
-  static updateMember: RequestDefinition<{ id: number }, UpdateMemberViewModel, void>;
-  static deleteMember: RequestDefinition<{ id: number }, void, void>;
-}
-
-export default abstract class MemberRequests extends IMemberRequests {
-  static async getAllMembers(http: AxiosInstance): Promise<AxiosResponse<MemberViewModel[], any>> {
-    return await http.get("/admin/member");
-  }
-  static async getMemberById(http: AxiosInstance, p: RequestData<{ id: number }, void>) {
-    return await http.get(`/admin/member/${p.params.id}`);
-  }
-  static async createMember(http: AxiosInstance, p: RequestData<void, CreateMemberViewModel>) {
-    return await http.post("/admin/member", p.body);
-  }
-  static async updateMember(http: AxiosInstance, p: RequestData<{ id: number }, UpdateMemberViewModel>) {
-    return await http.post(`/admin/member/${p.params.id}`, p.body);
-  }
-  static async deleteMember(http: AxiosInstance, p: RequestData<{ id: number }, void>) {
-    return await http.post(`/admin/member/${p.params.id}`);
-  }
-}

src/types/admin.ts

@@ -0,0 +1,4 @@
+export * as TableMeta from "./admin/tableMeta";
+export * as DynamicQueries from "./admin/dynamicQueries";
+export * as FieldTypes from "./admin/fieldTypes";
+export * as PermissionTypes from "./admin/permissionTypes";

src/viewmodels/admin.ts

@@ -0,0 +1,9 @@
+export * as MemberModels from "./admin/member.models";
+export * as MemberDataModels from "./admin/memberData.models";
+export * as CalendarModels from "./admin/calendar.models";
+export * as NewsletterModels from "./admin/newsletter.models";
+export * as ProtocolModels from "./admin/protocol.models";
+export * as QueryModels from "./admin/query.models";
+export * as TemplateModels from "./admin/template.models";
+export * as UserModels from "./admin/user.models";
+export * as RoleModels from "./admin/role.models";

src/viewmodels/admin/calendar.models.ts

@@ -1,5 +1,4 @@
-import type { CalendarTypeViewModel } from "../settings/calendarType.models";
+/** Calendar Models */
-
 export interface CalendarViewModel {
   id: string;
   starttime: string;
@@ -12,7 +11,6 @@ export interface CalendarViewModel {
   updatedAt: Date;
   type: CalendarTypeViewModel;
 }
-
 export interface CreateCalendarViewModel {
   starttime: string;
   endtime: string;
@@ -22,9 +20,7 @@ export interface CreateCalendarViewModel {
   allDay: boolean;
   typeId: string;
 }
-
 export interface UpdateCalendarViewModel {
-  id: string;
   starttime: string;
   endtime: string;
   title: string;
@@ -33,3 +29,24 @@ export interface UpdateCalendarViewModel {
   allDay: boolean;
   typeId: string;
 }
+
+/** Calendar Type Models */
+export interface CalendarTypeViewModel {
+  id: string;
+  type: string;
+  nscdr: boolean;
+  color: string;
+  passphrase: string | null;
+}
+export interface CreateCalendarTypeViewModel {
+  type: string;
+  nscdr: boolean;
+  color: string;
+  passphrase?: string;
+}
+export interface UpdateCalendarTypeViewModel {
+  type: string;
+  nscdr: boolean;
+  color: string;
+  passphrase?: string;
+}

src/viewmodels/admin/club/member/communication.models.ts

@@ -1,44 +0,0 @@
-import type { CommunicationTypeViewModel } from "../../settings/communicationType.models";
-
-export interface CommunicationViewModel {
-  id: number;
-  preferred: boolean;
-  mobile: string;
-  email: string;
-  postalCode: string;
-  city: string;
-  street: string;
-  streetNumber: number;
-  streetNumberAddition: string;
-  type: CommunicationTypeViewModel;
-  isNewsletterMain: boolean;
-  isSMSAlarming: boolean;
-}
-
-export interface CreateCommunicationViewModel {
-  preferred: boolean;
-  mobile: string;
-  email: string;
-  postalCode: string;
-  city: string;
-  street: string;
-  streetNumber: number;
-  streetNumberAddition: string;
-  typeId: number;
-  isNewsletterMain: boolean;
-  isSMSAlarming: boolean;
-}
-
-export interface UpdateCommunicationViewModel {
-  id: number;
-  preferred: boolean;
-  mobile: string;
-  email: string;
-  postalCode: string;
-  city: string;
-  street: string;
-  streetNumber: number;
-  streetNumberAddition: string;
-  isNewsletterMain: boolean;
-  isSMSAlarming: boolean;
-}

src/viewmodels/admin/club/member/member.models.ts

@@ -1,49 +0,0 @@
-import type { CommunicationViewModel } from "./communication.models";
-import type { MembershipViewModel } from "./membership.models";
-import type { SalutationViewModel } from "../../settings/salutation.models";
-
-export interface MemberViewModel {
-  id: number;
-  salutation: SalutationViewModel;
-  firstname: string;
-  lastname: string;
-  nameaffix: string;
-  birthdate: Date;
-  internalId?: string;
-  firstMembershipEntry?: MembershipViewModel;
-  lastMembershipEntry?: MembershipViewModel;
-  sendNewsletter?: CommunicationViewModel;
-  smsAlarming?: Array<CommunicationViewModel>;
-  preferredCommunication?: Array<CommunicationViewModel>;
-}
-
-export interface MemberStatisticsViewModel {
-  id: number;
-  salutation: string;
-  firstname: string;
-  lastname: string;
-  nameaffix: string;
-  birthdate: Date;
-  todayAge: number;
-  ageThisYear: number;
-  exactAge: string;
-}
-
-export interface CreateMemberViewModel {
-  salutationId: number;
-  firstname: string;
-  lastname: string;
-  nameaffix: string;
-  birthdate: Date;
-  internalId?: string;
-}
-
-export interface UpdateMemberViewModel {
-  id: number;
-  salutationId: number;
-  firstname: string;
-  lastname: string;
-  nameaffix: string;
-  birthdate: Date;
-  internalId?: string;
-}

src/viewmodels/admin/club/member/memberAward.models.ts

@@ -1,23 +0,0 @@
-export interface MemberAwardViewModel {
-  id: number;
-  given: boolean;
-  note?: string;
-  date: Date;
-  award: string;
-  awardId: number;
-}
-
-export interface CreateMemberAwardViewModel {
-  given: boolean;
-  note?: string;
-  date: Date;
-  awardId: number;
-}
-
-export interface UpdateMemberAwardViewModel {
-  id: number;
-  given: boolean;
-  note?: string;
-  date: Date;
-  awardId: number;
-}

src/viewmodels/admin/club/member/memberExecutivePosition.models.ts

@@ -1,23 +0,0 @@
-export interface MemberExecutivePositionViewModel {
-  id: number;
-  note?: string;
-  start: Date;
-  end?: Date;
-  executivePosition: string;
-  executivePositionId: number;
-}
-
-export interface CreateMemberExecutivePositionViewModel {
-  note?: string;
-  start: Date;
-  end?: Date;
-  executivePositionId: number;
-}
-
-export interface UpdateMemberExecutivePositionViewModel {
-  id: number;
-  note?: string;
-  start: Date;
-  end?: Date;
-  executivePositionId: number;
-}

src/viewmodels/admin/club/member/memberQualification.models.ts

@@ -1,24 +0,0 @@
-export interface MemberQualificationViewModel {
-  id: number;
-  note?: string;
-  start: Date;
-  end?: Date;
-  terminationReason?: string;
-  qualification: string;
-  qualificationId: number;
-}
-
-export interface CreateMemberQualificationViewModel {
-  note?: string;
-  start: Date;
-  qualificationId: number;
-}
-
-export interface UpdateMemberQualificationViewModel {
-  id: number;
-  note?: string;
-  start: Date;
-  end?: Date;
-  terminationReason?: string;
-  qualificationId: number;
-}

src/viewmodels/admin/club/member/membership.models.ts

@@ -1,34 +0,0 @@
-export interface MembershipViewModel {
-  id: number;
-  start: Date;
-  end?: Date;
-  terminationReason?: string;
-  status: string;
-  statusId: number;
-}
-
-export interface MembershipStatisticsViewModel {
-  durationInDays: number;
-  durationInYears: string;
-  status: string;
-  statusId: number;
-  memberId: number;
-  memberSalutation: string;
-  memberFirstname: string;
-  memberLastname: string;
-  memberNameaffix: string;
-  memberBirthdate: Date;
-}
-
-export interface CreateMembershipViewModel {
-  start: Date;
-  statusId: number;
-}
-
-export interface UpdateMembershipViewModel {
-  id: number;
-  start: Date;
-  end?: Date;
-  terminationReason?: string;
-  statusId: number;
-}

src/viewmodels/admin/club/newsletter/newsletter.models.ts

@@ -1,31 +0,0 @@
-import type { QueryViewModel } from "../../settings/query.models";
-
-export interface NewsletterViewModel {
-  id: number;
-  title: string;
-  description: string;
-  newsletterTitle: string;
-  newsletterText: string;
-  newsletterSignatur: string;
-  isSent: boolean;
-  recipientsByQueryId?: number | null;
-  recipientsByQuery?: QueryViewModel | null;
-}
-
-export interface CreateNewsletterViewModel {
-  title: string;
-}
-
-export interface SyncNewsletterViewModel {
-  id: number;
-  title: string;
-  description: string;
-  newsletterTitle: string;
-  newsletterText: string;
-  newsletterSignatur: string;
-  recipientsByQueryId?: number;
-}
-
-export interface SendNewsletterViewModel {
-  id: number;
-}

src/viewmodels/admin/club/newsletter/newsletterDates.models.ts

@@ -1,15 +0,0 @@
-import type { CalendarViewModel } from "../calendar.models";
-
-export interface NewsletterDatesViewModel {
-  newsletterId: number;
-  calendarId: string;
-  diffTitle: string | null;
-  diffDescription: string | null;
-  calendar: CalendarViewModel;
-}
-
-export interface SyncNewsletterDatesViewModel {
-  calendarId: string;
-  diffTitle?: string;
-  diffDescription?: string;
-}

src/viewmodels/admin/club/newsletter/newsletterRecipients.models.ts

@@ -1,11 +0,0 @@
-import type { MemberViewModel } from "../member/member.models";
-
-export interface NewsletterRecipientsViewModel {
-  newsletterId: number;
-  memberId: number;
-  member: MemberViewModel;
-}
-
-export interface SyncNewsletterRecipientsViewModel {
-  memberId: number;
-}

src/viewmodels/admin/club/protocol/protocol.models.ts

@@ -1,22 +0,0 @@
-export interface ProtocolViewModel {
-  id: number;
-  title: string;
-  date: Date;
-  starttime: Date;
-  endtime: Date;
-  summary: string;
-}
-
-export interface CreateProtocolViewModel {
-  title: string;
-  date: Date;
-}
-
-export interface SyncProtocolViewModel {
-  id: number;
-  title: string;
-  date: Date;
-  starttime: Date;
-  endtime: Date;
-  summary: string;
-}

src/viewmodels/admin/club/protocol/protocolAgenda.models.ts

@@ -1,12 +0,0 @@
-export interface ProtocolAgendaViewModel {
-  id: number;
-  topic: string;
-  context: string;
-  protocolId: number;
-}
-
-export interface SyncProtocolAgendaViewModel {
-  id?: number;
-  topic: string;
-  context: string;
-}

src/viewmodels/admin/club/protocol/protocolDecision.models.ts

@@ -1,12 +0,0 @@
-export interface ProtocolDecisionViewModel {
-  id: number;
-  topic: string;
-  context: string;
-  protocolId: number;
-}
-
-export interface SyncProtocolDecisionViewModel {
-  id?: number;
-  topic: string;
-  context: string;
-}

src/viewmodels/admin/club/protocol/protocolPresence.models.ts

@@ -1,10 +0,0 @@
-export interface ProtocolPresenceViewModel {
-  memberId: number;
-  absent: boolean;
-  excused: boolean;
-  protocolId: number;
-}
-
-export interface SyncProtocolPresenceViewModel {
-  memberIds: Array<number>;
-}

src/viewmodels/admin/club/protocol/protocolPrintout.models.ts

@@ -1,7 +0,0 @@
-export interface ProtocolPrintoutViewModel {
-  id: number;
-  title: string;
-  iteration: number;
-  createdAt: Date;
-  protocolId: number;
-}

src/viewmodels/admin/club/protocol/protocolVoting.models.ts

@@ -1,19 +0,0 @@
-export interface ProtocolVotingViewModel {
-  id: number;
-  topic: string;
-  context: string;
-  favour: number;
-  abstain: number;
-  against: number;
-  protocolId: number;
-}
-
-export interface SyncProtocolVotingViewModel {
-  id?: number;
-  topic: string;
-  context: string;
-  favour: number;
-  abstain: number;
-  against: number;
-  protocolId: number;
-}

src/viewmodels/admin/member.models.ts

@@ -0,0 +1,183 @@
+import { CommunicationTypeViewModel, SalutationViewModel } from "./memberData.models";
+
+/** Member Models */
+export interface MemberViewModel {
+  id: string;
+  salutation: SalutationViewModel;
+  firstname: string;
+  lastname: string;
+  nameaffix: string;
+  birthdate: Date;
+  internalId?: string;
+  firstMembershipEntry?: MembershipViewModel;
+  lastMembershipEntry?: MembershipViewModel;
+  sendNewsletter?: CommunicationViewModel;
+  smsAlarming?: Array<CommunicationViewModel>;
+  preferredCommunication?: Array<CommunicationViewModel>;
+}
+export interface MemberStatisticsViewModel {
+  id: string;
+  salutation: string;
+  firstname: string;
+  lastname: string;
+  nameaffix: string;
+  birthdate: Date;
+  todayAge: number;
+  ageThisYear: number;
+  exactAge: string;
+}
+export interface CreateMemberViewModel {
+  salutationId: number;
+  firstname: string;
+  lastname: string;
+  nameaffix: string;
+  birthdate: Date;
+  internalId?: string;
+}
+export interface UpdateMemberViewModel {
+  salutationId: number;
+  firstname: string;
+  lastname: string;
+  nameaffix: string;
+  birthdate: Date;
+  internalId?: string;
+}
+
+/** Award Models */
+export interface MemberAwardViewModel {
+  id: number;
+  given: boolean;
+  note?: string;
+  date: Date;
+  award: string;
+  awardId: number;
+}
+export interface CreateMemberAwardViewModel {
+  given: boolean;
+  note?: string;
+  date: Date;
+  awardId: number;
+}
+export interface UpdateMemberAwardViewModel {
+  given: boolean;
+  note?: string;
+  date: Date;
+  awardId: number;
+}
+
+/** Communication Models */
+export interface CommunicationViewModel {
+  id: number;
+  preferred: boolean;
+  mobile: string;
+  email: string;
+  postalCode: string;
+  city: string;
+  street: string;
+  streetNumber: number;
+  streetNumberAddition: string;
+  type: CommunicationTypeViewModel;
+  isNewsletterMain: boolean;
+  isSMSAlarming: boolean;
+}
+export interface CreateCommunicationViewModel {
+  preferred: boolean;
+  mobile: string;
+  email: string;
+  postalCode: string;
+  city: string;
+  street: string;
+  streetNumber: number;
+  streetNumberAddition: string;
+  typeId: number;
+  isNewsletterMain: boolean;
+  isSMSAlarming: boolean;
+}
+export interface UpdateCommunicationViewModel {
+  preferred: boolean;
+  mobile: string;
+  email: string;
+  postalCode: string;
+  city: string;
+  street: string;
+  streetNumber: number;
+  streetNumberAddition: string;
+  isNewsletterMain: boolean;
+  isSMSAlarming: boolean;
+}
+
+/** Executive Positon Models */
+export interface MemberExecutivePositionViewModel {
+  id: number;
+  note?: string;
+  start: Date;
+  end?: Date;
+  executivePosition: string;
+  executivePositionId: number;
+}
+export interface CreateMemberExecutivePositionViewModel {
+  note?: string;
+  start: Date;
+  end?: Date;
+  executivePositionId: number;
+}
+export interface UpdateMemberExecutivePositionViewModel {
+  note?: string;
+  start: Date;
+  end?: Date;
+  executivePositionId: number;
+}
+
+/** Qualification Models */
+export interface MemberQualificationViewModel {
+  id: number;
+  note?: string;
+  start: Date;
+  end?: Date;
+  terminationReason?: string;
+  qualification: string;
+  qualificationId: number;
+}
+export interface CreateMemberQualificationViewModel {
+  note?: string;
+  start: Date;
+  qualificationId: number;
+}
+export interface UpdateMemberQualificationViewModel {
+  note?: string;
+  start: Date;
+  end?: Date;
+  terminationReason?: string;
+  qualificationId: number;
+}
+
+/** Membership Models */
+export interface MembershipViewModel {
+  start: Date;
+  end?: Date;
+  terminationReason?: string;
+  status: string;
+  statusId: number;
+}
+export interface MembershipStatisticsViewModel {
+  durationInDays: number;
+  durationInYears: string;
+  status: string;
+  statusId: number;
+  memberId: number;
+  memberSalutation: string;
+  memberFirstname: string;
+  memberLastname: string;
+  memberNameaffix: string;
+  memberBirthdate: Date;
+}
+export interface CreateMembershipViewModel {
+  start: Date;
+  statusId: number;
+}
+export interface UpdateMembershipViewModel {
+  start: Date;
+  end?: Date;
+  terminationReason?: string;
+  statusId: number;
+}

src/viewmodels/admin/memberData.models.ts

@@ -0,0 +1,79 @@
+import { CommunicationFieldType } from "../../types/admin/fieldTypes";
+
+/** Award Models */
+export interface AwardViewModel {
+  id: number;
+  award: string;
+}
+export interface CreateAwardViewModel {
+  award: string;
+}
+export interface UpdateAwardViewModel {
+  award: string;
+}
+
+/** Communication Type Models */
+export interface CommunicationTypeViewModel {
+  id: number;
+  type: string;
+  fields: Array<CommunicationFieldType>;
+}
+export interface CreateCommunicationTypeViewModel {
+  type: string;
+  fields: Array<CommunicationFieldType>;
+}
+export interface UpdateCommunicationTypeViewModel {
+  type: string;
+  fields: Array<CommunicationFieldType>;
+}
+
+/** Membership Status Models */
+export interface MembershipStatusViewModel {
+  id: number;
+  status: string;
+}
+export interface CreateMembershipStatusViewModel {
+  status: string;
+}
+export interface UpdateMembershipStatusViewModel {
+  status: string;
+}
+
+/** Executive Positon Models */
+export interface ExecutivePositionViewModel {
+  id: number;
+  position: string;
+}
+export interface CreateExecutivePositionViewModel {
+  position: string;
+}
+export interface UpdateExecutivePositionViewModel {
+  position: string;
+}
+
+/** Qualification Models */
+export interface QualificationViewModel {
+  id: number;
+  qualification: string;
+  description: string | null;
+}
+export interface CreateQualificationViewModel {
+  qualification: string;
+  description: string | null;
+}
+export interface UpdateQualificationViewModel {
+  qualification: string;
+  description: string | null;
+}
+
+/** Salutation Models */
+export interface SalutationViewModel {
+  id: number;
+  salutation: string;
+}
+export interface CreateSalutationViewModel {
+  salutation: string;
+}
+export interface UpdateSalutationViewModel {
+  salutation: string;
+}

src/viewmodels/admin/newsletter.models.ts

@@ -0,0 +1,62 @@
+import { NewsletterConfigType } from "../../enums/admin/newsletterType";
+import { CalendarViewModel } from "./calendar.models";
+import { MemberViewModel } from "./member.models";
+import { CommunicationTypeViewModel } from "./memberData.models";
+import { QueryViewModel } from "./query.models";
+
+/** Newsletter Models */
+export interface NewsletterViewModel {
+  id: number;
+  title: string;
+  description: string;
+  newsletterTitle: string;
+  newsletterText: string;
+  newsletterSignatur: string;
+  isSent: boolean;
+  recipientsByQueryId?: number | null;
+  recipientsByQuery?: QueryViewModel | null;
+}
+export interface CreateNewsletterViewModel {
+  title: string;
+}
+export interface SyncNewsletterViewModel {
+  title: string;
+  description: string;
+  newsletterTitle: string;
+  newsletterText: string;
+  newsletterSignatur: string;
+  recipientsByQueryId?: number;
+}
+
+/** Newsletter Recipient Models */
+export interface NewsletterRecipientsViewModel {
+  newsletterId: number;
+  memberId: string;
+  member: MemberViewModel;
+}
+export interface SyncNewsletterRecipientsViewModel {
+  recipients: Array<string>;
+}
+
+/** Newsletter Date Models */
+export interface NewsletterDatesViewModel {
+  newsletterId: number;
+  calendarId: string;
+  diffTitle: string | null;
+  diffDescription: string | null;
+  calendar: CalendarViewModel;
+}
+export interface SyncNewsletterDatesViewModel {
+  dates: Array<{ calendarId: string; diffTitle?: string; diffDescription?: string }>;
+}
+
+/** Newsletter Config Models */
+export interface NewsletterConfigViewModel {
+  comTypeId: number;
+  config: NewsletterConfigType;
+  comType: CommunicationTypeViewModel;
+}
+export interface SetNewsletterConfigViewModel {
+  comTypeId: number;
+  config: NewsletterConfigType;
+}

src/viewmodels/admin/protocol.models.ts

@@ -0,0 +1,89 @@
+/** Protocol Models */
+export interface ProtocolViewModel {
+  id: number;
+  title: string;
+  date: Date;
+  starttime: Date;
+  endtime: Date;
+  summary: string;
+}
+export interface CreateProtocolViewModel {
+  title: string;
+  date: Date;
+}
+export interface SyncProtocolViewModel {
+  title: string;
+  date: Date;
+  starttime: Date;
+  endtime: Date;
+  summary: string;
+}
+
+/** Protocol Agenda Models */
+export interface ProtocolAgendaViewModel {
+  id: number;
+  topic: string;
+  context: string;
+  protocolId: number;
+}
+export interface SyncProtocolAgendaViewModel {
+  id: number;
+  topic: string;
+  context: string;
+}
+
+/** Protocol Decision Models */
+export interface ProtocolDecisionViewModel {
+  id: number;
+  topic: string;
+  context: string;
+  protocolId: number;
+}
+export interface SyncProtocolDecisionViewModel {
+  id: number;
+  topic: string;
+  context: string;
+}
+
+/** Protocol Presence Models */
+export interface ProtocolPresenceViewModel {
+  memberId: string;
+  absent: boolean;
+  excused: boolean;
+  protocolId: number;
+}
+export interface SyncProtocolPresenceViewModel {
+  presence: Array<{
+    memberId: string;
+    absent: boolean;
+    excused: boolean;
+  }>;
+}
+
+/** Protocol Voting Models */
+export interface ProtocolVotingViewModel {
+  id: number;
+  topic: string;
+  context: string;
+  favour: number;
+  abstain: number;
+  against: number;
+  protocolId: number;
+}
+export interface SyncProtocolVotingViewModel {
+  id: number;
+  topic: string;
+  context: string;
+  favour: number;
+  abstain: number;
+  against: number;
+}
+
+/** Protocol Printout Models */
+export interface ProtocolPrintoutViewModel {
+  id: number;
+  title: string;
+  iteration: number;
+  createdAt: Date;
+  protocolId: number;
+}

src/viewmodels/admin/query.models.ts

@@ -0,0 +1,35 @@
+import { DynamicQueryStructure, FieldType } from "../../types/admin/dynamicQueries";
+
+/** Query Store Models */
+export interface QueryViewModel {
+  id: number;
+  title: string;
+  query: string | DynamicQueryStructure;
+}
+
+export interface CreateQueryViewModel {
+  title: string;
+  query: string | DynamicQueryStructure;
+}
+
+export interface UpdateQueryViewModel {
+  query: string | DynamicQueryStructure;
+}
+
+/** Query Builder Models */
+export type QueryExecuteResult =
+  | {
+      stats: "error";
+      sql: string;
+      code: string;
+      msg: string;
+    }
+  | {
+      stats: "success";
+      rows: Array<{
+        [key: string]: FieldType;
+      }>;
+      total: number;
+      offset: number;
+      count: number;
+    };

src/viewmodels/admin/role.models.ts

@@ -0,0 +1,13 @@
+import { PermissionObject } from "../../types/admin/permissionTypes";
+
+export interface RoleViewModel {
+  id: number;
+  permissions: PermissionObject;
+  role: string;
+}
+export interface UpdateRoleViewModel {
+  role: string;
+}
+export interface UpdateRolePermissionViewModel {
+  permissions: PermissionObject;
+}

src/viewmodels/admin/settings/award.models.ts

@@ -1,13 +0,0 @@
-export interface AwardViewModel {
-  id: number;
-  award: string;
-}
-
-export interface CreateAwardViewModel {
-  award: string;
-}
-
-export interface UpdateAwardViewModel {
-  id: number;
-  award: string;
-}

src/viewmodels/admin/settings/calendarType.models.ts

@@ -1,22 +0,0 @@
-export interface CalendarTypeViewModel {
-  id: string;
-  type: string;
-  nscdr: boolean;
-  color: string;
-  passphrase: string | null;
-}
-
-export interface CreateCalendarTypeViewModel {
-  type: string;
-  nscdr: boolean;
-  color: string;
-  passphrase?: string;
-}
-
-export interface UpdateCalendarTypeViewModel {
-  id: string;
-  type: string;
-  nscdr: boolean;
-  color: string;
-  passphrase?: string;
-}

src/viewmodels/admin/settings/communicationType.models.ts

@@ -1,18 +0,0 @@
-import type { CommunicationFieldType } from "../../../types/fieldTypes";
-
-export interface CommunicationTypeViewModel {
-  id: number;
-  type: string;
-  fields: Array<CommunicationFieldType>;
-}
-
-export interface CreateCommunicationTypeViewModel {
-  type: string;
-  fields: Array<CommunicationFieldType>;
-}
-
-export interface UpdateCommunicationTypeViewModel {
-  id: number;
-  type: string;
-  fields: Array<CommunicationFieldType>;
-}

src/viewmodels/admin/settings/executivePosition.models.ts

@@ -1,13 +0,0 @@
-export interface ExecutivePositionViewModel {
-  id: number;
-  position: string;
-}
-
-export interface CreateExecutivePositionViewModel {
-  position: string;
-}
-
-export interface UpdateExecutivePositionViewModel {
-  id: number;
-  position: string;
-}

src/viewmodels/admin/settings/membershipStatus.models.ts

@@ -1,13 +0,0 @@
-export interface MembershipStatusViewModel {
-  id: number;
-  status: string;
-}
-
-export interface CreateMembershipStatusViewModel {
-  status: string;
-}
-
-export interface UpdateMembershipStatusViewModel {
-  id: number;
-  status: string;
-}

src/viewmodels/admin/settings/newsletterConfig.models.ts

@@ -1,13 +0,0 @@
-import type { NewsletterConfigType } from "../../../enums/newsletterConfigType";
-import type { CommunicationTypeViewModel } from "./communicationType.models";
-
-export interface NewsletterConfigViewModel {
-  comTypeId: number;
-  config: NewsletterConfigType;
-  comType: CommunicationTypeViewModel;
-}
-
-export interface SetNewsletterConfigViewModel {
-  comTypeId: number;
-  config: NewsletterConfigType;
-}

src/viewmodels/admin/settings/qualification.models.ts

@@ -1,16 +0,0 @@
-export interface QualificationViewModel {
-  id: number;
-  qualification: string;
-  description: string | null;
-}
-
-export interface CreateQualificationViewModel {
-  qualification: string;
-  description: string | null;
-}
-
-export interface UpdateQualificationViewModel {
-  id: number;
-  qualification: string;
-  description: string | null;
-}

src/viewmodels/admin/settings/query.models.ts

@@ -1,23 +0,0 @@
-import type { DynamicQueryStructure } from "../../../types/dynamicQueries";
-
-export interface TableMeta {
-  tableName: string;
-  columns: Array<{ column: string; type: string }>;
-  relations: Array<{ column: string; relationType: string; referencedTableName: string }>;
-}
-
-export interface QueryViewModel {
-  id: number;
-  title: string;
-  query: string | DynamicQueryStructure;
-}
-
-export interface CreateQueryViewModel {
-  title: string;
-  query: string | DynamicQueryStructure;
-}
-
-export interface UpdateQueryViewModel {
-  id: number;
-  query: string | DynamicQueryStructure;
-}

src/viewmodels/admin/settings/salutation.models.ts

@@ -1,13 +0,0 @@
-export interface SalutationViewModel {
-  id: number;
-  salutation: string;
-}
-
-export interface CreateSalutationViewModel {
-  salutation: string;
-}
-
-export interface UpdateSalutationViewModel {
-  id: number;
-  salutation: string;
-}

src/viewmodels/admin/settings/template.models.ts

@@ -1,20 +0,0 @@
-export interface TemplateViewModel {
-  id: number;
-  template: string;
-  description: string | null;
-  design: object;
-  html: string;
-}
-
-export interface CreateTemplateViewModel {
-  template: string;
-  description: string | null;
-}
-
-export interface UpdateTemplateViewModel {
-  id: number;
-  template: string;
-  description: string | null;
-  design: object;
-  html: string;
-}

src/viewmodels/admin/settings/templateUsage.models.ts

@@ -1,19 +0,0 @@
-import type { PermissionModule } from "../../../types/permissionTypes";
-
-export interface TemplateUsageViewModel {
-  scope: PermissionModule;
-  header: { id: number; template: string } | null;
-  body: { id: number; template: string } | null;
-  footer: { id: number; template: string } | null;
-  headerHeight: number | null;
-  footerHeight: number | null;
-}
-
-export interface UpdateTemplateUsageViewModel {
-  scope: PermissionModule;
-  headerId: number | null;
-  bodyId: number | null;
-  footerId: number | null;
-  headerHeight: number | null;
-  footerHeight: number | null;
-}

src/viewmodels/admin/template.models.ts

@@ -0,0 +1,43 @@
+import { PermissionModule } from "../../types/admin/permissionTypes";
+
+/** Template Models */
+export interface TemplateViewModel {
+  id: number;
+  template: string;
+  description: string | null;
+  design: object;
+  html: string;
+}
+
+export interface CreateTemplateViewModel {
+  template: string;
+  description: string | null;
+}
+export interface CloneTemplateViewModel {
+  cloneId: number;
+}
+export interface UpdateTemplateViewModel {
+  id: number;
+  template: string;
+  description: string | null;
+  design: object;
+  html: string;
+}
+
+/** Template Usage Models */
+export interface TemplateUsageViewModel {
+  scope: `${PermissionModule}` | `${PermissionModule}.${string}`;
+  header: { id: number; template: string } | null;
+  body: { id: number; template: string } | null;
+  footer: { id: number; template: string } | null;
+  headerHeight: number | null;
+  footerHeight: number | null;
+}
+
+export interface UpdateTemplateUsageViewModel {
+  headerId: number | null;
+  bodyId: number | null;
+  footerId: number | null;
+  headerHeight: number | null;
+  footerHeight: number | null;
+}

src/viewmodels/admin/user.models.ts

@@ -1,6 +1,7 @@
-import { PermissionObject } from "../../../types/permissionTypes";
+import { PermissionObject } from "../../types/admin/permissionTypes";
 import { RoleViewModel } from "./role.models";
 
+/** User Models */
 export interface UserViewModel {
   id: string;
   username: string;
@@ -12,16 +13,33 @@ export interface UserViewModel {
   roles: Array<RoleViewModel>;
   permissions_total: PermissionObject;
 }
-
 export interface CreateUserViewModel {
   username: string;
   mail: string;
   firstname: string;
   lastname: string;
 }
-
 export interface UpdateUserViewModel {
-  id: string;
+  username: string;
+  mail: string;
+  firstname: string;
+  lastname: string;
+}
+export interface UpdateUserRolesViewModel {
+  roleIds: Array<number>;
+}
+export interface UpdateUserPermissionViewModel {
+  permissions: PermissionObject;
+}
+
+/** Invite Models */
+export interface InviteViewModel {
+  username: string;
+  mail: string;
+  firstname: string;
+  lastname: string;
+}
+export interface CreateInviteViewModel {
   username: string;
   mail: string;
   firstname: string;

src/viewmodels/admin/user/invite.models.ts

@@ -1,13 +0,0 @@
-export interface InviteViewModel {
-  username: string;
-  mail: string;
-  firstname: string;
-  lastname: string;
-}
-
-export interface CreateInviteViewModel {
-  username: string;
-  mail: string;
-  firstname: string;
-  lastname: string;
-}

src/viewmodels/admin/user/role.models.ts

@@ -1,7 +0,0 @@
-import { PermissionObject } from "../../../types/permissionTypes";
-
-export interface RoleViewModel {
-  id: number;
-  permissions: PermissionObject;
-  role: string;
-}