Example #1
0
 private function _parseUrlParams($url)
 {
     $urlComponents = parse_url($url);
     $query = Arrays::getValue($urlComponents, 'query', '');
     parse_str($query, $array);
     return $array;
 }
Example #2
0
 /**
  * @return bool
  */
 public function isShittyRound()
 {
     $hitsInRound = Hit::where(['game_user_id' => $this->game->current_game_user_id, 'round' => $this->game->round])->fetchAll();
     return Arrays::all($hitsInRound, function ($hit) {
         return !$this->isScored($hit->field, $hit->multiplier);
     });
 }
Example #3
0
 public static function newInstance($options)
 {
     if (Arrays::getValue($options, Options::EMULATE_PREPARES)) {
         return new EmulatedPDOPreparedStatementExecutor();
     }
     return new PDOPreparedStatementExecutor();
 }
Example #4
0
 /**
  * Returns object from cache.
  * If there's no object for the given key and $functions is passed, $function result will be stored in cache under the given key.
  *
  * Example:
  * <code>
  * $countries = Cache::get("countries", function() {{
  *    //expensive computation that returns a list of countries
  *    return Country:all();
  * })
  * </code>
  *
  * @param $key
  * @param null $function
  * @return mixed|null
  */
 public static function get($key, $function = null)
 {
     if (!self::contains($key) && $function) {
         self::put($key, call_user_func($function));
     }
     return Arrays::getValue(self::$_cache, $key);
 }
Example #5
0
 private static function newRelation($name, $localKey, $foreignKey, $collection, $params)
 {
     $class = $params['class'];
     $condition = Arrays::getValue($params, 'conditions', '');
     $order = Arrays::getValue($params, 'order', '');
     return new Relation($name, $class, $localKey, $foreignKey, $collection, $condition, $order);
 }
Example #6
0
 public static function of(array $conditions)
 {
     if (Arrays::isAssociative($conditions)) {
         return new ArrayWhereClause($conditions, 'OR');
     }
     return new OrClause($conditions);
 }
 public function matches($argument)
 {
     if (get_class($this->expected) !== get_class($argument)) {
         return false;
     }
     $actualAttributes = Arrays::filterByAllowedKeys($argument->attributes(), $this->expected->getFields());
     return $this->expectedAttributes == $actualAttributes;
 }
 public function getRelation($name)
 {
     $value = Arrays::getValue($this->relations, $name);
     if (is_null($value)) {
         throw new Exception("Relation not found");
     }
     return $value;
 }
Example #9
0
 private function _prepareParameters($uri)
 {
     preg_match_all('#:(\\w+)#', $uri, $matches);
     $parameters = Arrays::getValue($matches, 1, array());
     return Arrays::map($parameters, function ($parameter) {
         return '$' . $parameter;
     });
 }
Example #10
0
 private function whereWithUsing()
 {
     $usingClauses = $this->_query->usingClauses;
     $whereClauses = Arrays::map($usingClauses, function (JoinClause $usingClause) {
         return WhereClause::create($usingClause->getJoinColumnWithTable() . ' = ' . $usingClause->getJoinedColumnWithTable());
     });
     return $this->_where(array_merge($whereClauses, $this->_query->whereClauses));
 }
Example #11
0
 /**
  * Returns comparator which compares objects by using values computed using given expressions.
  * Expressions should comply with format accepted by <code>Functions::extractExpression</code>.
  * Comparator returns an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
  *
  * @param mixed ...
  * @return callable
  */
 public static function compareBy()
 {
     $expressions = func_get_args();
     $comparators = Arrays::map($expressions, function ($expression) {
         return new EvaluatingComparator(Functions::extractExpression($expression));
     });
     return sizeof($comparators) == 1 ? $comparators[0] : new CompoundComparator($comparators);
 }
 public function contents()
 {
     $this->_setupTablePlaceholderReplacements();
     $this->classStub->addPlaceholderReplacement('class', $this->className);
     $this->classStub->addPlaceholderReplacement('namespace', $this->classNamespace);
     Arrays::map($this->tableInfo->tableColumns, array($this->classStub, 'addColumn'));
     return $this->classStub->contents();
 }
Example #13
0
 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());
 }
Example #14
0
 private static function getViewPostfix($responseType)
 {
     $availableViewsMap = array('text/xml' => '.xml.phtml', 'application/json' => '.json.phtml', 'text/json' => '.json.phtml');
     $viewForType = Arrays::getValue($availableViewsMap, $responseType, false);
     if ($viewForType) {
         return $viewForType;
     }
     return Uri::isAjax() ? '.ajax.phtml' : '.phtml';
 }
Example #15
0
 private static function extractParams($elements)
 {
     $params = array();
     foreach ($elements as $element) {
         list($name, $value) = Arrays::map(explode('=', $element), Functions::trim());
         $params[$name] = $value;
     }
     return $params;
 }
Example #16
0
 private function _getPrimaryKey($tableName)
 {
     $primaryKey = Db::getInstance()->query("SHOW KEYS FROM {$tableName} WHERE Key_name = 'PRIMARY'")->fetch();
     if ($primaryKey) {
         return Arrays::getValue($primaryKey, 'Column_name');
     } else {
         return '';
     }
 }
 public function parse()
 {
     if (preg_match('/^findBy([a-zA-Z]\\w*)$/', $this->method, $names)) {
         $names = explode('And', $names[1]);
         $this->names = Arrays::map($names, function ($name) {
             return Strings::camelCaseToUnderscore($name);
         });
     }
 }
Example #18
0
 /**
  * @test
  */
 public function shouldTraceInfoAboutHttpRequest()
 {
     //given
     $this->_createHttpTraceRequest('/request1', array('param1' => 1, 'param2' => 2));
     //when
     $queries = Arrays::first(Stats::queries());
     //then
     ArrayAssert::that($queries['request_params'][0])->hasSize(2)->containsKeyAndValue(array('param1' => 1, 'param2' => 2));
 }
Example #19
0
 public function getPath()
 {
     $uri = Arrays::getValue($_SERVER, 'REDIRECT_URL');
     if (!$uri) {
         return Arrays::getValue($_SERVER, 'REQUEST_URI', '/');
     }
     $queryString = Arrays::getValue($_SERVER, 'REDIRECT_QUERY_STRING');
     return $queryString ? $uri . '?' . $queryString : $uri;
 }
Example #20
0
 public function getFieldsAsString()
 {
     $fields = array_keys($this->_attributes);
     $escapedFields = Arrays::map($fields, Functions::compose(Functions::append("'"), Functions::prepend("'")));
     for ($index = self::FIELDS_COUNT_IN_LINE; $index < sizeof($escapedFields); $index += self::FIELDS_COUNT_IN_LINE) {
         $escapedFields[$index] = "\n\t\t\t" . $escapedFields[$index];
     }
     return implode(', ', $escapedFields);
 }
Example #21
0
 private function _getPrimaryKey($tableName)
 {
     $primaryKey = Db::getInstance()->query("SELECT pg_attribute.attname\n         FROM pg_index, pg_class, pg_attribute\n         WHERE\n            pg_class.oid = '{$tableName}'::REGCLASS AND\n            indrelid = pg_class.oid AND\n            pg_attribute.attrelid = pg_class.oid AND\n            pg_attribute.attnum = ANY(pg_index.indkey)\n            AND indisprimary;\n        ")->fetch();
     if ($primaryKey) {
         return Arrays::getValue($primaryKey, 'attname');
     } else {
         return '';
     }
 }
Example #22
0
 public function join()
 {
     $any = Arrays::any($this->_query->joinClauses, function (JoinClause $joinClause) {
         return Strings::equalsIgnoreCase($joinClause->type, 'RIGHT');
     });
     if ($any) {
         throw new BadMethodCallException('RIGHT JOIN is not supported in sqlite3');
     }
     return parent::join();
 }
Example #23
0
 public static function resolve()
 {
     $accept = array_keys(RequestHeaders::accept()) ?: array('*/*');
     $supported = array('application/json' => 'application/json', 'application/xml' => 'application/xml', 'application/*' => 'application/json', 'text/html' => 'text/html', 'text/*' => 'text/html');
     $intersection = array_intersect($accept, array_keys($supported));
     if ($intersection) {
         return $supported[Arrays::first($intersection)];
     }
     return Arrays::getValue($supported, ContentType::value(), 'text/html');
 }
Example #24
0
 public static function __callStatic($name, $arguments)
 {
     Session::checkSession();
     $dynamicFinder = DynamicFinder::match($name);
     if ($dynamicFinder) {
         $where = Arrays::combine($dynamicFinder->getNames(), $arguments);
         return static::where($where);
     }
     throw new BadMethodCallException('Method [' . $name . '] not exists');
 }
Example #25
0
function postButton($label, $url, $options = [])
{
    $class = Arrays::getValue($options, 'class', '');
    $id = Arrays::getValue($options, 'id', '');
    $idHtml = $id ? " id=\"{$id}\" " : "";
    return <<<TAG
<form action="{$url}" {$idHtml} method="post" class="post-button {$class}">
    <button type="submit" class="btn btn-primary">{$label}</button>
</form>
TAG;
}
Example #26
0
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;
}
Example #27
0
 private function _getColumnsWithoutPrimary(Dialect $dialect)
 {
     $primaryKeyName = $this->primaryKeyName;
     $columns = $dialect->columns();
     if ($primaryKeyName != 'id') {
         return Arrays::filter($columns, function (DatabaseColumn $column) use($primaryKeyName) {
             return $column->name != $primaryKeyName;
         });
     }
     return $columns;
 }
Example #28
0
 /**
  * @test
  */
 public function shouldCreateSelectQueryWithJoin()
 {
     // when
     $query = Query::select()->join('table', 'id', 'other_id', 'tab');
     // then
     $this->assertCount(1, $query->joinClauses);
     $join = Arrays::first($query->joinClauses);
     $this->assertEquals('id', $join->joinColumn);
     $this->assertEquals('table', $join->joinTable);
     $this->assertEquals('other_id', $join->joinedColumn);
 }
Example #29
0
 private function createCheckParameters($parameters)
 {
     if ($parameters) {
         $indent = self::INDENT;
         $checkFunctionParameters = Arrays::map($parameters, function ($element) use($indent) {
             return $indent . "checkParameter({$element});";
         });
         return implode("\n", $checkFunctionParameters) . "\n" . $indent;
     }
     return self::INDENT;
 }
Example #30
0
 public static function _checkCredentials($authUser, $authPassword, $realm)
 {
     $login = Arrays::getValue($_SERVER, 'PHP_AUTH_USER');
     $pass = Arrays::getValue($_SERVER, 'PHP_AUTH_PW');
     if ($authUser != $login || $authPassword != $pass) {
         $code = defined('UNAUTHORIZED') ? UNAUTHORIZED : 0;
         $error = new Error($code, I18n::t('exception.unauthorized'));
         throw new UnauthorizedException($error, array('WWW-Authenticate: Basic realm="' . $realm . '"'));
     }
     return true;
 }