Rôzne ceny za rôznych okolností

Není to tak dlouho, co jsem řešil podobný problém a vlastně i stále tak trochu řeším. Nakonec jsem nechal po šablonách jak píšeš $product->getPrice($customer, $season, $otherRule). Ale je to na minimum místech, protože to mám v komponentách.

Ukázka řešení výš mi přijde hrozně ošklivá (ať už je to moderní jak chce), psát funkce a metody do stringu? …

Jestli si vystačíš s PriceResolver, tak bych šel tou cestou… ale. Ale já potřebuji někde ceny s DPH, někde ceny bez DPH, někde ceny s aplikovanou slevou, jinde bez aplikované slevy, v některých místech potřebuju i vědět, jaká ta sleva byla, některé slevy potřebuju řešit ne jednotkové ceny, jiné zase až v závislosti na zadaném množství a řeším poměrně dost takových podmínek (doteď přesně nevím jak přesně mám ceny počítat a nemám to specifikováno, ha).

My to řešíme jinak. Máme upravenou Nette\Table\ActiveRow o vlastní datové typy, které prezentují konkrétní tabulku.

Takže pokud fetchnu řádek s Produktem, mám k dispozici něco jako \Nette\Table\Product a můžu si do datového typu dopsat cokoliv co chci (v rámci třídy používám $this = což je vlastně aktuální záznam v DB).

Takže pokud jsem v PHP nebo v Latte tak můžu psát $product // ActiveRow a rovnou volat metody z datatypu $product->basePrice()
$productPriceWoVat() apod.

Mám to k dispozici v každém kontextu bez serepetiček, resolverů a dalších různých injectů, helper modelů apod.

Editoval Kcko (3. 2. 2022 21:34)

Čiže v šablóne budem mať $product->getPrice($customer, $season, $otherRule)

a

>

Čiže v šablóne budem volať $priceResolver->resolve($product)

Pokud jsem tomu správně porozuměl, tak si v presenteru předáš do šablony modelovou třídu $product a v šabloně si z ní potom taháš co potřebuješ a případně si data v šabloně upravíš resolverem nebo modifikátory jako parametrem.

Určitě to takhle jde, ale pokud se nemýlím, tak koncept MVC modelu doporučuje, aby šablona pouze vykreslovala a požadovaná data dodal model. Rovněž koncepce DI doporučuje předávat vždy konkrétní závislosti, nikoliv předat velký balík všech závislostí, z nichž si komponenta vybere co potřebuje. Do šablony je ideální předat hotový objekt který se dá rovnou vykreslit, aby byla šablona jednodušší, přehlednější a více znovupoužitelná. Samozřejmě někdy to nejde, nebo je jednodušší data dodatečně upravit v šabloně, ale to je spíše vyjímečné.

PriceResolver by měl být v Modelu a třída Product by ho měla rovnou použít tak, aby do Presenteru dodala již vykreslitelná data. Ideální je, když šablona vůbec neví, jak se vykreslovaná data získaly.

@m.brecher
$product je entita (ORM ti mapuje dáta z databázy na objekty=entity, čo ale nie je predmetom diskusie), čiže nie je to služba, ktorú by vytváral DI, je to obálka na dáta, ktorú vytvára v mojom prípade Doctrine, práve vďaka tomu mám úplne odtienený logiku od zobrazovania – keďže ju ale nevytvára DI, neviem jej cez DI predať $resolver

$resolver je potom služba (čiže objekt modelovej vrstvy), ktorú si odovzdám do šablóny, aby vykonala logiku nad nejakou entitou a vrátila vykresliteľné dáta – toto je čisté riešenie, netvorím logiku v šablóne, v šablóne iba poviem, že chcem vykresliť cenu s DPH a aplikovanými zľavami, o všetko ostatné sa stará resolver/model.

Editoval MajklNajt (4. 2. 2022 13:21)

@Klobás ahoj, obe metódy vracajú objekt triedy Price, modify robí to, že hodnotu ceny zvýši/zníži a vráti novú inštanciu Price, nakoľko ide o Value Object

@jendaa ktorá bude robiť čo?

Klobás napsal(a):

MajklNajt napsal(a):

@Klobás ahoj, obe metódy vracajú objekt triedy Price, modify robí to, že hodnotu ceny zvýši/zníži a vráti novú inštanciu Price, nakoľko ide o Value Object

Ahoj, děkuji.
Pokud to není tajné a příliš dlouhé, mohl bych to vidět?

asi je to off-topic, ale nech sa páči, posielam obe triedy (Price aj Modifier), aby to teda malo možno nejaký úžitok aj pre iných

<?php
class Price
{
    private float $amount;
    private string $currency;

    public function __construct(float $amount, string $currency)
    {
        $this->amount = $amount;
        $this->currency = $currency;
    }

    public function getAmount(int $precision = 2): float
    {
        return round($this->amount, $precision);
    }

    public function getCurrency(): string
    {
        return $this->currency;
    }

    public function modify(Modifier $modifier): Price
    {
        if($modifier->isPercentage()) {
            $amount = $this->getAmount(4) * (100 + $modifier->getAmount()) / 100;
        }
        else {
            $amount = $this->getAmount(4) + $modifier->getAmount();
        }
        return new self($amount, $this->currency);
    }

    public function multiply(float $multiplier): Price
    {
        return new self($this->amount * $multiplier, $this->currency);
    }

    public function divide(float $divisor): Price
    {
        return new self($this->amount / $divisor, $this->currency);
    }

    public function add(Price $price): Price
    {
        if($this->currency !== $price->getCurrency()) {
            throw new CurrencyMismatchException("Currency missmatch");
        }
        return new self($this->amount + $price->getAmount(4), $this->currency);
    }

    public function minus(Price $price): Price
    {
        if($this->currency !== $price->getCurrency()) {
            throw new CurrencyMismatchException("Currency missmatch");
        }
        return new self($this->amount - $price->getAmount(4), $this->currency);
    }

    public function equals(Price $other): bool
    {
        return $this->getAmount(4) === $other->getAmount(4) and $this->currency === $other->getCurrency();
    }
}
?>

<?php
class Modifier
{
    const TYPE_PERCENTAGE = "P";
    const TYPE_ABSOLUTE = "A";

    private string $type;
    private float $amount;

    public function __construct(string $type, float $amount)
    {
        $this->type = $type;
        $this->amount = $amount;
    }

    public function getType(): string
    {
        return $this->type;
    }

    public function getAmount(int $precision = 2): float
    {
        return round($this->amount, $precision);
    }

    public function cumulate(Modifier $modifier): Modifier
    {
        if($this->type !== $modifier->getType()) {
            throw new TypeMissmatchException("Type missmatch");
        }
        return new self($this->type, $this->amount + $modifier->getAmount(4));
    }

    public function isPercentage(): bool
    {
        return $this->type === self::TYPE_PERCENTAGE;
    }

    public function isAbsolute(): bool
    {
        return $this->type === self::TYPE_ABSOLUTE;
    }
}
?>

<?php
 class Price
 {
     private float $amount;
     private string $currency;
[...]

Don't use float for money, it's conceptually the wrong type and the main headache of wrong results.

For money, or everything that must have an exact answer, fixed-point arithmetic must be used instead of floating-point arithmetic, in PHP this is supported with BCMath (that operates with strings, but it is well optimized and fast) or, if not available, integers could be used. Some other languages have the decimal type.

Or leave the calculation to the database (if you used numeric/decimal type) that is also well optimized and fast.

Editoval dsar (5. 2. 2022 19:16)