Laca-City/backend/dist/modules/parking/parking.service.js

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
var ParkingService_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ParkingService = void 0;
const common_1 = require("@nestjs/common");
const typeorm_1 = require("@nestjs/typeorm");
const typeorm_2 = require("typeorm");
const parking_lot_entity_1 = require("./entities/parking-lot.entity");
const parking_update_entity_1 = require("./entities/parking-update.entity");
let ParkingService = ParkingService_1 = class ParkingService {
    constructor(parkingRepository, updateRepository) {
        this.parkingRepository = parkingRepository;
        this.updateRepository = updateRepository;
        this.logger = new common_1.Logger(ParkingService_1.name);
    }
    async findNearbyParking(dto) {
        try {
            this.logger.debug(`Finding parking near ${dto.lat}, ${dto.lng} within ${dto.radius}m`);
            let query = this.parkingRepository
                .createQueryBuilder('lot')
                .select([
                'lot.*',
                'ST_Distance(lot.location::geography, ST_Point(:lng, :lat)::geography) as distance'
            ])
                .where('ST_DWithin(lot.location::geography, ST_Point(:lng, :lat)::geography, :radius)', {
                lng: dto.lng,
                lat: dto.lat,
                radius: dto.radius,
            })
                .andWhere('lot.isActive = :isActive', { isActive: true });
            if (dto.priceRange && dto.priceRange.length === 2) {
                query = query.andWhere('lot.hourlyRate BETWEEN :minPrice AND :maxPrice', { minPrice: dto.priceRange[0], maxPrice: dto.priceRange[1] });
            }
            if (dto.amenities && dto.amenities.length > 0) {
                dto.amenities.forEach((amenity, index) => {
                    query = query.andWhere(`lot.amenities ? :amenity${index}`, { [`amenity${index}`]: amenity });
                });
            }
            if (dto.availabilityFilter) {
                switch (dto.availabilityFilter) {
                    case 'available':
                        query = query.andWhere('(lot.availableSlots::float / lot.totalSlots::float) > 0.2');
                        break;
                    case 'limited':
                        query = query.andWhere('(lot.availableSlots::float / lot.totalSlots::float) BETWEEN 0.05 AND 0.2');
                        break;
                    case 'full':
                        query = query.andWhere('(lot.availableSlots::float / lot.totalSlots::float) < 0.05');
                        break;
                }
            }
            const results = await query
                .orderBy('distance', 'ASC')
                .limit(dto.maxResults)
                .getRawMany();
            const parkingLots = results.map((result) => {
                const { distance, ...lotData } = result;
                const lot = this.parkingRepository.create(lotData);
                lot.distance = parseFloat(distance);
                return lot;
            });
            return {
                parkingLots,
                userLocation: { lat: dto.lat, lng: dto.lng },
                searchRadius: dto.radius,
            };
        }
        catch (error) {
            this.logger.error('Failed to find nearby parking', error);
            throw new common_1.InternalServerErrorException('Failed to find nearby parking');
        }
    }
    async findById(id) {
        const lot = await this.parkingRepository.findOne({
            where: { id },
            relations: ['updates'],
        });
        if (!lot) {
            throw new common_1.NotFoundException(`Parking lot with ID ${id} not found`);
        }
        return lot;
    }
    async updateAvailability(id, dto) {
        const lot = await this.findById(id);
        const update = this.updateRepository.create({
            parkingLotId: id,
            availableSlots: dto.availableSlots,
            source: dto.source,
            confidence: dto.confidence,
            metadata: dto.metadata,
        });
        await this.updateRepository.save(update);
        lot.availableSlots = dto.availableSlots;
        lot.updatedAt = new Date();
        return this.parkingRepository.save(lot);
    }
    async getAllParkingLots() {
        return this.parkingRepository.find({
            where: { isActive: true },
            order: { name: 'ASC' },
        });
    }
    async getParkingLotHistory(id, limit = 100) {
        return this.updateRepository.find({
            where: { parkingLotId: id },
            order: { timestamp: 'DESC' },
            take: limit,
        });
    }
    async getPopularParkingLots(limit = 10) {
        const results = await this.parkingRepository
            .createQueryBuilder('lot')
            .leftJoin('lot.history', 'history')
            .select(['lot.*', 'COUNT(history.id) as visit_count'])
            .where('lot.isActive = :isActive', { isActive: true })
            .groupBy('lot.id')
            .orderBy('visit_count', 'DESC')
            .limit(limit)
            .getRawMany();
        return results.map((result) => {
            const { visit_count, ...lotData } = result;
            const lot = this.parkingRepository.create(lotData);
            lot.visitCount = parseInt(visit_count) || 0;
            return lot;
        });
    }
};
exports.ParkingService = ParkingService;
exports.ParkingService = ParkingService = ParkingService_1 = __decorate([
    (0, common_1.Injectable)(),
    __param(0, (0, typeorm_1.InjectRepository)(parking_lot_entity_1.ParkingLot)),
    __param(1, (0, typeorm_1.InjectRepository)(parking_update_entity_1.ParkingUpdate)),
    __metadata("design:paramtypes", [typeorm_2.Repository,
        typeorm_2.Repository])
], ParkingService);
//# sourceMappingURL=parking.service.js.map