conf.php

Transcription

conf.php

BACKEND MODULE
Auteur : Philippe Leblond
Compagnie : Sys-Tech (http://www.sys-tech.net)
Référence obligatoire pour les backend module :
http://typo3.org/documentation/document-library/core-documentation/doc_core_api/4.2.0/view/
conf.php
Accès :
$MCONF['access']='user,group,admin';
Valeur possible :
user : utilisateur (On pourra mettre des permissions sur les utilisateur qui auront accès à ce module)
group : groupe (On pourra mettre des permissions sur les groupes utilisateur qui auront accès à ce module)
admin : administrateur (Les administrateurs auront accès à ce module)
Script à utiliser :
$MCONF['script']='_DISPATCH'; //appelera par défaut index.php
La valeur par défaut est _DISPATCH mais on peut utilise un autre script exemple :
$MCONF['script']='allo.php'; //non recommandé
Icone du module backend :
$MCONF['default']['tabs_images']['tab']='moduleicon.gif';
Module de traduction pour les termes généraux relié au backend :
$MCONF['default']['11_ref']='LLL:EXT:st_kitchen/mod1/locallang_mod.php';
Workspace permission :
$MCONF['workspaces'] = “online,offline,custom”;
Valeur possible :
online : Permet en mode live
offline : Permit en mode draft
custom : Permit dans les workspace personnonalisé
Localisation
global $LANG
$LANG->getLL('function1')
Menu fonction
Pour ajouter des menus :
function menuConfig() {
global $LANG;
$this->MOD_MENU = Array (
'function' => Array (
'1' => $LANG->getLL('function1'),
)
);
parent::menuConfig();
}
Pour récupérer le numéro du menu contextuel :
$this->MOD_SETTINGS['function']
TYPO3 Core Engine (TCE)
Le TYPO3 core engine permet d'exécuter des commandes et faire des requêtes SQL sans avoir à
écrire des longues lignes de code php et des requêtes SQL. De plus il prend en compte tous les
paramètres et permission par défaut de TYPO3. Il y a donc moins de chance de se tromper en
utilisant le TCE que faire nous même nos requêtes SQL.
Documentation :
3/3/
Data : (création ou modification)
Syntaxe pour une modification :
$data[ tablename ][ uid ][ fieldname ] = value
Exemple pour une création :
$data['pages']['NEW9823be87'] = array(
"title" => "The page title",
"subtitle" => "Other title stuff",
"pid" => "45"
);
Soumission d'une data
$tce = t3lib_div::makeInstance('t3lib_TCEmain');
$tce->stripslashes_values = 0;
$tce->start($data,array());
$tce->process_datamap();
Pour récuper le id d'un nouvel enregistrement : $tce->substNEWwithIDs[$id];
Cmd : (delete,move,copy)
Syntaxe pour une supression :
$cmd[table][uid][commande] = valeur;
Exemple pour une suppression :
$cmd['pages'][66]['delete'] = 1;
Soumission d'une commande :
$tce = t3lib_div::makeInstance('t3lib_TCEmain');
$tce->stripslashes_values=0;
$tce->start(array(),$cmd);
$tce->process_cmdmap();
Création de lien et le TCE
Méthode editOnClick
Création d'un lien pour éditer une table du TCA :
//Éditer la page ayant comme uid 66
$params='&edit[pages][66]=edit';
$link = '<a href="#"
onclick="'.htmlspecialchars(t3lib_BEfunc::editOnClick($params)).'">Edit</a>';
//Éditer le titre de la page ayant comme uid 66
$params='&edit[pages][66]=edit&columnsOnly=title';
$link = '<a href="#"
onclick="'.htmlspecialchars(t3lib_BEfunc::editOnClick($params)).'">Edit</a>';
Création d'un lien pour créer un nouvel enregistrement dans une table :
//Créer une page sous la page ayant comme uid 33
$params =
'&edit[pages][33]=new&defVals[pages][title]=NewElement&defVals[pages][subtitle]=NewElement2';
$content.= '<a href="#"
onclick="'.htmlspecialchars(t3lib_BEfunc::editOnClick($params,$GLOBALS['BACK_PATH'])).'">'.
'Create new page inside page 33</a><br/>';
Méthode tce_db.php et alt_doc.php
tce_db.php : SC_tce_db Class Reference
Ce fichier TYPO3 permet d'exécuter des cmd et datamap.
Document : http://typo3.org/documentation/document-library/core-documentation/doc_core_api/
4.2.0/view/3/3/
Syntaxe :
// id : page du backend
// $this->MCONF['name'] : nom du module
// $this->MOD_SETTINGS['function'] : menu
$returnUrl="redirect=".$baseUrl.urlencode("mod.php?id={$this->id}&M={$this>MCONF['name']}&SET[function]={$this->MOD_SETTINGS['function']}{$param}");
$urlComplete =
"{$baseUrl}tce_db.php?&cmd[{$table}][{$uidRecord}][delete]=1&{$returnUrl}";
alt_doc.php : SC_alt_doc Class Reference
Permet de faire un rendu du TCA
Syntaxe :
// id : page du backend
// $this->MCONF['name'] : nom du module
// $this->MOD_SETTINGS['function'] : menu
$returnUrl="returnUrl=".urlencode("mod.php?id={$this->id}&M={$this>MCONF['name']}&SET[function]={$this->MOD_SETTINGS['function']}{$param}");
$editRecord = "edit[{$table}][{$uidRecord}]=edit";
$urlComplete = "{$baseUrl}alt_doc.php?{$returnUrl}&{$editRecord}";
Voici 2 fonctions pratiques pour les backend modules :
/*
* cmd : EDIT,NEW,DELETE
*/
function getUrlCmdRecord($table,$uidRecord,$cmd='EDIT',$param=array()) {
if (count($param)>0) {
$param = '&'.implode('&',$param);
}
$baseUrl = t3lib_div::getIndpEnv(TYPO3_REQUEST_DIR);
$returnUrl="returnUrl=".urlencode("mod.php?id={$this->id}&M={$this>MCONF['name']}&SET[function]={$this->MOD_SETTINGS['function']}{$param}");
if (strcasecmp('EDIT',$cmd)==0) {
$editRecord = "edit[{$table}][{$uidRecord}]=edit";
}
elseif (strcasecmp('DELETE',$cmd)==0) {
$returnUrl="redirect=".$baseUrl.urlencode("mod.php?id={$this->id}&M={$this>MCONF['name']}&SET[function]={$this->MOD_SETTINGS['function']}{$param}");
$urlComplete =
"{$baseUrl}tce_db.php?&cmd[{$table}][{$uidRecord}][delete]=1&{$returnUrl}";
}
else {
$editRecord = "edit[{$table}][{$this->id}]=new";
}
return $urlComplete;
}
/*
* cmd : EDIT,NEW,DELETE
*/
function
getIconCmd($table,$uidRecord,$cmd='EDIT',$param=array(),$width=16,$height=16,$addAttribute='')
{
$baseUrl = t3lib_div::getIndpEnv(TYPO3_REQUEST_DIR);
if (strcasecmp('DELETE',$cmd)==0) {
$icon = '<a '.$addAttribute.' href="'.$this>getUrlCmdRecord($table,$uidRecord,$cmd,$param).'"><img
'.t3lib_iconWorks::skinImg($baseUrl,'sysext/t3skin/icons/gfx/garbage.gif').' width="'.$width.'"
height="'.$height.'" alt="" /></a>';
}
if (strcasecmp('EDIT',$cmd)==0) {
'.t3lib_iconWorks::skinImg($baseUrl,'sysext/t3skin/icons/gfx/edit2.gif').' width="'.$width.'"
}
if (strcasecmp('NEW',$cmd)==0) {
'.t3lib_iconWorks::skinImg($baseUrl,'sysext/t3skin/icons/gfx/new_el.gif').' width="'.$width.'"
}
return $icon;
}
Simulation du frontend en backend
Il arrive parfois d'avoir besoin des méthodes du TSFE pour avoir accès aux méthode de la
librairie tslib_cObj. Avec la méthode suivante on peut avoir accès aux méthodes de template
ainsi qu'à l'objet typolink pour faire des liens en backend. Cette méthode peut causer certain
problème car on est pas dans un contexte de frontend.
function get_tsfe($pid = 1) {
require_once(PATH_site.'typo3/sysext/cms/tslib/class.tslib_fe.php');
require_once(PATH_site.'t3lib/class.t3lib_userauth.php');
require_once(PATH_site.'typo3/sysext/cms/tslib/class.tslib_feuserauth.php');
require_once(PATH_site.'t3lib/class.t3lib_cs.php');
require_once(PATH_site.'typo3/sysext/cms/tslib/class.tslib_content.php') ;
require_once(PATH_site.'t3lib/class.t3lib_tstemplate.php');
require_once(PATH_site.'t3lib/class.t3lib_page.php');
require_once(PATH_site.'t3lib/class.t3lib_timetrack.php');
$TSFEclassName = t3lib_div::makeInstanceClassName('tslib_fe');
$GLOBALS['TSFE'] = new $TSFEclassName($GLOBALS['TYPO3_CONF_VARS'],
$pid, '0', 0, '','','','');
$temp_TTclassName = t3lib_div::makeInstanceClassName('t3lib_timeTrack');
$GLOBALS['TT'] = new $temp_TTclassName();
$GLOBALS['TT']->start();
$GLOBALS['TSFE']->config['config']['language']=$_GET['L'];
$GLOBALS['TSFE']->id = $pid;
$GLOBALS['TSFE']->connectToMySQL();
$sqlDebug = $GLOBALS['TYPO3_DB']->debugOutput;
$GLOBALS['TYPO3_DB']->debugOutput = false;
$GLOBALS['TSFE']->initLLVars();
$GLOBALS['TSFE']->initFEuser();
$GLOBALS['TSFE']->sys_page = t3lib_div::makeInstance('t3lib_pageSelect');
$GLOBALS['TSFE']->sys_page->init($GLOBALS['TSFE']->showHiddenPage);
$page = $GLOBALS['TSFE']->sys_page->getPage($pid);
if (count($page) == 0) {
$GLOBALS['TYPO3_DB']->debugOutput = $sqlDebug;
return false;
}
if ($page['doktype']==4 && count($GLOBALS['TSFE']>getPageShortcut($page['shortcut'],$page['shortcut_mode'],$page['uid'])) == 0) {
return false;
}
if ($page['doktype'] == 199 || $page['doktype'] == 254) {
return false;
}
$GLOBALS['TSFE']->getPageAndRootline();
$GLOBALS['TSFE']->initTemplate();
$GLOBALS['TSFE']->forceTemplateParsing = 1;
$GLOBALS['TSFE']->tmpl->start($GLOBALS['TSFE']->rootLine);
$GLOBALS['TSFE']->sPre = $GLOBALS['TSFE']->tmpl>setup['types.'][$GLOBALS['TSFE']->type];
// toplevel - objArrayName
$GLOBALS['TSFE']->pSetup = $GLOBALS['TSFE']->tmpl>setup[$GLOBALS['TSFE']->sPre.'.'];
if (!$GLOBALS['TSFE']->tmpl->loaded || ($GLOBALS['TSFE']->tmpl->loaded &&
!$GLOBALS['TSFE']->pSetup)) {
return false;
}
$GLOBALS['TSFE']->getConfigArray();
//$GLOBALS['TSFE']->getCompressedTCarray();
$GLOBALS['TSFE']->inituserGroups();
$GLOBALS['TSFE']->connectToDB();
$GLOBALS['TSFE']->determineId();
return $GLOBALS['TSFE']->newCObj();
}
Avec cette fonction nous pouvons obtenir plusieurs fonctions relié exclusivement au frontend
telque la fonction typolink, typolink_url et les fonctions de template.
Pour initialiser le TSFE :
$this->get_tsfe();
Pour l'utilisation des fonction frontend :
url :
$GLOBALS['TSFE']->cObj->typolink_url($link);
$GLOBALS['TSFE']->cObj->typolink($link);
Template :
$html = "###TEST###<div>###REPLACE###</div>###TEST###";
$templateComplete = $GLOBALS['TSFE']->cObj->getSubpart($html,"###TEST###");
$markerArray=array();
$subpartArray=array();
$wrappedSubpartArray=array();
$markerArray['###REPLACE###'] = 'ceci est un test';
$content = $GLOBALS['TSFE']->cObj->substituteMarkerArrayCached($templateComplete,
$markerArray,$subpartArray,$wrappedSubpartArray);
Hook TCEMain
Hook pour les datas (lorsqu'on veux modifier ou créer un enregistrement):
Dans le fichier ext_localconf.php :
$GLOBALS ['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/
class.t3lib_tcemain.php']['processDatamapClass'][] = 'EXT:keyextension/file.php:tx_class';
Dans le fichier file.php :
// $status : update ou new
// $table : table sur laquelle on fait l'opération
// $id : reprsente le id de l'enregistrement (lors de la création d'un objet on doit utiliser la fonction $tce->substNEWwithIDs[$id];)
// $fieldArray : représente les champs qu'on crée ou modifie.
Action à faire après l'enregistrement des données.
function processDatamap_afterDatabaseOperations($status, $table, $id, $fieldArray, $tce) {
// mettre son code ici
}
Pour récuper le id d'un nouvel enregistrement : $tce->substNEWwithIDs[$id];
Action à faire avant l'enregistrement des données.
function processDatamap_preProcessFieldArray(&$incomingFieldArray, $table, $id, $tce) {
}
Hook pour les cmd (lorsqu'on veux déplacé, copié ou supprimé un
enregistrement)
$GLOBALS ['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/
class.t3lib_tcemain.php']['processCmdmapClass'][] = 'EXT:profweb_pratiques/
class.tx_profwebpratiques_tcemain.php:tx_profwebpratiques_tcemain';
// $command: delete, moce, copy, undelete
// $table : table sur laquelle on fait l'opération
// $id
// $value : représente les champs qu'on crée ou modifie.
function processCmdmap_preProcess($command, $table, $id, $value, $tce) {
}
Fonction backend et astuce
Cache :
Pour supprimer la cache d'une page on peut utiliser la fonction : $tce->clear_cacheCmd
exemple :
require_once (PATH_t3lib."class.t3lib_tcemain.php");
$tce = t3lib_div::makeInstance("t3lib_TCEmain");
$tce->clear_cacheCmd($uidPage);
t3lib_BEfunc :
Pour obtenir les champs startime, endtime, hidden :
t3lib_BEfunc::BEenableFields('table');
Pour obtenir le champ deleted :
t3lib_BEfunc::deleteClause('table');
t3lib_userAuthGroup :
Savoir si un utilisateur est administrateur ou pas :
$GLOBALS['BE_USER']->isAdmin
Permet d'obtenir les condition SQL pourr les permission d'une page sélectionner dans le backend
$GLOBALS['BE_USER']->getPagePermsClause
Pour savoir si un utilisateur appartient à un groupe :
$GLOBALS['BE_USER']->isMemberOfGroup($idGroup)
Autre :
Connaitre le ID de la page où l'on se trouve dans le backend :
$this->id
Création d'arbre dans le backend
Technique 1 :
require_once(PATH_t3lib.'../typo3/class.webpagetree.php');
$tree = t3lib_div::makeInstance('webPageTree');
$content .= $tree->getBrowsableTree();
Utiliser la fonction JumpTo en javascript pour identifier la bonne page.
Technique 2 :
require_once(PATH_t3lib.'class.t3lib_treeview.php');
$tree = t3lib_div::makeInstance('t3lib_treeView');
//initialise treeview
$tree->init();
$tree->expandFirst =1;
$tree->expandAll = 1;
$tree->MOUNTS = array(1);
$tree->table = 'pages';
$tree->clause = ''; //additionnal clause where (begin whith ' AND')
$tree->orderByFields = 'sorting';
debug($tree->tree);
$content.=$tree->getBrowsableTree();
Utiliser la fonction JumpTo en javascript pour identifier la bonne page.
Technique 3 (arbre statique) :
require_once(PATH_t3lib.'class.t3lib_pagetree.php');
// Initialize starting point of page tree:
$treeStartingPoint = 1;
$treeStartingRecord = t3lib_BEfunc::getRecord('pages', $treeStartingPoint);
$depth = 2;
// Initialize tree object:
$tree = t3lib_div::makeInstance('t3lib_pageTree');
$tree->init('AND '.$GLOBALS['BE_USER']->getPagePermsClause(1));
// Creating top icon; the current page
$HTML = t3lib_iconWorks::getIconImage('pages', $treeStartingRecord,
$GLOBALS['BACK_PATH'],'align="top"');
$tree->tree[] = array(
'row' => $treeStartingRecord,
'HTML'=>$HTML
);
// Create the tree from starting point:
$tree->getTree($treeStartingPoint, $depth, '');
#debug($tree->tree);
// Put together the tree HTML:
$output = '
<tr bgcolor="#999999">
<td><b>Icon / Title:</b></td>
<td><b>Page UID:</b></td>
</tr>
';
foreach($tree->tree as $data) {
$output.='
<tr bgcolor="#cccccc">
<td nowrap="nowrap">'.$data['HTML'].htmlspecialchars($data['row']['title']).'</td>
<td>'.htmlspecialchars($data['row']['uid']).'</td>
</tr>
';
}
$content .= '<table border="0" cellspacing="1" cellpadding="0">'.$output.'</table>';
CRON
Pour n'importe quelle commande provenant du CLI, il faut faire passer la requête par le fichier
typo3/cli_dispatch.phpsh. Celui-ci s'occupe d'initialiser l'environnement TYPO3 et de loader
l'utilisateur backend requis.
À noter qu'il est très important de créer un utilisateur backend et dont le nom d'utilisateur devra
obligatoirement commencer par _CLI_. Dans l'exemple ci-dessous le nom de notre utilisateur
backend est
_CLI_st_extension
ext_localconf.php :
$TYPO3_CONF_VARS['SC_OPTIONS']['GLOBAL']['cliKeys']['st_extension'] =
array('EXT:st_extension/cli/class.tx_st_extension_cli.php','_CLI_st_extension');
st_extension : représente le nom de notre cli
st_extension : représente la clé unique de notre extension
_CLI_st_extension : nom de l'utilisateur backend
Code :
<?php
// Ce fichier est inclu à partir de typo3/cli_dispatch.phpsh
if (!defined('TYPO3_cliMode'))
die('You cannot run this script directly!');
require_once(PATH_t3lib . 'class.t3lib_cli.php');
class tx_st_extension_cli extends t3lib_cli {
function tx_st_extension_cli() {
// Make sure the this always calls the parent's constructor
parent::t3lib_cli();
}
function main() {
// Check arguments by looping through $this->cli_args !
foreach($this->cli_args as $arg => $value) {
// Do something
}
}
function doSomething() {
// Do something here
return true;
}
}
// XCLASS Management
if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['ext/
st_extension/cli/tx_st_extension_cli.php'])
include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['ext/st_extension/cli/
tx_st_extension_cli.php']);
// Call the functionality
$myObj = t3lib_div::makeInstance('tx_st_extension_cli');
$myObj->main();
$myObj->doSomething();
?>
Tous les arguments passés au script se retrouvent dans la variable membre $cli_args après que le
constructeur de t3lib_cli ait été appelé.
Plusieurs fonctions sont aussi disponibles pour gérer les arguments. Utiliser $SERVER["argv"]
lorsque le paramètre $argv doit être spécifié.
Il ne reste plus qu'à appeller le script de cette façon. Le premier argument est obligatoire. Ça doit
être le keyname utilisé pour l'array
$TYPO3_CONF_VARS['SC_OPTIONS']['GLOBAL']['cliKeys']. On peut ensuite passer tous les
arguments qu'on veut.
Note: Le binaire de php doit obligatoirement être /usr/bin/php. Utilisez un symlink si ce n'est pas
le cas.
/srv/www/vhosts/csrsdev.clients.sys-tech.net/typo3/cli_dispatch.phpsh st_extension
Interface de configuration d'une extension dans l'Extension
manager
Créer dans le dossier de base de l'extension le fichier ext_conf_template.txt
exemple de ext_conf_template.txt :
# cat=basic; type=boolean; label= Titre de page
titlepage = 1
# cat=basic; type=string; label= Code
code =
cat :
cat correspond à la catégorie de la variable, les choix possibles sont :
basic,menu,content,page,advanced. La plus utilisé est basic.
On peut utiliser des sous-catégories pour ajouter des titres :
• enable
• dims
• file
• typo
• color
• links
• language
Exemple de sous-catégorie : # cat=basic/enable;
Les type possible :
- boolean (case à cocher à la restitution)
- int (entier)
- int[0-3] (entier entre 0 à 3)
- int+ (entier entre 0 et 10000)
- color (choix de couleurr)
- wrap (permet de mettre deux partie de code -> on récupère dans le code la "partie gauche|partie
droite")
- options[Option1,Option2,Option3,...] (Affiche une select box avec les valeurs définies entre [])
- file (pas testé)
- string : champ text
quelques exemple :
# cat=basic; type=options[label9,test2]; label=test
variableName9=test2
# cat=basic/file; type=file[html,jpg]; label=label11
variableName11=
# cat=basic; type=int[0-3]; label = 0 a 3
debug = 0
# cat=basic; type=string; label=label2
variableName2 = 123
# cat=basic; type=boolean; label=label1:mettre ici la description description
variableName1 = 1
Label : représenter un libellé à afficher.
Exploitation des variables
Maintenant il suffit de récupérer les variables dans le plugin pour pouvoir les utiliser, on procède
de cette manière :
global $TYPO3_CONF_VARS;
$variable=$TYPO3_CONF_VARS["EXT"]["extConf"]["NOM_EXTENSION"];
Ceci nous renvoi dans $variable le tableau sérialisé des variables de configuration. Il suffit de
désérialiser ce tableau comme ceci :
$variable=unserialize($variable);
Ensuite on peut accéder au valeur des variable puisque l'index de $variable est le nom mis dans
le fichier ext_conf_template.txt
exemple :
echo $variable["titlepage"];
TCA
exemple de la fonction itemsProcFunc : Permet de modifier la valeur d'un select
'category' => array (
'exclude' => 0,
'label' => 'test',
'config' => array (
'type' => 'select',
'foreign_table' => 'tx_stkitchen_category',
'foreign_table_where' => 'ORDER BY tx_stkitchen_category.uid',
"itemsProcFunc" => "user_GetGenreItems",
'size' => 5,
'minitems' => 0,
'maxitems' => 5,
)
),
function user_GetGenreItems(&$config, &$item) {
$config['items'][2] = array('label0',201);
return $config;
}
Exemple de la fonction userFunc : Permet de créer un champ sur mesure
"category" => Array (
"label" => "test",
'config' => Array (
'type' => 'user',
'userFunc' => 'user_GetGenreItems',
),
),
function user_GetGenreItems($PA, $fobj) {
//reponse dans $PA['row']['category']
$content = '<select name="data[tx_stkitchen_recipe][3][category]"><option
value="1">1</option><option value="2">2</option></select>';
return $content;
}
IRRE
'test' => Array(
'exclude' => 1,
'label' => 'test',
'config' => Array(
'type' => 'inline',
'foreign_table' => 'fe_groups',
'maxitems' => 10,
'appearance' => Array(
'collapseAll' => 1,
'expandSingle' => 1,
),
),
),
Fichier :
'file' => array (
'exclude' => 0,
'label' => 'LLL:EXT:bbb/locallang_db.xml:tx_bbb_bbb.file',
'config' => array (
'type' => 'group',
'internal_type' => 'file',
'allowed' => 'gif,png,jpeg,jpg',
'max_size' => $GLOBALS['TYPO3_CONF_VARS']['BE']['maxFileSize'],
'uploadfolder' => 'uploads/tx_bbb',
'size' => 1,
'minitems' => 0,
'maxitems' => 1,
)
),
Lien :
'link' => array (
'exclude' => 0,
'label' => 'LLL:EXT:bbb/locallang_db.xml:tx_bbb_bbb.link',
'config' => array (
'type' => 'input',
'size' => '15',
'max'
=> '255',
'checkbox' => '',
'eval' => 'trim',
'wizards' => array(
'_PADDING' => 2,
'link' => array(
'type'
=> 'popup',
'title'
=> 'Link',
'icon'
=> 'link_popup.gif',
'script'
=> 'browse_links.php?mode=wizard',
'JSopenParams' => 'height=300,width=500,status=0,menubar=0,scrollbars=1'
)
)
)
),
Méthode utilisé pour récuper notre lien de la BD :
$url = htmlspecialchars($link);
$name = explode(' ', $url);
$content = $this->cObj->getTypoLink('titre du url', $url);
AJAX
Coté serveur :
Dans le fichier ext_localconf.php
$TYPO3_CONF_VARS['BE']['AJAX']['tx_myext::ajaxID'] = 'filename:object->method';
exemple :
$TYPO3_CONF_VARS['BE']['AJAX']['SC_alt_db_navframe::expandCollapse'] = 'typo3/
alt_db_navframe.php:SC_alt_db_navframe->ajaxExpandCollapse';
alt_db_navframe.php :
public function ajaxExpandCollapse($params, &$ajaxObj) {
$this->init(); // do the logic...
if (empty($this->tree)) {
$ajaxObj->setError('An error occurred');
}
else {
// the content is an array that can be set through $key / $value pairs as parameter
$ajaxObj->addContent('tree', 'The tree works...');
}
}
Coté client :
$this->doc->loadJavascriptLib('contrib/prototype/prototype.js');
$this->doc->loadJavascriptLib('js/common.js');
new Ajax.Request('ajax.php', {
method: 'get',
parameters: 'ajaxID=SC_alt_db_navframe::expandCollapse',
onComplete: function(xhr, json) {
// display results, should be "The tree works"
}.bind(this),
onT3Error: function(xhr, json) {
// display error message, will be "An error occurred" if an error occurred
}.bind(this)
});
Versioning et workspace
Documentation :
3/2/
http://typo3.org/documentation/document-library/core-documentation/doc_core_inside/4.1.0/
view/3/7/
http://typo3.org/documentation/document-library/extension-manuals/doc_v4_workspace/1.0.5/
view/ (En allemand)
Stage de la version :
Editing : Le contenu peut être éditer librement.
Reviewer : Le contenu doit être approuver avant d'être publier. Le contenu ne peut être modifier
à moins d'avoir les droits de reviewer.
Publish : Le contenu peut être publier. Le contenu ne peut être modifer tant et aussi longtemp
que le contenu n'a pas été publié officiellement. Seul les membre ayant les droits d'éditer en
mode live peuvent changer le contenu. Pour cela il faut avoir les droits sur le "Live workspace"
Reject : Le contenu a été rejeter et peut être éditer à nouveau.
Toute personne ayant les droit sur le workspace a le droit d'éditer un contenu et passer au mode
reviewer.
Type de versionning :
Element : Versionning sur les enregistrements
Page : Versionning sur les pages
Branch : Versionning sur copy, deplacé des branches complète de page (page et sous page)
Workspace avec templavoila
• Lorsqu'on crée un nouvel élément dans le workspace nous créons un élément vide qui
aura comme label "INITIAL PLACEHOLDER" et un nouvel élément sera créé et aura
dans le champ t3ver_oid le uid du premier élément créé.
• Lorsqu'on modifie un élément de contenu dans le workspace il y aura un nouvel élément
de créer avec t3ver_label="Auto-created for WS 1" aura dans le champ t3ver_oid le uid
de l'élément en ligne.
• Lorsqu'on supprime un élément de contenu en fait c'est comme si on avait une nouvelle
révision de la page car l'élément de contenu était entrer dans la table pages.
Champ dans la base de donnée :
t3ver_oid : uid de la version originale
t3ver_id : le nieme nombre associer a la page original (incrementiel)
pid : -1 pour les versions hots ligne.
t3ver_wsid : id du workspace
t3ver_label : Description sur la version
t3ver_stage : id du stage
t3ver_state : 2 version supprimé, 1 nouvel élément, 3 élément déplacé, 4 are move-to pointer
elements
t3ver_count : Nombre de fois qu'un element a été en ligne
t3ver_tstamp : date de publication de la version
t3ver_move_id : Contient la source id de l'enregistrement qui doit être déplacé
Stage statut :
•
•
•
•
stage reject = -1
stage editing = 0
stage review = 1
stage publish = 10
Différence entre swap et publish :
Dans les 2 cas nous allons publié la version en ligne. La différence fondamentale est que
lorsqu'on utilise swap, la version hors ligne ira en ligne alors que la version live revient en mode
hors-ligne alors que si l'on utilise publish alors la version hors ligne ira en ligne et la version en
ligne ira dans les archives. Swap sera souvent utilisé pour un événement pontuel et que l'on veut
plus tard revenir avec notre ancienne version. On refera un swap à nouveau.
versionOL
Lorsqu'on selectionne un enregistrement basé sur le uid alors pour qu'on obtienne le bon resultat
en mode preview il est important d'utiliser la fonction $GLOBALS['TSFE']->sys_page>versionOL('table',$row);
versionOL transformera le uid avec le bon uid en mode preview.
Frontend : $GLOBALS['TSFE']->sys_page->versionOL($table,&$row,
$unsetMovePointers=FALSE)
Backend : t3lib_BEfunc::workspaceOL ($table, &$row)
exemple :
$res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*','tt_content', "uid='80'",'','','');
$row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
$GLOBALS['TSFE']->sys_page->versionOL('tt_content',$row,false);
if (is_array($row)) {
$content = "<br/>content header = {$row['header']}";
}
uid en mode live : 80
uid en mode preview : 82
80 est le uid en mode live mais en mode preview le uid devrait etre 82 pour notre exemple.
versionOL va transformer notre $row avec les bons paramètres.
Notre tableau devra contenir les valeur suivant pour être fonctionnel : "uid", "pid" and
"t3ver_state"
fixVersioningPid
Lorsque nous sommes en mode preview et que l'on choisit un uid qui a comme pid -1 alors on
utilise la fonction fixVersioningPid pour obtenir le pid de la page correspondante.
Frontend : $GLOBALS['TSFE']->sys_page->fixVersioningPid(table,$row);
Backend : t3lib_BEfunc::fixVersioningPid(table,$row);

conf.php

Transcription

Documents pareils

Refonte du site intranet de la Fonction Qualité PSA

Rester ou partir ?

Développement d`une solution packagée pour le CMS Open Source

Une page web est dj une image

Universites d`ete TYPO3

Présentation de TYPO3

créez votre

Fiche d`informations Hébergement revendeur

Université d`été

Télécharger - Romain CANON