Code Duplication - Jalle19/tvheadend-status-manager - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 22-22 lines in 11 locations

src/cli/Database/Base/ChannelQuery.php 1 location


     *
     * @return $this|ChildChannelQuery The current query, for fluid interface
     */
    public function filterById($id = null, $comparison = null)
    {
        if (is_array($id)) {
            $useMinMax = false;
            if (isset($id['min'])) {
                $this->addUsingAlias(ChannelTableMap::COL_ID, $id['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($id['max'])) {
                $this->addUsingAlias(ChannelTableMap::COL_ID, $id['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(ChannelTableMap::COL_ID, $id, $comparison);
    }

    /**
     * Filter the query on the instance_name column

src/cli/Database/Base/ConnectionQuery.php 3 locations


     *
     * @return $this|ChildConnectionQuery The current query, for fluid interface
     */
    public function filterById($id = null, $comparison = null)
    {
        if (is_array($id)) {
            $useMinMax = false;
            if (isset($id['min'])) {
                $this->addUsingAlias(ConnectionTableMap::COL_ID, $id['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($id['max'])) {
                $this->addUsingAlias(ConnectionTableMap::COL_ID, $id['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(ConnectionTableMap::COL_ID, $id, $comparison);
    }

    /**
     * Filter the query on the instance_name column

     *
     * @return $this|ChildConnectionQuery The current query, for fluid interface
     */
    public function filterByUserId($userId = null, $comparison = null)
    {
        if (is_array($userId)) {
            $useMinMax = false;
            if (isset($userId['min'])) {
                $this->addUsingAlias(ConnectionTableMap::COL_USER_ID, $userId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($userId['max'])) {
                $this->addUsingAlias(ConnectionTableMap::COL_USER_ID, $userId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(ConnectionTableMap::COL_USER_ID, $userId, $comparison);
    }

    /**
     * Filter the query on the peer column

     *
     * @return $this|ChildConnectionQuery The current query, for fluid interface
     */
    public function filterByStarted($started = null, $comparison = null)
    {
        if (is_array($started)) {
            $useMinMax = false;
            if (isset($started['min'])) {
                $this->addUsingAlias(ConnectionTableMap::COL_STARTED, $started['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($started['max'])) {
                $this->addUsingAlias(ConnectionTableMap::COL_STARTED, $started['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(ConnectionTableMap::COL_STARTED, $started, $comparison);
    }

    /**
     * Filter the query on the type column

src/cli/Database/Base/SubscriptionQuery.php 6 locations


     *
     * @return $this|ChildSubscriptionQuery The current query, for fluid interface
     */
    public function filterById($id = null, $comparison = null)
    {
        if (is_array($id)) {
            $useMinMax = false;
            if (isset($id['min'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_ID, $id['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($id['max'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_ID, $id['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(SubscriptionTableMap::COL_ID, $id, $comparison);
    }

    /**
     * Filter the query on the instance_name column

     *
     * @return $this|ChildSubscriptionQuery The current query, for fluid interface
     */
    public function filterByUserId($userId = null, $comparison = null)
    {
        if (is_array($userId)) {
            $useMinMax = false;
            if (isset($userId['min'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_USER_ID, $userId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($userId['max'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_USER_ID, $userId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(SubscriptionTableMap::COL_USER_ID, $userId, $comparison);
    }

    /**
     * Filter the query on the channel_id column

     *
     * @return $this|ChildSubscriptionQuery The current query, for fluid interface
     */
    public function filterByChannelId($channelId = null, $comparison = null)
    {
        if (is_array($channelId)) {
            $useMinMax = false;
            if (isset($channelId['min'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_CHANNEL_ID, $channelId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($channelId['max'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_CHANNEL_ID, $channelId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(SubscriptionTableMap::COL_CHANNEL_ID, $channelId, $comparison);
    }

    /**
     * Filter the query on the subscription_id column

     *
     * @return $this|ChildSubscriptionQuery The current query, for fluid interface
     */
    public function filterBySubscriptionId($subscriptionId = null, $comparison = null)
    {
        if (is_array($subscriptionId)) {
            $useMinMax = false;
            if (isset($subscriptionId['min'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_SUBSCRIPTION_ID, $subscriptionId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($subscriptionId['max'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_SUBSCRIPTION_ID, $subscriptionId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(SubscriptionTableMap::COL_SUBSCRIPTION_ID, $subscriptionId, $comparison);
    }

    /**
     * Filter the query on the started column

     *
     * @return $this|ChildSubscriptionQuery The current query, for fluid interface
     */
    public function filterByStarted($started = null, $comparison = null)
    {
        if (is_array($started)) {
            $useMinMax = false;
            if (isset($started['min'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_STARTED, $started['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($started['max'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_STARTED, $started['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(SubscriptionTableMap::COL_STARTED, $started, $comparison);
    }

    /**
     * Filter the query on the stopped column

     *
     * @return $this|ChildSubscriptionQuery The current query, for fluid interface
     */
    public function filterByStopped($stopped = null, $comparison = null)
    {
        if (is_array($stopped)) {
            $useMinMax = false;
            if (isset($stopped['min'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_STOPPED, $stopped['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($stopped['max'])) {
                $this->addUsingAlias(SubscriptionTableMap::COL_STOPPED, $stopped['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(SubscriptionTableMap::COL_STOPPED, $stopped, $comparison);
    }

    /**
     * Filter the query on the title column

src/cli/Database/Base/UserQuery.php 1 location


     *
     * @return $this|ChildUserQuery The current query, for fluid interface
     */
    public function filterById($id = null, $comparison = null)
    {
        if (is_array($id)) {
            $useMinMax = false;
            if (isset($id['min'])) {
                $this->addUsingAlias(UserTableMap::COL_ID, $id['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($id['max'])) {
                $this->addUsingAlias(UserTableMap::COL_ID, $id['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(UserTableMap::COL_ID, $id, $comparison);
    }

    /**
     * Filter the query on the instance_name column

		@@ 279-300 (lines=22) @@
276		*
277		* @return $this\|ChildChannelQuery The current query, for fluid interface
278		*/
279		public function filterById($id = null, $comparison = null)
280		{
281		if (is_array($id)) {
282		$useMinMax = false;
283		if (isset($id['min'])) {
284		$this->addUsingAlias(ChannelTableMap::COL_ID, $id['min'], Criteria::GREATER_EQUAL);
285		$useMinMax = true;
286		}
287		if (isset($id['max'])) {
288		$this->addUsingAlias(ChannelTableMap::COL_ID, $id['max'], Criteria::LESS_EQUAL);
289		$useMinMax = true;
290		}
291		if ($useMinMax) {
292		return $this;
293		}
294		if (null === $comparison) {
295		$comparison = Criteria::IN;
296		}
297		}
298
299		return $this->addUsingAlias(ChannelTableMap::COL_ID, $id, $comparison);
300		}
301
302		/**
303		* Filter the query on the instance_name column

		@@ 294-315 (lines=22) @@
291		*
292		* @return $this\|ChildConnectionQuery The current query, for fluid interface
293		*/
294		public function filterById($id = null, $comparison = null)
295		{
296		if (is_array($id)) {
297		$useMinMax = false;
298		if (isset($id['min'])) {
299		$this->addUsingAlias(ConnectionTableMap::COL_ID, $id['min'], Criteria::GREATER_EQUAL);
300		$useMinMax = true;
301		}
302		if (isset($id['max'])) {
303		$this->addUsingAlias(ConnectionTableMap::COL_ID, $id['max'], Criteria::LESS_EQUAL);
304		$useMinMax = true;
305		}
306		if ($useMinMax) {
307		return $this;
308		}
309		if (null === $comparison) {
310		$comparison = Criteria::IN;
311		}
312		}
313
314		return $this->addUsingAlias(ConnectionTableMap::COL_ID, $id, $comparison);
315		}
316
317		/**
318		* Filter the query on the instance_name column
		@@ 366-387 (lines=22) @@
363		*
364		* @return $this\|ChildConnectionQuery The current query, for fluid interface
365		*/
366		public function filterByUserId($userId = null, $comparison = null)
367		{
368		if (is_array($userId)) {
369		$useMinMax = false;
370		if (isset($userId['min'])) {
371		$this->addUsingAlias(ConnectionTableMap::COL_USER_ID, $userId['min'], Criteria::GREATER_EQUAL);
372		$useMinMax = true;
373		}
374		if (isset($userId['max'])) {
375		$this->addUsingAlias(ConnectionTableMap::COL_USER_ID, $userId['max'], Criteria::LESS_EQUAL);
376		$useMinMax = true;
377		}
378		if ($useMinMax) {
379		return $this;
380		}
381		if (null === $comparison) {
382		$comparison = Criteria::IN;
383		}
384		}
385
386		return $this->addUsingAlias(ConnectionTableMap::COL_USER_ID, $userId, $comparison);
387		}
388
389		/**
390		* Filter the query on the peer column
		@@ 438-459 (lines=22) @@
435		*
436		* @return $this\|ChildConnectionQuery The current query, for fluid interface
437		*/
438		public function filterByStarted($started = null, $comparison = null)
439		{
440		if (is_array($started)) {
441		$useMinMax = false;
442		if (isset($started['min'])) {
443		$this->addUsingAlias(ConnectionTableMap::COL_STARTED, $started['min'], Criteria::GREATER_EQUAL);
444		$useMinMax = true;
445		}
446		if (isset($started['max'])) {
447		$this->addUsingAlias(ConnectionTableMap::COL_STARTED, $started['max'], Criteria::LESS_EQUAL);
448		$useMinMax = true;
449		}
450		if ($useMinMax) {
451		return $this;
452		}
453		if (null === $comparison) {
454		$comparison = Criteria::IN;
455		}
456		}
457
458		return $this->addUsingAlias(ConnectionTableMap::COL_STARTED, $started, $comparison);
459		}
460
461		/**
462		* Filter the query on the type column

		@@ 319-340 (lines=22) @@
316		*
317		* @return $this\|ChildSubscriptionQuery The current query, for fluid interface
318		*/
319		public function filterById($id = null, $comparison = null)
320		{
321		if (is_array($id)) {
322		$useMinMax = false;
323		if (isset($id['min'])) {
324		$this->addUsingAlias(SubscriptionTableMap::COL_ID, $id['min'], Criteria::GREATER_EQUAL);
325		$useMinMax = true;
326		}
327		if (isset($id['max'])) {
328		$this->addUsingAlias(SubscriptionTableMap::COL_ID, $id['max'], Criteria::LESS_EQUAL);
329		$useMinMax = true;
330		}
331		if ($useMinMax) {
332		return $this;
333		}
334		if (null === $comparison) {
335		$comparison = Criteria::IN;
336		}
337		}
338
339		return $this->addUsingAlias(SubscriptionTableMap::COL_ID, $id, $comparison);
340		}
341
342		/**
343		* Filter the query on the instance_name column
		@@ 391-412 (lines=22) @@
388		*
389		* @return $this\|ChildSubscriptionQuery The current query, for fluid interface
390		*/
391		public function filterByUserId($userId = null, $comparison = null)
392		{
393		if (is_array($userId)) {
394		$useMinMax = false;
395		if (isset($userId['min'])) {
396		$this->addUsingAlias(SubscriptionTableMap::COL_USER_ID, $userId['min'], Criteria::GREATER_EQUAL);
397		$useMinMax = true;
398		}
399		if (isset($userId['max'])) {
400		$this->addUsingAlias(SubscriptionTableMap::COL_USER_ID, $userId['max'], Criteria::LESS_EQUAL);
401		$useMinMax = true;
402		}
403		if ($useMinMax) {
404		return $this;
405		}
406		if (null === $comparison) {
407		$comparison = Criteria::IN;
408		}
409		}
410
411		return $this->addUsingAlias(SubscriptionTableMap::COL_USER_ID, $userId, $comparison);
412		}
413
414		/**
415		* Filter the query on the channel_id column
		@@ 434-455 (lines=22) @@
431		*
432		* @return $this\|ChildSubscriptionQuery The current query, for fluid interface
433		*/
434		public function filterByChannelId($channelId = null, $comparison = null)
435		{
436		if (is_array($channelId)) {
437		$useMinMax = false;
438		if (isset($channelId['min'])) {
439		$this->addUsingAlias(SubscriptionTableMap::COL_CHANNEL_ID, $channelId['min'], Criteria::GREATER_EQUAL);
440		$useMinMax = true;
441		}
442		if (isset($channelId['max'])) {
443		$this->addUsingAlias(SubscriptionTableMap::COL_CHANNEL_ID, $channelId['max'], Criteria::LESS_EQUAL);
444		$useMinMax = true;
445		}
446		if ($useMinMax) {
447		return $this;
448		}
449		if (null === $comparison) {
450		$comparison = Criteria::IN;
451		}
452		}
453
454		return $this->addUsingAlias(SubscriptionTableMap::COL_CHANNEL_ID, $channelId, $comparison);
455		}
456
457		/**
458		* Filter the query on the subscription_id column
		@@ 475-496 (lines=22) @@
472		*
473		* @return $this\|ChildSubscriptionQuery The current query, for fluid interface
474		*/
475		public function filterBySubscriptionId($subscriptionId = null, $comparison = null)
476		{
477		if (is_array($subscriptionId)) {
478		$useMinMax = false;
479		if (isset($subscriptionId['min'])) {
480		$this->addUsingAlias(SubscriptionTableMap::COL_SUBSCRIPTION_ID, $subscriptionId['min'], Criteria::GREATER_EQUAL);
481		$useMinMax = true;
482		}
483		if (isset($subscriptionId['max'])) {
484		$this->addUsingAlias(SubscriptionTableMap::COL_SUBSCRIPTION_ID, $subscriptionId['max'], Criteria::LESS_EQUAL);
485		$useMinMax = true;
486		}
487		if ($useMinMax) {
488		return $this;
489		}
490		if (null === $comparison) {
491		$comparison = Criteria::IN;
492		}
493		}
494
495		return $this->addUsingAlias(SubscriptionTableMap::COL_SUBSCRIPTION_ID, $subscriptionId, $comparison);
496		}
497
498		/**
499		* Filter the query on the started column
		@@ 518-539 (lines=22) @@
515		*
516		* @return $this\|ChildSubscriptionQuery The current query, for fluid interface
517		*/
518		public function filterByStarted($started = null, $comparison = null)
519		{
520		if (is_array($started)) {
521		$useMinMax = false;
522		if (isset($started['min'])) {
523		$this->addUsingAlias(SubscriptionTableMap::COL_STARTED, $started['min'], Criteria::GREATER_EQUAL);
524		$useMinMax = true;
525		}
526		if (isset($started['max'])) {
527		$this->addUsingAlias(SubscriptionTableMap::COL_STARTED, $started['max'], Criteria::LESS_EQUAL);
528		$useMinMax = true;
529		}
530		if ($useMinMax) {
531		return $this;
532		}
533		if (null === $comparison) {
534		$comparison = Criteria::IN;
535		}
536		}
537
538		return $this->addUsingAlias(SubscriptionTableMap::COL_STARTED, $started, $comparison);
539		}
540
541		/**
542		* Filter the query on the stopped column
		@@ 561-582 (lines=22) @@
558		*
559		* @return $this\|ChildSubscriptionQuery The current query, for fluid interface
560		*/
561		public function filterByStopped($stopped = null, $comparison = null)
562		{
563		if (is_array($stopped)) {
564		$useMinMax = false;
565		if (isset($stopped['min'])) {
566		$this->addUsingAlias(SubscriptionTableMap::COL_STOPPED, $stopped['min'], Criteria::GREATER_EQUAL);
567		$useMinMax = true;
568		}
569		if (isset($stopped['max'])) {
570		$this->addUsingAlias(SubscriptionTableMap::COL_STOPPED, $stopped['max'], Criteria::LESS_EQUAL);
571		$useMinMax = true;
572		}
573		if ($useMinMax) {
574		return $this;
575		}
576		if (null === $comparison) {
577		$comparison = Criteria::IN;
578		}
579		}
580
581		return $this->addUsingAlias(SubscriptionTableMap::COL_STOPPED, $stopped, $comparison);
582		}
583
584		/**
585		* Filter the query on the title column

		@@ 289-310 (lines=22) @@
286		*
287		* @return $this\|ChildUserQuery The current query, for fluid interface
288		*/
289		public function filterById($id = null, $comparison = null)
290		{
291		if (is_array($id)) {
292		$useMinMax = false;
293		if (isset($id['min'])) {
294		$this->addUsingAlias(UserTableMap::COL_ID, $id['min'], Criteria::GREATER_EQUAL);
295		$useMinMax = true;
296		}
297		if (isset($id['max'])) {
298		$this->addUsingAlias(UserTableMap::COL_ID, $id['max'], Criteria::LESS_EQUAL);
299		$useMinMax = true;
300		}
301		if ($useMinMax) {
302		return $this;
303		}
304		if (null === $comparison) {
305		$comparison = Criteria::IN;
306		}
307		}
308
309		return $this->addUsingAlias(UserTableMap::COL_ID, $id, $comparison);
310		}
311
312		/**
313		* Filter the query on the instance_name column

Jalle19 / tvheadend-status-manager

Code Duplication Length = 22-22 lines in 11 locations

src/cli/Database/Base/ChannelQuery.php 1 location

src/cli/Database/Base/ConnectionQuery.php 3 locations

src/cli/Database/Base/SubscriptionQuery.php 6 locations

src/cli/Database/Base/UserQuery.php 1 location