src/Entity/Gauge/Gauge.php line 32

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Gauge;
  5. use App\Entity\Building\Building;
  6. use App\Entity\Building\Sector;
  7. use App\Entity\ContractPrice\Contract;
  8. use App\Entity\ContractPrice\ContractItemType;
  9. use App\Entity\Event\Event;
  10. use App\Entity\Extension\BlameableTrait;
  11. use App\Entity\Extension\DisabledReasonTrait;
  12. use App\Entity\Extension\DisabledTrait;
  13. use App\Entity\Extension\HistoricalInterface;
  14. use App\Entity\Extension\ItemsWithHistoryTrait;
  15. use App\Entity\Extension\TimestampableTrait;
  16. use App\Entity\File;
  17. use App\Entity\Import\DataImport;
  18. use App\Entity\PriceDecision\Distributor;
  19. use App\Repository\Gauge\GaugeRepository;
  20. use App\Utils\Dataset;
  21. use App\Utils\GaugeType;
  22. use App\Utils\Period;
  23. use App\Utils\Units;
  24. use Doctrine\Common\Collections\ArrayCollection;
  25. use Doctrine\Common\Collections\Collection;
  26. use Doctrine\ORM\Mapping as ORM;
  28. /**
  29. * @ORM\Entity(repositoryClass=GaugeRepository::class)
  30. * @ORM\Table(name="gauges")
  31. */
  32. class Gauge
  33. {
  34. /**
  35. * @var int|null
  36. * @ORM\Id()
  37. * @ORM\GeneratedValue()
  38. * @ORM\Column(type="integer")
  39. */
  40. private ?int $id = null;
  42. /**
  43. * values are defined above in class definition
  44. * @var int
  45. * @ORM\Column(type="smallint", nullable=false)
  46. */
  47. private int $level;
  49. /**
  50. * values are defined in App\Utils\GaugeType::TYPE_...
  51. * @var int
  52. * @ORM\Column(type="smallint", nullable=false)
  53. */
  54. private int $type;
  56. /**
  57. * values are defined in App\Utils\GaugeType::SOURCE...
  58. * @var int|null
  59. * @ORM\Column(type="smallint", nullable=true)
  60. */
  61. private ?int $primarySource = null;
  63. /**
  64. * @var string|null
  65. * @ORM\Column(type="string", nullable=true)
  66. */
  67. private ?string $primarySourceOther = null;
  69. /**
  70. * @var Building
  71. * @ORM\ManyToOne(targetEntity="App\Entity\Building\Building", inversedBy="gauges")
  72. * @ORM\JoinColumn(name="building_id", referencedColumnName="id", nullable=false)
  73. */
  74. private Building $building;
  76. /**
  77. * @var Collection|Gauge[]
  78. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\Gauge", mappedBy="parent", cascade={"persist"})
  79. */
  80. protected $children;
  82. /**
  83. * @var Collection|File[]
  84. *
  85. * @ORM\ManyToMany(targetEntity="App\Entity\File", mappedBy="gauges")
  86. */
  87. private $files;
  89. /**
  90. * @var Gauge|null
  91. * @ORM\ManyToOne(targetEntity="App\Entity\Gauge\Gauge", inversedBy="children")
  92. * @ORM\JoinColumn(name="parent", referencedColumnName="id", nullable=true)
  93. */
  94. protected ?Gauge $parent = null;
  96. /**
  97. * @var string
  98. * @ORM\Column(type="string", nullable=false)
  99. */
  100. private string $name = '';
  102. /**
  103. * Path to generated QR code image linking to gauge readings
  104. * @var string|null
  105. * @ORM\Column(type="string", name="qr_code_path", nullable=true)
  106. */
  107. private ?string $qrCodePath = null;
  109. /**
  110. * values are defined in App\Utils\Dataset::MEASUREMENT_PARAM...
  111. * @var int
  112. * @ORM\Column(type="smallint", nullable=false)
  113. */
  114. private int $measurementTarget = GaugeType::MEASUREMENT_TARGET_CONSUMPTION;
  116. /**
  117. * indicator if is allowed remote readings
  118. * @var bool
  119. * @ORM\Column(type="boolean")
  120. */
  121. private bool $remote = false;
  123. /**
  124. * @var bool
  125. * @ORM\Column(type="boolean", nullable=false, options={"default" : 0})
  126. */
  127. private bool $remoteAsPrimary = false;
  129. /**
  130. * Php stan exception: this is right entity mapping by documentation. In constructor is solved not-nullable properties.
  131. * https://github.com/phpstan/phpstan-doctrine/issues/97
  132. *
  133. * @ORM\OneToOne(targetEntity="App\Entity\Gauge\GaugeProperties", mappedBy="gauge", cascade={"all"})
  134. */
  135. private GaugeProperties $properties; // @phpstan-ignore-line
  137. /**
  138. * @var Collection|GaugeRate[]
  139. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeRate", mappedBy="gauge", cascade={"all"})
  140. */
  141. private $rates;
  143. /**
  144. * @var Collection|ShareOfGauges[]
  145. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\ShareOfGauges", mappedBy="gauge", cascade={"all"})
  146. */
  147. private $shares;
  149. /**
  150. * @var Collection|GaugePhaseAndBreaker[]
  151. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugePhaseAndBreaker", mappedBy="gauge", cascade={"all"})
  152. */
  153. private $phaseAndBreaker;
  155. /**
  156. * @var Collection|GaugeHeatingPower[]
  157. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeHeatingPower", mappedBy="gauge", cascade={"all"})
  158. */
  159. private $heatingPower;
  161. /**
  162. * @var Collection|GaugeUnitPrice[]
  163. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeUnitPrice", mappedBy="gauge", cascade={"all"})
  164. * @ORM\OrderBy({"validFrom" = "ASC"})
  165. */
  166. private $unitPrice;
  168. /**
  169. * @var Collection|GaugePriceSupplyPoint[]
  170. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugePriceSupplyPoint", mappedBy="gauge", cascade={"all"})
  171. */
  172. private $priceSupplyPoint;
  174. /**
  175. * @var GaugeRemoteProperties|null
  176. * @ORM\OneToOne(targetEntity="App\Entity\Gauge\GaugeRemoteProperties", mappedBy="gauge", cascade={"all"})
  177. */
  178. private ?GaugeRemoteProperties $remoteProperties;
  180. /**
  181. * @var File|null
  182. * @ORM\ManyToOne(targetEntity="App\Entity\File", inversedBy="gaugePhotos")
  183. * @ORM\JoinColumn(nullable=true)
  184. */
  185. private ?File $photo = null;
  187. /**
  188. * @var Distributor|null
  189. * @ORM\ManyToOne(targetEntity="App\Entity\PriceDecision\Distributor")
  190. * @ORM\JoinColumn(name="el_dictributor_id", referencedColumnName="id", nullable=true)
  191. */
  192. private ?Distributor $electricityDistributor = null;
  194. /**
  195. * @var Collection|GaugePurpose[]
  196. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugePurpose", mappedBy="gauge", cascade={"all"})
  197. */
  198. private $purposes;
  200. /**
  201. * @var Collection|GaugeReading[]
  202. *
  203. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeReading", mappedBy="gauge")
  204. */
  205. private $readings;
  207. /**
  208. * @var Collection|Invoice[]
  209. *
  210. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\Invoice", mappedBy="gauge")
  211. */
  212. private $invoices;
  214. /**
  215. * @var Collection|Event[]
  216. *
  217. * @ORM\ManyToMany(targetEntity="App\Entity\Event\Event", mappedBy="gauges", cascade={"persist"})
  218. */
  219. private $events;
  221. /**
  222. * @var Collection|GaugeInvoiceUnit[]
  223. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeInvoiceUnit", mappedBy="gauge", cascade={"all"})
  224. */
  225. private $invoiceUnits;
  227. /**
  228. * this attribute sets if data can be showed in output after gauge is disabled
  229. * @var \bool
  230. *
  231. * @ORM\Column(name="show_in_output", type="boolean", nullable=false, options={"default": 1})
  232. */
  233. protected bool $showInOutput = true;
  235. /**
  236. * values are defined in App\Utils\Dataset::CONSUMPTION_IN...
  237. * @var int|null
  238. * @ORM\Column(type="smallint", nullable=true)
  239. */
  240. private ?int $dataInResults = Dataset::CONSUMPTION_IN_RESULTS_ON;
  242. /**
  243. * @var Collection|ConsumptionLimit[]
  244. * @ORM\ManyToMany(targetEntity="App\Entity\Gauge\ConsumptionLimit", mappedBy="gauges", cascade={"persist"})
  245. */
  246. private $consumptionLimits;
  248. /**
  249. * @var \DateTime|null
  250. *
  251. * @ORM\Column(type="datetime", nullable=true)
  252. */
  253. private ?\DateTime $lastSentNotificationAt;
  255. /**
  256. * @var DataImport|null
  257. * @ORM\ManyToOne(targetEntity="App\Entity\Import\DataImport", inversedBy="gauges")
  258. * @ORM\JoinColumn(nullable=true)
  259. */
  260. private ?DataImport $import = null;
  262. /**
  263. * @var Collection|Contract[]|null
  264. * @ORM\ManyToMany(targetEntity=Contract::class, mappedBy="gauges")
  265. */
  266. private $contracts;
  268. use BlameableTrait;
  269. use TimestampableTrait;
  270. use ItemsWithHistoryTrait;
  271. use DisabledTrait;
  272. use DisabledReasonTrait;
  274. public function __construct()
  275. {
  276. $this->type = GaugeType::TYPE_ELECTRICITY_METER;
  277. $this->level = GaugeType::LEVEL_MAIN;
  278. $this->setProperties(new GaugeProperties($this));
  279. $this->remoteProperties = null;
  280. $this->children = new ArrayCollection();
  281. $this->files = new ArrayCollection();
  282. $this->rates = new ArrayCollection();
  283. $this->phaseAndBreaker = new ArrayCollection();
  284. $this->heatingPower = new ArrayCollection();
  285. $this->unitPrice = new ArrayCollection();
  286. $this->priceSupplyPoint = new ArrayCollection();
  287. $this->readings = new ArrayCollection();
  288. $this->purposes = new ArrayCollection();
  289. $this->invoices = new ArrayCollection();
  290. $this->invoiceUnits = new ArrayCollection();
  291. $this->contracts = new ArrayCollection();
  292. }
  294. /**
  295. * @return int|null
  296. */
  297. public function getId(): ?int
  298. {
  299. return $this->id;
  300. }
  302. /**
  303. * @param int|null $id
  304. * @return Gauge
  305. */
  306. public function setId(?int $id): Gauge
  307. {
  308. $this->id = $id;
  309. return $this;
  310. }
  312. /**
  313. * @return int
  314. */
  315. public function getLevel(): int
  316. {
  317. return $this->level;
  318. }
  320. /**
  321. * @param int $level
  322. * @return Gauge
  323. */
  324. public function setLevel(int $level): Gauge
  325. {
  326. $this->level = $level;
  327. return $this;
  328. }
  330. /**
  331. * @return int
  332. */
  333. public function getType(): int
  334. {
  335. return $this->type;
  336. }
  338. /**
  339. * @param int $type
  340. * @return Gauge
  341. */
  342. public function setType(int $type): Gauge
  343. {
  344. $this->type = $type;
  345. return $this;
  346. }
  349. /**
  350. * @return Building
  351. */
  352. public function getBuilding(): Building
  353. {
  354. return $this->building;
  355. }
  357. /**
  358. * @param Building $building
  359. * @return Gauge
  360. */
  361. public function setBuilding(Building $building): Gauge
  362. {
  363. $this->building = $building;
  364. return $this;
  365. }
  367. /**
  368. * @return Gauge[]|Collection
  369. */
  370. public function getChildren()
  371. {
  372. return $this->children;
  373. }
  375. /**
  376. * @return Gauge|null
  377. */
  378. public function getParent(): ?Gauge
  379. {
  380. return $this->parent;
  381. }
  383. /**
  384. * @param Gauge|null $parent
  385. * @return Gauge
  386. */
  387. public function setParent(?Gauge $parent): Gauge
  388. {
  389. $this->parent = $parent;
  390. return $this;
  391. }
  393. /**
  394. * @return string
  395. */
  396. public function getName(): string
  397. {
  398. return $this->name;
  399. }
  401. /**
  402. * @param string $name
  403. * @return Gauge
  404. */
  405. public function setName(string $name): Gauge
  406. {
  407. $this->name = $name;
  408. return $this;
  409. }
  411. /**
  412. * @return string|null
  413. */
  414. public function getQrCodePath(): ?string
  415. {
  416. return $this->qrCodePath;
  417. }
  419. /**
  420. * @param string|null $qrCodePath
  421. * @return $this
  422. */
  423. public function setQrCodePath(?string $qrCodePath): self
  424. {
  425. $this->qrCodePath = $qrCodePath;
  426. return $this;
  427. }
  429. /**
  430. * @return GaugeProperties
  431. */
  432. public function getProperties(): GaugeProperties
  433. {
  434. return $this->properties;
  435. }
  437. /**
  438. * @param GaugeProperties $properties
  439. * @return Gauge
  440. */
  441. public function setProperties(GaugeProperties $properties): Gauge
  442. {
  443. $this->properties = $properties;
  445. return $this;
  446. }
  448. /**
  449. * @return Collection|File[]
  450. */
  451. public function getFiles(): Collection
  452. {
  453. return $this->files;
  454. }
  456. /**
  457. * @param File $file
  458. * @return $this
  459. */
  460. public function addFile(File $file): self
  461. {
  462. if (!$this->files->contains($file)) {
  463. $file->addGauge($this);
  464. $this->files->add($file);
  465. }
  467. return $this;
  468. }
  470. /**
  471. * @return int|null
  472. */
  473. public function getPrimarySource(): ?int
  474. {
  475. return $this->primarySource;
  476. }
  478. /**
  479. * @param int|null $primarySource
  480. * @return Gauge
  481. */
  482. public function setPrimarySource(?int $primarySource): Gauge
  483. {
  484. $this->primarySource = $primarySource;
  485. return $this;
  486. }
  488. /**
  489. * @return string|null
  490. */
  491. public function getPrimarySourceOther(): ?string
  492. {
  493. return $this->primarySourceOther;
  494. }
  496. /**
  497. * @param string|null $primarySourceOther
  498. * @return Gauge
  499. */
  500. public function setPrimarySourceOther(?string $primarySourceOther): Gauge
  501. {
  502. $this->primarySourceOther = $primarySourceOther;
  503. return $this;
  504. }
  506. /**
  507. * @param File $file
  508. * @return $this
  509. */
  510. public function removeFile(File $file): self
  511. {
  512. if ($this->files->contains($file)) {
  513. $this->files->removeElement($file);
  514. $file->removeGauge($this);
  515. }
  517. return $this;
  518. }
  520. /**
  521. * kontrola zda je měřidlo podružné
  522. * @return bool
  523. */
  524. public function isSecondary(): bool
  525. {
  526. if ($this->getLevel() === GaugeType::LEVEL_SECONDARY && $this->getParent() !== null) {
  527. return true;
  528. }
  529. return false;
  530. }
  532. /**
  533. * kontrola zda je měřidlo hlavní
  534. * @return bool
  535. */
  536. public function isMain(): bool
  537. {
  538. return $this->getLevel() === GaugeType::LEVEL_MAIN;
  539. }
  541. /**
  542. * @return string
  543. */
  544. public function __toString(): string
  545. {
  546. return $this->getName();
  547. }
  549. /**
  550. * @return File|null
  551. */
  552. public function getPhoto(): ?File
  553. {
  554. return $this->photo;
  555. }
  557. /**
  558. * @param File|null $photo
  559. * @return Gauge
  560. */
  561. public function setPhoto(?File $photo): Gauge
  562. {
  563. $this->photo = $photo;
  565. if ($photo !== null) {
  566. $photo->addGauge($this);
  567. }
  569. return $this;
  570. }
  572. /**
  573. * @return GaugeRate[]|Collection
  574. */
  575. public function getRates()
  576. {
  577. return $this->rates;
  578. }
  580. /**
  581. * @param GaugeRate[]|Collection $rates
  582. * @return Gauge
  583. */
  584. public function setRates($rates)
  585. {
  586. $this->rates = $rates;
  587. return $this;
  588. }
  590. /**
  591. * @param GaugeRate $rate
  592. * @return Gauge
  593. */
  594. public function addRate(GaugeRate $rate): Gauge
  595. {
  596. $rate->setGauge($this);
  597. $this->rates->add($rate);
  598. return $this;
  599. }
  601. /**
  602. * @return GaugePhaseAndBreaker[]|Collection
  603. */
  604. public function getPhaseAndBreaker(): Collection
  605. {
  606. return $this->phaseAndBreaker;
  607. }
  609. /**
  610. * @param GaugePhaseAndBreaker[]|Collection $phaseAndBreaker
  611. * @return Gauge
  612. */
  613. public function setPhaseAndBreaker($phaseAndBreaker): Gauge
  614. {
  615. $this->phaseAndBreaker = $phaseAndBreaker;
  616. return $this;
  617. }
  619. /**
  620. * @param GaugePhaseAndBreaker $phaseAndBreaker
  621. * @return Gauge
  622. */
  623. public function addPhaseAndBreaker(GaugePhaseAndBreaker $phaseAndBreaker): Gauge
  624. {
  625. $phaseAndBreaker->setGauge($this);
  626. $this->phaseAndBreaker->add($phaseAndBreaker);
  627. return $this;
  628. }
  630. /**
  631. * @return GaugeHeatingPower[]|Collection
  632. */
  633. public function getHeatingPower()
  634. {
  635. return $this->heatingPower;
  636. }
  638. /**
  639. * @param GaugeHeatingPower[]|Collection $heatingPower
  640. * @return Gauge
  641. */
  642. public function setHeatingPower($heatingPower): Gauge
  643. {
  644. $this->heatingPower = $heatingPower;
  645. return $this;
  646. }
  648. /**
  649. * @param GaugeHeatingPower $heatingPower
  650. * @return Gauge
  651. */
  652. public function addHeatingPower(GaugeHeatingPower $heatingPower): Gauge
  653. {
  654. $heatingPower->setGauge($this);
  655. $this->heatingPower->add($heatingPower);
  656. return $this;
  657. }
  659. /**
  660. * @return GaugeUnitPrice[]|Collection
  661. */
  662. public function getUnitPrice()
  663. {
  664. return $this->unitPrice;
  665. }
  667. /**
  668. * @param GaugeUnitPrice[]|Collection $unitPrice
  669. * @return Gauge
  670. */
  671. public function setUnitPrice($unitPrice): Gauge
  672. {
  673. $this->unitPrice = $unitPrice;
  674. return $this;
  675. }
  677. /**
  678. * @param GaugeUnitPrice $unitPrice
  679. * @return $this
  680. */
  681. public function addUnitPrice(GaugeUnitPrice $unitPrice): Gauge
  682. {
  683. $unitPrice->setGauge($this);
  684. $this->unitPrice->add($unitPrice);
  685. return $this;
  686. }
  688. /**
  689. * @return GaugePriceSupplyPoint[]|Collection
  690. */
  691. public function getPriceSupplyPoint(): Collection
  692. {
  693. return $this->priceSupplyPoint;
  694. }
  696. /**
  697. * @param GaugePriceSupplyPoint[]|Collection $priceSupplyPoint
  698. * @return Gauge
  699. */
  700. public function setPriceSupplyPoint($priceSupplyPoint): Gauge
  701. {
  702. $this->priceSupplyPoint = $priceSupplyPoint;
  703. return $this;
  704. }
  706. /**
  707. * @param GaugePriceSupplyPoint $priceSupplyPoint
  708. * @return $this
  709. */
  710. public function addPriceSupplyPoint(GaugePriceSupplyPoint $priceSupplyPoint): Gauge
  711. {
  712. $priceSupplyPoint->setGauge($this);
  713. $this->priceSupplyPoint->add($priceSupplyPoint);
  714. return $this;
  715. }
  717. /**
  718. * @return GaugeRemoteProperties|null
  719. */
  720. public function getRemoteProperties(): ?GaugeRemoteProperties
  721. {
  722. return $this->remoteProperties;
  723. }
  725. /**
  726. * @param GaugeRemoteProperties|null $remoteProperties
  727. * @return Gauge
  728. */
  729. public function setRemoteProperties(?GaugeRemoteProperties $remoteProperties): Gauge
  730. {
  731. $this->remoteProperties = $remoteProperties;
  732. return $this;
  733. }
  735. /**
  736. * @param int $mediumType
  737. * @param \DateTime|null $date
  738. * @return HistoricalInterface|GaugeUnitPrice|mixed|null
  739. */
  740. public function getCurrentUnitPrice(int $mediumType, ?\DateTime $date = null)
  741. {
  742. if ($date === null) {
  743. $date = new \DateTime();
  744. }
  746. $current = null;
  747. foreach ($this->getUnitPrice() as $item) {
  748. if ($item->getValidFrom() <= $date
  749. && $mediumType === $item->getMedium()
  750. && (
  751. !$current instanceof GaugeUnitPrice
  752. || $item->getValidFrom() > $current->getValidFrom()
  753. )
  754. ) {
  755. $current = $item;
  756. }
  757. }
  759. return $current;
  760. }
  762. /**
  763. * @return bool
  764. */
  765. public function isRemote(): bool
  766. {
  767. return $this->remote;
  768. }
  770. /**
  771. * @param bool $remote
  772. * @return Gauge
  773. */
  774. public function setRemote(bool $remote): Gauge
  775. {
  776. $this->remote = $remote;
  777. return $this;
  778. }
  780. /**
  781. * @return GaugeReading[]|Collection
  782. */
  783. public function getReadings()
  784. {
  785. return $this->readings;
  786. }
  788. /**
  789. * @return bool
  790. */
  791. public function isElectricityMeter(): bool
  792. {
  793. return $this->isType(GaugeType::TYPE_ELECTRICITY_METER);
  794. }
  796. /**
  797. * @return bool
  798. */
  799. public function isGasometter(): bool
  800. {
  801. return $this->isType(GaugeType::TYPE_GASOMETER);
  802. }
  804. /**
  805. * @param int $type
  806. * @return bool
  807. */
  808. public function isType(int $type): bool
  809. {
  810. return $this->getType() === $type;
  811. }
  813. /**
  814. * @return bool
  815. */
  816. public function canHaveReadings(): bool
  817. {
  818. return $this->getLevel() !== GaugeType::LEVEL_FICTIVE && $this->getType() !== GaugeType::TYPE_OTHER_FUELS;
  819. }
  821. /**
  822. * @return bool
  823. */
  824. public function canHaveInvoices(): bool
  825. {
  826. return true;
  827. }
  829. public function hasProduction(): bool
  830. {
  831. return in_array($this->getMeasurementTarget(), [GaugeType::MEASUREMENT_TARGET_PRODUCTION, GaugeType::MEASUREMENT_TARGET_CONSUMPTION_DELIVERY], true);
  832. }
  834. /**
  835. * @return GaugePurpose[]|Collection
  836. */
  837. public function getPurposes(): Collection
  838. {
  839. return $this->purposes;
  840. }
  842. /**
  843. * @param GaugePurpose[]|Collection $purposes
  844. * @return Gauge
  845. */
  846. public function setPurposes($purposes): Gauge
  847. {
  848. $this->purposes = $purposes;
  849. return $this;
  850. }
  852. /**
  853. * @param GaugePurpose $gaugePurpose
  854. * @return Gauge
  855. */
  856. public function addPurpose(GaugePurpose $gaugePurpose): Gauge
  857. {
  858. if (!$this->purposes->contains($gaugePurpose)) {
  859. $gaugePurpose->setGauge($this);
  860. $this->purposes->add($gaugePurpose);
  861. }
  862. return $this;
  863. }
  865. /**
  866. * @return int
  867. */
  868. public function getMeasurementTarget(): int
  869. {
  870. return $this->measurementTarget;
  871. }
  873. /**
  874. * @param int $measurementTarget
  875. * @return Gauge
  876. */
  877. public function setMeasurementTarget(int $measurementTarget): Gauge
  878. {
  879. $this->measurementTarget = $measurementTarget;
  880. return $this;
  881. }
  883. /**
  884. * @param int $purposeConst
  885. * @return GaugePurpose|null
  886. */
  887. public function getPurposeObject(int $purposeConst): ?GaugePurpose
  888. {
  889. foreach ($this->getPurposes() as $gaugePurpose) {
  890. if ($gaugePurpose->getPurpose() === $purposeConst) {
  891. return $gaugePurpose;
  892. }
  893. }
  895. return null;
  896. }
  898. /**
  899. * @return GaugePurpose|null
  900. */
  901. public function getPurposeFirst(): ?GaugePurpose
  902. {
  903. if ($this->purposes->count() > 0) {
  904. return $this->purposes->first();
  905. }
  907. return null;
  908. }
  910. /**
  911. * @param int $purposeConst
  912. * @return GaugePurpose
  913. */
  914. public function getPurposeNewOrExistObject(int $purposeConst): GaugePurpose
  915. {
  916. $gaugePurpose = $this->getPurposeObject($purposeConst);
  917. if ($gaugePurpose === null) {
  918. $gaugePurpose = new GaugePurpose();
  919. $gaugePurpose->setPurpose($purposeConst);
  920. $gaugePurpose->setGauge($this);
  921. }
  923. return $gaugePurpose;
  924. }
  926. /**
  927. * @return Invoice[]|Collection
  928. */
  929. public function getInvoices(): Collection
  930. {
  931. return $this->invoices;
  932. }
  934. /**
  935. * @param Invoice[]|Collection $invoices
  936. * @return Gauge
  937. */
  938. public function setInvoices($invoices): Gauge
  939. {
  940. $this->invoices = $invoices;
  941. return $this;
  942. }
  944. /**
  945. * @param Invoice $invoice
  946. * @return Gauge
  947. */
  948. public function addInvoice(Invoice $invoice): Gauge
  949. {
  950. $this->invoices[] = $invoice;
  951. return $this;
  952. }
  954. /**
  955. * @param \DateTime|null $date
  956. * @return int
  957. */
  958. public function getInvoiceUnit(?\DateTime $date = null): int
  959. {
  960. $invUnitObj = $this->getCurrent('invoiceUnits', $date, $this->getInvoiceUnits());
  962. if ($invUnitObj instanceof GaugeInvoiceUnit) {
  963. return $invUnitObj->getUnit();
  964. }
  966. return Units::getDefaultUnitByGaugeType($this->getType());
  967. }
  969. /**
  970. * @return Event[]|Collection
  971. */
  972. public function getEvents()
  973. {
  974. return $this->events;
  975. }
  977. /**
  978. * @param Event[]|Collection $events
  979. * @return Gauge
  980. */
  981. public function setEvents($events): Gauge
  982. {
  983. $this->events = $events;
  984. return $this;
  985. }
  987. public function getSector(): Sector
  988. {
  989. return $this->getBuilding()->getSector();
  990. }
  992. /**
  993. * @return ShareOfGauges[]|Collection
  994. */
  995. public function getShares()
  996. {
  997. return $this->shares;
  998. }
  1000. /**
  1001. * @param ShareOfGauges[]|Collection $shares
  1002. * @return Gauge
  1003. */
  1004. public function setShares($shares): Gauge
  1005. {
  1006. $this->shares = $shares;
  1007. return $this;
  1008. }
  1010. /**
  1011. * @return array
  1012. */
  1013. public function toArray(): array
  1014. {
  1015. return [
  1016. 'id' => $this->getId(),
  1017. 'name' => $this->getName()
  1018. ];
  1019. }
  1021. /**
  1022. * @return bool
  1023. */
  1024. public function isElectricityWholesale():bool
  1025. {
  1026. if (
  1027. $this->getType() === GaugeType::TYPE_ELECTRICITY_METER &&
  1028. in_array($this->getProperties()->getConsumptionType(), [Dataset::CONSUMPTION_TYPE_WHOLESALE_VN, Dataset::CONSUMPTION_TYPE_WHOLESALE_VVN], true)
  1029. ) {
  1030. return true;
  1031. }
  1033. return false;
  1034. }
  1036. /**
  1037. * @return bool
  1038. */
  1039. public function isForceLowTariff():bool
  1040. {
  1041. return $this->getProperties()->getForceLowTariff() === true;
  1042. }
  1044. /**
  1045. * @return bool
  1046. */
  1047. public function isForceSpecialTariff():bool
  1048. {
  1049. return $this->getProperties()->getForceSpecialTariff() === true;
  1050. }
  1052. /**
  1053. * @return GaugeInvoiceUnit[]|Collection
  1054. */
  1055. public function getInvoiceUnits(): Collection
  1056. {
  1057. return $this->invoiceUnits;
  1058. }
  1060. /**
  1061. * @param GaugeInvoiceUnit $item
  1062. * @return $this
  1063. */
  1064. public function addInvoiceUnit(GaugeInvoiceUnit $item): self
  1065. {
  1066. $item->setGauge($this);
  1067. $this->invoiceUnits->add($item);
  1069. return $this;
  1070. }
  1072. /**
  1073. * @return Distributor|null
  1074. */
  1075. public function getElectricityDistributor(): ?Distributor
  1076. {
  1077. return $this->electricityDistributor;
  1078. }
  1080. /**
  1081. * @param Distributor|null $electricityDistributor
  1082. * @return Gauge
  1083. */
  1084. public function setElectricityDistributor(?Distributor $electricityDistributor): Gauge
  1085. {
  1086. $this->electricityDistributor = $electricityDistributor;
  1087. return $this;
  1088. }
  1090. /**
  1091. * @return string|null
  1092. */
  1093. public function getCustomerName() :?string
  1094. {
  1095. if ($this->properties->getCustomerName() === null) {
  1096. return $this->building->getOwner();
  1097. }
  1099. return $this->properties->getCustomerName();
  1100. }
  1102. /**
  1103. * @return GaugePurpose|null
  1104. */
  1105. public function getConsumptionPurpose(): ?GaugePurpose
  1106. {
  1107. foreach ($this->purposes as $gPurpose) {
  1108. if ($gPurpose->getPurpose() === GaugePurpose::PURPOSE_CONSUMPTION) {
  1109. return $gPurpose;
  1110. }
  1111. }
  1113. return null;
  1114. }
  1116. /**
  1117. * @return bool|null
  1118. */
  1119. public function getShowInOutput(): ?bool
  1120. {
  1121. return $this->showInOutput;
  1122. }
  1124. /**
  1125. * @param bool|null $showInOutput
  1126. * @return self
  1127. */
  1128. public function setShowInOutput(?bool $showInOutput): self
  1129. {
  1130. $this->showInOutput = $showInOutput;
  1131. return $this;
  1132. }
  1134. public function getImport(): ?DataImport
  1135. {
  1136. return $this->import;
  1137. }
  1139. public function setImport(?DataImport $import): Gauge
  1140. {
  1141. $this->import = $import;
  1142. return $this;
  1143. }
  1145. /**
  1146. * @return int
  1147. */
  1148. public function getConsumptionInResultsRatio(): int
  1149. {
  1150. $inResultsSettings = $this->getDataInResults();
  1152. if ($inResultsSettings === Dataset::CONSUMPTION_IN_RESULTS_OFF) {
  1153. return 0;
  1154. }
  1156. if ($inResultsSettings === Dataset::CONSUMPTION_IN_RESULTS_TAKE_OFF) {
  1157. return - 1;
  1158. }
  1160. return 1;
  1161. }
  1163. /**
  1164. * @return int
  1165. */
  1166. public function getCostInResultsRatio(): int
  1167. {
  1168. $costInResults = $this->getProperties()->getCostsInResults();
  1170. if ($costInResults === Dataset::COSTS_IN_RESULTS_OFF) {
  1171. return 0;
  1172. }
  1174. if ($costInResults === Dataset::COSTS_IN_RESULTS_TAKE_OFF) {
  1175. return - 1;
  1176. }
  1178. return 1;
  1179. }
  1181. /**
  1182. * @return bool
  1183. */
  1184. public function hasParentFromSameBuilding():bool
  1185. {
  1186. if ($this->getParent() === null) {
  1187. return false;
  1188. }
  1190. return $this->getParent()->getBuilding()->getId() === $this->getBuilding()->getId();
  1191. }
  1193. /**
  1194. * @param bool|null $client
  1195. * @return string
  1196. */
  1197. public function getNameWithBuilding(?bool $client = null): string
  1198. {
  1199. if ($client === true) {
  1200. return sprintf('%s - %s', $this->getBuilding()->getClient()->getName(), $this->getNameWithBuilding());
  1201. }
  1203. return sprintf('%s - %s', $this->getBuilding()->getName(), $this->getName());
  1204. }
  1206. /**
  1207. * @return int|string|null
  1208. */
  1209. public function getTdd()
  1210. {
  1211. if ($this->isElectricityMeter()) {
  1212. return $this->getProperties()->getTddEl();
  1213. }
  1215. if ($this->isGasometter()) {
  1216. return $this->getProperties()->getTdd();
  1217. }
  1219. return null;
  1220. }
  1222. /**
  1223. * method returns all allowed segments by all gauge purposes
  1224. * @return void
  1225. */
  1226. public function getSegments(): array
  1227. {
  1228. $segments = [];
  1230. foreach ($this->purposes as $gPurpose) {
  1231. $segments = array_merge($segments, $gPurpose->getSegments());
  1232. }
  1234. return $segments;
  1235. }
  1237. public function getDataInResults(): ?int
  1238. {
  1239. return $this->dataInResults;
  1240. }
  1242. public function setDataInResults(?int $dataInResults): Gauge
  1243. {
  1244. $this->dataInResults = $dataInResults;
  1245. return $this;
  1246. }
  1248. public function hasConsumptionUsage(int $usage): bool
  1249. {
  1250. $consumptionPurpose = $this->getConsumptionPurpose();
  1252. if ($consumptionPurpose === null) {
  1253. return false;
  1254. }
  1256. foreach ($consumptionPurpose->getConsumptionUsage() as $cUsageObj) {
  1257. if ($cUsageObj->getConsumptionUsage() === $usage) {
  1258. return true;
  1259. }
  1260. }
  1262. return false;
  1263. }
  1265. /**
  1266. * @return ConsumptionLimit[]|Collection
  1267. */
  1268. public function getConsumptionLimits()
  1269. {
  1270. return $this->consumptionLimits;
  1271. }
  1273. /**
  1274. * @param ConsumptionLimit[]|Collection $consumptionLimits
  1275. * @return Gauge
  1276. */
  1277. public function setConsumptionLimits($consumptionLimits)
  1278. {
  1279. $this->consumptionLimits = $consumptionLimits;
  1280. return $this;
  1281. }
  1283. /**
  1284. * @param ConsumptionLimit $gaugeLimitObj
  1285. * @return ConsumptionLimit|null
  1286. */
  1287. public function getOtherLimitControl(ConsumptionLimit $gaugeLimitObj): ?ConsumptionLimit
  1288. {
  1289. $otherControls = $this->consumptionLimits->filter(
  1290. fn (ConsumptionLimit $limitItem) => $limitItem->getId() !== $gaugeLimitObj->getId()
  1291. );
  1293. return $otherControls->count() > 0 ? $otherControls->first() : null;
  1294. }
  1296. public function getLastSentNotificationAt(): ?\DateTime
  1297. {
  1298. return $this->lastSentNotificationAt;
  1299. }
  1301. public function setLastSentNotificationAt(?\DateTime $lastSentNotificationAt): Gauge
  1302. {
  1303. $this->lastSentNotificationAt = $lastSentNotificationAt;
  1304. return $this;
  1305. }
  1307. public function isRemoteAsPrimary(): bool
  1308. {
  1309. return $this->remoteAsPrimary;
  1310. }
  1312. public function setRemoteAsPrimary(bool $remoteAsPrimary): Gauge
  1313. {
  1314. $this->remoteAsPrimary = $remoteAsPrimary;
  1315. return $this;
  1316. }
  1318. public function getPrimaryMode(): int
  1319. {
  1320. if ($this->remote && $this->isRemoteAsPrimary()) {
  1321. return GaugeType::MODE_REMOTE;
  1322. }
  1324. return GaugeType::MODE_MANUAL;
  1325. }
  1327. public function getSecondaryMode(): ?int
  1328. {
  1329. if (!$this->remote) {
  1330. return null;
  1331. }
  1333. if (!$this->isRemoteAsPrimary()) {
  1334. return GaugeType::MODE_REMOTE;
  1335. }
  1337. return GaugeType::MODE_MANUAL;
  1338. }
  1340. public function isRemoteOnly(): bool
  1341. {
  1342. $fullRemote = $this->remote && $this->getPrimaryMode() === GaugeType::MODE_REMOTE;
  1344. $noManualReadingsPeriod = true;
  1346. foreach ($this->purposes as $purpose) {
  1347. if ($purpose->getReadingsPeriod() !== Period::NONE) {
  1348. $noManualReadingsPeriod = false;
  1349. }
  1350. }
  1352. return $fullRemote && $noManualReadingsPeriod;
  1353. }
  1355. public function getPurposesForManualReadings()
  1356. {
  1357. $allowedPurposes = $this->getAllowedPurposesByMeasurementTarget();
  1359. return $this->purposes->filter(function (GaugePurpose $gp) use ($allowedPurposes) {
  1360. if (!empty($allowedPurposes) && !in_array($gp->getPurpose(), $allowedPurposes, true)) {
  1361. return false;
  1362. }
  1364. return $this->isPurposeManualEnabled($gp);
  1365. });
  1366. }
  1368. public function getPurposesForRemoteReadings()
  1369. {
  1370. $allowedPurposes = $this->getAllowedPurposesByMeasurementTarget();
  1372. return $this->purposes->filter(function (GaugePurpose $gp) use ($allowedPurposes) {
  1373. if (!empty($allowedPurposes) && !in_array($gp->getPurpose(), $allowedPurposes, true)) {
  1374. return false;
  1375. }
  1377. return $this->isPurposeRemoteEnabled($gp);
  1378. });
  1379. }
  1381. /**
  1382. * Returns purposes configured for remote readings only.
  1383. * Unlike getPurposesForRemoteReadings(), this is not filtered by measurement target.
  1384. */
  1385. public function getPurposesForConfiguredRemoteReadings()
  1386. {
  1387. return $this->purposes->filter(function (GaugePurpose $gp) {
  1388. return $this->isPurposeRemoteEnabled($gp);
  1389. });
  1390. }
  1392. private function getAllowedPurposesByMeasurementTarget(): array
  1393. {
  1394. $measurementTarget = $this->getMeasurementTarget();
  1395. $map = GaugeType::getPurposesByMeasurementTarget();
  1397. if ($measurementTarget === null) {
  1398. return [];
  1399. }
  1401. return $map[$measurementTarget] ?? [];
  1402. }
  1404. private function isPurposeManualEnabled(GaugePurpose $gp): bool
  1405. {
  1406. $readingsPeriod = $gp->getReadingsPeriod();
  1407. if ($readingsPeriod === null || $readingsPeriod === Period::NONE) {
  1408. return false;
  1409. }
  1411. return $this->getPrimaryMode() === GaugeType::MODE_MANUAL
  1412. || $this->getSecondaryMode() === GaugeType::MODE_MANUAL;
  1413. }
  1415. private function isPurposeRemoteEnabled(GaugePurpose $gp): bool
  1416. {
  1417. if (!$this->isRemote()) {
  1418. return false;
  1419. }
  1421. if ($this->getPrimaryMode() !== GaugeType::MODE_REMOTE && $this->getSecondaryMode() !== GaugeType::MODE_REMOTE) {
  1422. return false;
  1423. }
  1425. if ($gp->getRemoteReadingsMinuteFrequency() !== null || $gp->getRemoteReadingsPeriod() !== null) {
  1426. return true;
  1427. }
  1429. return $gp->getRemoteUnits()->count() > 0;
  1430. }
  1432. public function getContracts(): array|Collection|null
  1433. {
  1434. return $this->contracts;
  1435. }
  1437. /**
  1438. * @param Contract[]|Collection $contracts
  1439. * @return Gauge
  1440. */
  1441. public function setContracts($contracts): Gauge
  1442. {
  1443. $this->contracts = $contracts;
  1444. return $this;
  1445. }
  1447. public function addContract(Contract $contract): Gauge
  1448. {
  1449. if ($this->contracts === null) {
  1450. $this->contracts = new ArrayCollection();
  1451. }
  1452. if (!$this->contracts->contains($contract)) {
  1453. $this->contracts->add($contract);
  1454. }
  1456. return $this;
  1457. }
  1459. public function removeContract(Contract $contract): Gauge
  1460. {
  1461. if ($this->contracts === null) {
  1462. $this->contracts = new ArrayCollection();
  1463. }
  1465. if ($this->contracts->contains($contract)) {
  1466. $this->contracts->removeElement($contract);
  1467. $contract->removeGauge($this);
  1468. }
  1470. return $this;
  1471. }
  1472. }