src/Entity/Gauge/GaugePurpose.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Gauge;
  5. use App\Entity\Extension\GaugeUnitInterface;
  6. use App\Entity\Extension\ItemsWithHistoryTrait;
  7. use App\Utils\GaugeType;
  8. use App\Utils\Period;
  9. use App\Utils\Segment;
  10. use App\Utils\Units;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  13. use Doctrine\ORM\Mapping as ORM;
  14. use Symfony\Component\Validator\Constraints as Assert;
  16. /**
  17. * @ORM\Entity()
  18. * @ORM\Table(name="gauge_purpose")
  19. */
  20. class GaugePurpose
  21. {
  22. public const PURPOSE_CONSUMPTION = 1; // spotřeba
  23. public const PURPOSE_PRODUCTION = 2; // výroba
  24. public const PURPOSE_DELIVERY = 3; // dodávka (přetoky)
  25. public const PURPOSE_RAINFALL = 4; // srážky
  26. public const PURPOSE_TEMPERATURE = 5; // teplota
  27. public const PURPOSE_HUMIDITY = 6; // vlhkost
  28. public const PURPOSE_CO2 = 7; // koncentrace CO2
  30. public static array $all = [
  31. self::PURPOSE_CONSUMPTION,
  32. self::PURPOSE_PRODUCTION,
  33. self::PURPOSE_DELIVERY,
  34. self::PURPOSE_TEMPERATURE,
  35. self::PURPOSE_HUMIDITY,
  36. self::PURPOSE_CO2,
  37. ];
  39. /**
  40. * @var int|null
  41. * @ORM\Id()
  42. * @ORM\GeneratedValue()
  43. * @ORM\Column(type="integer")
  44. */
  45. private ?int $id = null;
  47. /**
  48. * @var Gauge $gauge
  49. * @ORM\ManyToOne(targetEntity="App\Entity\Gauge\Gauge", inversedBy="purposes")
  50. * @ORM\JoinColumn(name="gauge_id", referencedColumnName="id", nullable=false)
  51. */
  52. private Gauge $gauge;
  54. /**
  55. * values defined above GaugePurpose::PURPOSE_...
  56. * @var int
  57. * @ORM\Column(type="smallint")
  58. */
  59. private int $purpose;
  61. /**
  62. * TODO can be deleted after sql/EM-442.sql on production
  63. * @var int|null
  64. * @ORM\Column(type="smallint", nullable=true)
  65. */
  66. private ?int $primaryMode = GaugeType::MODE_MANUAL;
  68. /**
  69. * TODO can be deleted after sql/EM-442.sql on production
  70. * @var int|null
  71. * @ORM\Column(type="smallint", nullable=true)
  72. */
  73. private ?int $secondaryMode = GaugeType::MODE_NONE;
  75. /**
  76. * @var Collection|GaugeVolumeRatio[]
  77. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeVolumeRatio", mappedBy="gaugePurpose", cascade={"all"})
  78. */
  79. private $volumeRatio;
  81. /**
  82. * @var Collection|GaugeRemoteVolumeRatio[]
  83. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeRemoteVolumeRatio", mappedBy="gaugePurpose", cascade={"all"})
  84. */
  85. private $remoteVolumeRatio;
  87. /**
  88. * @var Collection|GaugeConsumptionUsage[]
  89. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeConsumptionUsage", mappedBy="gaugePurpose", cascade={"all"})
  90. */
  91. private $consumptionUsage;
  93. /**
  94. * @var int|null
  95. * @ORM\Column(type="smallint", nullable=true)
  96. */
  97. private ?int $readingsPeriod = Period::MONTH;
  99. /**
  100. * @var bool
  101. * @ORM\Column(type="boolean")
  102. */
  103. private bool $readingsPeriodControl = true;
  105. /**
  106. * values are defined in App\Utils\Period
  107. * @var int|null
  108. * @ORM\Column(type="smallint", nullable=true)
  109. */
  110. private ?int $secondaryReadingsPeriod = null;
  112. /**
  113. * @var bool
  114. * @ORM\Column(type="boolean")
  115. */
  116. private bool $secondaryReadingsPeriodControl = true;
  118. /**
  119. * values are defined in App\Utils\Period
  120. * @var int|null
  121. * @ORM\Column(type="smallint", nullable=true)
  122. */
  123. private ?int $remoteReadingsPeriod = null;
  125. /**
  126. * @var int|null
  127. * @ORM\Column(type="integer", nullable=true)
  128. */
  129. private ?int $remoteReadingsMinuteFrequency = null;
  131. /**
  132. * @var Collection|GaugeUnit[]
  133. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeUnit", mappedBy="gaugePurpose", cascade={"all"})
  134. */
  135. private $units;
  137. /**
  138. * @var Collection|GaugeRemoteUnit[]
  139. * @ORM\OneToMany(targetEntity="App\Entity\Gauge\GaugeRemoteUnit", mappedBy="gaugePurpose", cascade={"all"})
  140. */
  141. private $remoteUnits;
  143. use ItemsWithHistoryTrait;
  145. public function __construct()
  146. {
  147. $this->consumptionUsage = new ArrayCollection();
  148. $this->volumeRatio = new ArrayCollection();
  149. $this->remoteVolumeRatio = new ArrayCollection();
  150. $this->units = new ArrayCollection();
  151. $this->remoteUnits = new ArrayCollection();
  152. }
  154. /**
  155. * @return int|null
  156. */
  157. public function getId(): ?int
  158. {
  159. return $this->id;
  160. }
  162. /**
  163. * @param int|null $id
  164. * @return GaugePurpose
  165. */
  166. public function setId(?int $id): GaugePurpose
  167. {
  168. $this->id = $id;
  169. return $this;
  170. }
  172. /**
  173. * @return Gauge
  174. */
  175. public function getGauge(): Gauge
  176. {
  177. return $this->gauge;
  178. }
  180. /**
  181. * @param Gauge $gauge
  182. * @return GaugePurpose
  183. */
  184. public function setGauge(Gauge $gauge): GaugePurpose
  185. {
  186. $this->gauge = $gauge;
  187. return $this;
  188. }
  190. /**
  191. * @return GaugeVolumeRatio[]|Collection
  192. */
  193. public function getVolumeRatio()
  194. {
  195. return $this->volumeRatio;
  196. }
  198. /**
  199. * @param GaugeVolumeRatio[]|Collection $volumeRatio
  200. * @return GaugePurpose
  201. */
  202. public function setVolumeRatio($volumeRatio)
  203. {
  204. $this->volumeRatio = $volumeRatio;
  205. return $this;
  206. }
  208. /**
  209. * @return GaugeRemoteVolumeRatio[]|Collection
  210. */
  211. public function getRemoteVolumeRatio()
  212. {
  213. return $this->remoteVolumeRatio;
  214. }
  216. /**
  217. * @param GaugeRemoteVolumeRatio[]|Collection $remoteVolumeRatio
  218. * @return GaugePurpose
  219. */
  220. public function setRemoteVolumeRatio($remoteVolumeRatio)
  221. {
  222. $this->remoteVolumeRatio = $remoteVolumeRatio;
  223. return $this;
  224. }
  226. /**
  227. * @return GaugeConsumptionUsage[]|Collection
  228. */
  229. public function getConsumptionUsage()
  230. {
  231. return $this->consumptionUsage;
  232. }
  234. /**
  235. * @param GaugeConsumptionUsage[]|Collection $consumptionUsage
  236. * @return GaugePurpose
  237. */
  238. public function setConsumptionUsage($consumptionUsage)
  239. {
  240. $this->consumptionUsage = $consumptionUsage;
  241. return $this;
  242. }
  244. /**
  245. * @param float $volumeRatio
  246. * @return $this
  247. */
  248. public function addVolumeRatio(float $volumeRatio): self
  249. {
  250. $volumeRatioObj = (new GaugeVolumeRatio())
  251. ->setRatio($volumeRatio)
  252. ->setValidFrom(new \DateTime());
  254. $volumeRatioObj->setGaugePurpose($this);
  255. $this->volumeRatio->add($volumeRatioObj);
  256. return $this;
  257. }
  259. /**
  260. * @param GaugeConsumptionUsage $consumptionUsage
  261. * @return self
  262. */
  263. public function addConsumptionUsage(GaugeConsumptionUsage $consumptionUsage): self
  264. {
  265. $consumptionUsage->setGaugePurpose($this);
  266. $this->consumptionUsage->add($consumptionUsage);
  267. return $this;
  268. }
  270. /**
  271. * @param float $volumeRatio
  272. * @return $this
  273. */
  274. public function addRemoteVolumeRatio(float $volumeRatio): self
  275. {
  276. $remoteVolumeRatioObj = (new GaugeRemoteVolumeRatio())
  277. ->setRatio($volumeRatio)
  278. ->setValidFrom(new \DateTime());
  280. $remoteVolumeRatioObj->setGaugePurpose($this);
  281. $this->remoteVolumeRatio->add($remoteVolumeRatioObj);
  282. return $this;
  283. }
  285. /**
  286. * @return int
  287. */
  288. public function getPurpose(): int
  289. {
  290. return $this->purpose;
  291. }
  293. /**
  294. * @param int $purpose
  295. * @return GaugePurpose
  296. */
  297. public function setPurpose(int $purpose): GaugePurpose
  298. {
  299. $this->purpose = $purpose;
  300. return $this;
  301. }
  303. /**
  304. * @return int|null
  305. */
  306. public function getReadingsPeriod(): ?int
  307. {
  308. return $this->readingsPeriod;
  309. }
  311. /**
  312. * @param int|null $readingsPeriod
  313. * @return GaugePurpose
  314. */
  315. public function setReadingsPeriod(?int $readingsPeriod): GaugePurpose
  316. {
  317. $this->readingsPeriod = $readingsPeriod;
  318. return $this;
  319. }
  321. /**
  322. * @return bool
  323. */
  324. public function isReadingsPeriodControl(): bool
  325. {
  326. return $this->readingsPeriodControl;
  327. }
  329. /**
  330. * @param bool $readingsPeriodControl
  331. * @return GaugePurpose
  332. */
  333. public function setReadingsPeriodControl(bool $readingsPeriodControl): GaugePurpose
  334. {
  335. $this->readingsPeriodControl = $readingsPeriodControl;
  336. return $this;
  337. }
  339. /**
  340. * @return int|null
  341. */
  342. public function getSecondaryReadingsPeriod(): ?int
  343. {
  344. return $this->secondaryReadingsPeriod;
  345. }
  347. /**
  348. * @param int|null $secondaryReadingsPeriod
  349. * @return GaugePurpose
  350. */
  351. public function setSecondaryReadingsPeriod(?int $secondaryReadingsPeriod): GaugePurpose
  352. {
  353. $this->secondaryReadingsPeriod = $secondaryReadingsPeriod;
  354. return $this;
  355. }
  357. /**
  358. * @return bool
  359. */
  360. public function isSecondaryReadingsPeriodControl(): bool
  361. {
  362. return $this->secondaryReadingsPeriodControl;
  363. }
  365. /**
  366. * @param bool $secondaryReadingsPeriodControl
  367. * @return GaugePurpose
  368. */
  369. public function setSecondaryReadingsPeriodControl(bool $secondaryReadingsPeriodControl): GaugePurpose
  370. {
  371. $this->secondaryReadingsPeriodControl = $secondaryReadingsPeriodControl;
  372. return $this;
  373. }
  375. /**
  376. * TODO možná přidat jako argument datetime aby bylo možno se ptát i historicky na počet segmentů např podle sazby elektroměru
  377. * @return array
  378. */
  379. public function getSegments(): array
  380. {
  381. $gauge = $this->getGauge();
  383. if ($gauge->getLevel() !== GaugeType::LEVEL_MAIN && $gauge->getParent() !== null) {
  384. foreach ($gauge->getParent()->getPurposes() as $parentPurpose) {
  385. if ($parentPurpose->getPurpose() === $this->getPurpose()) {
  386. return $parentPurpose->getSegments();
  387. }
  388. }
  389. // EM-959: when purposes don't match (FVE case: CONSUMPTION sub-gauge under
  390. // PRODUCTION parent), fall through to own segment logic below instead of
  391. // returning []. The original commit 24553f76 commented out the entire block,
  392. // which broke ~130 ordinary CONSUMPTION → CONSUMPTION sub-gauges.
  393. }
  395. if ($gauge->getType() === GaugeType::TYPE_ELECTRICITY_METER && $this->getPurpose() === self::PURPOSE_CONSUMPTION) {
  396. $segments = [];
  398. if ($gauge->isElectricityWholesale()) {
  399. $segments[Segment::SEGMENT_HIGH_TARIFF] = Segment::SEGMENT_HIGH_TARIFF;
  401. if ($gauge->isForceLowTariff()) {
  402. $segments[Segment::SEGMENT_LOW_TARIFF] = Segment::SEGMENT_LOW_TARIFF;
  403. }
  405. if ($gauge->isForceSpecialTariff()) {
  406. $segments[Segment::SEGMENT_SPECIAL_TARIFF] = Segment::SEGMENT_SPECIAL_TARIFF;
  407. }
  409. return $segments;
  410. }
  412. $currentRate = $this->getCurrent('rate', null, $gauge->getRates());
  413. if ($currentRate instanceof GaugeRate) {
  414. $rate = $currentRate->getRate();
  415. if ($rate->isHighTariff() === true) {
  416. $segments[Segment::SEGMENT_HIGH_TARIFF] = Segment::SEGMENT_HIGH_TARIFF;
  417. }
  419. if ($rate->isLowTariff() === true) {
  420. $segments[Segment::SEGMENT_LOW_TARIFF] = Segment::SEGMENT_LOW_TARIFF;
  421. }
  422. } else {
  423. $segments[Segment::SEGMENT_HIGH_TARIFF] = Segment::SEGMENT_HIGH_TARIFF;
  424. }
  426. return $segments;
  427. }
  429. if ($this->getPurpose() === self::PURPOSE_PRODUCTION) {
  430. return [Segment::SEGMENT_PRODUCTION => Segment::SEGMENT_PRODUCTION];
  431. }
  433. if ($this->getPurpose() === self::PURPOSE_DELIVERY) {
  434. return [Segment::SEGMENT_ENERGY_DELIVERY => Segment::SEGMENT_ENERGY_DELIVERY];
  435. }
  437. return Segment::getSegmentsByPurpose($this->getPurpose());
  438. }
  440. /**
  441. * @param bool $primary
  442. * @return GaugeVolumeRatio|GaugeRemoteVolumeRatio|null
  443. */
  444. public function getCurrentVolumeRatio(bool $primary)
  445. {
  446. if ($primary) {
  447. if ($this->gauge->getPrimaryMode() === GaugeType::MODE_MANUAL) {
  448. // primary is manual return volumeRatio
  449. return $this->getCurrent('volumeRatio', null, $this->getVolumeRatio());
  450. }
  452. // primary is remote return remoteVolumeRatio
  453. return $this->getCurrent('remoteVolumeRatio', null, $this->getRemoteVolumeRatio());
  454. }
  456. // secondary is manual return volumeRatio
  457. if ($this->gauge->getSecondaryMode() === GaugeType::MODE_MANUAL) {
  458. return $this->getCurrent('volumeRatio', null, $this->getVolumeRatio());
  459. }
  461. // secondary is remote return remoteVolumeRatio
  462. return $this->getCurrent('remoteVolumeRatio', null, $this->getRemoteVolumeRatio());
  463. }
  465. /**
  466. * @return GaugeUnit[]|Collection
  467. */
  468. public function getUnits()
  469. {
  470. return $this->units;
  471. }
  473. /**
  474. * @return GaugeRemoteUnit[]|Collection
  475. */
  476. public function getRemoteUnits()
  477. {
  478. return $this->remoteUnits;
  479. }
  481. /**
  482. * @param \DateTime|null $date
  483. * @return int
  484. */
  485. public function getCurrentUnit(?\DateTime $date = null): int
  486. {
  487. $gUnit = $this->getCurrent('units', $date, $this->units);
  489. if ($gUnit instanceof GaugeUnitInterface) {
  490. return $gUnit->getUnit();
  491. }
  493. // return default unit by gauge type
  494. return Units::getDefaultUnitByGaugeType($this->gauge->getType());
  495. }
  497. /**
  498. * @param \DateTime|null $date
  499. * @return int
  500. */
  501. public function getCurrentRemoteUnit(?\DateTime $date = null): int
  502. {
  503. $gUnit = $this->getCurrent('remoteUnits', $date, $this->remoteUnits);
  505. if ($gUnit instanceof GaugeUnitInterface) {
  506. return $gUnit->getUnit();
  507. }
  509. // return default unit by gauge type
  510. return Units::getDefaultUnitByGaugeType($this->gauge->getType());
  511. }
  513. /**
  514. * @param int $remoteUnit
  515. * @return $this
  516. */
  517. public function newRemoteUnit(int $remoteUnit):self
  518. {
  519. $gru = (new GaugeRemoteUnit())->setUnit($remoteUnit)->setValidFrom(new \DateTime());
  520. $gru->setGaugePurpose($this);
  521. $this->remoteUnits->add($gru);
  522. return $this;
  523. }
  525. /**
  526. * @param int $unit
  527. * @return $this
  528. */
  529. public function newUnit(int $unit):self
  530. {
  531. $gru = (new GaugeUnit())->setUnit($unit)->setValidFrom(new \DateTime());
  532. $gru->setGaugePurpose($this);
  533. $this->units->add($gru);
  534. return $this;
  535. }
  537. public function getRemoteReadingsPeriod(): ?int
  538. {
  539. return $this->remoteReadingsPeriod;
  540. }
  542. public function setRemoteReadingsPeriod(?int $remoteReadingsPeriod): GaugePurpose
  543. {
  544. $this->remoteReadingsPeriod = $remoteReadingsPeriod;
  545. return $this;
  546. }
  548. public function getRemoteReadingsMinuteFrequency(): ?int
  549. {
  550. return $this->remoteReadingsMinuteFrequency;
  551. }
  553. public function setRemoteReadingsMinuteFrequency(?int $remoteReadingsMinuteFrequency): GaugePurpose
  554. {
  555. $this->remoteReadingsMinuteFrequency = $remoteReadingsMinuteFrequency;
  556. return $this;
  557. }
  558. }