<?php //$Id$
//Copyright (c) 2012-2016 Pierre Pronchery <khorben@defora.org>
//This file is part of DeforaOS Web DaPortal
//
//This program is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, version 3 of the License.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program.  If not, see <http://www.gnu.org/licenses/>.


//Content
class Content
{
	//public
	//methods
	//essential
	//Content::Content
	public function __construct(Engine $engine, Module $module,
			$properties = FALSE)
	{
		$credentials = $engine->getCredentials();
		$database = $engine->getDatabase();

		$this->stock = $module->getName();
		$this->module = $module;
		$this->user_id = $credentials->getUserID();
		$this->username = $credentials->getUsername();
		$this->group_id = $credentials->getGroupID();
		$this->group = $credentials->getGroupname();
		//properties
		if($properties === FALSE)
			$properties = array();
		foreach($properties as $k => $v)
			switch($k)
			{
				//private
				case 'enabled':
				case 'public':
					//boolean values
					$v = $database->isTrue($v);
					//fallback
				case 'content':
				case 'group_id':
				case 'group':
				case 'id':
				case 'title':
				case 'user_id':
				case 'username':
					$this->$k = $v;
					break;
				case 'timestamp':
					$v = $database->formatDate($v);
					$this->$k = $v;
					break;
				case 'groupname':
					//XXX for compatibility
					$this->group = $v;
					break;
				//protected
				default:
					$this->set($k, $v);
					break;
			}
		//translations
		$this->text_content_by = _('Content by');
		$this->text_link = _('Permalink');
		$this->text_more_content = _('More content...');
		$this->text_on = _('on');
		$this->text_open = _('Open');
		$this->text_publish = _('Publish');
		$this->text_submit_content = _('Submit content');
		$this->text_update = _('Update');
	}


	//accessors
	//Content::canAdmin
	public function canAdmin(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		$credentials = $engine->getCredentials();

		$error = _('Permission denied');
		if(!$credentials->isAdmin())
			return FALSE;
		return $this->canUpdate($engine, $request, $error);
	}


	//Content::canDelete
	public function canDelete(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		return $this->canAdmin($engine, $request, $error);
	}


	//Content::canDisable
	public function canDisable(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		return $this->canAdmin($engine, $request, $error);
	}


	//Content::canDisplay
	public function canDisplay(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		return TRUE;
	}


	//Content::canEnable
	public function canEnable(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		return $this->canAdmin($engine, $request, $error);
	}


	//Content::canPreview
	public function canPreview(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		return $this->canDisplay($engine, $request, $error);
	}


	//Content::canPublish
	public function canPublish(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		if($request === NULL)
			return TRUE;
		if($request->isIdempotent())
		{
			$error = _('The request expired or is invalid');
			return FALSE;
		}
		return TRUE;
	}


	//Content::canSubmit
	public function canSubmit(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		$credentials = $engine->getCredentials();
		$properties = $this->properties;

		if($request === NULL)
			return TRUE;
		if($request->isIdempotent())
		{
			$error = _('The request expired or is invalid');
			return FALSE;
		}
		//verify that the fields are set
		$fields = array();
		foreach($this->fields as $k => $v)
			switch($k)
			{
				case 'enabled':
				case 'public':
				case 'content':
				case 'group_id':
				case 'group':
				case 'id':
				case 'timestamp':
				case 'title':
				case 'user_id':
				case 'username':
					break;
				default:
					if(array_key_exists($k, $properties))
						break;
					else if($request->get($k) === FALSE)
						$fields[] = $v;
					break;
			}
		if(count($fields) > 0)
		{
			$error = implode($fields, _(' must be set')."\n")
				._(' must be set');
			return FALSE;
		}
		return TRUE;
	}


	//Content::canUnpublish
	public function canUnpublish(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		if($request === NULL)
			return TRUE;
		if($request->isIdempotent())
		{
			$error = _('The request expired or is invalid');
			return FALSE;
		}
		return TRUE;
	}


	//Content::canUpdate
	public function canUpdate(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		$credentials = $engine->getCredentials();

		if(!$credentials->isAdmin())
		{
			$error = _('Only administrators can update content');
			return FALSE;
		}
		if($request === NULL)
			return TRUE;
		if($request->isIdempotent())
		{
			$error = _('The request expired or is invalid');
			return FALSE;
		}
		return TRUE;
	}


	//Content::canUpdateTimestamp
	public function canUpdateTimestamp(Engine $engine,
			Request $request = NULL, &$error = FALSE)
	{
		$credentials = $engine->getCredentials();

		if(!$credentials->isAdmin())
		{
			$error = _('Only administrators can update timestamps');
			return FALSE;
		}
		if($request === NULL)
			return TRUE;
		if($request->isIdempotent())
		{
			$error = _('The request expired or is invalid');
			return FALSE;
		}
		return TRUE;
	}


	//Content::get
	public function get($property)
	{
		if(!array_key_exists($property, $this->properties))
			return FALSE;
		return $this->properties[$property];
	}


	//Content::getColumns
	static public function getColumns()
	{
		return array('icon' => '', 'title' => _('Title'),
			'username' => _('Username'), 'date' => _('Date'));
	}


	//Content::getContent
	public function getContent(Engine $engine)
	{
		if($this->content === FALSE)
			return '';
		return $this->content;
	}


	//Content::getDate
	public function getDate($format = FALSE)
	{
		$informat = FALSE;

		if(($timestamp = $this->timestamp) === FALSE)
		{
			$informat = '%Y-%m-%d %H:%M:%S';
			$timestamp = Date::formatTimestamp(time(), $informat);
		}
		return Date::format($timestamp, $format, $informat);
	}


	//Content::getGroup
	public function getGroup()
	{
		return $this->group;
	}


	//Content::getGroupID
	public function getGroupID()
	{
		return $this->group_id;
	}


	//Content::getID
	public function getID()
	{
		return $this->id;
	}


	//Content::getModule
	public function getModule()
	{
		return $this->module;
	}


	//Content::getOrder
	static public function getOrder(Engine $engine, $order = FALSE)
	{
		switch($order)
		{
			case 'timestamp':
				return 'timestamp DESC';
			default:
				return static::$list_order;
		}
	}


	//Content::getProperties
	public function getProperties()
	{
		return $this->properties;
	}


	//Content::getRequest
	public function getRequest($action = FALSE, $parameters = FALSE)
	{
		return new Request($this->module->getName(), $action,
			$this->getID(), $this->getTitle(), $parameters);
	}


	//Content::getTitle
	public function getTitle()
	{
		return $this->title;
	}


	//Content::getUser
	public function getUser(Engine $engine)
	{
		//XXX may fail
		return new User($engine, $this->user_id, $this->username);
	}


	//Content::getUserID
	public function getUserID()
	{
		return $this->user_id;
	}


	//Content::getUsername
	public function getUsername()
	{
		return $this->username;
	}


	//Content::isEnabled
	public function isEnabled()
	{
		return $this->enabled;
	}


	//Content::isPublic
	public function isPublic()
	{
		return $this->public;
	}


	//Content::set
	public function set($property, $value)
	{
		if(!isset($this->fields[$property]))
			return FALSE;
		$this->properties[$property] = $value;
		return TRUE;
	}


	//Content::setContent
	public function setContent(Engine $engine, $content)
	{
		if($content === FALSE)
			$content = '';
		$this->content = $content;
	}


	//Content::setPublic
	public function setPublic($public)
	{
		$this->public = $public ? TRUE : FALSE;
	}


	//Content::setTitle
	public function setTitle($title)
	{
		$this->title = $title;
	}


	//useful
	//Content::delete
	public function delete(Engine $engine)
	{
		$database = $engine->getDatabase();
		$query = static::$query_delete;
		$args = array('content_id' => $this->id);

		if(!$this->canDelete($engine))
			return FALSE;
		return $database->query($engine, $query, $args);
	}


	//Content::disable
	public function disable(Engine $engine)
	{
		$database = $engine->getDatabase();
		$query = static::$query_disable;
		$args = array('content_id' => $this->id);

		if(!$this->canDisable($engine))
			return FALSE;
		return $database->query($engine, $query, $args);
	}


	//Content::enable
	public function enable(Engine $engine)
	{
		$database = $engine->getDatabase();
		$query = static::$query_enable;
		$args = array('content_id' => $this->id);

		if(!$this->canEnable($engine))
			return FALSE;
		return $database->query($engine, $query, $args);
	}


	//Content::display
	public function display(Engine $engine, Request $request = NULL)
	{
		$type = ($request !== NULL) ? $request->get('display') : FALSE;
		$vbox = new PageElement('vbox');

		if($type === FALSE || $type == 'title')
			$vbox->append($this->displayTitle($engine, $request));
		if($type === FALSE || $type == 'toolbar')
			$vbox->append($this->displayToolbar($engine, $request));
		if($type === FALSE || $type == 'metadata')
			$vbox->append($this->displayMetadata($engine,
					$request));
		if($type === FALSE || $type == 'content'
				|| strncmp($type, 'content::', 9) == 0)
			$vbox->append($this->displayContent($engine, $request));
		if($type === FALSE || $type == 'buttons')
			$vbox->append($this->displayButtons($engine, $request));
		return $vbox;
	}


	//Content::displayButtons
	public function displayButtons(Engine $engine, Request $request)
	{
		$hbox = new PageElement('hbox');
		$r = $this->module->getRequest();
		$hbox->append('link', array('stock' => $this->stock_back,
				'request' => $r,
				'text' => $this->text_more_content));
		$r = $this->getRequest();
		$hbox->append('link', array('request' => $r,
				'stock' => $this->stock_link,
				'text' => $this->text_link));
		return $hbox;
	}


	//Content::displayContent
	public function displayContent(Engine $engine, Request $request)
	{
		$text = $this->getContent($engine);

		return new PageElement('label', array('text' => $text));
	}


	//Content::displayList
	static public function displayList(Engine $engine,
			Request $request = NULL, $content = FALSE,
			$limit = FALSE, $offset = 0)
	{
		$view = new PageElement('treeview', array(
				'columns' => static::getColumns(),
				'alternate' => static::$list_alternate));

		if($content === FALSE)
			$content = new ArrayIterator();
		else if(is_array($content))
			$content = new ArrayIterator($content);
		if($limit === FALSE && ($limit = static::$list_limit) === FALSE)
			$limit = $content->count();
		for($i = 0, $content->seek($offset);
			$i < $limit && $content->valid();
			$i++, $content->next())
		{
			$c = $content->current();
			$view->append($c->displayRow($engine, $request));
		}
		return $view;
	}


	//Content::displayMetadata
	public function displayMetadata(Engine $engine, Request $request = NULL)
	{
		$r = new Request('user', FALSE, $this->getUserID(),
			$this->getUsername());

		$meta = new PageElement('label', array(
				'text' => $this->text_content_by.' '));
		$link = $meta->append('link', array('request' => $r,
				'text' => $this->getUsername()));
		$date = $this->getDate();
		$meta->append('label', array(
				'text' => ' '.$this->text_on.' '.$date));
		return $meta;
	}


	//Content::displayRow
	public function displayRow(Engine $engine, Request $request = NULL)
	{
		$r = array();
		$no = new PageElement('image', array('stock' => 'no',
			'size' => 16, 'title' => _('Disabled')));
		$yes = new PageElement('image', array('stock' => 'yes',
			'size' => 16, 'title' => _('Enabled')));

		//title
		$rq = $this->getRequest();
		$link = new PageElement('link', array('request' => $rq,
			'text' => $this->getTitle()));
		$r['title'] = $link;
		$r['enabled'] = $this->isEnabled() ? $yes : $no;
		$r['public'] = $this->isPublic() ? $yes : $no;
		//username
		$rq = new Request('user', FALSE, $this->getUserID(),
			$this->getUsername());
		$link = new PageElement('link', array('request' => $rq,
			'stock' => 'user', 'text' => $this->getUsername()));
		$r['username'] = $link;
		//date
		$r['date'] = $this->getDate();
		//id
		$r['id'] = 'ids['.$this->getID().']';
		return new PageElement('row', $r);
	}


	//Content::displayToolbar
	public function displayToolbar(Engine $engine, Request $request = NULL)
	{
		$credentials = $engine->getCredentials();
		$action = ($request !== NULL) ? $request->getAction() : FALSE;

		$toolbar = new PageElement('toolbar');
		if($credentials->isAdmin())
		{
			$r = $this->module->getRequest('admin');
			$toolbar->append('button', array('request' => $r,
					'stock' => 'admin',
					'text' => _('Administration')));
		}
		if($action != 'submit' && $this->module->canSubmit($engine,
				NULL, $this))
		{
			$r = $this->module->getRequest('submit');
			$toolbar->append('button', array('request' => $r,
					'stock' => $this->stock_submit,
					'text' => $this->text_submit_content));
		}
		if($this->getID() !== FALSE)
		{
			if($action != 'publish' && !$this->isPublic()
					&& $this->canPublish($engine, NULL,
						$this))
			{
				$r = $this->getRequest('publish');
				$toolbar->append('button', array(
						'request' => $r,
						'stock' => 'publish',
						'text' => $this->text_publish));
			}
			if($action != 'update' && $this->canUpdate($engine,
					NULL, $this))
			{
				$r = $this->getRequest('update');
				$toolbar->append('button', array(
						'request' => $r,
						'stock' => 'update',
						'text' => $this->text_update));
			}
		}
		//FIXME implement
		return $toolbar;
	}


	//Content::displayTitle
	public function displayTitle(Engine $engine, Request $request)
	{
		return new PageElement('title', array(
			'stock' => $this->stock,
			'text' => $this->getTitle()));
	}


	//Content::form
	public function form(Engine $engine, Request $request)
	{
		return ($this->id !== FALSE)
			? $this->_formUpdate($engine, $request)
			: $this->_formSubmit($engine, $request);
	}

	protected function _formSubmit(Engine $engine, Request $request)
	{
		$vbox = new PageElement('vbox');
		$vbox->append('entry', array('name' => 'title',
				'text' => _('Title: '),
				'placeholder' => _('Title'),
				'value' => $request->get('title')));
		$vbox->append('textview', array('name' => 'content',
				'text' => _('Content: '),
				'value' => $request->get('content')));
		return $vbox;
	}

	protected function _formUpdate(Engine $engine, Request $request)
	{
		$vbox = new PageElement('vbox');
		if(($value = $request->get('title')) === FALSE)
			$value = $this->getTitle();
		$vbox->append('entry', array('name' => 'title',
				'text' => _('Title: '),
				'placeholder' => _('Title'),
				'value' => $value));
		$label = $vbox->append('label', array(
				'text' => _('Content: ')));
		if(($value = $request->get('content')) === FALSE)
			$value = $this->getContent($engine);
		$label->append('textview', array('name' => 'content',
				'value' => $value));
		return $vbox;
	}


	//Content::formPreview
	public function formPreview(Engine $engine, Request $request)
	{
		$properties = $this->properties;

		$content = clone $this;
		foreach($this->fields as $k => $v)
		{
			if(($p = $request->get($k)) === FALSE)
				continue;
			switch($k)
			{
				case 'content':
					$content->setContent($engine, $p);
					break;
				case 'title':
					$content->setTitle($p);
					break;
				default:
					$content->set($k, $p);
					break;
			}
		}
		$vbox = new PageElement('vbox');
		$vbox->append('title', array('stock' => 'preview',
				'text' => _('Preview: ').$content->getTitle()));
		$vbox->append($content->displayMetadata($engine, $request));
		$vbox->append($content->displayContent($engine, $request));
		return $vbox;
	}


	//Content::preview
	public function preview(Engine $engine, Request $request = NULL)
	{
		$vbox = new PageElement('vbox');

		$vbox->append($this->previewTitle($engine, $request));
		$vbox->append($this->previewMetadata($engine, $request));
		$vbox->append($this->previewContent($engine, $request));
		$vbox->append($this->previewButtons($engine, $request));
		return $vbox;
	}


	//Content::previewButtons
	public function previewButtons(Engine $engine, Request $request = NULL)
	{
		$hbox = new PageElement('hbox');

		$r = $this->getRequest();
		$hbox->append('button', array('request' => $r,
				'stock' => $this->stock_open,
				'text' => $this->text_open));
		return $hbox;
	}


	//Content::previewContent
	public function previewContent(Engine $engine, Request $request = NULL)
	{
		$content = $this->getContent($engine);
		$length = $this->preview_length;
		$text = ($length <= 0 || strlen($content) < $length)
			? $content : substr($content, 0, $length).'...';

		return new PageElement('label', array('text' => $text));
	}


	//Content::previewMetadata
	public function previewMetadata(Engine $engine, Request $request = NULL)
	{
		return $this->displayMetadata($engine, $request);
	}


	//Content::previewTitle
	public function previewTitle(Engine $engine, Request $request = NULL)
	{
		if($this->id === FALSE)
			return new PageElement('title', array(
					'text' => $this->getTitle()));
		$title = new PageElement('title');
		$title->append('link', array(
				'request' => $this->getRequest(),
				'text' => $this->getTitle()));
		return $title;
	}


	//Content::save
	public function save(Engine $engine, Request $request = NULL,
			&$error = FALSE)
	{
		$ret = ($this->id !== FALSE)
			? $this->_saveUpdate($engine, $request, $error)
			: $this->_saveInsert($engine, $request, $error);
		if($ret === FALSE || $request === NULL)
			return $ret;
		//reflect the new properties
		foreach($this->fields as $f)
			$this->set($f, $request->get($f));
		return $ret;
	}

	protected function _saveInsert(Engine $engine, Request $request = NULL,
			&$error)
	{
		$database = $engine->getDatabase();
		$query = static::$query_insert;
		$args = array('module_id' => $this->module->getID(),
			'user_id' => $this->user_id,
			'enabled' => $this->enabled,
			'public' => $this->public);

		if(!$this->canSubmit($engine, $request, $error))
			return FALSE;
		foreach($this->fields as $k => $v)
			switch($k)
			{
				case 'title':
				case 'content':
					$args[$k] = ($this->$k !== FALSE)
						? $this->$k : '';
					break;
			}
		//set the timestamp if necessary
		if($request !== NULL
				&& ($timestamp = $request->get('timestamp'))
				!== FALSE
				&& $this->canUpdateTimestamp($engine, $request))
		{
			$query = static::$query_insert_timestamp;
			$args['timestamp'] = $timestamp;
		}
		//insert the content
		$error = _('Could not insert the content');
		if($database->query($engine, $query, $args) === FALSE)
			return FALSE;
		return ($this->id = $database->getLastID($engine,
				'daportal_content', 'content_id')) !== FALSE
			? TRUE : FALSE;
	}

	protected function _saveUpdate(Engine $engine, Request $request = NULL,
			&$error)
	{
		$database = $engine->getDatabase();
		$query = static::$query_update;
		$args = array('module_id' => $this->module->getID(),
			'content_id' => $this->id,
			'enabled' => $this->enabled,
			'public' => $this->public);

		if(!$this->canUpdate($engine, $request, $error))
			return FALSE;
		foreach($this->fields as $k => $v)
			switch($k)
			{
				case 'title':
				case 'content':
					$args[$k] = ($this->$k !== FALSE)
						? $this->$k : '';
					if($request === NULL)
						break;
					if(($v = $request->get($k)) === FALSE)
						break;
					$args[$k] = $v;
					break;
			}
		//set the timestamp if necessary
		if($request !== NULL
				&& ($timestamp = $request->get('timestamp'))
				!== FALSE
				&& $this->canUpdateTimestamp($engine, $request))
		{
			$query = static::$query_update_timestamp;
			$args['timestamp'] = $timestamp;
		}
		//update the content
		$error = _('Could not update the content');
		//FIXME detect errors!@#$%
		if(($ret = $database->query($engine, $query, $args)) === FALSE)
			return FALSE;
		foreach($args as $k => $v)
			switch($k)
			{
				case 'title':
				case 'content':
					$this->$k = $v;
					break;
			}
		return TRUE;
	}


	//public static
	//Content::countAll
	static public function countAll(Engine $engine, Module $module,
			$user = FALSE)
	{
		if(($res = static::_listAll($engine, $module, FALSE, FALSE,
				FALSE, $user)) === FALSE)
			return FALSE;
		return $res->count();
	}


	//Content::listAll
	static public function listAll(Engine $engine, Module $module,
			$order = FALSE, $limit = FALSE, $offset = FALSE,
			$user = FALSE)
	{
		if(($res = static::_listAll($engine, $module, $order, $limit,
				$offset, $user)) === FALSE)
			return FALSE;
		return static::listFromResults($engine, $module, $res);
	}

	static protected function _listAll(Engine $engine, Module $module,
			$order, $limit, $offset, $user)
	{
		$credentials = $engine->getCredentials();
		$database = $engine->getDatabase();
		$query = static::$query_list;
		$args = array('module_id' => $module->getID());

		if($user instanceof User)
		{
			$query = static::$query_list_user;
			$args['user_id'] = $user->getUserID();
			if(($id = $credentials->getUserID()) != 0
					&& $id == $user->getUserID())
				$query = static::$query_list_user_private;
		}
		else if($user instanceof Group)
		{
			$query = static::$query_list_group;
			$args['group_id'] = $user->getGroupID();
		}
		return static::query($engine, $query, $args, $order, $limit,
				$offset);
	}


	//Content::listFromResults
	static public function listFromResults(Engine $engine, Module $module,
			$results)
	{
		return new ContentResult($engine, $module, static::$class,
			$results);
	}


	//Content::load
	static public function load(Engine $engine, Module $module, $id,
			$title = FALSE)
	{
		if(($res = static::_load($engine, $module, $id, $title))
				=== FALSE)
			return FALSE;
		return static::loadFromProperties($engine, $module, $res);
	}

	static protected function _load(Engine $engine, Module $module, $id,
			$title)
	{
		$credentials = $engine->getCredentials();
		$database = $engine->getDatabase();
		$query = static::$query_load;
		$column = static::$load_title;
		$args = array('module_id' => $module->getID(),
			'user_id' => $credentials->getUserID(),
			'content_id' => $id);
		$from = array('-', '\\');
		$to = array('_', '\\\\');

		if($engine instanceof HTTPFriendlyEngine)
		{
			//XXX friendly links may compress slashes
			$from[] = '/';
			$to[] = '%';
		}
		if(is_string($title))
		{
			$query .= ' AND '.$column.' '.$database->like(FALSE)
				.' :title ESCAPE :escape';
			$args['title'] = str_replace($from, $to, $title);
			//require 32 correct characters in the title
			if(strlen($title) >= 32)
				$args['title'] .= '%';
			$args['escape'] = '\\';
		}
		if(($res = $database->query($engine, $query, $args)) === FALSE
				|| $res->count() != 1)
			return FALSE;
		return $res->current();
	}


	//Content::loadFromProperties
	static public function loadFromProperties(Engine $engine,
			Module $module, $properties)
	{
		$class = static::$class;

		return new $class($engine, $module, $properties);
	}


	//Content::loadFromResult
	static public function loadFromResult(Engine $engine, Module $module,
			DatabaseResult $result)
	{
		$class = static::$class;

		return new $class($engine, $module, $result->current());
	}


	//protected
	//properties
	static protected $class = 'Content';
	protected $fields = array('title' => 'Title', 'content' => 'Content');
	static protected $list_alternate = FALSE;
	static protected $list_limit = 20;
	static protected $list_order = 'timestamp DESC';
	static protected $load_title = 'title';
	protected $preview_length = 150;
	//stock icons
	protected $stock = FALSE;
	protected $stock_back = 'back';
	protected $stock_link = 'link';
	protected $stock_open = 'open';
	protected $stock_submit = 'new';
	//strings
	static protected $text_content = 'Content';
	protected $text_content_by = 'Content by';
	protected $text_link = 'Permalink';
	protected $text_more_content = 'More content...';
	protected $text_on = 'on';
	protected $text_open = 'Open';
	protected $text_publish = 'Publish';
	protected $text_submit_content = 'Submit content';
	protected $text_update = 'Update';
	//queries
	//IN:	module_id
	//	content_id
	static protected $query_delete = 'DELETE FROM daportal_content
		WHERE module_id=:module_id AND content_id=:content_id';
	//IN:	module_id
	//	content_id
	static protected $query_disable = "UPDATE daportal_content
		SET enabled='0'
		WHERE module_id=:module_id AND content_id=:content_id";
	//IN:	module_id
	//	content_id
	static protected $query_enable = "UPDATE daportal_content
		SET enabled='1'
		WHERE module_id=:module_id AND content_id=:content_id";
	//IN:	module_id
	//	user_id
	//	title
	//	content
	//	enabled
	//	public
	static protected $query_insert = 'INSERT INTO daportal_content
		(module_id, user_id, title, content, enabled, public)
		VALUES (:module_id, :user_id, :title, :content, :enabled,
			:public)';
	//IN:	module_id
	//	user_id
	//	title
	//	content
	//	enabled
	//	public
	//	timestamp
	static protected $query_insert_timestamp = 'INSERT INTO daportal_content
		(module_id, user_id, title, content, enabled, public, timestamp)
		VALUES (:module_id, :user_id, :title, :content, :enabled,
			:public, :timestamp)';
	//IN:	module_id
	static protected $query_list = 'SELECT content_id AS id, timestamp,
		module_id, module, user_id, username, group_id, groupname,
		title, content, enabled, public
		FROM daportal_content_public
		WHERE module_id=:module_id';
	//IN:	module_id
	//	group_id
	static protected $query_list_group = 'SELECT content_id AS id,
		timestamp, module_id, module,
		daportal_content_public.user_id AS user_id, username,
		daportal_content_public.group_id AS group_id,
		daportal_content_public.groupname AS groupname, title, content,
		daportal_content_public.enabled AS enabled, public
		FROM daportal_content_public, daportal_user_group,
		daportal_group_enabled
		WHERE module_id=:module_id
		AND daportal_content_public.user_id=daportal_user_group.user_id
		AND daportal_user_group.group_id=daportal_group_enabled.group_id
		AND (daportal_user_group.group_id=:group_id
		OR daportal_content_public.group_id=:group_id)';
	//IN:	module_id
	//	user_id
	static protected $query_list_user = 'SELECT content_id AS id, timestamp,
		module_id, module, user_id, username, group_id, groupname,
		title, content, enabled, public
		FROM daportal_content_public
		WHERE module_id=:module_id
		AND user_id=:user_id';
	//IN:	module_id
	//	user_id
	static protected $query_list_user_private = 'SELECT content_id AS id,
		timestamp,
		module_id, module, user_id, username, group_id, groupname,
		title, content, enabled, public
		FROM daportal_content_enabled
		WHERE module_id=:module_id
		AND user_id=:user_id';
	//FIXME default to $query_list.' AND ...' ?
	//IN:	module_id
	//	user_id
	//	content_id
	static protected $query_load = "SELECT content_id AS id, timestamp,
		module_id, module, user_id, username, group_id, groupname,
		title, content, enabled, public
		FROM daportal_content_enabled
		WHERE module_id=:module_id
		AND (public='1' OR user_id=:user_id)
		AND content_id=:content_id";
	//IN:	module_id
	//	content_id
	//	title
	//	content
	//	enabled
	//	public
	static protected $query_update = 'UPDATE daportal_content
		SET title=:title, content=:content, enabled=:enabled,
		public=:public
		WHERE module_id=:module_id
		AND content_id=:content_id';
	//IN:	module_id
	//	content_id
	//	title
	//	content
	//	enabled
	//	public
	//	timestamp
	static protected $query_update_timestamp = 'UPDATE daportal_content
		SET title=:title, content=:content, enabled=:enabled,
		public=:public, timestamp=:timestamp
		WHERE module_id=:module_id
		AND content_id=:content_id';


	//methods
	//accessors
	//Content::configGet
	protected function configGet($variable)
	{
		global $config;
		$name = $this->getModule()->getName();

		return $config->get('module::'.$name, $variable);
	}


	//Content::setID
	protected function setID($id)
	{
		$this->id = $id;
	}


	//useful
	//Content::query
	static protected function query(Engine $engine, $query, $args = FALSE,
			$order = FALSE, $limit = FALSE, $offset = FALSE)
	{
		$database = $engine->getDatabase();

		if(($order = static::getOrder($engine, $order)) !== FALSE)
			$query .= ' ORDER BY '.$order;
		$query .= $database->limit($limit, $offset);
		return $database->query($engine, $query, $args);
	}


	//private
	//properties
	private $id = FALSE;
	private $timestamp = FALSE;
	private $module;
	private $user_id;
	private $username;
	private $group_id;
	private $group;
	private $title = FALSE;
	private $content = FALSE;
	private $enabled = TRUE;
	private $public = FALSE;
	private $properties = array();
}

?>