voodoophp/voodorm

VoodOrm 是一个微型 ORM，它既是一个流畅的查询 API，也是一个 CRUD 模型类。

维护者

详细信息

github.com/mardix/VoodOrm

主页

源代码

问题

安装量: 10,473

依赖项: 1

建议者: 0

安全性: 0

星标: 49

关注者: 11

分支: 11

开放问题: 6

2.1.0 2014-02-13 05:05 UTC

Requires

  • php: >=5.4.0

MIT 61d18f373a6e600aa54b39f2fcdc8f2f1cc68f66

ormmysqlsqlitepostgresqlpdofluent query

This package is not auto-updated.

Last update: 2024-09-14 13:23:17 UTC

README

一个简单且不干扰你的微型 ORM

名称: VoodOrm

许可证: MIT

作者: Mardix

版本: 2.x.x

要求: PHP >= 5.4, PDO

关于 Voodoo!

VoodOrm 是一个微型 ORM，它既是一个流畅的查询 API，也是一个 CRUD 模型类。

VoodOrm 建立在 PDO 之上，非常适合小型到中型项目，这些项目的重点是简洁和快速开发，而不是无限的灵活性和功能。VoodOrm 与表关系工作得很好，并提供获取 SQL 的 API

特性

  • PDO 和预处理语句
  • 流畅查询
  • 关系
  • 连接
  • 聚合
  • 查询调试器和查询分析器
  • Active Record 模式

要求

  • PHP >= 5.4
  • PDO

错误报告

VoodOrm 不会提升错误。不存在的表会产生 SQL 错误，该错误由 PDO 根据 PDO::ATTR_ERRMODE 报告。不存在的列会产生与尝试访问数组中不存在的键相同的 E_NOTICE

它不做的事情。

我们认为最好将某些事情留给开发者去做，例如缓存或数据验证。此外，数据验证也可以在数据库级别进行。

  • 无模型或实体生成
  • 无数据验证
  • 无缓存
  • 无数据库迁移

安装 VoodOrm

您可以直接下载 VoodOrm，也可以使用 Composer。

要使用 Composer 安装，请将以下内容添加到您的 composer.json 文件的 require 键中

"voodoophp/voodorm": "2.*"

composer.json

{
    "name": "voodoophp/myapp",
    "description": "My awesome Voodoo App",
    "require": {
        "voodoophp/voodorm": "2.*"
    }
}

使用 VoodOrm

new VoodOrm( PDO $pdo )

要开始使用 VoodOrm，您必须设置 PDO 连接。在本教程中，我们将使用变量 $DB 作为数据库连接，$users 作为表，$friends 作为另一个表

$pdo = new PDO("mysql:host=localhost;dbname=$dbname", $username, $password);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$DB = new VoodOrm($pdo);

VoodOrm VoodOrm::table( string $tablename )

要连接到表，只需调用方法 VoodOrm::table()

$users = $DB->table('users');

您还可以通过调用表作为方法来设置表。上面的代码也可以写成这样

$users = $DB->users();
$friends = $DB->friends();

从那里开始，您将能够使用 VoodOrm 流畅查询界面对该表进行任何 CRUD 操作

##数据修改

VoodOrm 支持数据修改（插入、更新和删除）。VoodOrm 不会执行数据验证，但所有数据库错误都会通过标准的 PDO 错误报告来报告。对于数据验证，我们认为最好在数据库级别或应用程序级别进行数据验证

mixed VoodOrm::insert( Array $data )

要向表中插入数据，请使用 insert(Array $data)，其中 $data 可以是一个一维数组以插入单个条目，也可以是多个数组以进行批量插入。

如果插入了一条单行记录，它将返回创建的对象的活跃记录。否则，它将返回插入的总条目数

对于单个条目

$user = $users->insert(array(
	 			"name" => "Mardix",
				"age" => 30, 
	 			"city" => "Charlotte",
     			"state" => "NC",
				"device" => "mobile",
	 			"timestamp" => $DB->NOW()
			));

返回此条目的 VoodOrm 活跃记录实例，您可以使用 $user->name 或 $user->city。我们稍后会做更多操作。

对于批量插入

$massInserts = $users->insert(array(
					array(
						 "name" => "Mardix",
						 "city" => "Charlotte",
					     "state" => "NC",
					     "device" => "mobile",
						 "timestamp" => $DB->NOW()
					),
					array(
						 "name" => "Cesar",
						 "city" => "Atlanta",
					     "state" => "GA",
						 "device" => "mobile",
						 "timestamp" => $DB->NOW()
					),
					array(
						 "name" => "Gaga",
						 "city" => "Port-au-Prince",
					     "state" => "HT",
						 "device" => "computer",
						 "timestamp" => $DB->NOW()
					),
				));

返回插入的总条目数

混合的 VoodOrm::update(Array $data)

在 VoodOrm 中更新条目有两种方式，1) 使用已检索行的活动记录模式，或 2) 使用 where 查询来指定更新位置。此外，方法 VoodOrm::set($key, $value) 也可以用于在更新之前设置数据。

对于单个条目

$user->update(array(
					"city" => "Raleigh"
				));

与以下相同

$user->city = "Raleigh";
$user->update();

您也可以使用 save() 代替 update()

$user->save();

或使用 Voodoo::set(Array $data) 或 Voodoo::set($key, $value)

$user->set('city','Raleigh')->update();

对于多个条目

对于多个条目，我们将使用 VoodOrm::set() 和 VoodOrm::where() 来指定更新位置。

Voodoo::set(Array $data) 或 Voodoo::set($key, $value)

对于批量更新，我们将使用 set(Array $data) 和 where($k, $v) 来设置要更新的数据。

$user->set(array(
				"country_code" => "US"
		))
		->where("device", "mobile")
		->update();

*在流畅查询接口下还有更多流畅的 where 别名

混合的 VoodOrm::save()

save() 是 VoodOrm::insert() 或 VoodOrm::update() 的快捷方式

要插入新数据

$user = $DB->users();
$user->name = "Mardix";
$user->city = "Charlotte";
$user->save();

要更新

$user = $users->findOne(123456);
$user->city = "Atlanta";
$user->save();

int VoodOrm::delete()

要删除条目，我们将使用 VoodOrm::delete() 方法

对于单个条目，通过调用 delete() 方法将删除当前条目

$user = $users->reset()->findOne(1234);
$user->delete();

对于多个条目，我们将使用 VoodOrm::where() 方法来指定删除位置

$users->where("city", "Charlotte")->delete();

聚合

VoodOrm 提供了对您表上聚合方法的访问

int VoodOrm::count()

根据 where 子句计算所有条目

$allUsers = $users->count();

$count = $voodorm->where($x, $y)->count();

或对于特定的列名

$count = $users->where($x, $y)->count($columnName);

float VoodOrm::max( string $columnName )

根据 where 子句获取 $columnName 的最大值

$max = $users->where($x, $y)->max($columnName);

float VoodOrm::min( string $columnName )

根据 where 子句获取 $columnName 的最小值

$min = $users->where($x, $y)->min($columnName);

float VoodOrm::sum( string $columnName )

根据 where 子句获取 $columnName 的总和

$sum = $users->where($x, $y)->sum($columnName);

float VoodOrm::avg( string $columnName )

根据 where 子句获取 $columnName 的平均值

$avg = $users->where($x, $y)->avg($columnName);

mixed VoodOrm::aggregate( string $function )

运行任何聚合函数

$agg = $users->where($x, $y)->aggregate('GROUP_CONCAT $columnName');

查询

VoodOrm 提供了一个流畅的接口，可以构建简单的查询，而无需写入任何 SQL 字符。

两种方法允许您获取单个条目或多个条目： findOne() 和 find()。还有 fromArray()，它将原始数据加载到对象中。

FindOne

VoodOrm VoodOrm::findOne()

findOne() 如果找到，则返回单个条目的 VoodOrm 实例，否则返回 FALSE。

$user = $users->where('id', 1234)
			  ->findOne();

可以在 findOne(int $primaryKey) 中设置主键来获取与上述查询相同的结果。这意味着不需要 where 子句。

$user = $users->findOne(1234);

让我们获取找到的条目

if ($user) {
	echo " Hello $user->name!";

// On a retrieved entry you can perform update and delete
	$user->last_viewed = $users->NOW();
	$suer->save();
}

Find

ArrayIterator VoodOrm::find()

find() 返回一个找到的行的 ArrayIterator，这些行是 VoodOrm 的实例，否则返回 False。

$allUsers = $users->where('gender', 'male')
				  ->find();

foreach ($allUsers as $user) {
	echo "{$user->name}";

// On a retrieved entry you can perform update and delete
	$user->last_viewed = $users->NOW();
	$user->save();
}

find() 在迭代调用时也包含一个快捷方式，如 foreach

$allUsers = $users->where('gender', 'male');

foreach ($allUsers as $user) {
	echo "{$user->name}";

// On a retrieved entry you can perform update and delete
	$user->last_viewed = $users->NOW();
	$suer->save();
}

mixed VoodOrm::find( Closure $callback )

VoodOrm::find() 还接受一个闭包作为回调来执行自己的数据操作。在执行时，VoodOrm 将查询中找到的数据传递给闭包函数。

	$users->where('gender', 'male');

	$results = $users->find(function($data){
		$newResults = array();

		foreach ($data as $d) {
			$d["full_name"] = ucwords("{$data["first_name"]} {$data["last_name"]}");
			$newResults[] = $d;
		}

		return $newResults;
	});

FromArray

VoodOrm VoodOrm::fromArray( Array $data )

与 find() 和 findOne() 不同，它们会向数据库查询以检索数据，fromArray() 加载原始数据并将其作为 VoodOrm 对象返回。这些数据可以是缓存在 Redis/Memcached 中的数据，但不是直接来自数据库的数据。

$data = [
		"id" => 916,
		"name" => "Jose",
		"last_name" => "Martinez"
		];

$anotherUser = $users->fromArray($data);

现在您可以对其进行操作

$anotherUse->update(
					["name" => "Yolo"]
				);

流畅查询构建器

Select

VoodOrm VoodOrm::select( $columns = '*' )

选择表中的字段。如果省略，VoodOrm 将获取所有列。

$users->select()

或选择指定列

$users->select("name, age")
		->select("last_viewed");

> SELECT name, age, last_viewed

Where

Where 允许您为查询设置 Where 条件。下面您将找到许多 where 的别名。

Where 条件与 VoodOrm::find()、VoodOrm::findOne()、VoodOrm::update() 和 VoodOrm::delete()` 一起使用。

重复调用 where 或任何 where 别名将使用 AND 操作符将 Where 条件附加到之前的 Where 条件。要使用 OR 操作符，必须调用 VoodOrm::_or()。更多内容见下文。

VoodOrm VoodOrm::where( $condition $parameters = array() )

这是主要的 where。它负责所有的 Where 条件。

$condition 是要使用的条件。它可以包含 ? 或 :name，由 PDO 绑定到 $parameters（因此不需要手动转义）。

$parameters 是绑定到条件的值（值）。它可以是一个数组、一个关联数组或零个或多个标量。

一些示例

$users->where("name", "Mardix");
WHERE name = ?

$users->where("age > ?", 25);
WHERE age > ?

$users->where("name in (?, ?, ?)", "Mike", "Jones", "Rich");
WHERE name IN (?, ?, ?)

$users->where("(field1, field2)", array(array(1, 2), array(3, 4)))
WHERE (field1, field2) IN ((?, ?), (?, ?))

但要方便完成任务，VoodOrm 为一些常见操作提供了别名。

VoodOrm VoodOrm::wherePK( int $primaryKey )

当主键被设置时，例如 $users->wherePK(1234);

VoodOrm VoodOrm::whereNot( $columnName, $value )

$users->whereNot('age', 24);

WHERE age != ?

VoodOrm VoodOrm::whereLike( $columnName, $value )

$users->whereLike('name', 'w%');

WHERE name LIKE ?

VoodOrm VoodOrm::whereNotLike( $columnName, $value )

$users->whereNotLike('name', 'r%');

WHERE name NOT LIKE ?

VoodOrm VoodOrm::whereGt( $columnName, $value )

$users->whereGt('age', 21);

WHERE age > ?

VoodOrm VoodOrm::whereGte( $columnName, $value )

$users->whereGte('age', 21);

WHERE age >= ?

VoodOrm VoodOrm::whereLt( $columnName, $value )

$users->whereLt('age', 21);

WHERE age < ?

VoodOrm VoodOrm::whereLte( $columnName, $value )

$users->whereLte('age', 21);

WHERE age <= ?

VoodOrm VoodOrm::whereIn( $columnName, Array $value )

$users->whereIn('city', array('Charlotte', 'Atlanta'));

WHERE city IN (?,?)

VoodOrm VoodOrm::whereNotIn( $columnName, Array $value )

$users->whereNotIn('city', array('Chicago', 'Miami'));

WHERE city NOT IN (?,?)

VoodOrm VoodOrm::whereNull( $columnName )

$users->whereNull('city');

WHERE city IS NULL

VoodOrm VoodOrm::whereNotNull( $columnName )

$users->whereNotNull('name');

WHERE city NOT NULL

使用 OR 和 AND 的 Where

构建查询时，您希望在 Where 条件中添加 AND 和 OR 操作符。为此，请使用与任何 where 别名连接的 VoodOrm::_and() 和 VoodOrm::_or()。

VoodOrm VoodOrm::_and()

在 Where 查询中添加 AND 操作符。默认情况下，如果未调用 _and()，VoodOrm 将默认添加它。

$users->where("city", "Charlotte")->_and()->whereGte("age", 21);

WHERE city = ? AND age >= ?

VoodOrm VoodOrm::_or()

在 Where 查询中添加 OR 操作符。

$users->where("city", "Charlotte")->_or()->whereGte("age", 21)->_or()->where("gender", "female");

WHERE city = ? OR age >= ? OR gender = ?

使用 Wrap() 的 Where

在构建包含多个 Where 组的复杂查询时，VoodOrm::wrap() 将 Where 条件分组在一起，用括号括起来。

VoodOrm VoodOrm::wrap()

$users->where("city", "Charlotte")->whereGte("age", 21)->wrap()
	  ->where("gender", "female")->where("city", "Atlanta");

WHERE (city = ? AND age >= ?) AND (gender = ? AND city = ?)

VoodOrm VoodOrm::wrap()->_and()

wrap()->_and() 使用 AND 操作符与另一个分组 Where 进行合并。

$users->where("city", "Charlotte")->whereGte("age", 21)->wrap()->_and()
	  ->where("gender", "female")->where("city", "Atlanta");

WHERE (city = ? AND age >= ?) AND (gender = ? AND city = ?)

VoodOrm VoodOrm::wrap()->_or()

wrap()->_or() 使用 OR 操作符与另一个分组 Where 进行合并。

$users->where("city", "Charlotte")->whereGte("age", 21)->wrap()->_or()
	  ->where("gender", "female")->where("city", "Atlanta");

WHERE (city = ? AND age >= ?) OR (gender = ? AND city = ?)

同一查询中的 wrap()->_and() 和 wrap()->_or()

$users->where("id",1)->where("city","charlotte")->wrap()
      ->where("gender","female")->where("country","US")->wrap()
      ->_or()->where("city",array("Charlotte","Atlanta"))->wrap()
      ->_or()->whereLt('age',21)->whereGte("name","Mardix")->wrap();

WHERE (id = ? AND city = ?) 
	  AND (gender = ? AND country = ?) 
      OR ((city IN (?, ?))) 
      OR (age < ? AND name >= ?)

排序、分组、限制、偏移

VoodOrm VoodOrm::orderBy( $columnName, $ordering )

$users->orderBy('name', 'DESC');

ORDER BY name DESC

VoodOrm VoodOrm::groupBy( $columnName )

$users->groupBy('city');

GROUP BY city

VoodOrm VoodOrm::limit( int $limit )

$users->limit(10);

LIMIT 10

VoodOrm VoodOrm::offset( int $offset )

$users->offset(10);

OFFSET 10

连接

VoodOrm VoodOrm::join( $tablename, $constraint, $table_alias , $join_operator )

$users->join('friends', 'f.user_id = u.id', 'f')

JOIN friends AS f ON f.user_id = u.id

VoodOrm VoodOrm::leftJoin( $tablename, $constraint, $table_alias )

$users->leftJoin('friends', 'f.user_id = u.id', 'f')

LEFT JOIN friends AS f ON f.user_id = u.id

关系

这就是杀手锏！

VoodOrm的杀手级特性之一是关系。通过将一个表作为对象上的方法调用，默认情况下会在该引用表上自动创建一个一对多关系。

在这个例子中，我们将有两个表：user（id，姓名，出生日期）和friend（id，user_id，friend_id）

friend.user_id是user表的键外键。而friend.friend_id是朋友user.id的外键。

让我们获取所有用户及其朋友

$allUsers = $users->find();

foreach ($allUsers as $user) {
    /**
    * Connect to the 'friend' table = $user->friend();
    * In the back, it does a ONE To MANY relationship 
    * SELECT * FROM friend WHERE friend.user_id = user.id 
    */
    $allFriends = $user->friend();
    foreach ($allFriends as $friend) {
        echo "{$friend->friend_id} : ";

        /**
        * We got the friend's entry, we want to go back in the user table
        * So we link back the friend table to the user table
        * SELECT * FROM user WHERE user.id = friend.friend_id LIMIT 1 
        * It will do a ONE to One relationship
        */
        echo $friend->user(Voodoo\VoodOrm::REL_HASONE, "friend_id")->name;

        echo "\n";
    }
}

// Same as above but with just one user
$user = $users->findOne($userId);
if($user) {

    foreach ($user->friend() as $friend) {

        echo "{$friend->friend_id} : ";

        echo $friend->user(Voodoo\VoodOrm::REL_HASONE, "friend_id")->name;

        echo "\n";
    }
}

这就是整体情况。将引用表作为对象上的方法调用将执行一个关系。

关系：一对多

一对多关系，在我们的用户和朋友案例中，是指一个用户可以有一个或多个朋友。但是每个friend.friend_id都与一个user.id相关联。这种关系将返回一个或多个条目。

user（单值）和friend（多值）之间的关系是一对多关系。

在我们上面的例子中，我们在朋友的表中执行了一对多关系

$allFriends = $user->friend();

关系常量

VoodOrm有预定义的常量，允许您选择执行关系类型

CONST::REL_HASMANY (2)

$allFriends = $user->friend(Voodoo\VoodOrm::REL_HASMANY);

这更快。它通过检索所有数据并将数据保持在内存中来进行预加载。它只执行一个查询。默认使用。

CONST::REL_LAZYMANY (-2)

$allFriends = $user->friend(Voodoo\VoodOrm::REL_LAZYMANY);

这较慢。它通过按需请求数据进行懒加载。它将执行1+N个查询。

关系：一对一

一对一关系在两个方向上都是单值的。在朋友表中，friend.friend_id与user.id相链接

$allFriends = $user->friend();

关系常量

CONST::REL_HASONE (1)

$friendUser = $friend->user(Voodoo\Core\VoodOrm::REL_HASONE, "friend_id");
echo $friendUser->name;

它通过检索所有数据并将数据保持在内存中来进行预加载。它只执行一个查询。默认使用。

CONST::REL_LAZYONE (-1)

$friendUser = $friend->user(Voodoo\VoodOrm::REL_LAZYONE, "friend_id");
echo $friendUser->name;

这较慢。它通过按需请求数据进行懒加载。它将执行1+N个查询。

关系：多对多

未实现。这个很复杂……找不到一个适合所有情况的案例...

关系参数

VoodOrm关系接受4种类型的参数，可以放置在任意位置

$user->friend(NUMBER, STRING, ARRAY, CALLBACK);

数字：通常是关系常量 REL_HASONE = 1，REL_LAZYONE = -1，RE_HASMANY = 2，REL_LAZYMANY = -2；

$user->friend(Voodoo\VoodOrm::REL_HASMANY);

字符串：将字符串作为参数使用时，将用作外键名称

$user->friend("friend_id");

数组：数组将用作WHERE条件。数组必须是与表字段匹配的键/值匹配

$user->friend(array(
	"friendship_start_time >= " => date("Y-m-d")
));

回调：回调是在结果上运行的函数

$user->friend(function($data){

	$tableData = array();

	foreach($data as $d) {
		$tableData[] = array_merge(
							$data,
							array("visits_count"=>$d[visits_count] + 1)
						); 
	}
	return $tableData;
});

现在进行拼凑！

$user->friend(Voodoo\VoodOrm::REL_HASONE, 

				"friend_id", 

				array("friendship_start_time >= " => date("Y-m-d"),

				function($data){
				
						$tableData = array();
				
						foreach($data as $d) {
							$tableData[] = array_merge(
												$data,
												array("visits_count"=>$d[visits_count] + 1)
											); 
						}
						return $tableData;
					}			
));



$user->friend(NUMBER, STRING, ARRAY, CALLBACK);

表结构

表结构允许在数据库中定义表结构。它在构造函数上设置

new VoodOrm($PDO, $primaryKey = 'id', $foreignKey = '%s_id')

PRIMARYKEY：默认设置为id，但可以是任何内容

FOREIGNKEY：是外键。默认设置为%s_id，其中%s是表名。所以一个user表，在朋友表中外键将是user_id

您还可以使用setStructure($primaryKey, $foreignKey)来设置结构。

$DB = new VoodOrm($PDO);
$DB->setStructure("id", "%s_id");

设置表结构很重要，这样VoodOrm可以识别关系的主键和外键。

其他方法

如下面的代码所示

$users = $DB->table('users');

string VoodOrm::getPrimaryKeyName()

$users->getPrimaryKeyName();

返回主键名称。大多数情况下将是id

string VoodOrm::getForeignKeyName()

$users->getForeignKeyName();

返回外键名称。根据上面的表结构，它将是user_id

string VoodOrm::getTableName()

返回表名

$tableName = $users->getTableName();

VoodOrm VoodOrm::tableAlias( string $alias )

将名称设置为表的别名

$users->tableAlias("user");

string VoodOrm::getTableAlias()

返回表别名名称

$alias = $users->getTableAlias();

Array VoodOrm::getStructure()

返回设置的结构

$structure = $users->getStructure();

Bool VoodOrm::isSingleRow()

如果条目是单行返回true或false

$user = $users->findOne(123);

if ($user->isSingleRow()) {
	// do something here
}

String VoodOrm::NOW()

它返回当前的日期时间：Y-M-D H:i:s

扩展VoodOrm到你的模型

以下是一个示例，说明如何在现实世界的应用中设置你的模型。我们将设置模型，并使用MVC应用程序的控制器来检索它们。该应用程序基于Voodoo，一个轻量级的模块化MVC框架。

Lib/Model/BaseModel.php

基本模型包含对数据库的连接，并可以添加额外的方法。BaseModel将在模型类中扩展

<?php

namespace Model;

use Voodoo;

abstract class BaseModel extends Voodoo\VoodOrm
{
	private static $pdo = null;

	// setup the DB connection
	public function __construct()
	{
		if (! self::$pdo) {
			self::$pdo = new PDO("mysql:host=localhost;dbname=$dbname", $username, $password);
		    self::$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);				
		}

		parent::__construct(self::$pdo);
        $instance = parent::table($this->tableName);
        $this->table_name = $instance->getTablename();			
	}
}

Lib/Model/Diskoteka/Artist.php

<?php

namespace Model\Diskoteka;

use Lib\Model;

class Artist extends Model\BaseModel
{
	protected $tableName = "artist";

	// We concat the first and last name
	public function getName()
	{
		return $this->first_name." ".$this->last_name; 
	}
}

Lib/Model/Diskoteka/Album.php

<?php

namespace Model\Diskoteka;

use Lib\Model;

class Album extends Model\BaseModel
{
	protected $tableName = "album";

	// Returns the VoodOrm object to do more in the query
	public function getSongs()
	{
		return (new Song)->where("album_id", $this->getPK());
	}
}

Lib/Model/Diskoteka/Song.php

<?php

namespace Model\Diskoteka;

use Lib\Model,
	Closure;

class Song extends Model\BaseModel
{
	protected $tableName = "song";

	public function getArtistName()
	{
		return $this->artist_first_name;
	}

	public function getAlbumTitle()
	{
		return $this->album_title;
	}

	// We modify the find() to join this table to album and artist tables
	public function find(Closure $callback = null) 
	{
		$this->tableAlias("song")
			->select("song.*")
			->select("album.title As album_title")
			->select("artist.first_name AS artist_first_name")
			->leftJoin(new Artist, "artist.id = song.artist_id", "artist")
			->leftJoin(new Album, "album.id = song.album_id", "album");

		retun parent::find($callback);
	}
}

App/Www/Main/Controller/Index.php

使用Voodoo，我们将创建一个控制器来使用模型

<?php

namespace App\Www\Main\Controller;

use Voodoo,
	Lib\Model\Diskoteka;

class Index extends Voodoo\Core\Controller
{
	/**
	 * List all songs, which will include the the artist name and album name
	 * http://the-url/
	 */
	public function actionIndex()
	{
		$allSongs = (new Diskoteka\Song);
		$allSongs->orderBy("title", "ASC");

		$songs = [];
		foreach ($allSongs as $song) {
			$songs[] = [
				"id" => $song->getPK()
				"title" => $song->title,
				"albumTitle" => $song->getAlbumTitle(),
				"artistName" => $song->getArtistName()
			];				
		}
		$this->view()->assign("songs", $songs);
	}

	/**
	 * Simply get the Artist info
	 * http://the-url/artist/59
	 */
	public function actionArtist()
	{
		$id = $this->getSegment(1); // -> 59
		$artist = (new Diskoteka\Artist)->findOne($id);	
		$countAlbums = (new Diskoteka\Album)
									->where("artist_id", $id)
									->count();

		$this->view()->assign([
			"name" => $artist->getName(),
			"countAlbums" => $countAlbums
		]);	
	}


	/**
	 * Get the song info, with album basic info
	 * http://the-url/song/1637
	 */
	public function actionSong()
	{
		$id = $this->getSegment(1); // -> 1637
		$song = (new Diskoteka\Song)->findOne($id);

		if ($song) {
			$this->view()->assign([
				"id" => $song->getPK()
				"title" => $song->title,
				"albumTitle" => $song->getAlbumTitle(),
				"artistName" => $song->getArtistName()
			]);
		}
	}

	/**
	 * Get the album info including all songs
	 * http://your-url.com/album/437
	 */
	public function actionAlbum()
	{
		$id = $this->getSegment(1);
		$album = (new Diskoteka\Album)->findOne($id);
		
		$allSongs = $album->getSongs();
		$albumSongs = [];
		foreach ($allSongs as $song) {
			$albumSongs[] = [
				"id" => $song->getPK(),
				"title" => $song->title
			];
		}
		$this->view()->assign([
			"album" => [
				"id" => $album->getPK(),
				"title" => $album->title
			],
			"songs" => $albumSongs
		]);
	}

}

贡献者

感谢您对VoodOrm感兴趣。

如果您想做出贡献，请发起一个pull request。

VoodOrm严格遵循PSR-2

(c) 今年Mardix :)