357 lines
13 KiB
PHP
357 lines
13 KiB
PHP
<?php
|
||
/*************************************************************************************/
|
||
/* */
|
||
/* Thelia */
|
||
/* */
|
||
/* Copyright (c) 2005-2013 OpenStudio */
|
||
/* email : info@thelia.fr */
|
||
/* web : http://www.thelia.net */
|
||
/* */
|
||
/* This program is free software; you can redistribute it and/or modify */
|
||
/* it under the terms of the GNU General Public License as published by */
|
||
/* the Free Software Foundation; either version 3 of the License */
|
||
/* */
|
||
/* This program is distributed in the hope that it will be useful, */
|
||
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
|
||
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
|
||
/* GNU General Public License for more details. */
|
||
/* */
|
||
/* You should have received a copy of the GNU General Public License */
|
||
/* along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
/* */
|
||
/*************************************************************************************/
|
||
|
||
require_once __DIR__ . "/../../fonctions/autoload.php";
|
||
|
||
class BoucleSimple extends PexElement{
|
||
public $nom;
|
||
public $args;
|
||
public $contenu;
|
||
public $est_vide;
|
||
public $variables;
|
||
|
||
private $compteur = 1;
|
||
|
||
function __construct($nom)
|
||
{
|
||
$this->nom = $nom;
|
||
|
||
$this->modules = null;
|
||
$this->est_vide = true;
|
||
$this->variables = array();
|
||
}
|
||
|
||
function type()
|
||
{
|
||
return PexToken::TYPE_BOUCLE_SIMPLE;
|
||
}
|
||
|
||
function set_args($args)
|
||
{
|
||
$this->args = $args;
|
||
|
||
$type_boucle = ucfirst(strtolower(lireTag($args, 'type')));
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug($this->nom, ": $type_boucle"); }
|
||
}
|
||
|
||
function ajouter($data)
|
||
{
|
||
$this->contenu = $data;
|
||
}
|
||
|
||
// Evaluer la boucle en utilisant la fonction classique
|
||
function evaluer_boucle_classique($type_boucle, $args)
|
||
{
|
||
$var_template = '';
|
||
|
||
$this->compteur = 1;
|
||
|
||
// HACK: Si la liste des variables contient une variable conditionelle, assurer le traitement
|
||
// de ces variables. Voir aussi la methode replace() de la classe PexElement
|
||
foreach(Parseur::$VARIABLES_CONDITIONNELLES as $varcond)
|
||
{
|
||
if (in_array($varcond, $this->variables))
|
||
{
|
||
if ($var_template != '') $var_template .= PexToken::COUPLE_SEP;
|
||
|
||
$var_template .= '__VARCOND__'.$varcond.'__' . PexToken::ASSIGN_SEP . '#' . $varcond . '[1][0]';
|
||
}
|
||
}
|
||
|
||
usort($this->variables, array("Analyse", "strlen_cmp"));
|
||
|
||
foreach($this->variables as $var)
|
||
{
|
||
if ($var_template != '') $var_template .= PexToken::COUPLE_SEP;
|
||
|
||
$var_template .= $var . PexToken::ASSIGN_SEP . '#' . $var;
|
||
}
|
||
|
||
// PexToken::START_MARK permet de déterminer si la boucle modifie ou remplace le texte
|
||
// indiqué dans la boucle (plugin notation et commentaires)
|
||
$var_template = PexToken::START_MARK . $var_template . PexToken::ITER_SEP;
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("appel boucle exec $type_boucle, args='$args', var_template='$var_template'");}
|
||
|
||
// Appel du boucle_exec() de base de Thélia
|
||
$valued_text = $this->boucle_exec(strtoupper($type_boucle), $args, $var_template);
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("$this->nom: valued template='$valued_text'"); }
|
||
|
||
if (trim($valued_text) != '')
|
||
{
|
||
$boucle_subst = new EvalBoucle();
|
||
|
||
// Parse $texte to extract substitutions
|
||
$rows = explode(PexToken::ITER_SEP, $valued_text);
|
||
|
||
// Compter le nombre de resultats
|
||
$nbres = count($rows);
|
||
foreach($rows as $row) if ($row == '') $nbres--;
|
||
|
||
foreach($rows as $row)
|
||
{
|
||
if ($row == '') continue;
|
||
|
||
$iteration = new IterationBoucle();
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("row: '$row'"); }
|
||
|
||
if ($row[0] != PexToken::START_MARK)
|
||
{
|
||
$start_pos = strpos($row, PexToken::START_MARK);
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("Start mark at pos '$start_pos'"); }
|
||
|
||
if ($start_pos === false)
|
||
{
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("Texte remplacé par '$row'"); }
|
||
|
||
$iteration->remplacement = $row;
|
||
|
||
$boucle_subst->ajoutIteration($iteration);
|
||
|
||
// On n'examine pas la suite
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("Texte modifié. prefixe: ".substr($row, 0, $start_pos)); }
|
||
|
||
// Retenir le prefixe, qui sera ajouté lors des substitutions
|
||
$iteration->prefixe = substr($row, 0, $start_pos);
|
||
|
||
// Continuer , et examiner le reste.
|
||
$row = substr($row, $start_pos + 1);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Enlever la marque de début
|
||
$row = substr($row, 1);
|
||
|
||
// S'il ne reste plus rien, on ne va pas plus loin, ça ne sert à rien.
|
||
// if ($row == '') continue;
|
||
}
|
||
|
||
$vars = explode(PexToken::COUPLE_SEP, $row);
|
||
|
||
$line_vars = array();
|
||
|
||
foreach($vars as $varval)
|
||
{
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("varval: '$varval'"); }
|
||
|
||
list($var, $value) = explode(PexToken::ASSIGN_SEP, $varval);
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("$var=$value"); }
|
||
|
||
$iteration->ajoutVarVal($var, $value);
|
||
}
|
||
|
||
// Ajouter le compteur
|
||
$iteration->ajoutVarVal('__COMPTEUR__', $this->compteur++);
|
||
|
||
// Ajouter le nombre de resultats total
|
||
$iteration->ajoutVarVal('__NOMBRE__', $nbres);
|
||
|
||
$boucle_subst->ajoutIteration($iteration);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// la boucle est vide
|
||
$boucle_subst = false;
|
||
}
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("type_boucle=$type_boucle: boucle_subst: ",$boucle_subst, $boucle_subst === false ? 'FALSE' : ''); }
|
||
|
||
return $boucle_subst;
|
||
}
|
||
|
||
function evaluer(&$substitutions = array())
|
||
{
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("Eval boucle simple $this->nom"); }
|
||
|
||
// Bug signalé par tetedelard
|
||
// Réinitialiser l'état (la boucle peut-être placée dans une boucle qui implique des iterations,
|
||
// et influe sur les paramètres de cette boucle, et donc sur ses résultats.
|
||
$this->est_vide = true;
|
||
|
||
$val = '';
|
||
|
||
// Effectuer les substitutions dans les arguments de la boucle a exécuter
|
||
// avec les valeurs de la présente boucle.
|
||
$args = $this->replace($substitutions, $this->args);
|
||
|
||
/*
|
||
if (DEBUG_EVAL) {
|
||
Analyse::echo_debug("Eval boucle simple $this->nom, args=$this->args, subst_args=$args, Substitutions: \n",
|
||
$substitutions,
|
||
'variables:,
|
||
$this->variables);
|
||
}
|
||
*/
|
||
$type_boucle = ucfirst(strtolower(lireTag($args, 'type')));
|
||
|
||
$boucle_subst = $this->evaluer_boucle_classique($type_boucle, $args);
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("Eval boucle simple $this->nom, subst: ",$boucle_subst === false ? 'FALSE' : $boucle_subst, " est vide: ",$this->est_vide === false ? 'FALSE' : "TRUE"); }
|
||
|
||
if ($boucle_subst !== false)
|
||
{
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("Boucle simple $this->nom n'est plus vide."); }
|
||
|
||
// Si boucle_subst es définie, alors la boucle n'est pas vide.
|
||
$this->est_vide = false;
|
||
|
||
// Evaluer la présente boucle.
|
||
foreach($boucle_subst->iterations as $iteration)
|
||
{
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("eval: type=".$this->contenu->type()."\nsubst: ", $iteration, "\ncontenu: "); $this->contenu->imprimer();}
|
||
|
||
if ($iteration->prefixe !== false)
|
||
{
|
||
// La boucle a place quelque chose avant le texte.
|
||
// On l'ajoute nous aussi.
|
||
$val .= $iteration->prefixe;
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("eval: prefixe=$iteration->prefixe"); }
|
||
}
|
||
|
||
if ($iteration->remplacement !== false)
|
||
{
|
||
// La boucle a remplacé le texte qu'on lui a passé par un autre
|
||
// -> on retourne simplement ce texte, sans faire d'autres évaluations
|
||
$val .= $iteration->remplacement;
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("eval: remplacement=$iteration->remplacement"); }
|
||
}
|
||
else
|
||
{
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("eval: evaluation contenu"); }
|
||
|
||
$val .= $this->contenu->evaluer($iteration->varval);
|
||
}
|
||
}
|
||
|
||
// Si la boucle n'est pas vide, mais n'a retourné aucune itération,
|
||
// il faut tout de même évaluer son contenu.
|
||
// FIXME: retiré, car on ajoute toujours une iteration par tour de boucle
|
||
// cf. ajoutIteration()
|
||
// if (count($boucle_subst->iterations) == 0) $val .= $this->contenu->evaluer();
|
||
}
|
||
|
||
if (DEBUG_EVAL) { Analyse::echo_debug("boucle=$type_boucle vide:", $this->est_vide ? "Oui" : "Non"); }
|
||
|
||
return $val;
|
||
}
|
||
|
||
function boucle_exec($type_boucle, $args, $texte, $nom_boucle = ""){
|
||
|
||
global $page;
|
||
|
||
$variables="";
|
||
$res = "";
|
||
|
||
$exec_boucle = 1;
|
||
|
||
//$param = array(&$type_boucle, &$args, &$texte, &$nom_boucle, &$exec_boucle);
|
||
//ActionsModules::instance()->appel_module( "avantboucle", $param);
|
||
|
||
if($exec_boucle)
|
||
switch($type_boucle){
|
||
case 'RUBRIQUE' : $res .= boucleRubrique($texte, $args); break;
|
||
case 'DOSSIER' : $res .= boucleDossier($texte, $args); break;
|
||
case 'CONTENU' : $res .= boucleContenu($texte, $args); break;
|
||
case 'CONTENUASSOC' : $res .= boucleContenuassoc($texte, $args); break;
|
||
case 'PRODUIT' : $res .= boucleProduit($texte, $args); break;
|
||
case 'PAGE' : $res .= bouclePage($texte, $args); break;
|
||
case 'PANIER' : $res .= bouclePanier($texte, $args); break;
|
||
case 'QUANTITE' : $res .= boucleQuantite($texte, $args); break;
|
||
case 'CHEMIN' : $res .= boucleChemin($texte, $args); break;
|
||
case 'CHEMINDOS' : $res .= boucleChemindos($texte, $args); break;
|
||
case 'PAIEMENT' : $res .= bouclePaiement($texte, $args); break;
|
||
case 'ADRESSE' : $res .= boucleAdresse($texte, $args); break;
|
||
case 'VENTEADR' : $res .= boucleVenteadr($texte, $args); break;
|
||
case 'COMMANDE' : $res .= boucleCommande($texte, $args); break;
|
||
case 'VENTEPROD' : $res .= boucleVenteprod($texte, $args); break;
|
||
case 'IMAGE' : $res .= boucleImage($texte, $args); break;
|
||
case 'DOCUMENT' : $res .= boucleDocument($texte, $args); break;
|
||
case 'ACCESSOIRE' : $res .= boucleAccessoire($texte, $args); break;
|
||
case 'TRANSPORT' : $res .= boucleTransport($texte, $args); break;
|
||
case 'PAYS' : $res .= bouclePays($texte, $args); break;
|
||
case 'CARACTERISTIQUE' : $res .= boucleCaracteristique($texte, $args); break;
|
||
case 'CARACDISP' : $res .= boucleCaracdisp($texte, $args); break;
|
||
case 'CARACVAL' : $res .= boucleCaracval($texte, $args); break;
|
||
case 'DEVISE' : $res .= boucleDevise($texte, $args); break;
|
||
case 'CLIENT' : $res .= boucleClient($texte, $args); break;
|
||
case 'DECLINAISON' : $res .= boucleDeclinaison($texte, $args); break;
|
||
case 'DECLIDISP' : $res .= boucleDeclidisp($texte, $args); break;
|
||
case 'DECVAL' : $res .= boucleDecval($texte, $args); break;
|
||
case 'RSS' : $res .= boucleRSS($texte, $args); break;
|
||
case 'STOCK' : $res .= boucleStock($texte, $args); break;
|
||
case 'PAGERUBRIQUE' : $res .= bouclePagerubrique($texte, $args); break;
|
||
case 'RAISON' : $res .= boucleRaison($texte, $args); break;
|
||
case 'TVA' : $res .= boucleTva($texte, $args); break;
|
||
case 'LANGUE' : $res .= boucleLangue($texte, $args); break;
|
||
case 'REPRISEPAIEMENT' : $res .= boucleReprisePaiement($texte, $args); break;
|
||
default: $res.= $this->moduleBoucle($type_boucle, $texte, $args); break;
|
||
}
|
||
|
||
else
|
||
$res = $texte;
|
||
|
||
//$param = array(&$type_boucle, &$args, &$res, &$nom_boucle);
|
||
//ActionsModules::instance()->appel_module( "apresboucle", $param);
|
||
|
||
return $res;
|
||
}
|
||
|
||
function moduleBoucle($type_boucle, $texte, $args){
|
||
|
||
try {
|
||
$modules = new Modules();
|
||
|
||
if ($modules->charger(strtolower($type_boucle)) && $modules->actif) {
|
||
|
||
$instance = ActionsModules::instance()->instancier($modules->nom);
|
||
|
||
if (method_exists($instance, 'boucle'))
|
||
return $instance->boucle($texte, $args);
|
||
}
|
||
} catch (Exception $ex) {}
|
||
|
||
return '';
|
||
}
|
||
|
||
function imprimer()
|
||
{
|
||
Analyse::echo_debug("[DEBUT $this->nom, args: ", $this->args, "]");
|
||
$this->contenu->imprimer();
|
||
Analyse::echo_debug("[FIN $this->nom]");
|
||
}
|
||
}
|
||
|
||
?>
|