viewmodels and factories

src/service/communicationService.ts

@@ -4,21 +4,48 @@ import InternalException from "../exceptions/internalException";
 
 export default abstract class CommunicationService {
   /**
-   * @description get communications by user
+   * @description get all by member id
+   * @param {number} memberId
    * @returns {Promise<Array<communication>>}
    */
-  static async getById(userId: number): Promise<communication> {
+  static async getAll(memberId: number): Promise<Array<communication>> {
     return await dataSource
       .getRepository(communication)
       .createQueryBuilder("communication")
-      .leftJoin("communication.user", "user")
-      .where("user.id = :id", { id: userId })
+      .leftJoinAndSelect("communication.type", "communicationType")
+      .leftJoinAndSelect("communication.member", "member")
+      .leftJoinAndSelect("member.sendNewsletter", "sendNewsletter")
+      .where("communication.memberId = :memberId", { memberId: memberId })
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("member communications not found", err);
+      });
+  }
+
+  /**
+   * @description get all by memberId and recordId
+   * @param {number} memberId
+   * @param {number} recordId
+   * @returns {Promise<communication>}
+   */
+  static async getById(memberId: number, recordId: number): Promise<communication> {
+    return await dataSource
+      .getRepository(communication)
+      .createQueryBuilder("communication")
+      .leftJoinAndSelect("communication.type", "communicationType")
+      .leftJoinAndSelect("communication.member", "member")
+      .leftJoinAndSelect("member.sendNewsletter", "sendNewsletter")
+      .where("communication.memberId = :memberId", { memberId: memberId })
+      .andWhere("communication.id = :recordId", { recordId: recordId })
       .getOneOrFail()
       .then((res) => {
         return res;
       })
       .catch((err) => {
-        throw new InternalException("communications not found by userid", err);
+        throw new InternalException("member communication not found by id", err);
       });
   }
 

src/service/memberAwardService.ts

@@ -0,0 +1,47 @@
+import { dataSource } from "../data-source";
+import { memberAwards } from "../entity/memberAwards";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class MemberAwardService {
+  /**
+   * @description get all by member id
+   * @param {number} memberId
+   * @returns {Promise<Array<memberAwards>>}
+   */
+  static async getAll(memberId: number): Promise<Array<memberAwards>> {
+    return await dataSource
+      .getRepository(memberAwards)
+      .createQueryBuilder("memberAwards")
+      .leftJoinAndSelect("memberAwards.award", "award")
+      .where("memberAwards.memberId = :memberId", { memberId: memberId })
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("member awards not found", err);
+      });
+  }
+
+  /**
+   * @description get by memberId and recordId
+   * @param {number} memberId
+   * @param {number} recordId
+   * @returns {Promise<Array<member>>}
+   */
+  static async getById(memberId: number, recordId: number): Promise<memberAwards> {
+    return await dataSource
+      .getRepository(memberAwards)
+      .createQueryBuilder("memberAwards")
+      .leftJoinAndSelect("memberAwards.award", "award")
+      .where("memberAwards.memberId = :memberId", { memberId: memberId })
+      .andWhere("memberAwards.id = :recordId", { recordId: recordId })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("member award not found by id", err);
+      });
+  }
+}

src/service/memberExecutivePositionService.ts

@@ -0,0 +1,49 @@
+import { dataSource } from "../data-source";
+import { memberExecutivePositions } from "../entity/memberExecutivePositions";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class MemberExecutivePositionService {
+  /**
+   * @description get all by member id
+   * @param {number} memberId
+   * @returns {Promise<Array<memberExecutivePositions>>}
+   */
+  static async getAll(memberId: number): Promise<Array<memberExecutivePositions>> {
+    return await dataSource
+      .getRepository(memberExecutivePositions)
+      .createQueryBuilder("memberExecutivePositions")
+      .leftJoinAndSelect("memberExecutivePositions.executivePosition", "executivePosition")
+      .where("memberExecutivePositions.memberId = :memberId", { memberId: memberId })
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("member executivePositions not found", err);
+      });
+  }
+
+  /**
+   * @description get by memberId and recordId
+   * @param {number} memberId
+   * @param {number} recordId
+   * @returns {Promise<Array<member>>}
+   */
+  static async getById(memberId: number, recordId: number): Promise<memberExecutivePositions> {
+    return await dataSource
+      .getRepository(memberExecutivePositions)
+      .createQueryBuilder("memberExecutivePositions")
+      .leftJoinAndSelect("memberExecutivePositions.executivePosition", "executivePosition")
+      .where("memberExecutivePositions.memberId = :memberId", { memberId: memberId })
+      .andWhere("memberExecutivePositions.id = :recordId", {
+        recordId: recordId,
+      })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("member executivePosition not found by id", err);
+      });
+  }
+}

src/service/memberQualificationService.ts

@@ -0,0 +1,47 @@
+import { dataSource } from "../data-source";
+import { memberQualifications } from "../entity/memberQualifications";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class MemberQualificationService {
+  /**
+   * @description get all by member id
+   * @param {number} memberId
+   * @returns {Promise<Array<memberQualifications>>}
+   */
+  static async getAll(memberId: number): Promise<Array<memberQualifications>> {
+    return await dataSource
+      .getRepository(memberQualifications)
+      .createQueryBuilder("memberQualifications")
+      .leftJoinAndSelect("memberQualifications.qualification", "qualification")
+      .where("memberQualifications.memberId = :memberId", { memberId: memberId })
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("member qualifications not found", err);
+      });
+  }
+
+  /**
+   * @description get by memberId and recordId
+   * @param {number} memberId
+   * @param {number} recordId
+   * @returns {Promise<Array<member>>}
+   */
+  static async getById(memberId: number, recordId: number): Promise<memberQualifications> {
+    return await dataSource
+      .getRepository(memberQualifications)
+      .createQueryBuilder("memberQualifications")
+      .leftJoinAndSelect("memberQualifications.qualification", "qualification")
+      .where("memberQualifications.memberId = :memberId", { memberId: memberId })
+      .andWhere("memberQualifications.id = :recordId", { recordId: recordId })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("member qualification not found by id", err);
+      });
+  }
+}

src/service/memberService.ts

@@ -1,5 +1,6 @@
 import { dataSource } from "../data-source";
 import { member } from "../entity/member";
+import { membership } from "../entity/membership";
 import InternalException from "../exceptions/internalException";
 
 export default abstract class MemberService {
@@ -11,6 +12,18 @@ export default abstract class MemberService {
     return await dataSource
       .getRepository(member)
       .createQueryBuilder("member")
+      .leftJoinAndMapOne(
+        "member.firstMembershipEntry",
+        "member.memberships",
+        "membership_first",
+        "membership_first.memberId = member.id AND membership_first.start = (SELECT MIN(m.start) FROM membership m WHERE m.memberId = member.id)"
+      )
+      .leftJoinAndMapOne(
+        "member.lastMembershipEntry",
+        "member.memberships",
+        "membership_last",
+        "membership_last.memberId = member.id AND membership_last.start = (SELECT MAX(m.start) FROM membership m WHERE m.memberId = member.id)"
+      )
       .getMany()
       .then((res) => {
         return res;
@@ -29,6 +42,28 @@ export default abstract class MemberService {
     return await dataSource
       .getRepository(member)
       .createQueryBuilder("member")
+      .leftJoinAndMapOne(
+        "member.firstMembershipEntry",
+        (subQuery) => {
+          return subQuery
+            .from(membership, "membership")
+            .where("membership.memberId = member.id")
+            .orderBy("membership.date", "ASC")
+            .limit(1);
+        },
+        "membership_first"
+      )
+      .leftJoinAndMapOne(
+        "member.lastMembershipEntry",
+        (subQuery) => {
+          return subQuery
+            .from(membership, "membership")
+            .where("membership.memberId = member.id")
+            .orderBy("membership.date", "DESC")
+            .limit(1);
+        },
+        "membership_last"
+      )
       .where("member.id = :id", { id: id })
       .getOneOrFail()
       .then((res) => {

src/service/membershipService.ts

@@ -0,0 +1,47 @@
+import { dataSource } from "../data-source";
+import { membership } from "../entity/membership";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class Membershipervice {
+  /**
+   * @description get all by member id
+   * @param {number} memberId
+   * @returns {Promise<Array<membership>>}
+   */
+  static async getAll(memberId: number): Promise<Array<membership>> {
+    return await dataSource
+      .getRepository(membership)
+      .createQueryBuilder("membership")
+      .leftJoinAndSelect("membership.membership", "membership")
+      .where("membership.memberId = :memberId", { memberId: memberId })
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("member memberships not found", err);
+      });
+  }
+
+  /**
+   * @description get by memberId and recordId
+   * @param {number} memberId
+   * @param {number} recordId
+   * @returns {Promise<Array<member>>}
+   */
+  static async getById(memberId: number, recordId: number): Promise<membership> {
+    return await dataSource
+      .getRepository(membership)
+      .createQueryBuilder("membership")
+      .leftJoinAndSelect("membership.membership", "membership")
+      .where("membership.memberId = :memberId", { memberId: memberId })
+      .andWhere("membership.id = :recordId", { recordId: recordId })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("member membership not found by id", err);
+      });
+  }
+}