agregando metodos para crear una ruta y agregar un lugar a una ruta

import { GetPlaceDto } from 'src/place/dto/get-place.dto';

import { Visited } from 'src/visited/entities/visited.entity';

import { RecommendPlace } from './dto/recommend-route.dto';

import { CreateRouteDto } from './dto/create-route.dto';

import { CreateTravelPlaceDto } from 'src/travel-place/dto/create-travel-place.dto';

@Injectable()

export class RouteService {

    private readonly placeService: PlaceService,

    private readonly visitedService: VisitedService,

  ) {}

  private async createRoute(email: string, idTown: number, idPlace: number, startDate: Date, endDate: Date) {

    const user: User = await this.userRepository.findOneBy({ email });

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

    // const idRoute =  await this.routeRepository.save({ user, town, startDate, endDate });

    const idRoute = (await this.routeRepository.save({ user, town, startDate, endDate })).idRoute;

    await this.travelPlaceService.create({

      idRoute,

      idPlace,

      startDate: new Date(),

      endDate: new Date(),

      done: false,

    });

  }

  async recommend(idTown: number, email: string, language: LANGUAGES) {

  async recommend(idTown: number, email: string, language: LANGUAGES, start, end) {

    // Obtener los visitados y los candidatos

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

    const user: User = await this.userRepository.findOneBy({ email });

    const placesNotVisited: GetPlaceDto[] = await this.placeService.findPlacesNotVisitedByUser(email, language, idTown);

    const visited: Visited[] = await this.visitedService.getVisitedByUser(email);

    const placesMapped: RecommendPlace[] = placesNotVisited.map((place) => {

      };

    });

    const system = new RecommendationsSystem();

    const chosen: [number, number][] = system.recommend(visitedMapped, placesMapped);

    const placesChooen: GetPlaceDto[] = [];

    for (const [index] of chosen) {

      placesChooen.push(await this.placeService.findOneAndTradAndAvailable(index, LANGUAGES.EN));

    }

    const system = new RecommendationsSystem(visitedMapped, placesMapped, start, end);

    const chosen: RecommendPlace[] = system.recommend();

    const startDate: Date = new Date();

    startDate.setHours(start);

    const endDate = new Date();

    endDate.setHours(end);

    for (const place of placesChooen) {

      await this.createRoute(email, idTown, place.idPlace, new Date(), new Date());

    const createRouteDto: CreateRouteDto = { startDate, endDate, town, user };

    const idRoute = (await this.routeRepository.save(createRouteDto)).idRoute;

    for (const curRecommended of chosen) {

      const place = await this.placeService.findOneAndTradAndAvailable(curRecommended.idPlace, language);

      const endDate = new Date();

      endDate.setHours(curRecommended.closeAt);

      const startDate = new Date();

      startDate.setHours(curRecommended.openAt);

      const createTravelPlace: CreateTravelPlaceDto = {

        ...place,

        done: false,

        idRoute,

        endDate,

        startDate,

      };

      await this.travelPlaceService.create(createTravelPlace);

    }

  }

    return placesChooen;

  async getRouteAndPlacesByUser(email: string, language: LANGUAGES, idTown: number) {

    const res = await this.routeRepository.findOne({

      relations: ['travelPlace'],

      where: { user: { email }, town: { townId: idTown } },

    });

    return res;

  }

}