chore: merge main

Author: RomuloNogueira02

CHANGELOG.md

@@ -1,6 +1,6 @@
 {
 	"name": "@hivetown/backend",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "Hivetown Backend",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package.json

@@ -19,6 +19,7 @@ import { Authentication } from '../external/Authentication';
 import { hasPermissions } from '../utils/hasPermission';
 import type { ProductionUnitFilters } from '../interfaces/ProductionUnitFilters';
 import { StringSearchType } from '../enums/StringSearchType';
+import type { CarrierFilters } from '../interfaces/CarrierFilters';
 
 @Controller('/producers')
 @Injectable()
@@ -926,15 +927,16 @@ export class ProducersController {
 		return res.status(200).json(products);
 	}
 
-	@Get('/:producerId/units/:unitId/carriers/inTransit', [
+	@Get('/:producerId/units/:unitId/carriers', [
 		validate({
 			params: Joi.object({
 				producerId: Joi.number().required(),
 				unitId: Joi.number().required()
 			}),
 			query: Joi.object({
 				page: Joi.number().optional(),
-				pageSize: Joi.number().optional()
+				pageSize: Joi.number().optional(),
+				status: Joi.string().valid('Available', 'Unavailable').optional()
 			})
 		}),
 		authenticationMiddleware,
@@ -952,24 +954,29 @@ export class ProducersController {
 			]
 		})
 	])
-	public async getProductionUnitCarriersInTransitOfProductionUnit(
+	public async getProductionUnitCarriers(
 		@Response() res: Express.Response,
-		@Request() req: Express.Request,
 		@Params('producerId') producerId: number,
-		@Params('unitId') unitId: number
+		@Params('unitId') unitId: number,
+		@Request() req: Express.Request
 	) {
-		const producer = await container.producerGateway.findById(producerId);
+		const producer = await container.producerGateway.findByIdWithUnits(producerId);
 		if (!producer) throw new NotFoundError('Producer not found');
 
-		const productionUnit = await container.productionUnitGateway.findById(unitId);
-		if (!productionUnit || productionUnit.producer.user.id !== producer.user.id) throw new NotFoundError('Production unit not found');
+		const productionUnit = producer.productionUnits.getItems().find((unit) => unit.id === Number(unitId));
+		if (!productionUnit) throw new NotFoundError('Production unit not found for this producer');
 
 		const options: PaginatedOptions = {
 			page: Number(req.query.page) || -1,
 			size: Number(req.query.pageSize) || -1
 		};
 
-		const carriers = await container.carrierGateway.findAllinTranstit(productionUnit.id, options);
+		const filters: CarrierFilters = {
+			productionUnitId: productionUnit.id,
+			status: req.query.status === 'Available' || req.query.status === 'Unavailable' ? req.query.status : undefined
+		};
+
+		const carriers = await container.carrierGateway.findFromProductionUnit(filters, options);
 
 		return res.status(200).json(carriers);
 	}

src/controllers/producers.ts

@@ -3,6 +3,7 @@ import type { EntityRepository, MikroORM } from '@mikro-orm/mysql';
 import type { BaseItems } from '../interfaces/BaseItems';
 import type { PaginatedOptions } from '../interfaces/PaginationOptions';
 import { paginate } from '../utils/paginate';
+import type { CarrierFilters } from '../interfaces/CarrierFilters';
 
 export class CarrierGateway {
 	private repository: EntityRepository<Carrier>;
@@ -11,24 +12,31 @@ export class CarrierGateway {
 		this.repository = orm.em.getRepository(Carrier);
 	}
 
-	public async findAllinTranstit(productionUnitId: number, options: PaginatedOptions): Promise<BaseItems<Carrier>> {
-		const pagination = paginate(options);
-		const [carriers, totalResults] = await Promise.all([
-			this.repository.find(
-				{ productionUnit: productionUnitId, status: 'UNAVAILABLE', deletedAt: null },
-				{
-					populate: ['productionUnit'],
-					limit: pagination.limit,
-					offset: pagination.offset
-				}
-			),
-			this.repository.count({ productionUnit: productionUnitId, status: 'UNAVAILABLE', deletedAt: null })
-		]);
+	public async findFromProductionUnit(filters: CarrierFilters, options: PaginatedOptions): Promise<BaseItems<Carrier>> {
+		const paginataion = paginate(options);
+		const qb = this.repository
+			.createQueryBuilder('c')
+			.select('*')
+			.where({ productionUnit: { id: filters.productionUnitId }, deletedAt: null })
+			.leftJoinAndSelect('c.image', 'ci');
+
+		if (filters.status) {
+			void qb.andWhere({ status: filters.status });
+		}
+
+		const totalItemsQb = qb.clone();
+
+		// Paginate
+		void qb.offset(paginataion.offset).limit(paginataion.limit);
+
+		// Fetch results and map them
+		const [totalResults, carriers] = await Promise.all([totalItemsQb.getCount(), qb.getResultList()]);
+
 		return {
 			items: carriers,
 			totalItems: totalResults,
-			totalPages: Math.ceil(totalResults / pagination.limit),
-			page: Math.ceil(pagination.offset / pagination.limit) + 1,
+			totalPages: Math.ceil(totalResults / paginataion.limit),
+			page: Math.ceil(paginataion.offset / paginataion.limit) + 1,
 			pageSize: carriers.length
 		};
 	}

src/gateways/CarrierGateway.ts

@@ -30,7 +30,8 @@ export class ProductionUnitGateway {
 			.createQueryBuilder('pu')
 			.select('*')
 			.where({ producer: { id: filter.producerId }, deletedAt: null })
-			.leftJoinAndSelect('pu.address', 'pa');
+			.leftJoinAndSelect('pu.address', 'pa')
+			.leftJoinAndSelect('pu.images', 'pi');
 
 		if (filter.search) {
 			void qb.andWhere({

src/gateways/ProductionUnitGateway.ts

@@ -0,0 +1,6 @@
+import type { CarrierStatus } from '../enums';
+
+export interface CarrierFilters {
+	productionUnitId?: number;
+	status?: keyof typeof CarrierStatus;
+}

src/interfaces/CarrierFilters.ts

@@ -10,6 +10,5 @@ export const paginate = (options: PaginatedOptions = { page: 1, size: 24 }, max
 
 	const offset = (page - 1) * size;
 	const limit = size;
-
 	return { offset, limit };
 };

src/utils/paginate.ts

@@ -0,0 +1,115 @@
+import type { User } from '../src/entities/User';
+import { Permission } from '../src/enums/Permission';
+import { UserType } from '../src/enums/UserType';
+import { hasPermissions } from '../src/utils/hasPermission';
+
+let user: User; // Variável para armazenar o usuário
+
+beforeAll(() => {
+	user = {
+		id: 1,
+		authId: '123',
+		name: 'John Doe',
+		email: 'johnD@gmail.com',
+		phone: '912345678',
+		vat: '123456789',
+		type: UserType.Consumer,
+		disableEmails: false
+	};
+
+	return user;
+});
+
+test('no permissions user example', () => {
+	const noPermissions = hasPermissions(user, Permission.READ_OTHER_CONSUMER);
+	expect(noPermissions).toBe(false);
+});
+
+test('read/write other consumer permission example', () => {
+	const role = {
+		id: 1,
+		name: 'AccountManager',
+		permissions: Permission.READ_OTHER_CONSUMER
+	};
+
+	user.role = role;
+
+	const readOtherConsumer = hasPermissions(user, Permission.READ_OTHER_CONSUMER);
+	const writeOtherConsumer = hasPermissions(user, Permission.WRITE_OTHER_CONSUMER);
+
+	const readOtherProducer = hasPermissions(user, Permission.READ_OTHER_PRODUCER);
+	const writeOtherProducer = hasPermissions(user, Permission.WRITE_OTHER_PRODUCER);
+
+	expect(readOtherConsumer).toBe(true);
+	expect(writeOtherConsumer).toBe(false);
+
+	expect(readOtherProducer).toBe(false);
+	expect(writeOtherProducer).toBe(false);
+});
+
+test('read/write other user (consumero or producer) permission example', () => {
+	const role = {
+		id: 2,
+		name: 'AccountEditor',
+		permissions:
+			Permission.READ_OTHER_CONSUMER | Permission.WRITE_OTHER_CONSUMER | Permission.READ_OTHER_PRODUCER | Permission.WRITE_OTHER_PRODUCER
+	};
+
+	user.role = role;
+
+	const readOtherConsumer = hasPermissions(user, Permission.READ_OTHER_CONSUMER);
+	const writeOtherConsumer = hasPermissions(user, Permission.WRITE_OTHER_CONSUMER);
+
+	const readOtherProducer = hasPermissions(user, Permission.READ_OTHER_PRODUCER);
+	const writeOtherProducer = hasPermissions(user, Permission.WRITE_OTHER_PRODUCER);
+
+	const writeCategory = hasPermissions(user, Permission.WRITE_CATEGORY);
+
+	expect(readOtherConsumer).toBe(true);
+	expect(writeOtherConsumer).toBe(true);
+
+	expect(readOtherProducer).toBe(true);
+	expect(writeOtherProducer).toBe(true);
+
+	expect(writeCategory).toBe(false);
+});
+
+test('all permissions user example', () => {
+	const role = {
+		id: 3,
+		name: 'Admin',
+		permissions: Permission.ALL
+	};
+
+	user.role = role;
+
+	const readOtherConsumer = hasPermissions(user, Permission.READ_OTHER_CONSUMER);
+	const writeOtherConsumer = hasPermissions(user, Permission.WRITE_OTHER_CONSUMER);
+
+	const readOtherProducer = hasPermissions(user, Permission.READ_OTHER_PRODUCER);
+	const writeOtherProducer = hasPermissions(user, Permission.WRITE_OTHER_PRODUCER);
+
+	const writeCategory = hasPermissions(user, Permission.WRITE_CATEGORY);
+	const deleteCategory = hasPermissions(user, Permission.DELETE_CATEGORY);
+
+	const writeProduct = hasPermissions(user, Permission.WRITE_PRODUCT);
+	const deleteProduct = hasPermissions(user, Permission.DELETE_PRODUCT);
+
+	const createAdmin = hasPermissions(user, Permission.CREATE_ADMIN);
+	const deleteAdmin = hasPermissions(user, Permission.DELETE_ADMIN);
+
+	expect(readOtherConsumer).toBe(true);
+	expect(writeOtherConsumer).toBe(true);
+
+	expect(readOtherProducer).toBe(true);
+	expect(writeOtherProducer).toBe(true);
+
+	expect(writeCategory).toBe(true);
+	expect(deleteCategory).toBe(true);
+
+	expect(writeProduct).toBe(true);
+	expect(deleteProduct).toBe(true);
+
+	expect(createAdmin).toBe(true);
+	expect(deleteAdmin).toBe(true);
+});

tests/hasPermissions.test.ts

@@ -0,0 +1,62 @@
+import { paginate } from '../src/utils/paginate';
+import type { PaginatedOptions } from '../src/interfaces/PaginationOptions';
+
+test('valid paginated example', () => {
+	const options: PaginatedOptions = {
+		page: 3,
+		size: 10
+	};
+
+	const result = paginate(options);
+
+	expect(result.limit).toEqual(10);
+	expect(result.offset).toEqual(20);
+});
+
+test('invalid paginated example - negative page', () => {
+	const options: PaginatedOptions = {
+		page: -3,
+		size: 10
+	};
+
+	const result = paginate(options);
+
+	expect(result.limit).toEqual(10);
+	expect(result.offset).toEqual(0);
+});
+
+test('invalid paginated example - negative size', () => {
+	const options: PaginatedOptions = {
+		page: 3,
+		size: -10
+	};
+
+	const result = paginate(options);
+
+	expect(result.limit).toEqual(1);
+	expect(result.offset).toEqual(2);
+});
+
+test('invalid paginated example - negative page and size', () => {
+	const options: PaginatedOptions = {
+		page: -3,
+		size: -10
+	};
+
+	const result = paginate(options);
+
+	expect(result.limit).toEqual(1);
+	expect(result.offset).toEqual(0);
+});
+
+test('invalid paginated example - size too big', () => {
+	const options: PaginatedOptions = {
+		page: 10,
+		size: 1000
+	};
+
+	const result = paginate(options);
+
+	expect(result.limit).toEqual(100);
+	expect(result.offset).toEqual(900);
+});

tests/paginate.test.ts

@@ -2,7 +2,7 @@
 	"extends": "../tsconfig.base.json",
 	"compilerOptions": {
 		"outDir": "../dist/tests",
-		"rootDir": ".",
+		"rootDir": "../",
 		"types": ["node", "jest"]
 	}
 }