src/Entity/Device.php line 29

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\Filter\MeasurementFilter;
  12. use DateTimeInterface;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use DateTime;
  17. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  18. use Symfony\Component\Validator\Constraints as Assert;
  20. /**
  21.  * Class Device.
  22.  *
  23.  * @ORM\Table("devices")
  24.  * @ORM\Entity(repositoryClass="App\Repository\DeviceRepository")
  25.  * @ORM\HasLifecycleCallbacks()
  26.  *
  27.  * @UniqueEntity(fields={"serialNumber"})
  28.  */
  29. class Device
  30. {
  31.     use IdTrait;
  32.     use TimeTrait;
  33.     use TimePreUpdateTrait;
  35.     /**
  36.      * Serial number.
  37.      *
  38.      * @var string
  39.      *
  40.      * @ORM\Column(name="serial_number", type="string", nullable=false, options={"comment": "Serial number."})
  41.      */
  42.     private $serialNumber;
  44.     /**
  45.      * Customer.
  46.      *
  47.      * @var Customer|null
  48.      *
  49.      * @ORM\ManyToOne(targetEntity="App\Entity\Customer", inversedBy="devices")
  50.      * @ORM\JoinColumn(name="customer_id", nullable=true)
  51.      */
  52.     private $customer;
  54.     /**
  55.      * Measurements.
  56.      *
  57.      * @var Measurement[]|ArrayCollection
  58.      *
  59.      * @ORM\OneToMany(targetEntity="App\Entity\Measurement", mappedBy="device")
  60.      *
  61.      * @ORM\OrderBy({"finishedAt" = "DESC"})
  62.      */
  63.     private $measurements;
  65.     /**
  66.      * @var array|null
  67.      */
  68.     private $measurementIds;
  70.     /**
  71.      * Assignment ends at.
  72.      *
  73.      * @var DateTime|null
  74.      *
  75.      * @ORM\Column(name="active_to", type="datetime", nullable=true, options={"comment": "Assignment ends at."})
  76.      */
  77.     private $assignmentEndsAt;
  79.     /**
  80.      * Is used.
  81.      *
  82.      * @var bool
  83.      *
  84.      * @ORM\Column(name="is_used", type="boolean", nullable=false, options={"comment": "Did used marked this devices as used.", "default": true})
  85.      */
  86.     private $isUsed = true;
  88.     /**
  89.      * @ORM\Column(type="datetime", nullable=true)
  90.      */
  91.     private $calibratedAt;
  93.     /**
  94.      * Channels limit.
  95.      *
  96.      * @var int|null
  97.      *
  98.      * @ORM\Column(name="channels_limit", type="integer", options={"comment": "Channels limit.", "default": 12}, nullable=true)
  99.      */
  100.     private $channelsLimit = 12;
  102.     /**
  103.      * Name assigned to this device.
  104.      *
  105.      * @var string|null
  106.      *
  107.      * @ORM\Column(name="name", type="text", nullable=true, options={"comment": "Name assigned to this device."})
  108.      */
  109.     private $name;
  111.     /**
  112.      * Device user settings.
  113.      *
  114.      * @var UserSetting[]|ArrayCollection
  115.      *
  116.      * @ORM\ManyToMany(targetEntity="App\Entity\UserSetting", mappedBy="usedDevices")
  117.      */
  118.     private $userSetting;
  120.     /**
  121.      * @ORM\OneToMany(targetEntity="App\Entity\DataSample", mappedBy="device")
  122.      * @ORM\OrderBy({"id" = "asc"})
  123.      */
  124.     private $dataSample;
  126.     /**
  127.      * @ORM\OneToMany(targetEntity="App\Entity\RecipeToSync", mappedBy="device", cascade={"remove"})
  128.      */
  129.     private $recipeToSyncs;
  131.     /**
  132.      * @ORM\OneToMany(targetEntity="App\Entity\DeviceCommand", mappedBy="device")
  133.      */
  134.     private $deviceCommands;
  136.     /**
  137.      * @ORM\OneToOne(targetEntity="App\Entity\DeviceLastCommunication", mappedBy="device", cascade={"persist", "remove"})
  138.      * @ORM\OrderBy({"id" = "DESC"})
  139.      */
  140.     private $deviceLastCommunication;
  142.     /**
  143.      * @ORM\Column(type="string", nullable=true, length=255)
  144.      *
  145.      * @Assert\Email(
  146.      *     message = "The email '{{ value }}' is not a valid email."
  147.      * )
  148.      */
  149.     private $email;
  151.     /**
  152.      * @ORM\Column(type="datetime", name="latest_battery_level_notification_at", nullable=true)
  153.      */
  154.     private $latestBatteryLevelNotificationAt;
  156.     /**
  157.      * Device constructor.
  158.      */
  159.     public function __construct()
  160.     {
  161.         $this->measurements = new ArrayCollection();
  162.         $this->userSetting = new ArrayCollection();
  163.         $this->dataSample = new ArrayCollection();
  164.         $this->recipeToSyncs = new ArrayCollection();
  165.         $this->deviceCommands = new ArrayCollection();
  166.     }
  168.     /**
  169.      * Get serial number.
  170.      *
  171.      * @return string
  172.      */
  173.     public function getSerialNumber(): string
  174.     {
  175.         return $this->serialNumber;
  176.     }
  178.     /**
  179.      * Set serial number.
  180.      *
  181.      * @param string $serialNumber
  182.      *
  183.      * @return Device
  184.      */
  185.     public function setSerialNumber(string $serialNumber): Device
  186.     {
  187.         $this->serialNumber = $serialNumber;
  189.         return $this;
  190.     }
  192.     /**
  193.      * Get customer.
  194.      *
  195.      * @return Customer|null
  196.      */
  197.     public function getCustomer(): ?Customer
  198.     {
  199.         return $this->customer;
  200.     }
  202.     /**
  203.      * Set customer.
  204.      *
  205.      * @param Customer|null $customer
  206.      *
  207.      * @return Device
  208.      */
  209.     public function setCustomer(?Customer $customer): Device
  210.     {
  211.         if ((!$this->customer && $customer) || ($this->customer && !$customer)
  212.             || ($this->customer && $customer && $customer->getId() !== $this->customer->getId())) {
  213.             $this->isUsed = true;
  214.         }
  215.         $this->customer = $customer;
  217.         return $this;
  218.     }
  220.     /**
  221.      * Get active measurements.
  222.      *
  223.      * @return Measurement[]|ArrayCollection
  224.      */
  225.     public function getActiveMeasurements(): ArrayCollection
  226.     {
  227.         $result = new ArrayCollection();
  228.         foreach ($this->measurements as $measurement) {
  229.             if (!$measurement->getIsFinished()) {
  230.                 $result->add($measurement);
  231.             }
  232.         }
  234.         return $result;
  235.     }
  237.     /**
  238.      * Get measurements.
  239.      *
  240.      * @return Measurement[]|ArrayCollection
  241.      */
  242.     public function getMeasurements()
  243.     {
  244.         return $this->measurements;
  245.     }
  247.     /**
  248.      * Get array of measurements id.
  249.      *
  250.      * The value is cached.
  251.      *
  252.      * @return array|null
  253.      */
  254.     public function getSortedMeasurmentsIdsArray()
  255.     {
  256.         if (!isset($this->measurementIds)) {
  257.             $measurements = $this->getMeasurements();
  259.             if ($measurements->isEmpty()) {
  260.                 return [];
  261.             }
  263.             $measurementIds = array_map(function ($measurement) {
  264.                 return $measurement->getId();
  265.             }, $measurements->toArray());
  267.             sort($measurementIds);
  269.             $this->measurementIds = $measurementIds;
  270.         }
  272.         return $this->measurementIds;
  273.     }
  275.     /**
  276.      * Prime the relative-name lookup when measurements were loaded by an
  277.      * optimized overview query instead of through this entity collection.
  278.      *
  279.      * @param Measurement[] $measurements
  280.      */
  281.     public function cacheSortedMeasurementIds(iterable $measurements): void
  282.     {
  283.         $this->measurementIds = [];
  284.         foreach ($measurements as $measurement) {
  285.             $this->measurementIds[] = $measurement->getId();
  286.         }
  288.         sort($this->measurementIds);
  289.     }
  291.     /**
  292.      * Prime the relative-name lookup from an inexpensive scalar ID query.
  293.      *
  294.      * @param int[] $measurementIds
  295.      */
  296.     public function cacheSortedMeasurementIdsArray(iterable $measurementIds): void
  297.     {
  298.         $this->measurementIds = array_values(array_unique(array_map('intval', is_array($measurementIds)
  299.             ? $measurementIds
  300.             : iterator_to_array($measurementIds))));
  301.         sort($this->measurementIds);
  302.     }
  304.     /**
  305.      * Get active measurements.
  306.      *
  307.      * @param MeasurementFilter $filters
  308.      *
  309.      * @return Measurement[]|ArrayCollection
  310.      */
  311.     public function getInactiveMeasurements(MeasurementFilter $filters): ArrayCollection
  312.     {
  313.         $result = new ArrayCollection();
  314.         foreach ($this->measurements as $measurement) {
  315.             if (!$measurement->getIsFinished()
  316.                 || ($filters->getMeasurementId() && (int) $filters->getMeasurementId() !== $measurement->getId())
  317.                 || $filters->getIsDateToLowerThan($measurement->getStartedAt())
  318.                 || $filters->getIsDateFromGreaterThan($measurement->getFinishedAt())) {
  319.                 continue;
  320.             }
  321.             $result->add($measurement);
  322.         }
  324.         return $this->sortMeasurementsByArchiveTime($result);
  325.     }
  327.     /**
  328.      * Keep archive ordering deterministic even when older measurements are inserted later.
  329.      *
  330.      * @param ArrayCollection|Measurement[] $measurements
  331.      *
  332.      * @return ArrayCollection
  333.      */
  334.     private function sortMeasurementsByArchiveTime(ArrayCollection $measurements): ArrayCollection
  335.     {
  336.         $iterator = $measurements->getIterator();
  337.         $iterator->uasort(function (Measurement $left, Measurement $right): int {
  338.             $comparison = $right->getFinishedAt() <=> $left->getFinishedAt();
  339.             if (0 !== $comparison) {
  340.                 return $comparison;
  341.             }
  343.             return $right->getStartedAt() <=> $left->getStartedAt();
  344.         });
  346.         return new ArrayCollection(iterator_to_array($iterator));
  347.     }
  349.     /**
  350.      * Get is active.
  351.      *
  352.      * @return bool
  353.      */
  354.     public function getIsActive(): bool
  355.     {
  356.         return $this->getActiveMeasurements()->count() > 0;
  357.     }
  359.     /**
  360.      * Get active assignment.
  361.      *
  362.      * @return Customer|null
  363.      *
  364.      * @throws \Exception
  365.      */
  366.     public function getActiveAssignment(): ?Customer
  367.     {
  368.         if (null === $this->assignmentEndsAt || $this->assignmentEndsAt > new DateTime()) {
  369.             return $this->customer;
  370.         }
  372.         return null;
  373.     }
  375.     /**
  376.      * Get last measurement.
  377.      *
  378.      * @return Measurement|null
  379.      */
  380.     public function getLastMeasurement(): ?Measurement
  381.     {
  382.         foreach (krsort($this->measurements) as $measurement) {
  383.             if (true === $measurement->getSetting()->isDeleted()) {
  384.                 continue;
  385.             }
  387.             return $measurement;
  388.         }
  390.         return null;
  391.     }
  393.     /**
  394.      * Get first measurement.
  395.      *
  396.      * @return Measurement|null
  397.      */
  398.     public function getFirstMeasurement(): ?Measurement
  399.     {
  400.         foreach ($this->measurements as $measurement) {
  401.             // im sorry but | null must be checked
  402.             if (null !== $measurement->getSetting()) {
  403.                 if (true === $measurement->getSetting()->isDeleted()) {
  404.                     continue;
  405.                 }
  406.             }
  408.             return $measurement;
  409.         }
  411.         return null;
  412.     }
  414.     /**
  415.      * Returns duration in days.
  416.      *
  417.      * @return int|null
  418.      *
  419.      * @throws \Exception
  420.      */
  421.     public function getDuration(): ?int
  422.     {
  423.         /** @var Measurement $lastMeasurement */
  424.         $lastMeasurement = $this->measurements->last();
  426.         if (!$lastMeasurement) {
  427.             return null;
  428.         }
  429.         $endsAt = $lastMeasurement->getFinishedAt() ?? new DateTime();
  430.         $startedAt = $lastMeasurement->getStartedAt() ?? $lastMeasurement->getCreatedAt();
  432.         return (int) $endsAt->diff($startedAt)->format('%a') + 1;
  433.     }
  435.     /**
  436.      * To string.
  437.      *
  438.      * @return string
  439.      */
  440.     public function __toString()
  441.     {
  442.         return $this->serialNumber ?? '{{ not-serialized-device }}';
  443.     }
  445.     /**
  446.      * Get assignment ends at.
  447.      *
  448.      * @return DateTime|null
  449.      */
  450.     public function getAssignmentEndsAt(): ?DateTime
  451.     {
  452.         return $this->assignmentEndsAt;
  453.     }
  455.     /**
  456.      * Set assignment ends at.
  457.      *
  458.      * @param DateTime|null $assignmentEndsAt
  459.      *
  460.      * @return Device
  461.      */
  462.     public function setAssignmentEndsAt(?DateTime $assignmentEndsAt): Device
  463.     {
  464.         $this->assignmentEndsAt = $assignmentEndsAt;
  466.         return $this;
  467.     }
  469.     /**
  470.      * Get is used.
  471.      *
  472.      * @return bool
  473.      */
  474.     public function isUsed(): bool
  475.     {
  476.         return $this->isUsed;
  477.     }
  479.     /**
  480.      * Set is used.
  481.      *
  482.      * @param bool $isUsed
  483.      *
  484.      * @return Device
  485.      */
  486.     public function setIsUsed(bool $isUsed): Device
  487.     {
  488.         $this->isUsed = $isUsed;
  490.         return $this;
  491.     }
  493.     /**
  494.      * @return DateTimeInterface|null
  495.      */
  496.     public function getCalibratedAt(): ?DateTimeInterface
  497.     {
  498.         return $this->calibratedAt;
  499.     }
  501.     /**
  502.      * @param DateTimeInterface|null $calibratedAt
  503.      *
  504.      * @return Device
  505.      */
  506.     public function setCalibratedAt(?DateTimeInterface $calibratedAt): self
  507.     {
  508.         $this->calibratedAt = $calibratedAt;
  510.         return $this;
  511.     }
  513.     /**
  514.      * Get channels limit.
  515.      *
  516.      * @return int|null
  517.      */
  518.     public function getChannelsLimit(): ?int
  519.     {
  520.         return $this->channelsLimit;
  521.     }
  523.     /**
  524.      * Set channels limit.
  525.      *
  526.      * @param int|null $channelsLimit
  527.      *
  528.      * @return Device
  529.      */
  530.     public function setChannelsLimit(?int $channelsLimit): Device
  531.     {
  532.         $this->channelsLimit = $channelsLimit;
  534.         return $this;
  535.     }
  537.     /**
  538.      * Get name.
  539.      *
  540.      * @param bool $defaultOnNull
  541.      *
  542.      * @return string|null
  543.      */
  544.     public function getName(?bool $defaultOnNull = false): ?string
  545.     {
  546.         if ($defaultOnNull && empty($this->name)) {
  547.             return '{{instrument}} '.$this->getId();
  548.         }
  550.         return $this->name;
  551.     }
  553.     /**
  554.      * @return string
  555.      */
  556.     public function getNameWithSerial(): string
  557.     {
  558.         return $this->getSerialNumber().': '.$this->getName(true);
  559.     }
  561.     /**
  562.      * Set name.
  563.      *
  564.      * @param string|null $name
  565.      *
  566.      * @return Device
  567.      */
  568.     public function setName(?string $name): Device
  569.     {
  570.         $this->name = $name;
  572.         return $this;
  573.     }
  575.     /**
  576.      * @return Collection|DataSample[]
  577.      */
  578.     public function getDataSample(): Collection
  579.     {
  580.         return $this->dataSample;
  581.     }
  583.     /**
  584.      * @param DataSample $dataSample
  585.      *
  586.      * @return Device
  587.      */
  588.     public function addDataSample(DataSample $dataSample): self
  589.     {
  590.         if (!$this->dataSample->contains($dataSample)) {
  591.             $this->dataSample[] = $dataSample;
  592.             $dataSample->setDevice($this);
  593.         }
  595.         return $this;
  596.     }
  598.     /**
  599.      * @param DataSample $dataSample
  600.      *
  601.      * @return Device
  602.      */
  603.     public function removeDataSample(DataSample $dataSample): self
  604.     {
  605.         if ($this->dataSample->contains($dataSample)) {
  606.             $this->dataSample->removeElement($dataSample);
  607.             // set the owning side to null (unless already changed)
  608.             if ($dataSample->getDevice() === $this) {
  609.                 $dataSample->setDevice(null);
  610.             }
  611.         }
  613.         return $this;
  614.     }
  616.     /**
  617.      * @return Collection|RecipeToSync[]
  618.      */
  619.     public function getRecipeToSyncs(): Collection
  620.     {
  621.         return $this->recipeToSyncs;
  622.     }
  624.     /**
  625.      * @param RecipeToSync $recipeToSync
  626.      *
  627.      * @return Device
  628.      */
  629.     public function addRecipeToSync(RecipeToSync $recipeToSync): self
  630.     {
  631.         if (!$this->recipeToSyncs->contains($recipeToSync)) {
  632.             $this->recipeToSyncs[] = $recipeToSync;
  633.             $recipeToSync->setDevice($this);
  634.         }
  636.         return $this;
  637.     }
  639.     /**
  640.      * @param RecipeToSync $recipeToSync
  641.      *
  642.      * @return Device
  643.      */
  644.     public function removeRecipeToSync(RecipeToSync $recipeToSync): self
  645.     {
  646.         if ($this->recipeToSyncs->contains($recipeToSync)) {
  647.             $this->recipeToSyncs->removeElement($recipeToSync);
  648.             // set the owning side to null (unless already changed)
  649.             if ($recipeToSync->getDevice() === $this) {
  650.                 $recipeToSync->setDevice(null);
  651.             }
  652.         }
  654.         return $this;
  655.     }
  657.     /**
  658.      * @return Collection|DeviceCommand[]
  659.      */
  660.     public function getDeviceCommands(): Collection
  661.     {
  662.         return $this->deviceCommands;
  663.     }
  665.     /**
  666.      * @param DeviceCommand $deviceCommand
  667.      *
  668.      * @return Device
  669.      */
  670.     public function addDeviceCommand(DeviceCommand $deviceCommand): self
  671.     {
  672.         if (!$this->deviceCommands->contains($deviceCommand)) {
  673.             $this->deviceCommands[] = $deviceCommand;
  674.             $deviceCommand->setDevice($this);
  675.         }
  677.         return $this;
  678.     }
  680.     /**
  681.      * @param DeviceCommand $deviceCommand
  682.      *
  683.      * @return Device
  684.      */
  685.     public function removeDeviceCommand(DeviceCommand $deviceCommand): self
  686.     {
  687.         if ($this->deviceCommands->contains($deviceCommand)) {
  688.             $this->deviceCommands->removeElement($deviceCommand);
  689.             // set the owning side to null (unless already changed)
  690.             if ($deviceCommand->getDevice() === $this) {
  691.                 $deviceCommand->setDevice(null);
  692.             }
  693.         }
  695.         return $this;
  696.     }
  698.     /**
  699.      * @return DeviceLastCommunication|null
  700.      */
  701.     public function getDeviceLastCommunication(): ?DeviceLastCommunication
  702.     {
  703.         return $this->deviceLastCommunication;
  704.     }
  706.     /**
  707.      * @param DeviceLastCommunication $deviceLastCommunication
  708.      *
  709.      * @return Device
  710.      */
  711.     public function setDeviceLastCommunication(DeviceLastCommunication $deviceLastCommunication): self
  712.     {
  713.         $this->deviceLastCommunication = $deviceLastCommunication;
  715.         // set the owning side of the relation if necessary
  716.         if ($deviceLastCommunication->getDevice() !== $this) {
  717.             $deviceLastCommunication->setDevice($this);
  718.         }
  720.         return $this;
  721.     }
  723.     /**
  724.      * @return string|null
  725.      */
  726.     public function getEmail(): ?string
  727.     {
  728.         return $this->email;
  729.     }
  731.     /**
  732.      * @param string|null $email
  733.      *
  734.      * @return Device
  735.      */
  736.     public function setEmail(?string $email): self
  737.     {
  738.         $this->email = $email;
  740.         return $this;
  741.     }
  743.   /**
  744.      * @return DateTime|null
  745.      */
  746.     public function getLatestBatteryLevelNotificationAt(): ?DateTime
  747.     {
  748.         return $this->latestBatteryLevelNotificationAt;
  749.     }
  751.     /**
  752.      * @param DateTime|null $latestBatteryLevelNotificationAt
  753.      *
  754.      * @return Device
  755.      */
  756.     public function setLatestBatteryLevelNotificationAt(?DateTime $latestBatteryLevelNotificationAt = null): self
  757.     {
  758.         $this->latestBatteryLevelNotificationAt = $latestBatteryLevelNotificationAt;
  760.         return $this;
  761.     }
  762. }