Commit fb6faead authored by Diego Iván's avatar Diego Iván
Browse files

agregando categories en las queries de Place

parent 6abfbd8e

backend/src/place/place.service.ts

+87 −73
Original line number Diff line number Diff line 
import { BadRequestException, Injectable } from '@nestjs/common';

import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';

import { CreatePlaceDateTradDto } from './dto/create-place-date.dto';

import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';

import { Place } from './entities/place.entity';
@@ -13,6 +13,7 @@ import { GetPlaceDto } from './dto/get-place.dto'; 
import { ServerConstants } from 'src/constants/server.contants';

import { Available } from 'src/pointOfInterest/enum/available.enum';

import { UpdatePlaceReqDto } from './dto/update-place.req.dto';

import { Category } from 'src/category/entities/category.entity';



@Injectable()

export class PlaceService {
@@ -26,35 +27,46 @@ export class PlaceService { 


  async create(createPlaceDto: CreatePlaceDateTradDto) {

    const town: Town = await this.townRepository.findOneBy({ townId: createPlaceDto.idTown });

    const categories: Category[] = [];

    for (const categoryId of createPlaceDto.categoriesId) {

      const categoryEN: Category = await this.dataSource

        .getRepository(Category)

        .findOneByOrFail({ idCategory: categoryId });

      categoryEN.language = LANGUAGES.EN;

      const categoryES: Category = { ...categoryEN, language: LANGUAGES.ES };

      categories.push(categoryEN);

      categories.push(categoryES);

    }

    const createPlace: CreatePlaceDto = {

      available: createPlaceDto.available,

      closeAt: createPlaceDto.closeAt,

      latitude: createPlaceDto.latitude,

      longitude: createPlaceDto.longitude,

      idTown: town,

      town: town,

      name: createPlaceDto.name,

      openAt: createPlaceDto.openAt,

      imageName: createPlaceDto.image.filename,

      categories: categories,

    };



    if (!town) {

      throw new BadRequestException('Town not found');

    }



    const insertedId = (await this.placeRepository.insert({ ...createPlace })).raw.insertId;

    const insertedPlace = await this.placeRepository.save({ ...createPlace });

    const createDate: CreateDateDto = {

      endDate: createPlaceDto.endDate,

      startDate: createPlaceDto.startDate,

      idPlace: insertedId,

      idPlace: insertedPlace,

    };

    const createTradEn: PlaceTraduction = {

      language: LANGUAGES.EN,

      idPlace: insertedId,

      idPlace: insertedPlace.idPlace,

      description: createPlaceDto.descriptionEN,

    };

    const createTradEs: PlaceTraduction = {

      language: LANGUAGES.ES,

      idPlace: insertedId,

      idPlace: insertedPlace.idPlace,

      description: createPlaceDto.descriptionES,

    };
@@ -62,48 +74,37 @@ export class PlaceService { 
    await this.placeTraductionRepository.insert(createTradEs);

    await this.placeTraductionRepository.insert(createTradEn);

    if (createPlaceDto.available === Available.CUSTOM) {

      await this.availableDateRepository.insert({ ...createDate, idPlace: insertedId });

      await this.availableDateRepository.insert({ ...createDate, idPlace: insertedPlace });

    }

  }



  async findAllByTown(idTown: number, lang: LANGUAGES) {

    const res: GetPlaceDto[] = await this.dataSource

      .getRepository(PlaceTraduction)

      .createQueryBuilder('placeTrad')

      .leftJoin('placeTrad.idPlace', 'place')

      .leftJoin('place.availableDates', 'availableDate')

      .select([

        'place.idPlace AS idPlace',

        'place.name AS name',

        'place.imageName AS imageName',

        'placeTrad.language AS language',

        'placeTrad.description AS description',

        'place.openAt AS openAt',

        'place.closeAt AS closeAt',

        'availableDate.startDate AS startDate',

        'availableDate.endDate AS endDate',

        'place.available AS available',

        'place.idTown AS idTown',

        'place.latitude AS latitude',

        'place.longitude AS longitude',

      ])

    const res: any[] = await this.dataSource

      .getRepository(Place)

      .createQueryBuilder('place')

      .leftJoinAndSelect('place.availableDates', 'availableDate')

      .leftJoinAndSelect('place.categories', 'category')

      .leftJoinAndSelect('place.placeTraduction', 'placeTrad')

      .leftJoinAndSelect('place.town', 'town')

      .where('place.idTown = :idTown', { idTown: idTown })

      .andWhere('placeTrad.language = :language', { language: lang })

      .getRawMany();

    const places: GetPlaceDto[] = res.map((place) => {

      .andWhere('category.language = :language', { language: lang })

      .getMany();

    const places: GetPlaceDto[] = res.map((place): GetPlaceDto => {

      return {

        idTown: place.idTown,

        idTown: place.town.townId,

        idPlace: place.idPlace,

        available: place.available,

        description: place.description,

        latitude: place.latitude,

        longitude: place.longitude,

        imageName: `${ServerConstants.HOST}/places/${place.imageName}`,

        name: place.name,

        openAt: place.openAt,

        closeAt: place.closeAt,

        startDate: place.startDate,

        endDate: place.endDate,

        startDate: place.availableDates[0]?.startDate || null,

        endDate: place.availableDates[0]?.endDate || null,

        categories: place.categories,

        description: place.placeTraduction[0].description,

      };

    });

    return places;
@@ -114,60 +115,71 @@ export class PlaceService { 
  }



  async findOneAndTradAndAvailable(idPlace: number, lang: LANGUAGES) {

    const place: GetPlaceDto = await this.dataSource

      .getRepository(PlaceTraduction)

      .createQueryBuilder('placeTrad')

      .leftJoin('placeTrad.idPlace', 'place')

      .leftJoin('place.availableDates', 'availableDate')

      .select([

        'place.idPlace AS idPlace',

        'place.name AS name',

        'place.imageName AS imageName',

        'placeTrad.language AS language',

        'placeTrad.description AS description',

        'place.latitude AS latitude',

        'place.longitude AS longitude',

        'place.openAt AS openAt',

        'place.closeAt AS closeAt',

        'availableDate.startDate AS startDate',

        'availableDate.endDate AS endDate',

        'place.idTown AS idTown',

        'place.available AS available',

      ])

      .where('place.idPlace = :idPlace', { idPlace: idPlace })

    const place: any = await this.dataSource

      .getRepository(Place)

      .createQueryBuilder('place')

      .leftJoinAndSelect('place.availableDates', 'availableDate')

      .leftJoinAndSelect('place.categories', 'category')

      .leftJoinAndSelect('place.placeTraduction', 'placeTrad')

      .leftJoinAndSelect('place.town', 'town')

      .where('place.idPlace = :idPlace', { idPlace })

      .andWhere('placeTrad.language = :language', { language: lang })

      .getRawOne();



    return {

      idTown: place.idTown,

      .andWhere('category.language = :language', { language: lang })

      .getOne();

    const res: GetPlaceDto = {

      idTown: place.town.townId,

      idPlace: place.idPlace,

      available: place.available,

      description: place.description,

      latitude: place.latitude,

      longitude: place.longitude,

      imageName: `${ServerConstants.HOST}/places/${place.imageName}`,

      name: place.name,

      openAt: place.openAt,

      closeAt: place.closeAt,

      startDate: place.startDate,

      endDate: place.endDate,

      startDate: place.availableDates[0]?.startDate,

      endDate: place.availableDates[0]?.endDate,

      categories: place.categories,

      description: place.placeTraduction[0].description,

    };

    return res;

  }



  async update(idPlace: number, updatePlaceReqDto: UpdatePlaceReqDto) {

    const place: Place = await this.placeRepository.findOneBy({ idPlace });

    const createPlaceDto: CreatePlaceDto = {

      available: updatePlaceReqDto.available,

      closeAt: updatePlaceReqDto.closeAt,

      latitude: updatePlaceReqDto.latitude,

      longitude: updatePlaceReqDto.longitude,

      name: updatePlaceReqDto.name,

      openAt: updatePlaceReqDto.openAt,

      imageName: updatePlaceReqDto.image.filename,

      idTown: place.idTown,

    };

    const place: Place = await this.placeRepository.findOne({

      where: { idPlace },

      relations: ['categories'],

    });



    if (!place) {

      throw new NotFoundException('Place not found');

    }



    // Update place properties

    place.available = updatePlaceReqDto.available;

    place.closeAt = updatePlaceReqDto.closeAt;

    place.latitude = updatePlaceReqDto.latitude;

    place.longitude = updatePlaceReqDto.longitude;

    place.name = updatePlaceReqDto.name;

    place.openAt = updatePlaceReqDto.openAt;

    place.imageName = updatePlaceReqDto.image.filename;



    // Update categories

    const categories: Category[] = [];

    for (const categoryId of updatePlaceReqDto.categoriesId) {

      const categoryEN: Category = await this.dataSource

        .getRepository(Category)

        .findOneByOrFail({ idCategory: categoryId });

      categoryEN.language = LANGUAGES.EN;

      const categoryES: Category = { ...categoryEN, language: LANGUAGES.ES };

      categories.push(categoryEN);

      categories.push(categoryES);

    }

    place.categories = categories;



    // Save the updated place

    await this.placeRepository.save(place);



    await this.placeRepository.update({ idPlace }, createPlaceDto);

    // Update PlaceTraduction for EN

    await this.placeTraductionRepository

      .createQueryBuilder()

      .update(PlaceTraduction)
@@ -175,6 +187,7 @@ export class PlaceService { 
      .where('idPlace = :idPlace AND language = :language', { idPlace, language: LANGUAGES.EN })

      .execute();



    // Update PlaceTraduction for ES

    await this.placeTraductionRepository

      .createQueryBuilder()

      .update(PlaceTraduction)
@@ -182,6 +195,7 @@ export class PlaceService { 
      .where('idPlace = :idPlace AND language = :language', { idPlace, language: LANGUAGES.ES })

      .execute();



    // Update available date if necessary

    if (updatePlaceReqDto.available === Available.CUSTOM) {

      await this.availableDateRepository.update(

        { idPlace: place },