Part::isObsolete() - Code Metrics - Inspection of "Added database migration for new entities." - Part-DB/Part-DB-symfony - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( bcdba8...408d98 )

by Jan
created 2019-08-12 16:05 UTC
Part::isObsolete() A

↳ Parent: Part
Complexity

Conditions	4
Paths	4
Size

Total Lines	15
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	4
eloc	7
c	0
b	0
f	0
nc	4
nop	0
dl	0
loc	15
rs	10
<?php
/**
 *
 * part-db version 0.1
 * Copyright (C) 2005 Christoph Lechner
 * http://www.cl-projects.de/
 *
 * part-db version 0.2+
 * Copyright (C) 2009 K. Jacobs and others (see authors.php)
 * http://code.google.com/p/part-db/
 *
 * Part-DB Version 0.4+
 * Copyright (C) 2016 - 2019 Jan Böhmer
 * https://github.com/jbtronics
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 *
 */

declare(strict_types=1);

/**
 * part-db version 0.1
 * Copyright (C) 2005 Christoph Lechner
 * http://www.cl-projects.de/.
 *
 * part-db version 0.2+
 * Copyright (C) 2009 K. Jacobs and others (see authors.php)
 * http://code.google.com/p/part-db/
 *
 * Part-DB Version 0.4+
 * Copyright (C) 2016 - 2019 Jan Böhmer
 * https://github.com/jbtronics
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

namespace App\Entity\Parts;

use App\Entity\Attachments\Attachment;
use App\Entity\Attachments\AttachmentContainingDBElement;
use App\Entity\Devices\Device;
use App\Entity\PriceInformations\Orderdetail;
use App\Security\Annotations\ColumnSecurity;
use Doctrine\ORM\Mapping as ORM;

use Symfony\Component\Validator\Constraints as Assert;

/**
 * Class Part.
 *
 * @ORM\Entity(repositoryClass="App\Repository\PartRepository")
 * @ORM\Table("`parts`")
 */
class Part extends AttachmentContainingDBElement
{
    public const INSTOCK_UNKNOWN = -2;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Attachments\PartAttachment", mappedBy="element")
     */
    protected $attachments;

    /**
     * @var Category
     * @ORM\ManyToOne(targetEntity="Category", inversedBy="parts")
     * @ORM\JoinColumn(name="id_category", referencedColumnName="id")
     */
    protected $category;

    /**
     * @var Footprint|null
     * @ORM\ManyToOne(targetEntity="Footprint", inversedBy="parts")
     * @ORM\JoinColumn(name="id_footprint", referencedColumnName="id")
     *
     * @ColumnSecurity(prefix="footprint", type="object")
     */
    protected $footprint;

    /**
     * @var Manufacturer|null
     * @ORM\ManyToOne(targetEntity="Manufacturer", inversedBy="parts")
     * @ORM\JoinColumn(name="id_manufacturer", referencedColumnName="id")
     *
     * @ColumnSecurity(prefix="manufacturer", type="object")
     */
    protected $manufacturer;

    /**
     * @var Attachment
     * @ORM\ManyToOne(targetEntity="App\Entity\Attachments\Attachment")
     * @ORM\JoinColumn(name="id_master_picture_attachement", referencedColumnName="id")
     *
     * @ColumnSecurity(prefix="attachments", type="object")
     */
    protected $master_picture_attachment;

    /**
     * @var Orderdetail[]
     * @ORM\OneToMany(targetEntity="App\Entity\PriceInformations\Orderdetail", mappedBy="part")
     *
     * @ColumnSecurity(prefix="orderdetails", type="object")
     */
    protected $orderdetails;

    /**
     * @var Orderdetail
     * @ORM\OneToOne(targetEntity="App\Entity\PriceInformations\Orderdetail")
     * @ORM\JoinColumn(name="order_orderdetails_id", referencedColumnName="id")
     *
     * @ColumnSecurity(prefix="order", type="object")
     */
    protected $order_orderdetail;

    //TODO
    protected $devices;

    /**
     *  @ColumnSecurity(type="datetime")
     *  @ORM\Column(type="datetimetz", name="datetime_added")
     */
    protected $addedDate;

    /**
     * @var \DateTime The date when this element was modified the last time.
     * @ORM\Column(type="datetimetz", name="last_modified")
     * @ColumnSecurity(type="datetime")
     */
    protected $lastModified;

    /**********************
     * Propertys
     ***********************/

    /**
     * @var string
     * @ORM\Column(type="string")
     *
     * @ColumnSecurity(prefix="name")
     */
    protected $name;

    /**
     * @var string
     * @ORM\Column(type="text")
     *
     * @ColumnSecurity(prefix="description")
     */
    protected $description = '';

    /**
     * @var ?PartLot[]
     * @ORM\OneToMany(targetEntity="PartLot", mappedBy="part")
     */
    protected $partLots;

    /**
     * @var int
     * @ORM\Column(type="integer")
     * @Assert\GreaterThanOrEqual(0)
     *
     * @ColumnSecurity(prefix="mininstock", type="integer")
     */
    protected $mininstock = 0;

    /**
     * @var float
     * @ORM\Column(type="float")
     * @Assert\PositiveOrZero()
     */
    protected $minamount;

    /**
     * @var string
     * @ORM\Column(type="text")
     * @ColumnSecurity(prefix="comment")
     */
    protected $comment = '';

    /**
     * @var bool
     * @ORM\Column(type="boolean")
     */
    protected $visible = true;

    /**
     * @var bool
     * @ORM\Column(type="boolean")
     * @ColumnSecurity(type="boolean")
     */
    protected $favorite = false;

    /**
     * @var int
     * @ORM\Column(type="integer")
     * @ColumnSecurity(prefix="order", type="integer")
     */
    protected $order_quantity = 0;

    /**
     * @var bool
     * @ORM\Column(type="boolean")
     * @ColumnSecurity(prefix="order", type="boolean")
     */
    protected $manual_order = false;

    /**
     * @var string
     * @ORM\Column(type="string")
     * @ColumnSecurity(prefix="manufacturer", type="string", placeholder="")
     */
    protected $manufacturer_product_url = '';

    /**
     * @var string
     * @ORM\Column(type="string")
     * @ColumnSecurity(prefix="manufacturer", type="string", placeholder="")
     */
    protected $manufacturer_product_number;

    /**
     * @var bool Determines if this part entry needs review (for example, because it is work in progress)
     * @ORM\Column(type="boolean")
     */
    protected $needs_review = false;

    /**
     * @var MeasurementUnit The unit in which the part's amount is measured.
     * @ORM\ManyToOne(targetEntity="MeasurementUnit")
     * @ORM\JoinColumn(name="id_part_unit", referencedColumnName="id", nullable=true)
     */
    protected $partUnit;

    /**
     * @var string A comma seperated list of tags, assocciated with the part.
     * @ORM\Column(type="text")
     */
    protected $tags;

    /**
     * @var float|null How much a single part unit weighs in gramms.
     * @ORM\Column(type="float", nullable=true)
     */
    protected $mass;

    /**
     * Returns the ID as an string, defined by the element class.
     * This should have a form like P000014, for a part with ID 14.
     *
     * @return string The ID as a string;
     */
    public function getIDString(): string
    {
        return 'P'.sprintf('%06d', $this->getID());
    }

    /*********************************************************************************
     * Getters
     ********************************************************************************/

    /**
     * Get the description string like it is saved in the database.
     * This can contain BBCode, it is not parsed yet.
     *
     * @return string the description
     */
    public function getDescription(): string
    {
        return  htmlspecialchars($this->description);
    }

    /**
     *  Get the count of parts which are in stock.
     *  When the instock is unkown, then Part::INSTOCK_UNKNOWN is returned.
     *
     * @return int count of parts which are in stock
     */
    public function getInstock(): int
    {
        return $this->instock;
    }

    /**
     * Check if the value of the Instock is unknown.
     *
     * @return bool True, if the value of the instock is unknown.
     */
    public function isInstockUnknown(): bool
    {
        return $this->instock <= static::INSTOCK_UNKNOWN;
    }

    /** @noinspection ReturnTypeCanBeDeclaredInspection */

    /**
     *  Get the count of parts which must be in stock at least.
     *
     * @return int count of parts which must be in stock at least
     */
    public function getMinInstock(): int
    {
        return $this->mininstock;
    }

    /**
     *  Get the comment associated with this part.
     *
     * @return string The raw/unparsed comment
     */
    public function getComment(): string
    {
        return htmlspecialchars($this->comment);
    }

    /**
     *  Get if this part is obsolete.
     *
     *     A Part is marked as "obsolete" if all their orderdetails are marked as "obsolete".
     *          If a part has no orderdetails, the part isn't marked as obsolete.
     *
     * @return bool true, if this part is obsolete. false, if this part isn't obsolete
     */
    public function isObsolete(): bool
    {
        $all_orderdetails = $this->getOrderdetails();

        if (0 === count($all_orderdetails)) {
            return false;
        }

        foreach ($all_orderdetails as $orderdetails) {
            if (!$orderdetails->getObsolete()) {
                return false;
            }
        }

        return true;
    }

    /**
     *  Get if this part is visible.
     *
     * @return bool true if this part is visible
     *              false if this part isn't visible
     */
    public function isVisible(): bool
    {
        return $this->visible;
    }

    /**
     * Get if this part is a favorite.
     *
     * @return bool * true if this part is a favorite
     *              * false if this part is not a favorite.
     */
    public function isFavorite(): bool
    {
        return $this->favorite;
    }

    /**
     *  Get the selected order orderdetails of this part.
     *
     * @return Orderdetail the selected order orderdetails
     *
     * @throws Exception
     */
    public function getOrderOrderdetails(): ?Orderdetail
    {
        //TODO
        /*
        if ($this->order_orderdetails->getObsolete()) {
            $this->setOrderOrderdetailsID(null);
            $this->order_orderdetails = null;
        }*/

        return $this->order_orderdetail;
    }

    /**
     *  Get the order quantity of this part.
     *
     * @return int the order quantity
     */
    public function getOrderQuantity(): int
    {
        return $this->order_quantity;
    }

    /**
     *  Get the minimum quantity which should be ordered.
     *
     * @param bool $with_devices * if true, all parts from devices which are marked as "to order" will be included in the calculation
     *                           * if false, only max(mininstock - instock, 0) will be returned
     *
     * @return int the minimum order quantity
     *
     * @throws Exception
     */
    public function getMinOrderQuantity(bool $with_devices = true): int
    public function getMinOrderQuantity(/** @scrutinizer ignore-unused */ bool $with_devices = true): int
    {
        //TODO
        throw new \Exception('Not implemented yet...');
        /*
        if ($with_devices) {
        $count_must_order = 0;      // for devices with "order_only_missing_parts == false"
        $count_should_order = 0;    // for devices with "order_only_missing_parts == true"
        $deviceparts = DevicePart::getOrderDeviceParts($this->database, $this->current_user, $this->log, $this->getID());
        foreach ($deviceparts as $devicepart) {
        /** @var $devicepart DevicePart */
        /* @var $device Device */ /*
    $device = $devicepart->getDevice();
    if ($device->getOrderOnlyMissingParts()) {
    $count_should_order += $device->getOrderQuantity() * $devicepart->getMountQuantity();
    } else {
    $count_must_order += $device->getOrderQuantity() * $devicepart->getMountQuantity();
    }
    }

    return $count_must_order + max(0, $this->getMinInstock() - $this->getInstock() + $count_should_order);
    } else {
    return max(0, $this->getMinInstock() - $this->getInstock());
    } **/
    }

    /**
     *  Check if this part is marked for manual ordering.
     *
     * @return bool the "manual_order" attribute
     */
    public function isMarkedForManualOrder(): bool
    {
        return $this->manual_order;
    }

    /**
     * Check if the part is automatically marked for Ordering, because the instock value is smaller than the min instock value.
     * This is called automatic ordering.
     *
     * @return bool True, if the part should be ordered.
     */
    public function isAutoOrdered(): bool
    {
        //Parts with negative instock never gets ordered.
        if ($this->getInstock() < 0) {
            return false;
        }

        return $this->getInstock() < $this->getMinInstock();
    }

    /**
     *  Get the link to the website of the article on the manufacturers website
     *  When no this part has no explicit url set, then it is tried to generate one from the Manufacturer of this part
     *  automatically.
     *
     * @param
     *
     * @return string the link to the article
     */
    public function getManufacturerProductUrl(): string
    {
        if ('' !== $this->manufacturer_product_url) {
            return $this->manufacturer_product_url;
        }

        if (null !== $this->getManufacturer()) {
            return $this->getManufacturer()->getAutoProductUrl($this->name);
        }

        return ''; // no url is available
    }

    /**
     * Similar to getManufacturerProductUrl, but here only the database value is returned.
     *
     * @return string The manufacturer url saved in DB for this part.
     */
    public function getOwnProductURL(): string
    {
        return $this->manufacturer_product_url;
    }

    /**
     *  Get the category of this part.
     *
     * There is always a category, for each part!
     *
     * @return Category the category of this part
     */
    public function getCategory(): Category
    {
        return $this->category;
    }

    /**
     *  Get the footprint of this part (if there is one).
     *
     * @return Footprint the footprint of this part (if there is one)
     */
    public function getFootprint(): ?Footprint
    {
        return $this->footprint;
    }

    /**
     *  Get the storelocation of this part (if there is one).
     *
     * @return Storelocation the storelocation of this part (if there is one)
     */
    public function getStorelocation(): ?Storelocation
    {
        return $this->storelocation;
    }

    /**
     *  Get the manufacturer of this part (if there is one).
     *
     * @return Manufacturer the manufacturer of this part (if there is one)
     */
    public function getManufacturer(): ?Manufacturer
    {
        return $this->manufacturer;
    }

    /**
     *  Get the master picture "Attachement"-object of this part (if there is one).
     *
     * @return Attachment the master picture Attachement of this part (if there is one)
     */
    public function getMasterPictureAttachement(): ?Attachment
    {
        return $this->master_picture_attachment;
    }

    /**
     *  Get all orderdetails of this part.
     *
     * @param bool $hide_obsolete If true, obsolete orderdetails will NOT be returned
     *
     * @return Orderdetail[] * all orderdetails as a one-dimensional array of Orderdetails objects
     *                        (empty array if there are no ones)
     *                        * the array is sorted by the suppliers names / minimum order quantity
     *
     * @throws Exception if there was an error
     */
    public function getOrderdetails(bool $hide_obsolete = false)
    {
        if ($hide_obsolete) {
            $orderdetails = $this->orderdetails;
            foreach ($orderdetails as $key => $details) {
                if ($details->getObsolete()) {
                    unset($orderdetails[$key]);
                }
            }

            return $orderdetails;
        } else {
            return $this->orderdetails;
        }
    }

    /**
     *  Get all devices which uses this part.
     *
     * @return Device[] * all devices which uses this part as a one-dimensional array of Device objects
     *                  (empty array if there are no ones)
     *                  * the array is sorted by the devices names
     *
     * @throws Exception if there was an error
     */
    public function getDevices(): array
    {
        return $this->devices;
    }

    /**
     *  Get all suppliers of this part.
     *
     * This method simply gets the suppliers of the orderdetails and prepare them.\n
     * You can get the suppliers as an array or as a string with individual delimeter.
     *
     * @param bool        $object_array  * if true, this method returns an array of Supplier objects
     *                                   * if false, this method returns an array of strings
     * @param string|null $delimeter     * if this is a string and "$object_array == false",
     *                                   this method returns a string with all
     *                                   supplier names, delimeted by "$delimeter"
     * @param bool        $full_paths    * if true and "$object_array = false", the returned
     *                                   suppliernames are full paths (path + name)
     *                                   * if true and "$object_array = false", the returned
     *                                   suppliernames are only the names (without path)
     * @param bool        $hide_obsolete If true, suppliers from obsolete orderdetails will NOT be returned
     *
     * @return array  all suppliers as a one-dimensional array of Supplier objects
     *                (if "$object_array == true")
     * @return array  all supplier-names as a one-dimensional array of strings
     *                ("if $object_array == false" and "$delimeter == NULL")
     * @return string a sting of all supplier names, delimeted by $delimeter
     *                ("if $object_array == false" and $delimeter is a string)
     *
     * @throws Exception if there was an error
     */
    public function getSuppliers(bool $object_array = true, $delimeter = null, bool $full_paths = false, bool $hide_obsolete = false)
    {
        $suppliers = array();
        $orderdetails = $this->getOrderdetails($hide_obsolete);

        foreach ($orderdetails as $details) {
            $suppliers[] = $details->getSupplier();
        }

        if ($object_array) {
            return $suppliers;
        } else {
            $supplier_names = array();
            foreach ($suppliers as $supplier) {
                /* @var Supplier $supplier */
                if ($full_paths) {
                    $supplier_names[] = $supplier->getFullPath();
                } else {
                    $supplier_names[] = $supplier->getName();
                }
            }

            if (\is_string($delimeter)) {
                return implode($delimeter, $supplier_names);

            }

            return $supplier_names;
        }
    }

    /**
     *  Get all supplier-part-Nrs.
     *
     * This method simply gets the suppliers-part-Nrs of the orderdetails and prepare them.\n
     * You can get the numbers as an array or as a string with individual delimeter.
     *
     * @param string|null $delimeter     * if this is a string, this method returns a delimeted string
     *                                   * otherwise, this method returns an array of strings
     * @param bool        $hide_obsolete If true, supplierpartnrs from obsolete orderdetails will NOT be returned
     *
     * @return array  all supplierpartnrs as an array of strings (if "$delimeter == NULL")
     * @return string all supplierpartnrs as a string, delimeted ba $delimeter (if $delimeter is a string)
     *
     * @throws Exception if there was an error
     */
    public function getSupplierPartNrs($delimeter = null, bool $hide_obsolete = false)
    {
        $supplierpartnrs = array();

        foreach ($this->getOrderdetails($hide_obsolete) as $details) {
            $supplierpartnrs[] = $details->getSupplierPartNr();
        }

        if (\is_string($delimeter)) {
            return implode($delimeter, $supplierpartnrs);

        } else {
            return $supplierpartnrs;
        }
    }

    /**
     *  Get all prices of this part.
     *
     * This method simply gets the prices of the orderdetails and prepare them.\n
     * In the returned array/string there is a price for every supplier.
     * @param int $quantity this is the quantity to choose the correct priceinformation
     * @param int|null $multiplier * This is the multiplier which will be applied to every single price
     *                                   * If you pass NULL, the number from $quantity will be used
     * @param bool $hide_obsolete If true, prices from obsolete orderdetails will NOT be returned
     *
     * @return float[]  all prices as an array of floats (if "$delimeter == NULL" & "$float_array == true")
     *
     * @throws \Exception if there was an error
     */
    public function getPrices(int $quantity = 1, $multiplier = null, bool $hide_obsolete = false) : array
    {
        $prices = array();

        foreach ($this->getOrderdetails($hide_obsolete) as $details) {
            $prices[] = $details->getPrice($quantity, $multiplier);
        }

        return $prices;
    }

    /**
     *  Get the average price of all orderdetails.
     *
     * With the $multiplier you're able to multiply the price before it will be returned.
     * This is useful if you want to have the price as a string with currency, but multiplied with a factor.
     *
     * @param int      $quantity        this is the quantity to choose the correct priceinformations
     * @param int|null $multiplier      * This is the multiplier which will be applied to every single price
     *                                  * If you pass NULL, the number from $quantity will be used
     *
     * @return float  price (if "$as_money_string == false")
     *
     * @throws \Exception if there was an error
     */
    public function getAveragePrice(int $quantity = 1, $multiplier = null) : ?float
    {
        $prices = $this->getPrices($quantity, $multiplier, true);
        $average_price = null;

        $count = 0;
        foreach ($prices as $price) {
            if (null !== $price) {
                $average_price += $price;
                ++$count;
            }
        }

        if ($count > 0) {
            $average_price /= $count;
        }

        return $average_price;
    }

    /**
     *  Get the filename of the master picture (absolute path from filesystem root).
     *
     * @param bool $use_footprint_filename * if true, and this part has no picture, this method
     *                                     will return the filename of its footprint (if available)
     *                                     * if false, and this part has no picture,
     *                                     this method will return NULL
     *
     * @return string the whole path + filename from filesystem root as a UNIX path (with slashes)
     *
     * @throws \Exception if there was an error
     */
    public function getMasterPictureFilename(bool $use_footprint_filename = false): ?string
    {
        $master_picture = $this->getMasterPictureAttachement(); // returns an Attachement-object

        if (null !== $master_picture) {
            return $master_picture->getPath();
        }

        if ($use_footprint_filename) {
            $footprint = $this->getFootprint();
            if (null !== $footprint) {
                return $footprint->getFilename();
            }
        }

        return null;
    }

    /**
     * Parses the selected fields and extract Properties of the part.
     *
     * @param bool $use_description Use the description field for parsing
     * @param bool $use_comment     Use the comment field for parsing
     * @param bool $use_name        Use the name field for parsing
     * @param bool $force_output    Properties are parsed even if properties are disabled.
     *
     * @return array A array of PartProperty objects.
     * @return array If Properties are disabled or nothing was detected, then an empty array is returned.
     *
     * @throws Exception
     */
    public function getProperties(bool $use_description = true, bool $use_comment = true, bool $use_name = true, bool $force_output = false): array
    public function getProperties(bool $use_description = true, bool $use_comment = true, /** @scrutinizer ignore-unused */ bool $use_name = true, bool $force_output = false): array
    {
        //TODO
        throw new \Exception('Not implemented yet!');
        /*
        global $config;

        if ($config['properties']['active'] || $force_output) {
            if ($this->getCategory()->getDisableProperties(true)) {
                return array();
            }

            $name = array();
            $desc = array();
            $comm = array();

            if ($use_name === true) {
                $name = $this->getCategory()->getPartnameRegexObj()->getProperties($this->getName());
            }
            if ($use_description === true) {
                $desc = PartProperty::parseDescription($this->getDescription());
            }
            if ($use_comment === true) {
                $comm = PartProperty::parseDescription($this->getComment(false));
            }

            return array_merge($name, $desc, $comm);
        } else {
            return array();
        }*/
    }

    /**
     * Returns a loop (array) of the array representations of the properties of this part.
     *
     * @param bool $use_description Use the description field for parsing
     * @param bool $use_comment     Use the comment field for parsing
     *
     * @return array A array of arrays with the name and value of the properties.
     */
    public function getPropertiesLoop(bool $use_description = true, bool $use_comment = true, bool $use_name = true): array
    public function getPropertiesLoop(/** @scrutinizer ignore-unused */ bool $use_description = true, bool $use_comment = true, bool $use_name = true): array
    {
        //TODO
        throw new \Exception('Not implemented yet!');
        $arr = array();
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
        foreach ($this->getProperties($use_description, $use_comment, $use_name) as $property) {
            /* @var PartProperty $property */
            $arr[] = $property->getArray(true);
        }

        return $arr;
    }

    /*
    public function hasValidName() : bool
    {
        return self::isValidName($this->getName(), $this->getCategory());
    } */

    /********************************************************************************
     *
     *   Setters
     *
     *********************************************************************************/

    /**
     *  Set the description.
     *
     * @param string $new_description the new description
     *
     * @return self
     */
    public function setDescription(?string $new_description): self
    {
        $this->description = $new_description;

        return $this;
    }

    /**
     *  Set the count of parts which are in stock.
     *
     * @param int $new_instock the new count of parts which are in stock
     *
     * @return self
     */
    public function setInstock(int $new_instock, $comment = null): self
    public function setInstock(int $new_instock, /** @scrutinizer ignore-unused */ $comment = null): self
    {
        //Assert::natural($new_instock, 'New instock must be positive. Got: %s');

        $old_instock = $this->getInstock();

        $this->instock = $new_instock;

        //TODO
        /*
        InstockChangedEntry::add(
            $this->database,
            $this->current_user,
            $this->log,
            $this,
            $old_instock,
            $new_instock,
            $comment
        );*/

        return $this;
    }

    /**
     * Sets the unknown status of this part.
     * When the instock is currently unknown and you pass false, then the instock is set to zero.
     * If the instock is not unknown and you pass false, nothing is changed.
     *
     * @param bool $new_unknown Set this to true if the instock should be marked as unknown.
     *
     * @return Part
     */
    public function setInstockUnknown(bool $new_unknown): self
    {
        if (true === $new_unknown) {
            $this->instock = self::INSTOCK_UNKNOWN;

        } elseif ($this->isInstockUnknown()) {
            $this->setInstock(0);
        }

        return $this;
    }

    /**
     * Withdrawal the given number of parts.
     *
     * @param $count int The number of parts which should be withdrawan.
     * @param $comment string A comment that should be associated with the withdrawal.
     *
     * @return self
     */
    public function withdrawalParts(int $count, $comment = null): self
    public function withdrawalParts(int $count, /** @scrutinizer ignore-unused */ $comment = null): self
    {
        //Assert::greaterThan($count,0, 'Count of withdrawn parts must be greater 0! Got %s!');
        //Assert::greaterThan($count, $this->instock, 'You can not withdraw more parts, than there are existing!');

        $old_instock = $this->getInstock();
        $new_instock = $old_instock - $count;

        //TODO
        /*
        InstockChangedEntry::add(
            $this->database,
            $this->current_user,
            $this->log,
            $this,
            $old_instock,
            $new_instock,
            $comment
        );*/

        $this->instock = $new_instock;


        return $this;
    }

    /**
     * Add the given number of parts.
     *
     * @param $count int The number of parts which should be withdrawan.
     * @param $comment string A comment that should be associated with the withdrawal.
     *
     * @return self
     */
    public function addParts(int $count, string $comment = null): self
    public function addParts(int $count, /** @scrutinizer ignore-unused */ string $comment = null): self
    {
        //Assert::greaterThan($count, 0, 'Count of added parts must be greater zero! Got %s.');

        //TODO

        $old_instock = $this->getInstock();
        $new_instock = $old_instock + $count;

        //TODO
        /*
        InstockChangedEntry::add(
            $this->database,
            $this->current_user,
            $this->log,
            $this,
            $old_instock,
            $new_instock,
            $comment
        );*/

        $this->instock = $new_instock;


        return $this;
    }

    /**
     *  Set the count of parts which should be in stock at least.
     *
     * @param int $new_mininstock the new count of parts which should be in stock at least
     *
     * @return self
     */
    public function setMinInstock(int $new_mininstock): self
    {
        //Assert::natural($new_mininstock, 'The new minimum instock value must be positive! Got %s.');

        $this->mininstock = $new_mininstock;

        return $this;
    }

    /**
     *  Set the comment.
     *
     * @param string $new_comment the new comment
     *
     * @return self
     */
    public function setComment(string $new_comment): self
    {
        $this->comment = $new_comment;

        return $this;
    }

    /**
     *  Set the "manual_order" attribute.
     *
     * @param bool     $new_manual_order          the new "manual_order" attribute
     * @param int      $new_order_quantity        the new order quantity
     * @param int|null $new_order_orderdetails_id * the ID of the new order orderdetails
     *                                            * or Zero for "no order orderdetails"
     *                                            * or NULL for automatic order orderdetails
     *                                            (if the part has exactly one orderdetails,
     *                                            set this orderdetails as order orderdetails.
     *                                            Otherwise, set "no order orderdetails")
     *
     * @return self
     */
    public function setManualOrder(bool $new_manual_order, int $new_order_quantity = 1, $new_order_orderdetails_id = null): self
    public function setManualOrder(bool $new_manual_order, int $new_order_quantity = 1, /** @scrutinizer ignore-unused */ $new_order_orderdetails_id = null): self
    {
        //Assert::greaterThan($new_order_quantity, 0, 'The new order quantity must be greater zero. Got %s!');

        $this->manual_order = $new_manual_order;

        //TODO;
        /* $this->order_orderdetail = $new_order_orderdetails_id; */
        $this->order_quantity = $new_order_quantity;

        return $this;
    }

    /**
     *  Set the ID of the order orderdetails.
     *
     * @param int|null $new_order_orderdetails_id * the new order orderdetails ID
     *                                            * Or, to remove the orderdetails, pass a NULL
     *
     * @return self
     */
    public function setOrderOrderdetailsID($new_order_orderdetails_id): self
    public function setOrderOrderdetailsID(/** @scrutinizer ignore-unused */ $new_order_orderdetails_id): self
    {
        //TODO
        throw new \Exception('Not implemented yet...');

        return $this;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
    }

    /**
     *  Set the order quantity.
     *
     * @param int $new_order_quantity the new order quantity
     *
     * @return self
     */
    public function setOrderQuantity(int $new_order_quantity): self
    {
        //Assert::greaterThan($new_order_quantity,0, 'The new order quantity must be greater zero. Got %s!');

        $this->order_quantity = $new_order_quantity;

        return $this;
    }

    /**
     *  Set the category of this Part.
     *
     *     Every part must have a valid category (in contrast to the
     *          attributes "footprint", "storelocation", ...)!
     *
     * @param Category $category The new category of this part
     *
     * @return self
     */
    public function setCategory(Category $category): self
    {
        $this->category = $category;

        return $this;
    }

    /**
     * Set the new Footprint of this Part.
     *
     * @param Footprint|null $new_footprint The new footprint of this part. Set to null, if this part should not have
     *                                      a footprint.
     *
     * @return self
     */
    public function setFootprint(?Footprint $new_footprint): self
    {
        $this->footprint = $new_footprint;

        return $this;
    }

    /**
     * Set the new store location of this part.
     *
     * @param Storelocation|null $new_storelocation The new Storelocation of this part. Set to null, if this part should
     *                                              not have a storelocation.
     *
     * @return Part
     */
    public function setStorelocation(?Storelocation $new_storelocation): self
    {
        $this->storelocation = $new_storelocation;


        return $this;
    }

    /**
     * Sets the new manufacturer of this part.
     *
     * @param Manufacturer|null $new_manufacturer The new Manufacturer of this part. Set to null, if this part should
     *                                            not have a manufacturer.
     *
     * @return Part
     */
    public function setManufacturer(?Manufacturer $new_manufacturer): self
    {
        $this->manufacturer = $new_manufacturer;

        return $this;
    }

    /**
     * Set the favorite status for this part.
     *
     * @param $new_favorite_status bool The new favorite status, that should be applied on this part.
     *      Set this to true, when the part should be a favorite.
     *
     * @return self
     */
    public function setFavorite(bool $new_favorite_status): self
    {
        $this->favorite = $new_favorite_status;

        return $this;
    }

    /**
     * Sets the URL to the manufacturer site about this Part. Set to "" if this part should use the automatically URL based on its manufacturer.
     *
     * @param string $new_url The new url
     *
     * @return self
     */
    public function setManufacturerProductURL(string $new_url): self
    {
        $this->manufacturer_product_url = $new_url;

        return $this;
    }

    /**
     *  Set the ID of the master picture Attachement.
     *
     * @param int|null $new_master_picture_attachement_id * the ID of the Attachement object of the master picture
     *                                                    * NULL means "no master picture"
     *
     * @throws Exception if the new ID is not valid
     * @throws Exception if there was an error
     *
     * @return self
     */
    public function setMasterPictureAttachementID($new_master_picture_attachement_id): self
    public function setMasterPictureAttachementID(/** @scrutinizer ignore-unused */ $new_master_picture_attachement_id): self
    {
        //TODO
        throw new \Exception('Not implemented yet!');

        return $this;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
    }
}

Part-DB / Part-DB-symfony

Push — master ( bcdba8...408d98 )

Part::isObsolete() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
