danak/negareh-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update ticket

Browse Source
This commit is contained in:
morteza-mortezai
2026-01-21 19:37:54 +03:30
parent 6c7dfbef1f
commit 9e233cd81a
5 changed files with 70 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/modules/ticket/providers/tickets.service.ts
+37 -267
View File
@@ -10,6 +10,8 @@ import { UserRepository } from "src/modules/user/repositories/user.repository";
import { AdminRepository } from "src/modules/admin/repositories/admin.repository";
import { Admin } from "src/modules/admin/entities/admin.entity";
import { FindTicketQueryDto } from "../DTO/search-ticket-query.dto";
import { EntityManager } from "@mikro-orm/postgresql";
import { UpdateTicketDto } from "../DTO/update-ticket.dto";
@Injectable()
@@ -21,7 +23,7 @@ export class TicketService {
private readonly orderRepository: OrderRepository,
private readonly userRepository: UserRepository,
private readonly adminRepository: AdminRepository,
// private readonly adminsService: AdminsService,
private readonly em: EntityManager,
) { }
async createTicket(orderId: string, dto: CreateTicketDto, userId?: string, adminId?: string) {
@@ -67,271 +69,6 @@ export class TicketService {
return ticket
}
// async onModuleInit() {
// await this.scheduleAutoCloseJob();
// }
// //******************************** */
// async getTicketCategories() {
// const ticketCategories = await this.ticketsCategoryRepository.find({});
// return {
// ticketCategories,
// };
// }
// //******************************** */
// async getCategoriesList(queryDto: SearchTicketCategoryDto) {
// const [categories, count] = await this.ticketsCategoryRepository.findCategoriesList(queryDto);
// return { categories, count, paginate: true };
// }
// //******************************** */
// async createTicketCategory(createDto: CreateTicketCategoryDto, userIpAndHeaders: IUserIpAndHeaders) {
// 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);
// await this.accessLogService.logCreate("TicketCategory", UserType.ADMIN, {
// user: { id: userIpAndHeaders.userId },
// endpoint: "/tickets/categories",
// requestId: userIpAndHeaders.headers["x-request-id"],
// ipAddress: userIpAndHeaders.ip,
// userAgent: userIpAndHeaders.headers["user-agent"],
// actionDescription: `Admin created ticket category: ${createDto.title}`,
// metadata: {
// categoryId: ticketCategory.id,
// categoryTitle: ticketCategory.title,
// },
// });
// return {
// message: TicketMessageEnum.CATEGORY_CREATED,
// };
// }
// //******************************** */
// async updateCategory(paramDto: ParamDto, updateCategoryDto: UpdateTicketCategoryDto, userIpAndHeaders: IUserIpAndHeaders) {
// 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,
// });
// await this.accessLogService.logUpdate("TicketCategory", paramDto.id, UserType.ADMIN, {
// user: { id: userIpAndHeaders.userId },
// endpoint: "/tickets/categories",
// requestId: userIpAndHeaders.headers["x-request-id"],
// ipAddress: userIpAndHeaders.ip,
// userAgent: userIpAndHeaders.headers["user-agent"],
// actionDescription: `Admin updated ticket category: ${category.title}`,
// metadata: {
// categoryId: category.id,
// categoryTitle: category.title,
// },
// oldValues: JSON.stringify({ ...category }),
// newValues: JSON.stringify({ ...updateCategoryDto }),
// });
// return {
// message: CommonMessage.UPDATE_SUCCESS,
// };
// }
// //******************************** */
// async toggleCategoryStatus(paramDto: ParamDto, userIpAndHeaders: IUserIpAndHeaders) {
// 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);
// //
// await this.accessLogService.logUpdate("TicketCategory", paramDto.id, UserType.ADMIN, {
// user: { id: userIpAndHeaders.userId },
// endpoint: "/tickets/categories",
// requestId: userIpAndHeaders.headers["x-request-id"],
// ipAddress: userIpAndHeaders.ip,
// userAgent: userIpAndHeaders.headers["user-agent"],
// actionDescription: `Admin toggled ticket category status: ${category.title}`,
// metadata: {
// categoryId: category.id,
// categoryTitle: category.title,
// isActive: category.isActive,
// },
// });
// return {
// message: CommonMessage.UPDATE_SUCCESS,
// isActive: category.isActive,
// };
// }
// //******************************** */
// private async checkTicketLimit(userId: string, queryRunner: QueryRunner): Promise<void> {
// const { userSupportPlan } = await this.supportPlansService.getUserSupportPlanOfUser(userId);
// if (!userSupportPlan) throw new BadRequestException(TicketMessageEnum.NO_ACTIVE_SUPPORT_PLAN);
// const ticketLimitFeature = userSupportPlan.supportPlan.features.find(
// (feature) => feature.featureKey === SupportPlanFeatureKey.TICKET_LIMIT,
// );
// if (!ticketLimitFeature) throw new BadRequestException(TicketMessageEnum.TICKET_LIMIT_NOT_FOUND);
// const ticketLimit = parseInt(ticketLimitFeature.featureValue);
// if (isNaN(ticketLimit)) return;
// const today = dayjs().startOf("day").toDate();
// const ticketCount = await queryRunner.manager.count(this.ticketsRepository.target, {
// where: {
// user: { id: userId },
// createdAt: MoreThanOrEqual(today),
// },
// });
// if (ticketCount >= ticketLimit) throw new BadRequestException(TicketMessageEnum.TICKET_LIMIT_EXCEEDED);
// }
// //******************************** */
// async createTicket(createDto: CreateTicketDto, userId: string) {
// const queryRunner = this.dataSource.createQueryRunner();
// try {
// await queryRunner.connect();
// await queryRunner.startTransaction();
// const [user, ticketCategory] = await Promise.all([
// this.usersService.findOneByIdWithQueryRunner(userId, queryRunner),
// queryRunner.manager.findOne(TicketCategory, { where: { id: createDto.categoryId }, relations: { group: { users: true } } }),
// ]);
// if (!ticketCategory) throw new BadRequestException(TicketMessageEnum.CATEGORY_NOT_FOUND);
// await this.checkTicketLimit(userId, queryRunner);
// let service = null;
// if (createDto.danakServiceId) {
// service = await queryRunner.manager.findOneBy(DanakService, { id: createDto.danakServiceId });
// if (!service) throw new BadRequestException(TicketMessageEnum.SERVICE_NOT_FOUND);
// }
// const ticketMessage: Partial<TicketMessage> = { content: createDto.message, author: user };
// if (createDto.attachmentUrls?.length) {
// ticketMessage.attachments = createDto.attachmentUrls.map((url) => {
// const attachment = new TicketMessageAttachment();
// attachment.attachmentUrl = url;
// return attachment;
// });
// }
// const ticket = queryRunner.manager.create(Ticket, {
// ...createDto,
// user,
// category: ticketCategory,
// messages: [ticketMessage],
// danakService: service,
// });
// await queryRunner.manager.save(Ticket, ticket);
// await this.assignTicketAndNotify(ticket, ticketCategory, user, queryRunner);
// await queryRunner.commitTransaction();
// return {
// message: TicketMessageEnum.CREATED,
// ticketId: ticket.id,
// };
// } catch (error) {
// this.logger.error("Error in create ticket transaction", error);
// await queryRunner.rollbackTransaction();
// throw error;
// } finally {
// await queryRunner.release();
// }
// }
// //******************************** */
// async createTicketByAdmin(createDto: CreateTicketByAdminDto, userIpAndHeaders: IUserIpAndHeaders) {
// const queryRunner = this.dataSource.createQueryRunner();
// try {
// await queryRunner.connect();
// await queryRunner.startTransaction();
// const [user, admin, ticketCategory] = await Promise.all([
// this.usersService.findOneByIdWithQueryRunner(createDto.userId, queryRunner),
// this.usersService.findOneByIdWithQueryRunner(userIpAndHeaders.userId, queryRunner),
// queryRunner.manager.findOne(TicketCategory, { where: { id: createDto.categoryId }, relations: { group: { users: true } } }),
// ]);
// if (!ticketCategory) throw new BadRequestException(TicketMessageEnum.CATEGORY_NOT_FOUND);
// const ticketMessage: Partial<TicketMessage> = { content: createDto.message, author: admin };
// const ticket = queryRunner.manager.create(Ticket, {
// ...createDto,
// user,
// category: ticketCategory,
// messages: [ticketMessage],
// assignedTo: admin,
// });
// await queryRunner.manager.save(Ticket, ticket);
// await this.notificationQueue.addTicketNotification(user.id, {
// ticketId: ticket.numericId.toString(),
// subject: ticket.subject,
// date: ticket.createdAt,
// userPhone: user.phone,
// userEmail: user.email,
// });
// await this.accessLogService.logCreate("Ticket", UserType.ADMIN, {
// user: { id: userIpAndHeaders.userId },
// endpoint: "/tickets",
// requestId: userIpAndHeaders.headers["x-request-id"],
// ipAddress: userIpAndHeaders.ip,
// userAgent: userIpAndHeaders.headers["user-agent"],
// actionDescription: `Admin created ticket: ${ticket.subject}`,
// metadata: {
// ticketId: ticket.id,
// ticketSubject: ticket.subject,
// },
// });
// await queryRunner.commitTransaction();
// return {
// message: TicketMessageEnum.CREATED,
// ticketId: ticket.id,
// };
// } catch (error) {
// await queryRunner.rollbackTransaction();
// throw error;
// } finally {
// await queryRunner.release();
// }
// }
// //******************************** */
@@ -341,7 +78,7 @@ export class TicketService {
if (!order) {
throw new BadRequestException("order not found!")
}
if(userId){
if (userId) {
if (order.user.id !== userId) {
throw new BadRequestException("This ticket doenst belongs to You !")
}
@@ -350,8 +87,41 @@ export class TicketService {
return data
}
//******************************** */
async deleteTicket(ticketId: string, userId?: string) {
const ticket = await this.ticketsRepository.findOne({ id: ticketId }, { populate: ['order', 'order.user'] })
if (!ticket) {
throw new BadRequestException('ticket not found!')
}
if (userId && ticket.order.user.id !== userId) {
throw new BadRequestException("You can not Delete this Ticket")
}
await this.em.removeAndFlush(ticket)
return true
}
// //******************************** */
async updateTicket(ticketId: string, dto: UpdateTicketDto, userId?: string) {
const ticket = await this.ticketsRepository.findOne({ id: ticketId }, { populate: ['order', 'order.user'] })
if (!ticket) {
throw new BadRequestException('ticket not found!')
}
if (userId && ticket.order.user.id !== userId) {
throw new BadRequestException("You can not Update this Ticket")
}
this.ticketsRepository.assign(ticket, dto, {
onlyProperties: true,
})
await this.em.flush()
return true
}
// //******************************** */