Bouss / boussimmo

src/Parser/AbstractParser.php

<?php

namespace App\Parser;

use App\DataProvider\ProviderProvider;
use App\DTO\Property;
use App\DTO\PropertyAd;
use App\Enum\PropertyFilter;
use App\Exception\ParseException;
use App\Util\NumericUtil;
use DateTime;
use Exception;
use Psr\Log\LoggerInterface;
use Symfony\Component\DomCrawler\Crawler;
use function array_filter;
use function Symfony\Component\String\u;

abstract class AbstractParser implements ParserInterface
{
    // Redefined in the child classes
    protected const PROVIDER = null;

    protected const SELECTOR_AD_WRAPPER    = null;
    protected const SELECTOR_PRICE         = null;
    protected const SELECTOR_AREA          = null;
    protected const SELECTOR_ROOMS_COUNT   = null;
    protected const SELECTOR_LOCATION      = null;
    protected const SELECTOR_BUILDING_NAME = null;
    protected const SELECTOR_TITLE         = null;
    protected const SELECTOR_DESCRIPTION   = null;
    protected const SELECTOR_PHOTO         = 'img:first-child';
    protected const SELECTOR_URL           = 'a:first-child';

    private const NEW_BUILD_KEYWORDS = ['neuf', 'livraison', 'programme', 'neuve', 'nouveau', 'nouvelle', 'remise'];

    public function __construct(
        private ProviderProvider $providerProvider,
        protected LoggerInterface $logger
    ) {}

    /**
     * {@inheritDoc}
     */
    public function parse(string $html, array $filters = [], array $params = []): array
    {
        $properties = [];

        // Iterate over all DOM elements wrapping a property ad
        ($this->createCrawler($html))->filter(static::SELECTOR_AD_WRAPPER)->each(function (Crawler $node) use (&$properties, $params) {

static::SELECTOR_AD_WRAPPER of type null is incompatible with the type string expected by parameter $selector of Symfony\Component\DomCrawler\Crawler::filter().

            try {
                $properties[] = $this->parseOne($node, $params['date']);
            } catch (Exception $e) {
                $this->logger->warning('Error while parsing a property: ' . $e->getMessage(), $params);
            }
        });

        if (empty($properties)) {
            throw new ParseException('No property parsed');
        }

        // Filter the properties
        return array_filter($properties, static fn(Property $ad) => isset($filters[PropertyFilter::NEW_BUILD]) ? $ad->isNewBuild() : true);
    }

    /**
     * Enable to modify the DOM before parsing
     *
     * @param string $html
     *
     * @return Crawler
     */
    protected function createCrawler(string $html): Crawler
    {
        return new Crawler($html);
    }

    protected function parsePrice(Crawler $crawler): ?float
    {
        if (null === static::SELECTOR_PRICE) {

The condition null === static::SELECTOR_PRICE is always true.

            return NumericUtil::parsePrice($crawler->html());
        }

        try {
            $priceStr = trim($crawler->filter(static::SELECTOR_PRICE)->text());
        } catch (Exception) {
            return null;
        }

        return NumericUtil::parsePrice($priceStr);
    }

    protected function parseArea(Crawler $crawler): ?float
    {
        if (null === static::SELECTOR_AREA) {

The condition null === static::SELECTOR_AREA is always true.

            return NumericUtil::parseArea($crawler->html());
        }

        try {
            $areaStr = trim($crawler->filter(static::SELECTOR_AREA)->text());
        } catch (Exception) {
            return null;
        }

        return NumericUtil::parseArea($areaStr);
    }

    protected function parseRoomsCount(Crawler $crawler): ?int
    {
        if (null === static::SELECTOR_ROOMS_COUNT) {

The condition null === static::SELECTOR_ROOMS_COUNT is always true.

            return NumericUtil::parseRoomsCount($crawler->html());
        }

        try {
            $roomsCountStr = trim($crawler->filter(static::SELECTOR_ROOMS_COUNT)->text());
        } catch (Exception) {
            return null;
        }

        return NumericUtil::parseRoomsCount($roomsCountStr);
    }

    protected function parseLocation(Crawler $crawler): ?string
    {
        if (null === static::SELECTOR_LOCATION) {

The condition null === static::SELECTOR_LOCATION is always true.

            return null;
        }

        try {
            return trim($crawler->filter(static::SELECTOR_LOCATION)->text());
        } catch (Exception) {
            return null;
        }
    }

    protected function parseBuildingName(Crawler $crawler): ?string
    {
        if (null === static::SELECTOR_BUILDING_NAME) {

The condition null === static::SELECTOR_BUILDING_NAME is always true.

            return null;
        }

        try {
            return trim($crawler->filter(static::SELECTOR_BUILDING_NAME)->text());
        } catch (Exception) {
            return null;
        }
    }

    protected function parseTitle(Crawler $crawler): ?string
    {
        if (null === static::SELECTOR_TITLE) {

The condition null === static::SELECTOR_TITLE is always true.

            return null;
        }

        try {
            return trim($crawler->filter(static::SELECTOR_TITLE)->text());
        } catch (Exception) {
            return null;
        }
    }

    protected function parseDescription(Crawler $crawler): ?string
    {
        if (null === static::SELECTOR_DESCRIPTION) {

The condition null === static::SELECTOR_DESCRIPTION is always true.

            return null;
        }

        try {
            return trim($crawler->filter(static::SELECTOR_DESCRIPTION)->text());
        } catch (Exception) {
            return null;
        }
    }

    /**
     * @throws ParseException
     */
    protected function parsePhoto(Crawler $crawler): ?string
    {
        try {
            return $crawler->filter(static::SELECTOR_PHOTO)->attr('src');
        } catch (Exception $e) {
            throw new ParseException('Error while parsing the photo: ' . $e->getMessage());
        }
    }

    /**
     * @throws ParseException
     */
    protected function parseUrl(Crawler $crawler): string
    {
        try {
            return $crawler->filter(static::SELECTOR_URL)->attr('href');

The expression return $crawler->filter(static::SELECTOR_URL)->attr('href') could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

        } catch (Exception $e) {
            throw new ParseException('Error while parsing the URL: ' . $e->getMessage());
        }
    }

    /**
     * @throws ParseException
     */
    private function parseOne(Crawler $crawler, DateTime $publishedAt): Property
    {
        $propertyAd = (new PropertyAd)
            ->setProvider(static::PROVIDER)

static::PROVIDER of type null is incompatible with the type string expected by parameter $provider of App\DTO\PropertyAd::setProvider().

            ->setTitle($this->parseTitle($crawler))

Are you sure the usage of $this->parseTitle($crawler) targeting App\Parser\AbstractParser::parseTitle() seems to always return null.

            ->setDescription($this->parseDescription($crawler))

Are you sure the usage of $this->parseDescription($crawler) targeting App\Parser\AbstractParser::parseDescription() seems to always return null.

            ->setPhoto($this->parsePhoto($crawler))

It seems like $this->parsePhoto($crawler) can also be of type null; however, parameter $photo of App\DTO\PropertyAd::setPhoto() does only seem to accept string, maybe add an additional type check?

            ->setUrl($this->parseUrl($crawler))
            ->setPublishedAt($publishedAt);

        $property = (new Property)
            ->setPrice($this->parsePrice($crawler))
            ->setArea($this->parseArea($crawler))
            ->setRoomsCount($this->parseRoomsCount($crawler))
            ->setLocation($this->parseLocation($crawler))

Are you sure the usage of $this->parseLocation($crawler) targeting App\Parser\AbstractParser::parseLocation() seems to always return null.

            ->setBuildingName($this->parseBuildingName($crawler))

Are you sure the usage of $this->parseBuildingName($crawler) targeting App\Parser\AbstractParser::parseBuildingName() seems to always return null.

            ->setAd($propertyAd);

        if ((null !== $provider = $this->providerProvider->find(static::PROVIDER)) && $provider->isNewBuildOnly()) {

static::PROVIDER of type null is incompatible with the type string expected by parameter $name of App\DataProvider\ProviderProvider::find().

            $property->setNewBuild(true);
        } else {
            $property->setNewBuild(u($propertyAd->getTitle() . $propertyAd->getDescription())->containsAny(self::NEW_BUILD_KEYWORDS));
        }

        return $property;
    }
}