/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our additional criterias
suxValidate::register_criteria('isDuplicateFeed', 'this->isDuplicateFeed');
suxValidate::register_criteria('isValidFeed', 'this->isValidFeed');
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('url', 'url', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('url2', 'url', 'isURL');
suxValidate::register_validator('url3', 'url', 'isDuplicateFeed');
suxValidate::register_validator('url4', 'url', 'isValidFeed');
}
// Urls
$this->r->text['form_url'] = suxFunct::makeUrl('/feeds/suggest');
$this->r->text['back_url'] = suxFunct::getPreviousURL();
$this->r->title .= " | {$this->r->gtext['suggest']}";
// Template
$this->tpl->display('suggest.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
suxValidate::register_validator('integrity', 'integrity:parent_id', 'hasIntegrity');
suxValidate::register_validator('title', 'title', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('body', 'body', 'notEmpty', false, false, 'trim');
}
// Additional variables
$this->r->text['form_url'] = suxFunct::makeUrl('/blog/reply/' . $this->parent['id']);
$this->r->text['back_url'] = suxFunct::getPreviousURL();
// Parent
$this->tpl->assign('parent_id', $this->parent['id']);
$this->tpl->assign('parent', "{$this->parent['title']} \n\n {$this->parent['body_plaintext']}");
$this->r->title .= " | {$this->r->gtext['blog']} | {$this->r->gtext['reply']}";
// Template
$this->tpl->display('reply.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('bookmarks', 'bookmarks', 'isInt', true);
}
// Urls
$this->r->text['form_url'] = suxFunct::makeUrl('/bookmarks/approve');
$this->r->text['back_url'] = suxFunct::getPreviousURL();
// bookmarks
$this->r->arr['bookmarks'] = $this->bm->get();
// Adjust variables
foreach ($this->r->arr['bookmarks'] as $key => $val) {
if (!$val['draft']) {
// This bookmark is not a draft, it's just in the future, ignore it.
unset($this->r->arr['bookmarks'][$key]);
continue;
}
// Append nickname
$u = $this->user->getByID($val['users_id']);
$this->r->arr['bookmarks'][$key]['nickname'] = $u['nickname'];
}
$this->r->title .= " | {$this->r->gtext['approve']}";
$this->tpl->display('approve.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('integrity', 'integrity:users_id:nickname', 'hasIntegrity');
}
// --------------------------------------------------------------------
// Template
// --------------------------------------------------------------------
// Additional
$this->tpl->assign('nickname', $this->nickname);
$this->tpl->assign('users_id', $this->users_id);
$this->r->text['form_url'] = suxFunct::makeUrl("/user/openid/{$this->nickname}");
$this->r->text['back_url'] = suxFunct::getPreviousURL();
$this->r->arr['openids'] = $this->user->getOpenIDs($this->users_id);
$this->r->arr['trusted'] = $this->openid->getTrusted($this->users_id);
$this->r->title .= " | {$this->r->gtext['edit_openid']}";
// Display template
$this->tpl->display('openid.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('date', 'Date:Date_Year:Date_Month:Date_Day', 'isDate', false, false, 'makeDate');
}
if (!$this->tpl->getTemplateVars('Date_Year')) {
// Today's Date
$this->tpl->assign('Date_Year', date('Y'));
$this->tpl->assign('Date_Month', date('m'));
$this->tpl->assign('Date_Day', date('j'));
}
// Urls
$this->r->text['form_url'] = suxFunct::makeUrl('/admin/purge');
$this->r->text['back_url'] = suxFunct::getPreviousURL();
$this->r->title .= " | {$this->r->gtext['admin_purge']}";
// Template
$this->tpl->display('purge.tpl');
}
/**
* Constructor
*/
function __construct()
{
// Pre-condition sanity check
if (empty($this->module)) {
throw new Exception('$this->module not set');
}
if (!$this->r instanceof suxRenderer) {
throw new Exception('$this->r is not an instance of suxRenderer()');
}
// Template
$this->tpl = new suxTemplate($this->module);
// Template
$this->tpl->assignByRef('r', $this->r);
// Renderer referenced in template
$this->tpl->configLoad('my.conf', $this->module);
// Config variables
// Form
$this->tpl->assign('form_name', $this->form_name);
suxValidate::set_form($this->form_name);
// Common objects
$this->user = new suxUser();
$this->log = new suxLog();
$this->link = new suxLink();
$this->pager = new suxPager();
$this->tags = new suxTags();
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('subscriptions', 'subscriptions', 'isInt', true);
}
// Urls
$this->r->text['form_url'] = suxFunct::makeUrl('/feeds/manage');
$this->r->text['back_url'] = suxFunct::getPreviousURL();
// Feeds
$feeds = array();
foreach ($this->rss->getFeeds() as $feed) {
$feeds[$feed['id']] = $feed['title'];
}
$this->r->arr['feeds'] = $feeds;
// Subscriptions
if (!isset($_POST['subscriptions'])) {
$this->r->arr['subscriptions'] = $this->link->getLinks('link__rss_feeds__users', 'users', $_SESSION['users_id']);
}
$this->r->title .= " | {$this->r->gtext['manage']}";
$this->tpl->display('manage.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('feeds', 'feeds', 'isInt', true);
}
// Urls
$this->r->text['form_url'] = suxFunct::makeUrl('/feeds/approve');
$this->r->text['back_url'] = suxFunct::getPreviousURL();
// Feeds
$this->r->arr['feeds'] = $this->rss->getFeeds();
// Additional variables
foreach ($this->r->arr['feeds'] as $key => $val) {
$u = $this->user->getByID($val['users_id']);
$this->r->arr['feeds'][$key]['nickname'] = $u['nickname'];
}
$this->r->title .= " | {$this->r->gtext['approve']}";
$this->tpl->display('approve.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Pre assign template variables, maybe overwritten by &$dirty
// --------------------------------------------------------------------
$change_me = array();
### change me
if ($this->id) {
### get the item from the database, assign it to the $change_me array.
// Don't allow spoofing
unset($dirty['id']);
}
// Assign
$this->tpl->assign($change_me);
### change me
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
### add validators here, examples:
// if ($this->id) suxValidate::register_validator('integrity', 'integrity:id', 'hasIntegrity');
// suxValidate::register_validator('title', 'title', 'notEmpty', false, false, 'trim');
### @see: ./includes/symbionts/SmartyAddons/docs/SmartyValidate/README
}
// --------------------------------------------------------------------
// Template
// --------------------------------------------------------------------
$this->r->text['form_url'] = suxFunct::makeUrl('/path/to/form' . $this->id);
### change me
$this->r->text['back_url'] = suxFunct::getPreviousURL();
### do template stuff here
// Template
$this->tpl->display('example.tpl');
### change me
}
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
suxValidate::register_validator('integrity', 'integrity:users_id:nickname', 'hasIntegrity');
}
// --------------------------------------------------------------------
// Template
// --------------------------------------------------------------------
$this->tpl->assign('nickname', $_SESSION['nickname']);
$this->tpl->assign('users_id', $_SESSION['users_id']);
$this->r->text['form_url'] = suxFunct::makeUrl("/{$this->module}/admin");
// Pager
$this->pager->limit = $this->per_page;
$this->pager->setStart();
$this->pager->setPages($this->photo->countAlbums());
$this->r->text['pager'] = $this->pager->pageList(suxFunct::makeUrl("/{$this->module}/admin"));
$this->r->arr['photos'] = $this->photo->getAlbums($this->pager->limit, $this->pager->start);
// Additional variables
if (!$this->r->arr['photos']) {
unset($this->r->arr['photos']);
} else {
foreach ($this->r->arr['photos'] as $key => $val) {
$u = $this->user->getByID($val['users_id']);
$this->r->arr['photos'][$key]['nickname'] = $u['nickname'];
$this->r->arr['photos'][$key]['photos_count'] = $this->photo->countPhotos($val['id']);
}
}
$this->r->title .= " | {$this->r->gtext['photos']} | {$this->r->gtext['admin']}";
// Display
$this->tpl->display('admin.tpl');
}
/**
* Override: build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('url', 'url', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('url2', 'url', 'isURL');
}
// Urls
$this->r->text['form_url'] = suxFunct::makeUrl('/user/login/openid');
$this->r->text['back_url'] = suxFunct::getPreviousURL();
$this->r->title .= " | {$this->r->gtext['openid_login']}";
// Template
$this->tpl->display('login_openid.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Get existing user info if available
// --------------------------------------------------------------------
// $u = array();
// Get stuff from the database
// $this->tpl->assign($u);
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect(true);
}
if (empty($dirty['action']) || !suxValidate::is_registered_form($dirty['action'])) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register additional forms
suxValidate::register_form('addvec');
suxValidate::register_form('addcat');
suxValidate::register_form('adddoc');
suxValidate::register_form('remcat');
suxValidate::register_form('remvec');
suxValidate::register_form('remdoc');
suxValidate::register_form('sharevec');
suxValidate::register_form('unsharevec');
// Register our additional criterias
suxValidate::register_criteria('invalidShare', 'this->invalidShare', 'sharevec');
suxValidate::register_criteria('userExists', 'this->userExists', 'sharevec');
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
// Add vector
suxValidate::register_validator('addvec1', 'vector', 'notEmpty', false, false, 'trim', 'addvec');
suxValidate::register_validator('addvec2', "vector:-1:{$this->nb->getMaxVectorLength()}", 'isLength', false, false, 'trim', 'addvec');
// Add category
suxValidate::register_validator('addcat1', 'category', 'notEmpty', false, true, 'trim', 'addcat');
suxValidate::register_validator('addcat2', 'vector_id', 'isInt', false, true, 'trim', 'addcat');
suxValidate::register_validator('addcat3', "category:-1:{$this->nb->getMaxCategoryLength()}", 'isLength', false, false, 'trim', 'addcat');
// Remove category
suxValidate::register_validator('remcat1', 'category_id', 'isInt', false, false, 'trim', 'remcat');
// Remove vector
suxValidate::register_validator('remvec1', 'vector_id', 'isInt', false, false, 'trim', 'remvec');
// Add document
suxValidate::register_validator('adddoc1', 'document', 'notEmpty', false, true, 'trim', 'adddoc');
suxValidate::register_validator('adddoc2', 'category_id', 'isInt', false, false, 'trim', 'adddoc');
// Remove document
suxValidate::register_validator('remdoc1', 'document_id', 'isInt', false, false, 'trim', 'remdoc');
// Share vector
suxValidate::register_validator('sharevec1', 'vector_id', 'isInt', false, false, 'trim', 'sharevec');
suxValidate::register_validator('sharevec2', 'users_id', 'isInt', false, false, 'trim', 'sharevec');
suxValidate::register_validator('sharevec3', 'trainer:1:1', 'isRange', true, false, 'trim', 'sharevec');
suxValidate::register_validator('sharevec4', 'owner:1:1', 'isRange', true, false, 'trim', 'sharevec');
suxValidate::register_validator('sharevec5', 'users_id', 'invalidShare', true, false, 'trim', 'sharevec');
suxValidate::register_validator('sharevec6', 'users_id', 'userExists', true, false, 'trim', 'sharevec');
// Unshare vector
suxValidate::register_validator('unsharevec1', 'unshare', 'dummyValid', false, false, null, 'unsharevec');
}
// Additional variables
$this->r->text['form_url'] = suxFunct::makeUrl('/bayes');
$this->r->title .= " | {$this->r->gtext['edit_bayes']}";
// Template
$this->tpl->display('edit.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('image', 'image:' . $this->extensions, 'isFileType');
suxValidate::register_validator('image2', 'image:' . ini_get('upload_max_filesize'), 'isFileSize');
suxValidate::register_validator('album', 'album', 'isInt', false, false, 'trim');
}
// Additional
$this->r->text['upload_max_filesize'] = ini_get('upload_max_filesize');
$this->r->text['supported'] = $this->extensions;
// Urls
$this->r->text['form_url'] = suxFunct::makeUrl('/photos/upload');
$this->r->text['back_url'] = suxFunct::getPreviousURL();
$this->r->title .= " | {$this->r->gtext['upload']}";
// Template
$this->tpl->display('upload.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Pre assign template variables, maybe overwritten by &$dirty
// --------------------------------------------------------------------
$blog = array();
if ($this->id) {
// Editing a blog post
$tmp = $this->msg->getByID($this->id);
$blog['id'] = $tmp['id'];
$blog['title'] = $tmp['title'];
$blog['image'] = $tmp['image'];
$blog['body'] = htmlentities($tmp['body_html'], ENT_QUOTES, 'UTF-8');
// Textarea fix
$blog['draft'] = $tmp['draft'];
$blog['thread_pos'] = $tmp['thread_pos'];
// Get publish date
// regex must match '2008-06-18 16:53:29' or '2008-06-18T16:53:29-04:00'
$matches = array();
$regex = '/^(\\d{4})-(0[0-9]|1[0,1,2])-([0,1,2][0-9]|3[0,1]).+(\\d{2}):(\\d{2}):(\\d{2})/';
preg_match($regex, $tmp['published_on'], $matches);
$blog['Date_Year'] = @$matches[1];
// year
$blog['Date_Month'] = @$matches[2];
// month
$blog['Date_Day'] = @$matches[3];
// day
$blog['Time_Hour'] = @$matches[4];
// hour
$blog['Time_Minute'] = @$matches[5];
// minutes
$blog['Time_Second'] = @$matches[6];
//seconds
/* Tags */
$links = $this->link->getLinks('link__messages__tags', 'messages', $blog['id']);
$blog['tags'] = '';
foreach ($links as $val) {
$tmp = $this->tags->getByID($val);
$blog['tags'] .= $tmp['tag'] . ', ';
}
$blog['tags'] = rtrim($blog['tags'], ', ');
/* Naive Bayesian:
1) Get the `link__bayes_documents__messages` matching this messages_id
2) Foreach linking bayes_document_id
3) get the categories I can train (nb::isCategoryTrainer($cat_id, $users_id)
4) stuff them into {$category_id} for template, append doc_id to {$link} string
*/
$links = $this->link->getLinks('link__bayes_documents__messages', 'messages', $blog['id']);
$blog['linked'] = '';
foreach ($links as $val) {
$cat = $this->nb->getCategoriesByDocument($val);
foreach ($cat as $key => $val2) {
if ($this->nb->isCategoryTrainer($key, $_SESSION['users_id'])) {
$blog['linked'] .= "{$val}, ";
$blog['category_id'][] = $key;
}
}
}
$blog['linked'] = rtrim($blog['linked'], ', ');
// Remove trailing comma
// Don't allow spoofing
unset($dirty['id']);
}
// Assign blog
$this->tpl->assign($blog);
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
if ($this->id) {
suxValidate::register_validator('integrity', 'integrity:id', 'hasIntegrity');
}
suxValidate::register_validator('title', 'title', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('image', 'image:' . $this->extensions, 'isFileType', true);
suxValidate::register_validator('image2', 'image:' . ini_get('upload_max_filesize'), 'isFileSize', true);
suxValidate::register_validator('body', 'body', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('date', 'Date:Date_Year:Date_Month:Date_Day', 'isDate', false, false, 'makeDate');
suxValidate::register_validator('time', 'Time_Hour', 'isInt');
suxValidate::register_validator('time2', 'Time_Minute', 'isInt');
suxValidate::register_validator('time3', 'Time_Second', 'isInt');
}
// --------------------------------------------------------------------
// Template
// --------------------------------------------------------------------
// Additional
$this->r->text['upload_max_filesize'] = ini_get('upload_max_filesize');
$this->r->text['supported'] = $this->extensions;
$this->r->text['form_url'] = suxFunct::makeUrl('/blog/edit/' . $this->id);
$this->r->text['back_url'] = suxFunct::getPreviousURL();
if (!$this->tpl->getTemplateVars('Date_Year')) {
// Today's Date
$this->tpl->assign('Date_Year', date('Y'));
$this->tpl->assign('Date_Month', date('m'));
$this->tpl->assign('Date_Day', date('j'));
}
if (!$this->tpl->getTemplateVars('Time_Hour')) {
// Current Time
$this->tpl->assign('Time_Hour', date('H'));
$this->tpl->assign('Time_Minute', date('i'));
$this->tpl->assign('Time_Second', date('s'));
}
if ($this->id) {
$this->r->title .= " | {$this->r->gtext['edit_2']}";
} else {
$this->r->title .= " | {$this->r->gtext['new']}";
}
// Template
$this->tpl->display('edit.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
$photoalbum = array();
if ($this->id) {
// Editing a photoalbum
$tmp = $this->photo->getAlbumByID($this->id);
$photoalbum['id'] = $tmp['id'];
$photoalbum['title'] = $tmp['title'];
$photoalbum['body'] = htmlentities($tmp['body_html'], ENT_QUOTES, 'UTF-8');
// Textarea fix
$photoalbum['draft'] = $tmp['draft'];
// Get publish date
// regex must match '2008-06-18 16:53:29' or '2008-06-18T16:53:29-04:00'
$matches = array();
$regex = '/^(\\d{4})-(0[0-9]|1[0,1,2])-([0,1,2][0-9]|3[0,1]).+(\\d{2}):(\\d{2}):(\\d{2})/';
preg_match($regex, $tmp['published_on'], $matches);
$photoalbum['Date_Year'] = @$matches[1];
// year
$photoalbum['Date_Month'] = @$matches[2];
// month
$photoalbum['Date_Day'] = @$matches[3];
// day
$photoalbum['Time_Hour'] = @$matches[4];
// hour
$photoalbum['Time_Minute'] = @$matches[5];
// minutes
$photoalbum['Time_Second'] = @$matches[6];
//seconds
// Don't allow spoofing
unset($dirty['id']);
}
// Assign photoalbum
// new dBug($photoalbum);
$this->tpl->assign($photoalbum);
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
if ($this->id) {
suxValidate::register_validator('integrity', 'integrity:id', 'hasIntegrity');
}
suxValidate::register_validator('title', 'title', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('body', 'body', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('date', 'Date:Date_Year:Date_Month:Date_Day', 'isDate', false, false, 'makeDate');
suxValidate::register_validator('time', 'Time_Hour', 'isInt');
suxValidate::register_validator('time2', 'Time_Minute', 'isInt');
suxValidate::register_validator('time3', 'Time_Second', 'isInt');
}
// Additional variables
$this->r->text['form_url'] = suxFunct::makeUrl('/photos/album/edit/' . $this->id);
$this->r->text['back_url'] = suxFunct::getPreviousURL();
if (!$this->tpl->getTemplateVars('Date_Year')) {
// Today's Date
$this->tpl->assign('Date_Year', date('Y'));
$this->tpl->assign('Date_Month', date('m'));
$this->tpl->assign('Date_Day', date('j'));
}
if (!$this->tpl->getTemplateVars('Time_Hour')) {
// Current Time
$this->tpl->assign('Time_Hour', date('H'));
$this->tpl->assign('Time_Minute', date('i'));
$this->tpl->assign('Time_Second', date('s'));
}
if ($this->id) {
$this->r->title .= " | {$this->r->gtext['edit_2']}";
} else {
$this->r->title .= " | {$this->r->gtext['new']}";
}
// Template
$this->tpl->display('edit.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Replace what we have with what the user submitted.
// --------------------------------------------------------------------
$count = 0;
if (isset($dirty['url']) && is_array($dirty['url'])) {
$count = count($this->arr['found_links']);
// Original count
$this->arr['found_links'] = array();
// Clear array
for ($i = 0; $i < $count; ++$i) {
if (!empty($dirty['url'][$i]) && !isset($this->arr['found_links'][$dirty['url'][$i]])) {
$this->arr['found_links'][$dirty['url'][$i]] = array('title' => $dirty['title'][$i], 'body' => $dirty['body'][$i]);
} else {
$title = isset($dirty['title'][$i]) ? $dirty['title'][$i] : null;
$body = isset($dirty['body'][$i]) ? $dirty['body'][$i] : null;
$this->arr['found_links'][] = array('title' => $title, 'body' => $body);
}
}
}
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
$count = count($this->arr['found_links']);
for ($i = 0; $i < $count; ++$i) {
suxValidate::register_validator("url[{$i}]", "url[{$i}]", 'notEmpty', false, false, 'trim');
suxValidate::register_validator("url2[{$i}]", "url[{$i}]", 'isURL');
suxValidate::register_validator("title[{$i}]", "title[{$i}]", 'notEmpty', false, false, 'trim');
suxValidate::register_validator("body[{$i}]", "body[{$i}]", 'notEmpty', false, false, 'trim');
}
}
// Additional variables
$this->r->text['form_url'] = suxFunct::makeUrl('/blog/bookmarks/' . $this->id);
$this->r->text['back_url'] = suxFunct::getPreviousURL();
$this->r->title .= " | {$this->r->gtext['suggest_bookmarks']} ";
// Template
$this->r->arr['found_links'] = $this->arr['found_links'];
$this->tpl->display('bookmarks.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
* @param array $filthy reference to unverified $_GET
*/
function formBuild(&$dirty, &$filthy)
{
// --------------------------------------------------------------------
// Pre assign template variables, maybe overwritten by &$dirty
// --------------------------------------------------------------------
$u = array();
if ($this->isOpenID()) {
// OpenID Registration
$this->r->bool['openid'] = true;
$this->r->text['openid_url'] = $_SESSION['openid_url_registration'];
// Sreg
if (!empty($filthy['nickname'])) {
$u['nickname'] = $filthy['nickname'];
}
if (!empty($filthy['email'])) {
$u['email'] = $filthy['email'];
}
if (!empty($filthy['fullname'])) {
// \w means alphanumeric characters, \W is the negated version of \w
$tmp = mb_split("\\W", $filthy['fullname']);
$u['given_name'] = array_shift($tmp);
$u['family_name'] = array_pop($tmp);
}
if (!empty($filthy['dob'])) {
$tmp = mb_split("-", $filthy['dob']);
$u['Date_Year'] = array_shift($tmp);
$u['Date_Month'] = array_shift($tmp);
$u['Date_Day'] = array_shift($tmp);
}
if (!empty($filthy['country'])) {
$u['country'] = mb_strtolower($filthy['country']);
}
if (!empty($filthy['gender'])) {
$u['gender'] = mb_strtolower($filthy['gender']);
}
if (!empty($filthy['postcode'])) {
$u['postcode'] = $filthy['postcode'];
}
if (!empty($filthy['language'])) {
$u['language'] = mb_strtolower($filthy['language']);
}
if (!empty($filthy['timezone'])) {
$u['timezone'] = $filthy['timezone'];
}
} elseif ($this->mode == 'edit') {
$u = $this->user->getByID($this->users_id, true);
// Unset
unset($u['password']);
unset($u['root']);
// Dob
if (!empty($u['dob'])) {
$tmp = mb_split("-", $u['dob']);
$u['Date_Year'] = array_shift($tmp);
$u['Date_Month'] = array_shift($tmp);
$u['Date_Day'] = array_shift($tmp);
}
unset($u['dob']);
// Country
if (!empty($u['country'])) {
$u['country'] = mb_strtolower($u['country']);
}
// Don't allow spoofing
unset($dirty['nickname']);
}
// Assign user
$this->tpl->assign($u);
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our additional criterias
suxValidate::register_criteria('invalidCharacters', 'this->invalidCharacters');
suxValidate::register_criteria('isDuplicateNickname', 'this->isDuplicateNickname');
suxValidate::register_criteria('isReservedNickname', 'this->isReservedNickname');
suxValidate::register_criteria('isDuplicateEmail', 'this->isDuplicateEmail');
suxValidate::register_criteria('isValidCaptcha', 'this->isValidCaptcha');
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('nickname', 'nickname', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('nickname2', 'nickname', 'invalidCharacters');
suxValidate::register_validator('nickname3', 'nickname', 'isDuplicateNickname');
suxValidate::register_validator('nickname4', 'nickname', 'isReservedNickname');
suxValidate::register_validator('email', 'email', 'isEmail', false, false, 'trim');
suxValidate::register_validator('email2', 'email', 'isDuplicateEmail');
if ($this->mode == 'edit') {
suxValidate::register_validator('integrity', 'integrity:nickname', 'hasIntegrity');
}
// --------------------------------------------------------------------
// Validators with special conditions
// --------------------------------------------------------------------
// Passwords
if (!$this->isOpenID()) {
if ($this->mode == 'edit') {
// Empty is ok in edit mode
suxValidate::register_validator('password', 'password:6:-1', 'isLength', true, false, 'trim');
suxValidate::register_validator('password2', 'password:password_verify', 'isEqual', true);
} else {
suxValidate::register_validator('password', 'password:6:-1', 'isLength', false, false, 'trim');
suxValidate::register_validator('password2', 'password:password_verify', 'isEqual');
}
}
// Captcha
if ($this->mode != 'edit') {
suxValidate::register_validator('captcha', 'captcha', 'isValidCaptcha');
}
}
// --------------------------------------------------------------------
// Template
// --------------------------------------------------------------------
// Defaults
if (!$this->tpl->getTemplateVars('country')) {
$this->tpl->assign('country', $GLOBALS['CONFIG']['COUNTRY']);
}
// Country
if (!$this->tpl->getTemplateVars('timezone')) {
$this->tpl->assign('timezone', $GLOBALS['CONFIG']['TIMEZONE']);
}
// Timezone
if (!$this->tpl->getTemplateVars('language')) {
$this->tpl->assign('language', $GLOBALS['CONFIG']['LANGUAGE']);
}
// Languages
// Additional variables
$this->r->text['form_url'] = suxFunct::makeUrl('/user/register');
// Register
// Overrides for edit mode
if ($this->mode == 'edit') {
$this->r->text['form_url'] = suxFunct::makeUrl('/user/edit/' . @$u['nickname']);
// Edit
$this->r->bool['edit'] = true;
}
$this->r->text['back_url'] = suxFunct::getPreviousURL();
if ($this->mode == 'edit') {
$this->r->title .= " | {$this->r->gtext['edit_profile']}";
} else {
$this->r->title .= " | {$this->r->gtext['reg']}";
}
// Template
$this->tpl->display('edit.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
$empty = false;
if ($this->image) {
$empty = true;
}
suxValidate::register_validator('integrity', 'integrity:users_id:nickname', 'hasIntegrity');
suxValidate::register_validator('image', 'image:' . $this->extensions, 'isFileType', $empty);
suxValidate::register_validator('image2', 'image:' . ini_get('upload_max_filesize'), 'isFileSize', $empty);
}
// --------------------------------------------------------------------
// Template
// --------------------------------------------------------------------
// Additional
$this->tpl->assign('nickname', $this->nickname);
$this->tpl->assign('users_id', $this->users_id);
$this->tpl->assign('image', $this->image);
$this->r->text['upload_max_filesize'] = ini_get('upload_max_filesize');
$this->r->text['supported'] = $this->extensions;
$this->r->text['form_url'] = suxFunct::makeUrl("/user/avatar/{$this->nickname}");
$this->r->text['back_url'] = suxFunct::getPreviousURL();
$this->r->title .= " | {$this->r->gtext['edit_avatar']}";
// Display template
$this->tpl->display('avatar.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Pre assign template variables, maybe overwritten by &$dirty
// --------------------------------------------------------------------
$rel = $this->soc->getRelationship($_SESSION['users_id'], $this->users_id);
if ($rel) {
list($identity, $friendship, $physical, $professional, $geographical, $family, $romantic) = $this->soc->relationshipArray($rel['relationship']);
// Radios
$this->tpl->assign('friendship', $friendship);
$this->tpl->assign('geographical', $geographical);
$this->tpl->assign('family', $family);
// Checkboxes
$this->tpl->assign('identity', @explode(' ', $identity));
$this->tpl->assign('physical', @explode(' ', $physical));
$this->tpl->assign('professional', @explode(' ', $professional));
$this->tpl->assign('romantic', @explode(' ', $romantic));
}
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('integrity', 'integrity:users_id:nickname', 'hasIntegrity');
}
// --------------------------------------------------------------------
// Template
// --------------------------------------------------------------------
$this->tpl->assign('nickname', $this->nickname);
$this->tpl->assign('users_id', $this->users_id);
$this->r->text['form_url'] = suxFunct::makeUrl("/society/relationship/{$this->nickname}");
$this->r->text['back_url'] = suxFunct::getPreviousURL();
$this->r->title .= " | {$this->r->gtext['edit_relationship']}";
// Display template
$this->tpl->display('relationship.tpl');
}
/**
* Build the form and show the template
*
* @global string $CONFIG['URL']
* @param string $module
* @param int $id
* @param array $dirty reference to unverified $_POST
*/
function formBuild($module, $id, &$dirty)
{
// Initialize width & height
$width = 0;
$height = 0;
// Check $id
if (!filter_var($id, FILTER_VALIDATE_INT) || $id < 1) {
throw new Exception('Invalid $id');
}
// Check $module, assign $table
$table = $this->getTable($module);
if (!$table) {
throw new Exception('Unsuported $module');
}
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
suxValidate::register_validator('integrity', 'integrity:module:id', 'hasIntegrity');
}
// --------------------------------------------------------------------
// Get image from database
// --------------------------------------------------------------------
$query = "SELECT users_id, image FROM {$table} WHERE id = ? ";
$db = suxDB::get();
$st = $db->prepare($query);
$st->execute(array($id));
$image = $st->fetch(PDO::FETCH_ASSOC);
if (!$image['image']) {
throw new Exception('$image not found');
}
if ($image['users_id'] != $_SESSION['users_id']) {
// Check that the user is allowed to be here
if (!$this->user->isRoot()) {
$access = $this->user->getAccess($module);
if (!isset($GLOBALS['CONFIG']['ACCESS'][$module]['admin'])) {
suxFunct::redirect(suxFunct::getPreviousURL('cropper'));
} elseif ($access < $GLOBALS['CONFIG']['ACCESS'][$module]['admin']) {
suxFunct::redirect(suxFunct::getPreviousURL('cropper'));
}
}
}
// Assign a url to the fullsize version of the image
$image = $image['image'];
$image = rawurlencode(suxPhoto::t2fImage($image));
$image = "{$GLOBALS['CONFIG']['URL']}/data/{$module}/{$image}";
$image = suxFunct::myHttpServer() . $image;
// Double check
if (!filter_var($image, FILTER_VALIDATE_URL)) {
$image = null;
}
if (!preg_match('/\\.(jpe?g|gif|png)$/i', $image)) {
$image = null;
}
if ($image) {
list($width, $height) = @getimagesize($image);
}
// --------------------------------------------------------------------
// Template
// --------------------------------------------------------------------
if ($image && $width && $height) {
// Get config variables
$this->tpl->configLoad('my.conf', $module);
$this->tpl->assign('module', $module);
$this->tpl->assign('id', $id);
$this->tpl->assign('x2', $this->tpl->getConfigVars('thumbnailWidth'));
// Pavatar
$this->tpl->assign('y2', $this->tpl->getConfigVars('thumbnailHeight'));
$this->tpl->assign('url_to_source', $image);
$this->tpl->assign('width', $width);
$this->tpl->assign('height', $height);
$this->tpl->assign('form_url', suxFunct::makeUrl("/cropper/{$module}/{$id}"));
$this->tpl->assign('prev_url', suxFunct::getPreviousURL('cropper'));
$this->r->title .= " | {$this->r->gtext['crop_image']}";
$this->tpl->display('cropper.tpl');
} else {
throw new Exception('$image not found');
}
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
// --------------------------------------------------------------------
// Pre assign template variables, maybe overwritten by &$dirty
// --------------------------------------------------------------------
$this->tpl->assign('root', $this->root);
$this->tpl->assign('banned', $this->banned);
// Dynamically create access dropdowns
$myOptions = array();
$mySelect = array();
$tmp = array('0' => '---');
foreach ($GLOBALS['CONFIG']['ACCESS'] as $key => $val) {
// Manipulate the array into something Smarty can use
$tmp2 = $tmp;
$val = array_flip($val);
foreach ($val as $key2 => $val2) {
$tmp2[$key2] = $val2;
}
$val = $tmp2;
$myOptions[$key] = $val;
$mySelect[$key] = $this->user->getAccess($key, $this->users_id);
}
if (!empty($dirty)) {
foreach ($dirty as $key => $val) {
// Use the submitted values
if (isset($mySelect[$key])) {
$mySelect[$key] = $val;
}
}
}
$this->tpl->assign('myOptions', $myOptions);
$this->tpl->assign('mySelect', $mySelect);
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
// register_validator($id, $field, $criteria, $empty = false, $halt = false, $transform = null, $form = 'default')
suxValidate::register_validator('integrity', 'integrity:users_id:nickname', 'hasIntegrity');
}
// --------------------------------------------------------------------
// Template
// --------------------------------------------------------------------
$this->tpl->assign('access', $GLOBALS['CONFIG']['ACCESS']);
$this->tpl->assign('nickname', $this->nickname);
$this->tpl->assign('users_id', $this->users_id);
$this->r->text['form_url'] = suxFunct::makeUrl("/admin/access/{$this->nickname}");
$this->r->text['back_url'] = suxFunct::getPreviousURL();
if ($this->users_id == $_SESSION['users_id']) {
$this->tpl->assign('disabled', 'disabled="disabled"');
}
$this->r->title .= " | {$this->r->gtext['edit_access']}";
// Display template
$this->tpl->display('access.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
$photoalbum = array();
// Editing a photoalbum
$tmp = $this->photo->getAlbumByID($this->id);
if (!$tmp) {
suxFunct::redirect(suxFunct::makeURL('/photos'));
}
// Invalid id
$photoalbum['id'] = $tmp['id'];
$photoalbum['cover'] = $tmp['thumbnail'];
// Don't allow spoofing
unset($dirty['id']);
$this->tpl->assign($photoalbum);
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
suxValidate::register_validator('integrity', 'integrity:id', 'hasIntegrity');
}
// --------------------------------------------------------------------
// Templating
// --------------------------------------------------------------------
// Start pager
$this->pager->limit = $this->per_page;
$this->pager->setStart();
$this->pager->setPages($this->photo->countPhotos($this->id));
$this->r->text['pager'] = $this->pager->pageList(suxFunct::makeUrl("/photos/album/annotate/{$this->id}"));
$this->r->arr['photos'] = $this->photo->getPhotos($this->pager->limit, $this->pager->start, $this->id);
$this->r->text['form_url'] = suxFunct::makeUrl('/photos/album/annotate/' . $this->id, array('page' => $_GET['page']));
$this->r->text['back_url'] = suxFunct::getPreviousURL();
$this->r->title .= " | {$this->r->gtext['annotate_2']}";
$this->tpl->display('annotate.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild()
{
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our validators
suxValidate::register_validator('integrity', 'integrity:users_id:nickname', 'hasIntegrity');
}
// -------------------------------------------------------------------
// Sort / Order
// -------------------------------------------------------------------
$sort = null;
if (isset($_GET['sort'])) {
$sort = $_GET['sort'];
}
$order = 'DESC';
if (!empty($_GET['order'])) {
$order = $_GET['order'];
}
// -------------------------------------------------------------------
// Pager
// -------------------------------------------------------------------
$params = array();
// Extra params
if ($sort) {
$params = array('sort' => $sort, 'order' => $order);
}
$this->pager->limit = $this->per_page;
$this->pager->setStart();
$this->pager->setPages($this->user->count());
$this->r->text['pager'] = $this->pager->pageList(suxFunct::makeUrl('/admin', $params));
// -------------------------------------------------------------------
// Template
// -------------------------------------------------------------------
$this->tpl->assign('nickname', $_SESSION['nickname']);
$this->tpl->assign('users_id', $_SESSION['users_id']);
$this->r->text['form_url'] = suxFunct::makeUrl("/{$this->module}/admin");
$valid = array('users_id', 'nickname', 'email', 'root', 'banned', 'ts');
if (in_array(mb_strtolower($sort), $valid)) {
if ($sort == 'ts') {
$this->user->setOrder('last_active', $order);
} else {
$this->user->setOrder($sort, $order);
}
}
$this->r->arr['ulist'] = $this->user->get($this->pager->limit, $this->pager->start);
// Additional variables
foreach ($this->r->arr['ulist'] as $key => $val) {
$u = $this->user->getByID($val['users_id'], true);
$this->r->arr['ulist'][$key]['url'] = $u['url'];
}
$this->tpl->assign('sort', $sort);
$this->r->text['sort_url'] = suxFunct::makeUrl('/admin', array('order' => mb_strtolower($order) == 'desc' ? 'ASC' : 'DESC'));
$this->r->title .= " | {$this->r->gtext['admin']}";
$this->tpl->display('userlist.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
unset($dirty['id']);
// Don't allow spoofing
$bookmark = array();
if ($this->id) {
// Editing a bookmark post
$tmp = $this->bm->getByID($this->id);
$bookmark['id'] = $tmp['id'];
$bookmark['title'] = $tmp['title'];
$bookmark['url'] = $tmp['url'];
$bookmark['body'] = htmlentities($tmp['body_html'], ENT_QUOTES, 'UTF-8');
// Textarea fix
$bookmark['draft'] = $tmp['draft'];
// Get publish date
// regex must match '2008-06-18 16:53:29' or '2008-06-18T16:53:29-04:00'
$matches = array();
$regex = '/^(\\d{4})-(0[0-9]|1[0,1,2])-([0,1,2][0-9]|3[0,1]).+(\\d{2}):(\\d{2}):(\\d{2})/';
preg_match($regex, $tmp['published_on'], $matches);
$bookmark['Date_Year'] = @$matches[1];
// year
$bookmark['Date_Month'] = @$matches[2];
// month
$bookmark['Date_Day'] = @$matches[3];
// day
$bookmark['Time_Hour'] = @$matches[4];
// hour
$bookmark['Time_Minute'] = @$matches[5];
// minutes
$bookmark['Time_Second'] = @$matches[6];
//seconds
/* Tags */
$links = $this->link->getLinks('link__bookmarks__tags', 'bookmarks', $bookmark['id']);
$bookmark['tags'] = '';
foreach ($links as $val) {
$tmp = $this->tags->getByID($val);
$bookmark['tags'] .= $tmp['tag'] . ', ';
}
$bookmark['tags'] = rtrim($bookmark['tags'], ', ');
}
// Assign bookmark
// new dBug($bookmark);
$this->tpl->assign($bookmark);
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our additional criterias
suxValidate::register_criteria('isDuplicateBookmark', 'this->isDuplicateBookmark');
suxValidate::register_criteria('isValidBookmark', 'this->isValidBookmark');
// Register our validators
if ($this->id) {
suxValidate::register_validator('integrity', 'integrity:id', 'hasIntegrity');
}
suxValidate::register_validator('url', 'url', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('url2', 'url', 'isURL');
suxValidate::register_validator('url3', 'url', 'isDuplicateBookmark');
suxValidate::register_validator('url4', 'url', 'isValidBookmark');
suxValidate::register_validator('title', 'title', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('body', 'body', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('date', 'Date:Date_Year:Date_Month:Date_Day', 'isDate', false, false, 'makeDate');
suxValidate::register_validator('time', 'Time_Hour', 'isInt');
suxValidate::register_validator('time2', 'Time_Minute', 'isInt');
suxValidate::register_validator('time3', 'Time_Second', 'isInt');
}
// Additional variables
$this->r->text['form_url'] = suxFunct::makeUrl('/bookmarks/edit/' . $this->id);
$this->r->text['back_url'] = suxFunct::getPreviousURL($this->prev_skip);
if (!$this->tpl->getTemplateVars('Date_Year')) {
// Today's Date
$this->tpl->assign('Date_Year', date('Y'));
$this->tpl->assign('Date_Month', date('m'));
$this->tpl->assign('Date_Day', date('j'));
}
if (!$this->tpl->getTemplateVars('Time_Hour')) {
// Current Time
$this->tpl->assign('Time_Hour', date('H'));
$this->tpl->assign('Time_Minute', date('i'));
$this->tpl->assign('Time_Second', date('s'));
}
$this->r->title .= " | {$this->r->gtext['edit_2']}";
// Template
$this->tpl->display('edit.tpl');
}
/**
* Build the form and show the template
*
* @param array $dirty reference to unverified $_POST
*/
function formBuild(&$dirty)
{
unset($dirty['id']);
// Don't allow spoofing
$feed = array();
if ($this->id) {
// Editing a feed
$tmp = $this->rss->getFeedByID($this->id);
$feed['id'] = $tmp['id'];
$feed['title'] = $tmp['title'];
$feed['url'] = $tmp['url'];
$feed['body'] = htmlentities($tmp['body_html'], ENT_QUOTES, 'UTF-8');
// Textarea fix
$feed['draft'] = $tmp['draft'];
}
// Assign feed
// new dBug($feed);
$this->tpl->assign($feed);
// --------------------------------------------------------------------
// Form logic
// --------------------------------------------------------------------
if (!empty($dirty)) {
$this->tpl->assign($dirty);
} else {
suxValidate::disconnect();
}
if (!suxValidate::is_registered_form()) {
suxValidate::connect($this->tpl, true);
// Reset connection
// Register our additional criterias
suxValidate::register_criteria('isDuplicateFeed', 'this->isDuplicateFeed');
suxValidate::register_criteria('isValidFeed', 'this->isValidFeed');
// Register our validators
if ($this->id) {
suxValidate::register_validator('integrity', 'integrity:id', 'hasIntegrity');
}
suxValidate::register_validator('url', 'url', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('url2', 'url', 'isURL');
suxValidate::register_validator('url3', 'url', 'isDuplicateFeed');
suxValidate::register_validator('url4', 'url', 'isValidFeed');
suxValidate::register_validator('title', 'title', 'notEmpty', false, false, 'trim');
suxValidate::register_validator('body', 'body', 'notEmpty', false, false, 'trim');
}
// Additional variables
$this->r->text['form_url'] = suxFunct::makeUrl('/feeds/edit/' . $this->id);
$this->r->text['back_url'] = suxFunct::getPreviousURL($this->prev_skip);
$this->r->title .= " | {$this->r->gtext['edit_2']}";
// Template
$this->tpl->display('edit.tpl');
}
