chore: ticket service but not tested

src/modules/tickets/DTO/create-ticket-category.dto.ts

@@ -0,0 +1,28 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsBoolean, IsNotEmpty, IsString, IsUUID, Length } from "class-validator";
+
+import { TicketMessageEnum } from "../../../common/enums/message.enum";
+
+export class CreateTicketCategoryDto {
+  @IsNotEmpty({ message: TicketMessageEnum.TITLE_REQUIRED })
+  @IsString({ message: TicketMessageEnum.TITLE_STRING })
+  @Length(3, 150, { message: TicketMessageEnum.TITLE_LENGTH })
+  @ApiProperty({ description: "Title of the ticket category", example: "فنی", minLength: 3, maxLength: 150 })
+  title: string;
+
+  @IsNotEmpty({ message: TicketMessageEnum.DESCRIPTION_REQUIRED })
+  @IsString({ message: TicketMessageEnum.DESCRIPTION_STRING })
+  @Length(3, 500, { message: TicketMessageEnum.DESCRIPTION_LENGTH })
+  @ApiProperty({ description: "Description of the ticket category", example: "درخواست‌های فنی", minLength: 3, maxLength: 500 })
+  description: string;
+
+  @IsNotEmpty({ message: TicketMessageEnum.USER_GROUP_ID_NOT_EMPTY })
+  @IsUUID("4", { message: TicketMessageEnum.USER_GROUP_ID_SHOULD_BE_UUID })
+  @ApiProperty({ description: "User group ID", example: "123e4567-e89b-12d3-a456-426614174000" })
+  userGroupId: string;
+
+  @IsNotEmpty({ message: TicketMessageEnum.IS_ACTIVE_REQUIRED })
+  @IsBoolean({ message: TicketMessageEnum.IS_ACTIVE_SHOULD_BE_BOOLEAN })
+  @ApiProperty({ description: "Is active", example: true })
+  isActive: boolean;
+}

src/modules/tickets/DTO/create-ticket-service.dto.ts

@@ -0,0 +1,29 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsEnum, IsNotEmpty, IsString, Length } from "class-validator";
+
+import { TicketPriority } from "../enums/ticket-priority.enum";
+
+export class CreateTicketDto {
+  @IsNotEmpty()
+  @IsString()
+  @Length(3, 150)
+  @ApiProperty()
+  title: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @Length(3, 150)
+  @ApiProperty()
+  subject: string;
+
+  @IsNotEmpty()
+  @IsEnum(TicketPriority)
+  @ApiProperty({ enum: TicketPriority, example: TicketPriority.LOW, description: "LOW, MEDIUM, HIGH" })
+  priority: TicketPriority;
+
+  danakServiceId: string;
+
+  categoryId: string;
+
+  message: string;
+}

src/modules/tickets/DTO/search-ticket-category.dto.ts

@@ -0,0 +1,3 @@
+import { CategoryListSearchQueryDto } from "../../danak-services/DTO/category-search-query.dto";
+
+export class SearchTicketCategoryDto extends CategoryListSearchQueryDto {}

src/modules/tickets/DTO/update-ticket-category.dto.ts

@@ -0,0 +1,5 @@
+import { OmitType, PartialType } from "@nestjs/swagger";
+
+import { CreateTicketCategoryDto } from "./create-ticket-category.dto";
+
+export class UpdateTicketCategoryDto extends PartialType(OmitType(CreateTicketCategoryDto, ["userGroupId"])) {}

src/modules/tickets/entities/ticket-category.entity.ts

@@ -1,16 +1,23 @@
-import { Column, Entity, OneToMany } from "typeorm";
+import { Column, Entity, ManyToOne, OneToMany } from "typeorm";
 
 import { Ticket } from "./ticket.entity";
 import { BaseEntity } from "../../../common/entities/base.entity";
+import { UserGroup } from "../../users/entities/user-group.entity";
 
 @Entity()
 export class TicketCategory extends BaseEntity {
   @Column({ type: "varchar", length: 150, nullable: false, unique: true })
-  name: string;
+  title: string;
 
   @Column({ type: "text", nullable: true })
   description: string;
 
+  @Column({ type: "boolean", default: true })
+  isActive: boolean;
+
   @OneToMany(() => Ticket, (ticket) => ticket.category)
   tickets: Ticket[];
+
+  @ManyToOne(() => UserGroup, (group) => group.ticketCategories, { onDelete: "RESTRICT" })
+  group: UserGroup;
 }

src/modules/tickets/entities/ticket-message.entity.ts

@@ -1,6 +1,7 @@
 import { Column, Entity, JoinColumn, ManyToOne } from "typeorm";
-import { BaseEntity } from "../../../common/entities/base.entity";
+
 import { Ticket } from "./ticket.entity";
+import { BaseEntity } from "../../../common/entities/base.entity";
 import { User } from "../../users/entities/user.entity";
 
 @Entity()

src/modules/tickets/entities/ticket.entity.ts

@@ -3,6 +3,7 @@ import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from "typeorm";
 import { TicketCategory } from "./ticket-category.entity";
 import { TicketMessage } from "./ticket-message.entity";
 import { BaseEntity } from "../../../common/entities/base.entity";
+import { DanakService } from "../../danak-services/entities/danak-service.entity";
 import { User } from "../../users/entities/user.entity";
 import { TicketPriority } from "../enums/ticket-priority.enum";
 import { TicketStatus } from "../enums/ticket-status.enum";
@@ -24,7 +25,8 @@ export class Ticket extends BaseEntity {
   @Column({ type: "enum", enum: TicketPriority, nullable: false })
   priority: TicketPriority;
 
-  //TODO:ADD service reference here
+  @ManyToOne(() => DanakService, (danakService) => danakService.tickets, { onDelete: "RESTRICT", nullable: false })
+  danakService: DanakService;
 
   @JoinColumn()
   @ManyToOne(() => User, (user) => user.tickets, { nullable: true })

src/modules/tickets/providers/tickets.service.ts

@@ -1,4 +1,97 @@
-import { Injectable } from "@nestjs/common";
+import { BadRequestException, Injectable } from "@nestjs/common";
+import { Not } from "typeorm";
+
+import { ParamDto } from "../../../common/DTO/param.dto";
+import { CommonMessage, TicketMessageEnum } from "../../../common/enums/message.enum";
+import { UsersService } from "../../users/providers/users.service";
+import { PaginationUtils } from "../../utils/providers/pagination.utils";
+import { CreateTicketCategoryDto } from "../DTO/create-ticket-category.dto";
+import { SearchTicketCategoryDto } from "../DTO/search-ticket-category.dto";
+import { UpdateTicketCategoryDto } from "../DTO/update-ticket-category.dto";
+import { TicketCategoryRepository } from "../repositories/tickets-category.repository";
 
 @Injectable()
-export class TicketsService {}
+export class TicketsService {
+  constructor(
+    private readonly ticketsCategoryRepository: TicketCategoryRepository,
+    private readonly usersService: UsersService,
+  ) {}
+  //******************************** */
+  async getTicketCategories() {
+    const ticketCategories = await this.ticketsCategoryRepository.find({ relations: { group: true } });
+    return {
+      ticketCategories,
+    };
+  }
+  //******************************** */
+
+  async getCategoriesList(queryDto: SearchTicketCategoryDto) {
+    const { limit, skip } = PaginationUtils(queryDto);
+    const queryBuilder = this.ticketsCategoryRepository
+      .createQueryBuilder("category")
+      //   .leftJoinAndSelect("category.group", "group")
+      //   .addSelect(["group.id", "group.name"])
+      .leftJoin("category.group", "group")
+      .addSelect(["group.id", "group.name"])
+      //   .leftJoinAndSelect("group.users", "users")
+      .loadRelationCountAndMap("category.ticketsCount", "category.tickets")
+      .loadRelationCountAndMap("category.usersCount", "group.users");
+
+    if (queryDto.isActive !== undefined) {
+      queryBuilder.andWhere("category.isActive = :isActive", { isActive: queryDto.isActive === 1 });
+    }
+
+    if (queryDto.q) {
+      queryBuilder.where("category.title LIKE :q", { q: `%${queryDto.q}%` });
+    }
+
+    const [categories, count] = await queryBuilder.skip(skip).take(limit).getManyAndCount();
+
+    return { categories, count };
+  }
+  //******************************** */
+  async createTicketCategory(createDto: CreateTicketCategoryDto) {
+    const { userGroup } = await this.usersService.getUserGroupById(createDto.userGroupId);
+    const existCategory = await this.ticketsCategoryRepository.findCategoryByTitle(createDto.title);
+
+    if (existCategory) throw new BadRequestException(TicketMessageEnum.CATEGORY_EXIST);
+    const ticketCategory = this.ticketsCategoryRepository.create({ ...createDto, group: userGroup });
+    await this.ticketsCategoryRepository.save(ticketCategory);
+
+    return {
+      message: TicketMessageEnum.CATEGORY_CREATED,
+    };
+  }
+
+  //******************************** */
+  async updateCategory(paramDto: ParamDto, updateCategoryDto: UpdateTicketCategoryDto) {
+    const category = await this.ticketsCategoryRepository.findCategoryById(paramDto.id);
+    if (!category) throw new BadRequestException(TicketMessageEnum.CATEGORY_NOT_FOUND);
+
+    if (updateCategoryDto.title) {
+      const { title } = updateCategoryDto;
+      const existCategory = await this.ticketsCategoryRepository.findOneBy({ title, id: Not(paramDto.id) });
+      if (existCategory) throw new BadRequestException(TicketMessageEnum.CATEGORY_EXIST);
+    }
+    await this.ticketsCategoryRepository.save({ ...category, ...updateCategoryDto });
+
+    return {
+      message: CommonMessage.UPDATE_SUCCESS,
+    };
+  }
+  //******************************** */
+  async toggleCategoryStatus(paramDto: ParamDto) {
+    const category = await this.ticketsCategoryRepository.findCategoryById(paramDto.id);
+    if (!category) throw new BadRequestException(TicketMessageEnum.CATEGORY_NOT_FOUND);
+    category.isActive = !category.isActive;
+    await this.ticketsCategoryRepository.save(category);
+    return {
+      message: CommonMessage.UPDATE_SUCCESS,
+      isActive: category.isActive,
+    };
+  }
+
+  //******************************** */
+
+  async createTicket() {}
+}

src/modules/tickets/repositories/tickets-category.repository.ts

@@ -1,11 +1,20 @@
+import { Injectable } from "@nestjs/common";
 import { InjectRepository } from "@nestjs/typeorm";
 import { Repository } from "typeorm";
+
 import { TicketCategory } from "../entities/ticket-category.entity";
-import { Injectable } from "@nestjs/common";
 
 @Injectable()
 export class TicketCategoryRepository extends Repository<TicketCategory> {
   constructor(@InjectRepository(TicketCategory) ticketCategoryRepository: Repository<TicketCategory>) {
     super(ticketCategoryRepository.target, ticketCategoryRepository.manager, ticketCategoryRepository.queryRunner);
   }
+
+  async findCategoryByTitle(title: string): Promise<TicketCategory | null> {
+    return this.findOneBy({ title });
+  }
+
+  async findCategoryById(id: string): Promise<TicketCategory | null> {
+    return this.findOneBy({ id });
+  }
 }

src/modules/tickets/repositories/tickets-message.repository.ts

@@ -1,7 +1,8 @@
+import { Injectable } from "@nestjs/common";
 import { InjectRepository } from "@nestjs/typeorm";
 import { Repository } from "typeorm";
+
 import { TicketMessage } from "../entities/ticket-message.entity";
-import { Injectable } from "@nestjs/common";
 
 @Injectable()
 export class TicketMessagesRepository extends Repository<TicketMessage> {

src/modules/tickets/repositories/tickets.repository.ts

@@ -1,7 +1,8 @@
-import { Repository } from "typeorm";
-import { Ticket } from "../entities/ticket.entity";
 import { Injectable } from "@nestjs/common";
 import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+
+import { Ticket } from "../entities/ticket.entity";
 
 @Injectable()
 export class TicketsRepository extends Repository<Ticket> {

src/modules/tickets/tickets.controller.ts

@@ -1,10 +1,60 @@
-import { Controller } from "@nestjs/common";
-import { ApiTags } from "@nestjs/swagger";
+import { Body, Controller, Get, HttpCode, HttpStatus, Param, Patch, Post, Query } from "@nestjs/common";
+import { ApiOperation, ApiTags } from "@nestjs/swagger";
 
-// import { TicketsService } from "./providers/tickets.service";
+import { CreateTicketCategoryDto } from "./DTO/create-ticket-category.dto";
+import { SearchTicketCategoryDto } from "./DTO/search-ticket-category.dto";
+import { UpdateTicketCategoryDto } from "./DTO/update-ticket-category.dto";
+import { TicketsService } from "./providers/tickets.service";
+import { AuthGuards } from "../../common/decorators/auth-guard.decorator";
+import { Pagination } from "../../common/decorators/pagination.decorator";
+import { Roles } from "../../common/decorators/roles.decorator";
+import { ParamDto } from "../../common/DTO/param.dto";
+import { RoleEnum } from "../users/enums/role.enum";
 
 @Controller("tickets")
 @ApiTags("Tickets")
 export class TicketsController {
-  // constructor(private readonly ticketsService: TicketsService) {}
+  constructor(private readonly ticketsService: TicketsService) {}
+
+  @ApiOperation({ summary: "Create ticket category => admin route" })
+  @AuthGuards()
+  @Roles(RoleEnum.ADMIN)
+  @Post("category")
+  createTicketCategory(@Body() createDto: CreateTicketCategoryDto) {
+    return this.ticketsService.createTicketCategory(createDto);
+  }
+
+  @ApiOperation({ summary: "Update ticket category => admin route" })
+  @AuthGuards()
+  @Roles(RoleEnum.ADMIN)
+  @Patch("category/:id")
+  updateCategory(@Param() paramDto: ParamDto, @Body() updateCategoryDto: UpdateTicketCategoryDto) {
+    return this.ticketsService.updateCategory(paramDto, updateCategoryDto);
+  }
+
+  @ApiOperation({ summary: "Get ticket categories => admin route" })
+  @AuthGuards()
+  @Roles(RoleEnum.ADMIN)
+  @Get("categories")
+  getTicketCategories() {
+    return this.ticketsService.getTicketCategories();
+  }
+
+  @ApiOperation({ summary: "Get ticket categories list => admin route" })
+  @Pagination()
+  @AuthGuards()
+  @Roles(RoleEnum.ADMIN)
+  @Get("categories-list")
+  getCategoriesList(@Query() queryDto: SearchTicketCategoryDto) {
+    return this.ticketsService.getCategoriesList(queryDto);
+  }
+
+  @ApiOperation({ summary: "toggle status of categories => admin route" })
+  @AuthGuards()
+  @Roles(RoleEnum.ADMIN)
+  @HttpCode(HttpStatus.OK)
+  @Post("category/toggle-status/:id")
+  toggleCategoryStatus(@Param() paramDto: ParamDto) {
+    return this.ticketsService.toggleCategoryStatus(paramDto);
+  }
 }

src/modules/tickets/tickets.module.ts

@@ -2,16 +2,17 @@ import { Module } from "@nestjs/common";
 import { TypeOrmModule } from "@nestjs/typeorm";
 
 import { TicketCategory } from "./entities/ticket-category.entity";
-import { Ticket } from "./entities/ticket.entity";
-import { TicketsController } from "./tickets.controller";
-import { TicketsService } from "./providers/tickets.service";
 import { TicketMessage } from "./entities/ticket-message.entity";
-import { TicketsRepository } from "./repositories/tickets.repository";
+import { Ticket } from "./entities/ticket.entity";
+import { TicketsService } from "./providers/tickets.service";
 import { TicketCategoryRepository } from "./repositories/tickets-category.repository";
 import { TicketMessagesRepository } from "./repositories/tickets-message.repository";
+import { TicketsRepository } from "./repositories/tickets.repository";
+import { TicketsController } from "./tickets.controller";
+import { UsersModule } from "../users/users.module";
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Ticket, TicketCategory, TicketMessage])],
+  imports: [TypeOrmModule.forFeature([Ticket, TicketCategory, TicketMessage]), UsersModule],
   providers: [TicketsService, TicketsRepository, TicketCategoryRepository, TicketMessagesRepository],
   controllers: [TicketsController],
   exports: [TypeOrmModule, TicketsService, TicketsRepository, TicketCategoryRepository, TicketMessagesRepository],