git reset --hard
git clean -fd
$q = "SELECT * FROM {projects} WHERE id = :id AND user_id = :uid";
$project = db_query($q, array(':id' => $id, ':uid' => $uid))
->fetchObject();
# returns an object with fields corresponding to the names
# of your database table, which you access like
# $project->name, $project->description, and so on.
# make sure the user owns the project id
$q = "SELECT user_id FROM {projects} WHERE id = :project_id";
$result = db_query($q, array(':project_id' => $project_id))->fetchObject();
echo 'user_id is ' . $result->user_id;
$q = "SELECT * FROM {projects} WHERE uid = :uid";
$result = db_query($q, array(':uid' => $uid));
foreach ($result as $row) {
// loop through your result set, working with $row here
}
$id = db_insert('projects')
->fields(array(
'user_id' => $uid,
'project_type' => $project_type,
'name' => $name,
'description' => $description,
'last_updated' => $timestamp,
'date_created' => $timestamp
))
->execute();
db_update('projects')
->fields(array(
'project_count_type' => $project_count_type,
'name' => $name,
'description' => $description,
'last_updated' => $timestamp,
)
)
->condition('id', $id)
->execute();
db_delete('projects')
->condition('id', $id)
->execute();
db_query('SELECT foo FROM {table} t WHERE t.name = '. $_GET['user']);$query = $connection->select('table', 't') ->fields('t', array('foo')) ->condition('t.name, $name);print $_GET['id'];$output .= $node->title;$node = \Drupal\node\Entity\Node::load($nid);<img src="http://example.com/user/logout" /><img src="http://example.com/node/12/delete" />example.name: path: '/example/settings' defaults: _controller: '\Drupal\example\Controller\ExampleController::content'requirements: _permission: 'access content'User class that reads from a file. You want to change it to a different class that reads from the database, but all the code references the original class that reads from a file. This is where the factory pattern comes in handy.newdirectly, you use the factory class to create objects. That way, if you want to change the types of objects created, you can change just the factory. All the code that uses the factory changes automatically.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| <?phpinterface IUser{ function getName();}class User implements IUser{ public function __construct( $id ) { } public function getName() { return "Jack"; }}class UserFactory{ public static function Create( $id ) { return new User( $id ); }}$uo = UserFactory::Create( 1 );echo( $uo->getName()."\n" );?> |
IUser defines what a user object should do. The implementation of IUser is called User, and a factory class called UserFactory creates IUser objects. This relationship is shown as UML in Figure 1.
php interpreter, you get this result:
1
2
3
| % php factory1.php Jack% |
User object and prints the result of the getName method.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| <?phpinterface IUser{ function getName();}class User implements IUser{ public static function Load( $id ) { return new User( $id ); } public static function Create( ) { return new User( null ); } public function __construct( $id ) { } public function getName() { return "Jack"; }}$uo = User::Load( 1 );echo( $uo->getName()."\n" );?> |
IUser, and one class called User that implements the interface. The User class has two static methods that create the object. This relationship is shown in UML in Figure 2.
1
2
3
| % php factory2.php Jack% |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| <?phprequire_once("DB.php");class DatabaseConnection{ public static function get() { static $db = null; if ( $db == null ) $db = new DatabaseConnection(); return $db; } private $_handle = null; private function __construct() { $dsn = 'mysql://root:password@localhost/photos'; $this->_handle =& DB::Connect( $dsn, array() ); } public function handle() { return $this->_handle; }}print( "Handle = ".DatabaseConnection::get()->handle()."\n" );print( "Handle = ".DatabaseConnection::get()->handle()."\n" );?> |
DatabaseConnection. You can't create your own DatabaseConnection because the constructor is private. But you can get the one and only oneDatabaseConnection object using the static get method. The UML for this code is shown in Figure 3.
handle method is the same between two calls. You can see this by running the code on the command line.
1
2
3
4
| % php singleton.php Handle = Object id #3Handle = Object id #3% |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| <?phpinterface IObserver{ function onChanged( $sender, $args );}interface IObservable{ function addObserver( $observer );}class UserList implements IObservable{ private $_observers = array(); public function addCustomer( $name ) { foreach( $this->_observers as $obs ) $obs->onChanged( $this, $name ); } public function addObserver( $observer ) { $this->_observers []= $observer; }}class UserListLogger implements IObserver{ public function onChanged( $sender, $args ) { echo( "'$args' added to user list\n" ); }}$ul = new UserList();$ul->addObserver( new UserListLogger() );$ul->addCustomer( "Jack" );?> |
IObservable interface defines an object that can be observed, and the UserList implements that interface to register itself as observable. The IObserver list defines what it takes to be an observer, and the UserListLogger implements thatIObserver interface. This is shown in the UML in Figure 4.
1
2
3
| % php observer.php 'Jack' added to user list% |
UserList and adds the UserListLogger observer to it. Then the code adds a customer, and the UserListLogger is notified of that change.UserList doesn't know what the logger is going to do. There could be one or more listeners that do other things. For example, you may have an observer that sends a message to the new user, welcoming him to the system. The value of this approach is that the UserList is ignorant of all the objects depending on it; it focuses on its job of maintaining the user list and sending out messages when the list changes.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| <?phpinterface ICommand{ function onCommand( $name, $args );}class CommandChain{ private $_commands = array(); public function addCommand( $cmd ) { $this->_commands []= $cmd; } public function runCommand( $name, $args ) { foreach( $this->_commands as $cmd ) { if ( $cmd->onCommand( $name, $args ) ) return; } }}class UserCommand implements ICommand{ public function onCommand( $name, $args ) { if ( $name != 'addUser' ) return false; echo( "UserCommand handling 'addUser'\n" ); return true; }}class MailCommand implements ICommand{ public function onCommand( $name, $args ) { if ( $name != 'mail' ) return false; echo( "MailCommand handling 'mail'\n" ); return true; }}$cc = new CommandChain();$cc->addCommand( new UserCommand() );$cc->addCommand( new MailCommand() );$cc->runCommand( 'addUser', null );$cc->runCommand( 'mail', null );?> |
CommandChain class that maintains a list of ICommand objects. Two classes implement the ICommand interface -- one that responds to requests for mail and another that responds to adding users. The UML is shows in Figure 5.
1
2
3
4
| % php chain.php UserCommand handling 'addUser'MailCommand handling 'mail'% |
CommandChain object and adds instances of the two command objects to it. It then runs two commands to see who responds to those commands. If the name of the command matches either UserCommand or MailCommand, the code falls through and nothing happens.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
| <?phpinterface IStrategy{ function filter( $record );}class FindAfterStrategy implements IStrategy{ private $_name; public function __construct( $name ) { $this->_name = $name; } public function filter( $record ) { return strcmp( $this->_name, $record ) <= 0; }}class RandomStrategy implements IStrategy{ public function filter( $record ) { return rand( 0, 1 ) >= 0.5; }}class UserList{ private $_list = array(); public function __construct( $names ) { if ( $names != null ) { foreach( $names as $name ) { $this->_list []= $name; } } } public function add( $name ) { $this->_list []= $name; } public function find( $filter ) { $recs = array(); foreach( $this->_list as $user ) { if ( $filter->filter( $user ) ) $recs []= $user; } return $recs; }}$ul = new UserList( array( "Andy", "Jack", "Lori", "Megan" ) );$f1 = $ul->find( new FindAfterStrategy( "J" ) );print_r( $f1 );$f2 = $ul->find( new RandomStrategy() );print_r( $f2 );?> |
UserList class is a wrapper around an array of names. It implements a find method that takes one of several strategies for selecting a subset of those names. Those strategies are defined by the IStrategyinterface, which has two implementations: One chooses users randomly and the other chooses all the names after a specified name. When you run the test code, you get the following output:
1
2
3
4
5
6
7
8
9
10
11
12
13
| % php strategy.php Array( [0] => Jack [1] => Lori [2] => Megan)Array( [0] => Andy [1] => Megan)% |
J, so you get Jack, Lori, and Megan. The second strategy picks names randomly and yields different results every time. In this case, the results are Andy and Megan.