HP-1751 Create configurations for billing types

src/product/AggregateNotFoundException.php

@@ -0,0 +1,9 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product;
+
+use hiqdev\php\billing\Exception\RuntimeException;
+
+class AggregateNotFoundException extends RuntimeException
+{
+}

src/product/BillingRegistry.php

@@ -0,0 +1,135 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product;
+
+use hiqdev\billing\registry\invoice\RepresentationInterface;
+use hiqdev\billing\registry\product\Aggregate;
+use hiqdev\billing\registry\quantity\formatter\QuantityFormatterNotFoundException;
+use hiqdev\billing\registry\quantity\FractionQuantityData;
+use hiqdev\php\billing\product\behavior\BehaviorInterface;
+use hiqdev\php\billing\product\behavior\BehaviorNotFoundException;
+use hiqdev\php\billing\type\Type;
+use hiqdev\php\billing\type\TypeInterface;
+
+class BillingRegistry implements BillingRegistryInterface
+{
+    /** @var TariffTypeDefinition[] */
+    private array $tariffTypes = [];
+    private bool $locked = false;
+
+    public function addTariffType(TariffTypeDefinition $tariffType): void
+    {
+        if ($this->locked) {
+            throw new \RuntimeException("BillingRegistry is locked and cannot be modified.");
+        }
+
+        $this->tariffTypes[] = $tariffType;
+    }
+
+    public function lock(): void
+    {
+        $this->locked = true;
+    }
+
+    public function priceTypes(): \Generator
+    {
+        foreach ($this->tariffTypes as $tariffType) {
+            foreach ($tariffType->withPrices() as $priceTypeDefinition) {
+                yield $priceTypeDefinition;
+            }
+        }
+    }
+
+    /**
+     * @param string $representationClass
+     * @return RepresentationInterface[]
+     */
+    public function getRepresentationsByType(string $representationClass): array
+    {
+        $representations = [];
+        foreach ($this->priceTypes() as $priceTypeDefinition) {
+            foreach ($priceTypeDefinition->documentRepresentation() as $representation) {
+                if ($representation instanceof $representationClass) {
+                    $representations[] = $representation;
+                }
+            }
+        }
+
+        return $representations;
+    }
+
+    public function createQuantityFormatter(
+        string $type,
+        FractionQuantityData $data,
+    ): array {
+        $type = $this->convertStringTypeToType($type);
+
+        foreach ($this->priceTypes() as $priceTypeDefinition) {
+            if ($priceTypeDefinition->hasType($type)) {
+                return $priceTypeDefinition->createQuantityFormatter($data);
+            }
+        }
+
+        throw new QuantityFormatterNotFoundException('Quantity formatter not found');
+    }
+
+    private function convertStringTypeToType(string $type): TypeInterface
+    {
+        return Type::anyId($type);
+    }
+
+    /**
+     * @param string $type - full type like 'overuse,lb_capacity_unit'
+     * @param string $behaviorClassWrapper
+     * @return BehaviorInterface
+     * @throws BehaviorNotFoundException
+     */
+    public function getBehavior(string $type, string $behaviorClassWrapper): BehaviorInterface
+    {
+        $type = $this->convertStringTypeToType($type);
+
+        foreach ($this->priceTypes() as $priceTypeDefinition) {
+            if ($priceTypeDefinition->hasType($type)) {
+                foreach ($priceTypeDefinition->withBehaviors() as $behavior) {
+                    if ($behavior instanceof $behaviorClassWrapper) {
+                        return $behavior;
+                    }
+                }
+            }
+        }
+
+        throw new BehaviorNotFoundException('Behaviour was not found');
+    }
+
+    public function getBehaviors(string $behaviorClassWrapper): \Generator
+    {
+        foreach ($this->tariffTypes as $tariffType) {
+            foreach ($tariffType->withBehaviors() as $behavior) {
+                if ($behavior instanceof $behaviorClassWrapper) {
+                    yield $behavior;
+                }
+            }
+        }
+
+        foreach ($this->priceTypes() as $priceTypeDefinition) {
+            foreach ($priceTypeDefinition->withBehaviors() as $behavior) {
+                if ($behavior instanceof $behaviorClassWrapper) {
+                    yield $behavior;
+                }
+            }
+        }
+    }
+
+    public function getAggregate(string $type): Aggregate
+    {
+        $type = $this->convertStringTypeToType($type);
+
+        foreach ($this->priceTypes() as $priceTypeDefinition) {
+            if ($priceTypeDefinition->hasType($type)) {
+                return $priceTypeDefinition->getAggregate();
+            }
+        }
+
+        throw new AggregateNotFoundException('Aggregate was not found');
+    }
+}

src/product/BillingRegistryInterface.php

@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product;
+
+interface BillingRegistryInterface
+{
+    /**
+     * @return PriceTypeDefinition[]
+     */
+    public function priceTypes(): \Generator;
+}

src/product/DocumentRepresentationInterface.php

@@ -0,0 +1,8 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product;
+
+interface DocumentRepresentationInterface
+{
+
+}

src/product/Domain/Model/TariffTypeInterface.php

@@ -0,0 +1,8 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product\Domain\Model;
+
+interface TariffTypeInterface
+{
+
+}

src/product/Domain/Model/Unit/FractionUnitInterface.php

@@ -0,0 +1,8 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product\Domain\Model\Unit;
+
+interface FractionUnitInterface
+{
+
+}

src/product/Domain/Model/Unit/UnitInterface.php

@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product\Domain\Model\Unit;
+
+use \hiqdev\php\units\UnitInterface as BaseUnitInterface;
+
+interface UnitInterface
+{
+    public function createExternalUnit(): BaseUnitInterface;
+
+    public function fractionUnit(): FractionUnitInterface;
+}

src/product/InvoiceDescriptionsBuilder.php

@@ -0,0 +1,23 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product;
+
+class InvoiceDescriptionsBuilder
+{
+    private BillingRegistry $registry;
+
+    public function __construct(BillingRegistry $registry)
+    {
+        $this->registry = $registry;
+    }
+
+    public function build(): array
+    {
+        $descriptions = [];
+        foreach ($this->registry->priceTypes() as $priceType) {
+            $descriptions[] = $priceType->representInvoice();
+        }
+
+        return $descriptions;
+    }
+}

src/product/ParentNodeDefinitionInterface.php

@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product;
+
+use hiqdev\php\billing\product\behavior\BehaviorCollectionInterface;
+
+interface ParentNodeDefinitionInterface
+{
+    public function withBehaviors(): BehaviorCollectionInterface;
+
+    public function hasBehavior(string $behaviorClassName): bool;
+}

src/product/PriceTypeDefinition.php

@@ -0,0 +1,154 @@
+<?php declare(strict_types=1);
+
+namespace hiqdev\php\billing\product;
+
+use hiqdev\php\billing\product\behavior\BehaviourPriceTypeDefinitionCollection;
+use hiqdev\billing\registry\invoice\InvoiceRepresentationCollection;
+use hiqdev\billing\registry\product\Aggregate;
+use hiqdev\billing\registry\quantity\formatter\QuantityFormatterDefinition;
+use hiqdev\billing\registry\quantity\formatter\QuantityFormatterFactory;
+use hiqdev\billing\registry\quantity\FractionQuantityData;
+use hiqdev\php\billing\product\Domain\Model\TariffTypeInterface;
+use hiqdev\php\billing\product\Domain\Model\Unit\FractionUnitInterface;
+use hiqdev\php\billing\product\Domain\Model\Unit\UnitInterface;
+use hiqdev\php\billing\quantity\QuantityFormatterInterface;
+use hiqdev\php\billing\type\TypeInterface;
+
+class PriceTypeDefinition implements ParentNodeDefinitionInterface
+{
+    private UnitInterface $unit;
+
+    private string $description;
+
+    private QuantityFormatterDefinition $quantityFormatterDefinition;
+
+    private InvoiceRepresentationCollection $invoiceCollection;
+
+    private BehaviourPriceTypeDefinitionCollection $behaviorCollection;
+
+    private Aggregate $aggregate;
+
+    public function __construct(
+        private readonly PriceTypeDefinitionCollection $parent,
+        private readonly TypeInterface $type,
+        TariffTypeInterface $tariffType,
+    ) {
+        $this->invoiceCollection = new InvoiceRepresentationCollection($this);
+        $this->behaviorCollection = new BehaviourPriceTypeDefinitionCollection($this, $tariffType);
+
+        $this->init();
+    }
+
+    protected function init(): void
+    {
+        // Hook
+    }
+
+    public function unit(UnitInterface $unit): self
+    {
+        $this->unit = $unit;
+
+        return $this;
+    }
+
+    public function description(string $description): self
+    {
+        $this->description = $description;
+
+        return $this;
+    }
+
+    public function getDescription(): string
+    {
+        return $this->description;
+    }
+
+    /**
+     * @param string $formatterClass
+     * @param null|FractionUnitInterface|string $fractionUnit
+     * @return $this
+     */
+    public function quantityFormatter(string $formatterClass, $fractionUnit = null): self
+    {
+        // TODO: check if formatterClass exists
+        $this->quantityFormatterDefinition = new QuantityFormatterDefinition($formatterClass, $fractionUnit);
+
+        return $this;
+    }
+
+    public function createQuantityFormatter(
+        FractionQuantityData $data,
+    ): QuantityFormatterInterface {
+        return QuantityFormatterFactory::create(
+            $this->getUnit()->createExternalUnit(),
+            $this->quantityFormatterDefinition,
+            $data,
+        );
+    }
+
+    public function end(): PriceTypeDefinitionCollection
+    {
+        // Validate the PriceType and lock its state
+        return $this->parent;
+    }
+
+    public function documentRepresentation(): InvoiceRepresentationCollection
+    {
+        return $this->invoiceCollection;
+    }
+
+    public function measuredWith(\hiqdev\billing\registry\measure\RcpTrafCollector $param): self
+    {
+        return $this;
+    }
+
+    public function type(): TypeInterface
+    {
+        return $this->type;
+    }
+
+    public function hasType(TypeInterface $type): bool
+    {
+        return $this->type->equals($type);
+    }
+
+    public function getUnit(): UnitInterface
+    {
+        return $this->unit;
+    }
+
+    public function withBehaviors(): BehaviourPriceTypeDefinitionCollection
+    {
+        return $this->behaviorCollection;
+    }
+
+    public function hasBehavior(string $behaviorClassName): bool
+    {
+        foreach ($this->behaviorCollection as $behavior) {
+            if ($behavior instanceof $behaviorClassName) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * це параметер визначає агрегатну функцію яка застосовується для щоденно записаних ресурсів щоб визнизначти
+     * місячне споживання за яке потрібно пробілити клієнта
+     *
+     * @param Aggregate $aggregate
+     * @return self
+     */
+    public function aggregation(Aggregate $aggregate): self
+    {
+        $this->aggregate = $aggregate;
+
+        return $this;
+    }
+
+    public function getAggregate(): Aggregate
+    {
+        return $this->aggregate;
+    }
+}