user-access-manager / src / Object / ObjectHandler.php

ObjectHandler.php in User Access Manager 2.1.4, at src/Object/ObjectHandler.php

410 lines 10.6 KB

Raw Download Zip

1	<?php
2	/**
3	* ObjectHandler.php
4	*
5	* The ObjectHandler class file.
6	*
7	* PHP versions 5
8	*
9	* @author Alexander Schneider <alexanderschneider85@gmail.com>
10	* @copyright 2008-2017 Alexander Schneider
11	* @license http://www.gnu.org/licenses/gpl-2.0.html GNU General Public License, version 2
12	* @version SVN: $id$
13	* @link http://wordpress.org/extend/plugins/user-access-manager/
14	*/
15	namespace UserAccessManager\Object;
16
17	use UserAccessManager\ObjectMembership\MissingObjectMembershipHandlerException;
18	use UserAccessManager\ObjectMembership\ObjectMembershipHandler;
19	use UserAccessManager\ObjectMembership\ObjectMembershipHandlerFactory;
20	use UserAccessManager\Wrapper\Php;
21	use UserAccessManager\Wrapper\Wordpress;
22
23	/**
24	* Class ObjectHandler
25	*
26	* @package UserAccessManager\ObjectHandler
27	*/
28	class ObjectHandler
29	{
30	const GENERAL_ROLE_OBJECT_TYPE = '_role_';
31	const GENERAL_USER_OBJECT_TYPE = '_user_';
32	const GENERAL_POST_OBJECT_TYPE = '_post_';
33	const GENERAL_TERM_OBJECT_TYPE = '_term_';
34	const ATTACHMENT_OBJECT_TYPE = 'attachment';
35	const POST_OBJECT_TYPE = 'post';
36	const PAGE_OBJECT_TYPE = 'page';
37	const POST_FORMAT_TYPE = 'post_format';
38
39	/**
40	* @var Php
41	*/
42	private $php;
43
44	/**
45	* @var Wordpress
46	*/
47	private $wordpress;
48
49	/**
50	* @var ObjectMembershipHandlerFactory
51	*/
52	private $membershipHandlerFactory;
53
54	/**
55	* @var null\|array
56	*/
57	private $postTypes = null;
58
59	/**
60	* @var null\|array
61	*/
62	private $taxonomies = null;
63
64	/**
65	* @var \WP_User
66	*/
67	private $users = null;
68
69	/**
70	* @var \WP_Post[]
71	*/
72	private $posts = null;
73
74	/**
75	* @var \WP_Term[]
76	*/
77	private $terms = null;
78
79	/**
80	* @var null\|array
81	*/
82	private $objectMembershipHandlers = null;
83
84	/**
85	* @var null\|array
86	*/
87	private $objectTypes = null;
88
89	/**
90	* @var null\|array
91	*/
92	private $allObjectTypesMap = null;
93
94	/**
95	* @var null\|array
96	*/
97	private $allObjectTypes = null;
98
99	/**
100	* @var array
101	*/
102	private $validObjectTypes = [];
103
104	/**
105	* ObjectHandler constructor.
106	*
107	* @param Php $php
108	* @param Wordpress $wordpress
109	* @param ObjectMembershipHandlerFactory $membershipHandlerFactory
110	*/
111	public function __construct(
112	Php $php,
113	Wordpress $wordpress,
114	ObjectMembershipHandlerFactory $membershipHandlerFactory
115	) {
116	$this->php = $php;
117	$this->wordpress = $wordpress;
118	$this->membershipHandlerFactory = $membershipHandlerFactory;
119	}
120
121	/**
122	* Returns all post types.
123	*
124	* @return array
125	*/
126	public function getPostTypes()
127	{
128	if ($this->postTypes === null) {
129	$this->postTypes = $this->wordpress->getPostTypes(['public' => true]);
130	}
131
132	return $this->postTypes;
133	}
134
135	/**
136	* Returns the taxonomies.
137	*
138	* @return array
139	*/
140	public function getTaxonomies()
141	{
142	if ($this->taxonomies === null) {
143	$this->taxonomies = $this->wordpress->getTaxonomies(['public' => true]);
144	}
145
146	return $this->taxonomies;
147	}
148
149	/**
150	* Returns a user.
151	*
152	* @param int\|string $id The user id.
153	*
154	* @return \WP_User\|false
155	*/
156	public function getUser($id)
157	{
158	if (isset($this->users[$id]) === false) {
159	$this->users[$id] = $this->wordpress->getUserData($id);
160	}
161
162	return $this->users[$id];
163	}
164
165	/**
166	* Returns a post.
167	*
168	* @param int $id The post id.
169	*
170	* @return \WP_Post\|false
171	*/
172	public function getPost($id)
173	{
174	if (isset($this->posts[$id]) === false) {
175	$post = $this->wordpress->getPost($id);
176	$this->posts[$id] = ($post instanceof \WP_Post) ? $post : false;
177	}
178
179	return $this->posts[$id];
180	}
181
182	/**
183	* Returns a term.
184	*
185	* @param int $id The term id.
186	* @param string $taxonomy The taxonomy.
187	*
188	* @return false\|\WP_Term
189	*/
190	public function getTerm($id, $taxonomy = '')
191	{
192	$fullId = $id.'\|'.$taxonomy;
193
194	if (isset($this->terms[$fullId]) === false) {
195	$term = $this->wordpress->getTerm($id, $taxonomy);
196	$this->terms[$fullId] = ($term instanceof \WP_Term) ? $term : false;
197	}
198
199	return $this->terms[$fullId];
200	}
201
202	/**
203	* Used for adding custom post types using the registered_post_type hook
204	* @see http://wordpress.org/support/topic/modifying-post-type-using-the-registered_post_type-hook
205	*
206	* @param string $postType The string for the new post_type
207	* @param \WP_Post_Type $arguments The array of arguments used to create the post_type
208	*/
209	public function registeredPostType($postType, \WP_Post_Type $arguments)
210	{
211	if ((bool)$arguments->public === true) {
212	$this->postTypes = $this->getPostTypes();
213	$this->postTypes[$postType] = $postType;
214	$this->objectTypes = null;
215	$this->allObjectTypes = null;
216	$this->allObjectTypesMap = null;
217	$this->validObjectTypes = [];
218	}
219	}
220
221	/**
222	* Adds an custom taxonomy.
223	*
224	* @param string $taxonomy
225	* @param string $objectType
226	* @param array $arguments
227	*/
228	public function registeredTaxonomy($taxonomy, $objectType, array $arguments)
229	{
230	if ((bool)$arguments['public'] === true) {
231	$this->taxonomies = $this->getTaxonomies();
232	$this->taxonomies[$taxonomy] = $taxonomy;
233	$this->objectTypes = null;
234	$this->allObjectTypes = null;
235	$this->allObjectTypesMap = null;
236	$this->validObjectTypes = [];
237	}
238	}
239
240	/**
241	* Checks if type is postable.
242	*
243	* @param string $type
244	*
245	* @return bool
246	*/
247	public function isPostType($type)
248	{
249	$postableTypes = $this->getPostTypes();
250	return isset($postableTypes[$type]);
251	}
252
253	/**
254	* Checks if the taxonomy is a valid one.
255	*
256	* @param string $taxonomy
257	*
258	* @return bool
259	*/
260	public function isTaxonomy($taxonomy)
261	{
262	$taxonomies = $this->getTaxonomies();
263	return in_array($taxonomy, $taxonomies);
264	}
265
266	/**
267	* Returns the predefined object types.
268	*
269	* @return array
270	*/
271	public function getObjectTypes()
272	{
273	if ($this->objectTypes === null) {
274	$this->objectTypes = array_merge(
275	$this->getPostTypes(),
276	$this->getTaxonomies()
277	);
278	}
279
280	return $this->objectTypes;
281	}
282
283	/**
284	* Returns the object types map.
285	*
286	* @return array
287	*/
288	private function getAllObjectsTypesMap()
289	{
290	if ($this->allObjectTypesMap === null) {
291	$this->allObjectTypesMap = [];
292	$objectHandlers = $this->getObjectMembershipHandlers();
293
294	foreach ($objectHandlers as $objectHandler) {
295	$handledObjects = $objectHandler->getHandledObjects();
296
297	if ($handledObjects === []) {
298	continue;
299	}
300
301	$handledObjectsMap = array_combine(
302	$handledObjects,
303	$this->php->arrayFill(0, count($handledObjects), $objectHandler->getGeneralObjectType())
304	);
305
306	$this->allObjectTypesMap = array_merge($this->allObjectTypesMap, $handledObjectsMap);
307	}
308	}
309
310	return $this->allObjectTypesMap;
311	}
312
313	/**
314	* Returns all objects types.
315	*
316	* @return array
317	*/
318	public function getAllObjectTypes()
319	{
320	if ($this->allObjectTypes === null) {
321	$objectTypes = array_keys($this->getAllObjectsTypesMap());
322	$this->allObjectTypes = array_combine($objectTypes, $objectTypes);
323	}
324
325	return $this->allObjectTypes;
326	}
327
328	/**
329	* Returns the general object type.
330	*
331	* @param string $objectType
332	*
333	* @return string
334	*/
335	public function getGeneralObjectType($objectType)
336	{
337	$objectsTypeMap = $this->getAllObjectsTypesMap();
338	return (isset($objectsTypeMap[$objectType]) === true) ? $objectsTypeMap[$objectType] : null;
339	}
340
341	/**
342	* Checks if the object type is a valid one.
343	*
344	* @param string $objectType The object type to check.
345	*
346	* @return bool
347	*/
348	public function isValidObjectType($objectType)
349	{
350	if (isset($this->validObjectTypes[$objectType]) === false) {
351	$objectTypesMap = $this->getAllObjectTypes();
352	$this->validObjectTypes[$objectType] = isset($objectTypesMap[$objectType]);
353	}
354
355	return $this->validObjectTypes[$objectType];
356	}
357
358	/**
359	* Returns the object membership handlers.
360	*
361	* @return ObjectMembershipHandler[]
362	*/
363	private function getObjectMembershipHandlers()
364	{
365	if ($this->objectMembershipHandlers === null) {
366	$factory = $this->membershipHandlerFactory;
367
368	$roleMembershipHandler = $factory->createRoleMembershipHandler();
369	$userMembershipHandler = $factory->createUserMembershipHandler($this);
370	$termMembershipHandler = $factory->createTermMembershipHandler($this);
371	$postMembershipHandler = $factory->createPostMembershipHandler($this);
372
373	$this->objectMembershipHandlers = [
374	$roleMembershipHandler->getGeneralObjectType() => $roleMembershipHandler,
375	$userMembershipHandler->getGeneralObjectType() => $userMembershipHandler,
376	$termMembershipHandler->getGeneralObjectType() => $termMembershipHandler,
377	$postMembershipHandler->getGeneralObjectType() => $postMembershipHandler
378	];
379
380	$this->objectMembershipHandlers = $this->wordpress->applyFilters(
381	'uam_register_object_membership_handler',
382	$this->objectMembershipHandlers
383	);
384	}
385
386	return $this->objectMembershipHandlers;
387	}
388
389	/**
390	* Returns the membership handler for the given object type.
391	*
392	* @param string $objectType
393	*
394	* @return ObjectMembershipHandler
395	*
396	* @throws MissingObjectMembershipHandlerException
397	*/
398	public function getObjectMembershipHandler($objectType)
399	{
400	$objectMembershipHandlers = $this->getObjectMembershipHandlers();
401	$generalObjectType = $this->getGeneralObjectType($objectType);
402
403	if (isset($objectMembershipHandlers[$generalObjectType]) === false) {
404	throw new MissingObjectMembershipHandlerException("Missing membership handler for '{$objectType}'.");
405	}
406
407	return $objectMembershipHandlers[$generalObjectType];
408	}
409	}
410