diff --git a/www/layout/admin/javascript/edit.jq.js b/www/layout/admin/javascript/edit.jq.js
index 6eab6076..061fd429 100644
--- a/www/layout/admin/javascript/edit.jq.js
+++ b/www/layout/admin/javascript/edit.jq.js
@@ -274,6 +274,22 @@ const keyInObject = (key, object) => (key in object) ? true : false;
return (key in object) ? true : false;
}*/
+// METHOD: getKeyByValue
+// PARAMS: object, value
+// RETURN: key found
+// DESC : returns matching key of value
+const getKeyByValue = (obj, value) => Object.keys(obj).find(key => obj[key] === value);
+// function getKeyByValue(object, value)
+// {
+// return Object.keys(object).find(key => object[key] === value);
+// }
+
+// METHOD: valueInObject
+// PARAMS: obj, value
+// RETURN: true/false
+// DESC : returns true if value is found in object with a key
+const valueInObject = (obj, value) => (Object.keys(obj).find(key => obj[key] === value)) ? true : false;
+
// METHOD: exists
// PARAMS: uid
// RETURN: true/false
diff --git a/www/layout/admin/javascript/edit.pt.js b/www/layout/admin/javascript/edit.pt.js
index 2d04c55f..f95b1a4f 100644
--- a/www/layout/admin/javascript/edit.pt.js
+++ b/www/layout/admin/javascript/edit.pt.js
@@ -352,6 +352,22 @@ const keyInObject = (key, object) => (key in object) ? true : false;
return (key in object) ? true : false;
}*/
+// METHOD: getKeyByValue
+// PARAMS: object, value
+// RETURN: key found
+// DESC : returns matching key of value
+const getKeyByValue = (obj, value) => Object.keys(obj).find(key => obj[key] === value);
+// function getKeyByValue(object, value)
+// {
+// return Object.keys(object).find(key => object[key] === value);
+// }
+
+// METHOD: valueInObject
+// PARAMS: obj, value
+// RETURN: true/false
+// DESC : returns true if value is found in object with a key
+const valueInObject = (obj, value) => (Object.keys(obj).find(key => obj[key] === value)) ? true : false;
+
// METHOD: exists
// PARAMS: uid
// RETURN: true/false
diff --git a/www/lib/CoreLibs/ACL/Login.inc b/www/lib/CoreLibs/ACL/Login.inc
index 34f2154b..f1e7b144 100644
--- a/www/lib/CoreLibs/ACL/Login.inc
+++ b/www/lib/CoreLibs/ACL/Login.inc
@@ -1,4 +1,4 @@
-dbReturn($q)) {
// page id array for sub data readout
- $edit_page_ids[] = $res['edit_page_id'];
+ $edit_page_ids[$res['edit_page_id']] = $res['cuid'];
// create the array for pages
- array_push($pages, array (
+ $pages[$res['cuid']] = array (
'edit_page_id' => $res['edit_page_id'],
+ 'cuid' => $res['cuid'],
+ 'content_alias_uid' => $res['content_alias_uid'], // for reference of content data on a differen page
'filename' => $res['filename'],
'page_name' => $res['edit_page_name'],
'order' => $res['edit_page_order'],
@@ -450,7 +454,7 @@ class Login extends \CoreLibs\DB\IO
'acl_type' => $res['type'],
'query' => array (),
'visible' => array ()
- ));
+ );
// make reference filename -> level
$pages_acl[$res['filename']] = $res['level'];
} // for each page
@@ -458,33 +462,42 @@ class Login extends \CoreLibs\DB\IO
$_edit_page_id = 0;
$q = "SELECT epvg.edit_page_id, name, flag ";
$q .= "FROM edit_visible_group evp, edit_page_visible_group epvg ";
- $q .= "WHERE evp.edit_visible_group_id = epvg.edit_visible_group_id AND epvg.edit_page_id IN (".join(', ', $edit_page_ids).") ";
+ $q .= "WHERE evp.edit_visible_group_id = epvg.edit_visible_group_id AND epvg.edit_page_id IN (".join(', ', array_keys($edit_page_ids)).") ";
$q .= "ORDER BY epvg.edit_page_id";
while ($res = $this->dbReturn($q)) {
- if ($res['edit_page_id'] != $_edit_page_id) {
- // search the pos in the array push
- $pos = $this->arraySearchRecursive($res['edit_page_id'], $pages, 'edit_page_id');
- $_edit_page_id = $res['edit_page_id'];
- }
- $pages[$pos[0]]['visible'][$res['name']] = $res['flag'];
+ $pages[$edit_page_ids[$res['edit_page_id']]]['visible'][$res['name']] = $res['flag'];
}
// get the same for the query strings
$_edit_page_id = 0;
$q = "SELECT eqs.edit_page_id, name, value, dynamic FROM edit_query_string eqs ";
- $q .= "WHERE enabled = 1 AND edit_page_id IN (".join(', ', $edit_page_ids).") ORDER BY eqs.edit_page_id";
+ $q .= "WHERE enabled = 1 AND edit_page_id IN (".join(', ', array_keys($edit_page_ids)).") ";
+ $q .= "ORDER BY eqs.edit_page_id";
while ($res = $this->dbReturn($q)) {
- if ($res['edit_page_id'] != $_edit_page_id) {
- // search the pos in the array push
- $pos = $this->arraySearchRecursive($res['edit_page_id'], $pages, 'edit_page_id');
- $_edit_page_id = $res['edit_page_id'];
- }
- $pages[$pos[0]]['query'][] = array (
+ $pages[$edit_page_ids[$res['edit_page_id']]]['query'][] = array (
'name' => $res['name'],
'value' => $res['value'],
'dynamic' => $res['dynamic']
);
}
-
+ // get the page content and add them to the page
+ $_edit_page_id = 0;
+ $q = "SELECT epc.edit_page_id, epc.name, epc.uid, epc.order_number, epc.online, ear.level, ear.type ";
+ $q .= "FROM edit_page_content epc, edit_access_right ear ";
+ $q .= "WHERE epc.edit_access_right_id = ear.edit_access_right_id AND ";
+ $q .= "epc.edit_page_id IN (".join(', ', array_keys($edit_page_ids)).") ";
+ $q .= "ORDER BY epc.order_number";
+ while ($res = $this->dbReturn($q)) {
+ $pages[$edit_page_ids[$res['edit_page_id']]]['content'][$res['uid']] = array (
+ 'name' => $res['name'],
+ 'uid' => $res['uid'],
+ 'online' => $res['online'],
+ 'order' => $res['order_number'],
+ // access name and level
+ 'acl_type' => $res['type'],
+ 'acl_level' => $res['level']
+ );
+ }
+ // write back the pages data to the output array
$_SESSION['PAGES'] = $pages;
$_SESSION['PAGES_ACL_LEVEL'] = $pages_acl;
// load the edit_access user rights
@@ -593,7 +606,8 @@ class Login extends \CoreLibs\DB\IO
if ($this->logout || $this->login_error) {
// unregister and destroy session vars
unset($_SESSION['EUID']);
- unset($_SESSION['GROUP_LEVEL']);
+ unset($_SESSION['GROUP_ACL_LEVEL']);
+ unset($_SESSION['USER_ACL_LEVEL']);
unset($_SESSION['PAGES']);
unset($_SESSION['USER_NAME']);
unset($_SESSION['UNIT']);
@@ -658,6 +672,7 @@ class Login extends \CoreLibs\DB\IO
$this->acl['base'] = $_SESSION['USER_ACL_LEVEL'];
}
}
+ $_SESSION['BASE_ACL_LEVEL'] = $this->acl['base'];
// set the current page acl
// start with default acl
diff --git a/www/lib/CoreLibs/Admin/Backend.inc b/www/lib/CoreLibs/Admin/Backend.inc
index 6702ef22..b02035b2 100644
--- a/www/lib/CoreLibs/Admin/Backend.inc
+++ b/www/lib/CoreLibs/Admin/Backend.inc
@@ -1,4 +1,4 @@
-running_uid = hash($this->hash_algo, uniqid(rand(), true));
+ $this->running_uid = hash($this->hash_algo, uniqid((string)rand(), true));
// internal info var
$this->class_info["basic"] = array (
@@ -369,8 +369,6 @@ class Basic
$this->session_id = session_id();
}
- // [!!! DEPRECATED !!!] init crypt settings
- $this->cryptInit();
// new better password init
$this->passwordInit();
@@ -452,7 +450,7 @@ class Basic
$this->endtime = ((float)$micro + (float)$timestamp);
$string .= $simple ? 'End: ' : "Stopped at: ";
}
- $string .= date("Y-m-d H:i:s", $timestamp);
+ $string .= date("Y-m-d H:i:s", (int)$timestamp);
$string .= " ".$micro;
if ($this->starttime && $this->endtime) {
$running_time = $this->endtime - $this->starttime;
@@ -480,7 +478,7 @@ class Basic
public static function printTime($set_microtime = -1)
{
list($microtime, $timestamp) = explode(' ', microtime());
- $string = date("Y-m-d H:i:s", $timestamp);
+ $string = date("Y-m-d H:i:s", (int)$timestamp);
// if microtime flag is -1 no round, if 0, no microtime, if >= 1, round that size
if ($set_microtime == -1) {
$string .= substr($microtime, 1);
@@ -494,8 +492,8 @@ class Basic
// METHOD: fdebug
// PARAMS: $string: data to write to file
- // $enter: default on true, if set to false, no linebreak (\n) will be put at the end
- // RETURN: none
+ // $enter: default on true, if set to false, no linebreak (\n) will be put at the end
+ // RETURN: none
// DESC : writes a string to a file immediatly, for fast debug output
public function fdebug($string, $enter = 1)
{
@@ -695,7 +693,7 @@ class Basic
$this->log_file_unique_id = $GLOBALS['LOG_FILE_UNIQUE_ID'];
}
if (!$this->log_file_unique_id) {
- $GLOBALS['LOG_FILE_UNIQUE_ID'] = $this->log_file_unique_id = date('Y-m-d_His').'_U_'.substr(hash('sha1', uniqid(mt_rand(), true)), 0, 8);
+ $GLOBALS['LOG_FILE_UNIQUE_ID'] = $this->log_file_unique_id = date('Y-m-d_His').'_U_'.substr(hash('sha1', uniqid((string)mt_rand(), true)), 0, 8);
}
$rpl_string = '_'.$this->log_file_unique_id; // add 8 char unique string
} else {
@@ -792,9 +790,9 @@ class Basic
// PARAMS: $array
// RETURN: string html formatted
// DESC : prints a html formatted (pre) array
- public static function printAr($array)
+ public static function printAr(array $array)
{
- return "
".print_r($array, 1)."
";
+ return "
".print_r($array, true)."
";
}
// METHOD: checked
@@ -951,6 +949,8 @@ class Basic
$host_name = 'NA';
}
$this->host_port = $port ? $port : 80;
+ $this->host_name = $host_name;
+ // also return for old type call
return $host_name;
}
@@ -993,7 +993,7 @@ class Basic
// RETURN: array with the elements where the needle can be found in the haystack array
// DESC : searches key = value in an array / array
// only returns the first one found
- public static function arraySearchRecursive($needle, $haystack, $key_lookin = "")
+ public static function arraySearchRecursive($needle, $haystack, $key_lookin = '')
{
$path = null;
if (!is_array($haystack)) {
@@ -1360,9 +1360,9 @@ class Basic
public static function timeStringFormat($timestamp, $show_micro = true)
{
// check if the timestamp has any h/m/s/ms inside, if yes skip
- if (!preg_match("/(h|m|s|ms)/", $timestamp)) {
+ if (!preg_match("/(h|m|s|ms)/", (string)$timestamp)) {
$ms = 0;
- list ($timestamp, $ms) = explode('.', round($timestamp, 4));
+ list ($timestamp, $ms) = explode('.', (string)round($timestamp, 4));
$timegroups = array (86400, 3600, 60, 1);
$labels = array ('d', 'h', 'm', 's');
$time_string = '';
@@ -1584,14 +1584,14 @@ class Basic
3 => 'png'
);
- if ($cache_source) {
+ if (!empty($cache_source)) {
$tmp_src = $cache_source;
} else {
$tmp_src = BASE.TMP;
}
// check if pic has a path, and override next sets
if (strstr($pic, '/') === false) {
- if (!$path) {
+ if (empty($path)) {
$path = BASE;
}
$filename = $path.MEDIA.PICTURES.$pic;
@@ -1847,6 +1847,7 @@ class Basic
// there is no auto init for this at the moment
private function cryptInit()
{
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
// SET CRYPT SALT PREFIX:
// the prefix string is defined by what the server can do
// first we check if we can do blowfish, if not we try md5 and then des
@@ -1892,6 +1893,7 @@ class Basic
// DESC : creates a random string from alphanumeric characters: A-Z a-z 0-9 ./
private function cryptSaltString($nSize = 22)
{
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
// A-Z is 65,90
// a-z is 97,122
// 0-9 is 48,57
@@ -1921,6 +1923,7 @@ class Basic
// DESC : encrypts the string with blowfish and returns the full string + salt part that needs to be stored somewhere (eg DB)
public function cryptString($string)
{
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
// the crypt prefix is set in the init of the class
// uses the random string method to create the salt
return crypt($string, $this->cryptSaltPrefix.$this->cryptSaltString($this->cryptSaltSize).$this->cryptSaltSuffix);
@@ -1934,6 +1937,7 @@ class Basic
// DESC : compares the string with the crypted one, is counter method to cryptString
public function verifyCryptString($string, $crypt)
{
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
// the full crypted string needs to be passed on to the salt, so the init (for blowfish) and salt are passed on
if (crypt($string, $crypt) == $crypt) {
return true;
@@ -2457,6 +2461,7 @@ class Basic
public function checkConvert($string, $from_encoding, $to_encoding)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->checkConvertEncoding($string, $from_encoding, $to_encoding);
}
@@ -2469,144 +2474,168 @@ class Basic
public function running_time($simple = false)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->runningTime($simple);
}
public static function print_time($set_microtime = -1)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return Basic::printTime($set_microtime);
}
private function fdebug_fp($flag = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->fdebugFP($flag);
}
public function debug_for($type, $flag)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->debugFor($type, $flag);
}
public function get_caller_method($level = 2)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->getCallerMethod($level);
}
public function merge_errors($error_msg = array ())
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->mergeErrors($error_msg);
}
public function print_error_msg($string = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->printErrorMsg($string);
}
private function write_error_msg($level, $error_string)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->writeErrorMsg($level, $error_string);
}
public function reset_error_msg($level = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->resetErrorMsg($level);
}
public static function print_ar($array)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return Basic::printAr($array);
}
public function magic_links($string, $target = "_blank")
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->magicLinks($string, $target);
}
private function create_url($href, $atag, $_1, $_2, $_3, $name, $class)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->createUrl($href, $atag, $_1, $_2, $_3, $name, $class);
}
private function create_email($mailto, $atag, $_1, $_2, $_3, $title, $class)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->createEmail($mailto, $atag, $_1, $_2, $_3, $title, $class);
}
public function get_host_name()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->getHostName();
}
public static function get_page_name($strip_ext = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return Basic::getPageName($strip_ext);
}
public static function get_filename_ending($filename)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return Basic::getFilenameEnding($filename);
}
public static function array_search_recursive($needle, $haystack, $key_lookin = "")
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return Basic::arraySearchRecursive($needle, $haystack, $key_lookin);
}
public static function array_search_recursive_all($needle, $haystack, $key, $path = null)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return Basic::arraySearchRecursiveAll($needle, $haystack, $key, $path);
}
public static function array_search_simple($array, $key, $value)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return Basic::arraySearchSimple($array, $key, $value);
}
public static function _mb_mime_encode($string, $encoding)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return Basic::__mbMimeEncode($string, $encoding);
}
public function _crc32b($string)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__crc32b($string);
}
public function _sha1_short($string, $use_sha = false)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__sha1Short($string, $use_sha);
}
public function _hash($string, $hash_type = 'adler32')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__hash($string, $hash_type);
}
public static function in_array_any($needle, $haystack)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return Basic::inArrayAny($needle, $haystack);
}
}
diff --git a/www/lib/CoreLibs/DB/Extended/ArrayIO.inc b/www/lib/CoreLibs/DB/Extended/ArrayIO.inc
index c8daefdc..4d65107c 100644
--- a/www/lib/CoreLibs/DB/Extended/ArrayIO.inc
+++ b/www/lib/CoreLibs/DB/Extended/ArrayIO.inc
@@ -1,4 +1,4 @@
-table_array)) {
foreach ($this->table_array as $key => $value) {
- if ($value['pk']) {
+ if (isset($value['pk'])) {
$this->pk_name = $key;
}
}
@@ -204,7 +204,9 @@ class ArrayIO extends \CoreLibs\DB\IO
$q_where = '';
foreach ($this->table_array as $column => $data_array) {
// suchen nach bildern und lschen ...
- if ($this->table_array[$column]['file'] && file_exists($this->table_array[$column]['url'].$this->table_array[$column]['value'])) {
+ if (!empty($this->table_array[$column]['file']) &&
+ file_exists($this->table_array[$column]['url'].$this->table_array[$column]['value'])
+ ) {
if (file_exists($this->table_array[$column]['path'].$this->table_array[$column]['value'])) {
unlink($this->table_array[$column]['path'].$this->table_array[$column]['value']);
}
@@ -214,7 +216,7 @@ class ArrayIO extends \CoreLibs\DB\IO
}
}
// if we have a foreign key
- if ($this->table_array[$column]['fk']) {
+ if (!empty($this->table_array[$column]['fk'])) {
// create FK constraint checks
if ($q_where) {
$q_where .= ' AND ';
@@ -263,7 +265,7 @@ class ArrayIO extends \CoreLibs\DB\IO
$q_select .= $column;
// check FK ...
- if ($this->table_array[$column]['fk'] && $this->table_array[$column]['value']) {
+ if (isset($this->table_array[$column]['fk']) && isset($this->table_array[$column]['value'])) {
if ($q_where) {
$q_where .= ' AND ';
}
@@ -290,7 +292,9 @@ class ArrayIO extends \CoreLibs\DB\IO
if ($edit) {
$this->table_array[$column]['value'] = $res[$column];
// if password, also write to hidden
- if ($this->table_array[$column]['type'] == 'password') {
+ if (isset($this->table_array[$column]['type']) &&
+ $this->table_array[$column]['type'] == 'password'
+ ) {
$this->table_array[$column]['HIDDEN_value'] = $res[$column];
}
} else {
@@ -336,7 +340,7 @@ class ArrayIO extends \CoreLibs\DB\IO
foreach ($this->table_array as $column => $data_array) {
/********************************* START FILE *************************************/
// file upload
- if ($this->table_array[$column]['file']) {
+ if (isset($this->table_array[$column]['file'])) {
// falls was im tmp drinnen, sprich ein upload, datei kopieren, Dateinamen in db schreiben
// falls datei schon am server (physischer pfad), dann einfach url in db schreiben (update)
// falls in 'delete' 'ja' dann loeschen (und gibts eh nur beim update)
@@ -384,9 +388,16 @@ class ArrayIO extends \CoreLibs\DB\IO
/********************************* END FILE **************************************/
// do not write 'pk' (primary key) or 'view' values
- if (!$this->table_array[$column]['pk'] && $this->table_array[$column]['type'] != 'view' && strlen($column) > 0) {
+ if (!isset($this->table_array[$column]['pk']) &&
+ isset($this->table_array[$column]['type']) &&
+ $this->table_array[$column]['type'] != 'view' &&
+ strlen($column) > 0
+ ) {
// for password use hidden value if main is not set
- if ($this->table_array[$column]['type'] == 'password' && !$this->table_array[$column]['value']) {
+ if (isset($this->table_array[$column]['type']) &&
+ $this->table_array[$column]['type'] == 'password' &&
+ empty($this->table_array[$column]['value'])
+ ) {
$this->table_array[$column]['value'] = $this->table_array[$column]['HIDDEN_value'];
}
if (!$insert) {
@@ -399,35 +410,47 @@ class ArrayIO extends \CoreLibs\DB\IO
if (strlen($q_data)) {
$q_data .= ', ';
}
- if ($q_vars) {
+ if (strlen($q_vars)) {
$q_vars .= ', ';
}
$q_vars .= $column;
}
// integer is different
- if ($this->table_array[$column]['int'] || $this->table_array[$column]['int_null']) {
- $this->debug('write_check', '[$column]['.$this->table_array[$column]['value'].'] Foo: '.isset($this->table_array[$column]['value']).' | '.$this->table_array[$column]['int_null']);
- if (!$this->table_array[$column]['value'] && $this->table_array[$column]['int_null']) {
+ if (isset($this->table_array[$column]['int']) || isset($this->table_array[$column]['int_null'])) {
+ $this->debug('write_check', '['.$column.']['.$this->table_array[$column]['value'].']['.$this->table_array[$column]['type'].'] VALUE SET: '.isset($this->table_array[$column]['value']).' | INT NULL: '.isset($this->table_array[$column]['int_null']));
+ if (isset($this->table_array[$column]['value']) &&
+ !$this->table_array[$column]['value'] &&
+ isset($this->table_array[$column]['int_null'])
+ ) {
$_value = 'NULL';
- } elseif (!isset($this->table_array[$column]['value'])) {
+ } elseif (!isset($this->table_array[$column]['value']) ||
+ (isset($this->table_array[$column]['value']) && !$this->table_array[$column]['value'])
+ ) {
$_value = 0;
} else {
$_value = $this->table_array[$column]['value'];
}
$q_data .= $_value;
- } elseif ($this->table_array[$column]['bool']) {
+ } elseif (isset($this->table_array[$column]['bool'])) {
// boolean storeage (reverse check on ifset)
$q_data .= "'".$this->dbBoolean($this->table_array[$column]['value'], true)."'";
- } elseif ($this->table_array[$column]["interval"]) {
+ } elseif (isset($this->table_array[$column]['interval'])) {
// for interval we check if no value, then we set null
- if (!$this->table_array[$column]['value']) {
+ if (!isset($this->table_array[$column]['value']) ||
+ (isset($this->table_array[$column]['value']) && !$this->table_array[$column]['value'])
+ ) {
$_value = 'NULL';
+ } elseif (isset($this->table_array[$column]['value'])) {
+ $_value = $this->table_array[$column]['value'];
}
$q_data .= $_value;
} else {
// if the error check is json, we set field to null if NOT set
// else normal string write
- if ($this->table_array[$column]['error_check'] == 'json' && !$this->table_array[$column]['value']) {
+ if (isset($this->table_array[$column]['error_check']) &&
+ $this->table_array[$column]['error_check'] == 'json' &&
+ (!isset($this->table_array[$column]['value']) || (isset($this->table_array[$column]['value']) && !$this->table_array[$column]['value']))
+ ) {
$q_data .= 'NULL';
} else {
// normal string
@@ -450,8 +473,8 @@ class ArrayIO extends \CoreLibs\DB\IO
// create select part & addition FK part
foreach ($this->table_array as $column => $data_array) {
// check FK ...
- if ($this->table_array[$column]['fk'] && $this->table_array[$column]['value']) {
- if ($q_where) {
+ if (isset($this->table_array[$column]['fk']) && isset($this->table_array[$column]['value'])) {
+ if (!empty($q_where)) {
$q_where .= ' AND ';
}
$q_where .= $column .= ' = '.$this->table_array[$column]['value'];
@@ -459,11 +482,11 @@ class ArrayIO extends \CoreLibs\DB\IO
}
// if no PK set, then get max ID from DB
- if (!$this->table_array[$this->pk_name]["value"]) {
+ if (!$this->table_array[$this->pk_name]['value']) {
// max id, falls INSERT
$q = 'SELECT MAX('.$this->pk_name.') + 1 AS pk_id FROM '.$this->table_name;
$res = $this->dbReturnRow($q);
- if (!$res['pk_id']) {
+ if (!isset($res['pk_id'])) {
$res['pk_id'] = 1;
}
$this->table_array[$this->pk_name]['value'] = $res['pk_id'];
@@ -474,7 +497,7 @@ class ArrayIO extends \CoreLibs\DB\IO
$q .= $q_data;
$q .= ' WHERE ';
$q .= $this->pk_name.' = '.$this->table_array[$this->pk_name]['value'].' ';
- if ($q_where) {
+ if (!empty($q_where)) {
$q .= ' AND '.$q_where;
}
// set pk_id ... if it has changed or so
@@ -486,8 +509,8 @@ class ArrayIO extends \CoreLibs\DB\IO
// write primary key too
// if ($q_data)
// $q .= ", ";
- // $q .= $this->pk_name." = ".$this->table_array[$this->pk_name]["value"]." ";
- // $this->pk_id = $this->table_array[$this->pk_name]["value"];
+ // $q .= $this->pk_name." = ".$this->table_array[$this->pk_name]['value']." ";
+ // $this->pk_id = $this->table_array[$this->pk_name]['value'];
}
// return success or not
if (!$this->dbExec($q)) {
@@ -512,48 +535,56 @@ class ArrayIO extends \CoreLibs\DB\IO
public function convert_data($text)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->convertData($text);
}
public function convert_entities($text)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->convertEntities($text);
}
public function db_dump_array($write = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbDumpArray($write);
}
public function db_check_pk_set()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbCheckPkSet();
}
public function db_reset_array($reset_pk = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbResetArray($reset_pk);
}
public function db_delete($table_array = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbDelete($table_array);
}
public function db_read($edit = 0, $table_array = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbRead($edit, $table_array);
}
public function db_write($addslashes = 0, $table_array = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbWrite($addslashes, $table_array);
}
} // end of class
diff --git a/www/lib/CoreLibs/DB/IO.inc b/www/lib/CoreLibs/DB/IO.inc
index 27c7b3ed..1b754a80 100644
--- a/www/lib/CoreLibs/DB/IO.inc
+++ b/www/lib/CoreLibs/DB/IO.inc
@@ -1,4 +1,4 @@
-db_functions->__dbFetchArray($this->cursor, PGSQL_ASSOC)) {
- // echo "*** RETURNING: ".print_r($_insert_id, 1)." ";
+ // echo "*** RETURNING: ".print_r($_insert_id, true)." ";
$this->insert_id[] = $_insert_id;
}
// if we have only one, revert from array to single
@@ -1307,10 +1307,11 @@ class IO extends \CoreLibs\Basic
// METHOD: dbReturnArray
// WAS : db_return_array
- // PARAMS: query -> the query to be executed, named_only -> if true, only name ref are returned
+ // PARAMS: query -> the query to be executed
+ // assoc_only -> if true, only name ref are returned
// RETURN: array of hashes (row -> fields)
// DESC : createds an array of hashes of the query (all data)
- public function dbReturnArray($query, $named_only = 0)
+ public function dbReturnArray($query, $assoc_only = false)
{
if (!$query) {
$this->error_id = 11;
@@ -1324,14 +1325,9 @@ class IO extends \CoreLibs\Basic
return false;
}
$cursor = $this->dbExec($query);
- while ($res = $this->dbFetchArray($cursor)) {
+ while ($res = $this->dbFetchArray($cursor, $assoc_only)) {
for ($i = 0; $i < $this->num_fields; $i ++) {
- // cereated mixed, first name
$data[$this->field_names[$i]] = $res[$this->field_names[$i]];
- // then number
- if (!$named_only) {
- $data[$i] = $res[$this->field_names[$i]];
- }
}
$rows[] = $data;
}
@@ -1590,7 +1586,7 @@ class IO extends \CoreLibs\Basic
public function dbCompareVersion($compare)
{
// compare has =, >, < prefix, and gets stripped, if the rest is not X.Y format then error
- preg_match("/^([<>=]{1,2})(\d{1,2})\.(\d{1,2})/", $compare, $matches);
+ preg_match("/^([<>=]{1,})(\d{1,})\.(\d{1,})/", $compare, $matches);
$compare = $matches[1];
$to_master = $matches[2];
$to_minor = $matches[3];
@@ -1601,7 +1597,9 @@ class IO extends \CoreLibs\Basic
}
// db_version can return X.Y.Z
// we only compare the first two
- list ($master, $minor, $_other) = explode('.', $this->dbVersion());
+ preg_match("/^(\d{1,})\.(\d{1,})\.?(\d{1,})?/", $this->dbVersion(), $matches);
+ $master = $matches[1];
+ $minor = $matches[2];
$version = $master.($minor < 10 ? '0' : '').$minor;
$return = false;
// compare
@@ -1866,264 +1864,308 @@ class IO extends \CoreLibs\Basic
private function _connect_to_db()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__connectToDB();
}
private function _close_db()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__closeDB();
}
private function _check_query_for_select($query)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__checkQueryForSelect($query);
}
private function _check_query_for_insert($query, $pure = false)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__checkQueryForInsert($query, $pure);
}
private function _print_array($array)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__printArray($array);
}
private function _db_debug($debug_id, $error_string, $id = '', $type = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__dbDebug($debug_id, $error_string, $id, $type);
}
public function _db_error($cursor = '', $msg = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__dbError($cursor, $msg);
}
private function _db_convert_encoding($row)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__dbConvertEncoding($row);
}
private function _db_debug_prepare($stm_name, $data = array())
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__dbDebugPrepare($stm_name, $data);
}
private function _db_return_table($query)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__dbReturnTable($query);
}
private function _db_prepare_exec($query, $pk_name)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__dbPrepareExec($query, $pk_name);
}
private function _db_post_exec()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->__dbPostExec();
}
public function db_set_debug($debug = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbSetDebug($debug);
}
public function db_reset_query_called($query)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbResetQueryCalled($query);
}
public function db_get_query_called($query)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbGetQueryCalled($query);
}
public function db_close()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbClose();
}
public function db_set_schema($db_schema = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbSetSchema($db_schema);
}
public function db_get_schema()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbGetSchema();
}
public function db_set_encoding($db_encoding = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbSetEncoding($db_encoding);
}
public function db_info($show = 1)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbInfo($show);
}
public function db_dump_data($query = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbDumpData($query);
}
public function db_return($query, $reset = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbReturn($query, $reset);
}
public function db_cache_reset($query)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbCacheReset($query);
}
public function db_exec($query = 0, $pk_name = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbExec($query, $pk_name);
}
public function db_exec_async($query, $pk_name = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbExecAsync($query, $pk_name);
}
public function db_check_async()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbCheckAsync();
}
public function db_fetch_array($cursor = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbFetchArray($cursor);
}
public function db_return_row($query)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbReturnRow($query);
}
public function db_return_array($query, $named_only = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbReturnArray($query, $named_only);
}
public function db_cursor_pos($query)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbCursorPos($query);
}
public function db_cursor_num_rows($query)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbCursorNumRows($query);
}
public function db_show_table_meta_data($table, $schema = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbShowTableMetaData($table, $schema);
}
public function db_prepare($stm_name, $query, $pk_name = '')
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbPrepare($stm_name, $query, $pk_name);
}
public function db_execute($stm_name, $data = array())
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbExecute($stm_name, $data);
}
public function db_escape_string($string)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbEscapeString($string);
}
public function db_escape_bytea($bytea)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbEscapeBytea($bytea);
}
public function db_version()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbVersion();
}
public function db_compare_version($compare)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbCompareVersion($compare);
}
public function db_boolean($string, $rev = false)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbBoolean($string, $rev);
}
public function db_write_data($write_array, $not_write_array, $primary_key, $table, $data = array ())
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbWriteData($write_array, $not_write_array, $primary_key, $table, $data);
}
public function db_write_data_ext($write_array, $primary_key, $table, $not_write_array = array (), $not_write_update_array = array (), $data = array ())
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbWriteDataExt($write_array, $primary_key, $table, $not_write_array, $not_write_update_array, $data);
}
public function db_time_format($age, $show_micro = false)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbTimeFormat($age, $show_micro);
}
public function db_array_parse($text)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbArrayParse($text);
}
public function db_sql_escape($value, $kbn = "")
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
+ trigger_error('Method '.__METHOD__.' is deprecated', E_USER_DEPRECATED);
return $this->dbSqlEscape($value, $kbn);
}
} // end if db class
diff --git a/www/lib/CoreLibs/DB/SQL/PgSQL.inc b/www/lib/CoreLibs/DB/SQL/PgSQL.inc
index adc7fcc7..a7076db6 100644
--- a/www/lib/CoreLibs/DB/SQL/PgSQL.inc
+++ b/www/lib/CoreLibs/DB/SQL/PgSQL.inc
@@ -1,4 +1,4 @@
-dbh, $string);
+ return pg_escape_string($this->dbh, (string)$string);
}
// METHOD: __dbEscapeBytea
diff --git a/www/lib/CoreLibs/Language/Core/CachedFileReader.inc b/www/lib/CoreLibs/Language/Core/CachedFileReader.inc
index 485d6e13..2823fa68 100755
--- a/www/lib/CoreLibs/Language/Core/CachedFileReader.inc
+++ b/www/lib/CoreLibs/Language/Core/CachedFileReader.inc
@@ -1,4 +1,4 @@
-.
diff --git a/www/lib/CoreLibs/Language/Core/FileReader.inc b/www/lib/CoreLibs/Language/Core/FileReader.inc
index 18ee1193..cb20375b 100755
--- a/www/lib/CoreLibs/Language/Core/FileReader.inc
+++ b/www/lib/CoreLibs/Language/Core/FileReader.inc
@@ -1,4 +1,4 @@
-.
diff --git a/www/lib/CoreLibs/Language/Core/GetTextReader.inc b/www/lib/CoreLibs/Language/Core/GetTextReader.inc
index 8ea50166..a2270d2a 100755
--- a/www/lib/CoreLibs/Language/Core/GetTextReader.inc
+++ b/www/lib/CoreLibs/Language/Core/GetTextReader.inc
@@ -1,4 +1,4 @@
-.
Copyright (c) 2005 Nico Kaiser
diff --git a/www/lib/CoreLibs/Language/Core/StreamReader.inc b/www/lib/CoreLibs/Language/Core/StreamReader.inc
index c6382222..0c3ea035 100755
--- a/www/lib/CoreLibs/Language/Core/StreamReader.inc
+++ b/www/lib/CoreLibs/Language/Core/StreamReader.inc
@@ -1,4 +1,4 @@
-.
diff --git a/www/lib/CoreLibs/Language/Core/StringReader.inc b/www/lib/CoreLibs/Language/Core/StringReader.inc
index 606618fc..0f527751 100755
--- a/www/lib/CoreLibs/Language/Core/StringReader.inc
+++ b/www/lib/CoreLibs/Language/Core/StringReader.inc
@@ -1,4 +1,4 @@
-.
diff --git a/www/lib/CoreLibs/Language/L10n.inc b/www/lib/CoreLibs/Language/L10n.inc
index 81ad1f3e..31479324 100644
--- a/www/lib/CoreLibs/Language/L10n.inc
+++ b/www/lib/CoreLibs/Language/L10n.inc
@@ -1,4 +1,4 @@
- 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
+ public $mobile_phone = false;
// buttons and checkboxes
public $archive;
public $new;
@@ -235,7 +236,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
public $really_delete;
public $save;
// security publics
- public $group_level_user;
+ public $base_acl_level;
public $security_levels;
// layout publics
public $table_width;
@@ -266,7 +267,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
include(BASE.INCLUDES.TABLE_ARRAYS.'array_'.$this->my_page_name.'.inc');
}
}
- if (is_array(${$this->my_page_name})) {
+ if (isset(${$this->my_page_name}) && is_array(${$this->my_page_name})) {
$config_array = ${$this->my_page_name};
} else {
// dummy created
@@ -304,20 +305,27 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
$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'];
+ $this->archive = isset($_POST['archive']) ? $_POST['archive'] : '';
+ $this->new = isset($_POST['new']) ? $_POST['new'] : '';
+ $this->really_new = isset($_POST['really_new']) ? $_POST['really_new'] : '';
+ $this->delete = isset($_POST['delete']) ? $_POST['delete'] : '';
+ $this->really_delete = isset($_POST['really_delete']) ? $_POST['really_delete'] : '';
+ $this->save = isset($_POST['save']) ? $_POST['save'] : '';
+ $this->remove_button = isset($_POST['remove_button']) ? $_POST['remove_button'] : '';
// security settings
- $this->group_level_user = isset($_SESSION['GROUP_ACL_LEVEL']) ? $_SESSION['GROUP_ACL_LEVEL'] : 0;
+ $this->base_acl_level = isset($_SESSION['BASE_ACL_LEVEL']) ? $_SESSION['BASE_ACL_LEVEL'] : 0;
// 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);
+ if (!isset($config_array['security_level']) || !is_array($config_array['security_level']) ||
+ (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'];
@@ -356,7 +364,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// METHOD: formGetColNameFromKey
// WAS : form_get_col_name_from_key
- // PARAMS: $want_key: the key where u want the data from
+ // PARAMS: $want_key: the key where you 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
@@ -368,12 +376,14 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
reset($this->table_array);
foreach ($this->table_array as $key => $value) {
- if ($value[$want_key] && !$key_value) {
+ if (isset($value[$want_key]) && !isset($key_value)) {
return $key;
- } elseif ($value[$want_key] == $key_value && $key_value) {
+ } elseif (isset($value[$want_key]) && $value[$want_key] == $key_value && isset($key_value)) {
return $key;
}
}
+ // return nothing on nothing
+ return '';
}
// METHOD: formGetColNameArrayFromKey
@@ -405,13 +415,18 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// RETURN: formated output for the error && warning msg
public function formPrintMsg()
{
+ $class = '';
if ($this->error) {
$class = 'error';
}
if ($this->warning) {
$class = 'warning';
}
- return array('msg' => $this->msg, 'width' => $this->table_width, 'class' => $class);
+ 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
@@ -422,7 +437,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// DESC : default load procedure
public function formProcedureLoad($archive_id)
{
- if ($this->archive && $archive_id && $this->group_level_user <= $this->security_level['load']) {
+ if ($this->archive && $archive_id && $this->base_acl_level >= $this->security_level['load']) {
$this->formLoadTableArray($archive_id);
$this->yes = 1;
}
@@ -435,7 +450,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// DESC : default new procedure
public function formProcedureNew()
{
- if ($this->new && $this->group_level_user <= $this->security_level['new']) {
+ if ($this->new && $this->base_acl_level >= $this->security_level['new']) {
if ($this->really_new == 'yes') {
$this->formUnsetTablearray();
} else {
@@ -453,7 +468,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// DESC : default save procedure
public function formProcedureSave()
{
- if ($this->save && $this->group_level_user <= $this->security_level['save']) {
+ if ($this->save && $this->base_acl_level >= $this->security_level['save']) {
$this->formErrorCheck();
if (!$this->error) {
$this->formSaveTableArray();
@@ -470,8 +485,8 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
public function formProcedureDelete()
{
// 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']) {
+ if ($this->delete && $this->base_acl_level >= $this->security_level['delete']) {
+ if (isset($this->table_array['protected']['value']) && $this->table_array['protected']['value']) {
$this->msg .= $this->l->__('Cannot delete this Dataset, because it is internaly protected!');
$this->error = 2;
}
@@ -492,8 +507,15 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// DESC : default delete procedure
public function formProcedureDeleteFromElementList($element_list, $remove_name)
{
+ $this->debug('REMOVE ELEMENT', 'Remove REF ELEMENT: '.$this->base_acl_level.' >= '.$this->security_level['delete']);
+ $this->debug('REMOVE ELEMENT', 'Protected Value set: '.isset($this->table_array['protected']['value']));
+ $this->debug('REMOVE ELEMENT', 'Error: '.$this->error);
// 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) {
+ if ($this->base_acl_level >= $this->security_level['delete'] &&
+ (!isset($this->table_array['protected']['value']) ||
+ (isset($this->table_array['protected']['value']) && !$this->table_array['protected']['value'])) &&
+ !$this->error
+ ) {
if (!is_array($element_list)) {
$element_list = array ();
}
@@ -503,14 +525,14 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
$prfx = ($this->element_list[$element_list[$i]]['prefix']) ? $this->element_list[$element_list[$i]]['prefix'].'_' : '';
// get the primary key
foreach ($this->element_list[$element_list[$i]]['elements'] as $el_name => $data) {
- if ($data['pk_id']) {
+ if (isset($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']
+ if ((!empty($this->element_list[$element_list[$i]]['delete_name']) || !empty($this->element_list[$element_list[$i]]['delete'])) &&
+ empty($this->element_list[$element_list[$i]]['enable_name'])
) {
// flag var name
$flag = $remove_name[$i].'_flag';
@@ -520,8 +542,10 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
$this->msg .= $this->l->__('Removed entry from list ');
$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']) {
- if (!is_array($_POST[$id])) {
+ } elseif (isset($this->element_list[$element_list[$i]]['read_data']) &&
+ !$this->element_list[$element_list[$i]]['delete']
+ ) {
+ if (!isset($_POST[$id])) {
$_POST[$id] = array ();
}
for ($j = 0, $j_max = count($_POST[$id]); $j < $j_max; $j ++) {
@@ -534,7 +558,9 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
$this->warning = 1;
}
}
- } elseif (is_array($this->element_list[$element_list[$i]]['read_data']) && $this->element_list[$element_list[$i]]['delete']) {
+ } elseif (isset($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->printAr($_POST[$id]));
// $this->debug('form_clean', 'PK arr: '.$this->printAr($_POST[$prfx.$pk_name]));
@@ -561,15 +587,21 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// RETURN: string from 'load' part of form ...
public function formCreateLoad()
{
- // when security leve is okay ...
- if ($this->group_level_user <= $this->security_level['load']) {
+ $pk_selected = '';
+ $t_pk_name = '';
+ $pk_names = array ();
+ $pk_ids = array ();
+ // when security level is okay ...
+ if ($this->base_acl_level >= $this->security_level['load']) {
$t_pk_name = $this->archive_pk_name;
// load list data
$this->dbExec($this->load_query);
while ($res = $this->dbFetchArray()) {
$pk_ids[] = $res[$this->int_pk_name];
- if ($res[$this->int_pk_name] == $this->table_array[$this->int_pk_name]['value']) {
+ if (isset($this->table_array[$this->int_pk_name]['value']) &&
+ $res[$this->int_pk_name] == $this->table_array[$this->int_pk_name]['value']
+ ) {
$pk_selected = $res[$this->int_pk_name];
}
$t_string = '';
@@ -577,10 +609,10 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
if ($t_string) {
$t_string .= ', ';
}
- if ($this->field_array[$i]['before_value']) {
+ if (isset($this->field_array[$i]['before_value'])) {
$t_string .= $this->field_array[$i]['before_value'];
}
- if ($this->field_array[$i]['binary']) {
+ if (isset($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']];
@@ -589,7 +621,12 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
$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);
+ return array (
+ 't_pk_name' => $t_pk_name,
+ 'pk_ids' => $pk_ids,
+ 'pk_names' => $pk_names,
+ 'pk_selected' => $pk_selected
+ );
}
// METHOD: formCreateNew
@@ -598,8 +635,10 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// RETURN: part for new
public function formCreateNew($hide_new_checkbox = 0)
{
+ $show_checkbox = 0;
+ $new_name = '';
// when security level is okay
- if ($this->group_level_user <= $this->security_level['new']) {
+ if ($this->base_acl_level >= $this->security_level['new']) {
if ($this->yes && !$hide_new_checkbox) {
$show_checkbox = 1;
}
@@ -610,7 +649,10 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
$new_name = $this->l->__('New');
}
} // security level okay
- return array('new_name' => $new_name, 'show_checkbox' => $show_checkbox);
+ return array (
+ 'new_name' => $new_name,
+ 'show_checkbox' => $show_checkbox
+ );
}
// METHOD: formCreateSaveDelete
@@ -619,11 +661,17 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// RETURN: string for delete / save part
public function formCreateSaveDelete($hide_delete = 0, $hide_delete_checkbox = 0)
{
- if ($this->group_level_user <= $this->security_level['save'] || $this->group_level_user <= $this->security_level['delete']) {
+ $seclevel_okay = 0;
+ $save = '';
+ $pk_name = '';
+ $pk_value = '';
+ $show_delete = 0;
+ $old_school_hidden = 0;
+ if ($this->base_acl_level >= $this->security_level['save'] || $this->base_acl_level >= $this->security_level['delete']) {
$old_school_hidden = 0;
- if ($this->group_level_user <= $this->security_level['save']) {
+ if ($this->base_acl_level >= $this->security_level['save']) {
$seclevel_okay = 1;
- if (!$this->table_array[$this->int_pk_name]['value']) {
+ if (empty($this->table_array[$this->int_pk_name]['value'])) {
$save = $this->l->__('Save');
} else {
$save = $this->l->__('Update');
@@ -635,7 +683,10 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
} // 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']) {
+ if (!empty($this->table_array[$this->int_pk_name]['value']) &&
+ !$hide_delete &&
+ $this->base_acl_level >= $this->security_level['delete']
+ ) {
$show_delete = 1;
}
} // print save/delete row at all$
@@ -645,6 +696,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
'pk_name' => $pk_name,
'pk_value' => $pk_value,
'show_delete' => $show_delete,
+ 'old_school_hidden' => $old_school_hidden,
'hide_delete_checkbox' => $hide_delete_checkbox
);
} // end of function
@@ -659,32 +711,35 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
public function formCreateElement($element_name, $query = '')
{
// special 2nd color for 'binary' attribut
- if ($this->table_array[$element_name]['type'] == 'binary' && !$this->table_array[$element_name]['value']) {
+ if ($this->table_array[$element_name]['type'] == 'binary' && !isset($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']) {
+ if (isset($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'];
+ $data['value'] = empty($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') {
+ $data['checked'] = 0;
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'])) {
+ if ((isset($i) && isset($this->table_array[$element_name]['value'])) ||
+ (!isset($i) && !isset($this->table_array[$element_name]['value']))
+ ) {
$data['checked'] = $this->table_array[$element_name]['value'];
}
- if ($i) {
+ if (isset($i)) {
$data['separator'] = '';
}
}
@@ -698,16 +753,16 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// 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'];
+ $data['value'] = isset($this->table_array[$element_name]['value']) ? $this->table_array[$element_name]['value'] : '';
+ $data['size'] = isset($this->table_array[$element_name]['size']) ? $this->table_array[$element_name]['size'] : '';
+ $data['length'] = isset($this->table_array[$element_name]['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'];
+ $data['size'] = isset($this->table_array[$element_name]['size']) ? $this->table_array[$element_name]['size'] : '';
+ $data['length'] = isset($this->table_array[$element_name]['length']) ? $this->table_array[$element_name]['length'] : '';
}
// date (YYYY-MM-DD)
if ($this->table_array[$element_name]['type'] == 'date') {
@@ -720,41 +775,60 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// 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'];
+ $data['value'] = isset($this->table_array[$element_name]['value']) ? $this->table_array[$element_name]['value'] : '';
+ $data['rows'] = isset($this->table_array[$element_name]['rows']) ? $this->table_array[$element_name]['rows'] : '';
+ $data['cols'] = isset($this->table_array[$element_name]['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) {
+ if (empty($query) && !empty($this->table_array[$element_name]['query'])) {
$query = $this->table_array[$element_name]['query'];
}
}
// for drop_down_db*
+ $data['drop_down_input'] = 0;
if (preg_match("/^drop_down_db/", $this->table_array[$element_name]['type'])) {
// if still NO query
- if (!$query) {
+ if (empty($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'];
+ $query = "SELECT ".((isset($this->table_array[$element_name]['select_distinct']) && $this->table_array[$element_name]['select_distinct']) ? "DISTINCT" : '');
+ $query .= " ".$this->table_array[$element_name]['pk_name'].", ".$this->table_array[$element_name]['input_name']." ";
+ if (!empty($this->table_array[$element_name]['order_by'])) {
+ $query .", ".$this->table_array[$element_name]['order_by']." ";
+ }
+ $query .= "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'];
+ if (!empty($this->table_array[$element_name]['where'])) {
+ $query .= " WHERE ".$this->table_array[$element_name]['where'];
+ }
+ // not self where
+ if (!empty($this->table_array[$element_name]['where_not_self'])) {
+ // check if query has where already
+ if (strstr($query, 'WHERE') === false) {
+ $query .= " WHERE ";
+ } else {
+ $query .= " AND ";
+ }
+ $query .= " ".$this->int_pk_name." <> ".$this->table_array[$this->int_pk_name]['value'];
}
// possible order statements
- if ($this->table_array[$element_name]['order_by']) {
- $query .= ' ORDER BY '.$this->table_array[$element_name]['order_by'];
+ if (!empty($this->table_array[$element_name]['order_by'])) {
+ $query .= " ORDER BY ".$this->table_array[$element_name]['order_by'];
}
}
// set output data
+ $data['selected'] = '';
$data['name'] = $element_name;
$data['value'][] = '';
$data['output'][] = $this->l->__('Please choose ...');
while ($res = $this->dbReturn($query)) {
$data['value'][] = $res[0];
$data['output'][] = $res[1];
- if ($this->table_array[$element_name]['value'] == $res[0]) {
+ if (isset($this->table_array[$element_name]['value']) &&
+ $this->table_array[$element_name]['value'] == $res[0]
+ ) {
$data['selected'] = $this->table_array[$element_name]['value'];
}
}
@@ -773,6 +847,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
// drop down array
if ($this->table_array[$element_name]['type'] == 'drop_down_array') {
+ $data['selected'] = '';
$data['name'] = $element_name;
$data['value'][] = '';
$data['output'][] = $this->l->__('Please choose ...');
@@ -808,7 +883,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
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['value'] = isset($this->table_array[$element_name]['value']) ? $this->table_array[$element_name]['value'] : 0;
$data['col_name'] = $this->col_name;
$data['table_name'] = $this->table_name;
$data['query'] = urlencode($query);
@@ -843,7 +918,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
foreach ($this->table_array as $key => $value) {
//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']) {
+ if (isset($value['error_check']) && isset($this->table_array[$key]['value']) && !empty($this->table_array[$key]['value'])) {
$this->debug('ERROR CHECK', 'Key: '.$key.' => '.$value['error_check']);
// each error check can be a piped seperated value, lets split it
// $this->debug('edit', $value['error_check']);
@@ -922,14 +997,14 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
case 'json':
// check if valid json
$json_out = json_decode($this->table_array[$key]['value'], true);
- $this->debug('JSON ENCODE', 'LAST ERROR: '.json_last_error());
+ $this->debug('JSON ENCODE', 'LAST ERROR: '.json_last_error().' WITH: '.$this->table_array[$key]['value']);
if (json_last_error()) {
$this->msg .= sprintf($this->l->__('Please enter a valid JSON string for the field %s: %s'), $this->table_array[$key]['output_name'], json_last_error_msg());
}
break;
} // switch
} // for each error to check
- } elseif ($value['mandatory'] &&
+ } elseif (isset($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']) ||
@@ -947,7 +1022,11 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
} // mandatory
// check file upload
- if ($this->table_array[$key]['type'] == 'file' && $GLOBALS['_FILES'][$key.'_file']['name'] && is_array($this->table_array[$key]['accept_type'])) {
+ if (isset($this->table_array[$key]['type']) &&
+ $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) {
@@ -977,17 +1056,17 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
}
}
- // $this->debug('edit_error', 'QS:
'.print_r($_POST, 1).'
');
+ // $this->debug('edit_error', 'QS:
'.print_r($_POST, true).'
');
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
foreach ($this->element_list as $table_name => $reference_array) {
// set pk/fk id for this
foreach ($reference_array['elements'] as $_name => $_data) {
- if ($_data['pk_id']) {
+ if (isset($_data['pk_id'])) {
$_pk_name = $_name;
}
- if ($_data['fk_id']) {
+ if (isset($_data['fk_id'])) {
$_fk_name = $_name;
}
}
@@ -998,28 +1077,35 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// get max elements
$max = 0;
foreach ($keys as $key) {
- if (is_array($_POST[$prfx.$key]) && count($_POST[$prfx.$key]) > $max) {
+ if (isset($_POST[$prfx.$key]) &&
+ is_array($_POST[$prfx.$key]) &&
+ 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->printAr($_POST));
+ $this->debug('POST ARRAY', $this->printAr($_POST));
+ $mand_okay = 0;
# check each row
for ($i = 0; $i < $max; $i ++) {
// either one of the post pks is set, or the mandatory
foreach ($reference_array['elements'] as $el_name => $data_array) {
- if ($data_array['mandatory']) {
+ if (isset($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']) {
+ if (isset($data_array['pk_id']) &&
+ count($_POST[$prfx.$el_name]) &&
+ isset($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]) {
+ if (isset($data_array['mandatory']) && $_POST[$prfx.$el_name][$i]) {
$mand_okay = 1;
$row_okay[$i] = 1;
} elseif ($data_array['type'] == 'radio_group' && !isset($_POST[$prfx.$el_name])) {
@@ -1028,17 +1114,17 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
$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]) {
+ } elseif (isset($_POST[$prfx.$el_name][$i]) && !isset($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]) {
+ } elseif (isset($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_array['error_check']) {
- foreach (explode('|', $value['error_check']) as $error_check) {
+ if (isset($data_array['error_check'])) {
+ foreach (explode('|', $data_array['error_check']) as $error_check) {
switch ($error_check) {
// check unique, check if field in table is not yet exist
case 'unique':
@@ -1063,14 +1149,14 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
// main mandatory is met -> error msg
- if (!$mand_okay && $reference_array['mandatory']) {
+ if (!isset($mand_okay) && isset($reference_array['mandatory'])) {
$this->msg .= sprintf($this->l->__('You need to enter at least one data set for field %s! '), $reference_array['output_name']);
}
for ($i = 0; $i < $max; $i ++) {
- if (!$row_okay[$i] && $element_set[$i]) {
+ if (!isset($row_okay[$i]) && isset($element_set[$i])) {
$this->msg .= sprintf($this->l->__('The row %s has %s set as mandatory, please fill at least this field out '), $i, $mand_name);
}
- if (!$row_okay[$i] && $default_wrong[$i]) {
+ if (!isset($row_okay[$i]) && isset($default_wrong[$i])) {
$this->msg .= sprintf($this->l->__('The row %s would have a default setting, but it would be disabled. Please change the default setting and save again '), $i);
}
}
@@ -1190,14 +1276,17 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
{
// 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)) {
+ if (!isset($this->table_array)) {
$this->table_array = array ();
}
reset($this->table_array);
foreach ($this->table_array as $key => $value) {
// 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']) {
+ if (isset($this->table_array[$key]['type']) &&
+ $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->dbEscapeString(strtolower($this->table_array[$key]['input_value']))."'";
@@ -1213,7 +1302,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// postgreSQL compatible insert
$q = 'INSERT INTO '.$this->table_array[$key]['table_name'].' ('.$this->table_array[$key]['input_name'].') VALUES ('."'".$this->dbEscapeString($this->table_array[$key]['input_value'])."')";
$this->dbExec($q);
- if ($this->table_array[$key]['where']) {
+ if (!empty($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'].' ';
@@ -1225,7 +1314,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
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 (isset($this->table_array[$key]['type']) && $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
@@ -1246,7 +1335,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
} // for same_db drop down
// upload & save files to locations
- if ($this->table_array[$key]['type'] == 'file') {
+ if (isset($this->table_array[$key]['type']) && $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
@@ -1280,7 +1369,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
// for password crypt it as blowfish, or if not available MD5
- if ($this->table_array[$key]['type'] == 'password') {
+ if (isset($this->table_array[$key]['type']) && $this->table_array[$key]['type'] == 'password') {
if ($this->table_array[$key]['value']) {
// use the better new passwordSet instead of crypt based
$this->table_array[$key]['value'] = $this->passwordSet($this->table_array[$key]['value']);
@@ -1293,6 +1382,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// set object order (if necessary)
$this->formSetOrder();
+ // echo "PK NAME: ".$this->pk_name."/".$this->int_pk_name.": ".$this->table_array[$this->pk_name]['value']."/".$this->table_array[$this->int_pk_name]['value']." ";
// write the object
$this->dbWrite($addslashes);
// write reference array(s) if necessary
@@ -1302,7 +1392,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
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'];
+ $q = 'DELETE FROM '.$reference_array['table_name'].' WHERE '.$this->int_pk_name.' = '.$this->table_array[$this->int_pk_name]['value'];
$this->dbExec($q);
$q = 'INSERT INTO '.$reference_array['table_name'].' ('.$reference_array['other_table_pk'].', '.$this->int_pk_name.') VALUES ';
for ($i = 0, $i_max = count($reference_array['selected']); $i < $i_max; $i ++) {
@@ -1312,16 +1402,16 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
} // 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 ();
- }
+ if (isset($this->element_list) && is_array($this->element_list)) {
+ $type = array ();
reset($this->element_list);
foreach ($this->element_list as $table_name => $reference_array) {
// init arrays
$q_names = array ();
$q_data = array ();
$q_values = array ();
+ $no_write = array ();
+ $block_write = array ();
// get the number of keys from the elements array
$keys = array_keys($reference_array['elements']);
// element prefix name
@@ -1329,63 +1419,94 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// get max elements
$max = 0;
foreach ($keys as $key) {
- if (is_array($_POST[$prfx.$key]) && count($_POST[$prfx.$key]) > $max) {
+ if (isset($_POST[$prfx.$key]) && is_array($_POST[$prfx.$key]) && count($_POST[$prfx.$key]) > $max) {
$max = count($_POST[$prfx.$key]);
}
}
+ $this->debug('REF ELEMENT', 'RUN FOR TABLE: '.$table_name);
// $this->debug('edit_error', 'MAX: $max');
// check if there is a hidden key, update, else insert
foreach ($reference_array['elements'] as $el_name => $data_array) {
- // 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->printAr($_POST));
// go through all submitted data
// for ($i = 0; $i < count($_POST[$el_name]); $i ++)
for ($i = 0; $i < $max; $i ++) {
+ if (!isset($no_write[$i])) {
+ $no_write[$i] = 0;
+ // $this->debug('REF ELEMENT', 'Init no write for pos: '.$i);
+ }
+ if (!isset($block_write[$i])) {
+ $block_write[$i] = 0;
+ // $this->debug('REF ELEMENT', 'Init block write for pos: '.$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]) {
+ if (isset($data_array['mandatory']) &&
+ (!isset($_POST[$prfx.$el_name][$i]) || (isset($_POST[$prfx.$el_name][$i]) && empty($_POST[$prfx.$el_name][$i])))
+ ) {
$no_write[$i] = 1;
}
- if ($reference_array['enable_name'] && $reference_array['delete'] && !$_POST[$reference_array['enable_name']][$i]) {
+ // $this->debug('REF ELEMENT', "[$i] [".$prfx.$el_name."]: MANDATORY: ".isset($data_array['mandatory'])." SET: ".isset($_POST[$prfx.$el_name][$i]).", EMPTY: ".empty($_POST[$prfx.$el_name][$i])." | DO ACTION ".((!isset($_POST[$prfx.$el_name][$i]) || (isset($_POST[$prfx.$el_name][$i]) && empty($_POST[$prfx.$el_name][$i]))) ? 'YES' : 'NO')." => NO WRITE: ".$no_write[$i]);
+ if (isset($reference_array['enable_name']) &&
+ isset($reference_array['delete']) &&
+ !isset($_POST[$reference_array['enable_name']][$i])
+ ) {
$no_write[$i] = 1;
}
+ // $this->debug('REF ELEMENT', "[$i] [".$prfx.$el_name."]: ENABLED NAME: ".isset($reference_array['enable_name']).", DELETE: ".isset($reference_array['delete']).", NOT ENABLED FOR POS: ".(isset($reference_array['enable_name']) ? isset($_POST[$reference_array['enable_name']][$i]) : '-'));
+ // $this->debug('REF ELEMENT', "[$i] [".$prfx.$el_name."]: WRITE: ".$no_write[$i]);
// 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]) {
+ if (isset($reference_array['type']) && $reference_array['type'] == 'reference_data') {
+ if ($data_array['type'] == 'text' && isset($_POST[$prfx.$el_name][$i])) {
$block_write[$i] = 1;
}
} else {
$block_write[$i] = 1;
}
+ // $this->debug('REF ELEMENT', "[$i] [".$prfx.$el_name."]: REFERENCE TYPE: ".isset($reference_array['type']).", SET REFERENCE TYPE: ".(isset($reference_array['type']) ? $reference_array['type'] : '-').", DATA TYPE: ".$data_array['type'].", SET: ".isset($_POST[$prfx.$el_name][$i]).", => BLOCK WIRTE: ".$block_write[$i]);
// set type and boundaries for insert/update
- if ($data_array['pk_id'] && $_POST[$prfx.$el_name][$i]) {
+ if (isset($data_array['pk_id']) &&
+ !empty($data_array['pk_id']) &&
+ !empty($_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]) {
+ // $this->debug('REF ELEMENT', 'SET UPDATE');
+ } elseif (isset($data_array['pk_id']) &&
+ !empty($data_array['pk_id']) &&
+ empty($_POST[$prfx.$el_name][$i])
+ ) {
$q_begin[$i] = 'INSERT INTO '.$table_name.' (';
$q_middle[$i] = ') VALUES (';
$q_end[$i] = ')';
$type[$i] = 'insert';
+ // $this->debug('REF ELEMENT', 'SET INSERT');
}
+ // $this->debug('REF ELEMENT', "[$i] [".$prfx.$el_name."] PK SET: ".isset($data_array['pk_id']).'/'.empty($data_array['pk_id']).', KEY SET: '.empty($_POST[$prfx.$el_name][$i])." -> TYPE: ".(isset($type[$i]) ? $type[$i] : '-'));
// 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]);
+ // $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']) {
+ if (!isset($data_array['pk_id']) && !isset($data_array['fk_id'])) {
// update data list
- if (strlen($q_data[$i])) {
+ if (isset($q_data[$i])) {
$q_data[$i] .= ', ';
+ } else {
+ $q_data[$i] = '';
}
// insert name part list
- if (strlen($q_names[$i])) {
+ if (isset($q_names[$i])) {
$q_names[$i] .= ', ';
+ } else {
+ $q_names[$i] = '';
}
// insert value part list
- if (strlen($q_values[$i])) {
+ if (isset($q_values[$i])) {
$q_values[$i] .= ', ';
+ } else {
+ $q_values[$i] = '';
}
// insert column name add
$q_names[$i] .= $el_name;
@@ -1398,13 +1519,13 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
$_value = 'NULL';
}
} else {
- $_value = $_POST[$prfx.$el_name][$i];
+ $_value = isset($_POST[$prfx.$el_name][$i]) ? $_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']) {
+ if (isset($data_array['int']) || isset($data_array['int_null'])) {
+ if (!$_value && isset($data_array['int_null'])) {
$_value = 'NULL';
- } elseif (!isset($_value)) {
+ } elseif (!$_value) {
$_value = 0;
}
$q_data[$i] .= $el_name.' = '.$_value;
@@ -1420,13 +1541,16 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// finalize the queries, add FK key reference for inserts and run the query
for ($i = 0, $i_max = count($type); $i < $i_max; $i ++) {
$q = '';
- if (!$no_write[$i]) {
+ // skip empty or not fully filled rows
+ if (isset($no_write[$i]) && !$no_write[$i]) {
+ // if tpye is update
if ($type[$i] == 'update') {
$q = $q_begin[$i].$q_data[$i].$q_end[$i];
- } elseif ($block_write[$i]) {
+ // or if we have block write, then it is insert (new)
+ } elseif (isset($block_write[$i]) && $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.' ');
+ $this->debug('edit', 'Pos['.$i.'] => '.$type[$i].' Q: '.$q.' ');
// write the dataset
if ($q) {
$this->dbExec($q);
@@ -1474,7 +1598,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
reset($this->table_array);
foreach ($this->table_array as $key => $value) {
- if ($this->table_array[$key]['type'] == 'file') {
+ if (isset($this->table_array[$key]['type']) && $this->table_array[$key]['type'] == 'file') {
unlink($this->table_array[$key]['save_dir'].$this->table_array[$key]['value']);
}
}
@@ -1496,9 +1620,11 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
reset($this->table_array);
foreach ($this->table_array as $key => $value) {
- if ($this->table_array[$key]['type'] == 'hidden') {
+ if (isset($this->table_array[$key]['type']) &&
+ $this->table_array[$key]['type'] == 'hidden'
+ ) {
if (array_key_exists($key, $this->table_array)) {
- $hidden_array[$key] = $this->table_array[$key]['value'];
+ $hidden_array[$key] = isset($this->table_array[$key]['value']) ? $this->table_array[$key]['value'] : '';
} else {
$hidden_array[$key] = '';
}
@@ -1529,7 +1655,10 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
while ($res = $this->dbReturn($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] : '';
+ $data['selected'][] = ($this->checked(
+ isset($this->reference_array[$table_name]['selected']) ? $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);
@@ -1546,47 +1675,56 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
{
// 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']) {
+ if (isset($this->element_list[$table_name]['mandatory'])) {
$output_name .= ' *';
}
// delete button name, if there is one set
- if ($this->element_list[$table_name]['delete_name']) {
+ if (isset($this->element_list[$table_name]['delete_name'])) {
$data['delete_name'] = $this->element_list[$table_name]['delete_name'];
+ } else {
+ $data['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']) {
+ if (isset($this->element_list[$table_name]['enable_name'])) {
$data['enable_name'] = $this->element_list[$table_name]['enable_name'];
- if ($this->element_list[$table_name]['delete']) {
+ if (isset($this->element_list[$table_name]['delete'])) {
$data['delete'] = 1;
}
+ } else {
+ $data['enable_name'] = '';
}
// prefix for the elements, to not collide with names in the master set
- if ($this->element_list[$table_name]['prefix']) {
+ if (isset($this->element_list[$table_name]['prefix'])) {
$data['prefix'] = $this->element_list[$table_name]['prefix'].'_';
+ } else {
+ $data['prefix'] = '';
}
// the sub data table name
$data['table_name'] = $table_name;
// build the select part
- if (!is_array($this->element_list[$table_name]['elements'])) {
+ if (!isset($this->element_list[$table_name]['elements']) || !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
foreach ($this->element_list[$table_name]['elements'] as $el_name => $data_array) {
- $this->debug('CFG', 'El: '.$el_name.' -> '.$this->printAr($data_array));
+ // $this->debug('CFG', 'El: '.$el_name.' -> '.$this->printAr($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
+ // this is for reading the data
+ $q_select[] = $el_name;
// 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
+ // this are the output names (if given)
+ $data['output_name'][$el_name] = isset($data_array['output_name']) ? $data_array['output_name'] : '';
+ // this is the type of the field
+ $data['type'][$el_name] = isset($data_array['type']) ? $data_array['type'] : '';
// set the primary key name
- if ($data_array['pk_id']) {
+ if (isset($data_array['pk_id'])) {
$data['pk_name'] = $el_name;
}
- if ($data_array['fk_id']) {
+ if (isset($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
@@ -1594,22 +1732,27 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
if ($data_array['type'] == 'drop_down_db') {
$md_q = md5($data_array['query']);
while ($res = $this->dbReturn($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]);
+ $this->debug('edit', 'Q['.$md_q.'] pos: '.$this->cursor_ext[$md_q]['pos'].' | want: '.(isset($data_array['preset']) ? $data_array['preset'] : '-').' | set: '.(isset($data['preset'][$el_name]) ? $data['preset'][$el_name] : '-'));
// first is default for this element
- if (!$data['preset'][$el_name] && ($this->cursor_ext[$md_q]['pos'] == $data_array['preset'])) {
+ if (isset($data_array['preset']) &&
+ (!isset($data['preset'][$el_name]) || (isset($data['preset'][$el_name]) && !$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']) {
+ } elseif (isset($data_array['element_list'])) {
$data['element_list'][$el_name] = $data_array['element_list']; // this is for the checkboxes
}
- $this->debug('CREATE ELEMENT LIST TABLE', 'Post: '.$el_name.' => '.$_POST[$el_name].' => '.is_array($_POST[$el_name]));
+ $this->debug('CREATE ELEMENT LIST TABLE', 'Table: '.$table_name.', Post: '.$el_name.' => '.
+ ((isset($_POST[$el_name]) && is_array($_POST[$el_name])) ? 'AS ARRAY'/*.$this->printAr($_POST[$el_name])*/ : 'NOT SET/OR NOT ARRAY').
+ ((isset($_POST[$el_name]) && !is_array($_POST[$el_name])) ? $_POST[$el_name] : ''));
// if error, check new line addition so we don't loose it
if ($this->error) {
- if (is_array($_POST[$el_name])) {
+ if (isset($_POST[$el_name]) && is_array($_POST[$el_name])) {
// this is for the new line
$proto[$el_name] = $_POST[$el_name][(count($_POST[$el_name]) - 1)];
} else {
@@ -1626,7 +1769,7 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// 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']) {
+ if (isset($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) {
@@ -1656,21 +1799,21 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
$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 .= 'AND '.$table_name.'.'.$this->int_pk_name.' = '.(!empty($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']) {
+ if (isset($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']) {
+ if (isset($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) {
+ if (isset($q)) {
$pos = 0; // position in while for overwrite if needed
// read out the list and add the selected data if needed
while ($res = $this->dbReturn($q)) {
@@ -1684,14 +1827,16 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
// 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') {
+ if (isset($data['element_list'][$prfx.$el_name]) && $data['element_list'][$prfx.$el_name] == 'radio_group') {
$_data[$prfx.$el_name] = ($res[$el_name]) ? ($res[$el_name] - 1) : 0;
- } else {
+ } elseif (isset($_POST[$prfx.$el_name][$pos])) {
$_data[$prfx.$el_name] = $_POST[$prfx.$el_name][$pos];
+ } else {
+ $_data[$prfx.$el_name] = '';
}
} else {
- if ($data['preset'][$prfx.$el_name] && !$res[$el_name]) {
- $_data[$prfx.$el_name] = $data['preset'][$el_name];
+ if (isset($data['preset'][$prfx.$el_name]) && !isset($res[$el_name])) {
+ $_data[$prfx.$el_name] = $data['preset'][$prfx.$el_name];
} else {
$_data[$prfx.$el_name] = $res[$el_name];
}
@@ -1706,43 +1851,61 @@ class Generate extends \CoreLibs\DB\Extended\ArrayIO
}
// 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 (/*isset($this->element_list[$table_name]['type']) &&
+ $this->element_list[$table_name]['type'] == 'reference_data' &&*/
+ isset($this->element_list[$table_name]['max_empty']) &&
+ 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 = is_array($data['content']) ? count($data['content']) : 0;
+ $element_count = (isset($data['content']) && is_array($data['content'])) ? count($data['content']) : 0;
$missing_empty_count = $this->element_list[$table_name]['max_empty'] - $element_count;
$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 = $element_count , $pos_max = $this->element_list[$table_name]['max_empty'] + $element_count; $pos <= $pos_max; $pos ++) {
+ for ($pos = $element_count, $pos_max = $this->element_list[$table_name]['max_empty'] + $element_count; $pos <= $pos_max; $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']) {
+ // do nothing for pk name
+ } elseif (isset($data['fk_name']) &&
+ $el_name == $data['fk_name'] &&
+ isset($this->table_array[$this->int_pk_name]['value'])
+ ) {
$_data[$el_name] = $this->table_array[$this->int_pk_name]['value'];
}
}
$data['content'][] = $_data;
- $data['pos'][] = array(0 => $pos); // this is for the checkboxes
+ $data['pos'][] = array (0 => $pos); // this is for the checkboxes
+ // $this->debug('CFG ELEMENT LIST FILL', 'Pos: '.$pos.'/'.$pos_max.', Content: '.count($data['content']).', Pos: '.count($data['pos']));
}
}
}
- // push in an empty line of this type, but only if we have a delete key
- if ($data['delete_name']) {
+ // push in an empty line of this type, but only if we have a delete key that is also filled
+ if (isset($data['delete_name']) && !empty($data['delete_name'])) {
$data['content'][] = $proto;
+ // we also need the pos add or we through an error in smarty
+ $data['pos'][] = array (
+ 0 => isset($data['pos']) ? count($data['pos']) : 0
+ );
}
- // $this->debug('edit', 'A: