mahyargdz
420 lines
15 KiB
TypeScript
Executable File
420 lines
15 KiB
TypeScript
Executable File
import { BadRequestException, HttpException, Injectable, InternalServerErrorException, Logger } from "@nestjs/common";
|
|
import { DataSource, Not } from "typeorm";
|
|
|
|
import { ParamDto } from "../../../common/DTO/param.dto";
|
|
import { CommonMessage, TicketMessageEnum, UserMessage } from "../../../common/enums/message.enum";
|
|
import { DanakService } from "../../danak-services/entities/danak-service.entity";
|
|
import { NotificationsService } from "../../notifications/providers/notifications.service";
|
|
import { User } from "../../users/entities/user.entity";
|
|
import { UsersService } from "../../users/providers/users.service";
|
|
import { PaginationUtils } from "../../utils/providers/pagination.utils";
|
|
import { CreateTicketCategoryDto } from "../DTO/create-ticket-category.dto";
|
|
import { CreateTicketMessageDto } from "../DTO/create-ticket-message.dto";
|
|
import { CreateTicketDto } from "../DTO/create-ticket.dto";
|
|
import { SearchTicketCategoryDto } from "../DTO/search-ticket-category.dto";
|
|
import { SearchTicketQueryDto } from "../DTO/search-ticket-query.dto";
|
|
import { UpdateTicketCategoryDto } from "../DTO/update-ticket-category.dto";
|
|
import { TicketCategory } from "../entities/ticket-category.entity";
|
|
import { TicketMessageAttachment } from "../entities/ticket-message-attachment";
|
|
import { TicketMessage } from "../entities/ticket-message.entity";
|
|
import { Ticket } from "../entities/ticket.entity";
|
|
import { TicketStatus } from "../enums/ticket-status.enum";
|
|
import { TicketCategoryRepository } from "../repositories/tickets-category.repository";
|
|
import { TicketMessagesRepository } from "../repositories/tickets-message.repository";
|
|
import { TicketsRepository } from "../repositories/tickets.repository";
|
|
|
|
@Injectable()
|
|
export class TicketsService {
|
|
private readonly logger = new Logger(TicketsService.name);
|
|
constructor(
|
|
private readonly notificationsService: NotificationsService,
|
|
private readonly ticketsCategoryRepository: TicketCategoryRepository,
|
|
private readonly ticketsRepository: TicketsRepository,
|
|
private readonly ticketMessagesRepository: TicketMessagesRepository,
|
|
private readonly usersService: UsersService,
|
|
private dataSource: DataSource,
|
|
) {}
|
|
//******************************** */
|
|
async getTicketCategories() {
|
|
const ticketCategories = await this.ticketsCategoryRepository.find({});
|
|
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, paginate: true };
|
|
}
|
|
//******************************** */
|
|
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(createDto: CreateTicketDto, userId: string) {
|
|
const queryRunner = this.dataSource.createQueryRunner();
|
|
await queryRunner.connect();
|
|
await queryRunner.startTransaction();
|
|
try {
|
|
let service;
|
|
const user = await this.usersService.findOneByIdWithQueryRunner(userId, queryRunner);
|
|
|
|
const ticketCategory = await queryRunner.manager.findOne(TicketCategory, {
|
|
where: { id: createDto.categoryId },
|
|
relations: { group: { users: true } },
|
|
});
|
|
if (!ticketCategory) throw new BadRequestException(TicketMessageEnum.CATEGORY_NOT_FOUND);
|
|
|
|
const { attachmentUrls } = createDto;
|
|
|
|
//
|
|
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 (attachmentUrls?.length) {
|
|
ticketMessage.attachments = 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);
|
|
|
|
const assignedUser = await this.autoAssignUser(ticketCategory);
|
|
//send notification to assignedUser
|
|
if (assignedUser) {
|
|
ticket.assignedTo = assignedUser;
|
|
await queryRunner.manager.save(Ticket, ticket);
|
|
await this.notificationsService.createAssignTicketNotificationForAdmin(
|
|
assignedUser.id,
|
|
{
|
|
ticketId: ticket.numericId.toString(),
|
|
subject: ticket.subject,
|
|
date: ticket.createdAt,
|
|
userPhone: user.phone,
|
|
userEmail: user.email,
|
|
user: `${user.firstName} ${user.lastName}`,
|
|
},
|
|
queryRunner,
|
|
);
|
|
}
|
|
|
|
await this.notificationsService.createTicketNotification(
|
|
userId,
|
|
{
|
|
ticketId: ticket.numericId.toString(),
|
|
subject: ticket.subject,
|
|
date: ticket.createdAt,
|
|
userPhone: user.phone,
|
|
userEmail: user.email,
|
|
},
|
|
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 getTickets(queryDto: SearchTicketQueryDto, userId: string) {
|
|
const { limit, skip } = PaginationUtils(queryDto);
|
|
|
|
const findOptions = {
|
|
where: {
|
|
user: { id: userId },
|
|
...(queryDto.status ? { status: queryDto.status } : { status: Not(TicketStatus.CLOSED) }),
|
|
},
|
|
relations: {
|
|
category: true,
|
|
danakService: true,
|
|
},
|
|
select: {
|
|
id: true,
|
|
subject: true,
|
|
status: true,
|
|
priority: true,
|
|
numericId: true,
|
|
createdAt: true,
|
|
updatedAt: true,
|
|
category: {
|
|
id: true,
|
|
title: true,
|
|
},
|
|
danakService: {
|
|
id: true,
|
|
name: true,
|
|
},
|
|
},
|
|
order: {
|
|
createdAt: "DESC" as const,
|
|
},
|
|
skip,
|
|
take: limit,
|
|
};
|
|
|
|
const [tickets, count] = await this.ticketsRepository.findAndCount(findOptions);
|
|
|
|
return { tickets, count, paginate: true };
|
|
}
|
|
//******************************** */
|
|
async getTicketForAdmin(queryDto: SearchTicketQueryDto, adminId: string) {
|
|
const { limit, skip } = PaginationUtils(queryDto);
|
|
|
|
const isSuperAdmin = await this.usersService.isSuperAdmin(adminId);
|
|
|
|
const queryBuilder = this.ticketsRepository
|
|
.createQueryBuilder("ticket")
|
|
.leftJoinAndSelect("ticket.category", "category")
|
|
.leftJoinAndSelect("ticket.user", "user")
|
|
.leftJoinAndSelect("ticket.assignedTo", "assignedTo")
|
|
.leftJoinAndSelect("ticket.danakService", "danakService")
|
|
.orderBy("ticket.createdAt", "DESC");
|
|
|
|
if (!isSuperAdmin) {
|
|
queryBuilder.andWhere("ticket.assignedToId = :adminId", { adminId });
|
|
}
|
|
|
|
if (queryDto.status) {
|
|
queryBuilder.andWhere("ticket.status = :status", { status: queryDto.status });
|
|
}
|
|
|
|
if (queryDto.userId) {
|
|
queryBuilder.andWhere("user.id = :userId", { userId: queryDto.userId });
|
|
}
|
|
|
|
const [tickets, count] = await queryBuilder.skip(skip).take(limit).getManyAndCount();
|
|
|
|
return { tickets, count, paginate: true };
|
|
}
|
|
|
|
//******************************** */
|
|
|
|
async createTicketMessage(ticketId: string, createDto: CreateTicketMessageDto, userId: string, isAdmin: boolean) {
|
|
const queryRunner = this.dataSource.createQueryRunner();
|
|
await queryRunner.connect();
|
|
await queryRunner.startTransaction();
|
|
|
|
try {
|
|
let ticket: null | Ticket = null;
|
|
|
|
if (isAdmin) {
|
|
ticket = await queryRunner.manager.findOne(Ticket, { where: { id: ticketId }, relations: { user: true } });
|
|
} else {
|
|
ticket = await queryRunner.manager.findOne(Ticket, { where: { id: ticketId, user: { id: userId } }, relations: { user: true } });
|
|
}
|
|
|
|
if (!ticket) throw new BadRequestException(TicketMessageEnum.TICKET_NOT_FOUND);
|
|
|
|
if (ticket.status === TicketStatus.CLOSED) throw new BadRequestException(TicketMessageEnum.TICKET_CLOSED);
|
|
|
|
const user = await queryRunner.manager.findOneBy(User, { id: userId });
|
|
if (!user) throw new BadRequestException(UserMessage.USER_NOT_FOUND);
|
|
|
|
const ticketMessage = queryRunner.manager.create(TicketMessage, { ...createDto, author: user, ticket });
|
|
|
|
if (isAdmin && ticket.status === TicketStatus.PENDING) {
|
|
ticket.status = TicketStatus.ANSWERED;
|
|
} else if (!isAdmin && ticket.status === TicketStatus.ANSWERED) {
|
|
ticket.status = TicketStatus.PENDING;
|
|
}
|
|
|
|
await queryRunner.manager.save(Ticket, ticket);
|
|
await queryRunner.manager.save(TicketMessage, ticketMessage);
|
|
|
|
if (createDto.attachmentUrls) {
|
|
const attachments = createDto.attachmentUrls.map((url) =>
|
|
queryRunner.manager.create(TicketMessageAttachment, { attachmentUrl: url, ticketMessage }),
|
|
);
|
|
await queryRunner.manager.save(TicketMessageAttachment, attachments);
|
|
}
|
|
|
|
if (isAdmin) {
|
|
await this.notificationsService.createAnswerTicketNotification(
|
|
ticket.user.id,
|
|
{
|
|
ticketId: ticket.numericId.toString(),
|
|
subject: ticket.subject,
|
|
date: ticket.createdAt,
|
|
userPhone: user.phone,
|
|
userEmail: user.email,
|
|
},
|
|
queryRunner,
|
|
);
|
|
}
|
|
|
|
await queryRunner.commitTransaction();
|
|
return {
|
|
message: TicketMessageEnum.MESSAGE_CREATED,
|
|
ticketMessage,
|
|
};
|
|
} catch (error) {
|
|
await queryRunner.rollbackTransaction();
|
|
if (error instanceof HttpException) throw error;
|
|
throw new InternalServerErrorException(TicketMessageEnum.ERROR_IN_TICKET_MSG_CREATION);
|
|
} finally {
|
|
await queryRunner.release();
|
|
}
|
|
}
|
|
|
|
//******************************** */
|
|
|
|
async getTicketMessages(ticketId: string, userId: string, isAdmin: boolean) {
|
|
let ticket: null | Ticket = null;
|
|
//
|
|
if (isAdmin) {
|
|
ticket = await this.ticketsRepository.findTicketById(ticketId);
|
|
} else {
|
|
ticket = await this.ticketsRepository.findTicketById(ticketId, userId);
|
|
}
|
|
if (!ticket) throw new BadRequestException(TicketMessageEnum.TICKET_NOT_FOUND);
|
|
|
|
const messages = await this.ticketMessagesRepository.findMessagesByTicketId(ticketId);
|
|
return {
|
|
ticket,
|
|
messages,
|
|
};
|
|
}
|
|
|
|
//******************************** */
|
|
|
|
async closeTicketByUser(ticketId: string, userId: string, isAdmin: boolean) {
|
|
let ticket: null | Ticket = null;
|
|
|
|
if (isAdmin) {
|
|
ticket = await this.ticketsRepository.findTicketById(ticketId);
|
|
} else {
|
|
ticket = await this.ticketsRepository.findTicketById(ticketId, userId);
|
|
}
|
|
|
|
if (!ticket) throw new BadRequestException(TicketMessageEnum.TICKET_NOT_FOUND);
|
|
|
|
ticket.status = TicketStatus.CLOSED;
|
|
await this.ticketsRepository.save(ticket);
|
|
|
|
return {
|
|
message: TicketMessageEnum.CLOSED,
|
|
};
|
|
}
|
|
|
|
//******************************** */
|
|
|
|
async getUnreadTickets() {
|
|
const unreadTickets = await this.ticketsRepository.count({
|
|
where: {
|
|
status: TicketStatus.PENDING,
|
|
},
|
|
});
|
|
return unreadTickets;
|
|
}
|
|
|
|
//******************************** */
|
|
async countUserTickets(userId: string) {
|
|
const ticketCount = await this.ticketsRepository.count({
|
|
where: {
|
|
user: { id: userId },
|
|
status: Not(TicketStatus.CLOSED),
|
|
},
|
|
});
|
|
return ticketCount;
|
|
}
|
|
|
|
//******************************** */
|
|
async autoAssignUser(category: TicketCategory): Promise<User | null> {
|
|
if (!category.group) return null;
|
|
|
|
const { users } = await this.usersService.getUsersByGroup(category.group.id);
|
|
|
|
if (users.length === 0) return null;
|
|
|
|
users.sort((a, b) => (a.tickets.length || 0) - (b.tickets.length || 0));
|
|
|
|
return users[0];
|
|
}
|
|
}
|