static function __callStatic($name, $arguments)
{
if (!method_exists(__CLASS__, $name)) {
Debug::toss('DbBatch method not found: ' . $name);
}
$class = __CLASS__;
$that = new $class();
return call_user_func_array(array($that, $name), $arguments);
}
function req($className)
{
$result = $this->load($className);
$lastAutoloader = array_slice(spl_autoload_functions(), -1)[0];
//this is the last autoload and it has failed
if (!$result['found'] && is_a($lastAutoloader, 'Autoload')) {
$error = 'Attempt to autoload class "' . $className . '" has failed. Tested folders: ' . "\n" . implode("\n", array_keys($result['searched']));
Debug::toss($error, __CLASS__ . 'Exception');
}
}
function __call($name, $arguments)
{
if (!method_exists($this, $name)) {
$name = substr($name, 1);
if (!method_exists(__CLASS__, $name)) {
\Debug::toss('Bad Form class method');
}
$formerValueBehavior = $this->valueBehavior;
$this->valueBehavior = array_shift($arguments);
$return = call_user_func_array(array($this, $name), $arguments);
$this->valueBehavior = $formerValueBehavior;
return $return;
}
return call_user_func_array(array($this, $name), $arguments);
}
static function loadXml($xml, $nsPrefix = 'd')
{
$dom = new DOMDocument();
@$dom->loadXML($xml);
$xpath = new DomXPath($dom);
$rootNamespace = $dom->lookupNamespaceUri($dom->namespaceURI);
if ($rootNamespace) {
if ($dom->documentElement->getAttribute('xmlns:d')) {
Debug::toss('Namespace prefix "' . $nsPrefix . '" taken');
}
$xpath->registerNamespace($nsPrefix, $rootNamespace);
$nsPrefix .= ':';
} else {
$nsPrefix = '';
}
return array($dom, $xpath, $nsPrefix);
}
function req($name, $timeout = 0)
{
if (!$this->on($name, $timeout)) {
Debug::toss('Failed to acquire lock "' . $name . '"', __CLASS__ . 'Exception');
}
}
protected function validateCsrfToken()
{
$csrfToken = $_SESSION['csrfToken'];
unset($_SESSION['csrfToken']);
if (!$this->control->in['csrfToken']) {
\Debug::toss('Missing CSRF token', 'InputException');
} elseif ($this->control->in['csrfToken'] != $csrfToken) {
\Debug::toss('CSRF token mismatch', 'InputException');
}
}
protected function findLink($table, $referencedTable, $referenceColumn = null)
{
foreach ($this->tables[$table]['links'] as $k => $v) {
if ($v['ft'] == $referencedTable) {
if (!$referenceColumn || $referenceColumn == $v['dc']) {
return $k;
}
}
}
Debug::toss('DbModel failed to find link', var_export(func_get_args(), 1));
}
function __call($fnName, $args)
{
if (method_exists($this, $fnName)) {
return call_user_func_array(array($this, $fnName), $args);
} elseif (method_exists($this->under, $fnName)) {
return call_user_func_array(array($this->under, $fnName), $args);
} elseif (method_exists($this->under, '__call')) {
//under may have it's own __call handling
return call_user_func_array(array($this->under, $fnName), $args);
}
Debug::toss(__CLASS__ . ' Method not found: ' . $fnName);
}
static function sendFile($path, $saveAs = null, $exit = true)
{
//Might potentially remove ".." from path, but it has already been removed by the time the request gets here by server or browser. Still removing for precaution
$path = Files::removeRelative($path);
if (is_file($path)) {
$mime = Files::mime($path);
header('Content-Type: ' . $mime);
if ($saveAs) {
header('Content-Description: File Transfer');
if (strlen($saveAs) > 1) {
$fileName = $saveAs;
} else {
$fileName = array_pop(explode('/', $path));
}
header('Content-Disposition: attachment; filename="' . self::escapeFilename($fileName) . '"');
}
echo file_get_contents($path);
} elseif ($_ENV['resourceNotFound']) {
Config::loadUserFiles($_ENV['resourceNotFound'], 'control');
} else {
Debug::toss('Request handler encountered unresolvable file. Searched at ' . $path);
}
if ($exit) {
exit;
}
}
/**
@param table table to replace on
@param where see self::where() function
@return row count
@note as a precaution, to delete all must use $where = '1 = 1'
*/
protected function delete($table, $where)
{
if (!$where) {
Debug::toss('Unqualified delete is too risky. Use 1=1 to verify');
}
return $this->query('DELETE FROM ' . $this->quoteIdentity($table) . $this->where($where))->rowCount();
}
/**
@param rules string or array
Rules can be an array of rules, or a string separated by "," for each rule.
Each rule can be a string or an array.
As a string, the rule should be in one of the following forms:
"f:name|param1;param2" indicates InputFilter method
"v:name|param1;param2" indicates InputValidate function
"g:name|param1;param2" indicates global scoped function
"class:name|param1,param2,param3" indicates static method "name: of class "class"
"l:name|param1,param2,param3" Local tool method
"name" replaced by Field fieldType of the same name
As an array, the rule function part (type:method) is the first element, and the parameters to the function part are the following elements. Useful if function arguments contain commas or semicolons. Ex:
array('type:method','arg1','arg2','arg3')
The "type:method" part can be prefixed with "!" to indicate there should be a break on error, and no more rules for that field should be applied
The "type:method" part can be prefixed with "!!" to indicate there should be a break on error and no more rules for any field should be applied
If array, first part of rule is taken as string with the behavior above without parameters and the second part is taken as the parameters; useful for parameters that include commas or semicolons or which aren't strings
Examples for rules:
1: 'v:email|bob.com,customClass:method|param1;param2',
2: array('v:email|bob.com','customClass:method|param1;param2'),
3: array(array('v:email','bob.com'),array('customClass:method','param1','param2')),
*/
function applyFilterValidateRules($field, $rules, $errorOptions)
{
$originalRules = $rules;
$rules = Arrays::stringArray($rules);
for ($i = 0; $i < count($rules); $i++) {
$rule = $rules[$i];
$params = array(&$this->in[$field]);
if (is_array($rule)) {
$callback = array_shift($rule);
$params2 =& $rule;
} else {
list($callback, $params2) = explode('|', $rule);
if ($params2) {
$params2 = explode(';', $params2);
}
}
///merge field value param with the user provided params
if ($params2) {
Arrays::mergeInto($params, $params2);
}
//used in combination with !, like ?! for fields that, if not empty, should be validated, otherwise, ignored.
$ignoreError = false;
if (substr($callback, 0, 1) == '?') {
$callback = substr($callback, 1);
$ignoreError = true;
}
if (substr($callback, 0, 2) == '!!') {
$callback = substr($callback, 2);
$superBreak = true;
}
if (substr($callback, 0, 1) == '!') {
$callback = substr($callback, 1);
$break = true;
}
list($type, $method) = explode(':', $callback, 2);
if (!$method) {
$method = $type;
$type = '';
}
if (!$method) {
Debug::quit('Failed to provide method for input handler on field: ' . $field, 'Rules:', $rules);
}
try {
switch ($type) {
case 'f':
call_user_func_array(array('InputFilter', $method), $params);
break;
case 'v':
call_user_func_array(array('InputValidate', $method), $params);
break;
case 'l':
call_user_func_array(array($this->lt, $method), $params);
break;
case 'g':
call_user_func_array($method, $params);
break;
case '':
if ($this->inputRuleAliases === null) {
$this->inputRuleAliases = \control\Field::$ruleAliases;
}
//get new named rules and parse
if (!$this->inputRuleAliases[$method]) {
Debug::toss('Unknown input rule alias on field ' . $field . ' Rule:' . $rule);
}
$newRules = Arrays::stringArray($this->inputRuleAliases[$method]);
if ($i + 1 < count($rules)) {
///there are rules after this alias, so combine alias with those existing after
$newRules = array_merge($newRules, array_slice($rules, $i + 1));
}
$rules = $newRules;
$i = -1;
break;
default:
call_user_func_array(array($type, $method), $params);
break;
}
} catch (InputException $e) {
//add error to messages
if (!$ignoreError) {
$this->error($e->getMessage(), $field, $errorOptions);
}
//super break will break out of all fields
if ($superBreak) {
return false;
}
//break will stop validators for this one field
if ($break) {
break;
}
}
}
return true;
}
static function htmlTagContextIntegrityCallback($match)
{
preg_match('@^[a-z]+@i', $match[2], $tagMatch);
$tagName = $tagMatch[0];
if ($match[1] == '<') {
//don't count self contained tags
if (substr($match[2], -1) != '/') {
self::$tagHierarchy[] = $tagName;
}
} else {
$lastTagName = array_pop(self::$tagHierarchy);
if ($tagName != $lastTagName) {
Debug::toss(self::$errorMessages['noTagIntegrity'], 'InputException');
}
}
}
/**
@param file file path
@param globalize list of strings representing variables to globalize for the included file
@param vars variables to extract for use by the file
@param extract variables to extract from the included file to be returned
@return true or extracted varaibles if file successfully included, else false
*/
private static function reqOnce($_file, $_globalize = null, $_vars = null, $_extract = null)
{
if (is_file($_file)) {
self::logIncluded(true);
if ($_globalize) {
foreach ($_globalize as $_global) {
global ${$_global};
}
}
if ($_vars) {
extract($_vars, EXTR_SKIP);
#don't overwrite existing
}
include_once $_file;
if ($_extract) {
foreach ($_extract as $_var) {
$_return[$_var] = ${$_var};
}
return $_return;
}
return true;
}
self::logIncluded(false);
Debug::toss('Could not include file "' . $_file . '"');
}
function load()
{
$this->under = $this->cacher = new Memcached();
if (!is_array(current($this->connectionInfo))) {
$this->connectionInfo = array($this->connectionInfo);
}
foreach ($this->connectionInfo as $v) {
if (!$this->cacher->addserver($v[0], $v[1], $v[2])) {
Debug::toss('Failed to add cacher "' . $name . '"', __CLASS__ . 'Exception');
}
}
}
static function fork($callable)
{
$pid = pcntl_fork();
if ($pid == -1) {
Debug::toss('could not fork');
} elseif ($pid) {
// we are the parent
return;
} else {
call_user_func_array($callable, array_slice(func_get_args(), 1));
exit;
}
}