public static function obtenirTout(Condition $conditions = NULL, $offset = 0, $limite = NULL)
 {
     $listeRecords = ORM::forTable(self::nomTable());
     // Prise en compte d'éventuelles conditions
     if ($conditions !== NULL) {
         $listeRecords->whereRaw($conditions->generer(), $conditions->listeValeurs());
     }
     // Pris en compte de l'éventuel limite
     if ($limite !== NULL) {
         $listeRecords->limit($limite);
     }
     // Prise en compte de l'éventuel offset
     $listeRecords->offset($offset);
     // Récupération des résultats
     $listeRecords = $listeRecords->findMany();
     $listeElements = array();
     // On récupère le nom de la classe instanciée pour pouvoir en retourner les objets
     $nomClasse = get_called_class();
     foreach ($listeRecords as $record) {
         $objet = new $nomClasse();
         // Hydration de l'objet
         $objet->setRecord($record);
         // Ajout dans la liste des résultats
         $listeElements[] = $objet;
     }
     return $listeElements;
 }

 function testValidateOperator()
 {
     $c = new Condition();
     $c->add('foo', 'bar', 'SQL injection!');
     $this->setExpectedException('InvalidArgumentException');
     $stmnt = $c->getQueryStatement();
     $stmnt->setConnection(DBManager::getConnection());
 }

 public function getTelefones()
 {
     $condition = new Condition();
     $condition->addFilter("pessoa_id = '" . $this->id . "'");
     $telefoneTable = new TelefoneTable();
     $telefones = $telefoneTable->get($condition);
     return $telefones;
 }

 public function doesNotContain($string)
 {
     $rep = Condition::stringOf($string);
     return $this->isNot(new Match(function ($value) use($string) {
         return false !== strpos($value, $string);
     }, ['%s does not contain ' . $rep, '%s contains ' . $rep]));
 }

 protected function evaluatedValue(Condition $condition)
 {
     if (!$this->state) {
         return 'unknown';
     }
     $value = $condition->evaluate($this->state);
     if ($value instanceof Yes) {
         return 'true';
     } elseif ($value instanceof No) {
         return 'false';
     } elseif ($value instanceof Maybe) {
         return 'maybe';
     } else {
         return 'undefined';
     }
 }

 /**
  * [checkCondition description]
  * @param  [type] $cond [description]
  * @return [type]       [description]
  */
 public function checkCondition($cond)
 {
     $rs = Condition::where('cond_name', '=', $cond)->count();
     if (isset($rs)) {
         return $rs >= 1 ? false : true;
     }
 }

 public function queryAction()
 {
     $q = new Query();
     $q->addAggregation(SelectAggregation::AGTN_DISTINTC, 'p', 'nombre')->addFrom('hello_world_persona', 'p')->setCondition(Condition::GT('p', "edad", 25));
     $pm = PersistentManager::getInstance();
     $result = $pm->findByQuery($q);
     return $this->renderString(print_r($result, true));
 }

 public function getView($slug)
 {
     $game = $this->getModelFromSlug($slug);
     $products = $game->products()->orderBy('created_at', 'DESC')->get();
     $platforms = Platform::all();
     $conditions = Condition::all();
     return View::make('site/game/view_game', compact('game', 'products', 'platforms', 'conditions'));
 }

 public function removeCondition(Condition $condition = null)
 {
     if ($condition) {
         if ($this->condition) {
             $this->condition->removeCondition($condition);
         }
     } else {
         $this->condition = null;
     }
 }

 protected function _argToCondition($arg)
 {
     if (!$arg instanceof Condition) {
         $arg = Condition::create($arg);
         if ($this->_prefix) {
             $arg->setPrefix($this->_prefix);
         }
     }
     return $arg;
 }

 /**
  * Apply this JOIN statement on given query
  * @param array $query Query to apply JOIN on
  * @return void
  */
 public function applyOn(array &$query)
 {
     $query[] = sprintf('%s %%n %%n', $this->type);
     $query[] = $this->table;
     $query[] = $this->name ?: $this->table;
     if (!empty($this->conditions)) {
         $query[] = 'ON';
         Condition::applyListOn($query, $this->conditions);
     }
 }

 /**
  * @param string $value
  * @return Condition
  * @throws \Exception
  * @internal
  */
 public function __getCondition($value)
 {
     if ($this->where === NULL && is_string($this->condition)) {
         list(, $from, $to) = \Nette\Utils\Strings::match($value, $this->mask);
         $from = \DateTime::createFromFormat($this->dateFormatInput, trim($from));
         $to = \DateTime::createFromFormat($this->dateFormatInput, trim($to));
         $values = $from && $to ? array($from->format($this->dateFormatOutput), $to->format($this->dateFormatOutput)) : NULL;
         return $values ? Condition::setup($this->getColumn(), $this->condition, $values) : Condition::setupEmpty();
     }
     return parent::__getCondition($value);
 }

 public function testCondition()
 {
     $params = array();
     $f = new Field('test');
     $arr = array(1, 2, 3, 4, 5);
     $c = new Condition('in', $f, $arr);
     $this->assertEquals('`t0`.`test` IN (1, 2, 3, 4, 5)', $c->getSql($params));
     $this->assertEquals('in', $c->getComparison());
     $this->assertEquals(var_export($f, true), var_export($c->getLeft(), true));
     $this->assertEquals(var_export($arr, true), var_export($c->getRight(), true));
     try {
         $c = new Condition('in', new Field('test'), 'error');
         $this->fail('second parameter shoud be array-only, but string passed');
     } catch (InvalidArgumentException $e) {
     }
     try {
         $c = new Condition('in', new Field('test'), array('a'));
         $this->fail('second parameter shoud be array of integets, but array of strings passed');
     } catch (InvalidArgumentException $e) {
     }
 }

 /**
  * constructor
  * @param string $column_name
  * @param mixed $argument
  * @param string $operation
  * @param string $pipe
  * @return void
  */
 function ConditionWithoutArgument($column_name, $argument, $operation, $pipe = "")
 {
     parent::Condition($column_name, $argument, $operation, $pipe);
     $tmpArray = array('in' => 1, 'notin' => 1, 'not_in' => 1);
     if (isset($tmpArray[$operation])) {
         if (is_array($argument)) {
             $argument = implode($argument, ',');
         }
         $this->_value = '(' . $argument . ')';
     } else {
         $this->_value = $argument;
     }
 }

 /**
  * @param string $value
  * @return Condition|bool
  * @throws \Exception
  * @internal
  */
 public function __getCondition($value)
 {
     $condition = parent::__getCondition($value);
     if ($condition === NULL) {
         $condition = Condition::setupEmpty();
         if (preg_match('/(<>|[<|>]=?)?([-0-9,|.]+)/', $value, $matches)) {
             $value = str_replace(',', '.', $matches[2]);
             $operator = $matches[1] ? $matches[1] : '=';
             $condition = Condition::setup($this->getColumn(), $operator . ' ?', $value);
         }
     }
     return $condition;
 }

 public function __set($name, $value)
 {
     if ($value instanceof PersistenceModel) {
         $value = ColumnManager::getColumn();
     } else {
         if (is_string($value)) {
             $value = preg_replace("/(.)'(.)/i", '$1\\\'$2', $value);
         }
     }
     if (Condition::is_operator($name)) {
         self::addCondition(Condition::getInstance($name, $this->relation_name, $value));
     } else {
         $fullname = ($this->relation ? "{$this->relation}." : "") . ($this->name ? "{$this->name}." : "") . $name;
         self::addCondition(Condition::__equ__($fullname, $value));
     }
 }

 public static function createSelectParams($condition = null, $order = null, $limit = null)
 {
     $sql = "";
     if (!is_null($condition)) {
         $sql .= " WHERE " . Condition::create($condition)->toSql();
     } else {
         $sql .= " WHERE 1";
     }
     if ($order) {
         $sql .= " ORDER BY " . Helper::orderToSql($order);
     }
     if ($limit) {
         $sql .= " LIMIT " . Helper::limitToSql($limit);
     }
     return $sql;
 }

 public static function getTimeline($user, $offset = 0, $max = 20)
 {
     if ($user == NULL) {
         throw new Exception('user is null');
     }
     // Messages belonging to me or the users I follow
     $_or = Condition::_OR()->add(Condition::EQ(self::TABLE, 'createdBy_id', $user->getId()));
     // I want to see my messages also
     $following = $user->getFollowing();
     foreach ($following as $otherUser) {
         $_or->add(Condition::EQ(self::TABLE, 'createdBy_id', $otherUser->getId()));
     }
     // Paginated search
     // Messages ordered by createdOn, first the last messages
     $list = Message::findBy($_or, new ArrayObject(array('sort' => 'createdOn', 'dir' => 'desc', 'offset' => $offset, 'max' => $max)));
     return $list;
 }

 public static function _select($condition = null, $order = null, $limit = null)
 {
     if (is_null(self::$_preloaded)) {
         self::$_preloaded = parent::_select();
     }
     //TODO: $order & $limit processing
     if (is_null($condition)) {
         return self::$_preloaded;
     }
     $condition = Condition::create($condition);
     $resultSet = [];
     foreach (self::$_preloaded as $entry) {
         if ($condition->test($entry)) {
             $resultSet[] = $entry;
         }
     }
     return $resultSet;
 }

 /**
  * @param string username
  * @param string password
  * @param boolean remember
  */
 public static function login($username, $password)
 {
     if (empty($username) || empty($password)) {
         return self::LOGIN_ERR_INCOMPLETE;
     }
     $cond = Condition::_AND()->add(Condition::EQ(self::TABLE, 'username', $username))->add(Condition::EQ(self::TABLE, 'password', $password));
     $list = TUser::findBy($cond, new ArrayObject());
     if (count($list) == 0) {
         return self::LOGIN_ERR_FAILED;
     }
     $user = $list[0];
     // Uusario logueado queda en session
     YuppSession::set('_twitter_user', $user);
     $user->save();
     // TODO: check 4 errors
     // TODO: se deberia llevar log de la IP+userid+fecha
     // Se podria hacer un archivo de log en disco por cada user id y poner fechas con ips nomas
     return self::LOGIN_ERR_SUCCESS;
 }