Source for file jControllerDaoCrudDfk.class.php

Documentation is available at jControllerDaoCrudDfk.class.php

  1. <?php
  2. /**
  3. @package      jelix
  4. @subpackage   controllers
  5. @author       Laurent Jouanneau
  6. @contributor  Bastien Jaillot
  7. @contributor  Thibault Piront (nuKs)
  8. @copyright    2007-2008 Laurent Jouanneau
  9. @copyright    2007 Thibault Piront
  10. @copyright    2007,2008 Bastien Jaillot
  11. @link         http://www.jelix.org
  12. @licence      http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
  13. *
  14. */
  15.  
  16. /**
  17.  * a base class for crud controllers, for DAO which have a primary key based on
  18.  * two fields, a "static" field (a field that we know the value and which is a criteria to
  19.  * to select all viewed record), and a
  20.  * "dynamic" field (the value of the field is created by the user or autoincremented)
  21.  * @package    jelix
  22.  * @subpackage controllers
  23.  * @since 1.1
  24.  */
  25. class jControllerDaoCrudDfk extends jController {
  26.  
  27.     /**
  28.      * name of the request parameter and of the field in the dao, for the dynamic primary key
  29.      */
  30.     protected $dpkName ='id';
  31.  
  32.     /**
  33.      * name of the request parameter and of the field in the dao, for the static primary key
  34.      */
  35.     protected $spkName = 'spk';
  36.  
  37.     /**
  38.      * selector of the dao to use for the crud.
  39.      * It should be filled by child controller.
  40.      * @var string 
  41.      */
  42.     protected $dao = '';
  43.  
  44.     /**
  45.      * selector of the form to use to edit and display a record
  46.      * It should be filled by child controller.
  47.      * @var string 
  48.      */
  49.     protected $form ='';
  50.  
  51.     /**
  52.      * list of properties to show in the list page
  53.      * if empty list (default), it shows all properties.
  54.      * this property is only usefull when you use the default "list" template
  55.      * @var array 
  56.      */
  57.     protected $propertiesForList = array();
  58.  
  59.     /**
  60.      * list of properties which serve to order the record list.
  61.      * if empty list (default), the list is in a natural order.
  62.      * keys are properties name, and values are "asc" or "desc".
  63.      * @var array 
  64.      */
  65.     protected $propertiesForRecordsOrder = array();
  66.  
  67.     /**
  68.      * template to display the list of records
  69.      * @var string 
  70.      */
  71.     protected $listTemplate = 'jelix~cruddfk_list';
  72.  
  73.     /**
  74.      * template to display the form
  75.      * @var string 
  76.      */
  77.     protected $editTemplate = 'jelix~cruddfk_edit';
  78.  
  79.     /**
  80.      * template to display a record
  81.      * @var string 
  82.      */
  83.     protected $viewTemplate = 'jelix~cruddfk_view';
  84.  
  85.     /**
  86.      * number of record to display in the list page
  87.      * @var integer 
  88.      */
  89.     protected $listPageSize = 20;
  90.  
  91.     /**
  92.      * the template variable name to display a CRUD content in the main template
  93.      * of the html response
  94.      * @var string 
  95.      */
  96.     protected $templateAssign = 'MAIN';
  97.  
  98.     /**
  99.      * name of the parameter which contains the page offset, for the index action
  100.      * @var string 
  101.      */
  102.     protected $offsetParameterName = 'offset';
  103.  
  104.     /**
  105.      * id for the "pseudo" form used to show a record. You can change it if the default one corresponds to
  106.      * a possible id in your dao.
  107.      * @var string 
  108.      */
  109.     protected $pseudoFormId = 'jelix_cruddf_roxor';
  110.  
  111.     /**
  112.      * full path to the directory where uploaded files will be stored
  113.      * automatically by jForms.
  114.      * Set it to false if you want to handle yourself the uploaded files.
  115.      * Set it with an empty string if you want to stored files in the default
  116.      * var/uploads directory.
  117.      * @var string|false
  118.      */
  119.     protected $uploadsDirectory ='';
  120.  
  121.     /**
  122.      * the jDb profile to use with the dao
  123.      */
  124.     protected $dbProfile = '';
  125.  
  126.     /**
  127.      * Returned a simple html response to display CRUD contents. You can override this
  128.      * method to return a personnalized response
  129.      * @return jResponseHtml the response
  130.      */
  131.     protected function _getResponse(){
  132.         return $this->getResponse('html');
  133.     }
  134.  
  135.     /**
  136.      * returned the selector of the action corresponding of the given method of the current controller.
  137.      * @param string $method  name of one of method of this controller
  138.      * @return string an action selector
  139.      */
  140.     protected function _getAction($method){
  141.         $act jApp::coord()->action;
  142.         return $act->module.'~'.$act->controller.':'.$method;
  143.     }
  144.  
  145.     /**
  146.      * you can do your own data check of a form by overloading this method.
  147.      * You can also do some other things. It is called only if the $form->check() is ok.
  148.      * and before the save of the data.
  149.      * @param string $spk the static value of the primary key of the record
  150.      * @param jFormsBase $form the current form
  151.      * @param boolean $calltype   true for an update, false for a create
  152.      * @return boolean true if it is ok.
  153.      */
  154.     protected function _checkData($spk$form$calltype){
  155.         return true;
  156.     }
  157.  
  158.  
  159.     protected function _isPkAutoIncrement($dao=null{
  160.         if($dao == null)
  161.             $dao jDao::get($this->dao$this->dbProfile);
  162.  
  163.         $props $dao->getProperties();
  164.         return ($props[$this->dpkName]['autoIncrement'== true);
  165.     }
  166.  
  167.     protected function _getPk($spk$dpk$dao=null{
  168.         if($dao == null)
  169.             $dao jDao::get($this->dao$this->dbProfile);
  170.  
  171.         $props $dao->getProperties();
  172.         $pks $dao->getPrimaryKeyNames();
  173.         if($pks[0== $this->spkName{
  174.             return array($spk$dpk);
  175.         }
  176.         else {
  177.             return array($dpk$spk);
  178.         }
  179.     }
  180.  
  181.     /**
  182.      * list all records
  183.      */
  184.     function index(){
  185.         $offset $this->intParam($this->offsetParameterName,0,true);
  186.  
  187.         $rep $this->_getResponse();
  188.  
  189.         $dao jDao::get($this->dao$this->dbProfile);
  190.  
  191.         $cond jDao::createConditions();
  192.         $cond->addCondition($this->spkName'='$this->param($this->spkName));
  193.         $this->_indexSetConditions($cond);
  194.  
  195.         $results $dao->findBy($cond,$offset,$this->listPageSize);
  196.  
  197.         // we're using a form to have the portunity to have
  198.         // labels for each columns.
  199.         $form jForms::create($this->form$this->pseudoFormId);
  200.         $tpl new jTpl();
  201.         $tpl->assign('list',$results);
  202.         $tpl->assign('dpkName'$this->dpkName);
  203.         $tpl->assign('spkName'$this->spkName);
  204.         $tpl->assign('spk'$this->param($this->spkName));
  205.  
  206.         if(count($this->propertiesForList)) {
  207.             $prop $this->propertiesForList;
  208.         }else{
  209.             $prop array_keys($dao->getProperties());
  210.         }
  211.  
  212.         $tpl->assign('properties'$prop);
  213.         $tpl->assign('controls',$form->getControls());
  214.         $tpl->assign('editAction' $this->_getAction('preupdate'));
  215.         $tpl->assign('createAction' $this->_getAction('precreate'));
  216.         $tpl->assign('deleteAction' $this->_getAction('delete'));
  217.         $tpl->assign('viewAction' $this->_getAction('view'));
  218.         $tpl->assign('listAction' $this->_getAction('index'));
  219.         $tpl->assign('listPageSize'$this->listPageSize);
  220.         $tpl->assign('page',$offset>0?$offset:null);
  221.         $tpl->assign('recordCount',$dao->countBy($cond));
  222.         $tpl->assign('offsetParameterName',$this->offsetParameterName);
  223.  
  224.         $this->_index($rep$tpl);
  225.         $rep->body->assign($this->templateAssign$tpl->fetch($this->listTemplate));
  226.         jForms::destroy($this->form$this->pseudoFormId);
  227.         return $rep;
  228.     }
  229.  
  230.     /**
  231.      * overload this method if you wan to do additionnal things on the response and on the list template
  232.      * during the index action.
  233.      * @param jResponseHtml $resp the response
  234.      * @param jtpl $tpl the template to display the record list
  235.      */
  236.     protected function _index($resp$tpl{
  237.  
  238.     }
  239.  
  240.     /**
  241.      * overload this method if you wan to do additionnal conditions to the index's select
  242.      * during the index action.
  243.      * @param jDaoConditions $cond the conditions
  244.      */
  245.     protected function _indexSetConditions($cond{
  246.         foreach ($this->propertiesForRecordsOrder as $p=>$order{
  247.             $cond->addItemOrder($p$order);
  248.         }
  249.     }
  250.  
  251.     /**
  252.      * prepare a form to create a record.
  253.      */
  254.     function precreate({
  255.         // first, we cannot create the form directly in the create action
  256.         // because if the forms already exists, we wouldn't show
  257.         // errors or already filled field. see ticket #292
  258.         $form jForms::create($this->form);
  259.         $this->_preCreate($form);
  260.         $rep $this->getResponse('redirect');
  261.         $rep->action $this->_getAction('create');
  262.         $rep->params[$this->spkName$this->param($this->spkName);
  263.         return $rep;
  264.     }
  265.  
  266.     /**
  267.      * overload this method if you want to do additionnal during the precreate action
  268.      * @param jFormsBase $form the form
  269.      */
  270.     protected function _preCreate($form{
  271.  
  272.     }
  273.  
  274.     /**
  275.      * display a form to create a record
  276.      */
  277.     function create(){
  278.         $form jForms::get($this->form);
  279.         if($form == null){
  280.             $form jForms::create($this->form);
  281.         }
  282.         $rep $this->_getResponse();
  283.  
  284.         $tpl new jTpl();
  285.         $tpl->assign('dpk'null);
  286.         $tpl->assign('page' null);
  287.         $tpl->assign('offsetParameterName' null);
  288.         $tpl->assign('dpkName'$this->dpkName);
  289.         $tpl->assign('spkName'$this->spkName);
  290.         $tpl->assign('spk'$this->param($this->spkName));
  291.         $tpl->assign('form',$form);
  292.         $tpl->assign('submitAction'$this->_getAction('savecreate'));
  293.         $tpl->assign('listAction' $this->_getAction('index'));
  294.         $this->_create($form$rep$tpl);
  295.         $rep->body->assign($this->templateAssign$tpl->fetch($this->editTemplate));
  296.         return $rep;
  297.     }
  298.  
  299.     /**
  300.      * overload this method if you wan to do additionnal things on the response and on the edit template
  301.      * during the create action.
  302.      * @param jFormsBase $form the form
  303.      * @param jResponseHtml $resp the response
  304.      * @param jtpl $tpl the template to display the edit form
  305.      */
  306.     protected function _create($form$resp$tpl{
  307.  
  308.     }
  309.  
  310.     /**
  311.      * save data of a form in a new record
  312.      */
  313.     function savecreate(){
  314.         $form jForms::fill($this->form);
  315.         $spk $this->param($this->spkName);
  316.         $rep $this->getResponse('redirect');
  317.         $rep->params[$this->spkName$spk;
  318.  
  319.         if($form == null){
  320.             $rep->action $this->_getAction('index');
  321.             return $rep;
  322.         }
  323.  
  324.         if($form->check(&& $this->_checkData($spk$formfalse)){
  325.             $results $form->prepareDaoFromControls($this->daonull$this->dbProfile);
  326.             extract($resultsEXTR_PREFIX_ALL"form");
  327.             $form_daorec->{$this->spkName$spk;
  328.             if(!$this->_isPkAutoIncrement($form_dao)) {
  329.                 $form_daorec->{$this->dpkName$this->param($this->dpkName);
  330.             }
  331.             $this->_beforeSaveCreate($form$form_daorec);
  332.             $form_dao->insert($form_daorec);
  333.             $id $form_daorec->getPk();
  334.  
  335.             $rep->action $this->_getAction('view');
  336.             $this->_afterCreate($form$id$rep);
  337.             if ($this->uploadsDirectory !== false)
  338.                 $form->saveAllFiles($this->uploadsDirectory);
  339.             jForms::destroy($this->form);
  340.  
  341.             $pknames $form_dao->getPrimaryKeyNames();
  342.             if($pknames[0== $this->spkName{
  343.                 $rep->params[$this->spkName$id[0];
  344.                 $rep->params[$this->dpkName$id[1];
  345.             }
  346.             else {
  347.                 $rep->params[$this->spkName$id[1];
  348.                 $rep->params[$this->dpkName$id[0];
  349.             }
  350.             return $rep;
  351.         else {
  352.             $rep->action $this->_getAction('create');
  353.             return $rep;
  354.         }
  355.     }
  356.  
  357.     /**
  358.      * overload this method if you wan to do additionnal things on the dao generated by the
  359.      * jFormsBase::prepareDaoFromControls method
  360.      * @param jFormsBase $form the form
  361.      * @param jDaoRecordBase $form_daorec 
  362.      */
  363.     protected function _beforeSaveCreate($form$form_daorec{
  364.  
  365.     }
  366.  
  367.     /**
  368.      * overload this method if you wan to do additionnal things after the creation of
  369.      * a record. For example, you can handle here the uploaded files. If you do
  370.      * such handling, set the uploadsDirectory property to false, to prevent
  371.      * the default behavior on uploaded files in the controller.
  372.      * @param jFormsBase $form the form object
  373.      * @param mixed $id the new id of the inserted record
  374.      * @param jResponseHtml $resp the response
  375.      */
  376.     protected function _afterCreate($form$id$resp{
  377.  
  378.     }
  379.  
  380.     /**
  381.      * prepare a form in order to edit an existing record, and redirect to the editupdate action
  382.      */
  383.     function preupdate(){
  384.         $spk $this->param($this->spkName);
  385.         $dpk $this->param($this->dpkName);
  386.         $page $this->param($this->offsetParameterName);
  387.  
  388.         $rep $this->getResponse('redirect');
  389.         $rep->params[$this->spkName$spk;
  390.  
  391.         if$dpk === null ){
  392.             $rep->action $this->_getAction('index');
  393.             return $rep;
  394.         }
  395.  
  396.         $id $this->_getPk($spk$dpk);
  397.         $form jForms::create($this->form$id);
  398.  
  399.         try {
  400.             $form->initFromDao($this->dao$id$this->dbProfile);
  401.         }catch(Exception $e){
  402.             $rep->action $this->_getAction('index');
  403.             return $rep;
  404.         }
  405.  
  406.         $this->_preUpdate($form);
  407.  
  408.         $rep->params[$this->dpkName$dpk;
  409.         $rep->params[$this->offsetParameterName$page;
  410.         $rep->action $this->_getAction('editupdate');
  411.         return $rep;
  412.     }
  413.  
  414.     /**
  415.      * overload this method if you want to do additionnal things during preupdate action
  416.      * @param jFormsBase $form the form object
  417.      */
  418.     protected function _preUpdate($form{
  419.  
  420.     }
  421.  
  422.     /**
  423.      * displays a forms to edit an existing record. The form should be
  424.      * prepared with the preupdate before, so a refresh of the page
  425.      * won't cause a reset of the form
  426.      */
  427.     function editupdate(){
  428.         $spk $this->param($this->spkName);
  429.         $dpk $this->param($this->dpkName);
  430.         $page $this->param($this->offsetParameterName);
  431.  
  432.         $id $this->_getPk($spk$dpk);
  433.         $form jForms::get($this->form$id);
  434.         if$form === null || $dpk === null){
  435.             $rep $this->getResponse('redirect');
  436.             $rep->params[$this->spkName$spk;
  437.             $rep->action $this->_getAction('index');
  438.             return $rep;
  439.         }
  440.         $rep $this->_getResponse();
  441.  
  442.         $tpl new jTpl();
  443.         $tpl->assign('dpk'$dpk);
  444.         $tpl->assign('dpkName'$this->dpkName);
  445.         $tpl->assign('spkName'$this->spkName);
  446.         $tpl->assign('spk'$spk);
  447.         $tpl->assign('form',$form);
  448.         $tpl->assign('page',$page);
  449.         $tpl->assign('offsetParameterName',$this->offsetParameterName);
  450.         $tpl->assign('submitAction'$this->_getAction('saveupdate'));
  451.         $tpl->assign('listAction' $this->_getAction('index'));
  452.         $tpl->assign('viewAction' $this->_getAction('view'));
  453.         $this->_editUpdate($form$rep$tpl);
  454.         $rep->body->assign($this->templateAssign$tpl->fetch($this->editTemplate));
  455.         return $rep;
  456.     }
  457.  
  458.     /**
  459.      * overload this method if you wan to do additionnal things on the response and on the edit template
  460.      * during the editupdate action.
  461.      * @param jFormsBase $form the form
  462.      * @param jResponseHtml $resp the response
  463.      * @param jtpl $tpl the template to display the edit form
  464.      */
  465.     protected function _editUpdate($form$resp$tpl{
  466.  
  467.     }
  468.  
  469.     /**
  470.      * save data of a form in a new record
  471.      */
  472.     function saveupdate(){
  473.         $spk $this->param($this->spkName);
  474.         $dpk $this->param($this->dpkName);
  475.         $page $this->param($this->offsetParameterName);
  476.  
  477.         $rep $this->getResponse('redirect');
  478.         $rep->params[$this->spkName$spk;
  479.  
  480.         $id $this->_getPk($spk$dpk);
  481.         $form jForms::fill($this->form$id);
  482.         if$form === null || $dpk === null){
  483.             $rep->action $this->_getAction('index');
  484.             return $rep;
  485.         }
  486.  
  487.         $rep->params[$this->dpkName$dpk;
  488.         $rep->params[$this->offsetParameterName$page;
  489.  
  490.         if($form->check(&& $this->_checkData($spk$formtrue)){
  491.             $results $form->prepareDaoFromControls($this->dao$id$this->dbProfile);
  492.             extract($resultsEXTR_PREFIX_ALL"form");
  493.             $this->_beforeSaveUpdate($form$form_daorec$id);
  494.             $form_dao->update($form_daorec);
  495.             $rep->action $this->_getAction('view');
  496.             $this->_afterUpdate($form$id$rep);
  497.             if ($this->uploadsDirectory !== false)
  498.                 $form->saveAllFiles($this->uploadsDirectory);
  499.             jForms::destroy($this->form$id);
  500.         else {
  501.             $rep->action $this->_getAction('editupdate');
  502.         }
  503.         return $rep;
  504.     }
  505.  
  506.     /**
  507.      * overload this method if you wan to do additionnal things on the dao generated by the
  508.      * jFormsBase::prepareDaoFromControls method
  509.      * @param jFormsBase $form the form
  510.      * @param jDaoRecordBase $form_daorec 
  511.      * @param mixed $id the new id of the updated record
  512.      */
  513.     protected function _beforeSaveUpdate($form$form_daorec$id{
  514.  
  515.     }
  516.  
  517.     /**
  518.      * overload this method if you wan to do additionnal things after the update of
  519.      * a record. For example, you can handle here the uploaded files. If you do
  520.      * such handling, set the uploadsDirectory property to false, to prevent
  521.      * the default behavior on uploaded files in the controller.
  522.      * @param jFormsBase $form the form object
  523.      * @param mixed $id the new id of the updated record
  524.      * @param jResponseHtml $resp the response
  525.      */
  526.     protected function _afterUpdate($form$id$resp{
  527.  
  528.     }
  529.  
  530.     /**
  531.      * displays a record
  532.      */
  533.     function view(){
  534.  
  535.         $spk $this->param($this->spkName);
  536.         $dpk $this->param($this->dpkName);
  537.         $page $this->param($this->offsetParameterName);
  538.  
  539.         if$dpk === null ){
  540.             $rep $this->getResponse('redirect');
  541.             $rep->action $this->_getAction('index');
  542.             $rep->params[$this->spkName$spk;
  543.             return $rep;
  544.         }
  545.         $rep $this->_getResponse();
  546.  
  547.         $id $this->_getPk($spk$dpk);
  548.  
  549.         // we're using a form to display a record, to have the portunity to have
  550.         // labels with each values. We need also him to load easily values of some
  551.         // of controls with initControlFromDao (to use in _view method).
  552.         $form jForms::create($this->form$id);
  553.         $form->initFromDao($this->dao$id$this->dbProfile);
  554.  
  555.         $tpl new jTpl();
  556.         $tpl->assign('dpk'$dpk);
  557.         $tpl->assign('dpkName'$this->dpkName);
  558.         $tpl->assign('spkName'$this->spkName);
  559.         $tpl->assign('spk'$spk);
  560.         $tpl->assign('form',$form);
  561.         $tpl->assign('page',$page);
  562.         $tpl->assign('offsetParameterName',$this->offsetParameterName);
  563.         $tpl->assign('editAction' $this->_getAction('preupdate'));
  564.         $tpl->assign('deleteAction' $this->_getAction('delete'));
  565.         $tpl->assign('listAction' $this->_getAction('index'));
  566.         $this->_view($form$rep$tpl);
  567.         $rep->body->assign($this->templateAssign$tpl->fetch($this->viewTemplate));
  568.         return $rep;
  569.     }
  570.  
  571.     /**
  572.      * overload this method if you want to do additionnal things on the response and on the view template
  573.      * during the view action.
  574.      * @param jFormsBase $form the form
  575.      * @param jResponseHtml $resp the response
  576.      * @param jtpl $tpl the template to display the form content
  577.      */
  578.     protected function _view($form$resp$tpl{
  579.  
  580.     }
  581.  
  582.     /**
  583.      * delete a record
  584.      */
  585.     function delete(){
  586.         $spk $this->param($this->spkName);
  587.         $dpk $this->param($this->dpkName);
  588.         $page $this->param($this->offsetParameterName);
  589.  
  590.         $rep $this->getResponse('redirect');
  591.         $rep->action $this->_getAction('index');
  592.         $rep->params[$this->spkName$spk;
  593.         $rep->params array($this->offsetParameterName=>$page);
  594.  
  595.         $dao jDao::get($this->dao$this->dbProfile);
  596.         $id $this->_getPk($spk$dpk$dao);
  597.         if$dpk !== null && $this->_delete($spk$dpk$rep) ){
  598.             $dao->delete($id);
  599.         }
  600.         return $rep;
  601.     }
  602.  
  603.     /**
  604.      * overload this method if you want to do additionnal things before the deletion of a record
  605.      * @param mixed $spk the static value of the primary key of the record to delete
  606.      * @param mixed $dpk the dynamic value of the primary key of the record to delete
  607.      * @return boolean true if the record can be deleted
  608.      * @param jResponseHtml $resp the response
  609.      */
  610.     protected function _delete($spk$dpk$resp{
  611.         return true;
  612.     }
  613.  
  614. }

Documentation generated on Mon, 26 Oct 2015 21:52:22 +0100 by phpDocumentor 1.4.3