Nextras\ORM – ORM nad Nextras\Dbal

@goood je to strasne dulezite :-) i pro ostatni, aby nahodou nekopirovali nebezpecny kod…

Zdravím,
chtěl jsem se zeptat jak to je s Nextras/ORM. Někde jsem se dočetl, že pracuje nad Nette/Database, ale v praxi mi to s ním nefunguje (je to tedy možné zprovoznit s NDtb?). Zjistil jsem že to funguje s Nextras/Dbal, ale vyhazuje mi to vyjímku Unknown or incorrect time zone: ‚Europe/Prague‘. V tomto vlákně jsem se dočetl, že se to má řešit importem názvů časových pásem do databáze, ale na produkci to bohužel nemůžeme ovlivni, jelikož máme externí správu databázového serveru. Lze to řešit i nějak jinak?

Někde jsem se dočetl, že pracuje nad Nette/Database, ale v praxi mi to s ním nefunguje

takto to bylo jeste pred stable 1.0. tj. hodne davno, vic jak pise Felix :-)

@Felix: Děkuji za radu. Je to funkční.

Ještě jsem se chtěl zeptat, zda se nedá náhodou řešit přes config nastavení prefixu tabulek nebo jestli to někdo neřešil nějakým způsobem. Díky za každou radu ;)

Editoval pfilipek (5. 5. 2016 17:56)

Zdravím, chtěl jsem se zeptat na to když mám u entity property například @property array $test, tak jestli ORM umí a případně jak ukládat do databáze (např pomocí serializace) a při dotázání z DB zase vrátit pole. Pokud ne tak posílám řešení které mě zatím funguje:

<?php
  namespace app\model\orm\entities;

  use pf\datatypes\JSON;

  /**
   * Třída TestEntity.
   *
   * @property JSON $test
   */
  class TestEntity extends Entity
  {
    /**
     * Nastaví test property na objekt JSON.
     *
     * @param mixed $data
     */
    protected function setterUserSettings($data) {
      if (!is_a($data, JSON::class)) {
        $data = JSON::create($data);
      }

      return $data;
    }
  }
?>

objekt JSON je třída, která je potomkem ArrayObject, takže se s ní pracuje jako s polem a má právě magickou metodu __toString(), která zajistí že při ukládání do databáze se pole uloží v JSONu a při načtení z DB se z něj stane opět JSON object.

Více viz. zdrojový kód:

<?php
  namespace prosys\datatypes;

  use ArrayObject;
  use Tracy\Debugger;

  /**
   * Objekt reprezentujici datovy typ JSON.
   */
  class JSON extends ArrayObject implements \JsonSerializable{
    private $_json;

    public function __construct($json = NULL, $flags = 0, $iterator_class = 'ArrayIterator') {
      if (!is_array($json)) {
        $json = ((($decoded = @json_decode($json, TRUE))) ? $decoded : array());
      }

      $this->_json = (($json) ? $json : array());

      parent::__construct($json, $flags, $iterator_class);
    }

    public function jsonSerialize() {
      return $this->_json;
    }

    public function offsetExists($offset) {
      return array_key_exists($offset, $this->_json);
    }

    public function offsetGet($offset) {
      return $this->_json[$offset];
    }

    public function offsetSet($offset, $value) {
      $this->_json[$offset] = $value;
    }

    public function offsetUnset($offset) {
      unset($this->_json[$offset]);
    }

    public function append($value) {
      $this->_json[] = $value;
    }

    public function count($mode = 'COUNT_NORMAL') {
      return count($this->_json, $mode);
    }

    public function getIterator() {
      return new \ArrayIterator($this->_json);
    }

    public function __toString() {
      return json_encode($this->_json, JSON_PRETTY_PRINT);
    }

    public static function create($json) {
      return new static($json);
    }
  }
?>

Editoval pfilipek (7. 5. 2016 14:53)

pfilipek napsal(a):

@Felix: Děkuji za radu. Je to funkční.

Ještě jsem se chtěl zeptat, zda se nedá náhodou řešit přes config nastavení prefixu tabulek nebo jestli to někdo neřešil nějakým způsobem. Díky za každou radu ;)

Zdravím, tak jsem implementoval použití prefixu tabulek definovaného v config.neon. V první řadě jsem si vytvořil MyMapper, který dědí od \Nextras\Orm\Mapper\Mapper a prefix jsem si ošetřil v něm viz následující ukázka:

<?php
  namespace app\orm;

  use Nette\Caching\Cache;
  use Nextras\Dbal\Connection;
  use Nextras\Dbal\InvalidArgumentException;
  use Nextras\Orm\Mapper\Mapper;
  use pf\common\Functions;

  /**
   * Hlavní mapper ORM systému.
   */
  abstract class MyMapper extends Mapper
  {
    private $prefix = NULL;
    protected $tableName = NULL;

    public function __construct(Connection $connection, Cache $cache) {
      parent::__construct($connection, $cache);

      $this->prefix = Functions::item($connection->getConfig(), 'prefix');
    }

    /**
     * Vrátí název tabulky.
     *
     * @return string
     */
    public function getTableName() {
      if (is_null($this->tableName) || !$this->tableName) {
        throw new InvalidArgumentException('Musí být zadán název tabulky pro mapper: ' . get_called_class());
      }
      return $this->prefix . $this->tableName;
    }
  }
?>

Třída Functions sdružuje užitečné funkce a zde použitá funkce item jen ošetřuje to, že pokud se požadovaný klíč v předaném poli nenachází, tak vrátí výchozí hodnotu (v default NULL, ale jinak se dá předa jako třetí parametr funkce).
V config.neon potom použijete klíč prefix v sekci dbal.

Editoval pfilipek (7. 5. 2016 14:53)

Zdravím,

chtěl jsem se zeptat, jak vyřešit tento problém:
Mám entitu Country a CountryTranslation. Problém je v tom, že potřebuju nyní řadit entitu Country podle property name z entity CountryTranslation. Entity mám nadefinované následovně:

Country:

/**
 * @property-read int $id {primary}
 * @property string                                  $isoCode
 * @property string                                  $isoCode2
 * @property JSON                                    $addressFormat
 * @property bool                                    $mandatoryZipcode
 * @property bool                                    $disabled
 *
 * @property ManyHasOne|CountryTranslation[]   $translations {1:m CountryTranslation::$country}
 */
class Country extends TranslationEntity
{
}

CountryTranslation:

/**
 * @property-read int       $id        {primary}
 * @property      Language  $language  {m:1 Language, oneSided=TRUE}
 * @property      Country   $country   {m:1 Country::$translations}
 */
class CountryTranslation extends MainEntity
{
}

Nevím si už rady jak docílit toho řazení. Někde jsem četl že přes Mapper ale netuším zatím jak na to. Můžete někdo aspoň trochu naznačit řešení? Díky moc.

chceš seřadit ty země podle názvu (jednoho?) jejich překladu?

Ahoj,
pochopil jsi to správně, každá země má n překladů podle jazyků v DB. Takže moje otázka zní když budu mít aktivní jazyk čeština tak potřebuji řadit podle názvu země pro jazyk čeština a když slovenština, tak zase řadit podle názvu překladu slovenština.

Díky moc

a jak to zakomponovat do Nextras/Datagrid, protože tam to dělám tak, že poskytuji data jako kolekci entit Country a ty vypisuji v šabloně, kde se odkazuji na překlad dle aktuálního jazyka. Sloupec mám pojmenovaný name, takže když mi přijde do sourceCallbacku order s nazvem sloupce name, tak to musim poskytnout jinym zpusobem ta data než když to dělám obvykle že? A ještě mi teď došlo co když budu chtít řadit podle názvu z překladu (CountryTranslation) a zároveň podle isoCode (Country) to už nebude tak easy že? Mě napadlo to nechat na mapperu a vyřešit to nějak přes join ale zatím v tom tápu a nevím jak a co předat.

kolekci entit Country

Můžeš to pole obalit objektem ArrayCollection. Nebo (pokud bys to potřeboval třeba dynamicky stránkovat, tak) to můžeš samozřejmě přepsat do SQL a dát do mapperu.

A ještě mi teď došlo co když budu chtít řadit podle názvu z překladu (CountryTranslation) a zároveň podle isoCode (Country)

Nechápu, to ty přeložené názvy nejsou unikátní? Slovo „zároveň“ používáš ve významu „sekundárně“? Mělo by snad fungovat i něco jako

$countryTranslations
	->findBy(['language' => $activeLanguage])
	->orderBy(['name', 'this->country->isoCode']);

Zdravim,
tak jsem zkoušel to co napsal @hrach

pripadne:

$countries = $orm->countries->findBy(['this->translation->lang' => $activeLanguage])
     ->orderBy('this->translation->name');

a nefunguje. Píše to následující chybu Cannot order by ‚this->translations->name‘ expression, includes has many relationship, což je logické, protože ORM neví podle kterého překladu to řadit.

to @Jan Tvrdík:
no ty překlady nemusí být unikátní, tady u překladu státu nejspíš ano, ale co když se to bude týkat překladu tabulky výrobků tam už jeden výrobek může být pro dva jazyky přeložen stejně, například čeština a slovenština mají některá slova totožná.

Editoval pfilipek (23. 5. 2016 8:46)

pfilipek napsal(a):

Tak jsme to teďka ještě s kolegou konzultovali a mě napadlo po přečtení příspěvku od @Jan Tvrdík, že i když chci vypisovat na výstup země, tak bude lepší k tomu přistupovat ze strany překladů zemí (CountryTranslation), protože každý překlad vidí právě na svoji konkrétní zemi a přes ni můžu jak filtrovat, tak i řadit pokud se nepletu:

$countryTranslations = $orm->countryTranslations->findBy(['language' => $activeLanguage, 'this->country->isoCode' => $filter['isoCode']])
     ->orderBy('name')
     ->orderBy('this->country->isoCode', ICollection::DESC);

problém u tohoto řešení je, že pokud některá země nebude mít překlad pro aktuální jazyk tak se mi nezobrazí. Jak na to? Chtěl bych, aby se to chovalo následovně:

Výchozí parametry:

• Výchozí jazyk systému je: čeština
• Aktuální jazyk je: sloveština
• Země mají pro výchozí jazyk překlady

Měly by se zobrazovat všechny země tak, že pokud nebude existovat překlad pro aktuální jazyk vezme se překlad pro výchozí jazyk.

Editoval pfilipek (23. 5. 2016 9:53)

hrach napsal(a):

Sorry za zmatky, uz chapu, proc to nejede :/ Namet na vylepseni ORM.

mohl bych poprosit o nastínění (nakopnutí) jak by se to dalo řešit, já bych to zkusil naimplementovat a hodil bych potom pullrequest na git, abych aspoň trochu pomohl.

Díky moc za návod, tvůj návod

$defaultLanguage = 'cs';
$activeLanguage = 'sk';

$countryTranslations = $orm->countryTranslations
	->findBy([
		'language' => [$activeLanguage, $defaultLanguage],
		'this->country->isoCode' => $filter['isoCode']]
	)
	->orderBy('name')
	->orderBy('this->country->isoCode', ICollection::DESC);

je super, akorát se mi dublují záznamy což je logické když udělám language IN (‚cs‘, ‚sk‘), ale potřeboval bych tím pádem udělat nějké GROUP BY pro seskupení těch záznamů.

SQL dotaz v Mapperu není problém, ale nevím co má mapper vracet, tak aby se mi to chovalo korektně a hlavně když budu chtít použít nějaké aliasy, tak se s tím už bude hůře pracovat v řazení atd. Nebude to vůbec použitelné pro napojení na Nextras\Datagrid.

Ještě dotaz na metody v mapperu:
Někde jsem četl, že když udělám metodu v Mapperu, tak stačí potom v repozitáři dát metodu do anotace třídy (předpokládám, že jen kvůli nápovědě) a mělo by být vše funkční, ale u mě není → vyhodí to chybu Call to undefined method prosys\model\orm\CountryRepository::test().

@JanTvrdík Vyzkoušel jsem tvoji radu

Mám dojem, že musí začínat ne get nebo find.

ale bohužel je nefunkční. Zkusil jsem si pojmenovat vlastni metodu getMy i findMy a pokaždé mi to zahlásilo chybu, že volám neznámou metodu na repozitář.

@goood Díky, tak už jsem pochopil použití a funguje.

Akorát pořád stojím na tom mém problému s překlady. Nevím si s tím rady. To co mi poradil @JanTvrdík (přistupovat ze strany překladů) je nepoužitelné, pokud daná entita nemá překlad pro aktuální jazyk. Když totiž použiji podmínku ...->findBy(['language' => [$activeLanguage, $defaultLanguage]); tak se mi vrátí překlady pro oba jazyky – logicky ;). Já bych ovšem potřeboval vrátit vždycky všechny entity, a ke každé entitě mít překlad aktuálního jazyka a pokud neexistuje, tak se vezme výchozí překlad (ten musí vždycky existovat).

Zkuste mě aspoň někdo nakopnout :) Díky moc.

Editoval pfilipek (24. 5. 2016 13:44)

pfilipek napsal(a):

@goood Díky, tak už jsem pochopil použití a funguje.

Akorát pořád stojím na tom mém problému s překlady. Nevím si s tím rady. To co mi poradil @JanTvrdík (přistupovat ze strany překladů) je nepoužitelné, pokud daná entita nemá překlad pro aktuální jazyk. Když totiž použiji podmínku ...->findBy(['language' => [$activeLanguage, $defaultLanguage]); tak se mi vrátí překlady pro oba jazyky – logicky ;). Já bych ovšem potřeboval vrátit vždycky všechny entity, a ke každé entitě mít překlad aktuálního jazyka a pokud neexistuje, tak se vezme výchozí překlad (ten musí vždycky existovat).

Zkuste mě aspoň někdo nakopnout :) Díky moc.

Tak si to napiš přímo v SQL, to asi bude nejjednodušší

@pfilipek

Díky za názor, ale pro mě v tu chvíli nemá význam asi používat ORM

zpusob vytazeni dat prece nic nerika o tom, ze nemuzes vyuzivat benefitu orm;
to ale porad nemeni nic na tom, ze zrejme muzes vyuzit QueryBuilder, ktery poskytuje dostatecnou abstrakci a posleze se porad da prevest na klasicke ICollection.

@Gappa Něco co potřebuješ mám již vyřešeno. Udělal jsem si obecnou TranslationEntity, od které dědí všechny entity, které mají překladovou entitu více napoví níže uvedený kód:

namespace prosys\model\orm\entities;

  use Nextras\Orm\InvalidArgumentException;
  use Nextras\Orm\InvalidStateException;
  use prosys\services\LanguageService;

  abstract class TranslationEntity extends MyEntity
  {
    /** @var LanguageService */
    protected $languageService;

    /**
     * Injectnutí LanguageService.
     * @param LanguageService $languageService
     */
    public function injectTranslator(LanguageService $languageService) {
      $this->languageService = $languageService;
    }

    /**
     * Vrátí překlad podle jazyka.<br />
     * Pokud jazyk není předán, vezme se výchozí.
     *
     * @param string $code
     * @return ProSYSEntity
     */
    public function getTranslation($code = NULL) {
      $language = NULL;
      if (!isset($this->translations)) {
        throw new InvalidArgumentException('Entita ' . get_called_class() . ' nemá definovanou property translations s vazbou na překladovou tabulku.');
      }

      if (!is_null($code)) {
        try {
          $language = $this->languageService->getLanguageByCode($code);
        } catch (InvalidArgumentException $e) {
          throw new InvalidArgumentException($e->getMessage());
        }
      }

      if (is_null($language)) {
        $language = $this->languageService->getCurrentLanguage();
      }

      $translation = $this->translations->get()->findBy(['language' => $language->id])->fetch();
      if (!$translation) {
        throw new InvalidArgumentException('<b>' . get_called_class() . ' (id: ' . $this->id . ')</b>', 'Následující entity nemají překlad pro jazyk: <b>' . $language->name . '</b>');
        $translation = $this->translations->get()->findBy(['language' => $this->languageService->getDefaultLanguage()])->fetch();
      }

      return $translation;
    }

    /**
     * Vyzkouší získat property způsobem, který definuje rodič, v případě výjimky vyzkouší, zda se nejedná o překladovou property v aktuálním jazyku a jinak vyhodí obě výjimky.
     *
     * @param $name
     * @return mixed
     */
    public function &__get($name) {
      $translate = function($name, $msgs = []) {
        try {
          return $this->getTranslation()->$name;
        } catch (InvalidArgumentException $e) {
          $msgs[] = $e->getMessage();
          throw new InvalidArgumentException(implode(' --> ', $msgs));
        }
      };

      try {
        $value = parent::__get($name);
      } catch (InvalidArgumentException $e) {             // neni-li uvedena v anotaci entity
        $value = $translate($name, [$e->getMessage()]);
      } catch (InvalidStateException $e) {                // je-li v anotaci entity jako virtual
        $value = $translate($name, [$e->getMessage()]);
      }

      return $value;
    }

A tady je použití v překladatelné entitě:

namespace prosys\model\orm\entities;

use prosys\datatypes\JSON;

/**
 * Třída CountryEntity - objektová reprezentace země systému.
 *
 * @property-read int $id {primary}
 * @property string                                  $isoCode
 * @property string                                  $isoCode2
 * @property JSON                                    $addressFormat
 * @property bool                                    $mandatoryZipcode
 * @property bool                                    $disabled
 *
 * @property ManyHasOne|CountryTranslationEntity[]   $translations {1:m CountryTranslationEntity::$country}
 *
 * @property-read string $name         {virtual}
 * @property-read string $description  {virtual}
 * @property-read string $help         {virtual}
 */
class CountryEntity extends ProSYSTranslationEntity
{
}

LanguageService je služba, která se mi stará o poskytování jazyků.

Funguje to tak, že překladatelná entita musí mít property $translations a potom se s tím pracuje následovně:

	$country = $orm->countries->getById(2);
	$country->getTrasnlation()->name; // vrátí název pro aktuální jazyk
	$country->getTrasnlation('en')->name; // vrátí název pro anglický jazyk

Editoval pfilipek (25. 5. 2016 8:31)

@hrach Tak jsem si udělal dotaz do DB v maperru:

public function findByLanguage(LanguageEntity $language) {
  $query = $this->builder()->from($this->getTableName(), 'c')
                         ->addSelect('c.*')
                         ->addSelect('CASE WHEN t.`name` IS NULL THEN d.`name` ELSE t.`name` END AS name')
                         ->leftJoin('c', 'country_translations', 't', 't.country_id = c.id AND t.language_id = %i', $language->id)
                         ->leftJoin('c', 'country_translations', 'd', "d.country_id = c.id AND d.language_id = (SELECT id FROM languages WHERE is_default = 1)");

  return $query;
}

vrátí mi to ICollection, ale problém nastane když chci na to zavolat orderBy('name') (sloupec, který mi vzniká pomocí CASE). Jak jsem zjistil, tak Dbal automaticky přidá k požadovanému sloupci alias z from tabulky a to vyhodí vyjímku Unknown column ‚c.name‘ in ‚order clause‘ což chápu, protože takový sloupec v tabulce countries c opravdu neexistuje.

Ještě se zeptám, kdybych to chtěl řešit pomocí DB view (pohledu), tak jak to mám udělat abych mohl i ukládat data, protože nad view samozřejmě nemůžu provádět INSERT, UPDATE a DELETE?

Editoval pfilipek (25. 5. 2016 12:33)

@pfilipek

• case & name: no a nemuzes tam dat as c.name? ICollection umi pracovat jen se strukturou entity, tzn. jen diky tomu, ze tam je takovy sloupec ti to funguje, ale tim hackem by to mohlo fungovat.
• view: tam je to prave ten vtip, ze by to bylo jen read-only. byla to jen idea, nevim, jestli je to dobry napad.
• rizeni flow – pres navratove hodnoty, nebo argumenty pasnuty jako reference. uplne presne jsem nezkoumal tvuj priklad, ale urcite to nejak pujde.

@hrach

• case & name: Tak jsem vyzkoušel doporučený hack ale stále to nefunguje. Stále to vyhazuje stejnou chybu.
• view: a můžu se zeptat jestli máš nápad? protože mě přijde blbost dělat kvůli tomu dvě entity, dva repositáře a dva mappery (jede pro obsluhu view – SELECT a druhý pro zbylé operace INSERT, UPDATE a DELETE)

@JanTvrdík Tak díky tvoje řešení je funkční. Jdu to testnout jak se to bude chovat dál v systému. Díky

@Gappa

Ideální stav by byl, že by entita řešila jak načítání, tak ukládání dat, aby nebylo poznat, že se reálně pracuje se dvěma tabulkami.

No úplně ideální to není, protože je lepší mít pro překlady zvlášť entitu, protože překladů máš většinou víc (podle počtu jazyků). Je to lepší z toho důvodu, že přes vazbu ManyHasOne si to pohodlně napáruješ a potom už můžeš jednoduše vypisovat v šabloně např:

<div id="someEntity_{$someEntity->id}">
	ID: {$someEntity->id}
	Překlady:
	<ul n:inner-foreach="$someEntity->translations as $translation">
		<li>Jazyk: {$translation->language->name}: {$translation->name}</li>
	</ul>
</div>

při definici entit:

/**
 * @property      string                                  $id           {primary}
 * @property      string                                  $version
 * @property      bool                                    $installed
 *
 * @property      ManyHasOne|SomeTranslationEntity[]      $translations {1:m SomeTranslationEntity::$some, cascade=[persist, remove]}
 *
 * @property-read string                                  $name         {virtual}
 * @property-read string                                  $description  {virtual}
 * @property-read string                                  $help         {virtual}
 */
class SomeEntity extends Entity
{
  /**
   * @param string    $id
   * @param string    $version
   * @param bool      $installed
   *
   * @return SomeEntity
   * @throws InvalidArgumentException
   */
  public static function create(string $id = '', string $version = '', bool $installed = FALSE): Entity {
    if (!$id || !$version) {
      throw new InvalidArgumentException('id a verze jsou povinné parametry');
    }

    $entity = new SomeEntity();

    $entity->id = $id;
    $entity->version = $version;
    $entity->installed = $installed;

    return $entity;
  }
}

/**
 * @property-read int             $id        {primary}
 * @property      ExtensionEntity $extension {m:1 SomeEntity::$translations}
 * @property      LanguageEntity  $language  {m:1 LanguageEntity, oneSided=TRUE}
 * @property      string          $name
 */
class SomeTranslationEntity extends TranslationEntity
{
  /**
   * @param LanguageEntity $code
   * @param string $name
   *
   * @return SomeTranslationEntity
   * @throws InvalidArgumentException
   */
  public static function create(LanguageEntity $language = NULL, string $name = ''): Entity {
    if (!$language || !$name) {
      throw new InvalidArgumentException('Entita jazyka a překlad názvu rozšíření jsou povinné parametry');
    }

    $entity = new SomeTranslationEntity();

    $entity->language = $language;
    $entity->name = $name;

    return $entity;
  }
}

V entitách mám vytvořené i továrničky, aby se to lépe používalo potom při ukládání atd …

a naopak zase při ukládání je to taky triviální a ještě navíc uzavřené v transakci, takže když by se něco pokazilo, tak se defacto nic nestane více příklad

	$someEntity = new SomeEntity();
	$someEntity->version = '1.0';
	$someEntity->installed = TRUE;

	$someEntity->translations->add(SomeTranslationEntity::create($currentLanguageEntity, 'Název nějaké entity'));

	// ulozeni hlavni entity vč. překladu
	$orm->someRepository->persistAndFlush($someEntity);

@Hanz25
Aha, už jsem to našel. Hledal jsem, kde se ten modifier tvoří a pak jsem zjistil, že se vybírá oproti databázi. A měl jsem hloupou chybu v tom, že ten sloupec nebyl v databázi nastavený na nullable.

Editoval Hanz25 (15. 6. 2016 9:45)