424 lines
12 KiB
TypeScript
424 lines
12 KiB
TypeScript
import { HttpException, HttpStatus } from '@nestjs/common';
|
|
import { EntityNotFoundError, IsNull, Repository } from 'typeorm';
|
|
import { Product } from './entities/product.entity';
|
|
import { InjectRepository } from '@nestjs/typeorm';
|
|
import { CreateProductDto } from './dto/product/create-product.dto';
|
|
import { ProductSubCategoriesService } from './product-sub-categories.service';
|
|
import { UpdateProductDto } from './dto/product/update-product.dto';
|
|
import { ProductHistoryPrice } from './entities/product-history-price.entity';
|
|
import { productType } from '../helper/enum-list';
|
|
import { UpdatePriceProductDto } from './dto/product/update-price-product.dto';
|
|
import { UsersService } from '../users/users.service';
|
|
import { SupplierService } from '../users/supplier/supplier.service';
|
|
import { parsingFile } from '../helper/csv-parser';
|
|
import { PartnerService } from '../users/partner/partner.service';
|
|
|
|
export class ProductService {
|
|
constructor(
|
|
@InjectRepository(Product)
|
|
private productRepository: Repository<Product>,
|
|
@InjectRepository(ProductHistoryPrice)
|
|
private productHistoryPrice: Repository<ProductHistoryPrice>,
|
|
private productSubCategoriesService: ProductSubCategoriesService,
|
|
private usersService: UsersService,
|
|
private supplierService: SupplierService,
|
|
private partnerService: PartnerService,
|
|
) {}
|
|
|
|
async create(createProductDto: CreateProductDto) {
|
|
const subCategories = await this.productSubCategoriesService.findOne(
|
|
createProductDto.subCategoriesId,
|
|
);
|
|
|
|
const result = await this.productRepository.insert({
|
|
name: createProductDto.name,
|
|
code: createProductDto.code,
|
|
status: createProductDto.status,
|
|
sub_categories: subCategories,
|
|
price: createProductDto.price,
|
|
});
|
|
|
|
await this.productHistoryPrice.insert({
|
|
product: result.identifiers[0],
|
|
type: productType.NORMAL,
|
|
price: createProductDto.price,
|
|
mark_up_price: createProductDto.markUpPrice,
|
|
startDate: new Date(),
|
|
endDate: null,
|
|
});
|
|
|
|
return this.productRepository.findOneOrFail(result.identifiers[0].id);
|
|
}
|
|
|
|
async processUploadCSV() {
|
|
const data = await parsingFile('');
|
|
data.shift();
|
|
await Promise.all(
|
|
data.map(async (it) => {
|
|
let dataHistoryPrice;
|
|
let partnerData;
|
|
|
|
const subCategories =
|
|
await this.productSubCategoriesService.findOneForCSVParser(it[2]);
|
|
|
|
if (!subCategories) {
|
|
return;
|
|
}
|
|
|
|
const productData = await this.productRepository.findOne({
|
|
code: it[0],
|
|
});
|
|
if (productData) {
|
|
//TODO : Handle Update Product
|
|
productData.name = it[1];
|
|
productData.status = it[5] == 'active' ? 'ACTIVE' : 'NOT ACTIVE';
|
|
await this.productRepository.save(productData);
|
|
|
|
//TODO : Handle History Price
|
|
if (it[6] != '-' && it[6] != '') {
|
|
partnerData = await this.partnerService.findOne(it[6]);
|
|
dataHistoryPrice = await this.productHistoryPrice.findOne({
|
|
product: productData,
|
|
partner: partnerData,
|
|
});
|
|
} else {
|
|
dataHistoryPrice = await this.productHistoryPrice.findOne({
|
|
product: productData,
|
|
});
|
|
}
|
|
|
|
dataHistoryPrice.endDate = new Date();
|
|
await this.productHistoryPrice.save(dataHistoryPrice);
|
|
|
|
await this.productHistoryPrice.insert({
|
|
product: productData,
|
|
mark_up_price: it[4],
|
|
price: it[3],
|
|
type: productType.NORMAL,
|
|
startDate: new Date(),
|
|
endDate: null,
|
|
partner: it[6] != '-' ? partnerData : null,
|
|
});
|
|
} else {
|
|
let partnerData;
|
|
if (it[6] != '-' && it[6] != '') {
|
|
partnerData = await this.partnerService.findOne(it[6]);
|
|
}
|
|
const savedProduct = await this.productRepository.insert({
|
|
name: it[1],
|
|
code: it[0],
|
|
status: it[5] == 'active' ? 'ACTIVE' : 'NOT ACTIVE',
|
|
sub_categories: subCategories,
|
|
});
|
|
|
|
await this.productHistoryPrice.insert({
|
|
product: savedProduct.identifiers[0],
|
|
mark_up_price: it[4],
|
|
price: it[3],
|
|
type: productType.NORMAL,
|
|
startDate: new Date(),
|
|
endDate: null,
|
|
partner: it[6] != '-' ? partnerData : null,
|
|
});
|
|
}
|
|
}),
|
|
);
|
|
|
|
return data;
|
|
}
|
|
|
|
async findAll(
|
|
page: number,
|
|
supplier: string,
|
|
subCategories: string,
|
|
pageSize?: number,
|
|
) {
|
|
let filterSupplier, filterSubCategories;
|
|
|
|
if (supplier) {
|
|
filterSupplier = supplier.split(',').map((data) => {
|
|
return data.trim();
|
|
});
|
|
}
|
|
|
|
if (subCategories) {
|
|
filterSubCategories = subCategories.split(',').map((data) => {
|
|
return data.trim();
|
|
});
|
|
}
|
|
|
|
const baseQuery = this.productRepository
|
|
.createQueryBuilder('product')
|
|
.leftJoin('product.sub_categories', 'sub_categories')
|
|
.leftJoin('sub_categories.category', 'category')
|
|
.leftJoin('product.supplier', 'supplier')
|
|
.where('supplier.status = :status', { status: true })
|
|
.leftJoinAndMapOne(
|
|
'product.currentPrice',
|
|
'product.priceHistory',
|
|
'current_price',
|
|
'current_price.partner_id is null and current_price.end_date is NULL',
|
|
)
|
|
.select(['product.id'])
|
|
.addSelect([
|
|
'product.name',
|
|
'product.code',
|
|
'sub_categories.name',
|
|
'category.name',
|
|
'product.status',
|
|
])
|
|
.addSelect('current_price.price')
|
|
.addSelect(
|
|
'(current_price.price + current_price.mark_up_price) as mark_up_price',
|
|
);
|
|
|
|
if (subCategories && filterSubCategories.length > 0) {
|
|
baseQuery.where('product.sub_categories_id IN (:...subCategoryId)', {
|
|
subCategoryId: filterSubCategories,
|
|
});
|
|
}
|
|
|
|
if (supplier && filterSupplier.length > 0) {
|
|
baseQuery.where('supplier.id IN (:...supplierId)', {
|
|
supplierId: filterSupplier,
|
|
});
|
|
}
|
|
|
|
const data = await baseQuery
|
|
.offset(page * (pageSize || 10))
|
|
.limit(pageSize || 10)
|
|
.getRawMany();
|
|
|
|
const totalData = await baseQuery.getCount();
|
|
|
|
return {
|
|
data,
|
|
count: totalData,
|
|
};
|
|
}
|
|
|
|
async findAllByCategories(page, subCategories, supplier) {
|
|
const baseQuery = this.productRepository
|
|
.createQueryBuilder('product')
|
|
.leftJoin('product.sub_categories', 'sub_categories')
|
|
.where(
|
|
'sub_categories.category_id = :id and product.supplier_id = :supplier_id',
|
|
{
|
|
id: subCategories,
|
|
supplier_id: supplier,
|
|
},
|
|
)
|
|
.leftJoinAndMapOne(
|
|
'product.currentPrice',
|
|
'product.priceHistory',
|
|
'current_price',
|
|
'current_price.partner_id is null',
|
|
);
|
|
|
|
const data = await baseQuery
|
|
.skip(page * 10)
|
|
.take(10)
|
|
.getMany();
|
|
|
|
const totalData = await baseQuery.getCount();
|
|
|
|
return {
|
|
data,
|
|
count: totalData,
|
|
};
|
|
}
|
|
|
|
async findAllBySubCategories(page, subCategories, supplier, pageSize?) {
|
|
if (supplier != 'null' && !supplier) {
|
|
supplier = (await this.supplierService.findByActive()).id;
|
|
}
|
|
|
|
const baseQuery = this.productRepository
|
|
.createQueryBuilder('product')
|
|
.leftJoin('product.sub_categories', 'sub_categories')
|
|
.where(
|
|
`product.supplier_id = :supplier_id and product.status = 'ACTIVE'`,
|
|
{
|
|
supplier_id: supplier,
|
|
},
|
|
)
|
|
.leftJoinAndMapOne(
|
|
'product.currentPrice',
|
|
'product.priceHistory',
|
|
'current_price',
|
|
'current_price.partner_id is null',
|
|
);
|
|
|
|
if (subCategories != 'null' && subCategories) {
|
|
baseQuery.where('product.sub_categories_id = :id', {
|
|
id: subCategories,
|
|
});
|
|
}
|
|
|
|
const data = await baseQuery
|
|
.skip(page * (pageSize || 10))
|
|
.take(pageSize || 10)
|
|
.getMany();
|
|
|
|
const totalData = await baseQuery.getCount();
|
|
|
|
return {
|
|
data,
|
|
count: totalData,
|
|
};
|
|
}
|
|
|
|
async findAllForPartner(
|
|
page: number,
|
|
pageSize: number,
|
|
subCategories: string,
|
|
username: string,
|
|
) {
|
|
const user = await this.usersService.findOneByUsername(username);
|
|
const supplier = await this.supplierService.findByActive();
|
|
|
|
let filterSupplier, filterSubCategories;
|
|
|
|
if (subCategories) {
|
|
filterSubCategories = subCategories.split(',').map((data) => data.trim());
|
|
} else {
|
|
throw new HttpException(
|
|
{
|
|
statusCode: HttpStatus.NOT_FOUND,
|
|
error: 'Sub Categories not inlcude',
|
|
},
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
|
|
const baseQuery = this.productRepository
|
|
.createQueryBuilder('product')
|
|
.leftJoin('product.sub_categories', 'sub_categories')
|
|
.where(
|
|
`product.sub_categories_id IN (:...subCategoryId) and product.supplier_id = :supplier_id and product.status = 'ACTIVE'`,
|
|
{
|
|
subCategoryId: filterSubCategories,
|
|
supplier_id: supplier.id,
|
|
},
|
|
)
|
|
.leftJoinAndMapOne(
|
|
'product.currentPrice',
|
|
'product.priceHistory',
|
|
'current_price',
|
|
'current_price.partner_id = :id_partner and current_price.end_date is NULL',
|
|
{
|
|
id_partner: user.partner.id,
|
|
},
|
|
)
|
|
.select(['product.id'])
|
|
.addSelect(['product.name', 'product.code', 'sub_categories.name'])
|
|
.addSelect(
|
|
'(current_price.price + current_price.mark_up_price) as price',
|
|
);
|
|
|
|
const data = await baseQuery
|
|
.offset(page * 10)
|
|
.limit(10)
|
|
.getRawMany();
|
|
|
|
const totalData = await baseQuery.getCount();
|
|
|
|
return {
|
|
data,
|
|
count: totalData,
|
|
};
|
|
}
|
|
|
|
async findOne(code: string) {
|
|
try {
|
|
return await this.productRepository.findOneOrFail({
|
|
relations: ['supplier'],
|
|
where: {
|
|
code: code,
|
|
},
|
|
});
|
|
} catch (e) {
|
|
if (e instanceof EntityNotFoundError) {
|
|
throw new HttpException(
|
|
{
|
|
statusCode: HttpStatus.NOT_FOUND,
|
|
error: 'Product not found',
|
|
},
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
async update(id: string, updateProductDto: UpdateProductDto) {
|
|
try {
|
|
await this.productRepository.findOneOrFail(id);
|
|
} catch (e) {
|
|
if (e instanceof EntityNotFoundError) {
|
|
throw new HttpException(
|
|
{
|
|
statusCode: HttpStatus.NOT_FOUND,
|
|
error: 'Product not found',
|
|
},
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
const subCategories = await this.productSubCategoriesService.findOne(
|
|
updateProductDto.subCategoriesId,
|
|
);
|
|
|
|
const result = await this.productRepository.update(id, {
|
|
name: updateProductDto.name,
|
|
code: updateProductDto.code,
|
|
status: updateProductDto.status,
|
|
sub_categories: subCategories,
|
|
});
|
|
|
|
return this.productRepository.findOneOrFail(id);
|
|
}
|
|
|
|
async updatePrice(
|
|
code: string,
|
|
updatePriceProductDto: UpdatePriceProductDto,
|
|
) {
|
|
const product = await this.findOne(code);
|
|
|
|
await this.productHistoryPrice.insert({
|
|
product: product,
|
|
type: updatePriceProductDto.type,
|
|
price: updatePriceProductDto.price,
|
|
mark_up_price: updatePriceProductDto.markUpPrice,
|
|
startDate: updatePriceProductDto.startDate,
|
|
endDate: updatePriceProductDto.endDate,
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
async remove(id: string) {
|
|
try {
|
|
await this.productRepository.findOneOrFail(id);
|
|
} catch (e) {
|
|
if (e instanceof EntityNotFoundError) {
|
|
throw new HttpException(
|
|
{
|
|
statusCode: HttpStatus.NOT_FOUND,
|
|
error: 'Product not found',
|
|
},
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
await this.productRepository.delete(id);
|
|
}
|
|
}
|