134 lines
3.7 KiB
TypeScript
134 lines
3.7 KiB
TypeScript
import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
|
|
import { InjectRepository } from '@nestjs/typeorm';
|
|
import { Repository } from 'typeorm';
|
|
import { Service } from '../entities/service.entity';
|
|
import { CreateServiceDto, UpdateServiceDto, QueryServiceDto } from './dto/service.dto';
|
|
|
|
@Injectable()
|
|
export class ServiceService {
|
|
constructor(
|
|
@InjectRepository(Service)
|
|
private serviceRepository: Repository<Service>,
|
|
) {}
|
|
|
|
async create(createServiceDto: CreateServiceDto): Promise<Service> {
|
|
// 检查服务类型是否已存在
|
|
const existingService = await this.serviceRepository.findOne({
|
|
where: { type: createServiceDto.type }
|
|
});
|
|
|
|
if (existingService) {
|
|
throw new ConflictException('该服务类型已存在');
|
|
}
|
|
|
|
const service = this.serviceRepository.create({
|
|
...createServiceDto,
|
|
status: 'active',
|
|
});
|
|
|
|
return this.serviceRepository.save(service);
|
|
}
|
|
|
|
async findAll(query: QueryServiceDto): Promise<any> {
|
|
const { type, status, keyword } = query;
|
|
const queryBuilder = this.serviceRepository.createQueryBuilder('service');
|
|
|
|
if (type) {
|
|
queryBuilder.andWhere('service.type = :type', { type });
|
|
}
|
|
|
|
if (status) {
|
|
queryBuilder.andWhere('service.status = :status', { status });
|
|
}
|
|
|
|
if (keyword) {
|
|
queryBuilder.andWhere(
|
|
'(service.name LIKE :keyword OR service.description LIKE :keyword)',
|
|
{ keyword: `%${keyword}%` }
|
|
);
|
|
}
|
|
|
|
queryBuilder.orderBy('service.sortOrder', 'ASC');
|
|
queryBuilder.addOrderBy('service.createdAt', 'DESC');
|
|
|
|
const services = await queryBuilder.getMany();
|
|
|
|
return {
|
|
list: services,
|
|
total: services.length
|
|
};
|
|
}
|
|
|
|
async findOne(id: number): Promise<Service> {
|
|
const service = await this.serviceRepository.findOne({
|
|
where: { id }
|
|
});
|
|
|
|
if (!service) {
|
|
throw new NotFoundException('服务不存在');
|
|
}
|
|
|
|
return service;
|
|
}
|
|
|
|
async findByType(type: string): Promise<Service> {
|
|
const service = await this.serviceRepository.findOne({
|
|
where: { type }
|
|
});
|
|
|
|
if (!service) {
|
|
throw new NotFoundException('服务类型不存在');
|
|
}
|
|
|
|
return service;
|
|
}
|
|
|
|
async update(id: number, updateServiceDto: UpdateServiceDto): Promise<Service> {
|
|
const service = await this.findOne(id);
|
|
|
|
// 如果要更新服务类型，检查新类型是否已被其他服务使用
|
|
if (updateServiceDto.type && updateServiceDto.type !== service.type) {
|
|
const existingService = await this.serviceRepository.findOne({
|
|
where: { type: updateServiceDto.type }
|
|
});
|
|
|
|
if (existingService) {
|
|
throw new ConflictException('该服务类型已存在');
|
|
}
|
|
}
|
|
|
|
await this.serviceRepository.update(id, updateServiceDto);
|
|
return this.findOne(id);
|
|
}
|
|
|
|
async remove(id: number): Promise<void> {
|
|
const service = await this.findOne(id);
|
|
await this.serviceRepository.remove(service);
|
|
}
|
|
|
|
async getActiveServices(): Promise<any> {
|
|
const services = await this.serviceRepository.find({
|
|
where: { status: 'active' },
|
|
order: { sortOrder: 'ASC', createdAt: 'DESC' }
|
|
});
|
|
|
|
return {
|
|
list: services,
|
|
total: services.length
|
|
};
|
|
}
|
|
|
|
async updateSortOrder(serviceOrders: { id: number; sortOrder: number }[]): Promise<void> {
|
|
for (const { id, sortOrder } of serviceOrders) {
|
|
await this.serviceRepository.update(id, { sortOrder });
|
|
}
|
|
}
|
|
|
|
async toggleStatus(id: number): Promise<Service> {
|
|
const service = await this.findOne(id);
|
|
const newStatus = service.status === 'active' ? 'inactive' : 'active';
|
|
|
|
await this.serviceRepository.update(id, { status: newStatus });
|
|
return this.findOne(id);
|
|
}
|
|
} |