chore: get announcements for customers

src/modules/announcements/DTO/create-announcement.dto.ts

@@ -61,4 +61,17 @@ export class CreateAnnouncementDto {
     example: ["f7b1b3b1-1b1b-4b1b-8b1b-1b1b1b1b1b1b"],
   })
   groupIds: string[];
+
+  @IsOptional()
+  @IsArray()
+  @IsUUID("4", {
+    each: true,
+    message: AnnouncementMessage.USER_MUST_BE_UUID,
+  })
+  @ApiProperty({
+    type: [String],
+    description: "Array of users ids",
+    example: ["f7b1b3b1-1b1b-4b1b-8b1b-1b1b1b1b1b1b"],
+  })
+  userIds: string[];
 }

src/modules/announcements/entities/announcement.entity.ts

@@ -1,9 +1,10 @@
-import { Column, Entity, Index, ManyToMany, ManyToOne, OneToMany } from "typeorm";
+import { Column, Entity, Index, JoinTable, ManyToMany, ManyToOne, OneToMany } from "typeorm";
 
 import { UserAnnouncement } from "./user-announcement.entity";
 import { BaseEntity } from "../../../common/entities/base.entity";
 import { DanakService } from "../../danak-services/entities/danak-service.entity";
 import { UserGroup } from "../../users/entities/user-group.entity";
+import { User } from "../../users/entities/user.entity";
 
 @Entity()
 @Index(["isPublic", "createdAt"])
@@ -34,6 +35,10 @@ export class Announcement extends BaseEntity {
     return this.isPublic;
   }
 
+  @ManyToMany(() => User, (user) => user.announcements)
+  @JoinTable({ name: "announcement_users" })
+  users: User[];
+
   @OneToMany(() => UserAnnouncement, (userAnnouncement) => userAnnouncement.announcement)
   userAnnouncements: UserAnnouncement[];
 }

src/modules/announcements/providers/announcement.service.ts

@@ -22,18 +22,24 @@ export class AnnouncementService {
   async createAnnouncement(createAnnouncementDto: CreateAnnouncementDto) {
     let service;
     let groups;
+    let users;
     if (createAnnouncementDto.serviceId) {
       service = await this.danakServicesService.findServiceById(createAnnouncementDto.serviceId);
     }
     if (createAnnouncementDto.groupIds) {
       groups = await this.usersService.getUserGroupsByIds(createAnnouncementDto.groupIds);
     }
+    if (createAnnouncementDto.userIds) {
+      users = await this.usersService.getUsersByIds(createAnnouncementDto.userIds);
+    }
     //TODO: Create Queue for publishAT
     const announcement = this.announcementRepository.create({
       ...createAnnouncementDto,
       service,
       targetGroups: groups?.userGroups,
+      users,
     });
+
     await this.announcementRepository.save(announcement);
     return {
       message: CommonMessage.CREATED,
@@ -134,6 +140,7 @@ export class AnnouncementService {
       .createQueryBuilder("announcement")
       .leftJoin("announcement.service", "service")
       .addSelect(["service.id", "service.name"])
+      .leftJoin("announcement.users", "announcementUser")
       .leftJoin("announcement.targetGroups", "group")
       .addSelect(["group.id", "group.name"])
       .leftJoin("group.users", "groupUser")
@@ -147,7 +154,8 @@ export class AnnouncementService {
       .leftJoinAndSelect("announcement.userAnnouncements", "userAnnouncements", "userAnnouncements.userId = :userId", { userId })
       .where("announcement.isPublic = :isPublic", { isPublic: true })
       .orWhere("groupUser.id = :userId", { userId })
-      .orWhere("userSubscription.userId = :userId", { userId });
+      .orWhere("userSubscription.userId = :userId", { userId })
+      .orWhere("announcementUser.id = :userId", { userId });
 
     if (queryDto.since) {
       queryBuilder.andWhere("announcement.createdAt >= :since", { since: queryDto.since });
@@ -164,7 +172,7 @@ export class AnnouncementService {
     queryBuilder.orderBy("announcement.createdAt", "DESC");
     const rawResults = await queryBuilder.getRawMany();
     const [, count] = await queryBuilder.skip(skip).take(limit).getManyAndCount();
-
+    //TODO: fix later
     const announcements = rawResults.map((raw) => ({
       id: raw.announcement_id,
       createdAt: raw.announcement_createdAt,

src/modules/users/entities/user.entity.ts

@@ -8,6 +8,7 @@ import { UserGroup } from "./user-group.entity";
 import { BaseEntity } from "../../../common/entities/base.entity";
 import { Address } from "../../address/entities/address.entity";
 import { City } from "../../address/entities/city.entity";
+import { Announcement } from "../../announcements/entities/announcement.entity";
 import { UserAnnouncement } from "../../announcements/entities/user-announcement.entity";
 import { Criticism } from "../../criticisms/entities/criticism.entity";
 import { DanakServiceReview } from "../../danak-services/entities/danak-service-review.entity";
@@ -127,6 +128,9 @@ export class User extends BaseEntity {
 
   @ManyToMany(() => UsageDiscount, (usageDiscount) => usageDiscount.users)
   usageDiscounts: UsageDiscount[];
+
+  @ManyToMany(() => Announcement, (announcement) => announcement.users)
+  announcements: Announcement[];
 }
 
 // @ManyToMany(() => DanakService, (danakService) => danakService.users)

src/modules/users/providers/users.service.ts

@@ -363,6 +363,14 @@ export class UsersService {
 
   ///****************************************************** */
 
+  async getUsersByIds(ids: string[]) {
+    const users = await this.userRepository.find({ where: { id: In(ids) } });
+    if (!users) throw new BadRequestException(UserMessage.USER_NOT_FOUND);
+    return users;
+  }
+
+  ///****************************************************** */
+
   async updateUserPassword(userId: string, newPassword: string) {
     const updatedUser = await this.userRepository.update(
       { id: userId },