130 lines
3.4 KiB
TypeScript
130 lines
3.4 KiB
TypeScript
import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
|
|
import { EntityManager } from '@mikro-orm/postgresql';
|
|
import { RequiredEntityData } from '@mikro-orm/core';
|
|
import { FieldRepository } from '../repository/field.repository';
|
|
import { Field } from '../entities/field.entity';
|
|
import { CreateFieldDto } from '../dto/create-field.dto';
|
|
import { UpdateFieldDto } from '../dto/update-field.dto';
|
|
import { EntityType } from '../interface/print';
|
|
import { Product } from 'src/modules/product/entities/product.entity';
|
|
import { PrintForm } from 'src/modules/print-form/entities/print-form.entity';
|
|
import { ProductService } from 'src/modules/product/providers/product.service';
|
|
import { PrintFormService } from 'src/modules/print-form/provider/print-form.service';
|
|
import { FindFieldsGroupDto } from '../dto/find-field-group.dto';
|
|
|
|
|
|
@Injectable()
|
|
export class FieldService {
|
|
|
|
constructor(
|
|
private readonly fieldRepository: FieldRepository,
|
|
private readonly productService: ProductService,
|
|
private readonly printFormService: PrintFormService,
|
|
private readonly em: EntityManager,
|
|
) { }
|
|
|
|
async create(entityId: string, dto: CreateFieldDto) {
|
|
const { entityType, isRequired, multiple, name, type, order } = dto
|
|
|
|
let entity: null | Product | PrintForm = null
|
|
|
|
if (entityType == EntityType.product) {
|
|
entity = await this.productService.findOneOrFail(entityId)
|
|
} else if (entityType == EntityType.printForm) {
|
|
entity = await this.printFormService.finOrFail(entityId)
|
|
}
|
|
|
|
if (!entity) {
|
|
throw new BadRequestException("Entity not Found")
|
|
}
|
|
|
|
const data: RequiredEntityData<Field> = {
|
|
name,
|
|
order,
|
|
type,
|
|
isRequired,
|
|
multiple,
|
|
entityId: entity.id,
|
|
entityType
|
|
};
|
|
|
|
const field = this.fieldRepository.create({
|
|
name,
|
|
order,
|
|
type,
|
|
isRequired,
|
|
multiple,
|
|
entityId: entity.id,
|
|
entityType
|
|
})
|
|
|
|
await this.em.persistAndFlush(field)
|
|
|
|
return field
|
|
|
|
}
|
|
|
|
async update(fieldId: string, dto: UpdateFieldDto) {
|
|
|
|
const field = await this.fieldRepository.findOne({ id: fieldId })
|
|
|
|
if (!field) {
|
|
throw new NotFoundException('Field not found');
|
|
}
|
|
|
|
this.fieldRepository.assign(field, dto)
|
|
|
|
this.em.persistAndFlush(field)
|
|
|
|
return field
|
|
|
|
}
|
|
|
|
findAll(entityId: string) {
|
|
return this.fieldRepository.find({
|
|
entityId,
|
|
},
|
|
{ populate: ['options'], orderBy: { order: 'ASC' } });
|
|
}
|
|
|
|
async findAllByIds(dto: FindFieldsGroupDto) {
|
|
const fields = await this.fieldRepository.find({
|
|
entityId: { $in: dto.entityIds }
|
|
},
|
|
{ populate: ['options'] },
|
|
);
|
|
|
|
// const fieldMap = new Map(fields.map(f => [f.entityId, f]))
|
|
|
|
const result: { entityId: number, fields: Field[] }[] = []
|
|
|
|
fields.forEach(field => {
|
|
if (!result.find((r => r.entityId == Number(field.entityId)))) {
|
|
result.push({
|
|
entityId: Number(field.entityId),
|
|
fields: fields.filter(f => f.entityId == field.entityId)
|
|
})
|
|
}
|
|
})
|
|
|
|
return result
|
|
}
|
|
|
|
async findById(fieldId: string): Promise<Field> {
|
|
const field = await this.fieldRepository.findOne({ id: fieldId },
|
|
{ populate: [] });
|
|
|
|
if (!field) throw new NotFoundException('Field not found');
|
|
return field;
|
|
}
|
|
|
|
async remove(id: string): Promise<void> {
|
|
const field = await this.findById(id);
|
|
|
|
field.deletedAt = new Date();
|
|
return await this.em.persistAndFlush(field);
|
|
|
|
}
|
|
|
|
}
|