Atena/feature/endpoint local proximo

src/api/contractorCompanies/domain/contractorCompanies.service.ts

@@ -10,6 +10,7 @@ import { ContractorCompaniesEntity } from '../contractorCompanies.entity';
 import { CreateContractorCompaniesDto } from '../dto/createContractorCompanies.dto';
 import * as bcrypt from 'bcrypt';
 import { AddressEntity } from '../address.entity';
+import { ClientEntity } from 'src/api/client/client.entity';
 
 @Injectable()
 export class ContractorCompaniesService {

src/api/products/domain/products.service.ts

 import {
   ForbiddenException,
+  HttpException,
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
@@ -7,12 +8,15 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { ILike, IsNull, MoreThan, Repository } from 'typeorm';
 import { CreateProductDto } from '../dto/createProductDto';
 import { ProductEntity } from '../product.entity';
+import { ContractorCompaniesEntity } from 'src/api/contractorCompanies/contractorCompanies.entity';
+import { ContractorCompaniesService } from 'src/api/contractorCompanies/domain/contractorCompanies.service';
 
 @Injectable()
 export class ProductsService {
   constructor(
     @InjectRepository(ProductEntity)
     private readonly productRepository: Repository<ProductEntity>,
+    private readonly contractorCompaniesService: ContractorCompaniesService,
   ) {}
 
   async findAll(): Promise<ProductEntity[]> {
@@ -20,12 +24,20 @@ export class ProductsService {
   }
 
   async findOne(id: number): Promise<ProductEntity> {
-    const product = await this.productRepository.findOne({
-      where: { id },
-    });
+    if (isNaN(id)) {
+      throw new HttpException('Invalid product ID', 400);
+    }
+
+    const product = await this.productRepository
+      .createQueryBuilder('product')
+      .where('product.id = :id', { id })
+      .andWhere('product.deletedAt IS NULL')
+      .getOne();
+
     if (!product) {
-      throw new NotFoundException(`Product with ID ${id} not found`);
+      throw new HttpException('Product not found', 400);
     }
+
     return product;
   }
 
@@ -112,6 +124,56 @@ export class ProductsService {
     return products;
   }
 
+  async getAllCompanies(): Promise<ContractorCompaniesEntity[]> {
+    return await this.contractorCompaniesService.findAll();
+  }
+
+  degToRad(deg: number): number {
+    return deg * (Math.PI / 180);
+  }
+
+  async findByLocation(
+    clientLatitude: number,
+    clientLongitude: number,
+    clientRadius: number,
+  ): Promise<ProductEntity[]> {
+    const companies: ContractorCompaniesEntity[] = await this.getAllCompanies();
+    const inRangeCompanies: ContractorCompaniesEntity[] = [];
+    const X1toRad = this.degToRad(clientLatitude);
+
+    companies.forEach((company) => {
+      const X2toRad = this.degToRad(+company.address.latitude);
+      const deltaLong = this.degToRad(
+        clientLongitude - +company.address.longitude,
+      );
+
+      const distance =
+        Math.acos(
+          Math.cos(X1toRad) * Math.cos(X2toRad) * Math.cos(deltaLong) +
+            Math.sin(X1toRad) * Math.sin(X2toRad),
+        ) * 6371;
+
+      if (clientRadius >= distance) inRangeCompanies.push(company);
+    });
+
+    if (inRangeCompanies.length === 0)
+      throw new HttpException('No companies found', 400);
+    const companyIds = inRangeCompanies.map((company) => company.id);
+    let products = await this.productRepository
+      .createQueryBuilder('product')
+      .where('product.companyId IN (:...companyIds)', { companyIds })
+      .andWhere('product.deletedAt IS NULL')
+      .getMany();
+    if (products.length === 0)
+      throw new HttpException('No products found', 400);
+
+    products = products.filter((product) => {
+      const dynamicPrice = this.calculateDynamicPrice(product, new Date());
+      return dynamicPrice !== 0;
+    });
+    return products;
+  }
+
   private calculateDynamicPrice(product: any, currentDate: Date): number {
     const expirationDate = new Date(product.expiration_date);
     const daysToExpiration = Math.ceil(

src/api/products/products.controller.ts

@@ -26,7 +26,7 @@ import { AuthenticatedRequest } from '../auth/request';
 @ApiTags('Produtos')
 @Controller('products')
 export class ProductsController {
-  constructor(private readonly productService: ProductsService) { }
+  constructor(private readonly productService: ProductsService) {}
 
   @Get('/mine')
   @ApiOperation({ summary: 'Listagem de produtos por empresa' })
@@ -65,6 +65,30 @@ export class ProductsController {
     return await this.productService.findByName(req.user.sub, name);
   }
 
+  @ApiOperation({ summary: 'Encontrar produtos próximos a um raio' })
+  @ApiResponse({ status: 200, description: 'Produtos encontrados' })
+  @ApiResponse({ status: 400, description: 'Erro ao encontrar produtos' })
+  @ApiBearerAuth()
+  @UseGuards(AuthGuard)
+  @Get('/location')
+  async findByLocation(
+    @Param('clientLatitude') clientLatitude: number,
+    @Param('clientLongitude') clientLongitude: number,
+    @Param('clientRadius') clientRadius: number,
+  ) {
+    try {
+      const products = await this.productService.findByLocation(
+        clientLatitude,
+        clientLongitude,
+        clientRadius,
+      );
+
+      return products;
+    } catch (error) {
+      throw new HttpException(error.message, error.status);
+    }
+  }
+
   @ApiOperation({ summary: 'Adiciona uma produto' })
   @ApiResponse({ status: 201, description: 'Produto adicionado com sucesso' })
   @ApiResponse({ status: 400, description: 'Erro ao adicionar produto' })
@@ -85,8 +109,11 @@ export class ProductsController {
         product: newProduct,
         statusCode: HttpStatus.CREATED,
       };
-    } catch (error) {
-      throw new HttpException({ message: error.message }, error.status);
+    } catch (HttpException) {
+      throw new HttpException(
+        { message: HttpException.message },
+        HttpException.status,
+      );
     }
   }
 

src/api/products/products.module.ts

@@ -3,9 +3,13 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { ProductsService } from './domain/products.service';
 import { ProductEntity } from './product.entity';
 import { ProductsController } from './products.controller';
+import { ContractorCompaniesModule } from '../contractorCompanies/contractorCompanies.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([ProductEntity])],
+  imports: [
+    TypeOrmModule.forFeature([ProductEntity]),
+    ContractorCompaniesModule,
+  ],
   providers: [ProductsService],
   controllers: [ProductsController],
 })