Inhoudsopgave voor CodeIgniter met Doctrine Serie

1. Deel 1 Codeigniter en Doctrine vanaf het begin – Installatie and Setup
2. Deel 2 Codeigniter met Doctrine de Basis

In dit 2e Deel:

http://localhost/ci_doctrine/index.php/CONTROLLER_NAAM/METHODE_NAAM

http://localhost/ci_doctrine/index.php/CONTROLLER_NAME

http://localhost/ci_doctrine/index.php/CONTROLLER_NAAM/METHODE_NAAM/WAARDE

application/views/my_view.php

Een beetje text.

  <div>
    Men kan zelfs HTML gebruiken.
  </div>

  <div>
   Geef variabelen doorgeven van de controller weer: <br />
   <?php echo $boodschap; ?> <br />
   <?php echo $nog_een_boodschap; ?>
  </div>

Men kan lussen gebruiken: <br />
  <?php for ($i = 0; $i < 3; $i++) {

   echo "Teller geeft weer: $i <br />";

  } ?>

Of in alternatieve syntaxis: <br />
  <?php for ($i = 0; $i < 3; $i++): ?>

   Teller geeft weer: <?php echo $i; ?> <br />

  <?php endfor; ?>

application/controllers/sample_controller.php

class Sample_controller extends Controller {

   function index() {
     $data = array();
     $data['message'] = "index was aangeroepen";
     $data['another_message'] = "blah blah";

     $this->load->view('my_view',$data);
   }

}

http://localhost/ci_doctrine/index.php/sample_controller/index
http://localhost/ci_doctrine/index.php/sample_controller

Een stukje tekst.
Men kan HTML gebruiken.
Geef variabelen weer vanuit de controller:
index was aangeroepen
blah blah
Je kunt zelfs lussen gebruiken:
Teller geeft weer: 0
Teller geeft weer: 1
Teller geeft weer: 2
Of in alternatieve syntaxis:
Teller geeft weer: 0
Teller geeft weer: 1
Teller geeft weer: 2

<?php
class User extends Doctrine_Record
{

  // definieer tabel kolommen in deze functie
  public function setTableDefinition() {

     $this->hasColumn('username', 'string', 255);
     $this->hasColumn('password', 'string', 255);
     $this->hasColumn('email', 'string', 255, array(
     'email' => true // de email input kan gevalideerd worden
     ));

     // Support vele kolom types, inclusief enum
     $this->hasColumn('status', 'enum', null,
     array('values' => array('unverified', 'verified', 'disabled'))
     );
   }

   // set wat options
   public function setUp() {

     // maak een relatie met het Post model
     $this->hasMany('Post as Posts');

     // kan zelfs met zichzelf een relatie hebben
     $this->hasOne('User as Referer');

     // 'created_at' en 'updated_at' worden automatisch aangemaakt en bijgewerkt
     $this->actAs('Timestampable');

     // Het password veld krijgt een mutator veld toegewezen, voor automatische encryptie
     $this->hasMutator('password', 'md5Password');

   }

   // de mutator functie
   public function md5Password($value) {
     $this->_set('password', md5($value));
   }

}

Inhoudsopgave voor CodeIgniter met Doctrine Serie

1. Deel 1 Codeigniter en Doctrine vanaf het begin – Installatie and Setup
2. Deel 2 Codeigniter met Doctrine de Basis

In dit 1e deel

- We beginnen met de basis installatie van CodeIgniter en Doctrine als plugin.

Waarom Doctrine toevoegen aan CodeIgniter?

Create, Read, Update en Delete (CRUD)

Creëer, Lees, Bewerk en Verwijder bewerkingen worden veel makkelijker uitgevoerd
doordat Tabellen en hun Relaties als Objecten worden gezien.

Er zijn nog veel meer voordelen maar deze zullen we verderop behandelen.
Voor meer informatie: Doctrine Introductie (Engels)

In bovenstaand voorbeeld spreekt de Controller van Codeigniter het Doctrine ORM i.p.v. het Model aan.

We gebruiken MySQL database maar door de PDO kan er ook een andere database worden gekozen.

De Eerste stap, het opzetten van de ontwikkelomgeving

Wanneer er al een Webserver met PHP en MySQL is geïnstalleerd, kun je sommige van deze stappen overslaan.

• Download en installeer WAMP (voor Mac: MAMP)
  Waarschuwing Skype gebruikers: Eerst moet Skype worden afgesloten door een poort conflict, na opstarten van wamp kan skype weer worden gestart.
• Bezoek http://localhost/ in je browser en check of de link werkt.
• Open de “www” folder onder de WAMP installatie (Standaard C:\WAMP\WWW\ ).
• Maak hierin de folder “ci_doctrine” aan.

Installeer CodeIgniter

• Download CodeIgniter
• Pak het bestand uit in de  “ci_doctrine″ map.
• Voor een goed overzicht verwijder ik altijd de “user_guide” folder en haal de apps map buiten de system map.

De nieuwe mappen zien er zo uit:

Installatie CI

In de ci_doctrine map, bevindt zich “index.php”

• Ga naar http://localhost/ci_doctrine

• Check of onderstaand voorbeeld te zien is:

Snelle CodeIgniter cursus: Controllers

Controllers worden aangeroepen met het laden van iedere pagina.
Controller staan onder:

ci_doctrine/application/controllers/

De url ziet er als volgt uit:

http://localhost/ci_doctrine/index.php/CONTROLLER_NAAM/FUNCTION_NAAM

Bijvoorbeeld wanneer de volgende url wordt geopend:

http://localhost/ci_doctrine/index.php/hallo/wereld

CodeIgniter zoekt naar controller classe genaamd “Hallo” en roept zijn methode “wereld()” aan.

Onze eerste Controller

• Maak het bestand aan:

ci_doctrine/application/controllers/hallo.php

<?php
//application/controllers/hallo.php

class Hallo extends Controller {

 function wereld() {
   echo "Hallo CodeIgniter!";
 }

}

• Ga naar: http://localhost/ci_doctrine/index.php/hallo/wereld

Nu zie je:

Hallo CodeIgniter!

Let op!:

• De klasse moet de controller extenden (uitbreiden).
• De klasse moet beginnen met een Hoofdletter.
• De bestandsnaam moet met kleine letters zijn geschreven.

Aanbevolen leesmateriaal:

• http://codeigniter.com/user_guide/general/controllers.html

Install Doctrine

In CodeIgniter gaan we Doctrine  als plug-in installeren.

• Maak de map: application/plugins
• Maak de map: application/plugins/doctrine
• Download Doctrine
• Pak alleen de folder “lib” uit naar application/plugins/doctrine.

Onze map ziet er als volgt uit:

• Maak het plugin bestand: application/plugins/doctrine_pi.php

<?php
// system/application/plugins/doctrine_pi.php

// laad Doctrine bibliotheek
require_once APPPATH.'/plugins/doctrine/lib/Doctrine.php';

// laad database configuratie uit CodeIgniter
require_once APPPATH.'/config/database.php';

// hier worden de Doctrine Model classes automatisch geladen
spl_autoload_register(array('Doctrine', 'autoload'));

// We laden onze database connecties in Doctrine_Manager
// Met deze lus kunnen we later meerdere connecties hebben
foreach ($db as $connection_name => $db_values) {

 // Eerst moeten we converteren naar het DSN formaat
 $dsn = $db[$connection_name]['dbdriver'] .
 '://' . $db[$connection_name]['username'] .
 ':' . $db[$connection_name]['password'].
 '@' . $db[$connection_name]['hostname'] .
 '/' . $db[$connection_name]['database'];

 Doctrine_Manager::connection($dsn,$connection_name);
}

// CodeIgniter's Model classe moet geladen worden
require_once BASEPATH.'/libraries/Model.php';

//Vertrl Doctrine waar onze models staan
Doctrine::loadModels(APPPATH.'/models');

// (OPTIONAL) CONFIGURATION BELOW

// Hierdoor kunnen we "mutators" gebruiken
Doctrine_Manager::getInstance()->setAttribute(
 Doctrine::ATTR_AUTO_ACCESSOR_OVERRIDE, true);

// Dit zet standaard alle tabel kolommen op "notnull" en "unsigned" (voor ints)
Doctrine_Manager::getInstance()->setAttribute(
 Doctrine::ATTR_DEFAULT_COLUMN_OPTIONS,
 array('notnull' => true, 'unsigned' => true));

//Noem de standaard primaire sleutel  'id', integer, 4 bytes
Doctrine_Manager::getInstance()->setAttribute(
 Doctrine::ATTR_DEFAULT_IDENTIFIER_OPTIONS,
 array('name' => 'id', 'type' => 'integer', 'length' => 4)); 

Probeer het commentaar in de code te lezen ( later begrijp je het beter).

Database Setup en Configuratie

• Open phpMyAdmin: http://localhost/phpmyadmin/
• Maak een database en noem deze “ci_doctrine”

• Wijzig Bestand:  application/config/database.php
• Zoek onderstaande zinnen en voer de waarden in.

 // in application/config/database.php
// ...

$db['default']['hostname'] = "localhost";
$db['default']['username'] = "root";
$db['default']['password'] = ""; //Of een eigen wachtwoord wanneer de database goed beveiligd is
$db['default']['database'] = "ci_doctrine";

// ...

We hebben net het database configuratie bestand van CodeIgniter aangepast.

Nog meer Configureren…

config.php

• Wijzig bestand: application/config/config.php

// in application/config/config.php
// ...

$config['base_url']    = "http://localhost/ci_doctrine/";

// ...

Nu weet Codeigniter de URL van onze site.

autoload.php

• Wijzig bestand: application/config/autoload.php

// in application/config/autoload.php
// ...

$autoload['plugin'] = array('doctrine');

// ... 

Deze code zorgt ervoor dat de Doctrine plug-in altijd wordt geladen.

Klaar!

Nu kunnen we met het echte werk beginnen. Laten we met de setup starten.

Ons Eerste Doctrine Model

Maak de user Tabel

• Open phpMyAdmin: http://localhost/phpmyadmin/
• Ga naar database “ci_doctrine”
• Maak een tabel “user” met de volgende kolommen:
  id => int, primary key, auto_increment,
  username => varchar(255), unique,
  password => varchar(255),
  first_name => varchar(255),
  last_name => varchar(255)

De onderstaande query kan in de SQL veld van PHPMyadmin worden geplakt:

CREATE TABLE `ci_doctrine`.`user` (
`id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`username` VARCHAR( 255 ) NOT NULL ,
`password` VARCHAR( 255 ) NOT NULL ,
`first_name` VARCHAR( 255 ) NOT NULL ,
`last_name` VARCHAR( 255 ) NOT NULL ,
UNIQUE (
`username`
)
)

Maak het Model

• Maak bestand: application/models/user.php

<?php
// system/application/models/user.php
class User extends Doctrine_Record {

 public function setTableDefinition() {
 $this->hasColumn('username', 'string', 255);
 $this->hasColumn('password', 'string', 255);
 $this->hasColumn('first_name', 'string', 255);
 $this->hasColumn('last_name', 'string', 255);
 }

}

Let op!:

• We extenden Doctrine_Record, i.p.v. Model (Normaal gebruik je de CodeIgniter models).
• Binnen de setTableDefinition() moeten we de tabel structuur definiëren.
• Standaard kijkt Doctrine naar een tabel met dezelfde naam, in dit geval: “user”. (Deze kan veranderd worden)
• In ons doctrine_pi.php hierboven, hebben we al een standaard primaire “id” sleutel aangemaakt. Hierdoor hoeven we deze niet in onze User classe te plaatsen.

Test het Model: Voeg wat gebruikers (Users) toe

• Pas onze controller welke we eerder gemaakt hebben aan: application/controllers/hallo.php

<?php
// system/application/controllers/hallo.php

class Hallo extends Controller {

 function world() {
   echo "Hallo CodeIgniter!";
 }

 function user_test() {

   $u = new User;
   $u->username = 'johndoe';
   $u->password = 'secret';
   $u->first_name = 'John';
   $u->last_name = 'Doe';
   $u->save();

   $u2 = new User;
   $u2->username = 'phprocks';
   $u2->password = 'mypass';
   $u2->first_name = 'Codeigniter';
   $u2->last_name = 'Doctrine';
   $u2->save();

   echo "2 Gebruikers toegevoegd";
 }

}

We hebben net 2 objecten aangemaakt en met gegevens voorzien. Wanneer save() wordt aangeroepen worden de gegevens opgeslagen in de database.

Let op!:

• We kunnen de velden als parameters benaderen (bijv. $u->username), ook al hebben we ze niet aangemaakt als classe parameters. Is Doctrine niet mooi?
• Wanneer je bekend bent met CodeIgniter, moet de $this->load->model() function angeroepen worden om de modellen te laden. Maar nu we de autoload functie van Doctrine hebben geregistreerd, hoeven we  alleen maar te zeggen: “new User;”
• We hebben de “save()” functie niet gemaakt, omdat deze uit de Doctrine_Record classe komt welke we extenden. Het slaat het object in de database op. Verder in deze lessen komen er nog veel meer leuke funties en handigheidjes in de Doctrine classen.

• Open: http://localhost/ci_doctrine/index.php/hallo/user_test

Onderstaande zou moeten verschijnen:

2 Gebruikers toegevoegd

• Ga nu terug naar: http://localhost/phpmyadmin/
• Verken de tabel ‘user’

Voila! Nu zouden 2 twee records zichtbaar moeten zijn welke we hebben aangemaakt.

Samengevat…

We hebben CodeIgniter met Doctrine geïnstalleerd. Het duurde even voor het werkte,
maar nu hebben we een MVC framework en ORM combinatie.

In de volgende lessen, zal ik nuttigere voorbeelden  en uiteindelijk een  een functionele website bouwen.
Met Doctrine kunnen heel makkelijk modellen gemaakt worden welke tijd besparen waardoor we niet steeds opnieuw CRUD (Create, read, update and delete) functies hoeven te schrijven in al onze modellen.

Doctrine helpt ook met het afhandelen van relaties tussen onze klassen, en kunnen we complexe logische code en query’s ontlopen.

Tot de volgende keer!