Del\Person\Criteria\PersonCriteria

Complexity

Total Complexity

37

Size/Duplication

Total Lines	210
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

37 Methods

Rating	Name	Duplication	Size	Complexity
A	getDob()	0	3	1
A	getId()	0	3	1
A	getOrder()	0	3	1
A	setOffset()	0	3	1
A	hasDob()	0	3	1
A	hasFirstname()	0	3	1
A	hasLimit()	0	3	1
A	getCountry()	0	3	1
A	setFirstname()	0	3	1
A	getFirstname()	0	3	1
A	hasId()	0	3	1
A	hasOffset()	0	3	1
A	setCountry()	0	3	1
A	setId()	0	3	1
A	hasOrderDirection()	0	3	1
A	setDob()	0	3	1
A	setMiddlename()	0	3	1
A	setBirthplace()	0	3	1
A	getLastname()	0	3	1
A	hasCountry()	0	3	1
A	hasLastname()	0	3	1
A	setAka()	0	3	1
A	getAka()	0	3	1
A	getOffset()	0	3	1
A	getBirthplace()	0	3	1
A	getLimit()	0	3	1
A	getOrderDirection()	0	3	1
A	hasMiddlename()	0	3	1
A	hasBirthplace()	0	3	1
A	setOrder()	0	3	1
A	hasAka()	0	3	1
A	setOrderDirection()	0	3	1
A	setPagination()	0	5	1
A	getMiddlename()	0	3	1
A	setLimit()	0	3	1
A	hasOrder()	0	3	1
A	setLastname()	0	3	1

<?php

namespace Del\Person\Criteria;

class PersonCriteria
{
    const ORDER_ASC = 'ASC';
    const ORDER_DESC = 'DESC';
    const ORDER_FIRSTNAME = 'firstname';
    const ORDER_MIDDLENAME = 'middlename';
    const ORDER_LASTNAME = 'state';
    const ORDER_AKA = 'aka';
    const ORDER_BIRTHPLACE = 'birthplace';
    const ORDER_COUNTRY = 'country';
    const ORDER_DOB = 'dob';

    protected ?int $id = null;
    protected ?string $firstname = null;
    protected ?string $middlename = null;
    protected ?string $lastname = null;
    protected ?string $aka = null;
    protected ?string $birthplace = null;
    protected ?string $country = null;
    protected ?string $dob = null;
    protected ?int $limit = null;
    protected ?int $offset = null;
    protected ?string $order = null;
    protected ?string $orderDirection = null;

    public function hasOffset(): bool
    {
        return $this->offset !== null;
    }

    public function setOffset(int $offset): void
    {
        $this->offset = $offset;
    }

    public function getOffset(): int
    {
        return $this->offset;

The expression return $this->offset could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    public function hasLimit(): bool
    {
        return $this->limit !== null;
    }

    public function setLimit(int $limit): void
    {
        $this->limit = $limit;
    }

    public function getLimit(): int
    {
        return $this->limit;

The expression return $this->limit could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    public function hasOrder(): bool
    {
        return $this->order !== null;
    }

    public function setOrder(string $order): void
    {
        $this->order = $order;
    }

    public function getOrder(): string
    {
        return $this->order;

The expression return $this->order could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function getOrderDirection(): string
    {
        return $this->orderDirection;

The expression return $this->orderDirection could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function setOrderDirection(string $orderDirection): void
    {
        $this->orderDirection = $orderDirection;
    }

    public function hasOrderDirection(): bool
    {
        return $this->orderDirection !== null;
    }

    public function setPagination(int $page, int $limit): void
    {
        $offset = ($limit * $page) - $limit;
        $this->setLimit($limit);
        $this->setOffset($offset);
    }

    public function getId(): int
    {
        return $this->id;

The expression return $this->id could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    public function setId(int $id): void
    {
        $this->id = $id;
    }

    public function hasId(): bool
    {
        return $this->id != null;

It seems like you are loosely comparing $this->id of type integer|null against null; this is ambiguous if the integer can be zero. Consider using a strict comparison !== instead.

    }

    public function getFirstname(): string
    {
        return $this->firstname;

The expression return $this->firstname could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function setFirstname(string $firstname): void
    {
        $this->firstname = $firstname;
    }

    public function hasFirstname(): bool
    {
        return $this->firstname != null;

It seems like you are loosely comparing $this->firstname of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

    }

    public function getMiddlename(): string
    {
        return $this->middlename;

The expression return $this->middlename could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function setMiddlename(string $middlename): void
    {
        $this->middlename = $middlename;
    }

    public function hasMiddlename(): bool
    {
        return $this->middlename != null;

It seems like you are loosely comparing $this->middlename of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

    }

    public function getLastname(): string
    {
        return $this->lastname;

The expression return $this->lastname could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function setLastname(string $lastname): void
    {
        $this->lastname = $lastname;
    }

    public function hasLastname(): bool
    {
        return $this->lastname != null;

It seems like you are loosely comparing $this->lastname of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

    }

    public function getAka(): string
    {
        return $this->aka;

The expression return $this->aka could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function setAka(string $aka): void
    {
        $this->aka = $aka;
    }

    public function hasAka(): bool
    {
        return $this->aka != null;

It seems like you are loosely comparing $this->aka of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

    }

    public function getBirthplace(): string
    {
        return $this->birthplace;

The expression return $this->birthplace could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function setBirthplace(string $birthplace): void
    {
        $this->birthplace = $birthplace;
    }

    public function hasBirthplace(): bool
    {
        return $this->birthplace != null;

It seems like you are loosely comparing $this->birthplace of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

    }

    public function getCountry(): string
    {
        return $this->country;

The expression return $this->country could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function setCountry(string $country): void
    {
        $this->country = $country;
    }

    public function hasCountry(): bool
    {
        return $this->country != null;

It seems like you are loosely comparing $this->country of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

    }

    public function getDob(): string
    {
        return $this->dob;

The expression return $this->dob could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function setDob(string $dob): void
    {
        $this->dob = $dob;
    }

    public function hasDob(): bool
    {
        return $this->dob != null;

It seems like you are loosely comparing $this->dob of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

    }
}