/**
* Check by triggering error if process
*
* Validation callback.
*
* @param Validation $validation Object for validation
* @param string $field Field name
* @return void
*
* @uses Module::event
*/
public function process_alias(Validation $validation, $field)
{
// always set unique alias if its set
$alias = $this->_unique_slug(trim($this->alias));
// make sure only one alias exists for home page <front>
if ($this->alias === Path::FRONT_ALIAS) {
$alias = Path::FRONT_ALIAS;
}
$this->type = empty($this->type) ? NULL : $this->type;
// allow other modules to interact with alias
Module::event('path_aliases', $this);
$source = trim($this->source, '/');
$this->lang = empty($this->lang) ? $this->_language_none : $this->lang;
if ($params = $this->_process_uri($source)) {
if (isset($params['directory'])) {
$this->route_directory = $params['directory'];
}
if (isset($params['controller'])) {
$this->route_controller = $params['controller'];
}
if (isset($params['action'])) {
$this->route_action = $params['action'];
}
if (isset($params['id'])) {
$this->route_id = $params['id'];
}
if (isset($params['route'])) {
$this->route_name = $params['route'];
}
$this->alias = $alias;
} elseif (!isset($params['controller']) or !isset($params) or empty($params['controller']) or empty($params)) {
$validation->error($field, 'invalid_source', array($validation[$field]));
}
}
/**
* Delete all objects in the associated table
*
* This does NOT destroy relationships that have been created with other objects.
*
* @return ORM
* @uses Module::event
* @throws Gleez_Exception
*/
public function delete_all()
{
if ($this->_loaded) {
throw new Gleez_Exception('Cannot delete all :model model because it is loaded.', array(':model' => $this->_object_name));
}
Module::event($this->_object_name . '_pre_delete_all', $this);
$this->_build(ORM::DELETE);
$this->_db_builder->execute($this->_db);
Module::event($this->_object_name . '_delete_all', $this);
return $this->clear();
}
/**
* Make sure the user has permission to do the action on this object
*
* Similar to [Comment::access] but this return TRUE/FALSE instead of exception
*
* @param string $action The action `view|edit|delete` default `view`
* @param ORM $comment The comment object
* @param Model_User $user The user object to check permission, defaults to loaded in user
* @param string $misc The misc element usually `id|slug` for logging purpose
*
* @return boolean
*
* @throws HTTP_Exception_404
*
* @uses User::active_user
* @uses Module::event
*/
public static function comment($action = 'view', ORM $comment, Model_User $user = NULL, $misc = NULL)
{
if (!in_array($action, array('view', 'edit', 'delete', 'add', 'list'), TRUE)) {
// If the $action was not one of the supported ones, we return access denied.
Log::notice('Unauthorized attempt to access non-existent action :act.', array(':act' => $action));
return FALSE;
}
if (!$comment->loaded()) {
// If the $action was not one of the supported ones, we return access denied.
throw HTTP_Exception::factory(404, 'Attempt to access non-existent comment.');
}
// If no user object is supplied, the access check is for the current user.
if (is_null($user)) {
$user = User::active_user();
}
if (self::check('bypass comment access', $user)) {
return TRUE;
}
// Allow other modules to interact with access
Module::event('comment_access', $action, $comment);
if ($action === 'view') {
if ($comment->status === 'publish' and self::check('access comment', $user)) {
return TRUE;
} elseif ($comment->status != 'publish' and $comment->author == (int) $user->id and $user->id != 1) {
return TRUE;
} elseif (self::check('administer comment', $user)) {
return TRUE;
} else {
return FALSE;
}
}
if ($action === 'edit') {
if (self::check('edit own comment') and $comment->author == (int) $user->id and $user->id != 1) {
return TRUE;
} elseif (self::check('administer comment', $user)) {
return TRUE;
} else {
return FALSE;
}
}
if ($action === 'delete') {
if ((self::check('delete own comment') or self::check('delete any comment')) and $comment->author == (int) $user->id and $user->id != 1) {
return TRUE;
} elseif (self::check('administer comment', $user)) {
return TRUE;
} else {
return FALSE;
}
}
return TRUE;
}
/**
* Static method to return menu object based on its unique name
*
* @param string $name The name of the menu
* @return object Menu
*/
public static function items($name)
{
$cache = Cache::instance('menus');
if (!($items = $cache->get($name))) {
$_menu = ORM::factory('menu')->where('name', '=', (string) $name)->find()->as_array();
if (!$_menu) {
return;
}
$ritems = ORM::factory('menu')->where('lft', '>', $_menu['lft'])->where('rgt', '<', $_menu['rgt'])->where('scp', '=', $_menu['scp'])->where('active', '=', 1)->order_by('lft', 'ASC')->find_all();
$items = array();
foreach ($ritems as $item) {
$items[] = $item->as_array();
}
if (empty($items)) {
return;
}
// set the cache for performance in production
if (Kohana::$environment === Kohana::PRODUCTION) {
$cache->set($name, $items, DATE::DAY);
}
}
//Initiate Menu Object
$menu = static::factory();
// start with an empty $right stack
$stack = array();
foreach ($items as &$item) {
// check if we should remove a node from the stack
while (count($stack) > 0 and $stack[count($stack) - 1]['rgt'] < $item['rgt']) {
array_pop($stack);
}
if (count($stack) > 0) {
$menu->add($item['name'], $item['title'], $item['url'], $item['descp'], $item['params'], $item['image'], $stack[count($stack) - 1]['name']);
} else {
$menu->add($item['name'], $item['title'], $item['url'], $item['descp'], $item['params'], $item['image']);
}
$stack[] =& $item;
}
// unset the stack array to freeup memory
unset($stack);
// Enable developers to override menu
Module::event('menus_items', $menu);
Module::event("menus_items_{$name}", $menu);
return $menu;
}
/**
* Run all the enabled filters on a piece of text.
*
* Note: Because filters can inject JavaScript or execute PHP code, security is
* vital here. When a user supplies a text format, you should validate it using
* filter_access() before accepting/using it. This is normally done in the
* validation stage of the Form API. You should for example never make a preview
* of content in a disallowed format.
*
* @param string $text The text to be filtered
* @param integer $format_id The format id of the text to be filtered. If no format is assigned, the fallback format will be used [Optional]
* @param string $langcode The language code of the text to be filtered, e.g. 'en' for English. This allows filters to be language aware so language specific text replacement can be implemented [Optional]
* @param boolean $cache Boolean whether to cache the filtered output in the {cache_filter} table. The caller may set this to FALSE when the output is already cached elsewhere to avoid duplicate cache lookups and storage [Optional]
*
* @return mixed
*
* @uses Config::load
* @uses Config_Group::get
* @uses Cache::get
* @uses Cache::set
* @uses Module::event
* @uses Filter::process
*
* @todo Make @params description shorter
*/
public static function markup($text, $format_id = NULL, $langcode = NULL, $cache = FALSE)
{
// Save some cpu cycles if text is empty or null
if (empty($text)) {
return $text;
}
$format_id = is_null($format_id) ? Config::get('inputfilter.default_format', 1) : $format_id;
$langcode = is_null($langcode) ? I18n::$lang : $langcode;
// Check for a cached version of this piece of text.
$cache_id = $format_id . ':' . $langcode . ':' . hash('sha256', $text);
if ($cache and $cached = Cache::instance('cache_filter')->get($cache_id)) {
return $cached;
}
// Convert all Windows and Mac newlines to a single newline, so filters
// only need to deal with one possibility.
$text = str_replace(array("\r\n", "\r"), "\n", $text);
$textObj = new ArrayObject(array('text' => (string) $text, 'format' => (int) $format_id, 'langcode' => (string) $langcode, 'cache' => (bool) $cache, 'cache_id' => (string) $cache_id), ArrayObject::ARRAY_AS_PROPS);
Module::event('inputfilter', $textObj);
$text = is_string($textObj->text) ? $textObj->text : $text;
$text = Filter::process($textObj);
// run all filters
// Store in cache with a minimum expiration time of 1 day.
if ($cache) {
Cache::instance('cache_filter')->set($cache_id, $text, null, time() + Date::DAY);
}
return $text;
}
/**
* If debugging is enabled, append profiler stats for non-production environments.
*
* @return void
*/
public function after()
{
if ($this->auto_render && $this->bare == FALSE) {
// Controller name as the default page id if none set
empty($this->_page_id) and $this->_page_id = $this->request->controller();
// Load left and right sidebars if available
$this->_set_sidebars();
// Set appropriate column css class
$this->_set_column_class();
// Do some CSS magic to page class
$classes = array(I18n::$lang, $this->request->controller(), $this->request->action(), $this->request->controller() . '-' . $this->request->action(), $this->template->column_class, $this->_page_class, $this->_auth->logged_in() ? 'logged-in' : 'not-logged-in');
// Special check for frontpage and frontpage title
if ($this->is_frontpage()) {
// Set front variable true for themers
$this->template->front = TRUE;
// Don't show title on homepage
$this->template->title = FALSE;
// Don't show title on homepage
$this->title = FALSE;
$this->template->mission = __($this->_config->get('site_mission', ''));
}
View::set_global(array('is_front' => $this->template->front, 'is_admin' => $this->template->_admin));
$classes[] = $this->template->_admin ? 'backend' : 'frontend';
$classes[] = $this->template->front ? 'front' : 'not-front';
$page_class = implode(' ', array_unique(array_map('trim', $classes)));
// Construct Head Section Page title
$this->_set_head_title();
// Allow module and theme developers to override
Module::event('template', $this);
// Set primary menu
$primary_menu = Menu::links('main-menu', array('class' => 'menus nav navbar-nav'));
// Bind the generic page variables
$this->template->set('lang', I18n::$lang)->set('page_id', $this->_page_id)->set('page_class', $page_class)->set('primary_menu', $primary_menu)->set('title', $this->title)->set('subtitle', $this->subtitle)->set('icon', $this->icon)->set('schemaType', $this->schemaType)->set('mission', $this->template->mission)->set('content', $this->response->body())->set('messages', Message::display())->set('profiler', FALSE);
if (count($this->_tabs) > 0) {
$this->template->tabs = View::factory('tabs')->set('tabs', $this->_tabs);
}
if (count($this->_subtabs) > 0) {
$this->template->subtabs = View::factory('tabs')->set('tabs', $this->_subtabs);
}
if (count($this->_actions) > 0) {
$this->template->actions = View::factory('actions')->set('actions', $this->_actions);
}
// And profiler if debug is true
if (Kohana::$environment !== Kohana::PRODUCTION and $this->debug) {
$this->template->profiler = View::factory('profiler/stats');
}
// And finally the profiler stats
$this->_set_profiler_stats();
// Assign the template as the request response and render it
$this->response->body($this->template);
} elseif ($this->_ajax && $this->bare == FALSE) {
$output = $this->response->body();
$this->process_ajax();
if ($this->_response_format === 'application/json') {
// Check for dataTables request
if ($this->request->query('draw') !== NULL) {
return;
}
$output = $this->_json['Data'];
}
$this->response->body($output);
} elseif ($this->_internal && $this->bare == FALSE) {
$output = $this->response->body();
$this->response->body($output);
}
if ($this->bare == FALSE) {
if (isset($this->_benchmark)) {
// Stop the benchmark
Profiler::stop($this->_benchmark);
}
// Set header content-type to response format with utf-8
$this->response->headers('Content-Type', $this->_response_format . '; charset=' . Kohana::$charset);
}
parent::after();
}
/**
* Validates login information from an array, and optionally redirects
* after a successful login.
*
* @param array $array Values to check
* @param boolean|string $redirect URI or URL to redirect to
*
* @throws Validation_Exception
*
* @return Model_User
*
* @uses Log::error
* @uses Module::event
* @uses Request::initial
* @uses Request::redirect
*/
public function login(array $array, $redirect = FALSE)
{
$labels = $this->labels();
$rules = $this->rules();
$array = Validation::factory($array);
// important to check isset to avoid unnecessary routing
if (isset($array['name'])) {
$login_name = $this->unique_key($array['name']);
// be sure remove the name/email_available rule during login
if (isset($rules[$login_name][4])) {
unset($rules[$login_name][4]);
}
$array->rules('name', $rules[$login_name]);
$array->label('name', $labels[$login_name]);
$array->label('password', $labels['pass']);
$array->rules('password', $rules['pass']);
}
// Get the remember login option
$remember = isset($array['remember']);
Module::event('user_login_validate', $array);
if ($array->check()) {
// Attempt to load the user
$this->where($login_name, '=', $array['name'])->find();
if ($this->loaded() and $this->status != 1) {
$array->error('name', 'blocked');
Module::event('user_blocked', $array);
Log::error('User: :name account blocked.', array(':name' => $array['name']));
throw new Validation_Exception($array, 'Account Blocked');
} elseif ($this->loaded() and Auth::instance()->login($this, $array['password'], $remember)) {
// Redirect after a successful login
if (is_string($redirect)) {
Request::initial()->redirect($redirect);
}
return $this;
} else {
$array->error('name', 'invalid');
Module::event('user_auth_failed', $array);
Log::error('User: :name failed login.', array(':name' => $array['name']));
throw new Validation_Exception($array, 'Validation has failed for login');
}
} else {
Log::error('User Login error.');
throw new Validation_Exception($array, 'Validation has failed for login');
}
}
/**
* Make sure the user has permission to do the action on this object
*
* Similar to Comment::access but this return True/False instead of exception
*
* @param bool|string $action The action view|edit|delete default view
* @param Model_User $user The user object to check permission, defaults to logged in user
* @param string $misc The misc element usually id|slug for logging purpose
*
* @throws HTTP_Exception_404
*
* @return boolean|Model_Comment
*
* @uses Log::add
* @uses User::active_user
* @uses ACL::check
* @uses Module::event
*/
public function user_can($action = FALSE, Model_User $user = NULL, $misc = NULL)
{
if (!$action) {
$action = 'view';
}
if (!in_array($action, array('view', 'edit', 'delete', 'add', 'list'), TRUE)) {
// If the $action was not one of the supported ones, we return access denied.
Log::notice('Unauthorised attempt to access non-existent action :act.', array(':act' => $action));
return FALSE;
}
if (!$this->loaded()) {
// If the $action was not one of the supported ones, we return access denied.
throw HTTP_Exception::factory(404, 'Attempt to access non-existent comment.');
}
// If no user object is supplied, the access check is for the current user.
if (empty($user)) {
$user = User::active_user();
}
if (ACL::check('bypass comment access', $user)) {
return TRUE;
}
//allow other modules to interact with access
Module::event('comment_access', $action, $this);
// can view?
if ($action === 'view') {
if ($this->status === 'publish' and ACL::check('access comment', $user)) {
return $this;
} elseif ($this->status != 'publish' and $this->author == (int) $user->id and $user->id != 1) {
return $this;
} elseif (ACL::check('administer comment', $user)) {
return $this;
} else {
Log::notice('Unauthorised attempt to view comment :post.', array(':post' => $this->id));
return FALSE;
}
}
// can edit?
if ($action === 'edit') {
if (ACL::check('edit own comment') and $this->author == (int) $user->id and $user->id != 1) {
return $this;
} elseif (ACL::check('administer comment', $user)) {
return $this;
} else {
Log::notice('Unauthorised attempt to edit comment :post.', array(':post' => $this->id));
return FALSE;
}
}
// can delete?
if ($action === 'delete') {
if ((ACL::check('delete own comment') or ACL::check('delete any comment')) and $this->author == (int) $user->id and $user->id != 1) {
return $this;
} elseif (ACL::check('administer comment', $user)) {
return $this;
} else {
Log::notice('Unauthorised attempt to delete comment :post.', array(':post' => $this->id));
return FALSE;
}
}
return TRUE;
}
/**
* Returns the named widget
*
* @param string $name Name of the widget
* @param boolean $visible Visibility permission from widget or FALSE to skip
* @param boolean $region The name of the region ex:left, right or FALSE for all regions
* @param boolean $format The format of the output ex:xhtml, html or FALSE for object
*
* @return object Widget widget
* @return string HTML widget
*/
public function get_widget($name, $visible = FALSE, $region = FALSE, $format = FALSE)
{
$response = FALSE;
if (!($widget = $this->get($name))) {
return $response;
}
$visible == TRUE ? $this->is_visible($widget) : $widget->visible == TRUE;
// Enable developers to override widget
Module::event('Widget', $widget);
Module::event('Widget_' . ucfirst($name), $widget);
if ($widget->status and $widget->visible) {
try {
$widget->content = Widget::factory($name, $widget, $widget->config)->render();
$response = $format === FALSE ? $widget : trim($this->_html($widget, $this->_region, $this->_format));
} catch (Exception $e) {
Log::error('Error processing widget ":name": :msg', array(':name' => $name, ':msg' => $e->getMessage()));
}
}
return $response;
}
/**
* Do save
*
* @uses Arr::get
* @uses Module::available
* @uses Module::is_active
* @uses Module::deactivate
* @uses Module::is_installed
* @uses Module::upgrade
* @uses Module::install
* @uses Module::activate
* @uses Module::event
* @uses Cache::delete_all
* @uses Log::add
* @uses Gleez_Exception::text
*/
private function _do_save()
{
$changes = new stdClass();
$changes->activate = array();
$changes->deactivate = array();
$activated_names = array();
$deactivated_names = array();
foreach (Module::available() as $module_name => $info) {
if ($info->locked) {
continue;
}
try {
$desired = Arr::get($_POST, $module_name) == 1;
if ($info->active and !$desired and Module::is_active($module_name)) {
Module::deactivate($module_name);
$changes->deactivate[] = $module_name;
$deactivated_names[] = __($info->name);
} elseif (!$info->active and $desired and !Module::is_active($module_name)) {
if (Module::is_installed($module_name)) {
Module::upgrade($module_name);
} else {
Module::install($module_name);
}
Module::activate($module_name);
$changes->activate[] = $module_name;
$activated_names[] = __($info->name);
}
} catch (Exception $e) {
Log::error(Gleez_Exception::text($e));
}
}
Module::event('module_change', $changes);
// @todo This type of collation is questionable from an i18n perspective
if ($activated_names) {
Message::success(__('Activated: %names', array('%names' => join(", ", $activated_names))));
}
if ($deactivated_names) {
Message::success(__('Deactivated: %names', array('%names' => join(", ", $deactivated_names))));
}
// Clear any cache for sure
Cache::instance()->delete_all();
}
/**
* Delete all objects in the associated table
*
* This does NOT destroy relationships that have been created with other objects.
*
* @param boolean $soft Make delete as soft or hard. Default hard
* @return ORM
* @uses Module::event
* @throws Gleez_Exception
*/
public function delete_all($soft = FALSE)
{
if ($this->_loaded) {
throw new Gleez_Exception('Cannot delete all :model model because it is loaded.', array(':model' => $this->_object_name));
}
Module::event($this->_object_name . '_pre_delete_all', $this, $soft);
if (is_array($this->_deleted_column) && $soft == TRUE) {
} else {
$this->_build(ORM::DELETE);
$this->_db_builder->execute($this->_db);
}
Module::event($this->_object_name . '_delete_all', $this, $soft);
return $this->clear();
}
/**
* Process actions
*/
public function action_process()
{
$route = Route::get('admin/comment')->uri(array('action' => 'list'));
$redirect = empty($this->redirect) ? $route : $this->redirect;
$post = $this->request->post();
// If deletion is not desired, redirect to list
if (isset($post['no']) and $this->valid_post()) {
$this->request->redirect($redirect);
}
// If deletion is confirmed
if (isset($post['yes']) and $this->valid_post()) {
$comments = array_filter($post['items']);
ORM::factory('comment')->where('id', 'IN', $comments)->delete_all();
Module::event('comment_bulk_delete', $comments);
Message::success(__('The delete has been performed!'));
$this->request->redirect($redirect);
}
if ($this->valid_post('comment-bulk-actions')) {
if (!isset($post['comments']) or (!is_array($post['comments']) or !count(array_filter($post['comments'])))) {
$this->_errors = array(__('No items selected.'));
$this->request->redirect($redirect);
}
try {
if ($post['operation'] == 'delete') {
// Filter out unchecked comments
$comments = array_filter($post['comments']);
$this->title = __('Delete Comments');
$items = DB::select('id', 'title')->from('comments')->where('id', 'IN', $comments)->execute()->as_array('id', 'title');
$view = View::factory('form/confirm_multi')->set('action', '')->set('items', $items);
$this->response->body($view);
return;
}
$this->_bulk_update($post);
Message::success(__('The update has been performed!'));
$this->request->redirect($redirect);
} catch (Exception $e) {
Message::error(__('The update has not been performed!'));
}
}
}
