ryanwong
1055 lines
24 KiB
PHP
Executable File
1055 lines
24 KiB
PHP
Executable File
<?php defined('BASEPATH') OR exit('No direct script access allowed');
|
|
include_once dirname(__FILE__) . '/Mapping.php';
|
|
/*Powered By: Manaknightdigital Inc. https://manaknightdigital.com/ Year: 2021*/
|
|
/**
|
|
* Abstract Model
|
|
*
|
|
* @copyright 2019 Manaknightdigital Inc.
|
|
* @link https://manaknightdigital.com
|
|
* @license Proprietary Software licensing
|
|
* @author Ryan Wong
|
|
*/
|
|
class Manaknight_Model extends CI_Model
|
|
{
|
|
protected $_mapping;
|
|
protected $_table = '';
|
|
protected $_primary_key = 'id';
|
|
protected $_return_type = 'array';
|
|
protected $_allowed_fields = [];
|
|
protected $_label_fields = [];
|
|
protected $_use_timestamps = FALSE;
|
|
protected $_created_field = 'created_at';
|
|
protected $_updated_field = 'updated_at';
|
|
protected $_validation_rules = [];
|
|
protected $_validation_messages = [];
|
|
|
|
public function __construct()
|
|
{
|
|
parent::__construct();
|
|
$this->_mapping = new Mapping();
|
|
}
|
|
|
|
/**
|
|
* Get Mapping Delegate
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function get_mapping()
|
|
{
|
|
return $this->_mapping;
|
|
}
|
|
|
|
/**
|
|
* Raw Mysql query
|
|
*
|
|
* @param string $sql
|
|
* @return mixed
|
|
*/
|
|
public function raw_query($sql)
|
|
{
|
|
return $this->db->query($sql);
|
|
}
|
|
|
|
/**
|
|
* Raw no error query for writes
|
|
*
|
|
* @param string $sql
|
|
* @return mixed
|
|
*/
|
|
public function raw_no_error_query($sql)
|
|
{
|
|
return $this->db->simple_query($sql);
|
|
}
|
|
|
|
/**
|
|
* Raw Mysql query
|
|
*
|
|
* @param string $sql
|
|
* @return mixed
|
|
*/
|
|
public function raw_prepare_query($sql, $parameters)
|
|
{
|
|
return $this->db->query($sql, $parameters);
|
|
}
|
|
|
|
/**
|
|
* Get Model
|
|
*
|
|
* @param integer $id
|
|
* @return mixed
|
|
*/
|
|
public function get($id)
|
|
{
|
|
$this->db->from($this->_table);
|
|
$this->db->where($this->_primary_key, $id, TRUE);
|
|
return $this->db->get()->row();
|
|
}
|
|
|
|
/**
|
|
* Get Model by field
|
|
*
|
|
* @param string $field
|
|
* @param mixed $value
|
|
* @return mixed
|
|
*/
|
|
public function get_by_field($field, $value)
|
|
{
|
|
$this->db->from($this->_table);
|
|
$this->db->where($this->clean_alpha_field($field), $value, TRUE);
|
|
return $this->db->get()->row();
|
|
}
|
|
|
|
/**
|
|
* Get Model by fields
|
|
*
|
|
* @param string $field
|
|
* @param mixed $value
|
|
* @return mixed
|
|
*/
|
|
public function get_by_fields($where)
|
|
{
|
|
$this->db->from($this->_table);
|
|
|
|
if (!empty($where))
|
|
{
|
|
foreach($where as $field => $value)
|
|
{
|
|
if (is_numeric($field) && strlen($value) > 0)
|
|
{
|
|
$this->db->where($value);
|
|
continue;
|
|
}
|
|
|
|
if ($value === NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ($value !== NULL)
|
|
{
|
|
$this->db->where($this->clean_alpha_field($field), $value, TRUE);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return $this->db->get()->row();
|
|
}
|
|
|
|
public function update($table,$set,$where)
|
|
{
|
|
return $this->db->set($set)->where($where)->update($table);
|
|
}
|
|
/**
|
|
* Get all Model
|
|
*
|
|
* @return array
|
|
*/
|
|
public function get_all($where = array())
|
|
{
|
|
$this->db->from($this->_table);
|
|
|
|
foreach($where as $field => $value)
|
|
{
|
|
if (is_numeric($field) && strlen($value) > 0)
|
|
{
|
|
$this->db->where($value);
|
|
continue;
|
|
}
|
|
|
|
if ($field === NULL && $value === NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ($value !== NULL)
|
|
{
|
|
$this->db->where($this->clean_alpha_field($field), $value, TRUE);
|
|
}
|
|
}
|
|
|
|
return $this->db->get()->result();
|
|
}
|
|
|
|
/**
|
|
* Get all Model
|
|
*
|
|
* @return array
|
|
*/
|
|
public function get_all_by_status($status)
|
|
{
|
|
$this->db->from($this->_table);
|
|
$this->db->where('status', $status, TRUE);
|
|
return $this->db->get()->result();
|
|
}
|
|
|
|
/**
|
|
* Get all Model key value
|
|
*
|
|
* @return array
|
|
*/
|
|
public function get_all_by_key_value($field, $status)
|
|
{
|
|
$this->db->from($this->_table);
|
|
$this->db->where('status', $status, TRUE);
|
|
|
|
$data = [];
|
|
$results = $this->db->get()->result();
|
|
|
|
foreach ($results as $key => $value)
|
|
{
|
|
$data[$value->id] = $value->{$field};
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Create
|
|
*
|
|
* @param array $data
|
|
* @return mixed
|
|
*/
|
|
public function create($data)
|
|
{
|
|
if ($this->_use_timestamps)
|
|
{
|
|
if (!isset($data[$this->_created_field]))
|
|
{
|
|
$data[$this->_created_field] = date('Y-m-j');
|
|
}
|
|
if (!isset($data[$this->_updated_field]))
|
|
{
|
|
$data[$this->_updated_field] = date('Y-m-j H:i:s');
|
|
}
|
|
}
|
|
|
|
$data = $this->_pre_create_processing($data);
|
|
|
|
$inserted_row = $this->db->insert($this->_table, $this->_filter_allow_keys($data), TRUE);
|
|
|
|
if ($inserted_row)
|
|
{
|
|
return $this->db->insert_id();
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Duplicate
|
|
*
|
|
* @param array $data
|
|
* @return mixed
|
|
*/
|
|
public function duplicate($where, $id)
|
|
{
|
|
$row = $this->get($id);
|
|
|
|
if (!$row)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
$data = json_decode(json_encode($row), true);
|
|
|
|
if ($this->_use_timestamps)
|
|
{
|
|
if (!isset($data[$this->_created_field]))
|
|
{
|
|
$data[$this->_created_field] = date('Y-m-j');
|
|
}
|
|
if (!isset($data[$this->_updated_field]))
|
|
{
|
|
$data[$this->_updated_field] = date('Y-m-j H:i:s');
|
|
}
|
|
}
|
|
|
|
unset($data['id']);
|
|
|
|
$data = $this->_pre_create_processing($data);
|
|
|
|
foreach ($where as $key => $value)
|
|
{
|
|
$data[$key] = $value;
|
|
}
|
|
|
|
|
|
$inserted_row = $this->db->insert($this->_table, $this->_filter_allow_keys($data), TRUE);
|
|
|
|
if ($inserted_row)
|
|
{
|
|
return $this->db->insert_id();
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Bulk Create
|
|
*
|
|
* @param [type] $params
|
|
* @return void
|
|
*/
|
|
public function batch_insert($params)
|
|
{
|
|
if ($this->_use_timestamps)
|
|
{
|
|
foreach ($params as $key => $value)
|
|
{
|
|
$params[$key][$this->_created_field] = date('Y-m-j');
|
|
$params[$key][$this->_updated_field] = date('Y-m-j H:i:s');
|
|
}
|
|
}
|
|
|
|
return $this->db->insert_batch($this->_table, $params);
|
|
}
|
|
|
|
/**
|
|
* Edit {{{upper_case_model}}}
|
|
* @param array $data
|
|
* @param integer $id
|
|
* @return bool
|
|
*/
|
|
public function edit($data, $id)
|
|
{
|
|
if ($this->_use_timestamps)
|
|
{
|
|
if (!isset($data[$this->_updated_field]))
|
|
{
|
|
$data[$this->_updated_field] = date('Y-m-j H:i:s');
|
|
}
|
|
}
|
|
|
|
$data = $this->_post_edit_processing($data);
|
|
|
|
$this->db->where($this->_primary_key, $id, TRUE);
|
|
|
|
return $this->db->update($this->_table, $this->_filter_allow_keys($data));
|
|
}
|
|
|
|
/**
|
|
* Edit {{{upper_case_model}}}
|
|
* @param array $data
|
|
* @param integer $id
|
|
* @return bool
|
|
*/
|
|
public function edit_raw($data, $id)
|
|
{
|
|
if ($this->_use_timestamps)
|
|
{
|
|
$data[$this->_updated_field] = date('Y-m-j H:i:s');
|
|
}
|
|
|
|
$this->db->where($this->_primary_key, $id, TRUE);
|
|
|
|
return $this->db->update($this->_table, $this->_filter_allow_keys($data));
|
|
}
|
|
|
|
/**
|
|
* Soft Delete Model
|
|
* @param array $data
|
|
* @param integer $id
|
|
* @return bool
|
|
*/
|
|
public function delete($id)
|
|
{
|
|
$data = [];
|
|
|
|
if ($this->_use_timestamps)
|
|
{
|
|
$data[$this->_updated_field] = date('Y-m-j H:i:s');
|
|
$data['status'] = 0;
|
|
}
|
|
|
|
$this->db->where($this->_primary_key, $id, TRUE);
|
|
|
|
return $this->db->update($this->_table, $this->_filter_allow_keys($data));
|
|
}
|
|
|
|
/**
|
|
* Real Delete Model
|
|
* @param integer $id
|
|
* @return bool
|
|
*/
|
|
public function real_delete($id)
|
|
{
|
|
return $this->db->delete($this->_table, ['id' => $id]);
|
|
}
|
|
|
|
/**
|
|
* Real Delete Model
|
|
* @param integer $id
|
|
* @return bool
|
|
*/
|
|
public function real_delete_by_fields($where=[])
|
|
{
|
|
$payload = [];
|
|
|
|
if (!empty($where))
|
|
{
|
|
foreach($where as $field => $value)
|
|
{
|
|
if (is_numeric($field) && strlen($value) > 0)
|
|
{
|
|
$payload[] = $value;
|
|
continue;
|
|
}
|
|
|
|
if ($value === null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ($value !== NULL)
|
|
{
|
|
$payload[$field] = $value;
|
|
}
|
|
|
|
}
|
|
}
|
|
return $this->db->delete($this->_table, $payload);
|
|
}
|
|
|
|
/**
|
|
* Real Delete Model
|
|
* @param integer $id
|
|
* @return bool
|
|
*/
|
|
public function real_delete_all()
|
|
{
|
|
return $this->db->truncate($this->_table);
|
|
}
|
|
|
|
/**
|
|
* Debug json Model to error_log and turn off in production
|
|
*
|
|
* @param mixed $data
|
|
* @return void
|
|
*/
|
|
public function dj($key, $data)
|
|
{
|
|
if (ENVIRONMENT == 'development') {
|
|
error_log($key . ' MODEL : ' . json_encode($data));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Debug Model to error_log and turn off in production
|
|
*
|
|
* @param mixed $data
|
|
* @return void
|
|
*/
|
|
public function dl($key, $data)
|
|
{
|
|
if (ENVIRONMENT == 'development') {
|
|
error_log($key . ' MODEL: ' . '<pre>' . print_r($data, TRUE) . '</pre>');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get All Validation Rules
|
|
*
|
|
* @param string $key
|
|
* @return array
|
|
*/
|
|
public function get_all_validation_rule ()
|
|
{
|
|
return $this->_validation_rules;
|
|
}
|
|
|
|
/**
|
|
* Get All Edit Validation Rules
|
|
*
|
|
* @param string $key
|
|
* @return array
|
|
*/
|
|
public function get_all_edit_validation_rule ()
|
|
{
|
|
return $this->_validation_edit_rules;
|
|
}
|
|
|
|
/**
|
|
* Fill validation rules
|
|
*
|
|
* @param mixed $form_validation
|
|
* @param mixed $validation_rules
|
|
* @return void
|
|
*/
|
|
public function set_form_validation($form_validation, $validation_rules)
|
|
{
|
|
$rules = $validation_rules;
|
|
|
|
$messages = $this->_validation_messages;
|
|
|
|
foreach ($rules as $key => $value)
|
|
{
|
|
$error_object = [];
|
|
|
|
if (array_key_exists($key, $messages))
|
|
{
|
|
$error_object = $messages[$key];
|
|
}
|
|
|
|
$form_validation->set_rules($value[0], $value[1], $value[2], $error_object);
|
|
}
|
|
|
|
return $form_validation;
|
|
}
|
|
|
|
/**
|
|
* Count number of model
|
|
*
|
|
* @access public
|
|
* @param mixed $parameters
|
|
* @return integer $result
|
|
*/
|
|
public function count($parameters)
|
|
{
|
|
if (!empty($parameters))
|
|
{
|
|
foreach ($parameters as $key => $value)
|
|
{
|
|
if (is_numeric($key) && strlen($value) > 0)
|
|
{
|
|
$this->db->where($value);
|
|
continue;
|
|
}
|
|
|
|
if ($key === NULL && $value === NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!is_null($value))
|
|
{
|
|
if(is_numeric($value))
|
|
{
|
|
$this->db->where($key, $value);
|
|
continue;
|
|
}
|
|
|
|
if(is_string($value))
|
|
{
|
|
$this->db->like($key, $value);
|
|
continue;
|
|
}
|
|
|
|
$this->db->where($key, $value);
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->_custom_counting_conditions($this->db);
|
|
$this->db->from($this->_table);
|
|
return $this->db->count_all_results();
|
|
}
|
|
|
|
/**
|
|
* Get paginated model
|
|
*
|
|
* @access public
|
|
* @param integer $page default 0
|
|
* @param integer $limit default 10
|
|
* @return array
|
|
*/
|
|
public function get_paginated($page = 0, $limit=10, $where=[], $order_by='', $direction='ASC')
|
|
{
|
|
$this->db->limit($limit, $page);
|
|
|
|
if ($order_by === '')
|
|
{
|
|
$order_by = $this->_primary_key;
|
|
}
|
|
|
|
$this->db->order_by($this->clean_alpha_num_field($order_by), $this->clean_alpha_field($direction));
|
|
|
|
if (!empty($where))
|
|
{
|
|
foreach($where as $field => $value)
|
|
{
|
|
if (is_numeric($field) && strlen($value) > 0)
|
|
{
|
|
$this->db->where($value);
|
|
continue;
|
|
}
|
|
|
|
if ($field === NULL && $value === NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ($value !== NULL)
|
|
{
|
|
if(is_numeric($value))
|
|
{
|
|
$this->db->where($field, $value);
|
|
continue;
|
|
}
|
|
|
|
if(is_string($value))
|
|
{
|
|
$this->db->like($field, $value);
|
|
continue;
|
|
}
|
|
|
|
$this->db->where($field, $value);
|
|
}
|
|
}
|
|
}
|
|
|
|
$query = $this->db->get($this->_table);
|
|
$result = [];
|
|
|
|
if ($query->num_rows() > 0)
|
|
{
|
|
foreach ($query->result() as $row)
|
|
{
|
|
$result[] = $row;
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function _join ($table, $field, $where, $custom_duplicate_names=[])
|
|
{
|
|
$select_statement = '`a`.id as a_id, `b`.id as b_id,' ;
|
|
|
|
$duplicate_names = [
|
|
// 'status',
|
|
// 'created_at',
|
|
// 'updated_at',
|
|
// 'type',
|
|
// 'image',
|
|
// 'data',
|
|
// 'slug',
|
|
// 'description',
|
|
// 'amount',
|
|
// 'subtotal',
|
|
// 'total',
|
|
// 'lat',
|
|
// 'lng',
|
|
// 'address',
|
|
// 'state',
|
|
// 'country',
|
|
// 'city',
|
|
// 'order'
|
|
];
|
|
|
|
if (count($custom_duplicate_names) > 0)
|
|
{
|
|
$duplicate_names = $custom_duplicate_names;
|
|
}
|
|
|
|
foreach ($this->_allowed_fields as $key => $value)
|
|
{
|
|
if (in_array($value, $duplicate_names))
|
|
{
|
|
$select_statement .= "`a`.{$value} as a_{$value}, `b`.{$value} as b_{$value}," ;
|
|
}
|
|
}
|
|
|
|
$this->db->select($select_statement . ' `a`.*, `b`.*');
|
|
$this->db->from($this->_table . ' a');
|
|
$this->db->join($table . ' b', "a.{$field} = b.id");
|
|
|
|
if (!empty($where))
|
|
{
|
|
foreach ($where as $key => $value)
|
|
{
|
|
$this->db->where($key, $value);
|
|
}
|
|
}
|
|
|
|
$result = [];
|
|
$query = $this->db->get();
|
|
foreach ($query->result() as $row)
|
|
{
|
|
$result[] = $row;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function _join_paginate ($table, $field, $where, $page = 0, $limit = 10, $order_by='', $direction='ASC', $custom_duplicate_names=[])
|
|
{
|
|
$select_statement = '`a`.id as a_id, `b`.id as b_id,' ;
|
|
|
|
$duplicate_names = [
|
|
// 'status',
|
|
// 'created_at',
|
|
// 'updated_at',
|
|
// 'type',
|
|
// 'image',
|
|
// 'data',
|
|
// 'slug',
|
|
// 'description',
|
|
// 'amount',
|
|
// 'subtotal',
|
|
// 'total',
|
|
// 'lat',
|
|
// 'lng',
|
|
// 'address',
|
|
// 'state',
|
|
// 'country',
|
|
// 'city',
|
|
// 'order'
|
|
];
|
|
|
|
if (count($custom_duplicate_names) > 0)
|
|
{
|
|
$duplicate_names = $custom_duplicate_names;
|
|
}
|
|
|
|
foreach ($this->_allowed_fields as $key => $value)
|
|
{
|
|
if (in_array($value, $duplicate_names))
|
|
{
|
|
$select_statement .= "`a`.{$value} as a_{$value}, `b`.{$value} as b_{$value}," ;
|
|
}
|
|
}
|
|
|
|
$this->db->select($select_statement . ' `a`.*, `b`.*');
|
|
$this->db->from($this->_table . ' a');
|
|
$this->db->join($table . ' b', "a.{$field} = b.id");
|
|
|
|
if (!empty($where))
|
|
{
|
|
foreach ($where as $key => $value)
|
|
{
|
|
if ($value === NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (is_numeric($key) && strlen($value) < 1)
|
|
{
|
|
$this->db->where($value);
|
|
continue;
|
|
}
|
|
|
|
if (is_numeric($key) && strlen($value) > 1)
|
|
{
|
|
$this->db->where($value);
|
|
continue;
|
|
}
|
|
|
|
if ($value !== NULL)
|
|
{
|
|
$this->db->where($key, $value);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
$result = [];
|
|
|
|
$this->db->limit($limit, $page);
|
|
|
|
if ($order_by === '')
|
|
{
|
|
$order_by = 'a_id';
|
|
}
|
|
|
|
$this->db->order_by($this->clean_alpha_num_field($order_by), $this->clean_alpha_field($direction));
|
|
|
|
$query = $this->db->get();
|
|
foreach ($query->result() as $row)
|
|
{
|
|
$result[] = $row;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Filter all keys before inserting to make sure they are allowed
|
|
*
|
|
* @param mixed $data
|
|
* @return mixed
|
|
*/
|
|
protected function _filter_allow_keys ($data)
|
|
{
|
|
$clean_data = [];
|
|
$allowed_fields = $this->_allowed_fields;
|
|
$allowed_fields[] = $this->_primary_key;
|
|
|
|
if($this->_use_timestamps)
|
|
{
|
|
$allowed_fields[] = $this->_created_field;
|
|
$allowed_fields[] = $this->_updated_field;
|
|
}
|
|
|
|
foreach ($data as $key => $val)
|
|
{
|
|
if (!in_array($key, $allowed_fields))
|
|
{
|
|
continue;
|
|
}
|
|
$clean_data[$key] = $val;
|
|
}
|
|
return $clean_data;
|
|
}
|
|
|
|
/**
|
|
* If you need to modify payload before create, overload this function
|
|
*
|
|
* @param mixed $data
|
|
* @return mixed
|
|
*/
|
|
protected function _pre_create_processing($data)
|
|
{
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* If you need to modify payload before edit, overload this function
|
|
*
|
|
* @param mixed $data
|
|
* @return mixed
|
|
*/
|
|
protected function _post_edit_processing($data)
|
|
{
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Allow user to add extra counting condition so user don't have to change main function
|
|
*
|
|
* @param mixed $parameters
|
|
* @return $db
|
|
*/
|
|
protected function _custom_counting_conditions(&$db)
|
|
{
|
|
return $this->db;
|
|
}
|
|
|
|
/**
|
|
* Escape data
|
|
*
|
|
* @param mixed $data
|
|
* @return mixed
|
|
*/
|
|
public function escape ($data)
|
|
{
|
|
return $this->db->escape($data);
|
|
}
|
|
|
|
/**
|
|
* escapeLikeString data
|
|
*
|
|
* @param mixed $data
|
|
* @return mixed
|
|
*/
|
|
public function escapeLikeString ($data)
|
|
{
|
|
return $this->db->escapeLikeString($data);
|
|
}
|
|
|
|
/**
|
|
* Get Last ID in table
|
|
*
|
|
* @return integer
|
|
*/
|
|
public function get_last_id()
|
|
{
|
|
$last = $this->db->order_by('id','desc')
|
|
->limit(1)
|
|
->get($this->_table)
|
|
->row();
|
|
|
|
if ($last)
|
|
{
|
|
return (int)$last->id;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Get Database Table Schema
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function get_schema()
|
|
{
|
|
return $this->db->field_data($this->_table);
|
|
}
|
|
|
|
/**
|
|
* Get Type Mapping
|
|
*
|
|
* @param string $text
|
|
* @param string $database_expected_field
|
|
* @return boolean
|
|
*/
|
|
public function verify_field_type ($text, $database_expected_field)
|
|
{
|
|
$type_mapping = [
|
|
'string' => ['varchar', 'text', 'char', 'tinytext','mediumtext','longtext', 'binary', 'blob', 'enum'],
|
|
'integer' => ['int', 'tinyint', 'bigint', 'mediumint', 'bit', 'timestamp', 'year'],
|
|
'float' => ['float','decimal', 'double'],
|
|
'date' => ['date'],
|
|
'datetime' => ['datetime'],
|
|
'time' => ['time']
|
|
];
|
|
|
|
$field_allow = $type_mapping['string'];
|
|
|
|
if (in_array($database_expected_field, $type_mapping['string']))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
if (preg_match("/^[0-9]+$/i", $text))
|
|
{
|
|
// $this->dl('integer', $text);
|
|
$field_allow = $type_mapping['integer'];
|
|
}
|
|
elseif (is_numeric($text))
|
|
{
|
|
// $this->dl('float', $text);
|
|
$field_allow = $type_mapping['float'];
|
|
}
|
|
elseif ($this->validate_date($text, 'Y-m-d'))
|
|
{
|
|
// $this->dl('date', $text);
|
|
$field_allow = $type_mapping['date'];
|
|
}
|
|
elseif ($this->validate_date($text, 'Y-m-d H:i:s'))
|
|
{
|
|
// $this->dl('datetime', $text);
|
|
$field_allow = $type_mapping['datetime'];
|
|
}
|
|
elseif ($this->validate_date($text, 'H:i:s'))
|
|
{
|
|
// $this->dl('time', $text);
|
|
$field_allow = $type_mapping['time'];
|
|
}
|
|
|
|
// $this->dl('keys', implode(',', $field_allow));
|
|
|
|
if (in_array($database_expected_field,$field_allow))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Validate string matches date
|
|
*
|
|
* @param string $date
|
|
* @param string $format
|
|
* @return boolean
|
|
*/
|
|
protected function validate_date($date, $format = 'Y-m-d')
|
|
{
|
|
$d = DateTime::createFromFormat($format, $date);
|
|
return $d && $d->format($format) === $date;
|
|
}
|
|
|
|
|
|
protected function clean_alpha_num_field ($text)
|
|
{
|
|
return preg_replace("/[^0-9a-zA-Z\_%]/", "", $text );
|
|
}
|
|
|
|
protected function clean_alpha_field ($text)
|
|
{
|
|
return preg_replace("/[^a-zA-Z\_%]/", "", $text );
|
|
}
|
|
|
|
public function batch_update($params)
|
|
{
|
|
return $this->db->update_batch($this->_table, $params, 'id');
|
|
}
|
|
|
|
public function time_default_mapping ()
|
|
{
|
|
$results = [];
|
|
for ($i=0; $i < 24; $i++)
|
|
{
|
|
for ($j=0; $j < 60; $j++)
|
|
{
|
|
$hour = ($i < 10) ? '0' . $i : $i;
|
|
$min = ($j < 10) ? '0' . $j : $j;
|
|
$results[($i * 60) + $j] = "$hour:$min";
|
|
}
|
|
}
|
|
return $results;
|
|
}
|
|
|
|
|
|
|
|
public function get_auto_increment_id()
|
|
{
|
|
$sql = $this->db->query('SELECT AUTO_INCREMENT FROM information_schema.TABLES WHERE TABLE_SCHEMA = "'. $this->db->database .'" AND TABLE_NAME = "'. $this->_table .'" ');
|
|
|
|
return $sql->row()->AUTO_INCREMENT;
|
|
}
|
|
|
|
public function log_activity($action, $now_data, $prev_data, $user_id)
|
|
{
|
|
$prev_data = json_decode(json_encode($prev_data), true);
|
|
$change_details = '';
|
|
if(count($prev_data) > 0)
|
|
{
|
|
$change_details = 'Data changed from '. json_encode($prev_data) . ' to ' .json_encode($now_data);
|
|
}
|
|
else
|
|
{
|
|
$change_details = json_encode($now_data);
|
|
}
|
|
$operation_data = [
|
|
'user_id' => $user_id,
|
|
'action' => $action,
|
|
'detail' => $change_details,
|
|
'created_at' => date('Y-m-j H:i:s'),
|
|
'updated_at' => date('Y-m-j H:i:s')
|
|
];
|
|
$this->db->insert($this->_table, $operation_data);
|
|
}
|
|
|
|
|
|
|
|
public function get_all_custom_where($custom_where = null,$where = array())
|
|
{
|
|
$this->db->from($this->_table);
|
|
|
|
foreach($where as $field => $value)
|
|
{
|
|
if (is_numeric($field) && strlen($value) > 0)
|
|
{
|
|
$this->db->where($value);
|
|
continue;
|
|
}
|
|
|
|
if ($field === NULL && $value === NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ($value !== NULL)
|
|
{
|
|
$this->db->where($this->clean_alpha_field($field), $value, TRUE);
|
|
}
|
|
}
|
|
|
|
if($custom_where !=null){
|
|
$this->db->where($custom_where);
|
|
}
|
|
|
|
return $this->db->get()->result();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} |