/**
* Create a new blog
*/
public function testCreateBlog()
{
// Setup some variables that will be used throughout this method.
$random = Core::RandomHex(6);
$title = 'New Test Blog ' . Core::RandomHex(6);
// Update the current user so it has admin access.
\Core\user()->set('admin', true);
$request = new PageRequest('/blog/create');
// Run the method, it should give me a 200 since the user is now an admin.
$request->execute();
$view = $request->getView();
$this->assertEquals(200, $view->error, 'Checking that admin users can create blogs');
// The returned data should have a "form" available. This is the actual creation form.
/** @var $form Form */
$form = $view->getVariable('form');
$this->assertInstanceOf('Form', $form, 'Checking that the form is set from the blog create controller');
// Set some variables on the form
$form->getElement('page[title]')->set('value', $title);
$form->getElement('page[rewriteurl]')->set('value', '/blogtest-' . $random);
// And submit this form to the handler.
// On a successful submission, it should be simply the URL of the blog.
$formsubmission = call_user_func_array($form->get('callsmethod'), array($form));
$this->assertStringStartsWith('/blog/view/', $formsubmission, 'Checking that form creation was successful');
self::$TestBlogID = substr($formsubmission, 11);
// This will be just the number at the end of the baseurl, ie: the id.
// Make sure that this blog exists!
$blog = new BlogModel(self::$TestBlogID);
$this->assertTrue($blog->exists(), 'Checking that blog model creation was successful');
// And make sure that the page was created.
$page = new PageModel('/blog/view/' . self::$TestBlogID);
$this->assertTrue($page->exists(), 'Checking that blog page creation was successful');
// Go to the page and make sure that it loads up!
$request = new PageRequest('/blog/view/' . self::$TestBlogID);
$request->execute();
$view = $request->getView();
$this->assertEquals(200, $view->error, 'Checking that public blog page exists');
$html = $view->fetch();
$this->assertContains($title, $html, 'Checking that the public blog page contains the correct title');
}
/**
* Shortcut for unpublishing a page.
*/
public function page_unpublish() {
$view = $this->getView();
$request = $this->getPageRequest();
if(!\Core\user()->checkAccess('p:/core/pages/manage')){
return View::ERROR_ACCESSDENIED;
}
$baseurl = $request->getParameter('baseurl');
$page = new PageModel($baseurl);
if(!$page->exists()){
return View::ERROR_NOTFOUND;
}
if(!$request->isPost()){
return View::ERROR_BADREQUEST;
}
// Is this page already un-published?
if($page->get('published_status') == 'draft'){
\Core\set_message('t:MESSAGE_ERROR_PAGE_ALREADY_UNPUBLISHED');
\Core\go_back();
}
$page->set('published_status', 'draft');
$page->save();
\Core\set_message('t:MESSAGE_SUCCESS_PAGE_UNPUBLISHED');
\Core\go_back();
}
/**
* Get the page model for the current page.
*
* @return PageModel
*/
public function getPageModel() {
if ($this->_pagemodel === null) {
$uri = $this->uriresolved;
$pagefac = new ModelFactory('PageModel');
$pagefac->where('rewriteurl = ' . $uri);
//$pagefac->where('fuzzy = 0');
$pagefac->limit(1);
if(Core::IsComponentAvailable('multisite') && MultiSiteHelper::IsEnabled()){
$pagefac->whereGroup('OR', array('site = -1', 'site = ' . MultiSiteHelper::GetCurrentSiteID()));
}
$p = $pagefac->get();
// Split this URL, it'll be used somewhere.
$pagedat = $this->splitParts();
if ($p) {
// :) Found it
$this->_pagemodel = $p;
}
elseif ($pagedat && isset($pagedat['baseurl'])) {
// Is this even a valid controller?
// This will allow a page to be called with it being in the pages database.
$p = new PageModel($pagedat['baseurl']);
if(!$p->exists()){
$p->set('rewriteurl', $pagedat['rewriteurl']);
}
$this->_pagemodel = $p;
}
else {
// No page in the database and no valid controller... sigh
$this->_pagemodel = new PageModel();
}
//var_dump($p); die();
// Make sure all the parameters from both standard GET and core parameters are tacked on.
if ($pagedat && $pagedat['parameters']) {
foreach ($pagedat['parameters'] as $k => $v) {
$this->_pagemodel->setParameter($k, $v);
}
}
if (is_array($_GET)) {
foreach ($_GET as $k => $v) {
if (is_numeric($k)) continue;
$this->_pagemodel->setParameter($k, $v);
}
}
}
return $this->_pagemodel;
}
public function testAdmin(){
// Basic Construct should return one result.
/** @var PageModel $page */
$page = PageModel::Construct('/admin');
$this->assertInstanceOf('Model', $page);
$this->assertInstanceOf('PageModel', $page);
if(!$page->exists()){
$this->markTestSkipped('/admin page does not exist, Core must not be installed.');
return;
}
// Test that getAsArray works as expected.
$asArray = $page->getAsArray();
$this->assertInternalType('array', $asArray);
$this->assertGreaterThan(0, sizeof($asArray));
// And JSON
$asJSON = $page->getAsJSON();
$this->assertInternalType('string', $asJSON);
$this->assertGreaterThan(0, strlen($asJSON));
$this->assertInternalType('array', json_decode($asJSON, true));
$this->assertArrayHasKey('title', $asArray);
$this->assertArrayHasKey('title', $page);
$this->assertEquals($asArray['title'], $page->get('title'));
$this->assertArrayHasKey('expires', $asArray);
$this->assertArrayHasKey('expires', $page);
$this->assertEquals($asArray['expires'], $page->get('expires'));
// Test that getLink behaves as expected.
$this->assertNull($page->getLink('nonexistent'));
// Pages also have the following linked records,
// insertables, pagemetas, and rewrites.
$this->assertInternalType('array', $page->getLink('Insertable'));
$this->assertInternalType('array', $page->getLink('PageMeta'));
$this->assertInternalType('array', $page->getLink('RewriteMap'));
// Ensure that creating meta files works
$meta_name = 'phpunit-test';
$meta_val = 'This is a test meta field from phpunit';
$page->setMeta($meta_name, $meta_val);
// Saving the page should also save this new meta.
$this->assertTrue($page->save());
// Verify this meta from a separate object
// (because Construct will use the cached copy)
$page2 = new PageModel('/admin');
$this->assertTrue($page2->exists());
$this->assertEquals($meta_val, $page2->getMetaValue($meta_name));
// Remove the field from the original object now.
$page->setMeta($meta_name, null);
// Test that removing it does not remove the object's data until the parent is saved though!
$meta = new PageMetaModel($page->get('site'), $page->get('baseurl'), $meta_name, '');
$this->assertTrue($meta->exists());
$this->assertTrue($page->save());
$meta = new PageMetaModel($page->get('site'), $page->get('baseurl'), $meta_name, '');
$this->assertFalse($meta->exists());
}
/**
* Internal function to parse and handle the configs in the component.xml file.
* This is used for installations and upgrades.
*
* @param boolean $install Set to false to force uninstall/disable mode.
* @param int $verbosity (default 0) 0: standard output, 1: real-time, 2: real-time verbose output.
*
* @return boolean | int
* @throws InstallerException
*/
public function _parsePages($install = true, $verbosity = 0) {
$changes = array();
$overallAction = $install ? 'Installing' : 'Uninstalling';
Core\Utilities\Logger\write_debug($overallAction . ' pages for ' . $this->getName());
// I need to get the schema definitions first.
$node = $this->_xmlloader->getElement('pages');
//$prefix = $node->getAttribute('prefix');
// Now, get every table under this node.
foreach ($node->getElementsByTagName('page') as $subnode) {
/** @var DomElement $subnode */
$baseurl = $subnode->getAttribute('baseurl');
// Insert/Update the defaults for an entry in the database.
// These are always global pages.
$m = new PageModel(-1, $baseurl);
if($verbosity == 2){
CLI::PrintActionStart($overallAction . ' page ' . $baseurl);
}
// Hard-set pages get removed upon disabling. They'll be recreated if re-enabled.
if($install){
// Just something to help the log.
$action = ($m->exists()) ? 'Updated' : 'Added';
$admin = $subnode->getAttribute('admin');
$selectable = ($admin ? '0' : '1'); // Defaults
$group = ($admin ? $subnode->getAttribute('group') : '');
if($subnode->getAttribute('selectable') !== ''){
$selectable = $subnode->getAttribute('selectable');
}
$indexable = ($subnode->getAttribute('indexable') !== '') ? $subnode->getAttribute('indexable') : $selectable;
$editurl = $subnode->getAttribute('editurl') ? $subnode->getAttribute('editurl') : '';
$access = ($subnode->getAttribute('access')) ? $subnode->getAttribute('access') : null;
// Do not "update" value, keep whatever the user set previously.
if (!$m->get('rewriteurl')) {
if ($subnode->getAttribute('rewriteurl')) $m->set('rewriteurl', $subnode->getAttribute('rewriteurl'));
else $m->set('rewriteurl', $subnode->getAttribute('baseurl'));
}
// Do not "update" value, keep whatever the user set previously.
if (!$m->get('title')) $m->set('title', $subnode->getAttribute('title'));
if($access !== null){
$m->set('access', $access);
}
// Do not update parent urls if the page already exists.
if(!$m->exists()) $m->set('parenturl', $subnode->getAttribute('parenturl'));
//$m->set('widget', $subnode->getAttribute('widget'));
$m->set('admin', $admin);
$m->set('admin_group', $group);
$m->set('selectable', $selectable);
$m->set('indexable', $indexable);
$m->set('component', $this->getKeyName());
$m->set('editurl', $editurl);
if ($m->save()){
$changes[] = $action . ' page [' . $baseurl . ']';
if($verbosity == 2){
CLI::PrintActionStatus(true);
}
}
else{
if($verbosity == 2){
CLI::PrintActionStatus('skip');
}
}
}
else{
$m->delete();
$changes[] = 'Removed page [' . $subnode->getAttribute('baseurl') . ']';
if($verbosity == 2){
CLI::PrintActionStatus(true);
}
}
}
return ($changes > 0) ? $changes : false;
}
