1805 lines
76 KiB
PHP
1805 lines
76 KiB
PHP
<?
|
|
/********************************************************************
|
|
* AUTHOR: Clemens "Gullevek" Schwaighofer (www.gullevek.org)
|
|
* CREATED: 2002/10/22
|
|
* VERSION: 2.4.9
|
|
* RELEASED LICENSE: BSD style (use it, u don't have to make YOUR source public)
|
|
* but let me know if u made changes, and please don't redistribute it
|
|
* with your name on it ...
|
|
* SHORT DESCRIPTION:
|
|
* ~ 2003/02/26: decided to move away from single class and change this
|
|
* to extend db_array_io which extends db_io. this is much more efficient
|
|
* in use of vars and use of methods of other classes
|
|
*
|
|
* ~ 2002/10/20: this class contains a set of functions that helps in creating
|
|
* more or less default forms, or supports u in handling normal
|
|
* form data
|
|
*
|
|
* description of the variables && arrays that have to be set ...
|
|
* $name_u_choose=array(
|
|
* # this is the description of ALL fields in the main table
|
|
* "table_array" => array(
|
|
* "name_of_col_in_table" => array(
|
|
* "value" => $name_of_col_in_table",
|
|
* "pk" => 1/0 - sets the primary key (only one)
|
|
* "fk" => 1/0 - sets the foreign key (do not use at the moment ... buggy ;)
|
|
* "mandatory" => 1/0 - triggers * in output, but nor error check
|
|
* "output_name" => "text" - text put as label for the element
|
|
* "type" => "view/text/textarea/date/drop_down_db/drop_down_array/drop_down_db_input/drop_down_db_same_db/radio_array/binary/hidden/file/password"
|
|
* View is special, it just prints out the data as is, will not be saved
|
|
* 1) more will come
|
|
* 2) keep in mind that binary will not be checked, as it is always set to a value (default is "no")
|
|
* ---- the next four fields are only NECESSARY (!!!) for drop_down_db_input
|
|
* "table_name" => the name of the table for the drop down
|
|
* "pk_name" => the pk_name of the table for the drop down
|
|
* "input_name" => the text field name in the table for the drop down
|
|
* "input_value" => the $name of input_name (must be same)
|
|
* "order_by" => "order bY" string for drop_down_db(_input) if no query given but fields set
|
|
* "query" => for drop_down_db/array if no outer query given
|
|
* "preset" => value to preset when array is unset (available for all types)
|
|
* "element_list" => array ( "true", "false") - MUST (!) be set for binary
|
|
* "length" => "nr" - only available for "text" (maxlength)
|
|
* "size" => "nr" - only available for "text" (size of input field)
|
|
* "rows" => "nr" - only available for "textarea"
|
|
* "cols" => "nr" - only available for "textarea"
|
|
* "error_check" => "custom/email/date/number/unique" - 1) more will come
|
|
* "error_regex" => "regex" - if error_check is custom regex here
|
|
* "error_example" => "text" - example input text for error_check (only custom right now)
|
|
* "empty" => "value/text" - ONLY for view. If no data found, set this value
|
|
* --- file:
|
|
* "save_dir" => "directory where it should be saved to
|
|
* "accept_type" => "mime types accepted (mime/text,mime/jpeg ... etc)"
|
|
* ),
|
|
* ...
|
|
* ),
|
|
* # all reference tables (n<->n)
|
|
* "reference_array" => array(
|
|
* "name_u_choose" => array(
|
|
* "table_name" => "table_u_choose_for_n_to_n_table",
|
|
* "other_table_pk" => "primary_key_name_of_reference_table",
|
|
* "output_name" => "Printed out next to multiple select field",
|
|
* "mandatory" => 1/0 for must be selected,
|
|
* "select_size" => size of multiple select field,
|
|
* "query" => "the query to load the multiple select field
|
|
* (select id, concat_ws(" ",name_a, name_b) from reference_table)",
|
|
* "selected" => $var_name for name="xx" in multiple select
|
|
* ),
|
|
* ...
|
|
* ),
|
|
* # fields that should be shown from the load_query and with what aditions
|
|
* "show_fields" => array(
|
|
* array(
|
|
* "name" => "name_of_col_in_query" - col from the query that should be shown
|
|
* "before_value" => "text" - if set this text will be put in FRONT of the value from the col
|
|
* "binary" => array ("true","false") - for 1/0 fields in DB changes it int human readable format
|
|
* ),
|
|
* ...
|
|
* ),
|
|
* # the laod query
|
|
* "load_query" => "query", - query for generting the list in "load" function
|
|
* # the name of the main table
|
|
* "table_name" => "table_name" - the exakt name of the table ...
|
|
* # security levels for load ... usefull is delete with a low number and load with a high
|
|
* "security_level" =>
|
|
* "load" => ... for load to appear
|
|
* "new" => 1... - security level minimum required for new part to appear (goes in hadn with save)
|
|
* "save" => ... - should be same level as new [or its a bit useless]
|
|
* "delete" => ... - for delete
|
|
*
|
|
* example for a page:
|
|
*
|
|
* $form->form_procedure_load(${$form->archive_pk_name});
|
|
* $form->form_procedure_new();
|
|
* $form->form_procedure_save();
|
|
* $form->form_procedure_delete();
|
|
* <HTML start>
|
|
* $form->form_create_load();
|
|
* $form->form_create_new();
|
|
* if ($form->yes)
|
|
* {
|
|
* $from->form_create_element("element_name");
|
|
* $from->form_create_hidden_fields();
|
|
* $form->form_creae_save_delete();
|
|
* }
|
|
* $form->_form();
|
|
* <HTML end>
|
|
*
|
|
* list_of_functions:
|
|
* form_get_col_name_from_key($want_key)
|
|
* returns the value for the key (out of table_array)
|
|
* form_get_col_name_array_from_key($want_key)
|
|
* returns array of values for the searched key ...
|
|
* form_print_msg () [form_error_msg()]
|
|
* returns the HTML formated part with the error msg, if one exists
|
|
* form_procedure_load($id)
|
|
* starts the loading procedure
|
|
* form_procedure_new()
|
|
* starts the new procedure
|
|
* form_procedure_save()
|
|
* starts the save procedure
|
|
* form_procedure_delete()
|
|
* starts the delete procedure
|
|
* form_create_load () [form_load()]
|
|
* returns the HTML part for loading a table row, load_query & field_array have to be set for this!!!!!!
|
|
* form_create_new () [form_new()]
|
|
* returns the HTML part for creating a new table_row
|
|
* form_create_save_delete () [form_delete_save()]
|
|
* returns the HTML part for saveing and deleteing one table_row
|
|
* form_create_element ($element_name, $query="")
|
|
* creates and HTML element based on the description in the table_array array, second parameter is for drop_down fields, either a query for _db or an array for _array
|
|
* form_error_check()
|
|
* checks on errors after submit based on the settings in the table_array array
|
|
* form_set_order()
|
|
* if it finds the order flag set in the table_array sets the order for the current element to MAX+1 from the DB
|
|
* form_unset_table_array()
|
|
* unsets the table_array value fields for new entries
|
|
* form_create_hidden_fields($hidden_array)
|
|
* outputs a string with the HTML hidden fields (array must be $name["hidden_name"]=$hidden_value)
|
|
* form_create_element_reference_table($table_name) [form_show_reference_table()]
|
|
* creates and table tr part for the reference table name given
|
|
* form_load_table_array($pk_id=0)
|
|
* loads the table_array and the reference tables for the pk_id set in the class or given via parameter
|
|
* form_save_table_array($addslashes=0)
|
|
* save table array & reference tables
|
|
* form_delete_table_array()
|
|
* deletes table array & reference tables
|
|
*
|
|
* // debug methods
|
|
* form_dump_table_array()
|
|
* returns a formatted string with alle table_array vars
|
|
*
|
|
* HISTORY:
|
|
* 2005/07/14 (cs) fixed the insert for reference tables, prepared drop down text insert to be correct [untested]
|
|
* 2005/07/08 (cs) added int set for integer insert values
|
|
* 2005/07/07 (cs) bug with protected data, error got triggered even if no delete was pressed
|
|
* 2005/06/30 (cs) changed color settings, they get set from CSS file now
|
|
* 2005/06/29 (cs) finished full support for element_lists
|
|
* 2005/06/24 (cs) added full support for a list in a form, a list is written to an other table and the other table has this forms PK as a FK
|
|
* 2005/06/23 (cs) changed all HTML to Smarty Template Type
|
|
* 2005/06/22 (cs) you can put more than one error check into the error field; alphanumeric check and unique in same table are new
|
|
* 2005/06/21 (cs) changed the error_msg writings to debug
|
|
* 2005/03/31 (cs) fixed the class call with all debug vars
|
|
* 2004/11/10 (cs) fix bug with preset: don't check if set, check if variable is set at all
|
|
* 2004/09/30 (cs) layout change
|
|
* 2003-06-13: error with "protected" flag, fixed and added error msg, if protected flag is detected during
|
|
* delete
|
|
* 2003-06-12: adapted class to register_global_vars off
|
|
* 2003-06-10: in procedure_delete function I added "protected" variable clause, so if this field exists
|
|
* in the DB and is set, you are not able to delete [at the moment used for admin edit user
|
|
* in DB]
|
|
* 2003-05-30: _temp for drop_down_db was added always and not only for same_db
|
|
* 2003-05-28: added drop_down_db_same_db for drop down/input combinations going into the same DB.
|
|
* WARNING!!! please be careful that input_value var name MUST have the ending _temp
|
|
* This might get change in future
|
|
* added a "where" field to the field list, this is only used for the drop_down for selecting
|
|
* only a certain field list. If where is filled out and used in combination with insert (not same_db)
|
|
* then this key will be SET when inserted into the DB !!!
|
|
* 2003-04-09: added open_dir for download of file (URL), save_dir is only for upload (absolute path)
|
|
* added require once for class_db_array_io.inc
|
|
* 2003-03-31: added a file upload module (type==file)
|
|
* 2003-03-20: added form_procedure_new, etc functions so for default calls it is easier to write
|
|
* also added security levels to all functions where it is needed
|
|
* 2003-03-14: changed the static error msgs to dynamic ones
|
|
* 2003-03-13: very bad bug with getting key function. fixed it (set first array value always)
|
|
* reason was that in second if I forgot to check if the second method field was really
|
|
* set, so I compared to empty which was always right.
|
|
* 2003-03-11: started renaming some functions:
|
|
* form_load, form_new, form_delete_save -> form_create_... (and _save_delete)
|
|
* .._show_reference_table -> create_element_reference_table
|
|
* added language array
|
|
* - kept old var names/function names for backward compatbile
|
|
* 2003-03-10: added flag for form_delete_save, first flag hides delete part, second flag
|
|
* hides checkbox for delete, both are set 0 default
|
|
* added drop_down_db_input element type.
|
|
* next to a drop down with elements froma db, there is an input field,
|
|
* if something is input there and not yet in the DB it will be inserted into
|
|
* the db first and then selected in the drop down, if already in db, the element
|
|
* in the drop down will be selected
|
|
* 2003-03-07: form_create_hidden_fields() has to be called mandatory
|
|
* 2003-03-06: if nothing selected for reference table, do not write
|
|
* a wrong return in form_delete_table_array quit the function to early
|
|
* 2003-03-04: drop_down_array value for option was left from array and
|
|
* not right
|
|
* 2003-02-27: added another check in unset if reference array exists
|
|
* 2003-02-26: change form to extend db_array_io and created load, save,
|
|
* delete functions removed all reference table functions,
|
|
* except show function rewrite config array
|
|
* re-wrote the class info vars into array
|
|
* 2003-02-25: added reference table functions
|
|
* 2002-10-22: create this class so creating basic and medium form pages
|
|
* can be handled easy.
|
|
* with a given config file the class handles error checks,
|
|
* save data, loads data, etc
|
|
*********************************************************************/
|
|
|
|
// try to include file from LIBS path, or from normal path
|
|
_spl_autoload('Class.DB.Array.IO.inc');
|
|
|
|
class form extends db_array_io
|
|
{
|
|
// rest
|
|
public $field_array = array (); // for the load statetment describes which elements from the load query should be shown and i which format
|
|
public $load_query; // the query needed for loading a data set (one row in the table)
|
|
public $col_name; // the name of the columen (before _<type>) [used for order button]
|
|
public $yes; // the yes flag that triggers the template to show ALL and not only new/load
|
|
public $msg; // the error msg
|
|
public $error; // the error flag set for printing red error msg
|
|
public $warning; // warning flag, for information (saved, loaded, etc)
|
|
public $archive_pk_name; // the pk name for the load select form
|
|
private $int_pk_name; // primary key, only internal usage
|
|
public $reference_array = array (); // reference arrays -> stored in $this->reference_array[$table_name]=>array();
|
|
public $element_list; // element list for elements next to each other as a special sub group
|
|
public $my_page_name; // the name of the page without .php extension
|
|
// buttons and checkboxes
|
|
public $archive;
|
|
public $new;
|
|
public $really_new;
|
|
public $delete;
|
|
public $really_delete;
|
|
public $save;
|
|
// security publics
|
|
public $group_level_user;
|
|
public $security_levels;
|
|
// layout publics
|
|
public $table_width;
|
|
|
|
// now some default error msgs (english)
|
|
public $language_array = array ();
|
|
|
|
// METHOD constructor
|
|
// PARAMS $db_config -> connect to DB
|
|
// $lang -> language code ("en", "ja", etc)
|
|
// $table_width -> width of table
|
|
// $db_debug -> turns db_io debug on/off (DB_DEBUG as global var does the same)
|
|
public function __construct($db_config, $lang, $table_width = 750, $debug = 0, $db_debug = 0, $echo = 1, $print = 0)
|
|
{
|
|
$this->my_page_name = $this->get_page_name(1);
|
|
// init the language class
|
|
_spl_autoload('Class.l10n.inc');
|
|
$this->l = new l10n($lang);
|
|
// load config array
|
|
// get table array definitions for current page name
|
|
// WARNING: auto spl load does not work with this as it is an array and not a function/object
|
|
// $flag = _spl_autoload('array_'.$this->my_page_name.'.inc');
|
|
include(TABLE_ARRAYS."array_".$this->my_page_name.".inc");
|
|
|
|
$config_array = ${$this->my_page_name};
|
|
|
|
// start the array_io class which will start db_io ...
|
|
parent::__construct($db_config, $config_array["table_array"], $config_array["table_name"], $debug, $db_debug, $echo, $print);
|
|
// here should be a check if the config_array is correct ...
|
|
//
|
|
$this->field_array = $config_array["show_fields"];
|
|
$this->load_query = $config_array["load_query"];
|
|
$this->archive_pk_name = "a_".$this->pk_name;
|
|
$this->col_name = str_replace("_id", "", $this->pk_name);
|
|
$this->int_pk_name = $this->pk_name;
|
|
// check if reference_arrays are given and proceed them
|
|
if (is_array($config_array["reference_arrays"]))
|
|
{
|
|
while (list($key, $value) = each($config_array["reference_arrays"]))
|
|
{
|
|
$this->reference_array[$key] = $value;
|
|
}
|
|
}
|
|
if (is_array($config_array["element_list"]))
|
|
{
|
|
while (list($key, $value) = each($config_array["element_list"]))
|
|
{
|
|
$this->element_list[$key] = $value;
|
|
}
|
|
}
|
|
|
|
// layout
|
|
$this->table_width = $table_width;
|
|
|
|
// set button vars
|
|
$this->archive = $_POST["archive"];
|
|
$this->new = $_POST["new"];
|
|
$this->really_new = $_POST["really_new"];
|
|
$this->delete = $_POST["delete"];
|
|
$this->really_delete = $_POST["really_delete"];
|
|
$this->save = $_POST["save"];
|
|
$this->remove_button = $_POST["remove_button"];
|
|
|
|
// security settings
|
|
$this->group_level_user = $_SESSION["GROUP_LEVEL"];
|
|
// security levels for buttons/actions
|
|
// if array does not exists create basic
|
|
if (!is_array($config_array["security_level"]) || count($config_array["security_level"]) < 4)
|
|
$config_array["security_level"] = array("load" => 100, "new" => 100, "save" => 100, "delete" => 100);
|
|
// write array to class var
|
|
$this->security_level = $config_array["security_level"];
|
|
|
|
// internal
|
|
$this->class_info["form"] = array(
|
|
"class_name" => "Form create",
|
|
"class_version" => "2.4.9",
|
|
"class_created" => "2002-10-22",
|
|
"class_author" => "cs/gullevek/at"
|
|
);
|
|
}
|
|
|
|
// dumps all values into output (for error msg)
|
|
public function form_dump_table_array()
|
|
{
|
|
if (!is_array($this->table_array))
|
|
$this->table_array = array ();
|
|
reset($this->table_array);
|
|
$string .= "<b>TABLE ARRAY DUMP:</b> ".$this->table_name."<br>";
|
|
while (list($key, $value) = each($this->table_array))
|
|
{
|
|
$string .= "<b>$key</b>: ".$value["value"]."<br>";
|
|
}
|
|
return $string;
|
|
}
|
|
|
|
// dekonstruktor
|
|
// writes out error msg to global var
|
|
// closes db connection
|
|
public function __destruct()
|
|
{
|
|
// close DB connection
|
|
parent::__destruct();
|
|
}
|
|
|
|
/*****************************************************
|
|
Along here are wrapper functions for the former, old names
|
|
*/
|
|
|
|
public function form_load()
|
|
{
|
|
return $this->form_create_load();
|
|
}
|
|
|
|
public function form_new($hide_new_checkbox = 0)
|
|
{
|
|
return $this->form_create_new($hide_new_checkbox);
|
|
}
|
|
|
|
public function form_delete_save($hide_delete = 0, $hide_delete_checkbox = 0)
|
|
{
|
|
return $this->form_create_save_delete($hide_delete, $hide_delete_checkbox);
|
|
}
|
|
|
|
public function form_error_msg()
|
|
{
|
|
return $this->form_print_msg();
|
|
}
|
|
|
|
public function form_show_reference_table($table_name)
|
|
{
|
|
return $this->form_create_element_reference_table($table_name);
|
|
}
|
|
|
|
public function form_show_list_table($table_name)
|
|
{
|
|
return $this->form_create_element_list_table($table_name);
|
|
}
|
|
|
|
// END wrapper
|
|
|
|
// METHOD form_get_col_name_from_key
|
|
// PARAMS $want_key: the key where u want the data from
|
|
// $key_value: if set searches for special right value
|
|
// RETURN the value of the $want_key array field
|
|
// works only with fields that appear only ONCE
|
|
// if multiple gets only FIRST
|
|
public function form_get_col_name_from_key($want_key, $key_value = "")
|
|
{
|
|
if (!is_array($this->table_array))
|
|
$this->table_array = array ();
|
|
reset($this->table_array);
|
|
while (list($key, $value) = each($this->table_array))
|
|
{
|
|
if ($value[$want_key] && !$key_value)
|
|
return $key;
|
|
else if ($value[$want_key] == $key_value && $key_value)
|
|
return $key;
|
|
}
|
|
}
|
|
|
|
// METHOD form_get_col_name_array_from_key
|
|
// PARAMS $want_key: the key where u want the data from
|
|
// $key_value: if set searches for special right value
|
|
// RETURN array of fields
|
|
public function form_get_col_name_array_from_key($want_key, $key_value = "")
|
|
{
|
|
$key_array = array();
|
|
if (!is_array($this->table_array))
|
|
$this->table_array = array ();
|
|
reset($this->table_array);
|
|
while (list($key, $value) = each($this->table_array))
|
|
{
|
|
if ($value[$want_key] && !$key_value)
|
|
array_push($key_array, $key);
|
|
if ($value[$want_key] == $key_value)
|
|
array_push($key_array, $key);
|
|
}
|
|
return $key_array;
|
|
}
|
|
|
|
// METHOD form_print_msg
|
|
// PARAMS none
|
|
// RETURN formated output for the error && warning msg
|
|
public function form_print_msg()
|
|
{
|
|
if ($this->error)
|
|
{
|
|
$class = "error";
|
|
}
|
|
if ($this->warning)
|
|
{
|
|
$class = "warning";
|
|
}
|
|
return array('msg' => $this->msg, 'width' => $this->table_width, 'class' => $class);
|
|
}
|
|
|
|
// next for functions are pre_test fkts for easier default new,load, etc handling
|
|
// METHOD form_procedure_load
|
|
// PARAMS archive_id - which ID should be loaded
|
|
// RETURN none
|
|
// DESC default load procedure
|
|
public function form_procedure_load($archive_id)
|
|
{
|
|
if ($this->archive && $archive_id && $this->group_level_user <= $this->security_level["load"])
|
|
{
|
|
$this->form_load_table_array($archive_id);
|
|
$this->yes = 1;
|
|
}
|
|
}
|
|
|
|
// METHOD form_procedure_new
|
|
// PARAMS none
|
|
// RETURN none
|
|
// DESC default new procedure
|
|
public function form_procedure_new()
|
|
{
|
|
if ($this->new && $this->group_level_user <= $this->security_level["new"])
|
|
{
|
|
if ($this->really_new == "yes")
|
|
{
|
|
$this->form_unset_table_array();
|
|
} else
|
|
{
|
|
$this->msg .= $this->l->__("You have to select the <b>Checkbox for New</b>!<br>");
|
|
$this->error = 2;
|
|
}
|
|
$this->yes = 1;
|
|
}
|
|
}
|
|
|
|
// METHOD form_procedure_save
|
|
// PARAMS none
|
|
// RETURN none
|
|
// DESC default save procedure
|
|
public function form_procedure_save()
|
|
{
|
|
if ($this->save && $this->group_level_user <= $this->security_level["save"])
|
|
{
|
|
$this->form_error_check();
|
|
if (!$this->error)
|
|
{
|
|
$this->form_save_table_array();
|
|
}
|
|
$this->yes = 1;
|
|
}
|
|
}
|
|
|
|
// METHOD form_procedure_delete
|
|
// PARAMS none
|
|
// RETURN none
|
|
// DESC default delete procedure
|
|
public function form_procedure_delete()
|
|
{
|
|
// delete is also by "protected"
|
|
if ($this->delete && $this->group_level_user <= $this->security_level["delete"] && !$this->table_array["protected"]["value"])
|
|
{
|
|
if ($this->table_array["protected"]["value"])
|
|
{
|
|
$this->msg .= $this->l->__("Cannot delete this Dataset, because it is internaly protected!");
|
|
$this->error = 2;
|
|
}
|
|
if ($this->really_delete == "yes")
|
|
{
|
|
$this->form_delete_table_array();
|
|
}
|
|
else
|
|
{
|
|
$this->msg .= $this->l->__("You have to select the <b>Checkbox for Delete</b>!<br>");
|
|
$this->error = 2;
|
|
$this->yes = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// METHOD form_procedure_delete_from_element_list
|
|
// PARAMS none
|
|
// RETURN none
|
|
// DESC default delete procedure
|
|
public function form_procedure_delete_from_element_list($element_list, $remove_name)
|
|
{
|
|
// only do if the user is allowed to delete
|
|
if ($this->group_level_user <= $this->security_level["delete"] && !$this->table_array["protected"]["value"] && !$this->error)
|
|
{
|
|
for ($i = 0; $i < count($element_list); $i ++)
|
|
{
|
|
//$this->debug('form_error', "Array: ".is_array($this->element_list[$element_list[$i]]["read_data"])." | ".$this->element_list[$element_list[$i]]["delete"]);
|
|
// if prefix, set it
|
|
$prfx = ($this->element_list[$element_list[$i]]["prefix"]) ? $this->element_list[$element_list[$i]]["prefix"]."_" : '';
|
|
// get the primary key
|
|
while (list($el_name, $data) = each($this->element_list[$element_list[$i]]["elements"]))
|
|
{
|
|
if ($data["pk_id"])
|
|
$pk_name = $el_name;
|
|
}
|
|
// which key should be deleted
|
|
$id = $remove_name[$i];
|
|
if (($this->element_list[$element_list[$i]]["delete_name"] || $this->element_list[$element_list[$i]]["delete"]) && !$this->element_list[$element_list[$i]]["enable_name"])
|
|
{
|
|
// flag var name
|
|
$flag = $remove_name[$i]."_flag";
|
|
|
|
if ($_POST[$flag] == "true")
|
|
{
|
|
$q = "DELETE FROM ".$element_list[$i]." WHERE ".$pk_name." = ".$_POST[$id];
|
|
$this->db_exec($q);
|
|
$this->msg .= $this->l->__("Removed entry from list<br>");
|
|
$this->warning = 1;
|
|
} // post okay true -> delete
|
|
}
|
|
elseif (is_array($this->element_list[$element_list[$i]]["read_data"]) && !$this->element_list[$element_list[$i]]["delete"])
|
|
{
|
|
for ($j = 0; $j < count($_POST[$id]); $j ++)
|
|
{
|
|
// if it is not activated
|
|
if (!$_POST[$remove_name[$i]][$j])
|
|
{
|
|
$q = "UPDATE ".$element_list[$i]." WHERE ".$pk_name." = ".$_POST[$prfx.$pk_name][$j];
|
|
// $this->debug('edit_db', "UP: $q");
|
|
// $this->db_exec($q);
|
|
$this->msg .= $this->l->__("Disabled deselected entries from list<br>");
|
|
$this->warning = 1;
|
|
}
|
|
}
|
|
}
|
|
elseif (is_array($this->element_list[$element_list[$i]]["read_data"]) && $this->element_list[$element_list[$i]]["delete"])
|
|
{
|
|
//$this->debug('form_clean', "ID [$id] [$prfx.$pk_name]");
|
|
//$this->debug('form_clean', "ID arr: ".$this->print_ar($_POST[$id]));
|
|
//$this->debug('form_clean', "PK arr: ".$this->print_ar($_POST[$prfx.$pk_name]));
|
|
for ($j = 0; $j < count($_POST[$prfx.$pk_name]); $j ++)
|
|
{
|
|
if (!$_POST[$remove_name[$i]][$j] && $_POST[$prfx.$pk_name][$j])
|
|
{
|
|
$q = "DELETE FROM ".$element_list[$i]." WHERE ".$pk_name." = ".$_POST[$prfx.$pk_name][$j];
|
|
// $this->debug('edit_db', "DEL: $q");
|
|
$this->db_exec($q);
|
|
$this->msg .= $this->l->__("Deleted deselected entries from list<br>");
|
|
$this->warning = 1;
|
|
}
|
|
}
|
|
}
|
|
} // for each element group
|
|
}
|
|
if ($this->remove_button)
|
|
$this->yes = 1;
|
|
}
|
|
|
|
// METHOD form_create_load
|
|
// PARAMS none
|
|
// RETURN string from "load" part of form ...
|
|
public function form_create_load()
|
|
{
|
|
// when security leve is okay ...
|
|
if ($this->group_level_user <= $this->security_level["load"])
|
|
{
|
|
$t_pk_name = $this->archive_pk_name;
|
|
|
|
// lade liste
|
|
$this->db_exec($this->load_query);
|
|
while ($res = $this->db_fetch_array())
|
|
{
|
|
$pk_ids[] = $res[$this->int_pk_name];
|
|
if ($res[$this->int_pk_name] == $this->table_array[$this->int_pk_name]["value"])
|
|
{
|
|
$pk_selected = $res[$this->int_pk_name];
|
|
}
|
|
unset($t_string);
|
|
for ($i = 0; $i < count($this->field_array); $i ++)
|
|
{
|
|
if ($t_string)
|
|
$t_string .= ", ";
|
|
if ($this->field_array[$i]["before_value"])
|
|
$t_string .= $this->field_array[$i]["before_value"];
|
|
if ($this->field_array[$i]["binary"])
|
|
$t_string .= ($res[$this->field_array[$i]["name"]]) ? $this->field_array[$i]["binary"][0] : $this->field_array[$i]["binary"][1];
|
|
else
|
|
$t_string .= $res[$this->field_array[$i]["name"]];
|
|
}
|
|
/*
|
|
//<? echo $res["question"]." (Lang: ".$res["lang_name"].", Freigeschalten: ".ucfirst($res["enabled"]?"ja":"nein").")"; ?>
|
|
*/
|
|
$pk_names[] = $t_string;
|
|
}
|
|
} // show it at all
|
|
return array('t_pk_name' => $t_pk_name, 'pk_ids' => $pk_ids, 'pk_names' => $pk_names, 'pk_selected' => $pk_selected);
|
|
}
|
|
|
|
// METHOD form_create_new
|
|
// PARAMS none
|
|
// RETURN part for new
|
|
public function form_create_new($hide_new_checkbox = 0)
|
|
{
|
|
// when security level is okay
|
|
if ($this->group_level_user <= $this->security_level["new"])
|
|
{
|
|
if ($this->yes && !$hide_new_checkbox)
|
|
{
|
|
$show_checkbox = 1;
|
|
}
|
|
// set type of new name
|
|
if ($this->yes)
|
|
$new_name = $this->l->__("Clear all and create new");
|
|
else
|
|
$new_name = $this->l->__("New");
|
|
} // security level okay
|
|
return array('new_name' => $new_name, 'show_checkbox' => $show_checkbox);
|
|
}
|
|
|
|
// METHOD form_create_save_delete
|
|
// PARAMS none
|
|
// RETURN string for delete / save part
|
|
public function form_create_save_delete($hide_delete = 0, $hide_delete_checkbox = 0)
|
|
{
|
|
if ($this->group_level_user <= $this->security_level["save"] || $this->group_level_user <= $this->security_level["delete"])
|
|
{
|
|
$old_school_hidden = 0;
|
|
if ($this->group_level_user <= $this->security_level["save"])
|
|
{
|
|
$seclevel_okay = 1;
|
|
if (!$this->table_array[$this->int_pk_name]["value"])
|
|
{
|
|
$save = $this->l->__("Save");
|
|
}
|
|
else
|
|
{
|
|
$save = $this->l->__("Update");
|
|
}
|
|
// print the old_school hidden if requestet
|
|
if ($old_school_hidden)
|
|
{
|
|
$pk_name = $this->int_pk_name;
|
|
$pk_value = $this->table_array[$this->int_pk_name]["value"];
|
|
}
|
|
} // show save part
|
|
// show delete part only if pk is set && we want to see the delete
|
|
if ($this->table_array[$this->int_pk_name]["value"] && !$hide_delete && $this->group_level_user <= $this->security_level["delete"])
|
|
{
|
|
$show_delete = 1;
|
|
}
|
|
} // print save/delete row at all$
|
|
return array('seclevel_okay' => $seclevel_okay, 'save' => $save, 'pk_name' => $pk_name, 'pk_value' => $pk_value, 'show_delete' => $show_delete, 'hide_delete_checkbox' => $hide_delete_checkbox);
|
|
} // end of function
|
|
|
|
// METHOD form_create_element
|
|
// PARAMS $element_name: the name from the array, you want to have build
|
|
// $query: can overrule internal query data,
|
|
// for drop down, as data comes from a reference table
|
|
// for drop_down_text it has to be an array with $key->$value
|
|
// RETURN element in HTML
|
|
public function form_create_element($element_name, $query = "")
|
|
{
|
|
// special 2nd color for "binary" attribut
|
|
if ($this->table_array[$element_name]["type"] == "binary" && !$this->table_array[$element_name]["value"])
|
|
$EDIT_FGCOLOR_T = 'edit_fgcolor_no';
|
|
else
|
|
$EDIT_FGCOLOR_T = 'edit_fgcolor';
|
|
$output_name = $this->table_array[$element_name]["output_name"];
|
|
if ($this->table_array[$element_name]["mandatory"])
|
|
$output_name .= ' *';
|
|
// create right side depending on "definiton" in table_array
|
|
$type = $this->table_array[$element_name]["type"];
|
|
// view only output
|
|
if ($this->table_array[$element_name]["type"] == "view")
|
|
{
|
|
$data['value'] = !$this->table_array[$element_name]["value"] ? $this->table_array[$element_name]['empty'] : $this->table_array[$element_name]["value"];
|
|
}
|
|
// binary true/false element
|
|
if ($this->table_array[$element_name]["type"] == "binary")
|
|
{
|
|
for ($i = (count($this->table_array[$element_name]["element_list"]) - 1); $i >= 0; $i --)
|
|
{
|
|
$data['value'][] = $i;
|
|
$data['output'][] = $this->table_array[$element_name]["element_list"][$i];
|
|
$data['name'] = $element_name;
|
|
if (($i && $this->table_array[$element_name]["value"]) || (!$i && !$this->table_array[$element_name]["value"]))
|
|
$data['checked'] = $this->table_array[$element_name]["value"];
|
|
|
|
if ($i)
|
|
$data['separator'] = '';
|
|
}
|
|
}
|
|
// checkbox element
|
|
if ($this->table_array[$element_name]["type"] == "checkbox")
|
|
{
|
|
$data['name'] = $element_name;
|
|
$data['value'][] = $this->table_array[$element_name]["element_list"];
|
|
$data['checked'] = $this->table_array[$element_name]["value"];
|
|
}
|
|
// normal text element
|
|
if ($this->table_array[$element_name]["type"] == "text")
|
|
{
|
|
$data['name'] = $element_name;
|
|
$data['value'] = $this->table_array[$element_name]["value"];
|
|
$data['size'] = $this->table_array[$element_name]["size"];
|
|
$data['length'] = $this->table_array[$element_name]["length"];
|
|
}
|
|
// password element, does not write back the value
|
|
if ($this->table_array[$element_name]["type"] == "password")
|
|
{
|
|
$data['name'] = $element_name;
|
|
$data['HIDDEN_value'] = $this->table_array[$element_name]["HIDDEN_value"];
|
|
$data['size'] = $this->table_array[$element_name]["size"];
|
|
$data['length'] = $this->table_array[$element_name]["length"];
|
|
}
|
|
// date (YYYY-MM-DD)
|
|
if ($this->table_array[$element_name]["type"] == "date")
|
|
{
|
|
if (!$this->table_array[$element_name]["value"])
|
|
$this->table_array[$element_name]["value"] = "YYYY-MM-DD";
|
|
$data['name'] = $element_name;
|
|
$data['value'] = $this->table_array[$element_name]["value"];
|
|
}
|
|
// textarea
|
|
if ($this->table_array[$element_name]["type"] == "textarea")
|
|
{
|
|
$data['name'] = $element_name;
|
|
$data['value'] = $this->table_array[$element_name]["value"];
|
|
$data['rows'] = $this->table_array[$element_name]["rows"];
|
|
$data['cols'] = $this->table_array[$element_name]["cols"];
|
|
}
|
|
// for drop_down_*
|
|
if (preg_match("/^drop_down_/", $this->table_array[$element_name]["type"]))
|
|
{
|
|
$type = 'drop_down';
|
|
// outer query overrules inner
|
|
if (!$query)
|
|
$query = $this->table_array[$element_name]["query"];
|
|
}
|
|
// for drop_down_db*
|
|
if (preg_match("/^drop_down_db/", $this->table_array[$element_name]["type"]))
|
|
{
|
|
// if still NO query
|
|
if (!$query)
|
|
{
|
|
// select pk_name, input_name from table_name (order by order_by)
|
|
$query = "SELECT DISTINCT ".$this->table_array[$element_name]["pk_name"].", ".$this->table_array[$element_name]["input_name"]." FROM ".$this->table_array[$element_name]["table_name"];
|
|
// possible where statements
|
|
if ($this->table_array[$element_name]["where"])
|
|
$query .= " WHERE ".$this->table_array[$element_name]["where"];
|
|
// possible order statements
|
|
if ($this->table_array[$element_name]["order_by"])
|
|
$query .= " ORDER BY ".$this->table_array[$element_name]["order_by"];
|
|
}
|
|
// set output data
|
|
$data['name'] = $element_name;
|
|
$data['value'][] = "";
|
|
$data['output'][] = $this->l->__("Please choose ...");
|
|
while ($res = $this->db_return($query))
|
|
{
|
|
$data['value'][] = $res[0];
|
|
$data['output'][] = $res[1];
|
|
if ($this->table_array[$element_name]["value"] == $res[0])
|
|
$data['selected'] = $this->table_array[$element_name]["value"];
|
|
}
|
|
// for _input put additional field next to drop down
|
|
if (preg_match("/^drop_down_db_input/", $this->table_array[$element_name]["type"]))
|
|
{
|
|
$data['drop_down_input'] = 1;
|
|
// pre fill the temp if empty and other side is selected, only for same_db
|
|
if ($this->table_array[$element_name]["type"] == "drop_down_db_input_same_db" && !$this->table_array[$element_name]["input_value"] && $this->table_array[$element_name]["value"])
|
|
$this->table_array[$element_name]["input_value"] = $this->table_array[$element_name]["value"];
|
|
$data['input_value'] = $this->table_array[$element_name]["input_value"];
|
|
$data['input_name'] = $this->table_array[$element_name]["input_name"].(($this->table_array[$element_name]["type"] == "drop_down_db_input_same_db") ? '_temp' : '');
|
|
$data['input_size'] = $this->table_array[$element_name]["size"];
|
|
$data['input_length'] = $this->table_array[$element_name]["length"];
|
|
}
|
|
}
|
|
// drop down array
|
|
if ($this->table_array[$element_name]["type"] == "drop_down_array")
|
|
{
|
|
$data['name'] = $element_name;
|
|
$data['value'][] = "";
|
|
$data['output'][] = $this->l->__("Please choose ...");
|
|
// outer query overrules inner
|
|
while (list($key, $value) = each($query))
|
|
{
|
|
$data['value'][] = $key;
|
|
$data['output'][] = $value;
|
|
if ($this->table_array[$element_name]["value"] == $key)
|
|
$data['selected'] = $this->table_array[$element_name]["value"];
|
|
}
|
|
}
|
|
// radio array
|
|
if ($this->table_array[$element_name]["type"] == "radio_array")
|
|
{
|
|
if (!$query)
|
|
$query = $this->table_array[$element_name]["query"];
|
|
$data['name'] = $element_name;
|
|
while (list($key, $value) = each($query))
|
|
{
|
|
$data['value'][] = $key;
|
|
$data['output'][] = $value;
|
|
if ($this->table_array[$element_name]["value"] == $key)
|
|
$data['checked'] = $this->table_array[$element_name]["value"];
|
|
$data['separator'] = '';
|
|
}
|
|
}
|
|
// for media / not yet implemented
|
|
if ($this->table_array[$element_name]["type"] == "media")
|
|
{
|
|
//media::insert_file($element_name,$this->table_array[$element_name]["value"],$query);
|
|
}
|
|
// order button
|
|
if ($this->table_array[$element_name]["type"] == "order")
|
|
{
|
|
$data['output_name'] = $this->table_array[$element_name]["output_name"];
|
|
$data['name'] = $element_name;
|
|
$data['value'] = $this->table_array[$element_name]["value"];
|
|
$data['col_name'] = $this->col_name;
|
|
$data['table_name'] = $this->table_name;
|
|
$data['query'] = urlencode($query);
|
|
}
|
|
// file upload
|
|
if ($this->table_array[$element_name]["type"] == "file")
|
|
{
|
|
$data['name'] = $element_name;
|
|
// if file for this exsists, print "delete, view stuff"
|
|
if ($this->table_array[$element_name]["value"])
|
|
{
|
|
$data['content'] = 1;
|
|
$data['url'] = $this->table_array[$element_name]["open_dir"].$this->table_array[$element_name]["value"];
|
|
$data['output'] = $this->table_array[$element_name]["value"];
|
|
$data['value'] = $this->table_array[$element_name]["value"];
|
|
}
|
|
}
|
|
return array('output_name' => $output_name, 'color' => $EDIT_FGCOLOR_T, 'type' => $type, 'data' => $data);
|
|
}
|
|
|
|
// METHOD form_error_check
|
|
// PARAMS none
|
|
// RETURNS full error message string for output
|
|
// should be cought like this ...
|
|
// if ($msg=$form->form_error_check())
|
|
// $error=1;
|
|
public function form_error_check()
|
|
{
|
|
if (!is_array($this->table_array))
|
|
$this->table_array = array ();
|
|
reset($this->table_array);
|
|
while (list($key, $value) = each($this->table_array))
|
|
{
|
|
//if ($value["mandatory"] && $value["error_check"])
|
|
// if error value set && somethign input, check if input okay
|
|
if ($value["error_check"] && $this->table_array[$key]["value"])
|
|
{
|
|
// each error check can be a piped seperated value, lets split it
|
|
//$this->debug('edit', $value["error_check"]);
|
|
foreach (explode('|', $value["error_check"]) as $error_check)
|
|
{
|
|
switch ($error_check)
|
|
{
|
|
case "number":
|
|
if (!preg_match("/^[0-9]+(['\,','.']?[0-9]+)*$/", $this->table_array[$key]["value"]))
|
|
$this->msg .= sprintf($this->l->__("Please enter a vailid Number for the <b>%s</b> Field!<br>"), $this->table_array[$key]["output_name"]);
|
|
break;
|
|
case "date": // YYYY-MM-DD
|
|
if (!check_date($this->table_array[$key]["value"], 1))
|
|
$this->msg .= sprintf($this->l->__("Please enter a vailid date (YYYY-MM-DD) for the <b>%s</b> Field!<br>"), $this->table_array[$key]["output_name"]);
|
|
break;
|
|
case "time": // HH:MM[:SS]
|
|
if (!check_time($this->table_array[$key]["value"]))
|
|
$this->msg .= sprintf($this->l->__("Please enter a vailid time (HH:MM[:SS]) for the <b>%s</b> Field!<br>"), $this->table_array[$key]["output_name"]);
|
|
break;
|
|
case "datetime": // YYYY-MM-DD HH:MM[:SS]
|
|
break;
|
|
case "intervalshort": // ony interval n [Y/M/D] only
|
|
if (preg_match("/^\d{1,3}\ ?[YMDymd]{1}$/", $this->table_array[$key]['value']))
|
|
$this->msg .= sprintf($this->l->__('Please enter a valid time interval in the format <length> Y|M|D for the <b>%s</b> Field!<br>'), $this->table[$key]['output_name']);
|
|
case "email":
|
|
if (!preg_match("/$this->email_regex/", $this->table_array[$key]["value"]))
|
|
$this->msg .= sprintf($this->l->__("Please enter a valid E-Mail Address for the <b>%s</b> Field!<br>"), $this->table_array[$key]["output_name"]);
|
|
break;
|
|
// check unique, check if field in table is not yet exist
|
|
case "unique":
|
|
$q = "SELECT ".$key." FROM ".$this->table_name." WHERE ".$key." = '".$this->db_escape_string($this->table_array[$key]["value"])."'";
|
|
if ($this->table_array[$this->int_pk_name]["value"])
|
|
$q .= " AND ".$this->int_pk_name." <> ".$this->table_array[$this->int_pk_name]["value"];
|
|
list($$key) = $this->db_return_row($q);
|
|
if ($$key)
|
|
$this->msg .= sprintf($this->l->__("The field <b>%s</b> can be used only once!<br>"), $this->table_array[$key]["output_name"]);
|
|
break;
|
|
case "custom":
|
|
if (!preg_match($this->table_array[$key]["error_regex"], $this->table_array[$key]["value"]))
|
|
$this->msg .= sprintf($this->l->__("Please enter a valid (%s) input for the <b>%s</b> Field!<br>"), $this->table_array[$key]["error_example"], $this->table_array[$key]["output_name"]);
|
|
break;
|
|
case "alphanumericspace":
|
|
//$this->debug('edit', 'IN Alphanumericspace');
|
|
if (!preg_match("/^[0-9A-Za-z\ ]+$/", $this->table_array[$key]["value"]))
|
|
$this->msg .= sprintf($this->l->__("Please enter a valid alphanumeric (Numbers and Letters, spaces allowed) value for the <b>%s</b> Field!<br>"), $this->table_array[$key]["output_name"]);
|
|
break;
|
|
case "alphanumeric":
|
|
//$this->debug('edit', 'IN Alphanumeric');
|
|
if (!preg_match("/^[0-9A-Za-z_\-]+$/", $this->table_array[$key]["value"]))
|
|
$this->msg .= sprintf($this->l->__("Please enter a valid alphanumeric (Numbers and Letters only also - and _, no spaces) value for the <b>%s</b> Field!<br>"), $this->table_array[$key]["output_name"]);
|
|
break;
|
|
// this one also allows @ and .
|
|
case "alphanumericextended":
|
|
//$this->debug('edit', 'IN Alphanumericextended');
|
|
if (!preg_match("/^[0-9A-Za-z_\-@\.]+$/", $this->table_array[$key]["value"]))
|
|
$this->msg .= sprintf($this->l->__("Please enter a valid alphanumeric extended (Numbers, Letters, -, _, @ and . only, no spaces) value for the <b>%s</b> Field!<br>"), $this->table_array[$key]["output_name"]);
|
|
break;
|
|
case "password":
|
|
// password can only be alphanumeric + special chars
|
|
// password and CONFIRM_password need to be the same
|
|
if ($this->table_array[$key]["value"] != $this->table_array[$key]["CONFIRM_value"])
|
|
{
|
|
// error
|
|
}
|
|
break;
|
|
} // switch
|
|
} // for each error to check
|
|
}
|
|
// if mandatory && no input
|
|
else if ($value["mandatory"] &&
|
|
(
|
|
// for all "normal" fields
|
|
($this->table_array[$key]["type"] != "password" && $this->table_array[$key]["type"] != "drop_down_db_input" && !$this->table_array[$key]["value"]) ||
|
|
// for drop_down_db_input check if one of both fields filled
|
|
($this->table_array[$key]["type"] == "drop_down_db_input" && !$this->table_array[$key]["input_value"] && !$this->table_array[$key]["value"]) ||
|
|
// for password
|
|
($this->table_array[$key]["type"] == "password" && !$this->table_array[$key]["value"] && !$this->table_array[$key]["HIDDEN_value"])
|
|
)
|
|
) // main if end
|
|
{
|
|
//$this->debug('form', "A: ".$this->table_array[$key]["type"]." -- ".$this->table_array[$key]["input_value"]." -- ".$this->table_array[$key]["value"]);
|
|
if (!$this->table_array[$key]["value"] && $this->table_array[$key]["type"] != "binary")
|
|
$this->msg .= sprintf($this->l->__("Please enter something into the <b>%s</b> field!<br>"), $this->table_array[$key]["output_name"]);
|
|
} // mandatory
|
|
// check file upload
|
|
if ($this->table_array[$key]["type"] == "file" && $GLOBALS["_FILES"][$key."_file"]['name'] && is_array($this->table_array[$key]["accept_type"]))
|
|
{
|
|
// check against allowed types
|
|
$mime_okay = 0;
|
|
foreach ($this->table_array[$key]["accept_type"] as $mime_type)
|
|
{
|
|
if ($GLOBALS["_FILES"][$key."_file"]['type'] == $mime_type)
|
|
$mime_okay = 1;
|
|
}
|
|
if (!$mime_okay)
|
|
{
|
|
$this->msg .= sprintf($this->l->__("Uploaded File <b>%s</b> has MIME Type <b>%s</b> which is not in theallowed MIME List for Upload Field <b>%s</b>!<br>"), $GLOBALS["_FILES"][$key."_file"]['name'], $GLOBALS["_FILES"][$key."_file"]['type'], $this->table_array[$key]["output_name"]);
|
|
}
|
|
}
|
|
} // while
|
|
if (is_array($this->reference_array))
|
|
{
|
|
// do check for reference tables
|
|
if (!is_array($this->reference_array))
|
|
$this->reference_array = array ();
|
|
reset($this->reference_array);
|
|
while (list($key, $value) = each($this->reference_array))
|
|
{
|
|
if ($this->reference_array[$key]["mandatory"] && !$this->reference_array[$key]["selected"][0])
|
|
$this->msg .= sprintf($this->l->__("Please select at least one Element from field <b>%s</b>!<br>"), $this->reference_array[$key]["output_name"]);
|
|
}
|
|
}
|
|
//$this->debug('edit_error', "QS: <pre>".print_r($_POST, 1)."</pre>");
|
|
if (is_array($this->element_list))
|
|
{
|
|
// check the mandatory stuff
|
|
// if mandatory, check that at least on pk exists or if at least the mandatory field is filled
|
|
while (list($table_name, $reference_array) = each($this->element_list))
|
|
{
|
|
// set pk/fk id for this
|
|
foreach ($reference_array['elements'] as $_name => $_data)
|
|
{
|
|
if ($_data['pk_id'])
|
|
$_pk_name = $_name;
|
|
if ($_data['fk_id'])
|
|
$_fk_name = $_name;
|
|
}
|
|
// get the leasy of keys from the elements array
|
|
$keys = array_keys($reference_array["elements"]);
|
|
// prefix
|
|
$prfx = ($reference_array["prefix"]) ? $reference_array["prefix"]."_" : '';
|
|
// get max elements
|
|
$max = 0;
|
|
foreach ($keys as $key)
|
|
{
|
|
if (count($_POST[$prfx.$key]) > $max)
|
|
$max = count($_POST[$prfx.$key]);
|
|
//$this->debug('edit_error_chk', "KEY: $prfx$key | count: ".count($_POST[$prfx.$key])." | M: $max");
|
|
//$this->debug('edit_error_chk', "K: ".$_POST[$prfx.$key]." | ".$_POST[$prfx.$key][0]);
|
|
}
|
|
//$this->debug('post_array', $this->print_ar($_POST));
|
|
# check each row
|
|
for ($i = 0; $i < $max; $i ++)
|
|
{
|
|
// either one of the post pks is set, or the mandatory
|
|
while (list($el_name, $data_array) = each($reference_array["elements"]))
|
|
{
|
|
if ($data_array["mandatory"])
|
|
$mand_name = $data_array["output_name"];
|
|
// check if there is a primary ket inside, so it is okay
|
|
if ($data_array["pk_id"] && count($_POST[$prfx.$el_name]) && $reference_array["mandatory"])
|
|
{
|
|
$mand_okay = 1;
|
|
}
|
|
// we found a mandatory field. check now if one is set to satisfy the main mandatory
|
|
// also check, if this field is mandatory and its not set, but any other, throw an error
|
|
//$this->debug('edit_error_chk', "RG error - Data[".$prfx.$el_name.": ".$_POST[$prfx.$el_name][$i]." | ".$_POST[$prfx.$el_name]." - ".$reference_array['enable_name']." - ".$_POST[$reference_array['enable_name']][$_POST[$prfx.$el_name][$i]]);
|
|
if ($data_array["mandatory"] && $_POST[$prfx.$el_name][$i])
|
|
{
|
|
$mand_okay = 1;
|
|
$row_okay[$i] = 1;
|
|
}
|
|
// radio group and set where one not active
|
|
elseif ($data_array['type'] == 'radio_group' && !isset($_POST[$prfx.$el_name]))
|
|
{
|
|
//$this->debug('edit_error_chk', "RADIO GROUP");
|
|
$row_okay[$_POST[$prfx.$el_name][$i]] = 0;
|
|
$default_wrong[$_POST[$prfx.$el_name][$i]] = 1;
|
|
$error[$_POST[$prfx.$el_name][$i]] = 1;
|
|
}
|
|
elseif ($_POST[$prfx.$el_name][$i] && !$error[$i])
|
|
{
|
|
//$this->debug('edit_error_chk', "[$i]");
|
|
$element_set[$i] = 1;
|
|
$row_okay[$i] = 1;
|
|
}
|
|
elseif ($data_array["mandatory"] && !$_POST[$prfx.$el_name][$i])
|
|
{
|
|
$row_okay[$i] = 0;
|
|
}
|
|
// do optional error checks like for normal fields
|
|
// currently active: unique/alphanumeric
|
|
if ($data_rray['error_check'])
|
|
{
|
|
foreach (explode('|', $value["error_check"]) as $error_check)
|
|
{
|
|
switch ($error_check)
|
|
{
|
|
// check unique, check if field in table is not yet exist
|
|
case "unique":
|
|
$q = "SELECT ".$_pk_name." FROM ".$table_name." WHERE ".$el_name." = '".$this->db_escape_string($_POST[$prfx.$el_name][$i])."'";
|
|
if ($this->table_array[$this->int_pk_name]["value"])
|
|
$q .= " AND ".$this->int_pk_name." <> ".$this->table_array[$this->int_pk_name]["value"];
|
|
list($$key) = $this->db_return_row($q);
|
|
if ($$key)
|
|
$this->msg .= sprintf($this->l->__("The field <b>%s</b> in row <b>%s</b> can be used only once!<br>"), $reference_array["output_name"], $i);
|
|
break;
|
|
case "alphanumericspace":
|
|
if (!preg_match("/^[0-9A-Za-z\ ]+$/", $_POST[$prfx.$el_name][$i]))
|
|
$this->msg .= sprintf($this->l->__("Please enter a valid alphanumeric (Numbers and Letters, spaces allowed) value for the <b>%s</b> Field and row <b>%s</b>!<br>"), $reference_array["output_name"], $i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} // if main mandatory
|
|
}
|
|
|
|
// main mandatory is met -> error msg
|
|
if (!$mand_okay && $reference_array["mandatory"])
|
|
{
|
|
$this->msg .= sprintf($this->l->__("You need to enter at least one data set for field <b>%s</b>!<Br>"), $reference_array["output_name"]);
|
|
}
|
|
for ($i = 0; $i < $max; $i ++)
|
|
{
|
|
if (!$row_okay[$i] && $element_set[$i])
|
|
{
|
|
$this->msg .= sprintf($this->l->__("The row <b>%s</b> has <b>%s</b> set as mandatory, please fill at least this field out<br>"), $i, $mand_name);
|
|
}
|
|
if (!$row_okay[$i] && $default_wrong[$i])
|
|
{
|
|
$this->msg .= sprintf($this->l->__("The row <b>%s</b> would have a default setting, but it would be disabled. Please change the default setting and save again<br>"), $i);
|
|
}
|
|
}
|
|
} // each element list
|
|
}
|
|
if ($this->msg)
|
|
$this->error = 1;
|
|
}
|
|
|
|
// METHOD form_set_order
|
|
// PARAMS none
|
|
// RETURN the table array
|
|
// DOES sets the order to the maximum, if order flag is set in array
|
|
public function form_set_order()
|
|
{
|
|
// get order name
|
|
$order_name = $this->form_get_col_name_from_key("order");
|
|
if ($order_name)
|
|
{
|
|
// first check out of order ...
|
|
|
|
if (!$this->table_array[$order_name]["value"])
|
|
{
|
|
// set order (read max)
|
|
$q = "SELECT MAX(".$order_name.") + 1 AS max_page_order FROM ".$this->table_name;
|
|
list($this->table_array[$order_name]["value"]) = $this->db_return_row($q);
|
|
// frist element is 0 because NULL gets returned, set to 1
|
|
if (!$this->table_array[$order_name]["value"])
|
|
$this->table_array[$order_name]["value"] = 1;
|
|
}
|
|
else if ($this->table_array[$this->int_pk_name]["value"])
|
|
{
|
|
$q = "SELECT $order_name FROM ".$this->table_name." WHERE ".$this->int_pk_name." = ".$this->table_array[$this->int_pk_name]["value"];
|
|
list($this->table_array[$order_name]["value"]) = $this->db_return_row($q);
|
|
}
|
|
}
|
|
return $this->table_array;
|
|
}
|
|
|
|
// METHOD form_unsert_table_array
|
|
// PARAMS none
|
|
// RETURN none
|
|
// DOES resets all values in table_array and in the reference tables
|
|
public function form_unset_table_array()
|
|
{
|
|
unset($this->pk_id);
|
|
if (!is_array($this->table_array))
|
|
$this->table_array = array ();
|
|
reset($this->table_array);
|
|
while (list($key, $value) = each($this->table_array))
|
|
{
|
|
unset($this->table_array[$key]["value"]);
|
|
unset($this->table_array[$key]["input_value"]);
|
|
// if preset var present preset
|
|
if (isset($this->table_array[$key]["preset"]))
|
|
$this->table_array[$key]["value"] = $this->table_array[$key]["preset"];
|
|
}
|
|
if (is_array($this->reference_array))
|
|
{
|
|
if (!is_array($this->reference_array))
|
|
$this->reference_array = array ();
|
|
reset($this->reference_array);
|
|
while (list($key, $value) = each($this->reference_array))
|
|
{
|
|
unset($this->reference_array[$key]["selected"]);
|
|
}
|
|
}
|
|
$this->warning = 1;
|
|
$this->msg = $this->l->__("Cleared for new Dataset!");
|
|
}
|
|
|
|
// METHOD form_load_table_array
|
|
// PARAMS pk_id - overrule pk_id
|
|
// RETURN none
|
|
// DESC load a table & reference
|
|
public function form_load_table_array($pk_id = 0)
|
|
{
|
|
if ($pk_id)
|
|
$this->pk_id = $pk_id;
|
|
$this->table_array = $this->db_read(1);
|
|
|
|
// reset all temp fields
|
|
if (!is_array($this->table_array))
|
|
$this->table_array = array ();
|
|
reset($this->table_array);
|
|
while (list($key, $value) = each($this->table_array))
|
|
unset($this->table_array[$key]["input_value"]);
|
|
|
|
if (is_array($this->reference_array))
|
|
{
|
|
// load each reference_table
|
|
if (!is_array($this->reference_array))
|
|
$this->reference_array = array ();
|
|
reset($this->reference_array);
|
|
while (list($key, $value) = each($this->reference_array))
|
|
{
|
|
unset($this->reference_array[$key]["selected"]);
|
|
$q = "SELECT ".$this->reference_array[$key]["other_table_pk"]." FROM ".$this->reference_array[$key]["table_name"]." WHERE ".$this->int_pk_name."=".$this->table_array[$this->int_pk_name]["value"];
|
|
while ($res = $this->db_return($q))
|
|
$this->reference_array[$key]["selected"][] = $res[$this->reference_array[$key]["other_table_pk"]];
|
|
}
|
|
}
|
|
$this->warning = 1;
|
|
$this->msg = $this->l->__("Dataset has been loaded!<br>");
|
|
}
|
|
|
|
// METHOD form_save_table_array
|
|
// PARAMS addslashes - if one, passes 1 to the db_write function
|
|
// RETURN none
|
|
// DESC save a table, reference and all input fields
|
|
public function form_save_table_array($addslashes = 0)
|
|
{
|
|
// global $_FILES;
|
|
// for drop_down_db_input check if text field is filled and if, if not yet in db ...
|
|
// and upload files
|
|
if (!is_array($this->table_array))
|
|
$this->table_array = array ();
|
|
reset($this->table_array);
|
|
while (list($key, $value) = each($this->table_array))
|
|
{
|
|
// drop_down_db with input + reference table
|
|
//$this->debug('form', "A: ".$this->table_array[$key]["type"]." --- ".$this->table_array[$key]["input_value"]);
|
|
if ($this->table_array[$key]["type"] == "drop_down_db_input" && $this->table_array[$key]["input_value"])
|
|
{
|
|
//$this->debug('form', "HERE");
|
|
// check if this text name already exists (lowercase compare)
|
|
$q = "SELECT ".$this->table_array[$key]["pk_name"]." FROM ".$this->table_array[$key]["table_name"]." WHERE LCASE(".$this->table_array[$key]["input_name"].") = '".$this->db_escape_string(strtolower($this->table_array[$key]["input_value"]))."'";
|
|
// if a where was given, add here
|
|
if ($this->table_array[$key]["where"])
|
|
$q .= " AND ".$this->table_array[$key]["where"];
|
|
list($pk_name_temp) = $this->db_return_row($q);
|
|
if ($this->num_rows >= 1)
|
|
{
|
|
$this->table_array[$key]["value"] = $pk_name_temp;
|
|
}
|
|
else
|
|
{
|
|
// if a where was given, set this key also [dangerous!]
|
|
|
|
// postgreSQL compatible insert
|
|
$q = "INSERT INTO ".$this->table_array[$key]["table_name"]." (".$this->table_array[$key]["input_name"].") VALUES ('".$this->db_escape_string($this->table_array[$key]["input_value"])."')";
|
|
$this->db_exec($q);
|
|
if ($this->table_array[$key]["where"])
|
|
{
|
|
// make an update on the just inseted data with the where data als update values
|
|
$q = "UPDATE ".$this->table_array[$key]["table_name"]." SET ";
|
|
$q .= $this->table_array[$key]["where"]." ";
|
|
$q .= "WHERE ".$this->table_array[$key]["pk_name"]." = ".$this->insert_id;
|
|
$this->db_exec($q);
|
|
}
|
|
$this->table_array[$key]["value"] = $this->insert_id;
|
|
} // set value from DB through select or insert
|
|
unset($this->table_array[$key]["input_value"]);
|
|
} // if it is certain field type && if there is something in the temp field
|
|
// drop_down_db with input and in same table
|
|
if ($this->table_array[$key]["type"] == "drop_down_db_input_same_db" && $this->table_array[$key]["input_value"])
|
|
{
|
|
// if drop down & input are different
|
|
if ($this->table_array[$key]["input_value"] != $this->table_array[$key]["value"])
|
|
{
|
|
// check if "right input" is in DB
|
|
$q = "SELECT ".$this->table_array[$key]["input_name"]." FROM ".$this->table_array[$key]["table_name"]." WHERE LCASE(".$this->table_array[$key]["input_name"].") = '".strtolower($this->db_escape_string($this->table_array[$key]["input_value"]))."'";
|
|
// if a where was given, add here
|
|
if ($this->table_array[$key]["where"])
|
|
$q .= " AND ".$this->table_array[$key]["where"];
|
|
list($temp) = $this->db_return_row($q);
|
|
// nothing found in table, use new inserted key
|
|
if (!$temp)
|
|
{
|
|
$this->table_array[$key]["value"] = $this->table_array[$key]["input_value"];
|
|
} else // found in DB
|
|
{
|
|
$this->table_array[$key]["input_value"] = $this->table_array[$key]["value"];
|
|
}
|
|
} // key difference ?
|
|
} // for same_db drop down
|
|
|
|
// upload & save files to locations
|
|
if ($this->table_array[$key]["type"] == "file")
|
|
{
|
|
// if smth in $$key_file -> save or overwrite
|
|
// if smth in $key && $$key_delete && !$$key_file-> delte
|
|
// if smth in $key, keep as is
|
|
// $_file=$key."_file";
|
|
// $_delete=$key."_delete";
|
|
//$this->debug('form', "UF: ".$GLOBALS["_FILES"][$key."_file"]['name']);
|
|
//$this->debug('form', "delete: ".$key."_delete => ".$GLOBALS[$key.'_delete']);
|
|
if ($GLOBALS["_FILES"][$key."_file"]['name'])
|
|
{
|
|
// check if dir exists
|
|
if (is_dir($this->table_array[$key]["save_dir"]))
|
|
{
|
|
//if a slash at the end (if not add slash)
|
|
if (!preg_match("|/$|", $this->table_array[$key]["save_dir"]))
|
|
$this->table_array[$key]["save_dir"] .= "/";
|
|
if (move_uploaded_file($GLOBALS["_FILES"][$key."_file"]['tmp_name'], $this->table_array[$key]["save_dir"].$GLOBALS["_FILES"][$key."_file"]['name']))
|
|
{
|
|
// make it unique with a unique number at the beginning
|
|
$this->table_array[$key]["value"] = uniqid(rand(), 1)."_".$GLOBALS["_FILES"][$key."_file"]['name'];
|
|
}
|
|
else
|
|
{
|
|
$this->msg .= $this->l->__("File could not be copied to target directory! Perhaps wrong directory permissions.");
|
|
$this->error = 1;
|
|
} // could not move file (dir permissions?)
|
|
}
|
|
else
|
|
{
|
|
$this->msg .= sprintf($this->l->__("Target Directory \"%s\" is not a vaild directory!"), $this->table_array[$key]["save_dir"]);
|
|
$this->error = 1;
|
|
} // could not dir check (dir wrong??)
|
|
}
|
|
if ($GLOBALS[$key.'_delete'] && $this->table_array[$key]["value"] && !$GLOBALS["_FILES"][$key."_file"]['name'])
|
|
{
|
|
unlink($this->table_array[$key]["save_dir"].$this->table_array[$key]["value"]);
|
|
unset($this->table_array[$key]["value"]);
|
|
}
|
|
}
|
|
|
|
// for password crypt it as blowfish, or if not available MD5
|
|
if ($this->table_array[$key]['type'] == 'password')
|
|
{
|
|
if ($this->table_array[$key]["value"])
|
|
{
|
|
// password is stored in blowfish format, or in the format supported by this PHP version
|
|
$this->table_array[$key]["value"] = $this->cryptString($this->table_array[$key]["value"]);
|
|
$this->table_array[$key]["HIDDEN_value"] = $this->table_array[$key]["value"];
|
|
}
|
|
else
|
|
{
|
|
// $this->table_array[$key]["HIDDEN_value"] =
|
|
}
|
|
}
|
|
} // go through each field
|
|
|
|
// set object order (if necessary)
|
|
$this->form_set_order();
|
|
// write the object
|
|
$this->db_write($addslashes);
|
|
// write reference array(s) if necessary
|
|
if (is_array($this->reference_array))
|
|
{
|
|
if (!is_array($this->reference_array))
|
|
$this->reference_array = array ();
|
|
reset($this->reference_array);
|
|
foreach ($this->reference_array AS $reference_array)
|
|
{
|
|
$q = "DELETE FROM ".$reference_array["table_name"]." WHERE ".$this->int_pk_name."=".$this->table_array[$this->int_pk_name]["value"];
|
|
$this->db_exec($q);
|
|
$q = "INSERT INTO ".$reference_array["table_name"]." (".$reference_array["other_table_pk"].", ".$this->int_pk_name.") VALUES ";
|
|
for ($i = 0; $i < count($reference_array["selected"]); $i ++)
|
|
{
|
|
$t_q = "(".$reference_array["selected"][$i].", ".$this->table_array[$this->int_pk_name]["value"].")";
|
|
$this->db_exec($q.$t_q);
|
|
}
|
|
} // foreach reference arrays
|
|
} // if reference arrays
|
|
// write element list
|
|
if (is_array($this->element_list))
|
|
{
|
|
if (!is_array($this->element_list))
|
|
$this->element_list = array ();
|
|
reset($this->element_list);
|
|
while (list($table_name, $reference_array) = each($this->element_list))
|
|
{
|
|
// get the number of keys from the elements array
|
|
$keys = array_keys($reference_array["elements"]);
|
|
// element prefix name
|
|
$prfx = ($reference_array["prefix"]) ? $reference_array["prefix"]."_" : '';
|
|
// get max elements
|
|
$max = 0;
|
|
foreach ($keys as $key)
|
|
{
|
|
if (count($_POST[$prfx.$key]) > $max)
|
|
$max = count($_POST[$prfx.$key]);
|
|
}
|
|
//$this->debug('edit_error', "MAX: $max");
|
|
// check if there is a hidden key, update, else insert
|
|
while (list($el_name, $data_array) = each($reference_array["elements"]))
|
|
{
|
|
// this is only for reference_data part, at least one of the text fields need to be set for writing
|
|
$blow_write = array ();
|
|
//$this->debug('edit_error_query', "QUERY: ".$this->print_ar($_POST));
|
|
// go through all submitted data
|
|
// for ($i = 0; $i < count($_POST[$el_name]); $i ++)
|
|
for ($i = 0; $i < $max; $i ++)
|
|
{
|
|
// if we have enable name & delete set, then only insert/update those which are flagged as active
|
|
// check if mandatory field is set, if not set "do not write flag"
|
|
if ($data_array["mandatory"] && !$_POST[$prfx.$el_name][$i])
|
|
{
|
|
$no_write[$i] = 1;
|
|
}
|
|
if ($reference_array['enable_name'] && $reference_array['delete'] && !$_POST[$reference_array['enable_name']][$i])
|
|
{
|
|
$no_write[$i] = 1;
|
|
}
|
|
// flag if data is in the text field and we are in a reference data set
|
|
if ($reference_array['type'] == 'reference_data' )
|
|
{
|
|
if ($data_array['type'] == 'text' && $_POST[$prfx.$el_name][$i])
|
|
$block_write[$i] = 1;
|
|
}
|
|
else
|
|
{
|
|
$block_write[$i] = 1;
|
|
}
|
|
// set type and boundaries for insert/update
|
|
if ($data_array["pk_id"] && $_POST[$prfx.$el_name][$i])
|
|
{
|
|
$q_begin[$i] = "UPDATE $table_name SET ";
|
|
$q_end[$i] = " WHERE $el_name = ".$_POST[$prfx.$el_name][$i];
|
|
$type[$i] = "update";
|
|
}
|
|
elseif ($data_array["pk_id"] && !$_POST[$prfx.$el_name][$i])
|
|
{
|
|
$q_begin[$i] = "INSERT INTO $table_name (";
|
|
$q_middle[$i] = ") VALUES (";
|
|
$q_end[$i] = ")";
|
|
$type[$i] = "insert";
|
|
}
|
|
// write all data (insert/update) because I don't know until all are processed if it is insert or update
|
|
// don't write primary key backup for update
|
|
// for reference_data type, only write if at least one text type field is set
|
|
//$this->debug('edit_error', "I: $i | EL Name: $prfx$el_name | Data: ".$_POST[$prfx.$el_name][$i]." | Type: ".$type[$i]." | PK: ".$data_array["pk_id"].", Block write: ".$block_write[$i]);
|
|
// only add elements that are not PK or FK flaged
|
|
if (!$data_array['pk_id'] && !$data_array['fk_id'])
|
|
{
|
|
// update data list
|
|
if (strlen($q_data[$i]))
|
|
$q_data[$i] .= ", ";
|
|
// insert name part list
|
|
if ($q_names[$i])
|
|
$q_names[$i] .= ", ";
|
|
// insert value part list
|
|
if (strlen($q_values[$i]))
|
|
$q_values[$i] .= ", ";
|
|
// insert column name add
|
|
$q_names[$i] .= $el_name;
|
|
// data part, read from where [POST]
|
|
// radio group selections (only one can be active)
|
|
if ($data_array['type'] == 'radio_group')
|
|
{
|
|
if ($i == $_POST[$prfx.$el_name])
|
|
$_value = $i + 1;
|
|
else
|
|
$_value = 'NULL';
|
|
}
|
|
else
|
|
{
|
|
$_value = $_POST[$prfx.$el_name][$i];
|
|
}
|
|
// pre write data set. if int value, unset flagged need to be set null or 0 depending on settings
|
|
if ($data_array['int'] || $data_array['int_null'])
|
|
{
|
|
if (!$_value && $data_array['int_null'])
|
|
$_value = 'NULL';
|
|
elseif (!isset($_value))
|
|
$_value = 0;
|
|
$q_data[$i] .= $el_name." = ".$_value;
|
|
$q_values[$i] .= $_value;
|
|
}
|
|
else
|
|
{
|
|
// normal data gets escaped
|
|
$q_data[$i] .= $el_name." = '".$this->db_escape_string($_value)."'";
|
|
$q_values[$i] .= "'".$this->db_escape_string($_value)."'";
|
|
}
|
|
}
|
|
}
|
|
} // eche table elements
|
|
// finalize the queries, add FK key reference for inserts and run the query
|
|
for ($i = 0; $i < count($type); $i ++)
|
|
{
|
|
$q = '';
|
|
if (!$no_write[$i])
|
|
{
|
|
if ($type[$i] == "update")
|
|
{
|
|
$q = $q_begin[$i].$q_data[$i].$q_end[$i];
|
|
}
|
|
elseif ($block_write[$i])
|
|
{
|
|
$q = $q_begin[$i].$q_names[$i].", ".$this->int_pk_name.$q_middle[$i].$q_values[$i].", ".$this->table_array[$this->int_pk_name]["value"].$q_end[$i];
|
|
}
|
|
$this->debug('edit', "Pos[$i] => ".$type[$i]." Q: ".$q."<br>");
|
|
// write the dataset
|
|
if ($q)
|
|
$this->db_exec($q);
|
|
}
|
|
} // for each created query
|
|
} // each element list
|
|
}
|
|
$this->warning = 1;
|
|
$this->msg = $this->l->__("Dataset has been saved!<Br>");
|
|
}
|
|
|
|
// METHOD form_delete_table_array
|
|
// PARAMS none
|
|
// RETURN none
|
|
// DESC delete a table and reference fields
|
|
public function form_delete_table_array()
|
|
{
|
|
// remove any reference arrays
|
|
if (is_array($this->reference_array))
|
|
{
|
|
if (!is_array($this->reference_array))
|
|
$this->reference_array = array ();
|
|
reset($this->reference_array);
|
|
foreach ($this->reference_array AS $reference_array)
|
|
{
|
|
$q = "DELETE FROM ".$reference_array["table_name"]." WHERE ".$this->int_pk_name." = ".$this->table_array[$this->int_pk_name]["value"];
|
|
$this->db_exec($q);
|
|
}
|
|
}
|
|
// remove any element list references
|
|
if (is_array($this->element_list))
|
|
{
|
|
if (!is_array($this->element_list))
|
|
$this->element_list = array ();
|
|
reset($this->element_list);
|
|
while (list($table_name, $data_array) = each($this->element_list))
|
|
{
|
|
$q = "DELETE FROM ".$table_name." WHERE ".$this->int_pk_name." = ".$this->table_array[$this->int_pk_name]["value"];
|
|
$this->db_exec($q);
|
|
}
|
|
}
|
|
// unlink ALL files
|
|
if (!is_array($this->table_array))
|
|
$this->table_array = array ();
|
|
reset($this->table_array);
|
|
while (list($key, $value) = each($this->table_array))
|
|
{
|
|
if ($this->table_array[$key]["type"] == "file")
|
|
unlink($this->table_array[$key]["save_dir"].$this->table_array[$key]["value"]);
|
|
}
|
|
$this->db_delete();
|
|
$this->warning = 1;
|
|
$this->msg = $this->l->__("Dataset has been deleted!");
|
|
}
|
|
|
|
// METHOD form_create_hidden_fields
|
|
// PARAMS $hidden_array
|
|
// RETURNS the input fields (html)
|
|
// creates HTML hidden input fields out of an hash array
|
|
public function form_create_hidden_fields($hidden_array = "")
|
|
{
|
|
$hidden = array ();
|
|
if (!is_array($this->table_array))
|
|
$this->table_array = array ();
|
|
reset($this->table_array);
|
|
while (list($key, $value) = each($this->table_array))
|
|
{
|
|
if ($this->table_array[$key]["type"] == "hidden")
|
|
{
|
|
$hidden_array[$key] = $this->table_array[$key]["value"];
|
|
}
|
|
}
|
|
if (is_array($hidden_array))
|
|
{
|
|
reset($hidden_array);
|
|
while (list($key, $value) = each($hidden_array))
|
|
{
|
|
$hidden[] = array('key' => $key, 'value' => $value);
|
|
}
|
|
}
|
|
return $hidden;
|
|
}
|
|
|
|
// METHOD form_create_element_reference_table
|
|
// PARAMS show which reference table
|
|
// RETURN array for output
|
|
// DESC creates the multiple select part for a reference_table
|
|
public function form_create_element_reference_table($table_name)
|
|
{
|
|
$output_name = $this->reference_array[$table_name]["output_name"];
|
|
if ($this->reference_array[$table_name]["mandatory"])
|
|
$output_name .= ' *';
|
|
$data['name'] = $this->reference_array[$table_name]["other_table_pk"];
|
|
$data['size'] = $this->reference_array[$table_name]["select_size"];
|
|
while ($res = $this->db_return($this->reference_array[$table_name]["query"]))
|
|
{
|
|
$data['value'][] = $res[0];
|
|
$data['output'][] = $res[1];
|
|
$data['selected'][] = ($this->checked($this->reference_array[$table_name]["selected"], $res[0])) ? $res[0] : '';
|
|
}
|
|
$type = 'reference_table';
|
|
return array('output_name' => $output_name, 'type' => $type, 'color' => 'edit_fgcolor', 'data' => $data);
|
|
}
|
|
|
|
// METHOD form_create_element_list
|
|
// PARAMS show which element list
|
|
// RETURN array for output
|
|
// DESC create list of elements next to each other for a group of data in an input field
|
|
// this currently only works for a list that is filled from a sub table and creates only a connection to this one
|
|
// new version will allow a sub list with free input fields to directly fill a sub table to a master table
|
|
public function form_create_element_list_table($table_name)
|
|
{
|
|
// output name for the viewable left table td box, prefixed with * if mandatory
|
|
$output_name = $this->element_list[$table_name]["output_name"];
|
|
if ($this->element_list[$table_name]["mandatory"])
|
|
$output_name .= ' *';
|
|
// delete button name, if there is one set
|
|
if ($this->element_list[$table_name]["delete_name"])
|
|
$data['delete_name'] = $this->element_list[$table_name]["delete_name"];
|
|
// set the enable checkbox for delete, if the delete flag is given if there is one
|
|
if ($this->element_list[$table_name]["enable_name"])
|
|
{
|
|
$data['enable_name'] = $this->element_list[$table_name]["enable_name"];
|
|
if ($this->element_list[$table_name]["delete"])
|
|
$data['delete'] = 1;
|
|
}
|
|
// prefix for the elements, to not collide with names in the master set
|
|
if ($this->element_list[$table_name]["prefix"])
|
|
$data["prefix"] = $this->element_list[$table_name]["prefix"]."_";
|
|
// the sub data table name
|
|
$data['table_name'] = $table_name;
|
|
|
|
// build the select part
|
|
if (!is_array($this->element_list[$table_name]["elements"]))
|
|
$this->element_list[$table_name]["elements"] = array ();
|
|
reset($this->element_list[$table_name]["elements"]);
|
|
// generic data read in (counts for all rows)
|
|
// visible list data output
|
|
while (list($el_name, $data_array) = each($this->element_list[$table_name]["elements"]))
|
|
{
|
|
// $this->debug('CFG', 'El: '.$el_name.' -> '.$this->print_ar($data_array));
|
|
// if the element name matches the read array, then set the table as a name prefix
|
|
$q_select[] = $el_name; // this is for reading the data
|
|
// prefix the name for any further data parts
|
|
$el_name = $data["prefix"].$el_name;
|
|
$data['output_name'][$el_name] = $data_array["output_name"]; // this are the output names (if given)
|
|
$data['type'][$el_name] = $data_array["type"]; /// this is the type of the field
|
|
// set the primary key name
|
|
if ($data_array['pk_id'])
|
|
$data['pk_name'] = $el_name;
|
|
if ($data_array['fk_id'])
|
|
$data['fk_name'] = $el_name;
|
|
// if drop down db read data for element list from the given sub table as from the query
|
|
// only two elements are allowed: pos 0 is key, pso 1 is visible output name
|
|
if ($data_array['type'] == 'drop_down_db')
|
|
{
|
|
$md_q = md5($data_array['query']);
|
|
while ($res = $this->db_return($data_array['query']))
|
|
{
|
|
//$this->debug('edit', "Q[$md_q] pos: ".$this->cursor_ext[$md_q]["pos"]." | want: ".$data_array["preset"]." | set: ".$data['preset'][$el_name]);
|
|
// first is default for this element
|
|
if (!$data['preset'][$el_name] && ($this->cursor_ext[$md_q]["pos"] == $data_array['preset']))
|
|
$data['preset'][$el_name] = $res[0];
|
|
// split up data, 0 is id, 1 name
|
|
$data['element_list'][$el_name][] = $res[0];
|
|
$data['output_data'][$el_name][] = $res[1];
|
|
}
|
|
}
|
|
elseif ($data_array["element_list"])
|
|
{
|
|
$data['element_list'][$el_name] = $data_array["element_list"]; // this is for the checkboxes
|
|
}
|
|
$proto[$el_name] = ($this->error) ? $_POST[$el_name][(count($_POST[$el_name]) - 1)] : ''; // this is for the new line
|
|
}
|
|
// $this->debug('CFG DATA', 'Data: '.$this->print_ar($data));
|
|
// $this->debug('CFG PROTO', 'Proto: '.$this->print_ar($proto));
|
|
// $this->debug('CFG SELECT', 'Proto: '.$this->print_ar($q_select));
|
|
// query for reading in the data
|
|
//$this->debug('edit_error', "ERR: ".$this->error);
|
|
// if we got a read data, build the read select for the read, and read out the "selected" data
|
|
if ($this->element_list[$table_name]["read_data"])
|
|
{
|
|
// we need a second one for the query build only
|
|
// prefix all elements with the $table name
|
|
foreach ($q_select as $_pos => $element)
|
|
{
|
|
$_q_select[$_pos] = $table_name.'.'.$element;
|
|
}
|
|
// add the read names in here, prefix them with the table name
|
|
// earch to read part is split by |
|
|
if ($this->element_list[$table_name]["read_data"]["name"])
|
|
{
|
|
foreach (explode('|', $this->element_list[$table_name]["read_data"]["name"]) as $read_name)
|
|
{
|
|
array_unshift($_q_select, $this->element_list[$table_name]["read_data"]["table_name"].'.'.$read_name);
|
|
array_unshift($q_select, $read_name);
|
|
}
|
|
}
|
|
// set the rest of the data so we can print something out
|
|
$data['type'][$data["prefix"].$this->element_list[$table_name]["read_data"]["name"]] = 'string';
|
|
// build the read query
|
|
$q = "SELECT ";
|
|
// if (!$this->table_array[$this->int_pk_name]["value"])
|
|
// $q .= "DISTINCT ";
|
|
// prefix join key with table name, and implode the query select part
|
|
$q .= str_replace($table_name.'.'.$this->element_list[$table_name]["read_data"]["pk_id"], $this->element_list[$table_name]["read_data"]["table_name"].'.'.$this->element_list[$table_name]["read_data"]["pk_id"], implode(', ', $_q_select)).' ';
|
|
// if (!$this->table_array[$this->int_pk_name]["value"] && $this->element_list[$table_name]["read_data"]["order"])
|
|
// $q .= ", ".$this->element_list[$table_name]["read_data"]["order"]." ";
|
|
// read from the read table as main, and left join to the sub table to read the actual data
|
|
$q .= "FROM ".$this->element_list[$table_name]["read_data"]["table_name"]." ";
|
|
$q .= "LEFT JOIN ".$table_name." ";
|
|
$q .= "ON (";
|
|
$q .= $this->element_list[$table_name]["read_data"]["table_name"].".".$this->element_list[$table_name]["read_data"]["pk_id"]." = ".$table_name.".".$this->element_list[$table_name]["read_data"]["pk_id"]." ";
|
|
// if ($this->table_array[$this->int_pk_name]["value"])
|
|
$q .= "AND ".$table_name.".".$this->int_pk_name." = ".(($this->table_array[$this->int_pk_name]["value"]) ? $this->table_array[$this->int_pk_name]["value"] : 'NULL')." ";
|
|
$q .= ") ";
|
|
if ($this->element_list[$table_name]["read_data"]["order"])
|
|
$q .= " ORDER BY ".$this->element_list[$table_name]["read_data"]["table_name"].'.'.$this->element_list[$table_name]["read_data"]["order"];
|
|
}
|
|
else
|
|
{
|
|
// only create query if we have a primary key
|
|
// reads directly from the reference table
|
|
if ($this->table_array[$this->int_pk_name]["value"])
|
|
$q = "SELECT ".implode(", ", $q_select)." FROM ".$table_name." WHERE ".$this->int_pk_name." = ".$this->table_array[$this->int_pk_name]["value"];
|
|
}
|
|
// $this->debug('CFG QUERY', 'Q: '.$q);
|
|
// only run if we have query strnig
|
|
if ($q)
|
|
{
|
|
$pos = 0; // position in while for overwrite if needed
|
|
// read out the list and add the selected data if needed
|
|
while ($res = $this->db_return($q))
|
|
{
|
|
$_data = array ();
|
|
$prfx = $data["prefix"]; // short
|
|
// go through each res
|
|
for ($i = 0; $i < count($q_select); $i ++)
|
|
{
|
|
// query select part, set to the element name
|
|
$el_name = $q_select[$i];
|
|
//$this->debug('edit_error', "[$i] ELNAME: $el_name | POS[$prfx$el_name]: ".$_POST[$prfx.$el_name][$pos]." | RES: ".$res[$el_name]);
|
|
// if we have an error, we take what we have in the vars, if not we take the data from the db
|
|
if ($this->error)
|
|
{
|
|
// if we have a radio group, set a bit different
|
|
if ($data['element_list'][$prfx.$el_name] == 'radio_group')
|
|
$_data[$prfx.$el_name] = ($res[$el_name]) ? ($res[$el_name] - 1) : 0;
|
|
else
|
|
$_data[$prfx.$el_name] = $_POST[$prfx.$el_name][$pos];
|
|
}
|
|
else
|
|
{
|
|
if ($data["preset"][$prfx.$el_name] && !$res[$el_name])
|
|
$_data[$prfx.$el_name] = $data["preset"][$el_name];
|
|
else
|
|
$_data[$prfx.$el_name] = $res[$el_name];
|
|
}
|
|
}
|
|
$data['content'][] = $_data;
|
|
$data['pos'][] = array(0 => $pos); // this is for the checkboxes
|
|
$pos ++; // move up one
|
|
// reset and unset before next run
|
|
unset($_data);
|
|
}
|
|
}
|
|
// if this is normal single reference data check the content on the element count
|
|
// if there is a max_empty is set, then fill up new elements (unfilled) until we reach max empty
|
|
if ($this->element_list[$table_name]['type'] == 'reference_data' && is_numeric($this->element_list[$table_name]['max_empty']) && $this->element_list[$table_name]['max_empty'] > 0)
|
|
{
|
|
// if the max empty is bigger than 10, just cut it to ten at the moment
|
|
if ($this->element_list[$table_name]['max_empty'] > 10)
|
|
$this->element_list[$table_name]['max_empty'] = 10;
|
|
// check if we need to fill fields
|
|
$element_count = count($data['content']);
|
|
$missing_empty_count = $this->element_list[$table_name]['max_empty'] - count($data['content']);
|
|
$this->debug('CFG MAX', 'Max empty: '.$this->element_list[$table_name]['max_empty'].', Missing: '.$missing_empty_count.', Has: '.$element_count);
|
|
// set if we need more open entries or if we do not have any entries yet
|
|
if (($missing_empty_count < $this->element_list[$table_name]['max_empty']) || $element_count == 0)
|
|
{
|
|
for ($pos = count($data['content']); $pos <= ($this->element_list[$table_name]['max_empty'] + $element_count); $pos ++)
|
|
{
|
|
$_data = array ();
|
|
|
|
// the fields that need to be filled are in data->type array:
|
|
// pk fields are unfilled
|
|
// fk fields are filled with the fk_id "int_pk_name" value
|
|
foreach ($data['type'] as $el_name => $type)
|
|
{
|
|
$_data[$el_name] = '';
|
|
if ($el_name == $data['pk_name'])
|
|
{
|
|
}
|
|
elseif ($el_name == $data['fk_name'])
|
|
{
|
|
$_data[$el_name] = $this->table_array[$this->int_pk_name]["value"];
|
|
}
|
|
}
|
|
$data['content'][] = $_data;
|
|
$data['pos'][] = array(0 => $pos); // this is for the checkboxes
|
|
}
|
|
}
|
|
}
|
|
|
|
// push in an empty line of this type, but only if we have a delete key
|
|
if ($data['delete_name'])
|
|
$data['content'][] = $proto;
|
|
//$this->debug('edit', "A:<pre>".print_r($data, 1)."</pre>");
|
|
$type = 'element_list';
|
|
return array('output_name' => $output_name, 'type' => $type, 'color' => 'edit_fgcolor', 'data' => $data);
|
|
}
|
|
} // end of class
|
|
?>
|