ZohoSyncDatabaseCommand::execute() - Code Metrics - Inspection of "Add command option to clear and dump logs" - Wabel/zoho-crm-copy-db - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 3.1.1 ( d44cca )

unknown

created 2019-07-29 12:06 UTC

ZohoSyncDatabaseCommand::execute() F

↳ Parent: ZohoSyncDatabaseCommand

Complexity

Conditions	18
Paths	3679

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	70
rs	0.7
c	0
b	0
f	0
cc	18
nc	3679
nop	2

How to fix Long Method Complexity

<?php

namespace Wabel\Zoho\CRM\Copy;

use Mouf\Utils\Common\Lock;
use Mouf\Utils\Common\LockException;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Logger\ConsoleLogger;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Input\InputOption;
use Wabel\Zoho\CRM\AbstractZohoDao;
use Wabel\Zoho\CRM\Service\EntitiesGeneratorService;
use Wabel\Zoho\CRM\ZohoClient;
use Logger\Formatters\DateTimeFormatter;
use Mouf\Utils\Log\Psr\MultiLogger;
use Wabel\Zoho\CRM\Request\Response;
use zcrmsdk\crm\utility\ZCRMConfigUtil;

class ZohoSyncDatabaseCommand extends Command
{
    /**
     * The list of Zoho DAOs to copy.
     *
     * @var AbstractZohoDao[]
     */
    private $zohoDaos;

    /**
     * @var ZohoDatabaseModelSync
     */
    private $zohoDatabaseModelSync;

    /**
     * @var ZohoDatabaseCopier
     */
    private $zohoDatabaseCopier;

    /**
     * @var ZohoDatabasePusher
     */
    private $zohoDatabaseSync;

    /**
     *
     * @var MultiLogger
     */
    private $logger;

    /**
     * @var Lock
     */
    private $lock;

    /**
     * The Zoho Dao and Beans generator
     *
     * @var EntitiesGeneratorService
     */
    private $zohoEntitiesGenerator;

    /**
     *
     * @var ZohoClient
     */
    private $zohoClient;

    private $pathZohoDaos;

    private $namespaceZohoDaos;

    /**
     *
     * @var Response
     */
    private $usersResponse;

    /**
     * @var string[]
     */
    private $excludedZohoDao;


    /**
     * @param ZohoDatabaseModelSync    $zohoDatabaseModelSync
     * @param ZohoDatabaseCopier       $zohoDatabaseCopier
     * @param ZohoDatabasePusher       $zohoDatabaseSync
     * @param EntitiesGeneratorService $zohoEntitiesGenerator The Zoho Dao and Beans generator
     * @param ZohoClient               $zohoClient
     * @param string                   $pathZohoDaos          Tht path where we need to generate the Daos.
     * @param string                   $namespaceZohoDaos     Daos namespace
     * @param MultiLogger              $logger
     * @param Lock                     $lock                  A lock that can be used to avoid running the same command (copy) twice at the same time
     * @param string[]                 $excludedZohoDao       To exclude Dao and or solve Dao which can create ZohoResponse Error
     */
    public function __construct(ZohoDatabaseModelSync $zohoDatabaseModelSync, ZohoDatabaseCopier $zohoDatabaseCopier, ZohoDatabasePusher $zohoDatabaseSync,
        EntitiesGeneratorService $zohoEntitiesGenerator, ZohoClient $zohoClient,
        $pathZohoDaos, $namespaceZohoDaos, MultiLogger $logger, Lock $lock = null, $excludedZohoDao = []
    ) {
        parent::__construct();
        $this->zohoDatabaseModelSync = $zohoDatabaseModelSync;
        $this->zohoDatabaseCopier = $zohoDatabaseCopier;
        $this->zohoDatabaseSync = $zohoDatabaseSync;
        $this->zohoEntitiesGenerator =  $zohoEntitiesGenerator;
        $this->zohoClient = $zohoClient;
        $this->pathZohoDaos = $pathZohoDaos;
        $this->namespaceZohoDaos = $namespaceZohoDaos;
        $this->logger = $logger;
        $this->lock = $lock;
        $this->excludedZohoDao = $excludedZohoDao;
    }

    protected function configure()
    {
        $this
            ->setName('zoho:sync')
            ->setDescription('Synchronize the Zoho CRM data in a local database.')
            ->addOption('reset', 'r', InputOption::VALUE_NONE, 'Get a fresh copy of Zoho (rather than doing incremental copy)')
            ->addOption('skip-trigger', 's', InputOption::VALUE_NONE, 'Do not create or update the trigger')
            ->addOption('fetch-only', 'f', InputOption::VALUE_NONE, 'Fetch only the Zoho data in local database')
            ->addOption('push-only', 'p', InputOption::VALUE_NONE, 'Push only the local data to Zoho')
            ->addOption('limit', 'l', InputOption::VALUE_NONE, 'use defined memory limit or unlimited memory limit')
            ->addOption('log-path', null, InputOption::VALUE_NONE, 'Set the path of logs file')
            ->addOption('clear-logs', null, InputOption::VALUE_NONE, 'Clear logs file at startup')
            ->addOption('dump-logs', null, InputOption::VALUE_NONE, 'Dump logs into console when command finishes');
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->logger->addLogger(new DateTimeFormatter(new ConsoleLogger($output)));
        try {
            if ($this->lock) {
                $this->lock->acquireLock();
            }

            // TODO: find a better way when zohocrm/php-sdk:src/crm/utility/Logger.php will allow to get the filename, delete, etc.
            if ($input->getOption('log-path') && $input->getOption('clear-logs')) {
                $output->writeln('Clearing logs...');
                $path = $input->getOption('log-path');
                $logFile = $path . '/ZCRMClientLibrary.log';
                if (file_exists($logFile)) {
                    if (is_writable($logFile)) {
                        if (file_put_contents($logFile, '') === false) {
                            $output->writeln(sprintf('<error>Error when clearing log file in %s</error>', $logFile));
                        }
                    } else {
                        $output->writeln(sprintf('<warning>Cannot write into log file in %s</warning>', $logFile));
                    }
                } else {
                    $output->writeln(sprintf('<warning>Cannot find log file in %s</warning>', $logFile));
                }
            }

            if(!$input->getOption('limit')) {
                ini_set('memory_limit', '-1');
            }

            if ($input->getOption('fetch-only') && $input->getOption('push-only')) {
                $output->writeln('<error>Options fetch-only and push-only are mutually exclusive.</error>');
            }

            $this->syncUserModel($output);

            $this->regenerateZohoDao($output);

            $this->syncModel($input, $output);

            if (!$input->getOption('push-only')) {
                $this->fetchUserDb($input, $output);
                $this->fetchDb($input, $output);
            }
            if (!$input->getOption('fetch-only')) {
                $this->pushDb($output);
            }

            if ($input->getOption('log-path') && $input->getOption('dump-logs')) {
                $output->writeln('Dumping logs...');
                $path = $input->getOption('log-path');
                $logFile = $path . '/ZCRMClientLibrary.log';
                if (file_exists($logFile)) {
                    if (is_readable($logFile)) {
                        $output->writeln(file_get_contents($logFile));
                    } else {
                        $output->writeln(sprintf('<warning>Cannot read into log file in %s</warning>', $logFile));
                    }
                } else {
                    $output->writeln(sprintf('<warning>Cannot find log file in %s</warning>', $logFile));
                }
            }

            if ($this->lock) {
                $this->lock->releaseLock();
            }
        } catch (LockException $e) {
            $output->writeln('<error>Could not start zoho:copy-db copy command. Another zoho:copy-db copy command is already running.</error>');
        }
    }

    /**
     * Sychronizes the model of the database with Zoho records.
     *
     * @param OutputInterface $output
     */
    private function syncModel(InputInterface $input, OutputInterface $output)
    {
        $twoWaysSync = !$input->getOption('fetch-only');
        $skipCreateTrigger = $input->getOption('skip-trigger');

        $output->writeln('Starting synchronize Zoho data into Zoho CRM.');
        foreach ($this->zohoDaos as $zohoDao) {
            $this->zohoDatabaseModelSync->synchronizeDbModel($zohoDao, $twoWaysSync, $skipCreateTrigger);
        }
        $output->writeln('Zoho data successfully synchronized.');
    }

    /**
     * Sychronizes the model of the database with Zoho Users records.
     *
     * @param OutputInterface $output
     */
    private function syncUserModel(OutputInterface $output)
    {
        $output->writeln('Starting synchronize Zoho users model.');
        $this->zohoDatabaseModelSync->synchronizeUserDbModel();
        $output->writeln('Zoho users model successfully synchronized.');
    }

    /**
     * Regerate Zoho Daos
     *
     * @param InputInterface  $input
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param OutputInterface $output
     */
    private function regenerateZohoDao(OutputInterface $output)
    {
        $output->writeln("Start to generate all the zoho daos.");
        $zohoModules = $this->zohoEntitiesGenerator->generateAll($this->pathZohoDaos, $this->namespaceZohoDaos);
        foreach ($zohoModules as $daoFullClassName) {
            /* @var $zohoDao AbstractZohoDao */
            $zohoDao = new $daoFullClassName($this->zohoClient);
            //To have more module which is use time of modification (createdTime or lastActivityTime).
            //use an array of Excluded Dao by full namespace
            if (($this->excludedZohoDao && in_array(get_class($zohoDao), $this->excludedZohoDao))) {

                continue;
            }
            $this->zohoDaos [] = $zohoDao;
            $output->writeln(sprintf('<info>%s has created</info>', get_class($zohoDao)));
        }
        $output->writeln("Success to create all the zoho daos.");
    }

    /**
     * Run the fetch User Db command.
     *
     * @param InputInterface  $input
     * @param OutputInterface $output
     */
    private function fetchUserDb(InputInterface $input, OutputInterface $output)

    {
        $output->writeln('Starting copying Zoho users data into local database.');
        $this->zohoDatabaseCopier->fetchUserFromZoho();
        $output->writeln('Zoho users data successfully copied.');
    }
    
    
    /**
     * Run the fetch Db command.
     *
     * @param InputInterface  $input
     * @param OutputInterface $output
     */
    private function fetchDb(InputInterface $input, OutputInterface $output)
    {
        if ($input->getOption('reset')) {
            $incremental = false;
        } else {
            $incremental = true;
        }

        $twoWaysSync = !$input->getOption('fetch-only');

        $output->writeln('Starting copying Zoho data into local database.');
        foreach ($this->zohoDaos as $zohoDao) {
                $output->writeln(sprintf('Copying data using <info>%s</info>', get_class($zohoDao)));
                $this->zohoDatabaseCopier->fetchFromZoho($zohoDao, $incremental, $twoWaysSync);
        }
        $output->writeln('Zoho data successfully copied.');
    }

    /**
     * Run the push Db command.
     *
     * @param OutputInterface $output
     */
    private function pushDb(OutputInterface $output)
    {
        $output->writeln('Starting synchronize Zoho data into Zoho CRM.');
        foreach ($this->zohoDaos as $zohoDao) {
            if($zohoDao->getFieldFromFieldName('createdTime')) {
                $this->zohoDatabaseSync->pushToZoho($zohoDao);
            }
        }
        $output->writeln('Zoho data successfully synchronized.');
    }
}


1			<?php
2
3			namespace Wabel\Zoho\CRM\Copy;
4
5			use Mouf\Utils\Common\Lock;
6			use Mouf\Utils\Common\LockException;
7			use Symfony\Component\Console\Command\Command;
8			use Symfony\Component\Console\Input\InputInterface;
9			use Symfony\Component\Console\Logger\ConsoleLogger;
10			use Symfony\Component\Console\Output\OutputInterface;
11			use Symfony\Component\Console\Input\InputOption;
12			use Wabel\Zoho\CRM\AbstractZohoDao;
13			use Wabel\Zoho\CRM\Service\EntitiesGeneratorService;
14			use Wabel\Zoho\CRM\ZohoClient;
15			use Logger\Formatters\DateTimeFormatter;
16			use Mouf\Utils\Log\Psr\MultiLogger;
17			use Wabel\Zoho\CRM\Request\Response;
18			use zcrmsdk\crm\utility\ZCRMConfigUtil;
19
20			class ZohoSyncDatabaseCommand extends Command
21			{
22			/**
23			* The list of Zoho DAOs to copy.
24			*
25			* @var AbstractZohoDao[]
26			*/
27			private $zohoDaos;
28
29			/**
30			* @var ZohoDatabaseModelSync
31			*/
32			private $zohoDatabaseModelSync;
33
34			/**
35			* @var ZohoDatabaseCopier
36			*/
37			private $zohoDatabaseCopier;
38
39			/**
40			* @var ZohoDatabasePusher
41			*/
42			private $zohoDatabaseSync;
43
44			/**
45			*
46			* @var MultiLogger
47			*/
48			private $logger;
49
50			/**
51			* @var Lock
52			*/
53			private $lock;
54
55			/**
56			* The Zoho Dao and Beans generator
57			*
58			* @var EntitiesGeneratorService
59			*/
60			private $zohoEntitiesGenerator;
61
62			/**
63			*
64			* @var ZohoClient
65			*/
66			private $zohoClient;
67
68			private $pathZohoDaos;
69
70			private $namespaceZohoDaos;
71
72			/**
73			*
74			* @var Response
75			*/
76			private $usersResponse;
77
78			/**
79			* @var string[]
80			*/
81			private $excludedZohoDao;
82
83
84			/**
85			* @param ZohoDatabaseModelSync $zohoDatabaseModelSync
86			* @param ZohoDatabaseCopier $zohoDatabaseCopier
87			* @param ZohoDatabasePusher $zohoDatabaseSync
88			* @param EntitiesGeneratorService $zohoEntitiesGenerator The Zoho Dao and Beans generator
89			* @param ZohoClient $zohoClient
90			* @param string $pathZohoDaos Tht path where we need to generate the Daos.
91			* @param string $namespaceZohoDaos Daos namespace
92			* @param MultiLogger $logger
93			* @param Lock $lock A lock that can be used to avoid running the same command (copy) twice at the same time
94			* @param string[] $excludedZohoDao To exclude Dao and or solve Dao which can create ZohoResponse Error
95			*/
96			public function __construct(ZohoDatabaseModelSync $zohoDatabaseModelSync, ZohoDatabaseCopier $zohoDatabaseCopier, ZohoDatabasePusher $zohoDatabaseSync,
97			EntitiesGeneratorService $zohoEntitiesGenerator, ZohoClient $zohoClient,
98			$pathZohoDaos, $namespaceZohoDaos, MultiLogger $logger, Lock $lock = null, $excludedZohoDao = []
99			) {
100			parent::__construct();
101			$this->zohoDatabaseModelSync = $zohoDatabaseModelSync;
102			$this->zohoDatabaseCopier = $zohoDatabaseCopier;
103			$this->zohoDatabaseSync = $zohoDatabaseSync;
104			$this->zohoEntitiesGenerator = $zohoEntitiesGenerator;
105			$this->zohoClient = $zohoClient;
106			$this->pathZohoDaos = $pathZohoDaos;
107			$this->namespaceZohoDaos = $namespaceZohoDaos;
108			$this->logger = $logger;
109			$this->lock = $lock;
110			$this->excludedZohoDao = $excludedZohoDao;
111			}
112
113			protected function configure()
114			{
115			$this
116			->setName('zoho:sync')
117			->setDescription('Synchronize the Zoho CRM data in a local database.')
118			->addOption('reset', 'r', InputOption::VALUE_NONE, 'Get a fresh copy of Zoho (rather than doing incremental copy)')
119			->addOption('skip-trigger', 's', InputOption::VALUE_NONE, 'Do not create or update the trigger')
120			->addOption('fetch-only', 'f', InputOption::VALUE_NONE, 'Fetch only the Zoho data in local database')
121			->addOption('push-only', 'p', InputOption::VALUE_NONE, 'Push only the local data to Zoho')
122			->addOption('limit', 'l', InputOption::VALUE_NONE, 'use defined memory limit or unlimited memory limit')
123			->addOption('log-path', null, InputOption::VALUE_NONE, 'Set the path of logs file')
124			->addOption('clear-logs', null, InputOption::VALUE_NONE, 'Clear logs file at startup')
125			->addOption('dump-logs', null, InputOption::VALUE_NONE, 'Dump logs into console when command finishes');
126			}
127
128			protected function execute(InputInterface $input, OutputInterface $output)
129			{
130			$this->logger->addLogger(new DateTimeFormatter(new ConsoleLogger($output)));
131			try {
132			if ($this->lock) {
133			$this->lock->acquireLock();
134			}
135
136			// TODO: find a better way when zohocrm/php-sdk:src/crm/utility/Logger.php will allow to get the filename, delete, etc.
137			if ($input->getOption('log-path') && $input->getOption('clear-logs')) {
138			$output->writeln('Clearing logs...');
139			$path = $input->getOption('log-path');
140			$logFile = $path . '/ZCRMClientLibrary.log';
141			if (file_exists($logFile)) {
142			if (is_writable($logFile)) {
143			if (file_put_contents($logFile, '') === false) {
144			$output->writeln(sprintf('<error>Error when clearing log file in %s</error>', $logFile));
145			}
146			} else {
147			$output->writeln(sprintf('<warning>Cannot write into log file in %s</warning>', $logFile));
148			}
149			} else {
150			$output->writeln(sprintf('<warning>Cannot find log file in %s</warning>', $logFile));
151			}
152			}
153
154			if(!$input->getOption('limit')) {
155			ini_set('memory_limit', '-1');
156			}
157
158			if ($input->getOption('fetch-only') && $input->getOption('push-only')) {
159			$output->writeln('<error>Options fetch-only and push-only are mutually exclusive.</error>');
160			}
161
162			$this->syncUserModel($output);
163
164			$this->regenerateZohoDao($output);
165
166			$this->syncModel($input, $output);
167
168			if (!$input->getOption('push-only')) {
169			$this->fetchUserDb($input, $output);
170			$this->fetchDb($input, $output);
171			}
172			if (!$input->getOption('fetch-only')) {
173			$this->pushDb($output);
174			}
175
176			if ($input->getOption('log-path') && $input->getOption('dump-logs')) {
177			$output->writeln('Dumping logs...');
178			$path = $input->getOption('log-path');
179			$logFile = $path . '/ZCRMClientLibrary.log';
180			if (file_exists($logFile)) {
181			if (is_readable($logFile)) {
182			$output->writeln(file_get_contents($logFile));
183			} else {
184			$output->writeln(sprintf('<warning>Cannot read into log file in %s</warning>', $logFile));
185			}
186			} else {
187			$output->writeln(sprintf('<warning>Cannot find log file in %s</warning>', $logFile));
188			}
189			}
190
191			if ($this->lock) {
192			$this->lock->releaseLock();
193			}
194			} catch (LockException $e) {
195			$output->writeln('<error>Could not start zoho:copy-db copy command. Another zoho:copy-db copy command is already running.</error>');
196			}
197			}
198
199			/**
200			* Sychronizes the model of the database with Zoho records.
201			*
202			* @param OutputInterface $output
203			*/
204			private function syncModel(InputInterface $input, OutputInterface $output)
205			{
206			$twoWaysSync = !$input->getOption('fetch-only');
207			$skipCreateTrigger = $input->getOption('skip-trigger');
208
209			$output->writeln('Starting synchronize Zoho data into Zoho CRM.');
210			foreach ($this->zohoDaos as $zohoDao) {
211			$this->zohoDatabaseModelSync->synchronizeDbModel($zohoDao, $twoWaysSync, $skipCreateTrigger);
212			}
213			$output->writeln('Zoho data successfully synchronized.');
214			}
215
216			/**
217			* Sychronizes the model of the database with Zoho Users records.
218			*
219			* @param OutputInterface $output
220			*/
221			private function syncUserModel(OutputInterface $output)
222			{
223			$output->writeln('Starting synchronize Zoho users model.');
224			$this->zohoDatabaseModelSync->synchronizeUserDbModel();
225			$output->writeln('Zoho users model successfully synchronized.');
226			}
227
228			/**
229			* Regerate Zoho Daos
230			*
231			* @param InputInterface $input
			0 ignored issues – show Bug introduced 2016-10-09 17:35 UTC by Report Bug Copy Issue Report There is no parameter named `$input`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
232			* @param OutputInterface $output
233			*/
234			private function regenerateZohoDao(OutputInterface $output)
235			{
236			$output->writeln("Start to generate all the zoho daos.");
237			$zohoModules = $this->zohoEntitiesGenerator->generateAll($this->pathZohoDaos, $this->namespaceZohoDaos);
238			foreach ($zohoModules as $daoFullClassName) {
239			/* @var $zohoDao AbstractZohoDao */
240			$zohoDao = new $daoFullClassName($this->zohoClient);
241			//To have more module which is use time of modification (createdTime or lastActivityTime).
242			//use an array of Excluded Dao by full namespace
243			if (($this->excludedZohoDao && in_array(get_class($zohoDao), $this->excludedZohoDao))) {
			0 ignored issues – show Bug Best Practice introduced 2019-03-11 22:17 UTC by Report Bug Copy Issue Report The expression `$this->excludedZohoDao` of type `string[]` 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. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
244			continue;
245			}
246			$this->zohoDaos [] = $zohoDao;
247			$output->writeln(sprintf('<info>%s has created</info>', get_class($zohoDao)));
248			}
249			$output->writeln("Success to create all the zoho daos.");
250			}
251
252			/**
253			* Run the fetch User Db command.
254			*
255			* @param InputInterface $input
256			* @param OutputInterface $output
257			*/
258			private function fetchUserDb(InputInterface $input, OutputInterface $output)
			0 ignored issues – show Unused Code introduced 2017-12-04 17:38 UTC by Report Bug Copy Issue Report The parameter `$input` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
259			{
260			$output->writeln('Starting copying Zoho users data into local database.');
261			$this->zohoDatabaseCopier->fetchUserFromZoho();
262			$output->writeln('Zoho users data successfully copied.');
263			}
264
265
266			/**
267			* Run the fetch Db command.
268			*
269			* @param InputInterface $input
270			* @param OutputInterface $output
271			*/
272			private function fetchDb(InputInterface $input, OutputInterface $output)
273			{
274			if ($input->getOption('reset')) {
275			$incremental = false;
276			} else {
277			$incremental = true;
278			}
279
280			$twoWaysSync = !$input->getOption('fetch-only');
281
282			$output->writeln('Starting copying Zoho data into local database.');
283			foreach ($this->zohoDaos as $zohoDao) {
284			$output->writeln(sprintf('Copying data using <info>%s</info>', get_class($zohoDao)));
285			$this->zohoDatabaseCopier->fetchFromZoho($zohoDao, $incremental, $twoWaysSync);
286			}
287			$output->writeln('Zoho data successfully copied.');
288			}
289
290			/**
291			* Run the push Db command.
292			*
293			* @param OutputInterface $output
294			*/
295			private function pushDb(OutputInterface $output)
296			{
297			$output->writeln('Starting synchronize Zoho data into Zoho CRM.');
298			foreach ($this->zohoDaos as $zohoDao) {
299			if($zohoDao->getFieldFromFieldName('createdTime')) {
300			$this->zohoDatabaseSync->pushToZoho($zohoDao);
301			}
302			}
303			$output->writeln('Zoho data successfully synchronized.');
304			}
305			}
306

Wabel / zoho-crm-copy-db

Push — 3.1.1 ( d44cca )

ZohoSyncDatabaseCommand::execute() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like