src/Entity/ChannelSetting.php line 26

Open in your IDE?
  1. <?php
  2. /**
  3.  * @license SILK SOFTWARE HOUSE SP Z O O
  4.  */
  6. namespace App\Entity;
  8. use App\Entity\Traits\IdTrait;
  9. use App\Entity\Traits\TimePreUpdateTrait;
  10. use App\Entity\Traits\TimeTrait;
  11. use App\Model\DefaultStrengthPoints;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Doctrine\ORM\Mapping as ORM;
  14. use DateTime;
  15. use Symfony\Component\Validator\Constraints as Assert;
  16. use App\Validator\Constraints as AppAssert;
  18. /**
  19.  * Class ChannelSetting.
  20.  * Simple channel consists of measurement channel. Calculated channel consist of sum of children channel settings.
  21.  *
  22.  * @ORM\Table("channel_settings")
  23.  * @ORM\Entity(repositoryClass="App\Repository\ChannelSettingRepository")
  24.  * @ORM\HasLifecycleCallbacks()
  25.  */
  26. class ChannelSetting
  27. {
  28.     use IdTrait;
  29.     use TimeTrait;
  30.     use TimePreUpdateTrait;
  32.     /**
  33.      * Measurement setting.
  34.      *
  35.      * @var MeasurementSetting|null
  36.      *
  37.      * @ORM\ManyToOne(targetEntity="App\Entity\MeasurementSetting", inversedBy="channelSettings")
  38.      * @ORM\JoinColumn(name="measurement_setting_id", nullable=true)
  39.      */
  40.     private $measurementSetting;
  42.     /**
  43.      * Channel has to be set for simple channel display - it can be empty when this channel is calculated from different ones.
  44.      *
  45.      * @var Channel|null
  46.      *
  47.      * @ORM\ManyToOne(targetEntity="App\Entity\Channel", inversedBy="channelSettings")
  48.      * @ORM\JoinColumn(name="channel_id", nullable=true)
  49.      */
  50.     private $channel;
  52.     /**
  53.      * Priority.
  54.      *
  55.      * @var int|null
  56.      *
  57.      * @ORM\Column(name="priority", type="integer", nullable=true, options={"comment": "Channel priority."})
  58.      */
  59.     private $priority;
  61.     /**
  62.      * Channel name.
  63.      *
  64.      * @Assert\Length(max=255)
  65.      *
  66.      * @var string|null
  67.      *
  68.      * @ORM\Column(name="name", type="string", length=255, nullable=true, options={"comment": "Channel name."})
  69.      */
  70.     private $name;
  72.     /**
  73.      * @var int|null
  74.      *
  75.      * @ORM\Column(name="number", type="integer", nullable=true, options={"comment": "Channel number."})
  76.      */
  77.     private $number;
  79.     /**
  80.      * Recipe.
  81.      *
  82.      * @var Recipe|null
  83.      *
  84.      * @ORM\ManyToOne(targetEntity="App\Entity\Recipe")
  85.      * @ORM\JoinColumn(name="recipe_id", nullable=true)
  86.      */
  87.     private $recipe;
  89.     /**
  90.      * When set it means that this channel will be calculated from few others.
  91.      * Watch out for circular reference!!!
  92.      *
  93.      * @var ChannelSettingCoefficient[]|ArrayCollection
  94.      *
  95.      * @ORM\OneToMany(targetEntity="App\Entity\ChannelSettingCoefficient", cascade={"persist", "remove"}, mappedBy="parentSetting", orphanRemoval=true)
  96.      *
  97.      * @Assert\Valid()
  98.      *
  99.      * @AppAssert\NotCircular()
  100.      */
  101.     private $channelSettingCoefficients;
  103.     /**
  104.      * Is average weighted.
  105.      *
  106.      * @var bool
  107.      *
  108.      * @ORM\Column(name="is_average_weighted", type="boolean", nullable=false, options={"default": false, "comment": "Is average weighted."})
  109.      */
  110.     private $isAverageWeighted = false;
  112.     /**
  113.      * Mixing time point.
  114.      *
  115.      * @var DateTime|null
  116.      *
  117.      * @Assert\LessThan(
  118.      *     message="This value should be less than measurement starting time {{ compared_value }}.",
  119.      *     propertyPath="measurementStartedAt"
  120.      * )
  121.      *
  122.      * @ORM\Column(name="mixing_time_point", type="datetime", nullable=true, options={"comment": "Mixing time point."})
  123.      */
  124.     private $mixingTimePoint;
  126.     /**
  127.      * Mixing temperature.
  128.      *
  129.      * @var float|null
  130.      *
  131.      * @Assert\Range(min="-273.15", max="1416833")
  132.      *
  133.      * @ORM\Column(name="mixing_temperature", type="float", nullable=true, options={"comment": "Mixing temperature"})
  134.      */
  135.     private $mixingTemperature;
  137.     /**
  138.      * Casting time point.
  139.      *
  140.      * @var DateTime|null
  141.      *
  142.      * @ORM\Column(name="casting_time_point", type="datetime", nullable=true, options={"comment": "Casting time point."})
  143.      */
  144.     private $castingTimePoint;
  146.     /**
  147.      * Starting time point.
  148.      *
  149.      * @var DateTime|null
  150.      *
  151.      * @ORM\Column(name="starting_time_point", type="datetime", nullable=true, options={"comment": "Starting time point."})
  152.      */
  153.     private $startingTimePoint;
  155.     /**
  156.      * Array of strings (times in YmdHis format).
  157.      *
  158.      * @var string[]
  159.      *
  160.      * @ORM\Column(name="hidden_probes", type="json", nullable=true, options={"default": "{}", "comment": "Hidden probes."})
  161.      */
  162.     private $hiddenProbes = [];
  164.     /**
  165.      * Strength points.
  166.      *
  167.      * @var array
  168.      *
  169.      * @ORM\Column(name="strength_points", type="json", nullable=false, options={"comment": "Strength points.", "default": "{}"})
  170.      */
  171.     private $strengthPoints = [];
  173.     /**
  174.      * @var bool
  175.      *
  176.      * @ORM\Column(name="skip_recipe", type="boolean", nullable=false, options={"comment": "Is channel skiping recipe or standard recipe"})
  177.      */
  178.     private $skipRecipe = false;
  180.     /**
  181.      * @var bool
  182.      *
  183.      * @ORM\Column(name="is_added_by_user", type="boolean", nullable=false, options={"comment": "Is added by user"})
  184.      */
  185.     private $isAddedByUser = false;
  187.     /**
  188.      * @var bool
  189.      *
  190.      * @ORM\Column(name="is_deleted", type="boolean", nullable=false, options={"comment": "Is channel deleted"})
  191.      */
  192.     private $isDeleted = false;
  194.     /**
  195.      * @var int
  196.      *
  197.      * @ORM\Column(name="diagram_group", type="integer", nullable=false, options={"comment": "Temperature diagram group.", "default": 1})
  198.      */
  199.     private $diagramGroup = 1;
  201.     /**
  202.      * ChannelSetting constructor.
  203.      */
  204.     public function __construct()
  205.     {
  206.         $this->channelSettingCoefficients = new ArrayCollection();
  207.         $this->strengthPoints = DefaultStrengthPoints::get();
  208.     }
  210.     /**
  211.      * ChannelSetting clone
  212.      */
  213.     public function __clone()
  214.     {
  215.         $this->id = null;
  216.     }
  218.     /**
  219.      * Get measurement setting.
  220.      *
  221.      * @return MeasurementSetting|null
  222.      */
  223.     public function getMeasurementSetting(): ?MeasurementSetting
  224.     {
  225.         return $this->measurementSetting;
  226.     }
  228.     /**
  229.      * Set measurement setting.
  230.      *
  231.      * @param MeasurementSetting|null $measurementSetting
  232.      *
  233.      * @return ChannelSetting
  234.      */
  235.     public function setMeasurementSetting(?MeasurementSetting $measurementSetting): ChannelSetting
  236.     {
  237.         $this->measurementSetting = $measurementSetting;
  239.         return $this;
  240.     }
  242.     /**
  243.      * Get channel setting.
  244.      *
  245.      * @return Channel|null
  246.      */
  247.     public function getChannel(): ?Channel
  248.     {
  249.         return $this->channel;
  250.     }
  252.     /**
  253.      * Channel setting.
  254.      *
  255.      * @param Channel|null $channel
  256.      *
  257.      * @return ChannelSetting
  258.      */
  259.     public function setChannel($channel): ChannelSetting
  260.     {
  261.         $this->channel = $channel;
  263.         return $this;
  264.     }
  266.     /**
  267.      * Get priority.
  268.      *
  269.      * @return int|null
  270.      */
  271.     public function getPriority(): ?int
  272.     {
  273.         return $this->priority;
  274.     }
  276.     /**
  277.      * Set priority.
  278.      *
  279.      * @param int|null $priority
  280.      *
  281.      * @return ChannelSetting
  282.      */
  283.     public function setPriority(?int $priority): ChannelSetting
  284.     {
  285.         $this->priority = $priority;
  287.         return $this;
  288.     }
  290.     /**
  291.      * Get channel name.
  292.      *
  293.      * @return string|null
  294.      */
  295.     public function getName(): ?string
  296.     {
  297.         return $this->name;
  298.     }
  300.     /**
  301.      * Set channel name.
  302.      *
  303.      * @param string|null $name
  304.      *
  305.      * @return ChannelSetting
  306.      */
  307.     public function setName(?string $name): ChannelSetting
  308.     {
  309.         $this->name = $name;
  311.         return $this;
  312.     }
  314.     /**
  315.      * Get recipe.
  316.      *
  317.      * @return Recipe|null
  318.      */
  319.     public function getRecipe(): ?Recipe
  320.     {
  321.         return $this->recipe;
  322.     }
  324.     /**
  325.      * Set recipe.
  326.      *
  327.      * @param Recipe|null $recipe
  328.      *
  329.      * @return ChannelSetting
  330.      */
  331.     public function setRecipe(?Recipe $recipe): ChannelSetting
  332.     {
  333.         $this->recipe = $recipe;
  335.         return $this;
  336.     }
  338.     /**
  339.      * Get is average weighted.
  340.      *
  341.      * @return bool
  342.      */
  343.     public function getIsAverageWeighted(): bool
  344.     {
  345.         return $this->isAverageWeighted;
  346.     }
  348.     /**
  349.      * Set is average weighted.
  350.      *
  351.      * @param bool $isAverageWeighted
  352.      *
  353.      * @return ChannelSetting
  354.      */
  355.     public function setIsAverageWeighted(bool $isAverageWeighted): ChannelSetting
  356.     {
  357.         $this->isAverageWeighted = $isAverageWeighted;
  359.         return $this;
  360.     }
  362.     /**
  363.      * Get number.
  364.      * Note: please don't add static values here ie. '?? 1'; it will break channelViewFactory.
  365.      *
  366.      * @return int|null
  367.      */
  368.     public function getNumber(): ?int
  369.     {
  370.         return $this->number;
  371.     }
  373.     /**
  374.      * Set number.
  375.      *
  376.      * @param int|null $number
  377.      *
  378.      * @return ChannelSetting
  379.      */
  380.     public function setNumber(?int $number): ChannelSetting
  381.     {
  382.         $this->number = $number;
  384.         return $this;
  385.     }
  387.     /**
  388.      * Get type.
  389.      *
  390.      * @return string
  391.      */
  392.     public function getType(): string
  393.     {
  394.         return $this->channelSettingCoefficients->count() ? 'calculated' : 'default';
  395.     }
  397.     /**
  398.      * Set type. Todo: it does nothing.
  399.      *
  400.      * @param string $type
  401.      *
  402.      * @return ChannelSetting
  403.      */
  404.     public function setType(string $type): ChannelSetting
  405.     {
  406.         return $this;
  407.     }
  409.     /**
  410.      * Get mixing time point.
  411.      *
  412.      * @return DateTime|null
  413.      */
  414.     public function getMixingTimePoint(): ?DateTime
  415.     {
  416.         return $this->mixingTimePoint;
  417.     }
  419.     /**
  420.      * Set mixing time point.
  421.      *
  422.      * @param DateTime|null $mixingTimePoint
  423.      *
  424.      * @return ChannelSetting
  425.      */
  426.     public function setMixingTimePoint(?DateTime $mixingTimePoint): ChannelSetting
  427.     {
  428.         $this->mixingTimePoint = $mixingTimePoint;
  430.         return $this;
  431.     }
  433.     /**
  434.      * Set mixing temperature.
  435.      *
  436.      * @param float|null $mixingTemperature
  437.      *
  438.      * @return ChannelSetting
  439.      */
  440.     public function setMixingTemperature(?float $mixingTemperature): ChannelSetting
  441.     {
  442.         $this->mixingTemperature = $mixingTemperature;
  444.         return $this;
  445.     }
  447.     /**
  448.      * Get mixing temperature.
  449.      *
  450.      * @return float|null
  451.      */
  452.     public function getMixingTemperature(): ?float
  453.     {
  454.         return $this->mixingTemperature;
  455.     }
  457.     /**
  458.      * Get casting time point.
  459.      *
  460.      * @return DateTime|null
  461.      */
  462.     public function getCastingTimePoint(): ?DateTime
  463.     {
  464.         return $this->castingTimePoint;
  465.     }
  467.     /**
  468.      * Set casting time point.
  469.      *
  470.      * @param DateTime|null $castingTimePoint
  471.      *
  472.      * @return ChannelSetting
  473.      */
  474.     public function setCastingTimePoint(?DateTime $castingTimePoint): ChannelSetting
  475.     {
  476.         $this->castingTimePoint = $castingTimePoint;
  478.         return $this;
  479.     }
  481.     /**
  482.      * Get starting time point.
  483.      *
  484.      * @return DateTime|null
  485.      */
  486.     public function getStartingTimePoint(): ?DateTime
  487.     {
  488.         return $this->startingTimePoint;
  489.     }
  491.     /**
  492.      * Set starting time point.
  493.      *
  494.      * @param DateTime|null $startingTimePoint
  495.      *
  496.      * @return ChannelSetting
  497.      */
  498.     public function setStartingTimePoint(?DateTime $startingTimePoint): ChannelSetting
  499.     {
  500.         $this->startingTimePoint = $startingTimePoint;
  502.         return $this;
  503.     }
  505.     /**
  506.      * @return ChannelSettingCoefficient[]|ArrayCollection
  507.      */
  508.     public function getChannelSettingCoefficients()
  509.     {
  510.         return $this->channelSettingCoefficients;
  511.     }
  513.     /**
  514.      * Add channel setting coefficient.
  515.      *
  516.      * @param ChannelSettingCoefficient $channelSettingCoefficient
  517.      *
  518.      * @return ChannelSetting
  519.      */
  520.     public function addChannelSettingCoefficient(ChannelSettingCoefficient $channelSettingCoefficient): ChannelSetting
  521.     {
  522.         if (!$this->channelSettingCoefficients->contains($channelSettingCoefficient)) {
  523.             $this->channelSettingCoefficients->add($channelSettingCoefficient->setParentSetting($this));
  524.         }
  526.         return $this;
  527.     }
  529.     /**
  530.      * Remove channel setting coefficient.
  531.      *
  532.      * @param ChannelSettingCoefficient $channelSettingCoefficient
  533.      *
  534.      * @return ChannelSetting
  535.      */
  536.     public function removeChannelSettingCoefficient(ChannelSettingCoefficient $channelSettingCoefficient): ChannelSetting
  537.     {
  538.         if ($this->channelSettingCoefficients->contains($channelSettingCoefficient)) {
  539.             $this->channelSettingCoefficients->removeElement($channelSettingCoefficient);
  540.         }
  542.         return $this;
  543.     }
  545.     /**
  546.      * To string.
  547.      *
  548.      * @return string|null
  549.      */
  550.     public function __toString(): string
  551.     {
  552.         if (!$this->channel || null === $this->channel->getMeasurement() || null === $this->getChannel()) {
  553.             return $this->getFullName(false, false);
  554.         }
  556.         return $this->getFullName() ?? '';
  557.     }
  559.     /**
  560.      * Get full name.
  561.      *
  562.      * @param bool $withMeasurement
  563.      * @param bool $withTraceability
  564.      *
  565.      * @return string
  566.      */
  567.     public function getFullName(bool $withMeasurement = true, bool $withTraceability = false): string
  568.     {
  569.         $traceability = $withTraceability ? $this->getTraceabilityName() : '';
  570.         $defaultMeasurement = null;
  571.         if (!$withTraceability && $withMeasurement) {
  572.             $defaultMeasurement = $this->measurementSetting->getMeasurement();
  573.         }
  574.         $name = $this->getName();
  575.         if (!$name) {
  576.             if ('default' !== $this->getType()) {
  577.                 $name = '{{calculated-channel}}';
  578.             } elseif ($this->isAddedByUser()) {
  579.                 $name = '{{added-channel}}';
  580.                 if ($withMeasurement) {
  581.                     $name .= ': '.$this->channel->getMeasurement()->getNameWithFallback()
  582.                         .' ({{Sequence}} '.($this->getChannel()->getNumber()).')';
  583.                 }
  585.                 return $name;
  586.                 //return '{{added-channel}}: '.$this->channel->getMeasurement()->getName(true).' ({{Sequence}} '.($this->getChannel()->getNumber()+1).')';
  587.             } else {
  588.                 $name = '{{Channel}} '.$this->getNumber();
  589.             }
  590.         }
  592.         $name = ('default' !== $this->getType() && true === $withTraceability) ? '' : $name;
  594.         $measurement = ($withMeasurement && $this->channel) ? $this->channel->getMeasurement() : $defaultMeasurement;
  595.         if ($measurement) {
  596.             $name .= ' '.$measurement->getName() ?? '{{Measurement}} '.$this->getId();
  597.         }
  599.         return ($this->name ?? $name).$traceability;
  600.     }
  602.     /**
  603.      * Is duplicate.
  604.      *
  605.      * @Assert\IsFalse(message="This channel already exists.")
  606.      *
  607.      * @return bool
  608.      */
  609.     public function isDuplicate()
  610.     {
  611.         if (!$this->channel) {
  612.             return false;
  613.         }
  615.         foreach ($this->measurementSetting->getChannelSettings() as $channelSetting) {
  616.             if ($channelSetting->getId() !== $this->id && $channelSetting->getChannel()
  617.                 && $channelSetting->getChannel()->getId() === $this->channel->getId()
  618.                 && $channelSetting->getRecipe() == $this->getRecipe()) {
  619.                 return true;
  620.             }
  621.         }
  623.         return false;
  624.     }
  626.     /**
  627.      * @Assert\IsTrue(message="Please select channel.")
  628.      *
  629.      * @return bool
  630.      */
  631.     public function hasChannelSettingCoefficients(): bool
  632.     {
  633.         return $this->channel || $this->channelSettingCoefficients->count() > 0;
  634.     }
  636.     /**
  637.      * Get measurement started at.
  638.      *
  639.      * @return DateTime
  640.      */
  641.     public function getMeasurementStartedAt(): ?DateTime
  642.     {
  643.         return $this->getMeasurement() ? $this->getMeasurement()->getStartedAt() : null;
  644.     }
  646.     /**
  647.      * Get measurement.
  648.      *
  649.      * @return Measurement|null
  650.      */
  651.     public function getMeasurement(): ?Measurement
  652.     {
  653.         return $this->channel ? $this->channel->getMeasurement()
  654.             : ($this->getMeasurementSetting() ? $this->getMeasurementSetting()->getMeasurement() : null);
  655.     }
  657.     /**
  658.      * Get is stopped.
  659.      *
  660.      * @param int|null $depth
  661.      *
  662.      * @return bool
  663.      */
  664.     public function getIsStopped($depth = 0): bool
  665.     {
  666.         if (++$depth > 5) {
  667.             return false;
  668.         }
  669.         if ($this->channel && $this->channel->getMeasurement() && $this->channel->getMeasurement()->getIsFinished()) {
  670.             return true;
  671.         }
  673.         $isStopped = false;
  674.         foreach ($this->channelSettingCoefficients as $relation) {
  675.             if (!$relation->getChildrenSetting()->getIsStopped($depth)) {
  676.                 return false;
  677.             }
  679.             $isStopped = true;
  680.         }
  682.         return $isStopped;
  683.     }
  685.     /**
  686.      * Hide probe.
  687.      *
  688.      * @param DateTime $probeTime
  689.      *
  690.      * @return ChannelSetting
  691.      */
  692.     public function hideProbe(DateTime $probeTime)
  693.     {
  694.         if (!in_array($probeTime->format('YmdHis'), $this->hiddenProbes)) {
  695.             $this->hiddenProbes[] = $probeTime->format('YmdHis');
  696.         }
  698.         return $this;
  699.     }
  701.     /**
  702.      * Show probe.
  703.      *
  704.      * @param DateTime $probeTime
  705.      *
  706.      * @return ChannelSetting
  707.      */
  708.     public function showProbe(DateTime $probeTime): ChannelSetting
  709.     {
  710.         if (false !== ($key = array_search($probeTime->format('YmdHis'), $this->hiddenProbes))) {
  711.             unset($this->hiddenProbes[$key]);
  712.         }
  714.         return $this;
  715.     }
  717.     /**
  718.      * Get is probe hidden.
  719.      *
  720.      * @param DateTime $probeTime
  721.      *
  722.      * @return bool
  723.      */
  724.     public function getIsProbeHidden(DateTime $probeTime): bool
  725.     {
  726.         return in_array($probeTime->format('YmdHis'), $this->hiddenProbes);
  727.     }
  729.     /**
  730.      * @return $this
  731.      */
  732.     public function clearHiddenProbes()
  733.     {
  734.         $this->hiddenProbes = [];
  736.         return $this;
  737.     }
  739.     /**
  740.      * Get channel short name.
  741.      *
  742.      * @return string
  743.      */
  744.     public function getChannelShortName(): string
  745.     {
  746.         return $this->getFullName(false);
  747.     }
  749.     /**
  750.      * Get traceability name.
  751.      *
  752.      * @return string
  753.      */
  754.     public function getTraceabilityName()
  755.     {
  756.         if (!$this->channel || !$this->channel->getId()) {
  757.             $name = null;
  758.             $sequencesArray = [];
  759.             foreach ($this->channelSettingCoefficients as $coefficient) {
  760.                 $name = $coefficient->getChildrenSetting()->getMeasurement()->getNameWithFallback();
  761.                 $sequencesArray[] = $name.' ('.$coefficient->getCoefficient().' * '.$coefficient->getName().')';
  762.             }
  763.             $sequence = implode(' + ', $sequencesArray);
  765.             return '{{Calculated from}}: '.($this->isAverageWeighted
  766.                     ? '('.$sequence.') / '.$this->channelSettingCoefficients->count() : $sequence);
  767.         }
  768.         $device = $this->getMeasurement()->getDevice();
  769.         $deviceId = $device->getSerialNumber();
  770.         $calibratedAt = $device->getCalibratedAt() ? $device->getCalibratedAt()->format('Y-m-d') : '-';
  772.         return ' {{Device}} '.$deviceId.', '
  773.             .'{{Sequence}}'.' '.($this->channel->getNumber()).', {{Calibrated at}}: '.$calibratedAt;
  774.     }
  776.     /**
  777.      * Get traceability tree.
  778.      *
  779.      * @return array
  780.      */
  781.     public function getTraceabilityTree()
  782.     {
  783.         $nodes = $this->getTraceabilityNodes();
  784.         $name = (!$this->getNumber() && $this->channel)
  785.             ? $this->channel->getSequenceName()
  786.             : (($this->channel) ? $this->channel->getSequenceName() : (string) $this);
  787.         /* Traceability channel name changed: task #261 */
  788.         $name = str_replace('Sequence', 'traceability_channel', $name);
  790.         $nodes = [
  791.                 'text' => str_replace(
  792.                     ['{{', '}}'],
  793.                     '--',
  794.                     "<strong>".(strlen($name) > 105 ? substr($name, 0, 105)."..." : $name).",
  795.                     </strong>".$this->getTraceabilityName()
  796.                 ),
  797.             ] + (count($nodes) ? ['nodes' => $nodes] : []);
  799.         return $nodes;
  800.     }
  802.     /**
  803.      * Get traceability nodes.
  804.      *
  805.      * @return array
  806.      */
  807.     public function getTraceabilityNodes()
  808.     {
  809.         $nodes = [];
  810.         foreach ($this->channelSettingCoefficients as $coefficient) {
  811.             $nodes[] = $coefficient->getChildrenSetting()->getTraceabilityTree();
  812.         }
  814.         return $nodes;
  815.     }
  817.     /**
  818.      * Get strength points.
  819.      *
  820.      * @return array
  821.      */
  822.     public function getStrengthPoints(): array
  823.     {
  824.         return $this->strengthPoints;
  825.     }
  827.     /**
  828.      * Set strength points.
  829.      *
  830.      * @param array $strengthPoints
  831.      *
  832.      * @return ChannelSetting
  833.      */
  834.     public function setStrengthPoints(array $strengthPoints): ChannelSetting
  835.     {
  836.         $this->strengthPoints = $strengthPoints;
  838.         return $this;
  839.     }
  841.     /**
  842.      * Get active strength points.
  843.      *
  844.      * @return array
  845.      */
  846.     public function getActiveStrengthPoints()
  847.     {
  848.         return array_keys(array_filter($this->strengthPoints, function ($element) {
  849.             return true === $element;
  850.         }));
  851.     }
  853.     /**
  854.      * @return bool
  855.      */
  856.     public function isDeleted(): bool
  857.     {
  858.         return $this->isDeleted;
  859.     }
  861.     /**
  862.      * @param bool $isDeleted
  863.      *
  864.      * @return self
  865.      */
  866.     public function setIsDeleted(bool $isDeleted): ChannelSetting
  867.     {
  868.         $this->isDeleted = $isDeleted;
  870.         return $this;
  871.     }
  873.     /**
  874.      * @return bool
  875.      */
  876.     public function isAddedByUser(): bool
  877.     {
  878.         return $this->isAddedByUser;
  879.     }
  881.     /**
  882.      * @param bool $isAddedByUser
  883.      *
  884.      * @return self
  885.      */
  886.     public function setIsAddedByUser(bool $isAddedByUser): ChannelSetting
  887.     {
  888.         $this->isAddedByUser = $isAddedByUser;
  890.         return $this;
  891.     }
  893.     public function getDiagramGroup(): int
  894.     {
  895.         return $this->diagramGroup ?: 1;
  896.     }
  898.     public function setDiagramGroup(int $diagramGroup): ChannelSetting
  899.     {
  900.         $this->diagramGroup = max(1, min(2, $diagramGroup));
  902.         return $this;
  903.     }
  905.     /**
  906.      * @return bool
  907.      */
  908.     public function isSkipRecipe(): bool
  909.     {
  910.         return $this->skipRecipe;
  911.     }
  913.     /**
  914.      * @param bool $skipRecipe
  915.      *
  916.      * @return self
  917.      */
  918.     public function setIsSkipRecipe(bool $skipRecipe): ChannelSetting
  919.     {
  920.         $this->skipRecipe = $skipRecipe;
  922.         return $this;
  923.     }
  924. }