Telegram – chat bot

Přeskočíme kecy o botech a rovnou se pustíme do práce. Největší platformou pro chatovací boty s otevřeným API nabízí Telegram. Dnes si ukážeme, jak si vytvořit bota, který bude interagovat na uživatelovo požadavky.

Vytvoření bota

Všechny boty vytváříme u toce botů – BotFather. Uděláme to tak, že v seznamu konverzací vyhledáme BotFather. V detailu konverzace vytvoříme nového bota příkazem /newbot a postupujeme podle pokynů.

Budete vyzváni na jméno bota (libovolné znaky včetně diakritiky) a následně na uživatelské jméno bota: slovo bez diakritiky, mezer s příponou bot nebo _bot. Uživatelské jméno musí být v celém Telegramu jedinečné.

Po vytvoření bota bude zobrazeno jeho API access token – dále jen token. Ten si pečlivě uchovejte a nikomu ho nesdělujte – slouží k ovládání bota.

Ovládání bota

V Telegramu existují dva způsoby, jak získat zprávy poslané botovi: long polling a webhooks

Long pooling

Při tomto přístupu se periodicky doptáváte API Telegramu na nové zprávy. Musíte vhodně nastavit periodu doptávání se na nové zprávy.

Webhooks

Při tomto přístupu je při každé interakci s botem zpráva odeslaná i na náš server. Tento přístup mám raději, protože vypadá jako komunikace v reálném čase.

V tomto článku si popíšeme použití webhooks. Pro použití webhooks potřebujeme php script, který běží na veřejné adrese s HTTPS certifikátem. Pro naši ukázku například: https://www.venca-x.cz/bot/pocasi.php

Teď trochu přeskočíme obsah souboru pocasi.php a rovnou tento script zaregistrujeme aby byl zavolán a přijal zprávu od našeho bota. To provedeme příkazem:

https://api.telegram.org:443/bot[token]/setwebhook?url=https://www.venca-x.cz/bot/pocasi.php 

Příkaz zadáme do URL v prohlížeči. Měli bychom obdržet hlášku s úspěšným nastavením webhooku:

 {"ok":true,"result":true,"description":"Webhook was set"}

Oživení bota

Bota máme vytvořeného, zaregistrovaný webhook, který nám přeposílá zprávy poslané botovi. Pojďme bota oživit aby zprávy zpracovával a reagoval na ně.

Pro práci s bot API se mi zalíbila knihovna telegram-bot/api nainstalujeme ji:

composer require telegram-bot/api

Super, konečně jsme se dostali na příjem zpráv a reagování na ně. Na zprávu /ping odpoví bot zprávou pong:

<?php

require_once "vendor/autoload.php";

try {
$bot = new \TelegramBot\Api\Client('YOUR_BOT_API_TOKEN');
$bot->command('ping', function ($message) use ($bot) {
$bot->sendMessage($message->getChat()->getId(), 'pong!');
}); $bot->run();
} catch (\TelegramBot\Api\Exception $e) {
$e->getMessage();
}

Nezapomeňte místo YOUR_BOT_API_TOKEN nastavit váš token z vytváření bota.

Klávesnice pro ovládání bota

Bota můžeme ovládát i přes speciální klávesnici pro rychlé volby. Po zadání příkazu /start přivítáme návštěvníka a zobrazíme mu klávesnici s rychlou volbou:

$bot->command('start', function ($message) use ($bot) {

$keyboard = new \TelegramBot\Api\Types\ReplyKeyboardMarkup(array(array("/pocasi", "/ping")), true);

$bot->sendMessage($message->getChat()->getId(), 'Vítejte počasí', null, false, null, $keyboard);

});

Nette ajax – Naja

Načítání obsahu webových stránek bez nutnosti obnovení stránky prostřednictvím AJAXového volání je dnes běžnou praxí.

Zavést toto funkčnost web postaveném na Nette frameworku, je velice jednoduché a rychlé. Ukážeme si jak na to s ajaxovou knihovnou s názvem Naja. Pokud děláte úplně nový projekt, doporučuji Nette 3.0, zapomeňte na nette.ajax.js ale rovnou použijte Naju. Nette,ajax.js je již “hotový” a dál se nevyvijí. Naja je jeho nástupce.

Instalace a zprovoznění Naja knihovny

npm install naja –save-dev

Pro sloučení všech js souborů a jejich minifikaci používám Gulp. V Gulp tasku přidáme Naja.js do našeho jednoho velkého minifikovaného main.min.js souboru:

var uglify = require('gulp-uglify-es').default;
 //…..
 gulp.task('jsMain', done => {
     gulp
         .src(['node_modules/jquery/dist/jquery.min.js',
             'node_modules/popper.js/dist/umd/popper.min.js',
             'node_modules/bootstrap/dist/js/bootstrap.min.js',
             'node_modules/tether/dist/js/tether.min.js',
             'node_modules/naja/dist/Naja.js',
             'venor/nette/forms/src/assets/netteForms.min.js',
             'src/js/main.js'], {allowEmpty: true})
         .pipe(uglify({
             mangle: false,//disable rename variables and functions
         }))
         .pipe(concat('main.min.js'))
         .pipe(gulp.dest('www/js'));
 done();
 });

TIP: je potřeba použít knihovnu gulp-uglify-es ( gulp-uglify nestačí)

npm gulp-uglify-es --save-dev

Pak jen jednoduše tento 1 minifikovaný JS vložíme do šablony:

<script src="{$basePath}/js/main.min.js"></script>

Do souboru /src/js/main.js (který se také přidává do main.min.js přidáme tento kód pro inicializaci Naji):

document.addEventListener(
     'DOMContentLoaded',
     () => {
         naja.initialize();
     }
);

A máme hotovo. Nyní jen přidáme class=”ajax” prvků, které chceme mít ajaxově, stejně jako u Nette.ajax.js

Demo signálu

Po kliknutí na tlačítko aktualizujeme ajaxem snippet, ve kterém se překreslí aktuální datum. Jednoduché 🙂

Presenter:

<?php
 declare(strict_types=1);
 namespace App\FrontModule\Presenters;
 use App;
 use Nette\Utils\DateTime;
 class HomepagePresenter extends BasePresenter
 {
    private $dateTime;
 public function handleActualiseDateTime()
    {
       $this->dateTime = new DateTime();
       if ($this->isAjax()) {
          $this->redrawControl('dateTimeSnippet');
       }
    }
 public function renderDefault(): void
    {
       if ($this->dateTime === null) {
          $this->dateTime = new DateTime();
       }
       $this->template->dateTime = $this->dateTime;
    }
 }

Šablona:

<div class="col-12">
   <hr/>
   {snippet dateTimeSnippet}
      {$dateTime|date:'j. n. Y H:i:s'}
   {/snippet}
   <a n:href="actualiseDateTime!" class="ajax">AKTUALIZOVAT</a>
</div>

Composer – instalujeme fork balíčku

Dnes si ukážeme jak nainstalovat fork balíčku. Proč instalovat fork? Důvodů může být mnoho: nekompatibilita s PHP,
nekompatibilita závislostí balíčku, … Já konkrétně popíši řešení s knihovnou h4kuna/fio, která je závislá na “nette/utils”: “^2.2”, ovšem já používám vývojový “nette/utils”: “^3.0”, proto není možné balíček vůbec nainstalovat.

Na Githubu tedy uděláme fork h4kuna/fio, čímž se knihovna “zkopíruje” pod náš Github účet a můžeme do ni přispívat kódem(bez schválení původního autora). Uděláme tedy commit, který upraví h4kuna/fio aby byl použitelný: https://github.com/venca-x/fio/commit/627218b174f75f452b25c02b3699641865efaa02

Já konkrétně jsem upravil soubor composer.json (ve forknutém balíčku – v master větvi):
“nette/utils”: “^2.2” na “nette/utils”: “^3.0”
a jelikož používám vývojovou verzi Nette 3.0 přidal na konec:
“minimum-stability”: “dev”

Tím máme hotovo a můžeme tento forknutý balíček nainstalovat. Ale jak?
Do souboru composer.json v našem projektu přidáme závislost na balíček, který nám předtím předtím nešel nainstalovat (ve vývojové verzi, naši úpravu forknutého balíčku jsme pushli do master větve):
“h4kuna/fio”: “dev-master”
ale pro tento balíček dáme náš zdroj – forknutý repozitář:

"repositories": [
{
"type": "git",
"url": "https://github.com/venca-x/fio.git"
}
],

Tím máme hotovo. Snad někomu pomůže stejně dobře jako mne 🙂


Debian 9 (stretch) – instalace php 7.1

V poslední verzi Debianu Stretch je defaultně php 7.0, pokud potřebujete novější 7.1, je možné jej bez kompilace zdrojových kódů nainstalovat přes balíčky:

apt-get install apt-transport-https lsb-release ca-certificates
wget -O /etc/apt/trusted.gpg.d/php.gpg https://packages.sury.org/php/apt.gpg
echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/php.list
apt-get update
apt-get install php7.1

Stejným způsobem nainstalujeme PHP7.2:

apt install php7.2 php7.2-cli php7.2-common php7.2-json php7.2-opcache php7.2-mysql php7.2-zip php7.2-fpm php7.2-mbstring 

WooCommerce: získání všech tagů a kategorií

Poslední dobou dělám věci okolo WordPressu a Woocommerce. Dnes si ukážeme jak v doplňku získávám všechny kategorie a tagy.

Jak získat všechny tagy?

Function Reference/get terms

$taxonomies = 'product_tag';
$args = array(
   'taxonomy'     => 'product_cat',
   'hide_empty'   => 0
);
$terms = get_terms($taxonomies, $args);
foreach ($terms as $term) {
   //var_dump($term);
   //$termLink = get_term_link( $term );
   echo $term->name;
}

 

Jak získat všechny kategorie?

Function Reference/get categories

$args = array(
   'taxonomy'     => 'product_cat',
   'hide_empty'   => 0
);
$categories = get_categories( $args );
foreach( $categories as $category ) {
   //var_dump($category);
   //$categoryLink = get_category_link( $category );
   echo $category->name;
}

 

PHP zobrazení chyb

Dřív nebo později narazíte v PHP na bílou obrazovku. V případě že je na serveru vypnuté zobrazování chyb a váš skript skončí chybou, nebude tato chyba zobrazena ale zobrazí se bílá obrazovka.

Jak nyní zjistíte kde máte chybu nebo v čem je problém? Umístěte na začátek PHP skriptu tento kód:

<?php
error_reporting(E_ALL);
ini_set('display_errors', 1);

...

Tím si zobrazíte chybovou hlášku z PHP. Nezapomeňte tento kód po opravení chyby opět odebrat 🙂

Nette a Doctrine

Účast na mé první Posobotě předčila veškeré očekávání. Perfektní workshop, skvělé přednášky a úžasní lidé kteří nic netají. Na workshopu jsem díky Filipovi a Chemixovi pronikl do základů Doctrine. Zkusím tyto informace sepsat.

Instalujeme Nette

Ani nemyslete na to že to budete zkoušet bez composeru 🙂

composer create-project nette/sandbox nette-doctrine

nette-doctrine je název složky do které se sandbox vytvoří.

Instalujeme Kdyby/Doctrine

cd nette-doctrine
composer require kdyby/doctrine

Pokud máte PHP verzi alespoň 5.4 hned z konzole můžete spustit web server:

php -S localhost:8888 -t www

webserver se spustí na portu 8888. Pokud do prohlížeče zadáte http://localhost:8888 uvidíte stránku Nette Congratulations!

Práda! Můžeme začít spouštět IDE a zažneme kódovat.

PhpStorm a live templaty pro Doctrine

Rozhodně doporučuji PhpStorm do kterého Filip napsal skvělé live templaty. Ušetří spoustu psaní a času.

Live templaty stáhněte a nahrajte do:

<your home directory>\.WebIde<version>\config\templates

Rozhodně doporučuji soubory: Doctrine.xml, Nette.icls, Nette.xml

Po nahrání je nutné znovu spustit PhpStorm.

Vytvoření databáze

Pojďme si vytvořit databázi a uživatele pro přístup k databázi:

CREATE DATABASE `doctrine_devel` COLLATE 'utf8_czech_ci';
CREATE USER 'doctrine'@'localhost' IDENTIFIED BY 'doctrine_pass';
GRANT USAGE ON * . * TO 'doctrine'@'localhost' IDENTIFIED BY 'doctrine_pass' WITH MAX_QUERIES_PER_HOUR 0 MAX_CONNECTIONS_PER_HOUR 0 MAX_UPDATES_PER_HOUR 0 MAX_USER_CONNECTIONS 0;
GRANT ALL PRIVILEGES ON `doctrine\_%` . * TO 'doctrine'@'localhost';
FLUSH PRIVILEGES;

Příkaz vykonáme v Admineru: http://localhost:8888/adminer

Klikneme na tlačítko SQL příkaz. Do okna vložíme kód výše a jeho vykonání potvrdíme tlačítkem Provést.

Tím jsme vytvořili databázi doctrine_devel a uživatele doctrine s heslem doctrine_pass.

Zaregistrování Doctrine do Nette

Do config.neon zamergujeme následující kód:

parameters:
    database:
        host: localhost
        dbname: production_db
        user: production
        password: production_pass

extensions:
    console: Kdyby\Console\DI\ConsoleExtension
    events: Kdyby\Events\DI\EventsExtension
    annotations: Kdyby\Annotations\DI\AnnotationsExtension
    doctrine: Kdyby\Doctrine\DI\OrmExtension

doctrine:
    dbname      : %database.dbname%
    host        : %database.host%
    user        : %database.user%
    password    : %database.password%
    metadata:
        App: %appDir%

Do config.local.neon uložíme přístupové údaje do DB pro vývoj u nás na localhostu:

parameters:
    database:
        host: localhost
        dbname: doctrine_devel
        user: doctrine
        password: doctrine_pass

Podle dokuentace Kdyby/Doctrine si vytvoříme první entitu:

app/model/Article.php

<?php

namespace App;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 */
class Article extends \Kdyby\Doctrine\Entities\BaseEntity
{

    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue
     */
    protected $id;

    /**
     * @ORM\Column(type="string")
     */
    protected $title;

}

V entitě Article definuje id (celé číslo, které se bude inkrementovat) a title (text).

Vytvoření tabulky z entity

V první řadě ověříme zda funguje Doctrine/Console:

php ./www/index.php

Výstup by měl vypadat takto a měl by zobrazovat všechny dostupné příkazy pro Doctrine:

D:\www\nette-doctrine>php ./www/index.php
Nette Framework version 2.2.7

Usage:
 [options] command [arguments]

Options:
 --help (-h)           Display this help message
 --quiet (-q)          Do not output any message
 --verbose (-v|vv|vvv) Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug
 --version (-V)        Display this application version
 --ansi                Force ANSI output
 --no-ansi             Disable ANSI output
 --no-interaction (-n) Do not ask any interactive question

Available commands:
 help                       Displays help for a command
 list                       Lists commands dbal
 dbal:import                Import SQL file(s) directly to Database. orm
 orm:clear-cache:metadata   Clear all metadata cache of the various cache drivers.
 orm:clear-cache:query      Clear all query cache of the various cache drivers.
 orm:clear-cache:result     Clear all result cache of the various cache drivers.

 orm:convert-mapping        Convert mapping information between supported formats.
 orm:convert:mapping        Convert mapping information between supported formats.
 orm:generate-entities      Generate entity classes and method stubs from your mapping information.
 orm:generate-proxies       Generates proxy classes for entity classes.
 orm:generate:entities      Generate entity classes and method stubs from your mapping information.
 orm:generate:proxies       Generates proxy classes for entity classes.
 orm:info                   Show basic information about all mapped entities
 orm:schema-tool:create     Processes the schema and either create it directly on EntityManager Storage Connection or generate the SQL output.
 orm:schema-tool:drop       Drop the complete database schema of EntityManager Storage Connection or generate the corresponding SQL output.
 orm:schema-tool:update     Executes (or dumps) the SQL needed to update the database schema to match the current mapping metadata.
 orm:validate-schema        Validate the mapping files.

Provedeme validaci:

php ./www/index.php orm:validate-schema

OK, to je v pořádku:

[Mapping]  OK - The mapping files are correct.
[Database] FAIL - The database schema is not in sync with the current mapping file.

Podíváme se jaký SQL kód nám Doctrine nabízí pro synchronizaci databáze:

php ./www/index.php orm:schema-tool:update --dump-sql

SQL kód pro synchronizaci databáze:

CREATE TABLE article (id INT AUTO_INCREMENT NOT NULL, author_id INT DEFAULT NULL, title VARCHAR(255) NOT NULL, text VARCHAR(255) DEFAULT NULL, INDEX IDX_23A0E66F675F31B (author_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = InnoDB;
CREATE TABLE author (id INT AUTO_INCREMENT NOT NULL, name VARCHAR(255) NOT NULL, PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = InnoDB;
CREATE TABLE tag (id INT AUTO_INCREMENT NOT NULL, name VARCHAR(255) NOT NULL, PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = InnoDB;
CREATE TABLE tag_article (tag_id INT NOT NULL, article_id INT NOT NULL, INDEX IDX_300B23CCBAD26311 (tag_id), INDEX IDX_300B23CC7294869C (article_id), PRIMARY KEY(tag_id, article_id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = InnoDB;
ALTER TABLE article ADD CONSTRAINT FK_23A0E66F675F31B FOREIGN KEY (author_id) REFERENCES author (id);
ALTER TABLE tag_article ADD CONSTRAINT FK_300B23CCBAD26311 FOREIGN KEY (tag_id)
REFERENCES tag (id) ON DELETE CASCADE;
ALTER TABLE tag_article ADD CONSTRAINT FK_300B23CC7294869C FOREIGN KEY (article_id) REFERENCES article (id) ON DELETE CASCADE;

Tento kód můžete vykonat v admineru, neb pokud máte koule můžete ho nechat vykonat přímo z příkazové řádky (hlavouni to nedoporučují):

php ./www/index.php orm:schema-tool:update --force

Nyní když znovu spustíme validaci, vidíme:

D:\www\nette-doctrine>php ./www/index.php orm:validate-schema
[Mapping]  OK - The mapping files are correct.
[Database] OK - The database schema is in sync with the mapping files.

Namapování a databáze jsou OK, pojďme na ukládání a zobrazení dat.

Doctrine – ukládání dat

V HomepagePresenter.php si uděláme add akci na přidání záznamů do entity Article:

<?php

namespace App\Presenters;

use App\Article;
use Nette;
use Kdyby;

/**
 * Homepage presenter.
 */
class HomepagePresenter extends BasePresenter
{

	/**
	 * @inject
	 * @var Kdyby\Doctrine\EntityManager
	 */
	public $entityManager;

	public function actionAdd()
	{
		$daoArticle = $this->entityManager->getRepository(Article::getClassName());

		$article = new Article();
		$article->title= "Slabikář";
		$daoArticle->save($article);

		$article = new Article();
		$article->title= "Čítanka";
		$daoArticle->save($article);

		exit();
	}

}

Definovali jsme $entityManager do které jsme injectli Kdyby\Doctrine\EntityManager.

V actionAdd jsme vytvořili 2 články které uložíme do DB. První s názvem Slabikář a druhý s názvem Čítanka. V DB se můžete přesvědčit že došlo k jejich uložení do tabulky article.

Doctrine výpis dat

Velice podobným způsobem jako jsme ukládali data je budeme vypisovat. Opět budeme potřebovat EntityManager:

<?php

namespace App\Presenters;

use App\Article;
use Nette;
use Kdyby;

/**
 * Homepage presenter.
 */
class HomepagePresenter extends BasePresenter
{

	/**
	 * @inject
	 * @var Kdyby\Doctrine\EntityManager
	 */
	public $entityManager;

	public function renderDefault()
	{
		$daoArticle = $this->entityManager->getDao(Article::getClassName());
		$this->template->articles = $daoArticle->findAll();
	}
}

v šabloně tyto články zobrazíme:

{block content}

{foreach $articles as $article}

    {$article->title}<br/>

{/foreach}

Jednoduché že ano?

Přidání nového položky do entity

Naše aplikace je známá po celém světě a používají ji milony lidí kteří píší podměty že jim pouze název článku nestačí a chtěli by ještě text článku 🙂 Vyhovíme jim a přidáme do entity Article ještě položku text.

Nyní nám perfektně poslouží Filipovo live templaty. Otevřeme si soubor Article.php a pod proměnou private $title odřádkujeme a napíšeme: col <tab> (napíšeme col a stiskneme klávesu Tab). Ide nám předvygeneruje následující kód:

    /**
     * @ORM\Column(type="string", nullable=TRUE)
     * @var string
     */
    protected $;

ve kterém se pohybujeme klávesou Tab. Napíšeme název proměnné (text) a definujeme typ (text). Výsledek vypadá takto:

    /**
     * @ORM\Column(type="text", nullable=TRUE)
     * @var text
     */
    protected $text;

Provedeme validaci:

php ./www/index.php orm:validate-schema
D:\www\nette-doctrine>php ./www/index.php orm:validate-schema
[Mapping]  OK - The mapping files are correct.
[Database] FAIL - The database schema is not in sync with the current mapping file.

která nám oznámí že nemáme synchronizovanou databázi. Podíváme se jaké úpravy databáze nám Doctrine nabízí:

D:\www\nette-doctrine>php ./www/index.php orm:schema-tool:update --dump-sql
ALTER TABLE article ADD text LONGTEXT DEFAULT NULL;

Kód vykonáme v admineru, nebo 🙂

php ./www/index.php orm:schema-tool:update --force

Následná validace by měla být OK. Tím máme přidán sloupec text a můžeme do něho rovnou ukládat data. Vytáhneme námi uložené publikace a donastavíme jim text:

    public function actionUpdate()
    {
        $daoArticle = $this->entityManager->getRepository( Article::getClassName() );

        $article = $daoArticle->findOneBy( array( "title" => "Slabikář" ) );
        $article->text = "Text knihy slabikář";

        $article = $daoArticle->findOneBy( array( "title" => "Čítanka" ) );
        $article->text = "Text knihy čítanka";

        $this->entityManager->flush();
        exit();
    }

Upravíme šablonu abychom vypisovali text:

{block content}

{foreach $articles as $article}

    <h2>{$article->title}</h2>
    <p>{$article->text}</p>

{/foreach}

 Vyšší liga – vazby mezi entitami

Toto jsme splodili na Workshopu:

Article.php

<?php

namespace App;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 */
class Article extends \Kdyby\Doctrine\Entities\BaseEntity
{

    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue
     */
    protected $id;

    /**
     * @ORM\Column(type="string")
     */
    protected $title;

    /**
     * @ORM\Column(type="string", nullable=TRUE)
     * @var string
     */
    protected $text;

    /**
     * @ORM\ManyToOne(targetEntity="\App\Author", inversedBy="articles", cascade={"persist"})
     * @var Author
     */
    protected $author;

    /**
     * @ORM\ManyToMany(targetEntity="\App\Tag", mappedBy="articles", cascade={"persist"}, orphanRemoval=true)
     * @var \App\Tag[]|\Doctrine\Common\Collections\ArrayCollection
     */
    protected $tags;


    function __construct()
    {
        $this->tags = new ArrayCollection();
    }

    public function addTag(Tag $tag)
    {
        $tag->addArticle($this);
        $this->tags->add( $tag );
    }

}

Author.php

<?php

namespace App;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping as ORM;


/**
 * @ORM\Entity
 * @property $name
 */
class Author extends \Kdyby\Doctrine\Entities\BaseEntity
{


    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue
     */
    protected $id;

    /**
     * @ORM\Column(type="string")
     */
    protected $name;

    /**
     * @ORM\OneToMany(targetEntity="\App\Article", mappedBy="author", cascade={"persist"})
     * @var Article[]|\Doctrine\Common\Collections\ArrayCollection
     */
    protected $articles;

    function __construct()
    {
        $this->articles = new ArrayCollection();
    }

    public function addArticle(Article $article)
    {
        $this->articles->add( $article );
    }
}

Tag.php

<?php


namespace App;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping as ORM;


/**
 * @ORM\Entity
 * @property $name
 */
class Tag extends \Kdyby\Doctrine\Entities\BaseEntity
{

    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue
     */
    protected $id;

    /**
     * @ORM\Column(type="string")
     */
    protected $name;


    /**
     * @ORM\ManyToMany(targetEntity="\App\Article", inversedBy="tags", cascade={"persist"})
     * @var \App\Article[]|\Doctrine\Common\Collections\ArrayCollection
     */
    protected $articles;


    function __construct()
    {
        $this->articles = new ArrayCollection();
    }

    public function addArticle(Article $article)
    {
        $this->articles->add( $article );
    }
}

HomepagePresenter.php

<?php

namespace App\Presenters;

use App\Author;
use App\Tag;
use Nette,
	App\Model;
use App\Article;

/**
 * Homepage presenter.
 */
class HomepagePresenter extends BasePresenter
{

	/**
	 * @inject
	 * @var \Kdyby\Doctrine\EntityManager
	 */
	public $EntityManager;

	public function renderDefault()
	{
		$this->template->anyVariable = 'any value';
		$dao = $this->EntityManager->getRepository(Article::getClassName());
		$this->template->articles = $dao->findAll();

	}

	public function actionAdd()
	{

		$daoArticle = $this->EntityManager->getRepository(Article::getClassName());
		$daoAuthor = $this->EntityManager->getRepository(Author::getClassName());

		//$author = new Author();
		//$author->name = "Pokusne jmeno";

		$author = $daoAuthor->findOneBy( array("name" => "Pokusne jmeno"));

		$article = new Article();
		$article->title = "titulke sntagem";
		$article->text = "text novinky s tagem";
		$article->author = $author;
		$author->addArticle($article);

		$tag = new Tag();
		$tag->name = "kniha";

		$article->addTag($tag);

		$tag = new Tag();
		$tag->name = "kniha dvojita";

		$article->addTag($tag);

		$daoArticle->save($article);

		exit();
	}

}

Šablona:

{block content}

{foreach $articles as $article}

    {$article->title}<br>
    {$article->author->name}<br/>
    {dump $article->tags}
    Tags: {if $article->tags}{foreach $article->tags as $tag}{$tag->name}, {/foreach}{/if}<br/>
<hr/>
{/foreach}

{/block}

 

Celé databázové schéma smažeme a vytvoříme znovu:

php ./www/index.php orm:schema-tool:drop --force

php ./www/index.php orm:schema-tool:create

Celou ukázku jsem nahrál na GitHub: https://github.com/venca-x/nette-sandbox-doctrine

Composer: jak nainstalovat Nette 2.3.0-beta

Po vystřízlivění ze včerejší posoboty nastal čas vyzkoušet Nette 2.3.0-beta.

Upgrade je jednoduchý. Stačí upravit composer.json:

...
  "require": {
    ...
    "nette/nette": "~2.3.0",
    ...
  },
  "minimum-stability": "beta",
  "prefer-stable": true
...

Velice důležitý je řádek minimum-stability: beta a prefer-stable: true

Následně do konzole pustíte příkaz composer update a můžete testovat Nette 2.3.0-beta

Nette: handle (signál)

Předpokládejme že máme TODO list ve kterém budeme chtít vybraný úkol nastavit jako splněný.

Na takový úkon je vhodný signál:

public function handleMarkDone( $taskId )
{
    $this->table->where(array('id' => $taskId))->update(array('done' => 1));
    $this->redirect('this');
}

Signál v šabloně zavoláme jednoduše:

<a n:href="markDone! $task->id">hotovo</a>

 

Nette + Texy

Pokud si zájemce o web přeje základní formátování textů, vetšinou nejprve sáhnu po Texy. Nemám rád weby které vypadají jako omalovánky (ano, tomu kdo dá tu práci aby každé písmenko ve slově mělo jinou barvu se to moc líbí ale spoustu návštěvníků to odradí). Texy je jednoduchý nástroj kterým můžete bez odborných znalostí psát HTML kód. Příklad si ukážeme na jednoduchém formuláři, jehož odesláním naformátujeme zadaný text přes Texy.

 

Pojďme si ukázat jak zprovoznit  Nette společně s Texy!

Ukázka je na poslední verzi Nette (2.2.6) a poslední verzi Texy (2.6).

Instalace Nette

Stáhneme Nette sandbox (přes composer):

composer create-project nette/sandbox nette-texy

příkazem se vytvoří složka nette-texy do které se nahraje Nette + sandbox. Document root pro virtualhost nasměrujeme do nette-texy/www/

Instalace Texy

nainstalujeme samozřejmě přes composer :

composer require dg/texy:~2.0

 

Zprovoznění Texy

Uděláme si pořádek na hřišti. Nahradíme obsah šablony pro titulní stránku: app/templates/Homepage/default.latte:

{block content}
   {ifset $text}
      {$text|texy|noescape}
   {/ifset}
   {control texyForm}
{/block}

 Vytvoření formuláře

app/presenters/HomepagePresenter.php:

<?php

namespace App\Presenters;

use Nette;

class HomepagePresenter extends BasePresenter
{

    protected function createComponentTexyForm()
    {
        $form = new Nette\Application\UI\Form;
        $form->addTextarea('text', 'Text:')
                ->setAttribute('cols', 80)
                ->setAttribute('rows', 10);
        $form->addSubmit('send', 'Send');

        $form->onSuccess[] = $this->texyFormSucceeded;
        return $form;
    }


    public function texyFormSucceeded($form, $values)
    {
        $this->template->text = $values->text;
    } 
}

Máme formulář který při odeslání odešle do šablony (proměnná $text ) zadaný text.

Zapnutí Texy

Nejprve je nutné přidat Texy do neon.config aby o Nette o Texy vědělo:

app/config/config.neon:

 

services:
	- App\Model\UserManager
	- App\RouterFactory
	router: @App\RouterFactory::createRouter
	texy: Texy

 

V souboru app/presenters/BasePresenter.php je nutné vytvořit helper, který bude fomárovat text přes Texy.

<?php

namespace App\Presenters;

use Nette;
use TexyConfigurator;

abstract class BasePresenter extends Nette\Application\UI\Presenter
{
    /** @var \Texy */
    private $texy;

    public function injectTexy( \Texy $texy )
    {
        $this->texy = $texy;

        //$this->texy->allowed['heading/underlined'] = FALSE;// podtržené titulky
        //$this->texy->allowed['heading/surrounded'] = FALSE;// ohraničené titulky

        //TexyConfigurator::safeMode( $this->texy ); //nastaveni pro diskuse, ktere nepovoli vlozeni kompromitovaneho kodu
        //TexyConfigurator::disableLinks( $this->texy );
        //TexyConfigurator::disableImages( $this->texy );
    }

    protected function createTemplate( $class = NULL )
    {
        $template = parent::createTemplate( $class );
        $template->registerHelper( 'texy', callback( $this->texy, 'process' ) );
        return $template;
    }

}

V nové verzi Nette (>=2.4) se helper (filtr) registruje takto, metodu createTemplate můžete úplně vynechat):

    protected function beforeRender()
    {
        parent::beforeRender();

        $this->template->addFilter('texy', function ($text) {
            return $this->texy->process($text);
        });

    }

Nejlepší cesta

Kvůli bezpečnosti, doporučuji tento způsob použití, ve kterém filtr vrací Nette\Utils\Html, který nemusíme nonescapovat. Registrujeme filter klasicky v beforeRender:

    protected function beforeRender()
    {
        parent::beforeRender();

        $this->template->addFilter('texy', function ($text) {
            //return $this->texy->process($text);
            return Nette\Utils\Html::el()->setHtml($texy->process($text));
        });

    }

A pak již pouze v šabloně vypíšeme:

{$text|texy}