cojack blog » Doctrine http://www.cojack.pl Programowanie oraz Open Source powodem do życia Sat, 26 Nov 2011 18:43:28 +0000 PL hourly 1 http://wordpress.org/?v=3.3.1 MVC w PHP cz.2 http://www.cojack.pl/mvc-w-php-cz-2 http://www.cojack.pl/mvc-w-php-cz-2#comments Fri, 23 Oct 2009 07:08:39 +0000 cojack http://cojack.os-cms.pl/?p=255 Tak więc chciałbym rozwinąć swoją myśl w poprzednim wpisie dotyczącym mvc w php, o co mi tu chodzi oraz czy temat i kategoria ma się jakoś do treści tutaj przedstawionej. Otóż uważam że tak, wzorzec mvc jak samo rozwiniecie jego skrótu nam mówi, model, widok, kontroler. Chodzi o prezentacje kodu złożoną z warstw, i połączeniem tego z sobą, dobrze wiemy że kontroler czyli nasz cały mózg operacji powinien wywoływać metody z modelu do pobierania danych z bazy danych, tak że end user nie ma że tak powiem bezpośredniego dostępu do tej że warstwy prezentacji kodu, chyba że jesteśmy na tyle upośledzeni że nie zabezpieczymy sobie katalogów i struktura naszych katalogów pozwala użytkownikowi na przeglądanie zawartości katalogów gdzie mamy poskładane nasze klasy. W różnych książkach można spotkać różnie przedstawione formy zapisu nazewnictwa plików, *.phpm itp ale nie o tym chcę pisać, ponieważ dla mnie to powinno być na tyle intuicyjne i poprawne by nam później było łatwiej się odnaleźć w utworzonej przez nas aplikacji.

Wracając do tematu, bo wydaje mi się że trochę od niego odbiegłem, chciałbym rozwinąć swoją myśl przedstawioną w poprzednim poście (czuje jakbym się powtarzał…). Pisałem o tym że użytkownicy Doctrine dostali narzędzie i ogromnej mocy do utworzenia aplikacji zorientowanej obiektowo oraz o wzorzec MVC, i w cale nie chcę się z tego wycofać a poprzeć tą tezę argumentami.

Do czego bym zachęcał? Otóż by każdy zainteresowany pobrał sobie sandbox’a doctrine z strony projektu, standardowo linki na samym dole. Sandbox jest w pewnym stopniu za nas skonfigurowany, i jeżeli nie czujemy potrzeby modyfikacji jego ustawień proponowałbym zostawić układ taki jaki jest, chociażby dla samego tego artykułu. Ja go osobiście trochę przerobiłem na wzór układu katalogów z symfony ale nie ważne jest to teraz.

Pisałem o tym że nie będziemy musieli ładować w kontrolerach modułów a same widoki (widok), tak zakładam że jeden widok dla jednego kontrolera, jeden model dla jednego kontrolera. Wychodząc z założenia DRY ( Don’t Repeat Yourself ), jedna metoda dla jednej i tej samej akcji, bo po co się powtarzać?

Nie chciałbym by ten topic zszedł do tematu konfiguracji sandboxa, dlatego o konfiguracji Doctrine w innym temacie.

A teraz jak to nam uprzyjemnia życie? A dajmy na to że mamy jakiś kontroler, np HandlerNews

class HandlerNews extends EventHandler  {
 
	private $_tpl;
	private $_handle;
	private $_lang;
 
	public function __construct($tpl,$event,$trans)	{
		$this->_tpl = $tpl;
		$this->_handle = $event;
		$this->_lang = $trans->getLanguage();
 
	}
 
	public function handledEvent($route) {
		if( $route[2] != '' && method_exists($this,$route[2]) ) {
			$this->_{$route[2]}();
		} else 
		  throw new Exception ('Brak akcji');
	}
 
	private function _show()	{
		$news = Doctrine::getTable('News')->getNews(Route::getId(), $this->_lang);
                $this->tpl->assign('news',$news);
	}
}

No i nasza metoda getNews wyglądała by mniej więcej tak (plik NewsTable.php):

class NewsTable extends Doctrine_Table
{
  public function getNews( $id, $lang ) {
    $query = $this->createQuery( 'n' )
                           ->where( 'n.id = ?', $id)
                           ->andWhere( 'n.lang = ?', $lang)
                           ->execute();
    return $query;
  }
}

Oto całe nasze mvc, mamy model, który jest organizowany za pomocą doctrine, mamy plik kontrolera który sobie pobiera z bazy danych dane, wrzuca je do templatki no i jakoś tam musimy wykombinować żeby jeszcze templatke wczytywać, ale to już inna kwestia.

No więc jak widać implementacja takiego wzorca MVC nie jest trudna, i nie uprzykrzajcie sobie ludzie życia wymyślając nie wiadomo co, nie wiadomo jak złożone struktury katalogów jak to jest proste jak budowa cepa ;)

Ja wiem że równie dobrze możemy sobie utworzyć klasę w której będziemy mieli standardowe zapytania do bazy danych np na PDO, z zwykłą składnią SQL’ową. Nikt nie broni, a nawet dlaczego nie? np:

class NewsModel extends Model {
 
  public function __construct () {
    parent::__construct();  
  }
 
  public function getNews ( $id ) {
    $query = $pdo->prepare( 'SELECT * FROM news WHERE id = :id' );
    $query->bindParam( ':id', $id, PDO::PARAM_INT);
    return $query->execute();
  }
}

Dlaczego wybrałem Doctrine zamiast właśnie w ten sposób pisać osobne klasy jako modele z standardową składnią SQL? Bo tak mi jest wygodniej, oraz dla mnie bezpieczniej. Wasz wybór jaką drogę obierzecie, tylko nie modźcie z tym wzorcem… Bo widziałem różne implementację MVC i nie które to mnie po prostu przerażają, tak jak Zyx napisał, prosty wzorzec, ale nie dla wszystkich.

]]> http://www.cojack.pl/mvc-w-php-cz-2/feed 1 MVC w PHP http://www.cojack.pl/mvc-w-php http://www.cojack.pl/mvc-w-php#comments Thu, 03 Sep 2009 12:02:00 +0000 cojack http://cojack.os-cms.pl/?p=198 Jak każdy tak i ja chcę swoje 3 grosze wrzucić do tego tematu, o czym chciałbym napisać, a o modelach, każdy dobrze wie czym jest mvc (nie czuje że rymuje), a jak nie to proszę wikipedia i tam jest bardzo ładnie opisane, tak więc co z tymi modelami, problem w tym że trzeba by te modele ładować w kontrolerach, albo przy dyspozytorze ładować kontroler, model i widok, ale można też to zrobić trochę inaczej, każdy kto się zdecydował na pracę z Doctrine, ma przecudowne narzędzie do utworzenia aplikacji zorientowanej obiektowo o wzorzec mvc, rozwiązującej problemy w pewnym stopniu z architekturą strukturalną plików i katalogów.
A tak po ludzku to chodzi mi o to że Doctrine ładuje za nas modele bazy danych, czyli jak np za pomocą doctrine wygenerujemy modele z bazy danych, to Doctrine utworzy za nas 3 pliki dla każdej z tabel, oraz 1 katalog. Będzie to:

|--------------------------------
|- models/
|- - - generated/
|- - - - BaseArticles.php
|- - Articles.php
|- - ArticlesTable.php
|--------------------------------

A taki przykład, i teraz dzięki Doctrine, w kontrolerach będziemy mogli bezpośrednio odwoływać się do metod w pliku ArticlesTable, a to jest tylko przedsmak tego co dzięki Doctrine jesteśmy w stanie zrobić. Przy następnym wpisie pokażę jak tego użyć, jak to zrobić. Może sami macie jakieś ciekawe propozycje, pomysły, czekam ;)

]]> http://www.cojack.pl/mvc-w-php/feed 3 Menu w postaci drzewa http://www.cojack.pl/menu-w-postaci-drzewa http://www.cojack.pl/menu-w-postaci-drzewa#comments Wed, 22 Jul 2009 15:36:43 +0000 cojack http://cojack.os-cms.pl/?p=137 Tak więc ostatnio gdy starałem się o pracę w pewnej firmie, dostałem jako zlecenie stworzenie menu o strukturze drzewa z nieograniczonymi gałęziami, liśćmi. Każdy kto programuje chwilkę w końcu natknie się na ten problem i będzie szukał rozwiązania w internecie. Tak samo było zemną, no więc założenia do projektu:

  • struktura drzewa
  • nieograniczona ilość gałęzi i liści
  • przenoszenie gałęzi wraz z zawartością
  • usuwanie gałęzi wraz z zawartością

Są to podstawowe założenia do projektu jakie są nam potrzebne, tak więc wyruszając w przygodę z google i znalezieniem jakiejś ciekawej struktury dla sql, na ircu od adi^R dostałem ciekawego linka depesz.com. Gościu opisuje jak rozwiązać ten problem z poziomu sql’a. No tak więc mamy już jeden problem z głowy (poniżej opiszę wszystko po kolei), został nam drugi, algorytm który będzie tą strukturę drzewa tworzył w php i zrobi z nam tego tablicę taką żeby móc ja ładnie użyć z smartami (tak przeszedłem na smarty z ITX, dlaczego? a tak jakoś). No i tu były schody, ponieważ twórcy smartów nie przewidzieli, lub nie chcieli przewidzieć rekurencji w ich skrypcie. Co nam pozostaje? W rekurencji includowanie tego samego pliku przy każdym kolejnym wykonaniu operacji, lub znaleźć plugin który to zrobi za nas.

Dobra po kolei, zacznijmy od kodu sql który jest na potrzebny i niezbędny do życia, więc na pewno potrzebne nam są dwie tabele oto one:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

CREATE TABLE "kategorie" (
   "id" serial PRIMARY KEY,
   "name" text, -- ważne name nie jest unique
   "parent_id" INTEGER,
   FOREIGN KEY ("parent_id") REFERENCES "kategorie" ("id") ON DELETE cascade
);
 
CREATE TABLE "powiazania" (
    "id" serial PRIMARY KEY,
    "parent_id" INTEGER NOT NULL,
    "child_id" INTEGER NOT NULL,
    "depth" INTEGER NOT NULL,
    FOREIGN KEY ("parent_id") REFERENCES "kategorie" ("id") ON DELETE cascade,
    FOREIGN KEY ("child_id") REFERENCES "kategorie" ("id") ON DELETE cascade
);

Poprawiłem tutaj trochę po fabryce, czyli po Hubercie Lubaczewskim, autorem tego skryptu. Bo tak mi pasowało zresztą gdy porównacie mój kod sql (mowa o tych 2 tabelach) zobaczycie różnice.

Następne co nam będzie potrzebne to funkcja oraz triger która dodaje za nas powiązania:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

CREATE LANGUAGE plpgsql; 
 
CREATE OR REPLACE FUNCTION tree_objects_ai() RETURNS TRIGGER AS
 $BODY$
 DECLARE
 BEGIN
  INSERT INTO powiazania (parent_id, child_id, depth) VALUES (NEW.id, NEW.id, 0);
  INSERT INTO powiazania (parent_id, child_id, depth) SELECT x.parent_id, NEW.id, x.depth + 1 FROM powiazania x WHERE x.child_id = NEW.parent_id;
  RETURN NEW;
 END;
 $BODY$
LANGUAGE 'plpgsql';
 
-- Dzięki tej procedurze, nie ważne czy mamy zagnieżdżenie 2, 3, 9, 231 stopniowe,
-- i tak za każdym razem wykonujemy tylko 1 insert
 
CREATE TRIGGER tree_objects_ai AFTER INSERT ON kategorie FOR EACH ROW EXECUTE PROCEDURE tree_objects_ai();
 
-- Tworzymy trigera który po każdym INSERT'cie wykona procedure trg_powiazania_i, dlaczego trigger i procedura
-- mają taką samą nazwę? Ponoć ułatwia analizę bazy danych... Ja tak tak to czemu nie ;]

Nie będę tutaj się rozpisywał ocb z tymi procedurami, trigerami i powiązaniami pomiędzy tabelami, wszystko możecie sobie doczytać na stronie Huberta.

To był funkcja która tworzy nam powiązania a teraz funkcja która przerzuca gałęzie drzewa pomiędzy sobą.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

CREATE OR REPLACE FUNCTION tree_objects_au() RETURNS TRIGGER AS
  $BODY$
  DECLARE
  BEGIN
    IF NOT OLD.parent_id IS DISTINCT FROM NEW.parent_id THEN
      RETURN NEW;
    END IF;
    IF OLD.parent_id IS NOT NULL THEN
      DELETE FROM powiazania WHERE id IN (
        SELECT r2.id FROM powiazania r1 JOIN powiazania r2 ON r1.child_id = r2.child_id
        WHERE r1.parent_id = NEW.id AND r2.depth > r1.depth
      );
    END IF;
    IF NEW.parent_id IS NOT NULL THEN
      INSERT INTO powiazania (parent_id, child_id, depth)
      SELECT r1.parent_id, r2.child_id, r1.depth + r2.depth + 1
      FROM
      powiazania r1,
      powiazania r2
      WHERE
      r1.child_id = NEW.parent_id AND
      r2.parent_id = NEW.id;
      END IF;
      RETURN NEW;
  END;
  $BODY$
  LANGUAGE 'plpgsql';
 
CREATE TRIGGER tree_objects_au AFTER UPDATE ON kategorie FOR EACH ROW EXECUTE PROCEDURE tree_objects_au();
 
-- triger i procedura dzięki której przerzucamy bez problemu gałęzie

Dobra mamy już cały SQL potrzebny i niezbędny do zbudowania takiego menu opartego na wielu poziomach.
A teraz trochę php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 09.07.09
 * @file controlers/tpl.php
**/
 
require_once('models/view.php');
 
class ShowData
{
  private $tpl;
  private $obj;
 
  public function __construct($tepel)
  {
    $this->tpl = $tepel;
    $this->obj = new GetData;
    $this->parseKat();
    $this->parseTree();
  }
 
 
  private function parseKat()
  {
    $data = $this->obj->_get_kat();
    $this->tpl->assign('kategorie',$data);
  }
 
  private function setSort(&$sort)
  {
    if($sort != 'ASC' && $sort != 'DESC')
     $sort = 'ASC';
  }
 
  private function parseTree()
  {
    $sort_kat = $_POST['sort_kat'];
    $sort_list = $_POST['sort_list'];
    $this->setSort($sort_kat);
    $this->setSort($sort_list);
    $mast = $this->obj->_get_master_kat($sort_kat);
    $n = count($mast);
    for($i = 0; $i < $n; $i++)
    {
      $tablica['element'][$i]['name'] = $mast[$i]['name'];
      $tablica['element'][$i] = $this->obj->_get_tree($mast[$i]['id'], $tablica['element'][$i], $sort_list);
    }
 
    $this->tpl->assign('tree',$tablica);
  }
}
 
?>

Co to jest? Jest to kontroler templatki, nie chciało mi się tworzyć jakiegoś MVC to zrobiłem pseudo MVC.
Pasowało by Wam pokazać jak to tworzy te drzewo co? No to jeszcze jeden plik z modelu, odpowiedzialny za widok.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 09.07.09
 * @file models/view.php
**/
 
class GetData
{
 
  public function _get_kat()
  {
    $kat = Doctrine::getTable('Kategoria')->findAll();
    return $kat->toArray();
  }
 
  public function _get_master_kat($sort)
  {
    $kat = Doctrine_Query::create()->query("SELECT k.name FROM Kategoria k WHERE NOT EXISTS (SELECT * FROM Powiazanie p WHERE k.id = p.child_id AND p.depth = 1) ORDER BY k.id $sort");
    return $kat->toArray();
  }
 
  public function _get_sub_kat($id_kat, $sort)
  {
    $kat = Doctrine_Query::create()->query("SELECT k.name FROM Kategoria k JOIN k.Powiazania p ON k.id = p.child_id WHERE p.parent_id = $id_kat AND p.depth = 1 ORDER BY k.id $sort");
    return $kat->toArray();
  }
 
  public function _get_tree($id, $tab, $sort)
  {
    $sub = $this->_get_sub_kat($id, $sort);
    $nn = count($sub);
    for($j = 0; $j < $nn; $j++)
    {
      $tab['element'][$j]['name'] = $sub[$j]['name'];
      $tab['element'][$j] = self::_get_tree($sub[$j]['id'],$tab['element'][$j], $sort);
    }
    return $tab;  
  }
 
}
 
?>

No i tak, teraz jeszcze przydałby by się modele dla doctrine, już pokazuję:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 07.07.09
 * @file models/doctrine/kategorie.php
**/ 
 
class Kategoria extends Doctrine_Record
{
 
  public function setTableDefinition()
  {
    $this->setTableName('kategorie');
    $this->hasColumn('name','string');
    $this->hasColumn('parent_id','integer');
  }
 
  public function setUp()
  {
    $this->hasMany('Powiazanie as Powiazania', array (
        'local' => 'id',
        'foreign' => 'parent_id',
        )
    );
 
    $this->hasMany('Powiazanie as Powiazanias', array (
        'local' => 'id',
        'foreign' => 'child_id',
        )
    );
 
    $this->hasMany('Kategoria as Kategorie', array (
        'local' => 'parent_id',
        'foreign' => 'id'
        )
    );
  }
}
 
?>

Nie ma tu nic ciekawego, trochę małe zamieszanie wprowadziłem z powiązaniami… przez co nie wiadomo z jakiej przyczyny nie chciał mi działać joinLeft w doctrine, dlatego zmuszony byłem użyć query().

Kolejny model:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 07.07.09
 * @file models/doctrine/powiazania.php
**/ 
 
class Powiazanie extends Doctrine_Record
{
  public function setTableDefinition()
  {
    $this->setTableName('powiazania');
    $this->hasColumn('parent_id','integer');
    $this->hasColumn('child_id','integer');
    $this->hasColumn('depth','integer');
  }
 
 
  public function setUp()
  {
    $this->hasMany('Kategoria as Kategorie', array (
        'local' => 'parent_id',
        'foreign' => 'id',
        )
    );
 
    $this->hasMany('Kategoria as Kategories', array (
        'local' => 'child_id',
        'foreign' => 'id',
        )
    );
  }
}
 
?>

Jak będę dopisywał to do swojego „cms’a” to obiecuję poprawić powiązania ;)

Dobra, no to mamy praktycznie wszystko co nam było potrzebne, jeszcze dorzucę dwie rzeczy:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 07.07.09
 * @file models/create.php
**/ 
 
class Dodawanie
{
 
  public function MasterKat($kat)
  {
    $query = new Kategoria;
    $query->name = $kat;
    $query->save();
  }
 
  public function SubKat($kat,$parent)
  {
    $query = new Kategoria;
    $query->name = $kat;
    $query->parent_id = $parent;
    $query->save();
  }
 
}
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.3
 * @author Przemysław Czekaj
 * @date 09.07.09
 * @file models/delete.php
**/ 
 
class Niszczenie
{
  public function czyIstniejeKat($kat)
  {
    $query = Doctrine_Query::create()
              ->from('Kategoria')
              ->where('name = ?',$kat)
              ->orWhere('id = ?',(int)$kat);
    $result = $query->execute();
    $result = $result->toArray();
    if(is_array($result[0]))
      return true;
    else
      return false;
  }
 
   public function czyDoPotomka($id_kat,$id_pod)
   {
     $query = Doctrine_Query::create()->query("SELECT k.id, k.name, k.parent_id FROM Kategoria k JOIN k.Powiazania p ON k.id = p.child_id WHERE p.parent_id = $id_kat AND p.depth <> 0");
     $result = $query->toArray();
     $n = count($result);
     for($i = 0; $i < $n; $i++)
     {
       if($result[$i]['id'] == (int)$id_pod)
         throw new Exception ('Nie można przenosić głównej kategorii do sub kategorii danej kategorii'); 
     }
   } //nie chce działać...
 
  public function usunKategorie($kat)
  {
    $query = Doctrine_Query::create()
            ->delete('Kategoria')
            ->where('name = ?',$kat)
            ->orWhere('id = ?',(int)$kat);
    $result = $query->execute();
    return $result;
  }
 
}
 
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 09.07.09
 * @file models/move.php
**/ 
 
class Posuwanie // xD
{
 
  public function MoveKat($kat,$parent)
  {
    $query = Doctrine_Query::create()
              ->update('Kategoria')
              ->set('parent_id','?',(int)$parent)
              ->where('id = '.(int)$kat);
    $result = $query->execute();
    return $result;
  }
 
}
?>

Tak więc mamy tutaj 3 modele, do tworzenia kategorii, do usuwania kategorii, oraz do przenoszenia kategorii.

Teraz pora na kontrolery, tak więc zobaczmy:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 07.07.09
 * @file controlers/dodaj.php
**/ 
 
require_once('controlers/validate.php');
 
final class HandlerDodaj
{
  private $handle;
  private $ref;
 
  public function __construct($handle)
  {
    $this->handle = $handle;
  }
 
  public function handled_event($ref)
  {
    $this->ref = $ref;
    $this->ref = 'valAdd'.ucfirst($this->ref);
    if(method_exists('Validate',$this->ref))
    {
      $val = new Validate;
      if(is_callable(array($val,$this->ref),true))
      {
        $val->{$this->ref}();
        return true;
      }
      throw new Exception ('Nie można wywołać zdarzenia');
 
      return true;
    }
    throw new Exception ('Brak obsługi zdarzenia');
  }
}
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 07.07.09
 * @file controlers/przenies.php
**/ 
 
require_once('controlers/validate.php');
 
final class HandlerPrzenies
{
  private $handle;
  private $ref;
 
  public function __construct($handle)
  {
    $this->handle = $handle;
  }
 
  public function handled_event($ref)
  {
    $this->ref = $ref;
    $this->ref = 'valPrzenies'.ucfirst($this->ref);
    if(method_exists('Validate',$this->ref))
    {
      $val = new Validate;
      if(is_callable(array($val,$this->ref),true))
      {
        $val->{$this->ref}();
        return true;
      }
      throw new Exception ('Nie można wywołać zdarzenia');
 
      return true;
    }
    throw new Exception ('Brak obsługi zdarzenia');
  }
}
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 07.07.09
 * @file controlers/usun.php
**/ 
 
require_once('controlers/validate.php');
 
final class HandlerUsun
{
  private $handle;
  private $ref;
 
  public function __construct($handle)
  {
    $this->handle = $handle;
  }
 
  public function handled_event($ref)
  {
    $this->ref = $ref;
    $this->ref = 'valDelete'.ucfirst($this->ref);
    if(method_exists('Validate',$this->ref))
    {
      $val = new Validate;
      if(is_callable(array($val,$this->ref),true))
      {
        $val->{$this->ref}();
        return true;
      }
      throw new Exception ('Nie można wywołać zdarzenia');
 
      return true;
    }
    throw new Exception ('Brak obsługi zdarzenia');
 
    return true;
  }
} 
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 07.07.09
 * @file controlers/validate.php
**/
 
require_once('models/delete.php');
require_once('models/create.php');
require_once('models/move.php');
 
final class Validate
{
 
  private $check;
  private $add;
 
  public function __construct()
  {
    $this->check = new Niszczenie;
  }
 
  public function valDeleteKat()
  {
    $nazwa_kat = trim($_POST['nazwa_kategorii']);
    $nazwa_pod = trim($_POST['nazwa_podkategorii']);
    if($nazwa_kat != '')
      $this->doIt($nazwa_kat);
    else
      $this->doIt($nazwa_pod);
  }
 
  public function valPrzeniesKat()
  {
    $nazwa_kat = trim($_POST['nazwa_kategorii']);
    $nazwa_pod = trim($_POST['nazwa_podkategorii']);
    if($nazwa_kat == 0 || $nazwa_pod == 0)
      throw new Exception ('Musisz wybrać skąd dokąd ma być przeniesiona kategoria');
    if ($nazwa_kat == $nazwa_pod)
      throw new Exception ('Nie ma sensu przenoszenia kategorii na ją samą');
    $this->check->czyDoPotomka($nazwa_kat,$nazwa_pod);
 
    if($this->check->czyIstniejeKat($nazwa_kat) && $this->check->czyIstniejeKat($nazwa_pod))
    {
      $przenies = new Posuwanie;
      $przenies->MoveKat($nazwa_kat,$nazwa_pod);
      return true;
    }
    throw new Exception ('Nie istnieje podana kategoria');
 
  }
 
  private function doIt($what)
  {
    if($this->check->czyIstniejeKat($what))
    {
      $this->check->usunKategorie($what);
      return true;
    }
    throw new Exception ('Nie ma podanej kategorii');
  }
 
  private function doItAgain($what,$i = 1,$child = '')
  {
    $this->valKat($what);
    switch($i)
    {
      case 1:
          $this->add->MasterKat($what);
        break;
      case 2:
          $this->add->SubKat($what,$child);
        break;
    }
  }
 
  private function valKat($string)
  {
    if($string == '')
      throw new Exception ('Nazwa kategorii nie może być pusta');
    elseif(!mb_check_encoding($string,'UTF-8'))
      throw new Exception ('Należy ustawić kodowanie w przeglądarce na UTF-8');
    elseif(strlen($string) < 3)
      throw new Exception ('Nazwa kategorii nie może być krótsza niż 3 znaki');
    elseif(!preg_match('/[a-zA-Z0-9ĄąĆćĘꣳŃńÓ󌜏źŻż]/',$string))
      throw new Exception ('Nazwa kategorii może składać się wyłącznie z liter i cyfr');
    else
      return true;
  }
 
  public function valAddKat()
  {
    $nazwa_kat = trim($_POST['nazwa_kategorii']);
    $nazwa_pod = trim($_POST['nazwa_podkategorii']);
    $this->add = new Dodawanie;
    if($nazwa_pod != 0)
    {
      $this->doItAgain($nazwa_kat,2,$nazwa_pod);      
    }
    else
    {
      $this->doItAgain($nazwa_kat);
    }
  }
 
}
?>

Wszystkie powyższe kontrolery zostały oparte o dyspozytora:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

<?php
/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author Przemysław Czekaj
 * @date 07.07.09
 * @file controlers/dispatcher.php
**/
 
require_once('controlers/dodaj.php');
require_once('controlers/usun.php');
require_once('controlers/przenies.php');
require_once('controlers/tpl.php');
 
final class Dispatcher
{
  private $handle;
  private $tpl;
 
  public function __construct($tepel, $link)
  {
    $this->tpl = $tepel;
    $this->handle = $link;
    $this->handle_the_event();
    $this->display();
  }
 
  public function handle_the_event()
  {
    try // posprawdzajamy co nam tam chce uzytkownik powysyłać
    {
      $name = "Handler".ucfirst($this->handle);
      if ($this->handle != '')
      {
        if (class_exists("$name"))
        {
          $handlerObj = new $name($tpl->handle);
          $handlerObj->handled_event($_GET['co']);
          return true;
        }
        throw new Exception ('Nie można obsłużyć');
      }
    }
    catch(Exception $e) // połapiemy błędy
    {
      $this->tpl->assign('typ_msg','error');
      $this->tpl->assign('wiadomosc',$e->getMessage());
    }
  }
 
  private function display() // poparsujmy troche templatke
  {
    $disTpl = new ShowData($this->tpl);
  }
}
 
?>

Najważniejsze pliki zostały Wam przedstawione, a teraz troche opisu, żeby móc utworzyć drzewo, musimy użyć Rekurencji, została ona użyta w pliku: models/view.php, linia 39. Odwołanie się do samego siebie przez self::, dlaczego po co i jak? Już tłumaczę:
Do stworzenia drzewa użyłem dwóch rzeczy:
1) compiler defun – plugin do smartów – link
2) gotowego przykładu z jquery z budową drzewiastą – link

Jak musi wyglądać tablica w php żeby mogła być przerobiona za pomocą tego pluginu do smartów? Otóż tak:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$tree = array('element'=>array(array('name' => 'test1',
                                     'element' => array(array('name' => 'test1.1'),
                                                        array('name' => 'test1.2',
                                                              'element' => array(array('name' => 'test1.2.1'),
                                                                                 array('name' => 'test1.2.2')
                                                                                )
                                                             ),
                                                        array('name' => 'test1.3',
                                                              'element' => array(array('name' => 'test1.3.1')
                                                                                )
                                                             )
                                                       )
                                    )
                              )
             );

Prawda że nie fajna co? Ni i właśnie za pomocą tej rekurencj którą przedstawiłem powyżej stworzyliśmy taką o to tablice, dzięki której piknie nam wszystko działa.

Teraz jak powinna wyglądać w tpl cała struktura? o tak:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 <ul id="black" class="treeview-black">
 {defun name="testrecursion" list=$tree.element}
 {foreach from=$list item=element}
   {if $element.element}
   <li>
    <span> {$element.name}</span>
    <ul>
      {fun name="testrecursion" list=$element.element}
    </ul>
   </li>
   {else}
    <li> {$element.name}</li>
   {/if}
 {/foreach}
 {/defun}
 </ul>

Dlaczego tak a nie inaczej? Ponieważ użyłem 3 przykładu z struktury drzewiastej w jQuery. Nie wiem co tu jeszcze opisywać, dam Wam do pobrania wszystkie pliki, link poniżej.

Do pobrania całość: link

]]> http://www.cojack.pl/menu-w-postaci-drzewa/feed 17 Doctrine ORM dla PHP cz.2 http://www.cojack.pl/doctrine-orm-dla-php-cz-2 http://www.cojack.pl/doctrine-orm-dla-php-cz-2#comments Tue, 30 Jun 2009 08:33:16 +0000 cojack http://cojack.os-cms.pl/?p=101 Doctrine Tak więc poznaliśmy już jak połączyć się z bazą danych, teraz należało by dowiedzieć się co nie co o modelach, tworzeniu, automatycznym generowaniu z bazy danych, referencjach pomiędzy tabelami.
Tak więc zacznijmy od tego jak prawidłowo model powinien wyglądać co powinien zawierać?

Model tabeli z bazy danych, jest klasą, w której główną metodą jest public function setTableDefinition(), klasa dziedziczy z Doctrine_Record, w niej należy powiedzieć Doctrine jak się nazywa dana tabela, jakie ma pola, jakiego są one typu, czy mają jakieś ograniczenia.

Przykład

1
2
3
4
5
6
7
8
9
10

<?php
class dTest extends Doctrine_Record
{
  public function setTableDefinition()
  {
    $this->setTableName('test');
    $this->hasColumn('imie','string');
  }
}
?>

Tutaj nawiązując do naszego przykładu wcześniejszego, utworzyliśmy sobie klasę dTest, powiedzieliśmy Doctrine jak się nazywa tabela w bazie danych setTableName, oraz że ta tabela ma 1 kolumnę hasColumn, kolumna nazywa się imie i jest typu string.

Typy danych w Doctrine

W zależności od typu kolumny, każda ma swój odpowiednik w Doctrine (no prawie każda, np nie ma w doctrine typu text, należy użyć string, co ma się zmienić w Doctrine 2.0). Dostępne typy danych dla tabel w Doctrine to:

  • Boolean
  • Integer
  • Float
  • Decimal
  • String
  • Array
  • Object
  • Blob
  • Clob
  • Timestamp
  • Time
  • Date
  • Enum
  • Gzip

W Doctrine możemy też używać aliasów dla kolumn, jeżli np mamy nawyk dodawania prefixu dla nazwy kolumny względnie zależnego od typu kolumny, to taki alias może nam ułatwić pracę, spójrzmy:

$this->hasColumn('s_imie as imie','string');

Dzięki temu podczas operacji na takiej kolumnie nie musimy używać jej nazwy s_imie tylko wystarczy wtedy już sam jej alias czyli imie

Nasze kolumny mogą mieć tak jakby modyfikatory, chodź nie do końca, ponieważ o modyfikatorach porozmawiamy później. Zobaczcie sami:

1
2
3
4
5
6
7
8

$this->hasColumn('s_imie as imie','string',64, array(
          'type'=>'string',
          'fixed'=> true,
          'notnull'=> true,
          'default' => 'Jaś',
          'lenght'=>64
          )
);

Omówmy te podane powyżej:
type – typ danych
fixed – Doctrine używa typów zmiennej różnej długości, parametr fixed wymusza używanie typów o stałej długości
notnull – komórka nie może być pustą wartością
default – domyślna wartość komórki
lenght – długość jaką może przyjąć wartość

inne nie przedstawione:
scale – dla Decimal, ilość miejsc po przecinku (int)
unsigned – dla Integer, oznaczony nie oznaczony integer (bool)
values -dla Enum, tablica asociacyjna z listą wartości (array), przykład:

$this->hasColumn('kolor', 'enum', null, array(
          'values' => array('zielony', 'czerwony', 'żółty')
);

Teraz jak wygląda ogólna definicja metody hasColumn

$this->hasColumn('nazwa_kolumny','typ_kolumny', zakres_typu, array(
          'modyfikator' => 'wartosc' .... )
);

Kolejną ważną metodą jest public function setUp(), w niej natomiast definiujemy relacje pomiędzy tabelami. Relacje mogą być typu:

    Typy relacji

  • one-to-one
  • one-to-many, many-to-one
  • many-to-many

Relacja typu one-to-one

Powiązanie jednej tabeli np Użytkownika z inna tabelą np tabelą przechowującą sesje użytkownika, czy czymkolwiek innym. Ogólnie rzecz biorąc powiązanie ma się tak: Po kluczu obcym w tabeli A, łączymy tabele B z kluczem podstawowym, czyli klucz obcy w tabeli A jest kluczem podstawowym w tabeli B i może wystąpić tylko raz! W każdym z przypadków.

Przykład stworzenia takiej metody:

1
2
3
4
5
6
7
8

public function setUp()
{
  $this->hasOne('NazwaKlasyModulu', array(
                    'local' => 'id', // pokazujemy na klucz główny
                    'foreign' => 'id_usera' // klucz obcy w tabeli na ktora wskazalismy NazwaKlasyModulu
                    )
  );
}

Tak tworzymy odwołanie macierzyste, czyli dla klasy Users, a tak będzie wyglądać funkcja setUp() w klasie modułu Sesji:

1
2
3
4
5
6
7
8

public function setUp()
{
  $this->hasOne('NazwaKlasyModulu', array(
                    'local' => 'id_usera', // pokazujemy na klucz obcy w naszej tabeli
                    'foreign' => 'id' // i wskazujemy że ma odwołanie do klucza głównego
                    )
  );
}

Relacja typu one-to-many oraz many-to-one

Powiązanie jednej tabeli np Użytkownika z inna tabelą np tabelą przechowującą dane adresowe użytkownika. Ogólnie rzecz biorąc powiązanie ma się tak:

Jeden użytkownik może mieć wiele np maili tak? Nie wiemy ile on może mieć tych maili czy np nr telefonów więc w tabeli User nie będziemy ich definiować tylko zrobimy sobie osobną tabelę na te dane adresowe. No więc
Po kluczu głównym w tabeli A, łączymy tabele B z kluczem obcym, czyli klucz podstawowy w tabeli A jest kluczem obcy w tabeli B i może wystąpić parę razy! W każdym z przypadków. Ale nie na odwrót!

Przykład tabela A:

1
2
3
4
5
6
7
8

public function setUp()
{
  $this->hasMany('NazwaKlasyModulu', array(
                    'local' => 'id', // pokazujemy na klucz obcy w naszej tabeli
                    'foreign' => 'id_usera' // i wskazujemy że ma odwołanie do klucza głównego
                    )
  );
}

Przykład tabela B:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public function setTableDefinition()
{
   $this->hasColumn('id_usera', 'integer');
   $this->hasColumn('email', 'string', 255);
}
 
public function setUp()
{
  $this->hasOne('NazwaKlasyModulu', array(
                    'local' => 'id_usera', // pokazujemy na klucz obcy w naszej tabeli
                    'foreign' => 'id' // i wskazujemy że ma odwołanie do klucza głównego
                    )
  );
}

Relacja typu many-to-many

Dobra szczeże, nie chce mi się jej opisywać ;D Ale hamskie wiem :P Dlatego zrobię jeszcze jeden motyw, po prostu na jana zedre przykład z Manuala. Ale tak z grubsza ocb.

Sprawa ma się tak, tworzymy dostęp użytkownikom do czegoś. No to najlepiej ich na grupy podzielić. No więc dlaczego jeden użytkownik nie może być w wielu grupach? A no może czemu nie. No właśnie. Jeden użytkownik może być w wielu grupach, jedna grupa może należeć do wielu użytkowników. I to jest własnie relacja typu many-to-many (hajs hajs ;D) Leci to tak:

class User extends BaseUser
{
    public function setUp()
    {
        parent::setUp();
 
        // ...
 
        $this->hasMany('Group as Groups', array(
                'local' => 'user_id',
                'foreign' => 'group_id',
                'refClass' => 'UserGroup'
            )
        );
    }
}

A teraz model Grup

class Group extends Doctrine_Record
{
    public function setTableDefinition()
    {
        $this->setTableName('groups');
        $this->hasColumn('name', 'string', 30);
    }
 
    public function setUp()
    {
        $this->hasMany('User as Users', array(
                'local' => 'group_id',
                'foreign' => 'user_id',
                'refClass' => 'UserGroup'
            )
        );
    }
}

No i nasza klasa wiążąca te dwie powyższe:

class UserGroup extends Doctrine_Record
{
    public function setTableDefinition()
    {
        $this->hasColumn('user_id', 'integer', null, array(
                'primary' => true
            )
        );
 
        $this->hasColumn('group_id', 'integer', null, array(
                'primary' => true
            )
        );
    }
}

Dobra, jak mi ktoś powie że nie działa to własnoręcznie powiesze za „uszy” :) Nic nie zmieniać, wrzucić sobie do plików, wygenerować z tego kod sql i zaimportować go do bazy. Liczę na Waszą kreatywność (o bym się nie przeliczył). Więcej można przeczytać na dole w linku Strona projektu. Już nie długo opis konfiguracji Doctrine Sandbox.

]]> http://www.cojack.pl/doctrine-orm-dla-php-cz-2/feed 6 Doctrine ORM dla PHP http://www.cojack.pl/doctrine-orm-dla-php http://www.cojack.pl/doctrine-orm-dla-php#comments Mon, 29 Jun 2009 10:36:51 +0000 cojack http://cojack.os-cms.pl/?p=68 DoctrineZacznijmy od tego czym jest ORM, ORM z ang Object-Relational Mapping, na Polski, mapowanie obiektowo-relacyjne, co nam to daje, z czym to się je, jeżeli mamy powiązania pomiędzy tabelami (tzw relacje) oraz tworzymy aplikacje zorientowaną obiektowo, pozwala nam taki ORM na działania obiektowe po pobraniu danych z bazy, czyli np pola z bazy danych mamy jako obiekty. Typy danych z pól mamy jako obiekty itp. No to do dzieła, to co nam potrzebne to Doctrine oczywiście, możemy pobrać najnowszą wersje z strony: Doctrine Project
Jeżeli już mamy ściągniętego Doctrine, należy zabrać się do pracy, na początek trzeba nawiązać połączenie z bazą danych, możemy to zrobić na dwa sposoby pracując z Doctrine,

Łącznie się z bazą danych
Pierwszy sposób z PDO:

1
2
3
4
5
6
7
8

<?php
$con = 'mysql:dbname=nazwa_bazy;host:ip_hosta';
$user = 'nazwa_uzytkownika';
$haslo ='haslo_uzytkownika';
 
$pdo_conn = new PDO ($con, $user, $haslo);
$doc_conn = Doctrine_Manager::connection($pdo_conn);
?>

Doctrine w taki sposób nie ma możliwości dostania nazwy użytkownika i hasła i jeżeli chcemy później przy pomocy Doctrine tworzyć bazę danych, lub ją usuwać musimy musimy podać te informacje w taki sposób:

<?php
$doc_conn->setOption('username',$user);
$doc_conn->setOption('password',$haslo);
?>

No i teraz będzie grała muzyka ;)

Drugi sposób z Doctrine:
Jest o tyle lepszy, że jeżeli nie potrzebujemy połączenia z bazą danych, Doctrine nie wywołuje go automatycznie, więc nie męczymy serwera. Ogólny schemat wygląda tak:

typbazy://uzykownik:haslo@adres/nazwa_bazy

Gdzie typ bazy może być:

  • mysql dla MySQL
  • psql dla PostgreSQL
  • ico dla Oracle 7/8/9/10
  • fbsql dla FrontBase
  • ibase dla InterBase/FireBird wymagany PHP 5
  • querysim dla QuerySim
  • sqlite (tak sqlite przez jedno l) dla SQLite 2
  • mssql dla Microsoft SQL Server (nie gra z Sybase)

Tak więc połączmy się:

1
2
3
4
5
6
7
8

<?php
require_once('Doctrine.php'); // wczytujemy klase Doctrine
spl_autoload_register(array('Doctrine', 'autoload')); // auto ładowanie klasy
$manager = Doctrine_Manager::getInstance(); // w późniejszym etapie wyjaśnię
$dbconn = 'psql://testowy:test123@127.0.0.1/testowa';
set_time_limit(0);
$dbhandle = Doctrine_Manager::connection($dbconn,'polaczenie');
?>

Jeżeli nie dostaniemy żadnego błędu tzn że połączenie z bazą danych się udało prawidłowo.
Sprawdźmy czy działa nasze połączenie, utworzymy sobie tabele i wrzucimy do niej jakieś treści:

1
2
3
4
5
6
7
8

<?php
$dbhandle->export->createTable('test',array('imie' => array('type' => 'string')));
$dbhandle->execute('INSERT INTO test (imie) VALUES (?)',array('Andrzej'));
$query = $dbhandle->prepare('SELECT * FROM test');
$query->execute();
$result = $query->toArray();
print_r($result);
?>

Powinno nam zwrócić:

1
2
3
4
5
6
7
8

Array
(
  [0] => Array
  (
    [imie] => Andrzej
    [0] => Andrzej
  )
)

dziękuje Paweł za wytknięte błędy, usunięto mysqli z listy typu, z prostej przyczyny, nie ma takiego drivera pdo ;)

]]> http://www.cojack.pl/doctrine-orm-dla-php/feed 5