public static function callFunction($functionName, $parameters)
{
$db = self::getInstance();
$bindParams = Arrays::toArray($parameters);
$paramsQueryString = implode(',', array_pad(array(), sizeof($bindParams), '?'));
return Arrays::first($db->query("SELECT {$functionName}({$paramsQueryString})", $parameters)->fetch());
}
public function __construct($httpCode, $errors, $headers = array())
{
$this->_httpCode = $httpCode;
$this->_errors = Arrays::toArray($errors);
$this->_headers = $headers;
$firstError = Arrays::first($this->_errors);
parent::__construct($firstError->getMessage(), $firstError->getCode());
}
function showSuccess(array $notices = array())
{
if (Session::has('messages') || $notices) {
$sessionMessages = Arrays::filterNotBlank(Arrays::toArray(Session::get('messages')));
$notices = array_merge($sessionMessages, $notices);
$noticeView = new View('success_alert');
$noticeView->notices = $notices;
return $noticeView->render();
}
return null;
}
private function getKeyAndValueArguments($args)
{
if (count($args) == 1 && is_array($args[0])) {
$args = $args[0];
}
if (count($args) < 2) {
throw new InvalidArgumentException('Method needs at least two arguments: key and value');
}
$value = array_pop($args);
$keys = Arrays::toArray($args);
return array($keys, $value);
}
function selectTag($name, array $items = array(), $value, array $attributes = array(), $promptOption = null)
{
$value = Arrays::toArray($value);
$attr = _prepareAttributes($attributes, array('name' => $name));
$optionsString = '';
if ($promptOption) {
$items = array(null => $promptOption) + $items;
}
foreach ($items as $optionValue => $optionName) {
$optionsString .= optionTag($optionValue, $optionName, $value);
}
return '<select ' . $attr . '>' . $optionsString . '</select>';
}
/**
* @param Relation[] $relations
* @param string|string[]|null $aliases
* @return RelationWithAlias[]
*/
public static function associateRelationsWithAliases(array $relations, $aliases)
{
$aliases = Arrays::toArray($aliases);
if (count($relations) < count($aliases)) {
throw new InvalidArgumentException("More aliases than relations in join");
}
$relationWithAliases = array();
foreach ($relations as $index => $relation) {
$alias = Arrays::getValue($aliases, $index, Arrays::getValue($aliases, $relation->getName()));
$relationWithAliases[] = new RelationWithAlias($relation, $alias);
}
return $relationWithAliases;
}
public function revertProperty($keys)
{
$keys = Arrays::toArray($keys);
$config =& $this->_config;
$overriddenConfig =& $this->_overriddenConfig;
$overriddenKey = null;
foreach ($keys as $key) {
if (!array_key_exists($key, $overriddenConfig)) {
throw new InvalidArgumentException('Cannot revert. No configuration override for: ' . Objects::toString($keys));
}
$config =& $config[$key];
if (is_array($overriddenConfig[$key])) {
$overriddenConfig =& $overriddenConfig[$key];
} else {
$overriddenKey = $key;
}
}
$config = $overriddenConfig[$overriddenKey];
}
private static function addRoute($method, $uri, $action, $requireAction = true, $options = array(), $isResource = false)
{
$methods = Arrays::toArray($method);
if (self::$isDebug && $requireAction && self::$validate && self::existRouteRule($methods, $uri)) {
$methods = implode(', ', $methods);
throw new InvalidArgumentException('Route rule for method ' . $methods . ' and URI "' . $uri . '" already exists');
}
$elements = explode('#', $action);
$controller = Arrays::first($elements);
$actionToRule = Arrays::getValue($elements, 1);
$routeRule = new RouteRule($method, $uri, $controller, $actionToRule, $requireAction, $options, $isResource);
if ($routeRule->hasRequiredAction()) {
throw new InvalidArgumentException('Route rule ' . $uri . ' required action');
}
self::$routes[] = $routeRule;
foreach ($methods as $method) {
self::$routeKeys[$method . $uri] = true;
}
}
/**
* @param $columns
* @param int $type
* @return ModelQueryBuilder
*/
public function select($columns, $type = PDO::FETCH_NUM)
{
$this->_selectModel = false;
$this->_query->selectColumns = Arrays::toArray($columns);
$this->_query->selectType = $type;
return $this;
}
/**
* @return $this
*/
private function types()
{
$ns = $this->builder->getNs();
$typesElement = $this->createElement('types');
$schemaElement = $this->createElementWithAttributes('xsd:schema', ['targetNamespace' => $ns, 'xmlns' => $ns]);
foreach ($this->builder->getMethods() as $method) {
$typesForParameters = $this->XMLStyle->generateTypes($this->DOMDocument, $method->getParameters(), $this->XMLSoapVersion);
$typesForReturn = $this->XMLStyle->generateTypes($this->DOMDocument, Arrays::toArray($method->getReturn()), $this->XMLSoapVersion);
$types = array_merge($typesForParameters, $typesForReturn);
foreach ($types as $type) {
$schemaElement->appendChild($type);
}
}
$typesElement->appendChild($schemaElement);
$this->definitionsRootNode->appendChild($typesElement);
return $this;
}
private function wrapAsNotices($messages, $url)
{
$array = Arrays::toArray($messages);
return Arrays::map($array, function ($msg) use($url) {
return new Notice($msg, $url);
});
}
/** Executes a native sql and returns an array of model objects created by passing every result row to the model constructor.
* @param $nativeSql - database specific sql
* @param array $params - bind parameters
* @return Model[]
*/
public static function findBySql($nativeSql, $params = array())
{
$meta = static::metaInstance();
$results = $meta->_modelDefinition->db->query($nativeSql, Arrays::toArray($params))->fetchAll();
return Arrays::map($results, function ($row) use($meta) {
return $meta->newInstance($row);
});
}
/**
* @test
*/
public function toArrayShouldReturnArrayWithOneElementForEmptyString()
{
// when
$result = Arrays::toArray('');
// then
$this->assertEquals(array(''), $result);
}
public function __construct($sql, $parameters = array())
{
$this->sql = $sql;
$this->values = $parameters === NULL ? array(null) : Arrays::toArray($parameters);
}
public static function getControllerNamespace()
{
$controllerPath = Config::getValue('namespace', 'controller');
return $controllerPath ? Arrays::toArray($controllerPath) : array("\\Application\\Controller\\");
}
private static function _isServerVariableSetAndHasValue($variableName, $values)
{
$value = Arrays::getValue($_SERVER, $variableName);
return in_array($value, Arrays::toArray($values));
}
/**
* @param $class
* @param $params
* @return ModelDefinition
*/
private static function _createDefinition($class, $params)
{
$table = Arrays::getValue($params, 'table') ?: self::defaultTable($class);
$primaryKey = Arrays::getValue($params, 'primaryKey', 'id');
$sequence = Arrays::getValue($params, 'sequence', "{$table}_{$primaryKey}_seq");
list($fields, $defaults) = self::_extractFieldsAndDefaults($params['fields']);
$relations = new Relations($class, $params, $primaryKey);
$db = empty($params['db']) ? Db::getInstance() : $params['db'];
if ($primaryKey && !in_array($primaryKey, $fields)) {
$fields[] = $primaryKey;
}
$afterSaveCallbacks = Arrays::toArray(Arrays::getValue($params, 'afterSave'));
$beforeSaveCallbacks = Arrays::toArray(Arrays::getValue($params, 'beforeSave'));
return new ModelDefinition($db, $table, $sequence, $primaryKey, $fields, $relations, $afterSaveCallbacks, $beforeSaveCallbacks, $defaults);
}
