newsletter CRUD & pdf

src/service/newsletterDatesService.ts

@@ -0,0 +1,26 @@
+import { dataSource } from "../data-source";
+import { newsletterDates } from "../entity/newsletterDates";
+import { member } from "../entity/member";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class NewsletterDatesService {
+  /**
+   * @description get all newsletterDates
+   * @returns {Promise<Array<newsletterDates>>}
+   */
+  static async getAll(newsletterId: number): Promise<Array<newsletterDates>> {
+    return await dataSource
+      .getRepository(newsletterDates)
+      .createQueryBuilder("newsletterDates")
+      .leftJoinAndSelect("newsletterDates.calendar", "calendar")
+      .leftJoinAndSelect("newsletterDates.newsletter", "newsletter")
+      .where("newsletterDates.newsletterId = :id", { id: newsletterId })
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletterDatess not found", err);
+      });
+  }
+}

src/service/newsletterRecipientsService.ts

@@ -0,0 +1,28 @@
+import { dataSource } from "../data-source";
+import { newsletterRecipients } from "../entity/newsletterRecipients";
+import { member } from "../entity/member";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class NewsletterRecipientsService {
+  /**
+   * @description get all newsletterRecipients
+   * @returns {Promise<Array<newsletterRecipients>>}
+   */
+  static async getAll(newsletterId: number): Promise<Array<newsletterRecipients>> {
+    return await dataSource
+      .getRepository(newsletterRecipients)
+      .createQueryBuilder("newsletterRecipients")
+      .leftJoinAndSelect("newsletterRecipients.member", "member")
+      .leftJoinAndSelect("member.sendNewsletter", "sendNewsletter")
+      .leftJoinAndSelect("sendNewsletter.type", "communicationtype")
+      .leftJoinAndSelect("newsletterRecipients.newsletter", "newsletter")
+      .where("newsletterDates.newsletterId = :id", { id: newsletterId })
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletterRecipientss not found", err);
+      });
+  }
+}

src/service/newsletterService.ts

@@ -0,0 +1,44 @@
+import { dataSource } from "../data-source";
+import { newsletter } from "../entity/newsletter";
+import { member } from "../entity/member";
+import InternalException from "../exceptions/internalException";
+
+export default abstract class NewsletterService {
+  /**
+   * @description get all newsletters
+   * @returns {Promise<[Array<newsletter>, number]>}
+   */
+  static async getAll(offset: number = 0, count: number = 25): Promise<[Array<newsletter>, number]> {
+    return await dataSource
+      .getRepository(newsletter)
+      .createQueryBuilder("newsletter")
+      .offset(offset)
+      .limit(count)
+      .getManyAndCount()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletters not found", err);
+      });
+  }
+
+  /**
+   * @description get newsletter by id
+   * @returns {Promise<newsletter>}
+   */
+  static async getById(id: number): Promise<newsletter> {
+    return await dataSource
+      .getRepository(newsletter)
+      .createQueryBuilder("newsletter")
+      .leftJoinAndSelect("newsletter.recipientsByQuery", "query")
+      .where("newsletter.id = :id", { id: id })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new InternalException("newsletter not found by id", err);
+      });
+  }
+}

src/service/protocolPrecenseService.ts

@@ -21,23 +21,4 @@ export default abstract class ProtocolPresenceService {
         throw new InternalException("protocolPresence not found", err);
       });
   }
-
-  /**
-   * @description get protocolDecision by id
-   * @returns {Promise<protocolPresence>}
-   */
-  static async getById(id: number): Promise<protocolPresence> {
-    return await dataSource
-      .getRepository(protocolPresence)
-      .createQueryBuilder("protocolPresence")
-      .leftJoinAndSelect("protocolPresence.member", "member")
-      .where("protocolPresence.id = :id", { id: id })
-      .getOneOrFail()
-      .then((res) => {
-        return res;
-      })
-      .catch((err) => {
-        throw new InternalException("protocolDecision not found by id", err);
-      });
-  }
 }