Loevgaard\DandomainConsignmentBundle\ConsignmentService\ConsignmentService

Complexity

Total Complexity

41

Size/Duplication

Total Lines	374
Duplicated Lines	4.81 %

Coupling/Cohesion

Components	2
Dependencies	12

Test Coverage

Coverage

0%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	3
C	generateReport()	0	50	8
A	generateReportFile()	0	15	2
B	deliverReport()	0	34	4
C	queryBuilder()	0	46	7
A	getProductQueryBuilder()	0	17	2
A	getIncludedProductIds()	0	15	2
A	getExcludedProductIds()	0	4	1
A	getProductIdsFromProductNumbers()	0	14	1
A	validateBarCodes()	9	20	3
A	validateVendorNumbers()	9	23	3
A	getFile()	0	8	2
A	configureGenerateReportOptions()	0	9	1
A	configureQueryBuilderOptions()	0	15	1
A	queryBuilderOptions()	0	10	1

<?php

declare(strict_types=1);

namespace Loevgaard\DandomainConsignmentBundle\ConsignmentService;

use Doctrine\Common\Persistence\ManagerRegistry;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\QueryBuilder;
use Loevgaard\DandomainConsignment\Entity\Generated\ReportInterface;
use Loevgaard\DandomainConsignment\Entity\Report;
use Loevgaard\DandomainConsignment\Repository\ReportRepository;
use Loevgaard\DandomainConsignmentBundle\Exception\InvalidBarCodeException;
use Loevgaard\DandomainConsignmentBundle\Exception\InvalidVendorNumberException;
use Loevgaard\DandomainFoundation\Entity\Generated\ManufacturerInterface;
use Loevgaard\DandomainStock\Entity\Generated\StockMovementInterface;
use Loevgaard\DandomainStock\Entity\StockMovement;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Symfony\Component\OptionsResolver\OptionsResolver;

abstract class ConsignmentService implements ConsignmentServiceInterface
{
    /**
     * @var EntityManager
     */
    protected $entityManager;

    /**
     * @var ReportRepository
     */
    protected $reportRepository;

    /**
     * The directory where report files will be saved
     *
     * @var string
     */
    protected $reportDir;

    /**
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * @var ManufacturerInterface
     */
    protected $manufacturer;

    /**
     * Contains the included product ids
     *
     * @var array
     */
    protected $includedProductIds;

    public function __construct(ManagerRegistry $managerRegistry, ReportRepository $reportRepository, string $reportDir)
    {
        $this->entityManager = $managerRegistry->getManager();
        $this->reportRepository = $reportRepository;
        $this->reportDir = rtrim($reportDir, '/');
        $this->logger = new NullLogger();

        if(!is_dir($this->reportDir)) {
            throw new \InvalidArgumentException('The report dir given is not a directory');
        }

        if(!is_writable($this->reportDir)) {
            throw new \InvalidArgumentException('The report dir given is not writable');
        }
    }

    /**
     * @param array $options
     * @return ReportInterface
     * @throws \Doctrine\ORM\ORMException
     */
    public function generateReport(array $options = []): ReportInterface
    {
        // resolve options
        $resolver = new OptionsResolver();
        $this->configureGenerateReportOptions($resolver);
        $options = $resolver->resolve($options);

        $report = new Report();
        $report->setManufacturer($this->manufacturer);

        $this->reportRepository->persist($report);

        try {
            if($options['valid_bar_codes']) {
                $this->validateBarCodes();
            }

            if($options['valid_vendor_numbers']) {
                $this->validateVendorNumbers();
            }

            $qb = $this->queryBuilder();

            /** @var StockMovementInterface[] $stockMovements */
            $stockMovements = $qb->getQuery()->getResult();

            if(!count($stockMovements)) {
                throw new \Exception('No stock movements applicable for this report');
            }

            $lastStockMovement = null;
            foreach ($stockMovements as $stockMovement) {
                $report->addStockMovement($stockMovement);

                $lastStockMovement = $stockMovement;
            }

            if ($lastStockMovement && $options['update_last_stock_movement']) {
                $this->manufacturer->setConsignmentLastStockMovement($lastStockMovement);
            }

            $report->markAsSuccess();
        } catch (\Exception $e) {
            $report->markAsError($e->getMessage());
        }

        $this->reportRepository->flush();

        return $report;
    }

    public function generateReportFile(ReportInterface $report, array $options = []): \SplFileObject
    {
        $file = $this->getFile();

        foreach ($report->getStockMovements() as $stockMovement) {
            $file->fputcsv([
                $stockMovement->getQuantity(),
                $stockMovement->getProduct()->getBarCodeNumber(),
            ]);
        }

        $report->setFile($file);

        return $file;
    }

    public function deliverReport(ReportInterface $report, array $options = []) : bool
    {
        if(!$report->isDeliverable()) {
            return false;
        }

        $file = $report->getFile();
        if(!$file || $file->isFile()) {
            $file = $this->generateReportFile($report);
        }

        $this->logger->info('File has been delivered to: '.$file->getPathname());

        /*

55% of this comment could be valid code. Did you maybe forget this after debugging?

        Example of mailing the report
        -------
        $recipients = ['johndoe@example.com'];

        $attachment = \Swift_Attachment::fromPath($reportFile->getPathname());
        $attachment->setFilename('report-'.$report->getId().'.csv');

        $message = \Swift_Message::newInstance()
            ->attach($attachment)
            ->setSubject('Consignment report (id: '.$report->getId().')')
            ->setFrom('william@yourbusiness.com', 'Your Business')
            ->setTo($recipients)
            ->setBody('See the attached file.', 'text/plain')
        ;

        $this->mailer->send($message);
        */

        return true;
    }

    public function queryBuilder(array $options = [], string $alias = 's'): QueryBuilder
    {
        // resolve options
        $resolver = new OptionsResolver();
        $this->configureQueryBuilderOptions($resolver);
        $options = $resolver->resolve($options);

        $includedProductIds = $this->getIncludedProductIds();

        if (!count($includedProductIds)) {
            throw new \RuntimeException('No included product ids. Something is wrong');
        }

        $qb = $this->entityManager->createQueryBuilder();
        $qb->select('s, p')
            ->from('AppBundle:StockMovement', 's')
            ->join('s.product', 'p')
            ->andWhere($qb->expr()->in('p.id', ':includedProductIds'))
            ->andWhere($qb->expr()->in('s.type', ':stockMovementTypes'))
            ->addOrderBy('s.id', 'asc')
            ->setParameters([
                'includedProductIds' => $includedProductIds,
                'stockMovementTypes' => $options['stock_movement_types']
            ]);

        if(!$options['include_complaints']) {
            $qb->andWhere('s.complaint = 0');
        }

        if ($options['use_last_stock_movement'] && $this->manufacturer->getConsignmentLastStockMovement()) {
            $qb->andWhere($qb->expr()->gt('s.id', ':lastStockMovementId'))
                ->setParameter('lastStockMovementId', $this->manufacturer->getConsignmentLastStockMovement()->getId());
        }

        if($options['start_date']) {
            $qb->andWhere($qb->expr()->gte('s.createdAt', ':startDate'))
                ->setParameter('startDate', $options['start_date']);
        }

        if($options['end_date']) {
            $qb->andWhere($qb->expr()->lte('s.createdAt', ':endDate'))
                ->setParameter('endDate', $options['end_date']);
        }

        return $qb;
    }

    public function getProductQueryBuilder(string $alias = 'p'): QueryBuilder
    {
        $excludedProductIds = $this->getExcludedProductIds();

        $qb = $this->entityManager->createQueryBuilder();
        $qb->select($alias)
            ->from('Loevgaard\DandomainFoundation\Entity\Product', $alias)
            ->where($qb->expr()->isMemberOf(':manufacturer', $alias.'.manufacturers'))
            ->setParameter('manufacturer', $this->manufacturer);

        if(!empty($excludedProductIds)) {
            $qb->andWhere($qb->expr()->notIn($alias.'.id', ':excluded'))
                ->setParameter('excluded', $excludedProductIds);
        }

        return $qb;
    }

    /**
     * This method should return an array of included product ids
     * It excludes the excluded product ids, by using the getProductQueryBuilder method
     *
     * @return array
     */
    protected function getIncludedProductIds() : array
    {
        if(!$this->includedProductIds) {

The expression $this->includedProductIds of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            $qb = $this->getProductQueryBuilder();
            $qb->select('p.id');

            $res = $qb->getQuery()->getArrayResult();

            $this->includedProductIds = array_map(function ($elm) {
                return array_values($elm)[0];
            }, $res);
        }

        return $this->includedProductIds;
    }

    /**
     * This method should return an array of excluded product ids
     *
     * @return array
     */
    protected function getExcludedProductIds() : array
    {
        return [];
    }

    /**
     * This is a helper method which takes an array of product numbers and returns their respective product ids
     *
     * @param array $numbers
     * @return array
     */
    protected function getProductIdsFromProductNumbers(array $numbers) : array
    {
        $qb = $this->entityManager->createQueryBuilder();
        $qb->select('p.id')
            ->from('Loevgaard\DandomainFoundation\Entity\Product', 'p')
            ->where($qb->expr()->in('p.number', ':numbers'))
            ->setParameter('numbers', $numbers);

        $res = $qb->getQuery()->getArrayResult();

        return array_map(function ($elm) {
            return array_values($elm)[0];
        }, $res);
    }

    /**
     * @throws InvalidBarCodeException
     */
    protected function validateBarCodes() : void
    {
        $qb = $this->queryBuilder();
        $qb->andWhere('p.validBarCode = 0');

        /** @var StockMovementInterface[] $stockMovements */
        $stockMovements = $qb->getQuery()->getResult();

        $c = count($stockMovements);

        if($c) {

This code seems to be duplicated across your project.

            $this->logger->emergency('There are '.$c.' stock movements with invalid bar codes');
            $productNumbers = [];
            foreach ($stockMovements as $stockMovement) {
                $productNumbers[] = $stockMovement->getProduct()->getNumber();
            }

            throw new InvalidBarCodeException('Products with invalid bar codes: '.join(', ', $productNumbers), $productNumbers);
        }
    }

    /**
     * @throws InvalidVendorNumberException
     */
    protected function validateVendorNumbers() : void
    {
        $qb = $this->queryBuilder();
        $qb->andWhere($qb->expr()->orX(
            $qb->expr()->eq('p.vendorNumber', ':empty'),
            $qb->expr()->isNull('p.vendorNumber')
        ))->setParameter(':empty', '');

        /** @var StockMovementInterface[] $stockMovements */
        $stockMovements = $qb->getQuery()->getResult();

        $c = count($stockMovements);

        if($c) {

This code seems to be duplicated across your project.

            $this->logger->critical('There are '.$c.' stock movements with invalid vendor numbers');
            $productNumbers = [];
            foreach ($stockMovements as $stockMovement) {
                $productNumbers[] = $stockMovement->getProduct()->getNumber();
            }

            throw new InvalidVendorNumberException('Products with invalid vendor numbers: '.join($productNumbers), $productNumbers);
        }
    }

    protected function getFile(string $extension = 'csv') : \SplFileObject
    {
        do {
            $filename = $this->reportDir.'/'.uniqid('consignment-', true).'.'.$extension;
        } while(file_exists($filename));

        return new \SplFileObject($filename, 'w+');
    }

    protected function configureGenerateReportOptions(OptionsResolver $resolver) : void
    {
        $resolver->setDefined($this->queryBuilderOptions());
        $resolver->setDefaults([
            'valid_bar_codes' => false,
            'valid_vendor_numbers' => false,
            'update_last_stock_movement' => true,
        ]);
    }

    protected function configureQueryBuilderOptions(OptionsResolver $resolver) : void
    {
        $resolver->setDefined($this->queryBuilderOptions());
        $resolver->setDefaults([
            'stock_movement_types' => [
                StockMovement::TYPE_RETURN,
                StockMovement::TYPE_SALE,
                StockMovement::TYPE_REGULATION
            ],
            'include_complaints' => false,
            'use_last_stock_movement' => true,
            'start_date' => null,
            'end_date' => null,
        ]);
    }

    protected function queryBuilderOptions() : array
    {
        return [
            'stock_movement_types',
            'include_complaints',
            'use_last_stock_movement',
            'start_date',
            'end_date',
        ];
    }
}