b2evolution

Multilingual multiuser multiblog engine

b2evolution Technical Documentation (Version 1.10) [ class tree: main ] [ index: main ] [ all elements ]

Source for file _listeditor.php

Documentation is available at _listeditor.php

  1. <?php
  2. /**
  3.  * This file implements the generic list editor
  4.  *
  5.  * @deprecated use genreic listeditor instead
  6.  *
  7.  * @version $Id: _listeditor.php,v 1.7 2006/06/14 17:26:13 fplanque Exp $
  8.  */
  9. if!defined('EVO_MAIN_INIT') ) die'Please, do not access this page directly.' );
  10.  
  11. /**
  12.  * Includes:
  13.  */
  14. param'action''string''list' );
  15. param'ID''integer');
  16.  
  17. // Init fadeout result array:
  18. $result_fadeout array();
  19.  
  20. /**
  21.  * Check locked elements
  22.  */
  23. if!empty$locked_IDs )
  24.         && in_array$actionarray'edit''update''delete' ) )
  25.         && in_array$ID$locked_IDs ) )
  26. {
  27.     $Messages->addT_('This element is locked and cannot be edited!') );
  28.     $action 'list';
  29. }
  30.  
  31.  
  32. /**
  33.  * Perform action:
  34.  */
  35. switch$action )
  36. {
  37.     case 'copy':
  38.     case 'edit':
  39.         ifisset$perm_name ) )
  40.         {    // We need to Check permission:
  41.             $current_User->check_perm$perm_name$perm_leveltrue );
  42.         }
  43.  
  44.         $name $DB->get_var"
  45.                 SELECT $edited_table_namecol
  46.                   FROM $edited_table
  47.                  WHERE $edited_table_IDcol = $ID);
  48.  
  49.         if$DB->num_rows != )
  50.         {
  51.             $Messages->head T_('Cannot edit entry!');
  52.             $Messages->addT_('Requested entry does not exist any longer.')'error' );
  53.             $action 'list';
  54.         }
  55.         break;
  56.  
  57.  
  58.     case 'create':
  59.         // Insert into database...:
  60.  
  61.         ifisset$perm_name ) )
  62.         {    // We need to Check permission:
  63.             $current_User->check_perm$perm_name$perm_leveltrue );
  64.         }
  65.  
  66.         $Request->param'name''string'true );
  67.         if$Request->param_check_not_empty'name'T_('Please enter a string.') ) )
  68.         {
  69.             $DB->begin();
  70.  
  71.             if!empty$edited_table_ordercol ) )
  72.             // The element has an order field in database
  73.                 if$max_order $DB->get_var"SELECT MAX($edited_table_ordercol) FROM $edited_table) )
  74.                 {    // The new element order must be the lastest
  75.                     $max_order++;
  76.                 }
  77.                 else
  78.                 // There are no elements in the database yet, so his order is set to 1.
  79.                     $max_order 1;
  80.                 }
  81.             }
  82.             $DB->query"
  83.                 INSERT INTO $edited_table$edited_table_namecol".
  84.                 (isset$edited_table_ordercol ', '.$edited_table_ordercol '')
  85.               .(isset$edited_table_filtercol ', '.$edited_table_filtercol '')
  86.                 .')
  87.                 VALUES( '.$DB->quote($name).
  88.                 (isset$edited_table_ordercol ', '.$max_order '')
  89.                 .(isset$edited_table_filtercol ', '.$val_filtercol '')
  90.                 .' )' );
  91.  
  92.             $DB->commit();
  93.  
  94.             // Add the ID of the new object to the result fadeout
  95.             $result_fadeout[$edited_table_IDcol][$DB->insert_id;
  96.  
  97.             $Messages->addT_('Entry created.')'success' );
  98.             $name '';
  99.         }
  100.         break;
  101.  
  102.  
  103.     case 'update':
  104.         // Update in database...:
  105.  
  106.         ifisset$perm_name ) )
  107.         {    // We need to Check permission:
  108.             $current_User->check_perm$perm_name$perm_leveltrue );
  109.         }
  110.  
  111.         $Request->param'ID''integer'true );
  112.         if$Request->param_string_not_empty'name'T_('Please enter a string.') ) )
  113.         {    // Update in database
  114.             $DB->query"
  115.                 UPDATE $edited_table
  116.                    SET $edited_table_namecol = ".$DB->quote($name)."
  117.                  WHERE $edited_table_IDcol = $ID);
  118.  
  119.             $Messages->addsprintfT_('Entry #%d updated.')$ID )'success' );
  120.             // Add the object ID to the result fadeout
  121.             $result_fadeout[$edited_table_IDcol][$ID;
  122.             unset$ID );
  123.             $name '';
  124.         }
  125.         else
  126.         {
  127.             $action 'edit';
  128.         }
  129.         break;
  130.  
  131.  
  132.     case 'delete':
  133.         // Delete entry:
  134.  
  135.         ifisset$perm_name ) )
  136.         {    // We need to Check permission:
  137.             $current_User->check_perm$perm_name$perm_leveltrue );
  138.         }
  139.  
  140.         param'ID''integer'true );
  141.  
  142.         ifparam'confirm''integer') )
  143.         // confirmed
  144.             // Delete from DB:
  145.             $DB->query"
  146.                 DELETE FROM $edited_table
  147.                 WHERE $edited_table_IDcol = $ID);
  148.  
  149.             if$DB->rows_affected != )
  150.             {
  151.                 $Messages->head T_('Cannot delete entry!');
  152.                 $Messages->addT_('Requested entry does not exist any longer.')'error' );
  153.             }
  154.             else
  155.             {
  156.                 $Messages->addsprintfT_('Entry #%d deleted.')$ID )'success' );
  157.             }
  158.             unset$ID );
  159.             $action 'list';
  160.         }
  161.         elseifisset$delete_restrictions ) )
  162.         {  // Not confirmed, delete restrictions set, so check for restrictions:
  163.             foreach$delete_restrictions as $restriction )
  164.             {
  165.                 if!isset$db_config['aliases'][$restriction['table']] ) )
  166.                 {    // We have no declaration for this table, we consider we don't deal with this table in this app:
  167.                     continue;
  168.                 }
  169.                 $count $DB->get_var(
  170.                     'SELECT COUNT(*)
  171.                        FROM '.$restriction['table'].'
  172.                       WHERE '.$restriction['fk'].' = '.$ID,
  173.                     00'restriction/cascade check' );
  174.                 if$count )
  175.                 {
  176.                     $Messages->addsprintf$restriction['msg']$count )'restrict' );
  177.                 }
  178.             }
  179.             if$Messages->count('restrict') )
  180.             {    // There are restrictions:
  181.                 $Messages->head array(
  182.                         'container' => $restrict_title,
  183.                         'restrict' => T_('The following relations prevent deletion:')
  184.                     );
  185.                 $Messages->foot =    T_('Please delete related objects before you proceed.');
  186.             }
  187.             else
  188.             // There are no restrictions, so we can display delete dialog
  189.                 $checked_delete true;
  190.             }
  191.         }
  192.         else
  193.         {    // No delete restrictions to check, so we can display delete dialog
  194.             $checked_delete true;
  195.         }
  196.  
  197.         $name '';
  198.         break;
  199.  
  200.  
  201.     case 'move_up':
  202.         // Move up
  203.  
  204.         ifisset$perm_name ) )
  205.         {    // We need to Check permission:
  206.             $current_User->check_perm$perm_name$perm_leveltrue );
  207.         }
  208.  
  209.         $ID param$edited_table_prefix.'ID''integer'true );
  210.  
  211.         $DB->begin();
  212.  
  213.         // Test if the ID exist and set his order
  214.         $order $DB->get_var"SELECT $edited_table_ordercol
  215.                                                           FROM $edited_table
  216.                                                          WHERE $edited_table_IDcol = $ID);
  217.  
  218.         if$DB->num_rows != )
  219.         {
  220.             $Messages->head T_('Cannot edit entry!');
  221.             $Messages->addT_('Requested entry does not exist any longer.')'error' );
  222.             $action 'list';
  223.             $name '';
  224.             $DB->commit();
  225.             break;
  226.             /* break */
  227.         }
  228.  
  229.         // Get the ID and the order of the inferior element which his order is the nearest
  230.         $rows $DB->get_results"SELECT $edited_table_IDcol$edited_table_ordercol
  231.                                                                    FROM $edited_table
  232.                                                                 WHERE $edited_table_ordercol < $order"
  233.                                                         .(isset$edited_table_filtercol ' AND '.$edited_table_filtercol.' = '.$val_filtercol 0)
  234.                                                     ." ORDER BY $edited_table_ordercol DESC
  235.                                                                  LIMIT 0,1);
  236.  
  237.         ifcount$rows ) )
  238.         {
  239.             $name_ID $edited_table_prefix.'ID';
  240.             $ID_inf $rows[0]->$name_ID;
  241.  
  242.             $name_order $edited_table_prefix.'order';
  243.             $order_inf $rows[0]->$name_order;
  244.  
  245.             // Update the order of the ID
  246.             $DB->query"UPDATE $edited_table
  247.                                             SET $edited_table_ordercol = $order_inf
  248.                                         WHERE $edited_table_IDcol = $ID);
  249.  
  250.             // Update the order of the inferior element
  251.             $DB->query"UPDATE $edited_table
  252.                                             SET $edited_table_ordercol = $order
  253.                                         WHERE $edited_table_IDcol = $ID_inf);
  254.  
  255.         // EXPERIMENTAL FOR FADEOUT RESULT
  256.             $result_fadeout[$edited_table_IDcol][$ID;
  257.             $result_fadeout[$edited_table_IDcol][$ID_inf;
  258.         }
  259.         else
  260.         {
  261.             $Messages->addT_('This element is already at the top.')'error' );
  262.         }
  263.  
  264.         $DB->commit();
  265.  
  266.         $name '';
  267.         break;
  268.  
  269.  
  270.     case 'move_down':
  271.         // Move down
  272.  
  273.         ifisset$perm_name ) )
  274.         {    // We need to Check permission:
  275.             $current_User->check_perm$perm_name$perm_leveltrue );
  276.         }
  277.  
  278.         $ID param$edited_table_prefix.'ID''integer'true );
  279.  
  280.         $DB->begin();
  281.  
  282.         // Test if the ID exist and set his order
  283.         $order $DB->get_var"SELECT $edited_table_ordercol
  284.                                                           FROM $edited_table
  285.                                                          WHERE $edited_table_IDcol = $ID);
  286.  
  287.         if$DB->num_rows != )
  288.         {
  289.             $Messages->head T_('Cannot edit entry!');
  290.             $Messages->addT_('Requested entry does not exist any longer.')'error' );
  291.             $action 'list';
  292.             $name '';
  293.             $DB->commit();
  294.             break;
  295.             /* break */
  296.         }
  297.  
  298.         // Get the ID and the order of the inferior element which his order is the nearest
  299.         $rows $DB->get_results"SELECT $edited_table_IDcol$edited_table_ordercol
  300.                                                                    FROM $edited_table
  301.                                                                 WHERE $edited_table_ordercol > $order"
  302.                                                         .(isset$edited_table_filtercol ' AND '.$edited_table_filtercol.' = '.$val_filtercol 0)
  303.                                                     ." ORDER BY $edited_table_ordercol ASC
  304.                                                                  LIMIT 0,1);
  305.  
  306.         ifcount$rows ) )
  307.         {
  308.             $name_ID $edited_table_prefix.'ID';
  309.             $ID_sup $rows[0]->$name_ID;
  310.  
  311.             $name_order $edited_table_prefix.'order';
  312.             $order_sup $rows[0]->$name_order;
  313.  
  314.             // Update the order of the ID
  315.             $DB->query"UPDATE $edited_table
  316.                                             SET $edited_table_ordercol = $order_sup
  317.                                         WHERE $edited_table_IDcol = $ID);
  318.  
  319.             // Update the order of the superior element
  320.             $DB->query"UPDATE $edited_table
  321.                                             SET $edited_table_ordercol = $order
  322.                                         WHERE $edited_table_IDcol = $ID_sup);
  323.  
  324.             // EXPERIMENTAL FOR FADEOUT RESULT
  325.             $result_fadeout[$edited_table_IDcol][$ID;
  326.             $result_fadeout[$edited_table_IDcol][$ID_sup;
  327.         }
  328.         else
  329.         {
  330.             $Messages->addT_('This element is already at the bottom.')'error' );
  331.         }
  332.  
  333.  
  334.         $DB->commit();
  335.  
  336.         $name '';
  337.         break;
  338.  
  339.  
  340.     case 'sort_by_order':
  341.         // The list is sorted by the order column now.
  342.         $Request->set_param'results_'.$edited_table_prefix.'order''--A');
  343.         $name '';
  344.         $action 'list';
  345.         break;
  346.  
  347.  
  348.     default:
  349.         $name '';
  350. }
  351.  
  352.  
  353. // Display <html><head>...</head> section! (Note: should be done early if actions do not redirect)
  354. $AdminUI->disp_html_head();
  355.  
  356. // Display title, menu, messages, etc. (Note: messages MUST be displayed AFTER the actions)
  357. $AdminUI->disp_body_top();
  358.  
  359.  
  360. /**
  361.  * Display payload:
  362.  */
  363. if( ($action == 'delete'&& !$confirm && $checked_delete )
  364. {
  365.     ?>
  366.     <div class="panelinfo">
  367.         <h3><?php printfT_('Delete entry #%d?')$ID )?></h3>
  368.  
  369.         <p><?php echo T_('THIS CANNOT BE UNDONE!'?></p>
  370.  
  371.         <?php
  372.         $Form new Form'''form_delete''get''' );
  373.  
  374.         $Form->begin_form'inline' );
  375.         $Form->hidden'action''delete' );
  376.         $Form->hidden'ID'$ID );
  377.         $Form->hidden'confirm');
  378.  
  379.         // We may need to use memorized params in the next page
  380.         $Form->hiddens_by_keyget_memorized'action,ID') );
  381.  
  382.         $Form->submitarray''T_('I am sure!')'DeleteButton' ) );
  383.         $Form->end_form();
  384.  
  385.         $Form new Form'''form_cancel''get''' );
  386.  
  387.         $Form->begin_form'inline' );
  388.         $Form->hiddens_by_keyget_memorized'action,ID') );
  389.         $Form->buttonarray'submit'''T_('CANCEL')'CancelButton' ) );
  390.         $Form->end_form()
  391.         ?>
  392.  
  393.     </div>
  394.     <?php
  395. }
  396.  
  397.  
  398. // Begin payload block:
  399. $AdminUI->disp_payload_begin();
  400.  
  401.  
  402. // EXPERIMENTAL
  403. if !isset$default_col_order ) )
  404. // The default order column is not set, so the default is the name column
  405.     $default_col_order '-A-';
  406. }
  407.  
  408.  
  409. // Create result set:
  410. $sql "SELECT $edited_table_IDcol$edited_table_namecol
  411.                    FROM $edited_table"
  412.                 . !empty$edited_table_filtercol ' WHERE '.$edited_table_filtercol.' = '.$val_filtercol '' ;
  413.  
  414. $Results new Results(    $sqlisset$edited_table_prefix $edited_table_prefix '',  $default_col_order );
  415.  
  416. ifisset$list_title ) )
  417. {
  418.     $Results->title $list_title;
  419. }
  420.  
  421. $Results->cols[array(
  422.         'th' => T_('ID'),
  423.         'order' => $edited_table_IDcol,
  424.         'th_class' => 'shrinkwrap',
  425.         'td_class' => 'shrinkwrap',
  426.         'td' => "\$$edited_table_IDcol\$",
  427.     );
  428.  
  429. if!isset$perm_name || $current_User->check_perm$perm_name$perm_levelfalse ) )
  430. {    // We have permission permission to edit:
  431.     function link_name$title $ID )
  432.     {
  433.         return '<strong><a href="'.regenerate_url'action,ID''ID='.$ID.'&amp;action=edit' ).'">'.$title.'</a></strong>';
  434.     }
  435. }
  436. else
  437. {
  438.     function link_name$title $ID )
  439.     {
  440.         return '<strong>'.$title.'</strong>';
  441.     }
  442. }
  443. $Results->cols[array(
  444.         'th' => T_('Name'),
  445.         'order' => $edited_table_namecol,
  446.          'td' => '%link_name( #'.$edited_table_namecol.'#, #'.$edited_table_IDcol.'# )%',
  447.     );
  448.  
  449.  
  450. if!isset$perm_name || $current_User->check_perm$perm_name$perm_levelfalse ) )
  451. {    // We have permission permission to edit:
  452.  
  453.     if!empty$edited_table_ordercol ) )
  454.     {
  455.         $Results->cols[array(
  456.                 'th' => T_('Move'),
  457.                 'order' => $edited_table_ordercol,
  458.                 'th_class' => 'shrinkwrap',
  459.                 'td_class' => 'shrinkwrap',
  460.                 'td' => '{move}',
  461.             );
  462.     }
  463.  
  464.     function edit_actions$ID )
  465.     {
  466.         global $locked_IDs;
  467.  
  468.         $r action_iconT_('Duplicate...')'copy'regenerate_url'action''ID='.$ID.'&amp;action=copy' ) );
  469.  
  470.         ifempty$locked_IDs || !in_array$ID$locked_IDs ) )
  471.         // This element is NOT locked:
  472.             $r action_iconT_('Edit...')'edit'regenerate_url'action''ID='.$ID.'&amp;action=edit' ) )
  473.                         .$r
  474.                         .action_iconT_('Delete!')'delete'regenerate_url'action''ID='.$ID.'&amp;action=delete' ) );
  475.  
  476.         }
  477.  
  478.         return $r;
  479.     }
  480.  
  481.     $Results->cols[array(
  482.             'th' => T_('Actions'),
  483.             'td_class' => 'shrinkwrap',
  484.             'td' => '%edit_actions( #'.$edited_table_IDcol.'# )%',
  485.         );
  486.  
  487. }
  488.  
  489.  
  490. // EXPERIMENTAL
  491. // $Results->display();
  492. $Results->displayNULL$result_fadeout );
  493.  
  494.  
  495. // NEW ENTRY / EDIT FORM:
  496. if!isset$perm_name || $current_User->check_perm$perm_name$perm_levelfalse ) )
  497. {    // We have permission permission to edit:
  498.  
  499.     switch$action )
  500.     {
  501.         case 'edit':
  502.         case 'delete':
  503.             $creating false;
  504.             break;
  505.  
  506.         default:
  507.             $creating true;
  508.     }
  509.  
  510.     $Form new form'''leditor_checkchanges' );
  511.  
  512.     $Form->begin_form'fform'$creating T_('New entry'T_('Edit entry') );
  513.  
  514.     $Form->hidden'action'$creating 'create' 'update' );
  515.  
  516.     if$action == 'edit' )
  517.     {
  518.         $Form->hidden'ID'$ID );
  519.         $Form->infoT_('ID')$ID );
  520.     }
  521.  
  522.     $Form->text_input'name'$namemin(40,$edited_name_maxlen)T_('Name')array'maxlength'=>$edited_name_maxlen'required'=>true ) );
  523.  
  524.     if$creating )
  525.     {
  526.         $Form->end_formarray(
  527.             array''''T_('Record')'SaveButton' ),
  528.             array'reset''reset'T_('Reset')'SaveButton' ) ) );
  529.     }
  530.     else
  531.     {
  532.         $Form->end_formarray(
  533.             array''''T_('Update')'SaveButton' ),
  534.             array'reset''reset'T_('Reset')'SaveButton' ) ) );
  535.     }
  536.  
  537. }
  538.  
  539.  
  540. // End payload block:
  541. $AdminUI->disp_payload_end();
  542.  
  543. // Display body bottom, debug info and close </html>:
  544. $AdminUI->disp_global_footer();
  545. ?>

Documentation generated on Tue, 20 May 2008 01:42:34 +0200 by phpDocumentor 1.4.2