# Source for file Hook.php

Documentation is available at Hook.php

1. <?php
2. /*
3. * $Id: Hook.php 2149 2007-08-02 21:27:42Z zYne $
4. *
5. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
6. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
7. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
8. * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
9. * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
10. * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
11. * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
12. * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
13. * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
14. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
15. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
16. *
17. * This software consists of voluntary contributions made by many individuals
18. * and is licensed under the LGPL. For more information, see
19. * <http://www.phpdoctrine.com>.
20. */
22. /**
23. * Doctrine_Hook
24. *
25. * @package Doctrine
26. * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
27. * @category Object Relational Mapping
28. * @link www.phpdoctrine.com
29. * @since 1.0
30. * @version $Revision: 2149 $
31. * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
32. */
33. class Doctrine_Hook
34. {
35. /**
36. * @var Doctrine_Query $query the base query
37. */
38. protected $query;
39. /**
40. * @var array $joins the optional joins of the base query
41. */
42. protected $joins;
43. /**
44. * @var array $hooks hooks array
45. */
46. protected $hooks = array(
47. 'where',
48. 'orderby',
49. 'limit',
50. 'offset'
51. );
52. /**
53. * @var array $fieldParsers custom field parsers array
54. * keys as field names in the format componentAlias.FieldName
55. * values as parser names / objects
56. */
57. protected $fieldParsers = array();
59. /**
60. * @var array $typeParsers type parsers array
61. * keys as type names and values as parser names / objects
62. */
63. protected $typeParsers = array(
64. 'char' => 'Doctrine_Hook_WordLike',
65. 'string' => 'Doctrine_Hook_WordLike',
66. 'varchar' => 'Doctrine_Hook_WordLike',
67. 'integer' => 'Doctrine_Hook_Integer',
68. 'enum' => 'Doctrine_Hook_Integer',
69. 'time' => 'Doctrine_Hook_Time',
70. 'date' => 'Doctrine_Hook_Date',
71. );
73. /**
74. * @param Doctrine_Query $query the base query
75. */
76. public function __construct($query)
77. {
78. if (is_string($query)) {
79. $this->query = new Doctrine_Query();
80. $this->query->parseQuery($query);
81. } elseif ($query instanceof Doctrine_Query) {
82. $this->query = $query;
83. } else {
84. throw new Doctrine_Exception('Constructor argument should be either Doctrine_Query object or valid DQL query');
85. }
87. $this->query->getQuery();
88. }
89. /**
90. * getQuery
91. *
92. * @return Doctrine_Query returns the query object associated with this hook
93. */
94. public function getQuery()
95. {
96. return $this->query;
97. }
98. /**
99. * setTypeParser
100. *
101. * @param string $type type name
102. * @param string|object $parser parser name or custom parser object
103. */
104. public function setTypeParser($type, $parser)
105. {
106. $this->typeParsers[$type] = $parser;
107. }
108. /**
109. * setFieldParser
110. *
111. * @param string $field field name
112. * @param string|object $parser parser name or custom parser object
113. */
114. public function setFieldParser($field, $parser)
115. {
116. $this->fieldParsers[$field] = $parser;
117. }
118. /**
119. * hookWhere
120. * builds DQL query where part from given parameter array
121. *
122. * @param array $params an associative array containing field
123. * names and their values
124. * @return boolean whether or not the hooking was
125. */
126. public function hookWhere($params)
127. {
128. if ( ! is_array($params)) {
129. return false;
130. }
131. foreach ($params as $name => $value) {
132. if ($value === '' || $value === '-') {
133. continue;
134. }
135. $e = explode('.', $name);
137. if (count($e) == 2) {
138. list($alias, $column) = $e;
140. $map = $this->query->getAliasDeclaration($alias);
141. $table = $map['table'];
143. if ( ! $table) {
144. throw new Doctrine_Exception('Unknown alias ' . $alias);
145. }
147. if ($def = $table->getDefinitionOf($column)) {
149. $def[0] = gettype($value);
150. if (isset($this->typeParsers[$def[0]])) {
151. $name = $this->typeParsers[$def[0]];
152. $parser = new $name;
153. }
155. $parser->parse($alias, $column, $value);
157. $this->query->addWhere($parser->getCondition(), $parser->getParams());
158. }
159. }
160. }
162. return true;
163. }
164. /**
165. * hookOrderBy
166. * builds DQL query orderby part from given parameter array
167. *
168. * @param array $params an array containing all fields which the built query
169. * should be ordered by
170. * @return boolean whether or not the hooking was successful
171. */
172. public function hookOrderby($params)
173. {
174. if ( ! is_array($params)) {
175. return false;
176. }
177. foreach ($params as $name) {
178. $e = explode(' ', $name);
180. $order = 'ASC';
182. if (count($e) > 1) {
183. $order = ($e[1] == 'DESC') ? 'DESC' : 'ASC';
184. }
186. $e = explode('.', $e[0]);
188. if (count($e) == 2) {
189. list($alias, $column) = $e;
191. $map = $this->query->getAliasDeclaration($alias);
192. $table = $map['table'];
194. if ($def = $table->getDefinitionOf($column)) {
195. $this->query->addOrderBy($alias . '.' . $column . ' ' . $order);
196. }
197. }
198. }
199. return true;
200. }
201. /**
202. * @param integer $limit
203. */
204. public function hookLimit($limit)
205. {
206. $this->query->limit((int) $limit);
207. }
208. /**
209. * @param integer $offset
210. */
211. public function hookOffset($offset)
212. {
213. $this->query->offset((int) $offset);
214. }
215. }