update: add new field for subscription of user when purchased

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

@@ -1,77 +1,54 @@
 import { ApiProperty } from "@nestjs/swagger";
-import { IsArray, IsBoolean, IsNotEmpty, IsOptional, IsString, IsUUID, MinLength } from "class-validator";
+import {
+  ArrayMinSize,
+  IsArray,
+  IsBoolean,
+  IsDateString,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+  Length,
+  MinLength,
+} from "class-validator";
 
 import { AnnouncementMessage } from "../../../common/enums/message.enum";
 
 export class CreateAnnouncementDto {
   @IsNotEmpty({ message: AnnouncementMessage.TITLE_IS_REQUIRED })
   @IsString({ message: AnnouncementMessage.TITLE_STRING })
-  @ApiProperty({
-    description: "Title of the announcement",
-    example: "اطلاعیه جدید",
-  })
+  @Length(5, 100, { message: AnnouncementMessage.TITLE_LENGTH })
+  @ApiProperty({ description: "Title of the announcement", example: "اطلاعیه جدید" })
   title: string;
 
   @IsNotEmpty({ message: AnnouncementMessage.CONTENT_IS_REQUIRED })
   @IsString({ message: AnnouncementMessage.CONTENT_IS_STRING })
   @MinLength(10, { message: AnnouncementMessage.CONTENT_MUST_BE_LONGER })
-  @ApiProperty({
-    description: "Content of the announcement",
-    example: "اطلاعیه جدید برای کاربران",
-  })
+  @ApiProperty({ description: "Content of the announcement", example: "اطلاعیه جدید برای کاربران" })
   content: string;
 
   @IsOptional()
   @IsNotEmpty({ message: AnnouncementMessage.PUBLISH_AT_IS_REQUIRED })
-  @ApiProperty({
-    description: "Publish date of the announcement",
-    example: "2023-10-01T10:00:00Z",
-  })
+  @IsDateString({}, { message: AnnouncementMessage.PUBLISH_AT_MUST_BE_DATE })
+  @ApiProperty({ description: "Publish date of the announcement", example: "2023-10-01T10:00:00Z" })
   publishAt: Date;
 
-  @IsBoolean()
-  @ApiProperty({
-    description: "Is this announcement public?",
-    example: false,
-  })
-  isPublic: boolean;
-
-  @IsBoolean()
-  @ApiProperty({
-    description: "Is this announcement important?",
-    example: false,
-  })
+  @IsNotEmpty({ message: AnnouncementMessage.IMPORTANT_IS_REQUIRED })
+  @IsBoolean({ message: AnnouncementMessage.IMPORTANT_MUST_BE_BOOLEAN })
+  @ApiProperty({ description: "Is this announcement important?", example: false })
   isImportant: boolean;
 
   @IsOptional()
   @IsNotEmpty({ message: AnnouncementMessage.SERVICE_MUST_BE_ID })
-  @IsUUID("4", { message: AnnouncementMessage.SERVICE_MUST_BE_UUID })
-  @ApiProperty({ description: "Service ID", example: "d290f1ee-6c54-4b01-90e6-d701748f0851" })
-  serviceId: string;
+  @ArrayMinSize(1)
+  @IsUUID("4", { message: AnnouncementMessage.SERVICE_MUST_BE_UUID, each: true })
+  @ApiProperty({ type: [String], description: "Service IDs", example: ["d290f1ee-6c54-4b01-90e6-d701748f0851"] })
+  serviceIds: string[];
 
   @IsOptional()
-  @IsArray()
-  @IsUUID("4", {
-    each: true,
-    message: AnnouncementMessage.GROUP_MUST_BE_UUID,
-  })
-  @ApiProperty({
-    type: [String],
-    description: "Array of group ids",
-    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"],
-  })
+  @ArrayMinSize(1)
+  @IsArray({ message: AnnouncementMessage.USER_IDS_MUST_BE_ARRAY })
+  @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/announcement.controller.ts

@@ -1,7 +1,6 @@
-import { Body, Controller, Get, Param, Post, Query } from "@nestjs/common";
+import { Controller, Get, Param, Query } from "@nestjs/common";
 import { ApiProperty, ApiTags } from "@nestjs/swagger";
 
-import { CreateAnnouncementDto } from "./DTO/create-announcement.dto";
 import { AnnouncementService } from "./providers/announcement.service";
 import { AuthGuards } from "../../common/decorators/auth-guard.decorator";
 import { PermissionsDec } from "../../common/decorators/permission.decorator";
@@ -16,13 +15,13 @@ import { PermissionEnum } from "../users/enums/permission.enum";
 export class AnnouncementController {
   constructor(private readonly announcementService: AnnouncementService) {}
 
-  @AuthGuards()
-  @PermissionsDec(PermissionEnum.ANNOUNCEMENTS)
-  @ApiProperty({ description: "Create a new announcement ===> login as admin" })
-  @Post()
-  async create(@Body() createAnnouncementDto: CreateAnnouncementDto) {
-    return await this.announcementService.createAnnouncement(createAnnouncementDto);
-  }
+  // @AuthGuards()
+  // @PermissionsDec(PermissionEnum.ANNOUNCEMENTS)
+  // @ApiProperty({ description: "Create a new announcement ===> login as admin" })
+  // @Post()
+  // async create(@Body() createAnnouncementDto: CreateAnnouncementDto) {
+  //   return await this.announcementService.createAnnouncement(createAnnouncementDto);
+  // }
 
   @AuthGuards()
   @ApiProperty({ description: "Get all announcements ===> login as admin" })
@@ -33,9 +32,7 @@ export class AnnouncementController {
   }
 
   @AuthGuards()
-  @ApiProperty({
-    description: "Get all announcements ===> login as user",
-  })
+  @ApiProperty({ description: "Get all announcements ===> login as user" })
   @Get("user")
   async getAllAnnouncementsByUser(@Query() queryDto: SearchCriticismQueryDto, @UserDec() user: User) {
     return await this.announcementService.getAllAnnouncementsByUser(queryDto, user.id);

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

@@ -1,10 +1,8 @@
-import { Column, Entity, Index, JoinTable, ManyToMany, ManyToOne, OneToMany } from "typeorm";
+import { Column, Entity, Index, 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"])
@@ -15,30 +13,22 @@ export class Announcement extends BaseEntity {
   @Column({ type: "text" })
   content: string;
 
-  @Column({ type: "timestamp", default: null, nullable: true })
-  publishAt: Date;
+  @Column({ type: "timestamp", nullable: true, default: null })
+  publishAt: Date | null;
 
-  //TODO: Add customer here
   @ManyToOne(() => DanakService, (service) => service.announcements, { eager: true, onDelete: "CASCADE" })
-  service: DanakService;
+  targetService: DanakService;
 
   @Column({ type: "boolean", default: false })
   isImportant: boolean;
 
-  @ManyToMany(() => UserGroup, (group) => group.announcements)
-  targetGroups: UserGroup[];
+  @OneToMany(() => UserAnnouncement, (userAnnouncement) => userAnnouncement.announcement)
+  userAnnouncements: UserAnnouncement[];
 
-  @Column({ default: false })
+  @Column({ type: "boolean", default: false })
   isPublic: boolean;
 
   isPublicAnnouncement(): boolean {
     return this.isPublic;
   }
-
-  @ManyToMany(() => User, (user) => user.announcements)
-  @JoinTable({ name: "announcement_users" })
-  users: User[];
-
-  @OneToMany(() => UserAnnouncement, (userAnnouncement) => userAnnouncement.announcement)
-  userAnnouncements: UserAnnouncement[];
 }

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

@@ -1,4 +1,4 @@
-import { Column, Entity, JoinColumn, ManyToOne } from "typeorm";
+import { Column, Entity, ManyToOne } from "typeorm";
 
 import { Announcement } from "./announcement.entity";
 import { BaseEntity } from "../../../common/entities/base.entity";
@@ -7,11 +7,9 @@ import { User } from "../../users/entities/user.entity"; // Assuming you have a
 @Entity()
 export class UserAnnouncement extends BaseEntity {
   @ManyToOne(() => User, (user) => user.userAnnouncements, { onDelete: "CASCADE" })
-  @JoinColumn({ name: "userId" })
   user: User;
 
   @ManyToOne(() => Announcement, (announcement) => announcement.userAnnouncements, { onDelete: "CASCADE" })
-  @JoinColumn({ name: "announcementId" })
   announcement: Announcement;
 
   @Column({ type: "boolean", default: false })

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

@@ -1,10 +1,7 @@
 import { BadRequestException, Injectable } from "@nestjs/common";
 
-import { AnnouncementMessage, CommonMessage } from "../../../common/enums/message.enum";
-import { DanakServicesService } from "../../danak-services/providers/danak-services.service";
-import { UsersService } from "../../users/providers/users.service";
+import { AnnouncementMessage } from "../../../common/enums/message.enum";
 import { PaginationUtils } from "../../utils/providers/pagination.utils";
-import { CreateAnnouncementDto } from "../DTO/create-announcement.dto";
 import { SearchAnnouncementQueryDto } from "../DTO/search-announcement-query.dto";
 import { AnnouncementRepository } from "../repositories/announcement.repository";
 import { UserAnnouncementRepository } from "../repositories/user-announcement.repository";
@@ -14,39 +11,8 @@ export class AnnouncementService {
   constructor(
     private readonly announcementRepository: AnnouncementRepository,
     private readonly userAnnouncementRepository: UserAnnouncementRepository,
-    private readonly danakServicesService: DanakServicesService,
-    private readonly usersService: UsersService,
   ) {}
 
-  /***************************************** */
-  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,
-      announcement,
-    };
-  }
-
   /***************************************** */
 
   async getAllAnnouncements(queryDto: SearchAnnouncementQueryDto, userId: string) {
@@ -81,58 +47,6 @@ export class AnnouncementService {
 
   /***************************************** */
 
-  // async getAllAnnouncementsByUser(queryDto: SearchAnnouncementQueryDto, userId: string) {
-  //   const { limit, skip } = PaginationUtils(queryDto);
-  //   const queryBuilder = this.announcementRepository
-  //     .createQueryBuilder("announcement")
-  //     .leftJoin("announcement.service", "danak_service")
-  //     .addSelect(["danak_service.id", "danak_service.name"])
-  //     .leftJoin("announcement.targetGroups", "group")
-  //     .addSelect(["group.id", "group.name"])
-  //     .leftJoin("group.users", "groupUser")
-  //     .leftJoinAndSelect("announcement.userAnnouncements", "userAnnouncements", "userAnnouncements.userId = :userId", { userId })
-  //     .where("announcement.isPublic = :isPublic", { isPublic: true }) // Check if the announcement is public
-  //     .orWhere("groupUser.id = :userId", { userId });
-
-  //   if (queryDto.since) {
-  //     queryBuilder.andWhere("announcement.createdAt >= :since", { since: queryDto.since });
-  //   }
-
-  //   if (queryDto.publishAt) {
-  //     queryBuilder.andWhere("announcement.publishAt >= :publishAt", { publishAt: queryDto.publishAt });
-  //   }
-
-  //   if (queryDto.q) {
-  //     queryBuilder.andWhere("announcement.title LIKE :q", { q: `%${queryDto.q}%` });
-  //   }
-
-  //   queryBuilder.orderBy("announcement.createdAt", "DESC");
-  //   const rawResults = await queryBuilder.getRawMany();
-
-  //   const [, count] = await queryBuilder.skip(skip).take(limit).getManyAndCount();
-
-  //   const announcements = rawResults.map((raw) => ({
-  //     id: raw.announcement_id,
-  //     createdAt: raw.announcement_createdAt,
-  //     updatedAt: raw.announcement_updatedAt,
-  //     title: raw.announcement_title,
-  //     content: raw.announcement_content,
-  //     publishAt: raw.announcement_publishAt,
-  //     service: {
-  //       id: raw.danak_service_id,
-  //       name: raw.danak_service_name,
-  //     },
-  //     isImportant: raw.announcement_isImportant,
-  //     targetGroups: raw.group_id ? [{ id: raw.group_id, name: raw.group_name }] : [],
-  //     isPublic: raw.announcement_isPublic,
-  //     isRead: raw.userAnnouncements_isRead ? true : false,
-  //   }));
-
-  //   return { announcements, count, paginate: true };
-  // }
-
-  /***************************************** */
-
   async getAllAnnouncementsByUser(queryDto: SearchAnnouncementQueryDto, userId: string) {
     const { limit, skip } = PaginationUtils(queryDto);