Merge pull request #57 from hivetown/fix/search

RomuloNogueira02 · web-flow · commit 30a2509b563b · 2023-06-18T09:24:49.000+01:00
feat: category product's price and name search
diff --git a/src/controllers/category.ts b/src/controllers/category.ts
@@ -9,6 +9,7 @@ import { NotFoundError } from '../errors/NotFoundError';
 import { UniqueConstraintViolationException } from '@mikro-orm/core';
 import { ConflictError } from '../errors/ConflictError';
 import { Permission } from '../enums/Permission';
+import type { CategoryFilters } from '../interfaces/CategoryFilters';
 
 @Controller('/categories')
 @Injectable()
@@ -17,7 +18,11 @@ export class CategoryController {
 		validate({
 			query: Joi.object({
 				page: Joi.number().min(1),
-				pageSize: Joi.number().min(1)
+				pageSize: Joi.number().min(1),
+				productMinPrice: Joi.number().min(0),
+				productMaxPrice: Joi.number().min(0),
+				productSearch: Joi.string(),
+				parentId: Joi.number().min(1)
 			})
 		})
 	])
@@ -27,7 +32,14 @@ export class CategoryController {
 			size: Number(req.query.pageSize) || -1
 		};
 
-		const items = await container.categoryGateway.findAllRoot(options);
+		const filters: CategoryFilters = {
+			productMinPrice: Number(req.query.productMinPrice) || undefined,
+			productMaxPrice: Number(req.query.productMaxPrice) || undefined,
+			productSearch: req.query.productSearch?.toString() || undefined,
+			parentId: Number(req.query.parentId) || undefined
+		};
+
+		const items = await container.categoryGateway.findAll(filters, options);
 		return res.status(200).json(items);
 	}
 
@@ -114,30 +126,6 @@ export class CategoryController {
 		return res.status(204).send();
 	}
 
-	@Get('/:categoryId/categories', [
-		validate({
-			params: Joi.object({
-				categoryId: Joi.number().min(1).required()
-			}),
-			query: Joi.object({
-				page: Joi.number().min(1),
-				pageSize: Joi.number().min(1)
-			})
-		})
-	])
-	public async categoryCategories(@Response() res: Express.Response, @Params('categoryId') categoryId: number, @Request() req: Express.Request) {
-		const category = await container.categoryGateway.findById(categoryId);
-		if (!category) throw new NotFoundError('Category not found');
-
-		const options: PaginatedOptions = {
-			page: Number(req.query.page) || -1,
-			size: Number(req.query.pageSize) || -1
-		};
-
-		const items = await container.categoryGateway.findAllChildrenOfCategory(categoryId, options);
-		return res.status(200).json(items);
-	}
-
 	@Get('/:categoryId/fields', [
 		validate({
 			params: Joi.object({
diff --git a/src/controllers/products.ts b/src/controllers/products.ts
@@ -26,7 +26,9 @@ export class ProductsController {
 				search: Joi.string().min(3),
 				page: Joi.number().integer().min(1),
 				pageSize: Joi.number().integer().min(1),
-				field: Joi.object().pattern(/^'\d+'$/, Joi.array())
+				field: Joi.object().pattern(/^'\d+'$/, Joi.array()),
+				minPrice: Joi.number().integer().min(0),
+				maxPrice: Joi.number().integer().min(0)
 			})
 		})
 	])
@@ -53,6 +55,14 @@ export class ProductsController {
 			filters.search = { value: req.query.search as string, type: StringSearchType.CONTAINS };
 		}
 
+		if ('minPrice' in req.query) {
+			filters.minPrice = Number(req.query.minPrice);
+		}
+
+		if ('maxPrice' in req.query) {
+			filters.maxPrice = Number(req.query.maxPrice);
+		}
+
 		const options: ProductSpecOptions = {
 			page: Number(req.query.page) || -1,
 			size: Number(req.query.pageSize) || -1
diff --git a/src/gateways/CategoryGateway.ts b/src/gateways/CategoryGateway.ts
@@ -3,6 +3,7 @@ import { Category } from '../entities';
 import type { BaseItems } from '../interfaces/BaseItems';
 import type { PaginatedOptions } from '../interfaces/PaginationOptions';
 import { paginate } from '../utils/paginate';
+import type { CategoryFilters } from '../interfaces/CategoryFilters';
 
 export class CategoryGateway {
 	private repository: EntityRepository<Category>;
@@ -11,36 +12,66 @@ export class CategoryGateway {
 		this.repository = orm.em.getRepository(Category);
 	}
 
-	public async findAllRoot(options: PaginatedOptions): Promise<BaseItems<Category>> {
+	public async findAll(filters: CategoryFilters, options: PaginatedOptions): Promise<BaseItems<Category>> {
 		const pagination = paginate(options);
-		const [categories, totalResults] = await Promise.all([
-			this.repository
-				.createQueryBuilder('category')
-				.where('category.parent_id IS NULL')
-				.leftJoinAndSelect('category.image', 'image')
-				.limit(pagination.limit)
-				.offset(pagination.offset)
-				.getResult(),
-			this.repository.createQueryBuilder('category').where('category.parent_id IS NULL').count()
-		]);
-		return {
-			items: categories,
-			totalItems: totalResults,
-			totalPages: Math.ceil(totalResults / pagination.limit),
-			page: Math.ceil(pagination.offset / pagination.limit) + 1,
-			pageSize: categories.length
-		};
-	}
 
-	public async findAllChildrenOfCategory(categoryId: number, options: PaginatedOptions): Promise<BaseItems<Category>> {
-		const pagination = paginate(options);
-		const [categories, totalResults] = await Promise.all([
-			this.repository.find(
-				{ parent: categoryId },
-				{ fields: ['name', 'parent.name', 'image'], limit: pagination.limit, offset: pagination.offset }
-			),
-			this.repository.count({ parent: categoryId })
-		]);
+		const parentFilterValues = [];
+		if (filters.parentId) parentFilterValues.push(filters.parentId);
+		const parentWhere = `category.parent_id ${parentFilterValues.length ? '= ?' : 'IS NULL'}`;
+		const qb = this.repository.createQueryBuilder('category').where(parentWhere, parentFilterValues);
+
+		if (filters.productMaxPrice || filters.productMinPrice || filters.productSearch) {
+			// Number() to prevent SQL injection
+			const signal = ['>', '<']; // used for mapping
+			const priceQuery = [Number(filters.productMinPrice), Number(filters.productMaxPrice)]
+				.filter((v) => !Number.isNaN(v))
+				.map((v, idx) => `producer_product.current_price ${signal[idx]}= ${v}`)
+				.join(' AND ');
+
+			const productSearchFilterValues = [];
+			if (filters.productSearch) productSearchFilterValues.push(`%${filters.productSearch}%`);
+
+			// We need to check if the current level (children, filhos) meets the criteria
+			// or if any of the children's children (netos) meet the criteria.
+			// We need to show every leaf of the tree, even if the actual leaf does not meet the criteria, for navigation:
+			// we need the *parents to show a child that meets it.
+			void qb.andWhere(
+				// We check if the current category meets the criteria OR has a child that meets the criteria
+				`category.id IN (SELECT product_spec_category.category_id
+					FROM product_spec_category,
+						 producer_product,
+						 product_spec
+					WHERE product_spec_category.product_spec_id = product_spec.id
+					  AND producer_product.product_spec_id = product_spec.id
+					  AND (${priceQuery.length ? `(${priceQuery})` : ''}
+						${productSearchFilterValues.length ? `${priceQuery.length ? 'OR' : ''} product_spec.name LIKE ?` : ''}
+						OR category.id IN (select category_inner.parent_id
+										   from (select *
+												 from category category_inner2
+												 order by parent_id, id) category_inner,
+												(select @pv := category.id) initialisation
+										   where find_in_set(parent_id, @pv) > 0
+													 and @pv :=
+															 concat(@pv, ',', id)
+															 AND category_inner.id IN
+																 (SELECT product_spec_category_inner.category_id
+																  FROM product_spec_category product_spec_category_inner,
+																	   producer_product producer_product_inner,
+																	   product_spec product_spec_inner
+																  WHERE product_spec_category_inner.product_spec_id = product_spec.id
+																	AND producer_product_inner.product_spec_id = product_spec.id
+																	AND (${priceQuery.length ? `(${priceQuery})` : ''}
+																		${productSearchFilterValues.length ? `${priceQuery.length ? 'OR' : ''} product_spec.name LIKE ?` : ''})))))`,
+				// Needs to be duplicated because we use it in two places (children and grandchildren)
+				[...productSearchFilterValues, ...productSearchFilterValues]
+			);
+		}
+
+		const totalResultsQb = qb.clone();
+
+		void qb.leftJoinAndSelect('category.image', 'image').limit(pagination.limit).offset(pagination.offset);
+
+		const [categories, totalResults] = await Promise.all([qb.getResult(), totalResultsQb.count()]);
 		return {
 			items: categories,
 			totalItems: totalResults,
diff --git a/src/gateways/ProductSpecGateway.ts b/src/gateways/ProductSpecGateway.ts
@@ -1,4 +1,4 @@
-import type { EntityRepository, MikroORM, QueryBuilder } from '@mikro-orm/mysql';
+import type { EntityRepository, MikroORM, QueryBuilder, SelectQueryBuilder } from '@mikro-orm/mysql';
 import { isEmpty } from 'lodash';
 import { ProductSpec } from '../entities';
 import type { BaseItems } from '../interfaces/BaseItems';
@@ -22,12 +22,40 @@ export class ProductSpecGateway {
 		return this.repository.removeAndFlush(productSpec);
 	}
 
-	public async findAll(filter?: ProductSpecFilters, options?: ProductSpecOptions): Promise<BaseItems<ProductSpec>> {
+	public async findAll(
+		filter?: ProductSpecFilters,
+		options?: ProductSpecOptions
+	): Promise<BaseItems<ProductSpec> | { minPrice: number; maxPrice: number }> {
 		const pagination = paginate(options);
 		const qb: QueryBuilder<ProductSpec> = this.repository.createQueryBuilder('spec').select('*');
 
 		if (filter?.categoryId) {
-			void qb.leftJoin('spec.categories', 'specCategory').andWhere({ 'specCategory.category_id': filter.categoryId });
+			// Number() to prevent SQL injection
+			const categoryId = Number(filter.categoryId);
+
+			void qb.leftJoin('spec.categories', 'specCategory').andWhere(`
+			(specCategory.category_id = ${categoryId} OR
+			specCategory.category_id IN
+				(select category.parent_id
+				 from (select *
+					   from category c
+					   order by parent_id, id) category,
+					  (select @pv := '${categoryId}') initialisation
+				 where find_in_set(parent_id, @pv) > 0
+						   and @pv := concat(@pv, ',', category.id)))
+			`);
+		}
+
+		if (filter?.minPrice) {
+			void qb.leftJoin('spec.producerProducts', 'producerProduct').andWhere({
+				'producerProduct.current_price': { $gte: filter.minPrice }
+			});
+		}
+
+		if (filter?.maxPrice) {
+			void qb.leftJoin('spec.producerProducts', 'producerProduct').andWhere({
+				'producerProduct.current_price': { $lte: filter.maxPrice }
+			});
 		}
 
 		if (filter?.search) {
@@ -48,7 +76,16 @@ export class ProductSpecGateway {
 		}
 
 		// Calculate items count before grouping and paginating
-		const totalItemsQb = qb.clone();
+		const miscQb = qb
+			.clone()
+			.select('COUNT(*) as totalItems')
+			.addSelect('MIN(producerProduct.current_price) as minPrice')
+			.addSelect('MAX(producerProduct.current_price) as maxPrice')
+			.leftJoin('spec.producerProducts', 'producerProduct') as unknown as SelectQueryBuilder<{
+			totalItems: number;
+			minPrice: number;
+			maxPrice: number;
+		}>;
 
 		// Add producers count, min and max price
 		void qb
@@ -63,11 +100,20 @@ export class ProductSpecGateway {
 		void qb.offset(pagination.offset).limit(pagination.limit);
 
 		// Fetch results and map them
-		const [totalItems, productSpecs] = await Promise.all([totalItemsQb.getCount(), qb.getResultList()]);
+		const [miscData, productSpecs] = await Promise.all([miscQb.execute('get'), qb.getResultList()]);
+		console.log('\n\n\n\n\n\n', qb.getQuery(), '\n\n\n\n\n\n');
 
-		const totalPages = Math.ceil(totalItems / pagination.limit);
+		const totalPages = Math.ceil(miscData.totalItems / pagination.limit);
 		const page = Math.ceil(pagination.offset / pagination.limit) + 1;
-		return { items: productSpecs, totalItems, totalPages, page, pageSize: productSpecs.length };
+		return {
+			items: productSpecs,
+			totalItems: miscData.totalItems,
+			totalPages,
+			page,
+			pageSize: productSpecs.length,
+			maxPrice: miscData.maxPrice,
+			minPrice: miscData.minPrice
+		};
 	}
 
 	public async findById(id: number): Promise<ProductSpec | null> {
diff --git a/src/interfaces/CategoryFilters.ts b/src/interfaces/CategoryFilters.ts
@@ -0,0 +1,6 @@
+export interface CategoryFilters {
+	productMinPrice?: number;
+	productMaxPrice?: number;
+	productSearch?: string;
+	parentId?: number;
+}
diff --git a/src/interfaces/ProductSpecFilters.ts b/src/interfaces/ProductSpecFilters.ts
@@ -9,4 +9,6 @@ export interface ProductSpecFilters {
 	 */
 	fields?: { [key: number]: FieldTypeType[] };
 	search?: StringSearch;
+	minPrice?: number;
+	maxPrice?: number;
 }
diff --git a/src/seeders/HivetownSeeder.ts b/src/seeders/HivetownSeeder.ts
@@ -68,7 +68,8 @@ export class HivetownSeeder extends Seeder {
 			if (faker.datatype.number({ min: 1, max: 100 }) <= 5) return;
 
 			// The remaining 95% get a random parent
-			const parent = faker.helpers.arrayElement(categories);
+			// Limitation: the parent must have a lower id than the child
+			const parent = faker.helpers.arrayElement(categories.filter((c) => c.id < category.id));
 			if (parent.id !== category.id) category.parent = parent;
 		});
 

Original file line number	Diff line number	Diff line change
`@@ -9,4 +9,6 @@ export interface ProductSpecFilters {`
`9`	`9`	`*/`
`10`	`10`	`fields?: { [key: number]: FieldTypeType[] };`
`11`	`11`	`search?: StringSearch;`
	`12`	`+ minPrice?: number;`
	`13`	`+ maxPrice?: number;`
`12`	`14`	`}`