AS1024
/
Kanboard-Prod
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add metadata for users, tasks and projects

This commit is contained in:
Frederic Guillot 2015-10-17 15:27:43 -04:00
parent 9153c6ff0d
commit 9283fb88d8
15 changed files with 553 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ChangeLog
View File

@ -15,6 +15,7 @@ Improvements:
* Allow to change comments sorting
* Add the possibility to append or not custom filters
* Make mail transports pluggable
* Add Task, User and Project metadata for plugin creators
Version 1.0.19
--------------

68
app/Model/Config.php
View File

@ -12,15 +12,8 @@ use Kanboard\Core\Session;
* @package model
* @author Frederic Guillot
*/
class Config extends Base
class Config extends Setting
{
/**
* SQL table name
*
* @var string
*/
const TABLE = 'settings';
/**
* Get available currencies
*
@ -170,8 +163,7 @@ class Config extends Base
public function get($name, $default_value = '')
{
if (! Session::isOpen()) {
$value = $this->db->table(self::TABLE)->eq('option', $name)->findOneColumn('value');
return $value ?: $default_value;
return $this->getOption($name, $default_value);
}
// Cache config in session
@ -186,43 +178,6 @@ class Config extends Base
return $default_value;
}
/**
* Get all settings
*
* @access public
* @return array
*/
public function getAll()
{
return $this->db->hashtable(self::TABLE)->getAll('option', 'value');
}
/**
* Save settings in the database
*
* @access public
* @param $values array Settings values
* @return boolean
*/
public function save(array $values)
{
foreach ($values as $option => $value) {
// Be sure that a trailing slash is there for the url
if ($option === 'application_url' && ! empty($value) && substr($value, -1) !== '/') {
$value .= '/';
}
$result = $this->db->table(self::TABLE)->eq('option', $option)->update(array('value' => $value));
if (! $result) {
return false;
}
}
return true;
}
/**
* Reload settings in the session and the translations
*
@ -310,8 +265,21 @@ class Config extends Base
*/
public function regenerateToken($option)
{
return $this->db->table(self::TABLE)
->eq('option', $option)
->update(array('value' => Security::generateToken()));
$this->save(array($option => Security::generateToken()));
}
/**
* Prepare data before save
*
* @access public
* @return array
*/
public function prepare(array $values)
{
if (! empty($values['application_url']) && substr($values['application_url'], -1) !== '/') {
$values['application_url'] = $values['application_url'].'/';
}
return $values;
}
}

98
app/Model/Metadata.php Normal file
View File

@ -0,0 +1,98 @@
<?php
namespace Kanboard\Model;
/**
* Metadata
*
* @package model
* @author Frederic Guillot
*/
abstract class Metadata extends Base
{
/**
* Define the entity key
*
* @abstract
* @access protected
* @return string
*/
abstract protected function getEntityKey();
/**
* Get all metadata for the entity
*
* @access public
* @param integer $entity_id
* @return array
*/
public function getAll($entity_id)
{
return $this->db
->hashtable(static::TABLE)
->eq($this->getEntityKey(), $entity_id)
->asc('name')
->getAll('name', 'value');
}
/**
* Get a metadata for the given entity
*
* @access public
* @param integer $entity_id
* @param string $name
* @param string $default
* @return mixed
*/
public function get($entity_id, $name, $default = '')
{
return $this->db
->table(static::TABLE)
->eq($this->getEntityKey(), $entity_id)
->eq('name', $name)
->findOneColumn('value') ?: $default;
}
/**
* Return true if a metadata exists
*
* @access public
* @param integer $entity_id
* @param string $name
* @return boolean
*/
public function exists($entity_id, $name)
{
return $this->db
->table(static::TABLE)
->eq($this->getEntityKey(), $entity_id)
->eq('name', $name)
->exists();
}
/**
* Update or insert new metadata
*
* @access public
* @param integer $entity_id
* @param array $values
*/
public function save($entity_id, array $values)
{
$results = array();
$this->db->startTransaction();
foreach ($values as $key => $value) {
if ($this->exists($entity_id, $key)) {
$results[] = $this->db->table(static::TABLE)->eq($this->getEntityKey(), $entity_id)->eq('name', $key)->update(array('value' => $value));
} else {
$results[] = $this->db->table(static::TABLE)->insert(array('name' => $key, 'value' => $value, $this->getEntityKey() => $entity_id));
}
}
$this->db->closeTransaction();
return ! in_array(false, $results, true);
}
}

30
app/Model/ProjectMetadata.php Normal file
View File

@ -0,0 +1,30 @@
<?php
namespace Kanboard\Model;
/**
* Project Metadata
*
* @package model
* @author Frederic Guillot
*/
class ProjectMetadata extends Metadata
{
/**
* SQL table name
*
* @var string
*/
const TABLE = 'project_has_metadata';
/**
* Define the entity key
*
* @access protected
* @return string
*/
protected function getEntityKey()
{
return 'project_id';
}
}

96
app/Model/Setting.php Normal file
View File

@ -0,0 +1,96 @@
<?php
namespace Kanboard\Model;
/**
* Application Settings
*
* @package model
* @author Frederic Guillot
*/
abstract class Setting extends Base
{
/**
* SQL table name
*
* @var string
*/
const TABLE = 'settings';
/**
* Prepare data before save
*
* @abstract
* @access public
* @return array
*/
abstract public function prepare(array $values);
/**
* Get all settings
*
* @access public
* @return array
*/
public function getAll()
{
return $this->db->hashtable(self::TABLE)->getAll('option', 'value');
}
/**
* Get a setting value
*
* @access public
* @param string $name
* @param string $default
* @return mixed
*/
public function getOption($name, $default = '')
{
return $this->db
->table(self::TABLE)
->eq('option', $name)
->findOneColumn('value') ?: $default;
}
/**
* Return true if a setting exists
*
* @access public
* @param string $name
* @return boolean
*/
public function exists($name)
{
return $this->db
->table(self::TABLE)
->eq('option', $name)
->exists();
}
/**
* Update or insert new settings
*
* @access public
* @param array $values
*/
public function save(array $values)
{
$results = array();
$values = $this->prepare($values);
$this->db->startTransaction();
foreach ($values as $option => $value) {
if ($this->exists($option)) {
$results[] = $this->db->table(self::TABLE)->eq('option', $option)->update(array('value' => $value));
} else {
$results[] = $this->db->table(self::TABLE)->insert(array('option' => $option, 'value' => $value));
}
}
$this->db->closeTransaction();
return ! in_array(false, $results, true);
}
}

30
app/Model/TaskMetadata.php Normal file
View File

@ -0,0 +1,30 @@
<?php
namespace Kanboard\Model;
/**
* Task Metadata
*
* @package model
* @author Frederic Guillot
*/
class TaskMetadata extends Metadata
{
/**
* SQL table name
*
* @var string
*/
const TABLE = 'task_has_metadata';
/**
* Define the entity key
*
* @access protected
* @return string
*/
protected function getEntityKey()
{
return 'task_id';
}
}

30
app/Model/UserMetadata.php Normal file
View File

@ -0,0 +1,30 @@
<?php
namespace Kanboard\Model;
/**
* User Metadata
*
* @package model
* @author Frederic Guillot
*/
class UserMetadata extends Metadata
{
/**
* SQL table name
*
* @var string
*/
const TABLE = 'user_has_metadata';
/**
* Define the entity key
*
* @access protected
* @return string
*/
protected function getEntityKey()
{
return 'user_id';
}
}

37
app/Schema/Mysql.php
View File

@ -6,7 +6,40 @@ use PDO;
use Kanboard\Core\Security;
use Kanboard\Model\Link;
const VERSION = 92;
const VERSION = 93;
function version_93($pdo)
{
$pdo->exec("
CREATE TABLE user_has_metadata (
user_id INT NOT NULL,
name VARCHAR(50) NOT NULL,
value VARCHAR(255) DEFAULT '',
FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
UNIQUE(user_id, name)
) ENGINE=InnoDB CHARSET=utf8
");
$pdo->exec("
CREATE TABLE project_has_metadata (
project_id INT NOT NULL,
name VARCHAR(50) NOT NULL,
value VARCHAR(255) DEFAULT '',
FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE,
UNIQUE(project_id, name)
) ENGINE=InnoDB CHARSET=utf8
");
$pdo->exec("
CREATE TABLE task_has_metadata (
task_id INT NOT NULL,
name VARCHAR(50) NOT NULL,
value VARCHAR(255) DEFAULT '',
FOREIGN KEY(task_id) REFERENCES tasks(id) ON DELETE CASCADE,
UNIQUE(task_id, name)
) ENGINE=InnoDB CHARSET=utf8
");
}
function version_92($pdo)
{
@ -14,7 +47,7 @@ function version_92($pdo)
CREATE TABLE project_has_notification_types (
id INT NOT NULL AUTO_INCREMENT,
project_id INT NOT NULL,
notification_type VARCHAR(50),
notification_type VARCHAR(50) NOT NULL,
PRIMARY KEY(id),
FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE
UNIQUE(project_id, notification_type),

37
app/Schema/Postgres.php
View File

@ -6,7 +6,40 @@ use PDO;
use Kanboard\Core\Security;
use Kanboard\Model\Link;
const VERSION = 72;
const VERSION = 73;
function version_73($pdo)
{
$pdo->exec("
CREATE TABLE user_has_metadata (
user_id INTEGER NOT NULL,
name VARCHAR(50) NOT NULL,
value VARCHAR(255) DEFAULT '',
FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
UNIQUE(user_id, name)
)
");
$pdo->exec("
CREATE TABLE project_has_metadata (
project_id INTEGER NOT NULL,
name VARCHAR(50) NOT NULL,
value VARCHAR(255) DEFAULT '',
FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE,
UNIQUE(project_id, name)
)
");
$pdo->exec("
CREATE TABLE task_has_metadata (
task_id INTEGER NOT NULL,
name VARCHAR(50) NOT NULL,
value VARCHAR(255) DEFAULT '',
FOREIGN KEY(task_id) REFERENCES tasks(id) ON DELETE CASCADE,
UNIQUE(task_id, name)
)
");
}
function version_72($pdo)
{
@ -14,7 +47,7 @@ function version_72($pdo)
CREATE TABLE project_has_notification_types (
id SERIAL PRIMARY KEY,
project_id INTEGER NOT NULL,
notification_type VARCHAR(50),
notification_type VARCHAR(50) NOT NULL,
FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE,
UNIQUE(project_id, notification_type)
)

37
app/Schema/Sqlite.php
View File

@ -6,7 +6,40 @@ use Kanboard\Core\Security;
use PDO;
use Kanboard\Model\Link;
const VERSION = 87;
const VERSION = 88;
function version_88($pdo)
{
$pdo->exec("
CREATE TABLE user_has_metadata (
user_id INTEGER NOT NULL,
name TEXT NOT NULL,
value TEXT DEFAULT '',
FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
UNIQUE(user_id, name)
)
");
$pdo->exec("
CREATE TABLE project_has_metadata (
project_id INTEGER NOT NULL,
name TEXT NOT NULL,
value TEXT DEFAULT '',
FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE,
UNIQUE(project_id, name)
)
");
$pdo->exec("
CREATE TABLE task_has_metadata (
task_id INTEGER NOT NULL,
name TEXT NOT NULL,
value TEXT DEFAULT '',
FOREIGN KEY(task_id) REFERENCES tasks(id) ON DELETE CASCADE,
UNIQUE(task_id, name)
)
");
}
function version_87($pdo)
{
@ -14,7 +47,7 @@ function version_87($pdo)
CREATE TABLE project_has_notification_types (
id INTEGER PRIMARY KEY,
project_id INTEGER NOT NULL,
notification_type TEXT,
notification_type TEXT NOT NULL,
FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE,
UNIQUE(project_id, notification_type)
)

3
app/ServiceProvider/ClassProvider.php
View File

@ -41,6 +41,7 @@ class ClassProvider implements ServiceProviderInterface
'ProjectIntegration',
'ProjectPermission',
'ProjectNotification',
'ProjectMetadata',
'Subtask',
'SubtaskExport',
'SubtaskTimeTracking',
@ -59,6 +60,7 @@ class ClassProvider implements ServiceProviderInterface
'TaskStatus',
'TaskValidator',
'TaskImport',
'TaskMetadata',
'Transition',
'User',
'UserImport',
@ -67,6 +69,7 @@ class ClassProvider implements ServiceProviderInterface
'UserNotificationType',
'UserNotificationFilter',
'UserUnreadNotification',
'UserMetadata',
),
'Formatter' => array(
'TaskFilterGanttFormatter',

25
tests/units/Model/ConfigTest.php
View File

@ -7,6 +7,31 @@ use Kanboard\Core\Session;
class ConfigTest extends Base
{
public function testCRUDOperations()
{
$c = new Config($this->container);
$this->assertTrue($c->save(array('key1' => 'value1')));
$this->assertTrue($c->save(array('key1' => 'value2')));
$this->assertTrue($c->save(array('key2' => 'value2')));
$this->assertEquals('value2', $c->getOption('key1'));
$this->assertEquals('value2', $c->getOption('key2'));
$this->assertEquals('', $c->getOption('key3'));
$this->assertEquals('default', $c->getOption('key3', 'default'));
$this->assertTrue($c->exists('key1'));
$this->assertFalse($c->exists('key3'));
$this->assertTrue($c->save(array('key1' => 'value1')));
$this->assertArrayHasKey('key1', $c->getAll());
$this->assertArrayHasKey('key2', $c->getAll());
$this->assertContains('value1', $c->getAll());
$this->assertContains('value2', $c->getAll());
}
public function testSaveApplicationUrl()
{
$c = new Config($this->container);

47
tests/units/Model/ProjectMetadataTest.php Normal file
View File

@ -0,0 +1,47 @@
<?php
require_once __DIR__.'/../Base.php';
use Kanboard\Model\Project;
use Kanboard\Model\ProjectMetadata;
class ProjectMetadataTest extends Base
{
public function testOperations()
{
$p = new Project($this->container);
$pm = new ProjectMetadata($this->container);
$this->assertEquals(1, $p->create(array('name' => 'project #1')));
$this->assertEquals(2, $p->create(array('name' => 'project #2')));
$this->assertTrue($pm->save(1, array('key1' => 'value1')));
$this->assertTrue($pm->save(1, array('key1' => 'value2')));
$this->assertTrue($pm->save(2, array('key1' => 'value1')));
$this->assertTrue($pm->save(2, array('key2' => 'value2')));
$this->assertEquals('value2', $pm->get(1, 'key1'));
$this->assertEquals('value1', $pm->get(2, 'key1'));
$this->assertEquals('', $pm->get(2, 'key3'));
$this->assertEquals('default', $pm->get(2, 'key3', 'default'));
$this->assertTrue($pm->exists(2, 'key1'));
$this->assertFalse($pm->exists(2, 'key3'));
$this->assertEquals(array('key1' => 'value2'), $pm->getAll(1));
$this->assertEquals(array('key1' => 'value1', 'key2' => 'value2'), $pm->getAll(2));
}
public function testAutomaticRemove()
{
$p = new Project($this->container);
$pm = new ProjectMetadata($this->container);
$this->assertEquals(1, $p->create(array('name' => 'project #1')));
$this->assertTrue($pm->save(1, array('key1' => 'value1')));
$this->assertTrue($pm->exists(1, 'key1'));
$this->assertTrue($p->remove(1));
$this->assertFalse($pm->exists(1, 'key1'));
}
}

37
tests/units/Model/TaskMetadataTest.php Normal file
View File

@ -0,0 +1,37 @@
<?php
require_once __DIR__.'/../Base.php';
use Kanboard\Model\Project;
use Kanboard\Model\TaskCreation;
use Kanboard\Model\TaskMetadata;
class TaskMetadataTest extends Base
{
public function testOperations()
{
$p = new Project($this->container);
$tm = new TaskMetadata($this->container);
$tc = new TaskCreation($this->container);
$this->assertEquals(1, $p->create(array('name' => 'project #1')));
$this->assertEquals(1, $tc->create(array('title' => 'task #1', 'project_id' => 1)));
$this->assertEquals(2, $tc->create(array('title' => 'task #2', 'project_id' => 1)));
$this->assertTrue($tm->save(1, array('key1' => 'value1')));
$this->assertTrue($tm->save(1, array('key1' => 'value2')));
$this->assertTrue($tm->save(2, array('key1' => 'value1')));
$this->assertTrue($tm->save(2, array('key2' => 'value2')));
$this->assertEquals('value2', $tm->get(1, 'key1'));
$this->assertEquals('value1', $tm->get(2, 'key1'));
$this->assertEquals('', $tm->get(2, 'key3'));
$this->assertEquals('default', $tm->get(2, 'key3', 'default'));
$this->assertTrue($tm->exists(2, 'key1'));
$this->assertFalse($tm->exists(2, 'key3'));
$this->assertEquals(array('key1' => 'value2'), $tm->getAll(1));
$this->assertEquals(array('key1' => 'value1', 'key2' => 'value2'), $tm->getAll(2));
}
}

33
tests/units/Model/UserMetadataTest.php Normal file
View File

@ -0,0 +1,33 @@
<?php
require_once __DIR__.'/../Base.php';
use Kanboard\Model\User;
use Kanboard\Model\UserMetadata;
class UserMetadataTest extends Base
{
public function testOperations()
{
$m = new UserMetadata($this->container);
$u = new User($this->container);
$this->assertEquals(2, $u->create(array('username' => 'foobar')));
$this->assertTrue($m->save(1, array('key1' => 'value1')));
$this->assertTrue($m->save(1, array('key1' => 'value2')));
$this->assertTrue($m->save(2, array('key1' => 'value1')));
$this->assertTrue($m->save(2, array('key2' => 'value2')));
$this->assertEquals('value2', $m->get(1, 'key1'));
$this->assertEquals('value1', $m->get(2, 'key1'));
$this->assertEquals('', $m->get(2, 'key3'));
$this->assertEquals('default', $m->get(2, 'key3', 'default'));
$this->assertTrue($m->exists(2, 'key1'));
$this->assertFalse($m->exists(2, 'key3'));
$this->assertEquals(array('key1' => 'value2'), $m->getAll(1));
$this->assertEquals(array('key1' => 'value1', 'key2' => 'value2'), $m->getAll(2));
}
}