/**
* Handles the request to execute a task.
*
* Responsible for parsing the tasks to execute & also any config items that
* should be passed to the tasks
*/
public function action_execute()
{
if (empty($this->_task)) {
return $this->action_help();
}
$task = $this->_retrieve_task();
$defaults = $task->get_config_options();
if (!empty($defaults)) {
if (Arr::is_assoc($defaults)) {
$options = array_keys($defaults);
$options = call_user_func_array(array('CLI', 'options'), $options);
$config = Arr::merge($defaults, $options);
} else {
// Old behavior
$config = call_user_func_array(array('CLI', 'options'), $defaults);
}
} else {
$config = array();
}
// Validate $config
$validation = Validation::factory($config);
$validation = $task->build_validation($validation);
if (!$validation->check()) {
echo View::factory('minion/error/validation')->set('errors', $validation->errors($task->get_errors_file()));
} else {
// Finally, run the task
echo $task->execute($config);
}
}
public function get(Model $from, array $conditions = array())
{
// Create the query on the model_through
$query = call_user_func(array($this->model_to, 'query'));
// set the model_from's keys as where conditions for the model_through
$join = array('table' => array($this->table_through, 't0_through'), 'join_type' => null, 'join_on' => array(), 'columns' => $this->select_through('t0_through'));
reset($this->key_from);
foreach ($this->key_through_from as $key) {
if ($from->{current($this->key_from)} === null) {
return array();
}
$query->where('t0_through.' . $key, $from->{current($this->key_from)});
next($this->key_from);
}
reset($this->key_to);
foreach ($this->key_through_to as $key) {
$join['join_on'][] = array('t0_through.' . $key, '=', 't0.' . current($this->key_to));
next($this->key_to);
}
$conditions = \Arr::merge($this->conditions, $conditions);
foreach (\Arr::get($conditions, 'where', array()) as $key => $condition) {
is_array($condition) or $condition = array($key, '=', $condition);
$query->where($condition);
}
foreach (\Arr::get($conditions, 'order_by', array()) as $field => $direction) {
if (is_numeric($field)) {
$query->order_by($direction);
} else {
$query->order_by($field, $direction);
}
}
$query->_join($join);
return $query->get();
}
public function get(Model $from, array $conditions = array())
{
$query = call_user_func(array($this->model_to, 'query'));
reset($this->key_to);
foreach ($this->key_from as $key) {
// no point running a query when a key value is null
if ($from->{$key} === null) {
return array();
}
$query->where(current($this->key_to), $from->{$key});
next($this->key_to);
}
$conditions = \Arr::merge($this->conditions, $conditions);
foreach (\Arr::get($conditions, 'where', array()) as $key => $condition) {
is_array($condition) or $condition = array($key, '=', $condition);
$query->where($condition);
}
foreach (\Arr::get($conditions, 'order_by', array()) as $field => $direction) {
if (is_numeric($field)) {
$query->order_by($direction);
} else {
$query->order_by($field, $direction);
}
}
return $query->get();
}
protected function resolve($item, $property)
{
$items = array();
$arrowPos = strpos($property, '->');
if ($arrowPos !== false) {
$propertyMatch = mb_substr($property, 0, $arrowPos);
} else {
$propertyMatch = $property;
}
$match = $item->{$propertyMatch};
if (empty($match)) {
return array();
}
if ($arrowPos !== false) {
if (is_array($match)) {
foreach ($match as $matched) {
$items = \Arr::merge($items, $this->resolve($matched, mb_substr($property, $arrowPos + 2)));
}
} else {
$items = \Arr::merge($items, $this->resolve($match, mb_substr($property, $arrowPos + 2)));
}
} else {
if (is_array($match)) {
$items = \Arr::merge($items, $match);
} else {
$items[] = $match;
}
}
return $items;
}
/**
* Return the query builder for this model
*
* @return \Api\Rest_Query
*/
protected function getQuery($params = array())
{
if (!$this->query) {
$this->query = new Rest_Query($this->model, $this->plural, 'data', \Arr::merge($this->params, $params), $this->field);
}
return $this->query;
}
/**
* @param array $data
* @param null $id
*/
public function __construct($data = array(), $id = NULL)
{
$klass = get_called_class();
$meta = $klass::meta();
$this->_options = Arr::merge($this->_options, Arr::get($meta, "options"));
$this->__fields = Arr::get($meta, "fields");
$this->__2m_fields = Arr::get($meta, "2m_fields", array());
if ($this->__instance === NULL) {
$this->__instance = Arr::get($this->_options, "model");
}
$this->__relations = $this->__load_relations();
if ($data instanceof ORM) {
$data = $data->as_array();
}
$columns = Arr::get($this->_options, "model")->list_columns();
if ($id !== NULL) {
$this->__instance = Arr::get($this->_options, "model")->where(Arr::get($this->_options, "model")->primary_key(), "=", $id)->find();
$iterated = array();
foreach ($this->__instance->as_array() as $key => $value) {
$iterated[$key] = $value;
}
$data = Arr::merge($iterated, $data);
}
foreach ($columns as $column) {
$name = $column["column_name"];
$field = $this->__create_field($name, $column, $data);
$field->theme(Arr::get($this->_options, "theme"));
if (in_array($name, Arr::get($this->_options, "display_fields")) || empty($this->_options["display_fields"])) {
if (!in_array($name, Arr::get($this->_options, "except_fields"))) {
$this->add_field($field);
}
}
}
$this->__load_2m($data);
}
public function action_index()
{
$username = $this->request->param('username');
$this->view = new View_Message_Create();
$this->view->username = $username;
if ($this->request->method() == HTTP_Request::POST) {
try {
$post = $this->request->post();
$receiver = ORM::factory('User')->where('username', '=', $post['receiver'])->find();
if (!$receiver->loaded()) {
return Hint::error('Cannot find a user with the username: '******'You cannot send a message to yourself!');
}
$message_data = Arr::merge($this->request->post(), array('sender_id' => $this->user->id, 'receiver_id' => $receiver->id));
$message = ORM::factory('Message')->create_message($message_data, array('receiver_id', 'subject', 'content', 'sender_id'));
$message_data_sent = Arr::merge($this->request->post(), array('receiver_id' => $this->user->id, 'sender_id' => $receiver->id, 'sent' => 1, 'read' => 1));
ORM::factory('Message')->create_message($message_data_sent, array('receiver_id', 'subject', 'content', 'sender_id', 'sent', 'read'));
Hint::success('You have sent a message');
$this->redirect(Route::get('message.inbox')->uri());
} catch (ORM_Validation_Exception $e) {
Hint::error($e->errors('models'));
}
}
}
public function load($group)
{
if (!count($this->_sources)) {
throw new JsonApiApplication_Exception("No configuration sources attached");
}
if (empty($group)) {
throw new JsonApiApplication_Exception("Need to specify a config group");
}
if (!is_string($group)) {
throw new JsonApiApplication_Exception("Config group must be a string");
}
if (strpos($group, ".") !== FALSE) {
list($group, $path) = explode(".", $group, 2);
}
if (isset($this->_groups[$group])) {
if (isset($path)) {
return Arr::path($this->_groups[$group], $path, NULL, ".");
}
return $this->_groups[$group];
}
$config = array();
$sources = array_reverse($this->_sources);
foreach ($sources as $source) {
if ($source instanceof JsonApiApplication_Config_Reader) {
if ($source_config = $source->load($group)) {
$config = Arr::merge($config, $source_config);
}
}
}
$this->_groups[$group] = new JsonApiApplication_Config_Group($this, $group, $config);
if (isset($path)) {
return Arr::path($config, $path, NULL, ".");
}
return $this->_groups[$group];
}
/**
* Create a feed from the given parameters
*
* @param array $info Feed information
* @param array $items Items to add to the feed
* @param string $encoding Define which encoding to use [Optional]
*
* @return string
*
* @throws Feed_Exception
*
* @uses Arr::merge
* @uses URL::is_absolute
* @uses URL::site
*/
public function create(array $info, array $items, $encoding = NULL)
{
$generator = array('title' => Feed::NAME, 'link' => '', 'generator' => Feed::getGenerator());
$info = Arr::merge($generator, $info);
$feed = $this->prepareXML($encoding);
foreach ($info as $name => $value) {
if ($name === 'image') {
// Create an image element
$image = $feed->channel->addChild('image');
if (!isset($value['link'], $value['url'], $value['title'])) {
throw new Feed_Exception('Feed images require a link, url, and title');
}
if (URL::is_absolute($value['url'])) {
// Convert URIs to URLs
$value['url'] = URL::site($value['url'], TRUE);
}
// Create the image elements
$image->addChild('link', $value['link']);
$image->addChild('url', $value['url']);
$image->addChild('title', $value['title']);
} else {
if (($name === 'pubDate' or $name === 'lastBuildDate') and (is_int($value) or ctype_digit($value))) {
// Convert timestamps to RFC 822 formatted dates
$value = date('r', $value);
} elseif (($name === 'link' or $name === 'docs') and URL::is_absolute($value)) {
// Convert URIs to URLs
$value = URL::site($value, TRUE);
}
// Add the info to the channel
$feed->channel->addChild($name, $value);
}
}
foreach ($items as $item) {
// Add the item to the channel
$row = $feed->channel->addChild('item');
foreach ($item as $name => $value) {
if ($name === 'pubDate' and (is_int($value) or ctype_digit($value))) {
// Convert timestamps to RFC 822 formatted dates
$value = date('r', $value);
} elseif (($name === 'link' or $name === 'guid') and URL::is_absolute($value)) {
// Convert URIs to URLs
$value = URL::site($value, TRUE);
}
// Add the info to the row
$row->addChild($name, $value);
}
}
if (function_exists('dom_import_simplexml')) {
// Convert the feed object to a DOM object
$feed = dom_import_simplexml($feed)->ownerDocument;
// DOM generates more readable XML
$feed->formatOutput = TRUE;
// Export the document as XML
$feed = $feed->saveXML();
} else {
// Export the document as XML
$feed = $feed->asXML();
}
return $feed;
}
/**
* Verify the access token.
*
* @param array an associative array of auth settings
* @return OAuthToken
* @link http://digg.com/api/docs/1.0/detail/oauth.verify
*/
public function verify_access_token()
{
// Configure the auth settings
$auth_config = array();
if ($this->is_valid_token(NULL, TRUE)) {
$token = $this->_token;
$auth_config = array('token_key' => $token->key, 'token_secret' => $token->secret);
}
$auth_config = Arr::merge($this->_auth_config, $auth_config);
// Configure the HTTP method, URL, and request parameters
$http_method = MMI_HTTP::METHOD_POST;
$url = $this->_api_url;
$parms = array('method' => 'oauth.verify');
// Verify the request token
$verified = 0;
$response = $this->_auth_request($auth_config, $http_method, $url, $parms);
if ($response instanceof MMI_Curl_Response) {
$http_status_code = $response->http_status_code();
if (intval($http_status_code) === 200) {
$data = $this->_decode_xml($response->body(), TRUE);
if (is_array($data)) {
$verified = intval(Arr::path($data, '@attributes.verified', 0));
}
}
}
unset($response);
return $verified === 1;
}
/**
* Create an OpAuth instance
*
* @param array any call-time configuration to be used
* @param bool whether or not Opauth should run automatically
*/
public static function forge($config = array(), $autorun = true)
{
// deal with passing only the autorun value
if (func_num_args() == 1 and is_bool($config)) {
$autorun = $config;
$config = array();
}
// merge the default config with the runtime config
$config = \Arr::merge(\Config::get('opauth'), $config);
// define the transport system we use
$config['callback_transport'] = 'get';
// make sure we have a remotes table
if (!isset($config['table']) and ($config['table'] = static::$provider_table) === null) {
throw new \OpauthException('No providers table configured. At the moment, only SimpleAuth and OrmAuth can be auto-detected.');
}
// and a security salt
if (empty($config['security_salt'])) {
throw new \OpauthException('There is no "security_salt" defined in the opauth.php configuration file.');
}
// set some defaults, just in case
isset($config['security_iteration']) or $config['security_iteration'] = 300;
isset($config['security_timeout']) or $config['security_timeout'] = '2 minutes';
if (empty($config['path'])) {
$parsed_url = parse_url(\Uri::base() . \Request::main()->uri->get());
$path = explode('/', trim($parsed_url['path'], '/'));
// construct the path if needed
// $path = \Request::main()->uri->get_segments();
$params = count(\Request::active()->route->method_params);
while ($params-- > 0) {
array_pop($path);
}
$config['path'] = '/' . implode('/', $path) . '/';
}
// and construct the callback URL if needed
if (empty($config['callback_url'])) {
// pop the method name from the path
$path = explode('/', trim($config['path'], '/'));
array_pop($path);
// and add 'callback' as the controller callback action
$config['callback_url'] = '/' . implode('/', $path) . '/callback/';
}
// determine the name of the provider we want to call
if (!$autorun) {
// we're processing a callback
$config['provider'] = 'Callback';
} else {
if (empty($config['provider'])) {
$parsed_url = parse_url(\Uri::base() . \Request::main()->uri->get());
$provider = explode('/', substr($parsed_url['path'], strlen($config['path'])));
$config['provider'] = ucfirst($provider[0]);
}
// check if we have a strategy defined for this provider
$strategies = \Config::get('opauth.Strategy', array());
if (!array_key_exists(strtolower($config['provider']), array_change_key_case($strategies))) {
throw new \OpauthException('Opauth strategy "' . $config['provider'] . '" is not supported');
}
}
// return the created Auth_Opauth object
return new static($config, $autorun);
}
protected function __construct()
{
$this->_installer = new Installer();
$default = $this->_installer->default_params();
$this->_options = Arr::merge($this->_options, $default);
parent::__construct();
}
public function __construct($options)
{
if (!isset($options["choices"])) {
throw new Kohana_Exception("You should define a list of a choices into a factory for Choice field");
}
$this->_options = Arr::merge($this->_options, $options);
}
public function get_options()
{
$uid = $this->param('uid', NULL, TRUE);
$options = ORM::factory('email_type', (int) $uid)->data();
$options = Arr::merge($options, Config::get('email', 'default_template_data', array()));
$this->response($options);
}
/**
* Get a request token.
*
* @throws Kohana_Exception
* @param string the callback URL
* @param array an associative array of auth settings
* @return OAuthToken
*/
public function get_request_token($oauth_callback = NULL, $auth_config = array())
{
// Configure the auth settings
if (!is_array($auth_config)) {
$auth_config = array();
}
$auth_config = Arr::merge($this->_auth_config, $auth_config);
// Configure the HTTP method and the URL
$http_method = $this->_request_token_http_method;
$url = $this->_request_token_url;
$this->_ensure_parm('Request token URL', $url);
// Configure the auth scope parameter
$scope = Arr::get($auth_config, 'scope');
$this->_ensure_parm('Authorization scope', $scope);
$parms['scope'] = $scope;
// Configure the OAuth callback URL
if (!isset($oauth_callback)) {
$oauth_callback = $this->auth_callback_url();
}
if (!empty($oauth_callback)) {
$parms['oauth_callback'] = $oauth_callback;
}
// Make the request and extract the token
$response = $this->_auth_request($auth_config, $http_method, $url, $parms);
$token = NULL;
if ($this->_validate_curl_response($response, 'Invalid request token')) {
$token = $this->_extract_token($response);
}
return $token;
}
/**
*
* @param string $name
*/
public function __construct($name = '')
{
$this->_name = $name;
if ($file = $this->find_file()) {
$this->_path = pathinfo($file, PATHINFO_DIRNAME);
$this->_file = $file;
$this->name = pathinfo($file, PATHINFO_FILENAME);
} else {
$this->_path = pathinfo($this->name, PATHINFO_DIRNAME);
if (empty($this->_path) or $this->_path == '.') {
$this->_path = DOCROOT . $this->_folder;
$this->_file = $this->_path . DIRECTORY_SEPARATOR . $this->name;
} else {
$this->_file = $this->name;
}
$this->name = pathinfo($this->name, PATHINFO_FILENAME);
}
if (strpos($this->_file, EXT) === FALSE) {
$this->_file .= EXT;
}
$settings = FileSystem::load_merged_array($this->_folder, '.settings');
if (isset($settings[$this->name]) and is_array($settings[$this->name])) {
$this->_settings = Arr::merge($this->_settings, $settings[$this->name]);
}
if ($this->is_exists() and !Auth::has_permissions($this->get_roles())) {
$this->set_read_only();
}
}
/**
* Supplier driver forge.
*
* @param string $supplier Supplier id or friendly name
* @param array $config Config array
* @return Supplier instance
*/
public static function forge($supplier, $config = array())
{
$model = Model_Supplier::query();
if (is_int($supplier)) {
$model = $model->where('id', $supplier)->get_one();
} elseif (is_string($supplier)) {
$model = $model->where('slug', $supplier)->get_one();
} elseif ($supplier instanceof Model_Supplier) {
$model = $supplier;
} else {
throw new SupplierException('Invalid Supplier!');
}
if (!$model instanceof Model_Supplier) {
throw new SupplierException('Supplier ' . $supplier . ' not found');
}
if (\Arr::get($config, 'filter_disabled', false) === true and $model->enabled !== 1) {
throw new SupplierException('This supplier (' . $model->name . ') has been disabled.');
}
if (isset($model->driver) and empty($model->driver)) {
throw new SupplierException('This supplier (' . $model->name . ') has no driver to be used.');
}
$driver = ucfirst(strtolower(isset($model->driver) ? $model->driver : $model->slug));
$class = 'Indigo\\Erp\\Stock\\Supplier_' . $driver;
if (!class_exists($class, true)) {
throw new \FuelException('Could not find Supplier driver: ' . $driver);
}
$config = \Arr::merge(static::$_defaults, \Config::get('supplier.drivers.' . strtolower($driver), array()), $config);
$driver = new $class($model, $config);
return $driver;
}
/**
* Setting the display of pages
*
* @uses Arr::merge
* @uses Config::load
* @uses Message::success
*/
public function action_settings()
{
$this->title = __('Page Settings');
$post = Config::load('page');
$action = Route::get('admin/page')->uri(array('action' => 'settings'));
$vocabs = array(__('none'));
$view = View::factory('admin/page/settings')->set('vocabs', $vocabs)->set('post', $post)->set('action', $action);
$vocabs = Arr::merge($vocabs, ORM::factory('term')->where('lft', '=', 1)->where('type', '=', 'page')->find_all()->as_array('id', 'name'));
if ($this->valid_post('page_settings')) {
unset($_POST['page_settings'], $_POST['_token'], $_POST['_action']);
$cats = $post->get('category', array());
foreach ($_POST as $key => $value) {
if ($key == 'category') {
$terms = array_diff($cats, $value);
if ($terms) {
DB::delete('posts_terms')->where('parent_id', 'IN', array_values($terms))->execute();
}
}
$post->set($key, $value);
}
Log::info('Page Settings updated.');
Message::success(__('Page Settings updated!'));
$this->request->redirect(Route::get('admin/page')->uri(array('action' => 'settings')), 200);
}
$this->response->body($view);
}
/**
* Construct the form object
*
* @access public
* @param mixed $alias. (default: NULL)
* @param mixed $driver. (default: NULL)
* @return void
*/
public function __construct($alias = NULL, $driver = NULL, array $options = NULL)
{
// Setup options array
$options = func_get_args();
$options = Formo::args(__CLASS__, __FUNCTION__, $options);
// Load the config file
$this->set('config', Kohana::$config->load('formo'));
// Set the default alias and driver if necessary
(empty($options['alias']) AND $options['alias'] = $this->get('config')->form_alias);
(empty($options['driver']) AND $options['driver'] = $this->get('config')->form_driver);
(empty($options['kind']) AND $options['kind'] = $this->get('config')->kind);
// Always process the driver first
$driver = $options['driver'];
unset($options['driver']);
$options = Arr::merge(array('driver' => $driver), $options);
// Load the orm config file
if ($orm_file = Arr::get($this->get('config'), 'ORM') !== NULL)
{
$this->set('orm_config', $orm_file);
}
// Run validator setup
$this->_setup_validation();
// Load the options
$this->_load_options($options);
}
/**
* Load modules config
*
* @param $group
* @param $module
* @return mixed
* @throws Kohana_Exception
*/
public function load($group, $module)
{
if (empty($group) || empty($module)) {
throw new Twig_Exception("Need to specify a config group and module name");
}
if (!is_string($group) || !is_string($module)) {
throw new Twig_Exception("Config group and module name must be a string");
}
if (strpos($group, '.') !== FALSE) {
// Split the config group and path
list($group, $path) = explode('.', $group, 2);
}
if (isset($this->_config_groups[$group])) {
if (isset($path)) {
return Arr::path($this->_config_groups[$group], $path, NULL, '.');
}
return $this->_config_groups[$group];
}
$config = array();
$file = $this->_get_config_file($group, $module);
if (is_file($file)) {
$config = Arr::merge($config, Kohana::load($file));
}
$this->_config_groups[$group] = new Config_Group(Kohana::$config, $group, $config);
if (isset($path)) {
return Arr::path($config, $path, NULL, '.');
}
return $this->_config_groups[$group];
}
/**
* @param array $array1 initial array
* @param array $array2,... array to merge
*
* @return array
*/
public static function merge($array1, $array2)
{
$result = [];
for ($i = 0; $i < func_num_args(); $i++) {
$result = parent::merge($result, static::asArray(func_get_arg($i)));
}
return $result;
}
protected function get_filter_type() {
$types = DB::select_array(array('type'))
->distinct(TRUE)
->from(Kohana::config('dblog.table'))
->execute()
->as_array('type', 'type');
return Arr::merge($types, array('' => __('any')));
}
protected function _get_options($element_name, array $options = NULL)
{
if (!empty($options)) {
return Arr::merge($this->get_config($element_name), $options);
} else {
return $this->get_config($element_name);
}
}
public function __construct($config = array())
{
// Append default auth configuration
$config = Arr::merge((array) Kohana::config('paypal'), $config);
// Save the config in the object
$this->config = $config;
$this->paypal_url = isset($config['url']) ? $config['url'] : 'https://www.paypal.com/cgi-bin/webscr';
}
public final function set_global($key, $value = NULL)
{
if (is_array($key) and Arr::is_assoc($key)) {
Kostache::$globals = Arr::merge(Kostache::$globals, $key);
} else {
Kostache::$globals[$key] = $value;
}
}
static function fetch($type)
{
$data = array();
foreach (self::$data as $values) {
$data = Arr::merge($data, $values[$type]);
}
return implode("\r\n", array_unique($data));
}
/**
* set config
*
* @param string | array $key config's key or an array, if array is provided , ignore the 2nd param
* @param string $val config value
*/
public function set_config($key, $val = NULL)
{
if (is_string($key)) {
$this->_config[$key] = $val;
} elseif (is_array($key)) {
$this->_config = Arr::merge($this->_config, $key);
}
}
public static function select_theme()
{
foreach (self::$routes as $key => $route) {
if (in_array($key, self::$route_search)) {
self::$selected_theme = Arr::merge(self::$selected_theme, $route);
}
}
}
/**
* Loads the config file(s).
*
* @param bool $overwrite Whether to overwrite existing values
* @return array the config array
*/
public function load($overwrite = false, $cache = true)
{
$paths = $this->find_file($cache);
$config = array();
foreach ($paths as $path) {
$config = $overwrite ? array_merge($config, $this->load_file($path)) : \Arr::merge($config, $this->load_file($path));
}
return $config;
}
/**
* {@inheritdoc}
*/
public function register()
{
// \Fuel\Agent\Agent
$this->container->add('agent', function (array $config = [], $method = 'browscap') {
$configInstance = $this->container->get('configInstance');
$config = \Arr::merge($configInstance->load('agent', true), $config);
return new Agent($config, $method);
});
}
