/**
  * @return \Illuminate\Database\Eloquent\Builder
  */
 public static function withoutOrders()
 {
     $instance = new static();
     $query = $instance->newQuery();
     $query->getQuery()->orders = [];
     return $query;
 }

 /**
  * Retrieves all Hail Api Object of a specific type
  *
  * @return void
  */
 public static function fetch()
 {
     try {
         $list = HailApi::getList(static::getObjectType());
     } catch (HailApiException $ex) {
         Debug::warningHandler(E_WARNING, $ex->getMessage(), $ex->getFile(), $ex->getLine(), $ex->getTrace());
         die($ex->getMessage());
         return;
     }
     $hailIdList = array();
     foreach ($list as $hailData) {
         // Check if we can find an existing item.
         $hailObj = static::get()->filter(array('HailID' => $hailData->id))->First();
         if (!$hailObj) {
             $hailObj = new static();
         }
         $result = $hailObj->importHailData($hailData);
         if ($result) {
             //Build up Hail ID list
             $hailIdList[] = $hailData->id;
         }
     }
     //Remove all object for which we don't have reference
     static::get()->exclude('HailID', $hailIdList)->removeAll();
 }

 /**
  * @param $key
  * @param $value
  *
  * @return static
  */
 public static function build($key, $value)
 {
     $EnvironmentVariable = new static();
     $EnvironmentVariable->setKey($key);
     $EnvironmentVariable->setValue($value);
     return $EnvironmentVariable;
 }

 /**
  * Creates collection of items.
  *
  * Override it if you need to implement
  * derived collection that requires specific initialization.
  *
  * @param array $items
  *
  * @return static
  */
 protected function createCollection(array $items)
 {
     $collection = new static();
     $itemsRef =& $collection->items();
     $itemsRef = $items;
     return $collection;
 }

 /**
  * Get instance 
  *
  * @return static
  */
 public static function getInstance()
 {
     if (!static::$instance instanceof static) {
         static::$instance = new static();
     }
     return static::$instance->getConnection();
 }

 /**
  * 
  * @param type $array
  * @param type $throw
  * @return \storm\actions\IntentPayload
  */
 public static function simpleInvoke($array = [], $throw = true)
 {
     $action = new static();
     $payload = new IntentPayload($array);
     $action->invoke($payload, $throw);
     return $payload;
 }

 /**
  * Remove any instance of the facet from the parameters and add a new one.
  *
  * @param string $field    Facet field
  * @param string $value    Facet value
  * @param string $operator Facet type to add (AND, OR, NOT)
  *
  * @return string
  */
 public function replaceFacet($field, $value, $operator = 'AND')
 {
     $newParams = clone $this->params;
     $newParams->removeAllFilters($field);
     $helper = new static($newParams);
     return $helper->addFacet($field, $value, $operator);
 }

 /**
  * Handle dynamic static method calls into the method.
  *
  * @param  string $method
  * @param  array $parameters
  * @return mixed
  */
 public static function __callStatic($method, $parameters)
 {
     $instance = new static();
     $class = get_class($instance->getModel());
     $model = new $class();
     return call_user_func_array([$model, $method], $parameters);
 }

 public static function register($data)
 {
     static::$error = false;
     $user = new static();
     if (!$user->set($data)->success()) {
         static::$error = 'REGISTER_VALIDATION_FALSE';
         return false;
     }
     $login = isset($data[static::ROW_LOGIN]) ? $data[static::ROW_LOGIN] : '';
     if (!$login) {
         static::$error = 'REGISTER_NO_LOGIN';
         return false;
     }
     $found = static::findBy(static::ROW_LOGIN, $login)->getFirst();
     if ($found) {
         static::$error = 'REGISTER_DUBLICATE_USER';
         return false;
     }
     $password = isset($data[static::ROW_PASSWORD]) ? $data[static::ROW_PASSWORD] : '';
     if (!$password) {
         static::$error = 'REGISTER_NO_PASSWORD';
         return false;
     }
     $user->{static::ROW_HASH_RESTORE} = static::makeHash();
     $user->save();
     return $user;
 }

 /**
  * Queries the table for the given primary key value ($id).  $id can also
  * contain 2 special values:
  *
  * <ul>
  * <li>'all' - Will return all of the records in the table</li>
  * <li>'first' - Will return the first record.  This will set automatically
  * set the 'limit' option to 1.</li>
  * </ul>
  *
  * The following options are available to use in the $options parameter:
  *
  * <ul>
  * <li>include - an array of associations to include in the query.  Example:
  * <code>array('group', 'posts')</code></li>
  * <li>select - an array of columns to select (defaults to '*').  Example:
  * <code>array('first_name', 'last_name')</code></li>
  * <li>limit - the maximum number of records to fetch</li>
  * <li>offset - the offset to start from</li>
  * <li>order - an array containing the ORDER BY clause.  Example:
  * <code>array('last_name', 'ASC')</code></li>
  * <li>where - an array of arrays containing the where clauses.  Example:
  * <code>array(array('enabled', '=', 1), array('blacklisted', '=', 0))</code>
  * <li>or_where - identical to 'where' except these are OR WHERE statements.</li>
  *
  * Usage:
  *
  * <code>$user = User::find(2, array('include' => array('group')));</code>
  *
  * @param	int|string	$id			the primary key value
  * @param	srray		$options	the find options
  * @return	object		the result
  */
 public static function find($id = 'all', $options = array())
 {
     $instance = new static();
     $results = $instance->run_find($id, $options);
     unset($instance);
     return $results;
 }

 /**
  * Creates token
  * @param string $type Type of the token
  * @param string $name Name of the token unique for selected type
  * @param callable|AlgorithmInterface $algorithm Algorithm of the token generation
  * @param int|\DateTime|Expression $expire Expiration date of the token
  * @return static
  */
 public static function create($type, $name, $algorithm = null, $expire = null)
 {
     if ($algorithm === null) {
         $algorithm = new RandomString();
     }
     $token = static::findOne(['type' => $type, 'name' => $name]);
     if ($token == null) {
         $token = new static();
     }
     $token->type = $type;
     $token->name = $name;
     if (is_callable($algorithm)) {
         $token->token = call_user_func($algorithm);
     } else {
         $token->token = $algorithm->generate();
     }
     if (is_integer($expire)) {
         $token->expire_at = \DateTime::createFromFormat('U', $expire, new \DateTimeZone('UTC'))->setTimezone(new \DateTimeZone('MSK'))->format('Y-m-d H:i:s');
     } elseif ($expire instanceof \DateTime) {
         $token->expire_at = $expire->format('Y-m-d h:i:s');
     } else {
         $token->expire_at = $expire;
     }
     $token->created_at = new Expression('NOW()');
     $token->save(false);
     return $token;
 }

 public function createQuestion(Model $questionable, $data, Model $author)
 {
     $question = new static();
     $question->fill(array_merge($data, ['author_id' => $author->id, 'author_type' => get_class($author)]));
     $questionable->questions()->save($question);
     return $question;
 }

 /**
  * Set an API statistic in the DB
  * 
  * @param int $code		The HTTP status code from the request or cache
  * @param string $uri	The dynamic call URL or the static call name
  * @param string $api	The API to set the stats for
  * 
  * @return bool True if the stat was added/updated successfully, or false if it wasn't.
  */
 public static function set_stat($code, $uri, $api = null, $is_static = null)
 {
     // Save queries if we don't need the stats.
     if (\Config::get('engine.track_usage_stats', false) === false) {
         return true;
     }
     $api_name = $api === null ? \V1\APIRequest::get('api') : $api;
     $is_static = $is_static === null ? \V1\APIRequest::is_static() : $is_static;
     $api = \V1\Model\APIs::get_api($api_name);
     // Do we have a stat entry for this timeframe?
     $existing_api_stats_obj = static::query()->where('apis_id', '=', $api['id'])->where('code', '=', (int) $code)->where('call', '=', $uri)->where('created_at', '>', time() - (int) \Config::get('api_stats_increment', 30) * 60)->get_one();
     // If we have a row, update it.
     if (!empty($existing_api_stats_obj)) {
         $existing_api_stats_obj->count++;
         return $existing_api_stats_obj->save();
     }
     // Add the new entry.
     $api_stats_object = new static();
     $api_stats_object->apis_id = $api['id'];
     $api_stats_object->code = $code;
     $api_stats_object->count = 1;
     $api_stats_object->call = $uri;
     $api_stats_object->is_static = intval($is_static);
     return $api_stats_object->save();
 }

 public static function isColumnNullable($column_name)
 {
     $instance = new static();
     // create an instance of the model to be able to get the table name
     $answer = DB::select(DB::raw("SELECT IS_NULLABLE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='" . $instance->getTable() . "' AND COLUMN_NAME='" . $column_name . "' AND table_schema='" . env('DB_DATABASE') . "'"))[0];
     return $answer->IS_NULLABLE == 'YES' ? true : false;
 }

 /**
  * Register the error handler.
  *
  * @param integer $level The level at which the conversion to Exception is done (null to use the error_reporting() value and 0 to disable)
  *
  * @return The registered error handler
  */
 public static function register($level = null)
 {
     $handler = new static();
     $handler->setLevel($level);
     set_error_handler(array($handler, 'handle'));
     return $handler;
 }

 /**
  * @param array $values
  * @return Folder
  */
 public static function create($values)
 {
     $object = new static();
     $object->setValues($values);
     $object->save();
     return $object;
 }

 /**
  * Populates headers from string representation
  *
  * Parses a string for headers, and aggregates them, in order, in the
  * current instance, primarily as strings until they are needed (they
  * will be lazy loaded)
  *
  * @param  string $string
  * @param  string $EOL EOL string; defaults to {@link EOL}
  * @throws Exception\RuntimeException
  * @return Headers
  */
 public static function fromString($string, $EOL = self::EOL)
 {
     $headers = new static();
     $currentLine = '';
     // iterate the header lines, some might be continuations
     foreach (explode($EOL, $string) as $line) {
         // check if a header name is present
         if (preg_match('/^(?P<name>[\\x21-\\x39\\x3B-\\x7E]+):.*$/', $line, $matches)) {
             if ($currentLine) {
                 // a header name was present, then store the current complete line
                 $headers->addHeaderLine($currentLine);
             }
             $currentLine = trim($line);
         } elseif (preg_match('/^\\s+.*$/', $line, $matches)) {
             // continuation: append to current line
             $currentLine .= trim($line);
         } elseif (preg_match('/^\\s*$/', $line)) {
             // empty line indicates end of headers
             break;
         } else {
             // Line does not match header format!
             throw new Exception\RuntimeException(sprintf('Line "%s"does not match header format!', $line));
         }
     }
     if ($currentLine) {
         $headers->addHeaderLine($currentLine);
     }
     return $headers;
 }

 /**
  * Calculates total count of query records
  *
  * @param Query|SqlQuery $query
  * @param bool           $useWalker
  *
  * @return integer
  */
 public static function calculateCount($query, $useWalker = null)
 {
     /** @var QueryCountCalculator $instance */
     $instance = new static();
     $instance->setUseWalker($useWalker);
     return $instance->getCount($query);
 }

 public static function send($viewPath, $data, $callback)
 {
     $config = Bootstrap::get('config');
     $mailer = Bootstrap::get('mailer');
     if (!$mailer) {
         throw new InvalidArgumentException(__t('mail_configuration_no_defined'));
     }
     $DirectusSettingsTableGateway = new \Zend\Db\TableGateway\TableGateway('directus_settings', Bootstrap::get('zendDb'));
     $rowSet = $DirectusSettingsTableGateway->select();
     $settings = [];
     foreach ($rowSet as $setting) {
         $settings[$setting['collection']][$setting['name']] = $setting['value'];
     }
     $instance = new static($mailer, $settings);
     $message = Swift_Message::newInstance();
     // default mail from address
     $mailConfig = $config['mail'];
     $message->setFrom($mailConfig['from']);
     call_user_func($callback, $message);
     if ($message->getBody() == null) {
         // Slim Extras View twig act weird on this version
         $viewContent = $instance->getViewContent($viewPath, $data);
         $message->setBody($viewContent, 'text/html');
     }
     $instance->sendMessage($message);
 }

 public static function afterTopicInsert($tc)
 {
     $editor = new \app\lib\Editor(['editor' => Yii::$app->params['settings']['editor']]);
     $content = $editor->parse($tc->content);
     $pa = new PhpAnalysis();
     $pa->SetSource($tc->topic->title . strip_tags($content));
     $pa->resultType = 2;
     $pa->differMax = true;
     $pa->StartAnalysis();
     $tagNames = $pa->GetFinallyKeywords(3);
     $tagNames = explode(',', $tagNames);
     $tags = static::find()->select(['id', 'name'])->where(['in', 'name', $tagNames])->indexBy('name')->all();
     foreach ($tagNames as $tn) {
         if (!empty($tags) && !empty($tags[$tn])) {
             $tag = $tags[$tn];
             $tagTopic = new TagTopic(['tag_id' => $tag->id, 'topic_id' => $tc->topic_id]);
             $tagTopic->save(false);
             $tag->updateCounters(['topic_count' => 1]);
         } else {
             $tag = new static(['name' => $tn, 'topic_count' => 1]);
             $tag->save(false);
             $tagTopic = new TagTopic(['tag_id' => $tag->id, 'topic_id' => $tc->topic_id]);
             $tagTopic->save(false);
         }
     }
 }