Pour suivre, il est indispensable d’utiliser eclipse, car celui-ci possède un mode graphique pour la création de web-service qui va nous faciliter la vie.

Le fonctionnement

Vous savez certainement qu’un Web-Service est un programme qui permet la communication et l’échange de données entre des applications et des systèmes totalement différents.

Pour que le Web-Service puisse communiquer avec n’importe quels systèmes, il faut utiliser un même format de données. Pour nous, ça sera le SOAP(c’est un protocole procédural basé sur du XML). Dans ce format, il faut aussi bien définir les données qui seront reçues et envoyées par le Web-Service.

Ne vous inquiétez pas si cela vous paraît trop abstrait, on va tout expliquer avec un exemple.

Voici une petite illustration du fonctionnement de ce Web-Service :


Première étape :
L’application java va faire appel au web-service en envoyant un message WSDL (en SOAP).

Qui avait dit que c’était compliqué les web-service ?


Fini la théorie passons à la pratique, nous allons faire un Web-Service qui nous donne le jour en fonction de la date que l’on envoie.

Création du wsdl

Nous allons créer un nouveau projet que nous appellerons MonWebService (il n’y a pas plus clair ^^).


On va commencer par faire le format WSDL (fichier soap) de notre web service.

On le nomme monFormat.wsdl

Pour nous aider, Eclipse nous construit automatiquement un format wsdl par défaut, nous allons le reprendre et le paramétrer. Mais avant tout, je vais vous parler rapidement de l’interface.

C’est avec la boîte à gauche que l’on définit l’adresse du serveur du web-service ( c’est là où tout le traitement php va se faire), Dans le champ de saisie, il faudra mettre : http://localhost/MonWebService/serveur.php

Input qui représente les données que va recevoir le Web-Service
Output qui représente les données que va envoyer le Web-Service


Tout le monde suit ?

En entrée, on aura besoin d’une chaine de caractère(string).
Pour se faire, on fait un clique droit sur case la plus à droite de la ligne input, dans le menu contextuel
On clique sur Set Type puis Existing Type et là on sélectionne string.


On réitère cette opération pour le paramètre de sortie.

Du serveur au client

On va s’attaquer à notre serveur, préparez vos doigts ça va coder !

On va le nommer serveur.php
Attention, le chemin de votre fichier doit être le même que celui que vous avez paramétré dans votre web-service.

Ex : http://localhost/MonWebService/serveur.php => C:\wam\www\MonWebService\serveur.php

Voici le code source, les commentaires parlent d’eux-même :

// Pour supprimer le cache du web-service
ini_set('soap.wsdl_cache_enabled', 0);
// Pour définir le temp maximal d'éxecution de notre web-service
ini_set('default_socket_timeout', 180);

// Nom de notre web-service
class Server {
     // Le service QuelJour que l'on a définit dans notre format wsdl
    function QuelJour($parm) {
    	return 'Web-Service ok';
    }
}
// On tente d'instancier la classe soapServer
// Si cela s'avère impossible, on affiche une erreur
try {
    $server = new SoapServer('monFormat.wsdl',  array('trace' => 1,'encoding'	=> 'ISO-8859-1'));
    // On définit la classe qui va gérer les requêtes SOAP (pour nous c'est la class Server)
    $server -> setclass('Server');
    $server->setPersistence(SOAP_PERSISTENCE_REQUEST);
} catch (Exception $e) {
    echo 'erreur'.$e;
}
// Si l'appel provient d'un Web-Service
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
	try {
		$server -> handle();}
	catch (Exception $e) {
    echo 'erreur'.$e;
	}
}
// Facultatif seulement pour montrer les fonctions disponibles par le web-service
else {
    echo '<strong>This SOAP server can handle following functions : </strong>';
    echo '<ul>';
    foreach($server -> getFunctions() as $func) {
        echo '<li>' , $func , '</li>';
    }
    echo '</ul>';
}

Si tout se passe bien et si on se rend sur cette adresse :

http://localhostMonWebService/serveur.php

On devrait voir :



Tout marche ? On est trop fort \o/

// Pour supprimer le cache du web-service
ini_set('soap.wsdl_cache_enabled', 0);

// Nouveau Client SOAP
try {
    // Nouvelle instance de la classe soapClient
   $client = new SoapClient('http://localhost/MonWebService/monFormat.wsdl', array('trace' => 1));
   $parm = date('Y-m-d');
    // Appel de la méthode QuelJour du service web
   try{
    $oReturn =  $client -> __soapCall('QuelJour', array('string' =>$parm));
	} catch (SoapFault $fault) {
    	trigger_error("SOAP Fault: (faultcode: {$fault->faultcode}, faultstring: {$fault->faultstring})", E_USER_ERROR);
	}
        // affiche le résultat
	var_dump($oReturn);
} catch (SoapFault $fault) {
    echo 'erreur : '.$fault;
}

    function QuelJour($parm) {
    	$aJour[1] = 'Lundi';
    	$aJour[2] = 'Mardi';
    	$aJour[3] = 'Mercredi';
    	$aJour[4] = 'Jeudi';
    	$aJour[5] = 'Vendredi';
    	$aJour[6] = 'Samedi';
    	$aJour[0] = 'Dimanche';
    	return $aJour[date("w",strtotime($parm))];
    }

Debugger un web-service

Le debugage d’un web-service est toujours difficile. Le client interprète directement la réponse du web-service et si la réponse n’est pas correctement formaté (qui ne respecte pas le format wsdl du web-service), il affiche une erreur du type :

( ! ) Fatal error: SOAP Fault: (faultcode: Client, faultstring: looks like we got no XML document) in /var/www/MonWebService/client.php on line 17 Call Stack #TimeMemoryFunctionLocation 10.000158584{main}( )../client.php:0 20.002180708trigger_error ( )../client.php:17

Les erreurs :


Pendant le développement de différents de web-services, je suis tombé sur des erreurs de toute part, malheureusement je ne les ai pas tous mémorisé mais voici un début de liste qui pourrait vous aider. Si vous aussi vous êtes embétez un petit commentaire et on pourra certainement vous aider.

Installation

Pour l’installation, nous allons commencer à ouvrir une invite de commande dos.
Et commencer par faire :

set PATH=%PATH%;C:\wamp\php

Normalement dans votre dossier php, vous avez un dossier PEAR, il faut s’y rendre.

Par exemple, pour wamp il faut taper : cd C:\wamp\php\PEAR

Vous trouverez un fichier php go-pear.phar, il suffit de l’exécuter :

php go-pear.phar

Et là, l’installation se lance

installation pear

Si vous voulez que l’installation de pear concerne toutes les sessions d’utilisateurs, il faut mettre system.

Un récapitulatif des chemins de configuration de pear est affiché, vous pouvez laisser la configuration par défaut, elle est très bien.

installation pear

Dernière étape, on accepte de modifier notre fichier php.ini pour qu’il prenne en compte notre bibliothèque PEAR.

pear installation

Eh voilà c’est installé

pear installation

Première utilisation

Nous allons installer la librairie DATE

Dans un premier temps nous allons faire :

set PATH=%PATH%;C:\wamp\php\PEAR

Il faut aller ensuite sur http://pear.php.net/packages.php.

Date and Time -> Date -> Download.

On va récupérer la commande pour le téléchargement :

utilisation pear

Pour moi, il faut taper :

pear install Date-1.5.0a1

PEAR Fatal error: Allowed memory size of 8388608 bytes exhausted

Il faut modifier votre fichier C:\wamp\php\php.ini, aller dans l’attribut memory_limit = 8M
et remplacer par : memory_limit = 256M

Comme ça, on est tranquille

// on fait appel a notre librairie PEAR
set_include_path(get_include_path() . ";C:\wamp\php\PEAR\pear");

require_once 'DATE.php';
$now = new Date();

//UNIX timestamp:
echo $now->getTime().'<br/>';

//format de date iso
echo $now->getDate();

Et voilà, vous savez utiliser PEAR

Les layouts

Dans cet article, nous allons reprendre le code source du tutoriel précédent.

Pour éviter d’avoir à recopier les mêmes morceaux de code pour chaque page, il est important de bien savoir structurer nos pages (définir une entête,un corps, un pied de page …). Avec Zend cette organisation se fait à travers les layouts.

// setup controller
$frontController = Zend_Controller_Front::getInstance();
$frontController->throwExceptions(true);
$frontController->setControllerDirectory('./application/controllers');
// on définit le chemin des layouts
$aOptions = array(
    'layout'     => 'home',
    'layoutPath' => './application/layouts'
);
Zend_Layout::startMvc($aOptions);

Vous l’aurez compris, nous allons créer un dossier layouts dans notre dossier application où seront stockés nos layouts. Voici notre nouvelle arborescence :

layouts zend

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
<head>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
	<title><?php echo $this->title; ?></title>
</head>
<body>
<div id="content">
    <h1><?php echo $this->welcome; ?></h1>
    <?php echo $this->layout()->content; ?>
</div>
</body>
</html>

$this->layout()->content; sera le contenu de nos pages.

Nous allons retourner dans notre contrôleur principal.

class IndexController extends Zend_Controller_Action
{
    function indexAction()
    {
    	    $this->view->title = "Mes amis";
    	    $this->view->welcome = "Bienvenue";
    }

Le rendu n’est pas super, mais ça au moins le mérite de montrer que ça marche.

zend layout

La base de données avec Zend_Db

Pour se connecter à la base de données, il faut bien naturellement indiquer les identifiants de connexions.
Avec Zend, on passe par un fichier de configuration ini.

Zend_Loader::registerAutoload();
//on définit un nouvel objet de configuration
$oConfig = new Zend_Config_Ini('./application/config.ini', 'connexion');
// Mise en place de la BDD
$oDb = Zend_Db::factory($oConfig->db);
// on définit notre objet de base de données par défaut
Zend_Db_Table::setDefaultAdapter($oDb);

new Zend_Config_Ini(le chemin de notre fichier ini, la section concerner);

[connexion]
db.adapter = PDO_MYSQL
db.params.host = localhost
db.params.username = root
db.params.password =
db.params.dbname = zendfacile

Nous allons créer la base de donnée, voici la table :

CREATE TABLE ami (
id INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
nom VARCHAR( 255 ) NOT NULL ,
prenom VARCHAR( 255 ) NOT NULL
)

Les données :

INSERT INTO zendfacile.ami (id ,nom ,prenom)
VALUES (NULL , 'Laporte', 'Jean');

INSERT INTO zendfacile.ami (id ,nom ,prenom)
VALUES (NULL , 'LaPie', 'Marie');

Maintenant que notre base est faite, on va s’attaquer au code

class IndexController extends Zend_Controller_Action
{
    function indexAction()
    {
    	    $this->view->title = "Mes amis";
    	    $this->view->welcome = "Bienvenue";
    	    $oAmi = new Ami();
    	     $this->view->ami = $oAmi->fetchAll();
    }

$oAmi = new Ami();
va faire appel au modéle ami. On l’a pas créé ?
j’allais l’oublier

class Ami extends Zend_Db_Table
{
    protected $_name = 'ami';
}

On a plus qu’à afficher notre résultat :

<table>
<tr>
	<th>Nom</th>
	<th>Prenom</th>
	<th>&amp;amp;amp;amp;amp;nbsp;</th>
</tr>

<?php foreach($this->ami as $ami) : ?>
<tr>
	<td><?php echo $ami->nom;?></td>
	<td><?php echo $ami->prenom;?></td>

</tr>
<?php endforeach; ?>
</table>

C’est pas beau, mais on a ce que l’on a demandé :

Zend_Db

Voilà une première mise en bouche des possibilités de Zend, dans les prochains articles nous irons plus loin dans l’univers de ZEND.

Les demandes d’ajouts

Nous allons commencer par faire les demandes d’ajouts.

api facebook mode bac à sable

Aussi, je vous conseille aussi de créer un deuxième compte plutôt que piquer celui de votre sœur

Nous allons donc créer une page de demande d’ajout.

Voici ce que l’on va mettre, les explications sont juste en-dessous :

<!-- demande d'ajout -->
<fb:fbml>
<fb:request-form action="index.php" method="POST" invite="true" type=" De Malade " content="Je suis sur que je te bats facilement au quizz."
<?php echo htmlentities("<fb:req-choice url=\"http://apps.facebook.com/waanser/\" label=\"J'accepte le défis\"") ?>" >
<fb:multi-friend-selector showborder="false" actiontext="Défie tes amis !">
</fb:request-form>
</fb:fbml>

Voilà ce que ça va donner :

facebook demande d'ajouts

Même si c’est long, on va y aller pas à pas :

action = « index.php »

Une fois le formulaire validé, l’application va nous rediriger vers la page index.php

method = « POST »

Tout comme les formulaires traditionnels, c’est la méthode d’envoie des données (POST ou GET)

invite = « true »

Pour indiquer que le formulaire est une invitation

type =  » De Malade « 

C’est le texte qui va s’afficher à la fin de l’entête de l’invitation

content = « Je suis sur …

Le contenu du message

<fb:req-choice

C’est pour créer un bouton

url = « http://apps.facebook.com/waanser/ »

L’url que redirige la fenêtre

label = « J’accepte le défis »

Le message sur le bouton

<fb:multi-friend-selector

La fenêtre où l’utilisateur choisit les amis à défier

Eh oui, facebook nous laisse la possibilité de tout paramétrer

Les fils d’actualités

Publier les fils d’actualités, est une des fonction phare de facebook.

Pour créer ces fils d’actualités, il faut dans un premier temps créer et enregistrer les maquettes d’évènements.

Pour enregistrer les maquettes de fils d’actualités c’est par ici.
Vous avez reconnu ? C’est la page boîte à outil que facebook propose pour les développeurs.

api facebook

Vous avez la possibilité de faire 2 types d’actualités :

• les actualités standards
• les actualités sur une ligne

Comment créer une maquette

Vous tombez sur un panneau d’administration, c’est avec ça que l’on va faire notre fameuse maquette.

Là, c’est la structure de votre maquette :

facebook template

On le devine tout seul, cette partie c’est le rendu :

rendu maquette facebook

Et enfin, c’est un exemple de données que l’on va appliquer dans la structure :

maquette facebook

exemple maquette facebook

Pour mieux comprendre, nous allons décomposer le message :

donnée : rouge
structure : vert
Julien maitrise l’histoire à 65%

Il savoir que facebook appel les données dynamiques ; un jeton.

Pour indiquer les données dynamiques, nous allons utiliser cette syntaxe : {*nom du jeton*}
La maquette va ressembler à ça :
{*actor*} maitrise {*theme*} à {*points*} %

erreur prévualsisation maquette

En fait, votre maquette est bonne ! Mais pour que la prévisualisation se passe bien, il faut lui fournir un jeu de données.

Et là Miracle ! ça fonctionne

{*author*} est un jeton par défaut que facebook met d’office pour afficher le nom de l’utilisateur.

L’actualité courte permet d’afficher des médias comme les images :

Pour afficher les images, il faut continuer dans la partie : Exemple de données de modèle

Voici la syntaxe :

{« images »:[{"src":"url de li'mage", "href":"la cible du lien"}

Voici un exemple :

{"images":[{"src":"http://media.waanser.com/2009/05/genie.png", "href":"http://apps.facebook.com/waanser/"}

Créer un lien d'action

Étape très importante, parce que c'est le lien qui va renvoyer l'utilisateur vers notre application.

api facebook lien d'action

URL de lien d’action : l’adresse de redirection du lien.

api facebook lien d'action

Vous avez plus qu’à passer à l’étape suivante, puis à cliquer sur enregistre le lot de modèles.
Facebook va alors vous donner un bundle id

Il faut bien le conserver, vous en aurez bientôt besoin.

Utilisez la maquette dans votre application

Nous allons commencer avec l’exemple le plus simple, celui où il y a qu’une seule ligne.

{« content »: {« feed »: {« template_id »:identifiant de la maquette , « template_data »: {« nom du jeton 1″: »valeur du jeton 1″, »nom du jeton 2″: »valeur du jeton 2″} } }, « method »: »feedStory » }

{« content »: {« feed »: {« template_id »:43745522324, « template_data »: {« points »: »65″, »theme »: »l’histoire »} } }, « method »: »feedStory » }

Le php propose une librairie pour manipuler le json, nous allons en bénéficier pour faire un beau feed json
facilement paramétrable.

$arr = array(
'content' => array(
'feed' => array(
'template_id' => 43745522324,'template_data' => array(
'points' => '65', 'theme' => 'l\'histoire'
)
)
),'method' => 'feedStory'
);

echo json_encode($arr);

Notification

Nous allons voir comment générer des notifications, rassurez-vous, c’est beaucoup plus simple que les fils d’actualités

Voici la syntaxe :

$oFacebook->api_client->notifications_send(DESTINATAIRE, MESSAGE, TYPE);

• app_to_user => L’expéditeur c’est l’application
• app_to_user => L’expéditeur c’est l’utilisateur enregistré r

Voici un exemple d’utilisation :

$oFacebook->api_client->notifications_send($iUid, 'some info', 'user_to_user');
$oFacebook->api_client->notifications_send($iUid, 'some info', 'app_to_user');

Le rendu :

api facebook notification

Et voilà vous avez tous les outils en main pour propager votre application.

Bonne propagation

Installation

Nous allons télécharger WampServeur, CodeIgniter et Smarty.

Pour WampServeur, suivez les instructions d’installation.
Pour CodeIgniter et Smarty il suffit de dezipper les fichiers.

Dans WampServeur nous allons créer notre dossier de base de notre site
C:/wamp/www/tutorielwaanser

Intégration de Smarty

Dans le fichier index.php ajouter la constante : WEBSITE_PATH

if (strpos($system_folder, '/') === FALSE) {

if (function_exists('realpath') AND @realpath(dirname(__FILE__)) !== FALSE)
{
$system_folder = realpath(dirname(__FILE__)).'/'.$system_folder;
}
} else {
// Swap directory separators to Unix style for consistency
$system_folder = str_replace("\\", "/", $system_folder);
}

define('WEBSITE_PATH', realpath(dirname(__FILE__)).'/'.$application_folder );

Dans le fichier system/application/config/config.php modifier la variable :

$config['subclass_prefix'] = 'WAANSER_';

Créer les arborescences suivantes :
- system/smarty/libs et copier  les dossiers Internals et plugins de Smarty

system/application/smarty/plugins
system/application/smarty/tpl

system/application/tmp/smarty/cache
system/application/tmp/smarty/templates_c

Renommer le fichier Smarty.class.php en Smarty.php
Copier les fichier Smarty.php, Smarty_Compiler.class.php et Config_File.class.php dans le dossier system/libraries

//  ******* Smarty ********
define('DIR_SEP', DIRECTORY_SEPARATOR);
define('SMARTY_DIR', BASEPATH.'smarty'.DIRECTORY_SEPARATOR);
define('SMARTY_CORE_DIR', BASEPATH.'smarty/libs/internals' . DIRECTORY_SEPARATOR);

define('SMARTY_PHP_PASSTHRU',   0);
define('SMARTY_PHP_QUOTE',      1);
define('SMARTY_PHP_REMOVE',     2);
define('SMARTY_PHP_ALLOW',      3);

Ensuite nous devons créer les libraries WAANSER_controller et WAANSER_smarty dans le dossier system\application\libraries

class WAANSER_Controller extends Controller {

/**
* @desc	for template
* @var 	obj smarty
*/
public $oMySmarty = null;

public function Controller() {

parent::Controller();

$this->loadSmarty();
}

public function loadSmarty() {

$this->oMySmarty = &load_class('Smarty');
}

}

Ce fichier va nous permettre d’étendre le contrôleur d’origine, pour récupérer tous le processus de chargement des classes, et nous ajoutons un attribut $oMySmarty qui sera un objet de la classe Smarty.

Avec cet objet on pourra changer de générateur de template.
On peut, même si c’est moche   utiliser le générateur de templates par défaut en même temps que le générateur Smarty.

class WAANSER_Smarty extends Smarty {

/**
* @desc	class constructor
* @version	1.0.0
* @date	20090307
*/
public function __construct() {

parent::Smarty();
$this->setParams();
}

/**
* @desc 	initialise les variables pour smarty
* @version 1.0.0
* @date	20090307
*/

public function setParams() {
$this->template_dir = APPPATH.'smarty/tpl';
$this->compile_dir = APPPATH.'tmp/smarty/templates_c';
$this->plugins_dir = array(APPPATH.'smarty/libs/plugins', APPPATH.'smarty/plugins');
}

}

?>

Il nous reste a changer le fichier welcome dans le dossier system\application\controllers, il suffit juste de changer l’appel au fichier parent.

class Welcome extends WAANSER_Controller {

function Welcome()
{
parent::Controller();
}

function index()
{
$this->oMySmarty->assign('TEST_WAANSER', 'Smarty est OK');
$this->oMySmarty->display('welcome.tpl');
//$this->load->view('welcome_message');
}
}

Et de lui ajouter une variable avec la methode assign et de lui indiquer le template a afficher avec la methode display.

Ensuite ajouter le fichier welcome.tpl dans le dossier system\application\smarty\tpl

<p>{$TEST_WAANSER}</p>

Au prochain Tuto

Ce qu’il faut

Si vous le savez pas, il faut php5 et activé le module_rewrite

zend

Et on télécharge la dernière version.

On va créer notre dossier zenfacile où seront enregistrées les pages. Dans ce dossier on va créer un dossier Zend. Dans ce dossier on va mettre la librairie Zend.

Arborescence

L’arborescence de notre site va suivre une structure MVC traditionnel :

Comme on va faire de la réécriture d’url, on va ajouter un fichier .htaccess

# Règles de réécriture pour Zend Framework
RewriteEngine on
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule .* index.php

# Sécurité : Ne pas autoriser le parcours de répertoires
Options -Indexes

# Configuration PHP
php_flag magic_quotes_gpc off
php_flag register_globals off
php_flag short_open_tag on

voici le fichier .htaccess

Maintenant tout est prêt, on va pouvoir s’attaquer au php.
(eh oui ça va très vite on y va pas avec de la dentelle)

On va commencer par l’index.php

On va pas se précipiter, on va déjà voir si la librairie est bien chargé :

error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', 1);
date_default_timezone_set('Europe/Paris');

// mise en place des répertoires et chargement des classes
set_include_path('.'
    . PATH_SEPARATOR . './library'
    . PATH_SEPARATOR . './application/models/'
    . PATH_SEPARATOR . get_include_path());
include "Zend/Loader.php";

echo 'salut Zend !';

Le message salut Zend ! devrait s’afficher sur cette page :http://localhost/zenfacile

C’est bon ?

Voici ce que l’on va mettre :

<?php

error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', 1);
date_default_timezone_set('Europe/Paris');

// mise en place des répertoires et chargement des classes
set_include_path('.'
    . PATH_SEPARATOR . './library'
    . PATH_SEPARATOR . './application/models/'
    . PATH_SEPARATOR . get_include_path());
include "Zend/Loader.php";

Zend_Loader::registerAutoload();

// setup controller
$frontController = Zend_Controller_Front::getInstance();
$frontController->throwExceptions(true);
$frontController->setControllerDirectory('./application/controllers');

// run!
$frontController->dispatch();
?>

Normalement vous avez une belle fatal erreur :

Pas de panique c’est normal . Par défaut Zend recherche le contrôleur Index.

Et comme il n’existe pas, Zend nous génère une erreur.

Strucuture MVC

On va créer ce controleur :

Le nom de la classe doit forcément ce terminer par Controller

class IndexController extends Zend_Controller_Action
{
    function indexAction()
    {
    	 $this->view->title = "Mon Zend";
    }
}

Il faut savoir que dans chaque controleur il y a des actions (qui est en fait des méthodes de la classe).
Ces méthodes actions doivent se terminer par Action.
Ainsi pour l’action Index la méthode l’appellera indexAction.

L’objet $this->view est l’objet qui manipule la vue.

Comme vous l’avez remarquez notre classe hérite de Zend_Controller_Action.

Comment fait-on pour retrouver cette classe ?

Facile ! On remplace les _ par les / . Et voilà, on a l’arborescence et le nom de la classe.
Pour Zend_Controller_Action la classe se situeras dans :
Zend => Controller =>Action.php

La vue

Pour la vue, il faut aller dans le dossier views créer un dossier scripts.
Un fois ceci fait nous allons créer un dossier qui porte le nom du contrôleur. Le nom de notre vue sera alors index.

Le nom de la vue doit être le nom de l’action, son nom sera alors index.phtml

<html>
<head>
	<title><?php echo $this->escape($this->title); ?></title>
</head>
<body>
	<h1><?php echo $this->escape($this->title); ?></h1>
</body>
</html>

et là on rafraichit

on voit le message ! c’est que ça marche \o/

Pour la réécriture d’url zend fait vraiment simple. c’est http://lenomdusite/controleur/action.
On va créer une autre page, une page contact (elle aussi sera toute simple)

    function contactAction()
    {
    	 $this->view->title = "Contact";
    }

Avec une vue identique :

<html>
<head>
	<title><?php echo $this->escape($this->title); ?></title>
</head>
<body>
	<h1><?php echo $this->escape($this->title); ?></h1>
</body>
</html>

Pour y accéder ça sera : http://localhost/zenfacile/index/contact

Et voila notre Zend est installé, pour ne pas trop alourdir le tutoriel, j’ai fait l’impasse sur des notions importantes comme le MVC, si vous avez des questions n’hésitez pas à poster un commentaire.

Voici le dossier complet : zenfacile

Les statistiques avec la table Metrics

Si vous voulez vendre de la publicité dans votre site, ou tout simplement connaitre le traffic de votre gadget il essentiel de connaitre les statiques. Ces informations se trouvent dans la table Metrics.

Les statistiques se font sur une portion de temps. (ex : du 01/02/2009 au 01/03/2009).
Pour définir cette portion de temps à notre table Metrics, il faut définir 2 champs ; end_time et period .

end_time : la date de début de votre portion en timestamp
period : la durée en seconde de votre portion.

active_users : le nombre d’utilisateur unique
canvas_page_views : le nombre de page vue
unique_adds : le nombre de fois que votre application à été ajoutée.
unique_removes : le nombre de fois que votre application à été enlevée.
unique_blocks : le nombre de fois que votre application à été bloquée.
unique_unblocks : le nombre de fois que votre application à été débloquée.

C’est compliqué ? Je vais vous montrez un exemple.

$iTime = mktime(9, 0, 0, date('m')-1, date('d'), date('Y')); // il ya 1 moi en timestamp
$sQuery = 'SELECT end_time, period, active_users, canvas_page_views  FROM metrics WHERE end_time ='.$iTime.' AND period = 2592000';
$aStatInformation = $oFacebook->api_client->fql_query($sQuery);
// un affichage bête et méchant
echo'<pre>';
var_dump($aStatInformation);
echo'</pre>';

fql

Vous avez remarquez que l’on a pas récupérer ces quatre données unique_adds, unique_removes, unique_blocks, unique_unblocks.

C’est parce que facebook nous complique la tache.
En effet si on veut récupérer ces données il faut que la portion de temps soit d’un jour (et non d’un mois).
Pour récupérer ces données pour un mois on va faire un script à part :

$iDay = 1;// jour 1
$aResult = array('unique_adds' => 0,'unique_removes' => 0,'unique_blocks' => 0,'unique_unblocks' => 0);
while($iDay<31) // pour un mois
{	// on convertit notre date en time stamp
	$iTime = mktime(9, 0, 0, date('m'), date('d')-$iDay, date('Y'));
	$sQuery = 'SELECT unique_adds, unique_removes, unique_blocks, unique_unblocks  FROM metrics WHERE end_time ='.$iTime.' AND period = 86400';
	$aStatInformation = $oFacebook->api_client->fql_query($sQuery);
	if (is_array($aStatInformation)){//  on sotcke les infos
		foreach($aStatInformation[0] as $iKey => $iVal)
		{
			$aResult[$iKey]+=(int)$iVal;
		}
	}
	$iDay++;
}
// on affiche le résultat
echo'<pre>';
var_dump($aResult);
echo'</pre>';

Cibler les utilisateurs avec les tables fan et groups

Cibler les utilisateurs et un atout essentiel si vous voulez optimiser le rendement de vos pubs.
La table fan permet de savoir quel page l’utilisateur est fan.


Voici comment faire pour récupérer ces pages. (biensur on a besoin de l’id utilisateur)

//on récupère l'id de l'utilisateur
$sUser_id = $oFacebook->user;
//récupérer les id des pages
$sQuery = 'SELECT page_id, type FROM page_fan	 WHERE uid=' . $sUser_id.;
$aUserInformation = $oFacebook->api_client->fql_query($sQuery);

Les ids des pages nous parlent pas beaucoup. Mais ce n’est pas un problème, on va utiliser une autre table
pour récupérer les informations de ces pages.
La table page est une des plus grosses tables de facebook, voici ça structure.

Dans cet exemple nous allons récupérez l’essentiel (le nom, l’image représentative,le type, les informations générales et le nombre de page)

//on récupère l'id de l'utilisateur
$sUser_id = $oFacebook->user;

//on récupère les informations importantes
$sQuery = 'SELECT name, pic, type, website, general_info,  fan_count from, website page where page_id IN (SELECT page_id, type FROM page_fan	 WHERE uid=' . $sUser_id.')';  

$aUserInformation = $oFacebook->api_client->fql_query($sQuery);

Rien de particulier sur cette table, on y accède de la même manière que pour la page fan :

//on récupère l'id de l'utilisateur
$sUser_id = $oFacebook->user;

// on récupère les informations du groupe
$sQuery = 'SELECT name, pic, description, group_type, group_subtype, website from group where gid IN (SELECT gid FROM group_member WHERE uid=' . $sUser_id.')';  

$aUserInformation = $oFacebook->api_client->fql_query($sQuery);

Les permissions avec la table Permissions

Comme son nom l’indique, la table permissions va nous dire ce que notre gadget peut ou pas faire.
Dans cette table ce qui va nous intéresser, c’est de savoir si on peut leur envoyer des sms ou des mails.
ps : si on a l’autorisation, ce n’est pas une bonne raison pour faire du spam

Voici la requête :

//on récupère l'id de l'utilisateur
$sUser_id = $oFacebook->user;

// les permissions pour l'envoi de mail et de sms
$sQuery = 'SELECT email, sms FROM permissions WHERE uid=' . $sUser_id;  

$aUserInformation = $oFacebook->api_client->fql_query($sQuery);

Pour avoir la permission il faut utiliser le fbml. plus précisément la balise <fb:prompt-permission>

L’attribut perms est obligatoir puisque c’est lui qui va définir quelle autorisation à accorder. (pour nous ça sera sms et mail)

<fb:prompt-permission perms="email">Autorisez vous l'application a envoyez des mails</fb:prompt-permission>

Si l’utilisateur clique sur le lien, une fenêtre devrait apparaître :

apifacebook

Voila nous avons fait le tour des données clé de l’api facebook. A travers ces exemples on a pu voir le fonctionnement de la base de données facebook. Comme je vous l’ai déjà dit, chaque donnée a son utilité, et c’est en fonction de vos projet que vous allez devoir choisir les données à récupérer. Le choix des données est une étape très importante, parce que vous pouvez manquez une information importantes ou alourdir votre base pour rien (à l’échelle de milliers d’utilisateurs, cela peut venir vite une catastrophe).

FirePHP qu’est ce que c’est ?

Tout d’abord FirePHP est un plugin firefox, qui s’attache à celui de firebug.
Les données de debug sont représentées de cette façon :

C’est à l’aide d’une classe php, que l’on va définir les données de debug à afficher.
Et c’est cette classe php, qui envoie ces données au format JSON.
Pour finir le plugin s’occupe d’afficher les données.

Passons maintenant à la pratique .

Installation

Si vous ne l’avez pas fait , il faut installer firebug,une fois ceci fait, vous pouvez installer le plugin firephp.

Maintenant nous allons récupérer la dernière version de la librairie .

Nous allons voir si firePHP fonctionne :

require_once './FirePHPCore/FirePHP.class.php';
$oFirebug = FirePHP::getInstance(true);
$oFirebug->fb('FirePhp fonctionne !');

Voilà ce que cela doit donner :

Si vous ne voyez rien, c’est que vous avez oublié d’activer la surveillance réseau de votre firebug:

Utilisation de firePhp

Avant toute chose, il faut bien avoir en tête que ces données sont visibles par tous les visiteurs qui possèdent firePHP. Il est préférable d’afficher les données dans un environnement de développement ou de test.

Normalement avec l’exemple de fonctionnement vous avez déjà du tout comprendre

$oFirebug = FirePHP::getInstance(true);
c’est notre objet firebug.
$f->fb(‘FirePhp fonctionne !’);
pour afficher un message.

Grouper les variables de debug

Vous pouvez regroupez vos variables de debug avec Firephp. Cela peut être utile si vos tests se font sur plusieurs fonctions.

$oFirebug->group('Fonction animal');
$oFirebug->log('Chien');
$oFirebug->log('Chat');
$oFirebug->log('Poisson');
$oFirebug->groupEnd();

$oFirebug->group('Fonction ville');
$oFirebug->log('Lens');
$oFirebug->log('Rennes');
$oFirebug->log('Caen');
$oFirebug->groupEnd();

Voilà ce que ça donne :

Définir des niveaux d’erreurs

Tout comme l’objet error_reporting de php, avec firePHP on peux définir un niveau d’erreur.

méthode info : ressemble au notice
méthode warn : ressemble au warning
méthode error : ressemble au fatal error

$oFirebug->log('Plain Message');     // or FB::
$oFirebug->info('Info Message');     // or FB::
$oFirebug->warn('Warn Message');     // or FB::
$oFirebug->error('Error Message');   // or FB::

Firebug va donc afficher :

Afficher les tableaux

C’est avec la méthode table() que l’on va pouvoir afficher les tableaux avec FirePHP

Voici un exemple de code :

$aTable   = array();
$aTable[] = array('Col 1 Heading','Col 2 Heading');
$aTable[] = array('Row 1 Col 1','Row 1 Col 2');
$aTable[] = array('Row 2 Col 1','Row 2 Col 2');
$aTable[] = array('Row 3 Col 1','Row 3 Col 2');

$oFirebug->table('Table Label', $aTable)

Cela donne :

Laissez des traces avec trace()

Affiche un bascktrace de la ligne ou est tapée la méthode trace().

Voici un exemple d’utilisation:

mess($oFirebug);
function mess($oFirebug)
{
 $oFirebug->trace('Trace Label');
}

Firephp va afficher :

Attraper les erreurs avec firePhp

On peut aussi gérer l’affichage des erreurs par firePhp

$oFirebug->registerErrorHandler();
$oFirebug->registerExceptionHandler();

try {
  throw new Exception('Test erreur');
} catch(Exception $e) {
  $oFirebug->error($e);
}

Et voila notre belle erreur

On a fait le tour de firePhp, vous pouvez maintenant debugger en toute transparence.

Dans ce tutoriel, il est nécessaire d’avoir des bases en SQL.

Le FQL qu’es-ce ce que c’est ?

On pourrait dire que le FQL c’est le SQL de facebook. Mais en fait, bien qu’il ressemble au sql il n’en est rien, parce que le FQL
est interprété et traité (par l’API facebook).

Oui, pour nous, ça change rien ?

Contrairement au SQL, on ne peut pas modifier les données (UPDATE,DELETE,UPDATE).
De plus il est évident que facebook nous ne donne pas la possibilité de récupérer toute sa base de données.(il est pas fou facebook:)) Il faut forcément un identifiant (d’une personne, un groupe …) pour accéder aux informations.

Ne vous inquiéter pas si le FQL ne vous paraît pas clair, avec quelques exemples vous comprendrez tout de suite ce que je veux dire .

Notre première requête FQL

Déjà on va se connecter à notre API.

// on charge la librairie facebook
require_once 'lib-facebook/facebook.php';

// on définit la clé et le code secret
$sAppapikey = CLE;
$sAppsecret = CODE SECRET;

// on se connecte à facebook par la création d'un objet Facebook
$oFacebook = new Facebook($sAppapikey, $sAppsecret);

// on demande à l'utilisateur de se loguer
$oFacebook->require_login();

//on récupère l'id de l'utilisateur
$sUser_id = $oFacebook->user;

On va pas faire compliquer pour notre première requête FQL, on va juste récupérer les informations principales de
l’utilisateur en cours. C’est à dire son nom, prénom, date de naissance,sexe,photo.

//notre requête FQL
$sQuery = 'SELECT first_name,last_name,birthday,sex,pic_big FROM user WHERE uid=' . $sUser_id;  

// information de notre utilisateur
$aUserInformation = $oFacebook->api_client->fql_query($sQuery);

Comme vous le voyez nous avons interrogé la table user pour récupérer les informations de l’utilisateur en cours.

Par défaut le résultat retourné est sous forme de tableau.

fql

Maintenant c’est pas compliqué pour mettre tout ça en forme

// affichage des données
echo '<h1>Mes informations</h1><br/>';
echo 'nom : '.$aUserInformation[0]['last_name'].'<br/>';
echo 'prenom : '.$aUserInformation[0]['first_name'].'<br/>';
echo 'date de naissance : '.$aUserInformation[0]['birthday'].'<br/>';
echo 'sexe : '.$aUserInformation[0]['sex'].'<br/>';
echo 'photo :<br/> <img src=\''.$aUserInformation[0]['pic_big'].'\'/>';

Voila ce que ça donne :

fql

Voila nous avons fait notre première requête. On va pouvoir savoir tout sur nos utilisateurs :p.

Stocker ces informations sur une base de données:

Il est toujours intéressant de stocker les informations sur une base de données. Il est bien important d’optimiser
votre base en fonction de votre application (et non de la base facebook).
Par exemple pour le sexe plutôt que stocker male ou female, il est plus intéressant de stocker 2 id différents qui feront référence à une table.
Si vous stockez les informations de facebook pour être en toute légalité, n’oubliez pas de faire un tour à la cnil pour faire une déclaration de fichier.

La base de données Facebook

Vous pouvez avoir toute la structure de la base de données facebook sur la documentation.Hélas elle n’est qu’en anglais

Actuellement il y a 23 tables que l’ont peut interroger. Cela fait une quantité astronomique de données que l’on peut récupérer.
Il est essentiel de bien comprendre l’utilité de chaque table et surtout de savoir faire le tri entre toutes ses données.

note sur la documentation : en FQL il est nécessaire d’utiliser un critère (clause WHERE)
sur un élément marqué par une étoile « * ».

fql

Dans cette exemple, pour récupérer les information d’un utilisateur on a besoin forcément de son uid ou de son name.

Bon si vous n’êtes pas motivé pour éplucher toute la doc, très prochainement un tutoriel sur les données clés de facebook va voir le jour.

En attentant vous pouvez toujours poster un commentaire pour une remarque ou une interrogation.

Création du formulaire

Pour créer notre formulaire, nous allons faire appel au helper (form).

Un helper est une librairie de code igniter.

Dans le controleur ecoleCtr, nous allons charger la vue ajoutEleve.

    public function __construct()
    {
        parent::__construct();
        $this->load->helper('form');
    }
    public function ajoutEleve()
    {
		$this->load->view('ajoutEleve');
    }

Maintenant dans la vue ajoutEleve nous allons utiliser la commande form_open pour construire le formulaire.

la synthaxe : form_open(méthode du contrôleur où seront envoyées les données du formulaire);

Pour nous ça va être :

<?=form_open('ecoleCtr/insertEleve');?>

<p>nom : <input type="text" name="nom"/></p>
<p>prenom : <input type="text" name="prenom"/></p>
<p><input type="submit" value="envoyer"/></p>

Attention les noms de champs doivent être les même que ceux de la base.
Cela va permettre d’insérer les données dans la base plus facilement.

Envoi et traitement des données

Stocker les données avec Code Ingiter se fait très rapidement

On va utiliser la méthode insert de la librairie db.

    public function insertEleve()
    {
		$this->db->insert('user',$_POST);
    }

Un fois que vous validez votre formulaire si vous tombez sur cette adresse :

http://example.com/index.php/eleveCtr/eleve_insert

C’est que vous avez oublier comme moi de remplir :

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

dans system-> application -> config -> config.php

Redirection

On va rediriger notre utilisateur à la page où il y a la liste d’élève.

Avec Code Igniter pour faire des redirections on a besoin du helper url

       $this->load->helper('url');

La méthode redirect(chemin,type); s’occupe de la redirection.

Pour nous ça sera :

redirect('/ecoleCtr/listeEleve', 'refresh');

Modification Update avec CI

Maintenant que nous savons insérer des données nous allons apprendre à les modifier

Retournons dans notre vue listeEleve.php

ecole -> system -> application -> views-> listeEleve.php

Pour chaque élève, on va ajouter un lien vers un formulaire pour modifier les informations de cet élève.

Les liens avec anchor

La syntaxe n’est pas compliqué anchor(url,texte)

Donc dans notre exemple nous allons rediriger vers la méthode modifEleve de ecoleCtr;

<td><?=anchor('ecoleCtr/modifEleve/'.$oEleve->id, 'Modifier');?></td>

Rendez vous dans le modèle

ecole -> system -> application -> models -> ecoleMod.php

On va modifier notre fonction :

    public function getEnfant($aRestriction = null)
    {
    	if (is_array($aRestriction))
    	{
	    	foreach ($aRestriction as $sKey => $sValue)
	    	{
	    		$this->db->where($sKey, $sValue);
	    	}
    	}
    	$oEleve=$this->db->get('eleve');
    	return $oEleve->result();
    }

La clause $this->db->where

La clause $this->db->where va nous permettre de créer nos requête de projections.
Le premier paramètre est l’attribut de la table et le second est la valeur.
Par exemple :
$oEleve=$this->db->get(‘eleve’);
$this->db->where(‘nom’, ‘paul’);

donnera SELECT * FROM eleve WHERE nom = paul

On s’est occupé du modèle, on va pouvoir redescendre au contrôleur .
Bon là rien de nouveau :

    public function modifEleve()
    {
    	$this->load->model('ecoleMod');
    	$iIdEleve = $this->uri->segment(3);
		$aEleve = $this->ecoleMod->getEnfant(array('id'=>$iIdEleve));
		$aData['nom'] = $aEleve[0]->nom;
		$aData['prenom'] = $aEleve[0]->prenom;
		$aData['id'] = $aEleve[0]->id;
		$this->load->view('modifEleve',$aData);
    }

Pareil pour la vue modifEleve, on est sur du terrain connu

<html>
<body>
<h1>Modification d'un eleve</h1>

<?=form_open('ecoleCtr/updateEleve/'.$id);?>

<p>nom : <input type="text" name="nom" value ="<?=$nom?>"/></p>
<p>prenom : <input type="text" name="prenom" value ="<?=$prenom?>"/></p>
<p><input type="submit" value="envoyer"/></p>

</body>
</html>

La clause $this->db->update

pour faire un update avec un code igniter on a besoin de la méthodewhere et update.

$this->db->where(attribut,valeur)

Faites bien attention à cette méthode, une erreur et Code Igniter modifie tous les champs de la table.
(et oui ça m’est arrivé ^^)

$this->db->update(table,valeurs)

Notre méthode updateEleve va ressembler à ça :

    public function updateEleve()
    {
    	$this->db->where('id', $this->uri->segment(3));
		$this->db->update('eleve',$_POST);
		 redirect('/ecoleCtr/listeEleve', 'refresh');
    }

Voila ce tutoriel est terminé, votre base de données n’a plus qu’à bien se tenir.