user-access-manager / class / UamUserGroup.class.php

UamUserGroup.class.php in User Access Manager 1.1.3, at class/UamUserGroup.class.php

980 lines 26.3 KB

Raw Download Zip

1	<?php
2	/**
3	* UamUserGroup.class.php
4	*
5	* The UamUserGroup class file.
6	*
7	* PHP versions 5
8	*
9	* @category UserAccessManager
10	* @package UserAccessManager
11	* @author Alexander Schneider <alexanderschneider85@googlemail.com>
12	* @copyright 2008-2010 Alexander Schneider
13	* @license http://www.gnu.org/licenses/gpl-2.0.html GNU General Public License, version 2
14	* @version SVN: $Id$
15	* @link http://wordpress.org/extend/plugins/user-access-manager/
16	*/
17
18	/**
19	* The user group class.
20	*
21	* @category UserAccessManager
22	* @package UserAccessManager
23	* @author Alexander Schneider <alexanderschneider85@gmail.com>
24	* @license http://www.gnu.org/licenses/gpl-2.0.html GNU General Public License, version 2
25	* @link http://wordpress.org/extend/plugins/user-access-manager/
26	*/
27
28	class UamUserGroup
29	{
30	protected $accessHandler = null;
31	protected $id = null;
32	protected $groupName = null;
33	protected $groupDesc = null;
34	protected $readAccess = null;
35	protected $writeAccess = null;
36	protected $ipRange = null;
37	protected $roles = array();
38	protected $objects = null;
39	protected $singleObjects = null;
40	private $_assignedObjects = null;
41	protected $plObjects = array();
42
43	/**
44	* Consturtor
45	*
46	* @param object &$uamAccessHandler The access handler object.
47	* @param integer $id The id of the user group.
48	*
49	* @return null
50	*/
51	public function __construct(&$uamAccessHandler, $id = null)
52	{
53	$this->accessHandler = $uamAccessHandler;
54
55	//Create default values for the objects.
56	foreach ($this->getAllObjectTypes() as $objectType) {
57	$this->objects[$objectType] = array(
58	'real' => -1,
59	'full' => -1
60	);
61	$this->_assignedObjects[$objectType] = null;
62	}
63
64	if ($id !== null) {
65	global $wpdb;
66
67	$this->id = $id;
68
69	$dbUsergroup = $wpdb->get_row(
70	"SELECT *
71	FROM ".DB_ACCESSGROUP."
72	WHERE ID = ".$this->getId()."
73	LIMIT 1",
74	ARRAY_A
75	);
76
77	$this->groupName = $dbUsergroup['groupname'];
78	$this->groupDesc = $dbUsergroup['groupdesc'];
79	$this->readAccess = $dbUsergroup['read_access'];
80	$this->writeAccess = $dbUsergroup['write_access'];
81	$this->ipRange = $dbUsergroup['ip_range'];
82	}
83	}
84
85	/**
86	* Returns the user access handler object.
87	*
88	* @return object
89	*/
90	public function &getAccessHandler()
91	{
92	return $this->accessHandler;
93	}
94
95	/**
96	* Deletes the user group.
97	*
98	* @return null
99	*/
100	public function delete()
101	{
102	if ($this->id == null) {
103	return false;
104	}
105
106	global $wpdb;
107
108	$wpdb->query(
109	"DELETE FROM " . DB_ACCESSGROUP . "
110	WHERE ID = $this->id LIMIT 1"
111	);
112
113	foreach ($this->getAllObjectTypes() as $objectType) {
114	$this->_deleteObjectsFromDb($objectType);
115	}
116	}
117
118	/**
119	* Saves the user group.
120	*
121	* @return null;
122	*/
123	public function save()
124	{
125	global $wpdb;
126
127	if ($this->id == null) {
128	$wpdb->query(
129	"INSERT INTO " . DB_ACCESSGROUP . " (
130	ID,
131	groupname,
132	groupdesc,
133	read_access,
134	write_access,
135	ip_range
136	)
137	VALUES (
138	NULL,
139	'" . $this->groupName . "',
140	'" . $this->groupDesc . "',
141	'" . $this->readAccess . "',
142	'" . $this->writeAccess . "',
143	'" . $this->ipRange . "'
144	)"
145	);
146
147	$this->id = $wpdb->insert_id;
148	} else {
149	$wpdb->query(
150	"UPDATE " . DB_ACCESSGROUP . "
151	SET groupname = '" . $this->groupName . "',
152	groupdesc = '" . $this->groupDesc . "',
153	read_access = '" . $this->readAccess . "',
154	write_access = '" . $this->writeAccess . "',
155	ip_range = '" . $this->ipRange . "'
156	WHERE ID = " . $this->id
157	);
158
159	foreach ($this->getAllObjectTypes() as $objectType) {
160	//Load to object
161	$this->getObjectsFromType($objectType);
162	//Delete form database
163	$this->_deleteObjectsFromDb($objectType);
164	}
165	}
166
167	foreach ($this->getAllObjectTypes() as $objectType) {
168	foreach ($this->getObjectsFromType($objectType) as $key => $object) {
169	$sql = sprintf(
170	$this->_getSqlQuery($objectType, 'insert'),
171	trim($key)
172	);
173	$wpdb->query($sql);
174	}
175	}
176	}
177
178
179	/*
180	* Primary values.
181	*/
182
183	/**
184	* Returns the group id.
185	*
186	* @return integer
187	*/
188	public function getId()
189	{
190	return $this->id;
191	}
192
193	/**
194	* Returns the group name.
195	*
196	* @return string
197	*/
198	public function getGroupName()
199	{
200	return $this->groupName;
201	}
202
203	/**
204	* Sets the group name.
205	*
206	* @param string $groupName The new group name.
207	*
208	* @return null
209	*/
210	public function setGroupName($groupName)
211	{
212	$this->groupName = $groupName;
213	}
214
215	/**
216	* Returns the group description.
217	*
218	* @return string
219	*/
220	public function getGroupDesc()
221	{
222	return $this->groupDesc;
223	}
224
225	/**
226	* Sets the group description.
227	*
228	* @param string $groupDesc The new group description.
229	*
230	* @return null
231	*/
232	public function setGroupDesc($groupDesc)
233	{
234	$this->groupDesc = $groupDesc;
235	}
236
237	/**
238	* Returns the read access.
239	*
240	* @return string
241	*/
242	public function getReadAccess()
243	{
244	return $this->readAccess;
245	}
246
247	/**
248	* Sets the read access.
249	*
250	* @param string $readAccess The read access.
251	*
252	* @return null
253	*/
254	public function setReadAccess($readAccess)
255	{
256	$this->readAccess = $readAccess;
257	}
258
259	/**
260	* Returns the write access.
261	*
262	* @return string
263	*/
264	public function getWriteAccess()
265	{
266	return $this->writeAccess;
267	}
268
269	/**
270	* Sets the write access.
271	*
272	* @param string $writeAccess The wirte access.
273	*
274	* @return null
275	*/
276	public function setWriteAccess($writeAccess)
277	{
278	$this->writeAccess = $writeAccess;
279	}
280
281	/**
282	* Returns the ip range.
283	*
284	* @param string $type The return type.
285	*
286	* @return array
287	*/
288	public function getIpRange($type = null)
289	{
290	if ($type == 'string') {
291	return $this->ipRange;
292	}
293
294	$ipRange = explode(';', $this->ipRange);
295
296	if ($ipRange[0] == null) {
297	return null;
298	}
299
300	return $ipRange;
301	}
302
303	/**
304	* Sets the ip range.
305	*
306	* @param string $ipRange The new ip range.
307	*
308	* @return null
309	*/
310	public function setIpRange($ipRange)
311	{
312	if (is_array($ipRange)) {
313	$ipRange = implode(';', $ipRange);
314	}
315
316	$this->ipRange = $ipRange;
317	}
318
319	/**
320	* Returns all objects types.
321	*
322	* @return array
323	*/
324	public function getAllObjectTypes()
325	{
326	return $this->getAccessHandler()->getAllObjectTypes();
327	}
328
329
330	/*
331	* Meta functions.
332	*/
333
334	/**
335	* Magic method getter.
336	*
337	* @param string $name The name of the function
338	* @param array $arguments The arguments for the function
339	*
340	* @return mixed
341	*/
342	public function __call($name, $arguments)
343	{
344	$uam = $this->getAccessHandler()->getUserAccessManager();
345
346	$action = '';
347
348	if ($uam->startsWith($name, 'add')) {
349	$prefix = 'add';
350	} elseif ($uam->startsWith($name, 'remove')) {
351	$prefix = 'remove';
352	} elseif ($uam->startsWith($name, 'isMember')) {
353	$prefix = 'isMember';
354	}
355
356	$objectType = str_replace($prefix, '', $name);
357	$objectType = strtolower($objectType);
358
359	$objectId = $arguments[0];
360
361	if ($prefix == 'add') {
362	return $this->addObject(
363	$objectType,
364	$objectId
365	);
366	} elseif ($prefix == 'remove') {
367	return $this->removeObject(
368	$objectType,
369	$objectId
370	);
371	} elseif ($prefix == 'ismember') {
372	$withInfo = $arguments[1];
373
374	return $this->objectIsMember(
375	$objectType,
376	$objectId,
377	$withInfo
378	);
379	}
380	}
381
382	/**
383	* Returns the sql query.
384	*
385	* @param string $objectType The object type.
386	* @param string $action The sql action.
387	*
388	* @return string
389	*/
390	private function _getSqlQuery($objectType, $action)
391	{
392	$sql = '';
393
394	if ($action == 'select') {
395	$sql = "SELECT object_id as id
396	FROM ".DB_ACCESSGROUP_TO_OBJECT."
397	WHERE group_id = ".$this->getId()."
398	AND object_type = '".$objectType ."'";
399	} elseif ($action == 'delete') {
400	$sql = "DELETE FROM ".DB_ACCESSGROUP_TO_OBJECT."
401	WHERE group_id = ".$this->getId()."
402	AND object_type = '".$objectType ."'";
403	} elseif ($action == 'insert') {
404	$sql = "INSERT INTO ".DB_ACCESSGROUP_TO_OBJECT." (
405	group_id,
406	object_id,
407	object_type
408	) VALUES (
409	'".$this->getId()."',
410	'%s',
411	'".$objectType."'
412	)";
413	}
414
415	return $sql;
416	}
417
418	/**
419	* Adds a object of the given type.
420	*
421	* @param string $objectType The object type.
422	* @param integer $objectId The object id.
423	*
424	* @return null
425	*/
426	public function addObject($objectType, $objectId)
427	{
428	if (!in_array($objectType, $this->getAllObjectTypes())) {
429	return;
430	}
431
432	$this->getAccessHandler()->unsetUserGroupsForObject();
433	$this->getObjectsFromType($objectType);
434
435	$object = new stdClass;
436	$object->id = $objectId;
437
438	$this->objects[$objectType]['real'][$objectId] = $object;
439	$this->objects[$objectType]['full'] = -1;
440
441	$this->_assignedObjects[$objectType][$objectId] = $objectId;
442	}
443
444	/**
445	* Removes a object of the given type.
446	*
447	* @param string $objectType The object type.
448	* @param integer $objectId The object id.
449	*
450	* @return null
451	*/
452	public function removeObject($objectType, $objectId)
453	{
454	if (!in_array($objectType, $this->getAllObjectTypes())) {
455	return;
456	}
457
458	$this->getAccessHandler()->unsetUserGroupsForObject();
459	$this->getObjectsFromType($objectType);
460
461	unset($this->objects[$objectType]['real'][$objectId]);
462	$this->objects[$objectType]['full'] = -1;
463
464	unset($this->singleObjects[$objectType][$objectId]);
465	unset($this->_assignedObjects[$objectType][$objectId]);
466	}
467
468	/**
469	* Returns the assigned objects.
470	*
471	* @param string $objectType The object type.
472	*
473	* @return array
474	*/
475	private function _getAssignedObjects($objectType)
476	{
477	if ($this->_assignedObjects[$objectType] !== null) {
478	return $this->_assignedObjects[$objectType];
479	}
480
481	global $wpdb;
482
483	$dbObjects = $wpdb->get_results(
484	$this->_getSqlQuery($objectType, 'select')
485	);
486
487	$this->_assignedObjects[$objectType] = array();
488
489	foreach ($dbObjects as $dbObject) {
490	$this->_assignedObjects[$objectType][$dbObject->id]
491	= $dbObject->id;
492	}
493
494	return $this->_assignedObjects[$objectType];
495	}
496
497	/**
498	* Checks if the object is assigned to the group.
499	*
500	* @param string $objectType The object type.
501	* @param integer $objectId The object id.
502	*
503	* @return boolean
504	*/
505	private function _isObjectAssignedToGroup($objectType, $objectId)
506	{
507	return array_key_exists(
508	$objectId,
509	$this->_getAssignedObjects($objectType)
510	);
511	}
512
513	/**
514	* Unsets the ojects.
515	*
516	* @param string $objectType The object type.
517	* @param boolean $plusRemove If true also database entrys will remove.
518	*
519	* @return null;
520	*/
521	public function unsetObjects($objectType, $plusRemove = false)
522	{
523	if (!in_array($objectType, $this->getAllObjectTypes())) {
524	return;
525	}
526
527	if ($plusRemove) {
528	$this->_deleteObjectsFromDb($objectType);
529	}
530
531	$this->objects[$objectType] = array(
532	'real' => array(),
533	'full' => array(),
534	);
535	}
536
537	/**
538	* Removes all objects from the user group.
539	*
540	* @param string $objectType The object type.
541	*
542	* @return null
543	*/
544	private function _deleteObjectsFromDb($objectType)
545	{
546	if (isset($this->id)) {
547	global $wpdb;
548
549	$wpdb->query(
550	$this->_getSqlQuery($objectType, 'delete')
551	);
552	}
553	}
554
555	/**
556	* Checks if the given object is a member of the group.
557	*
558	* @param string $objectType The object type.
559	* @param interger $objectId The id of the object which should be checked.
560	* @param boolean $withInfo If true then we return additional infos.
561	*
562	* @return boolean
563	*/
564	public function objectIsMember($objectType, $objectId, $withInfo = false)
565	{
566	if (!in_array($objectType, $this->getAllObjectTypes())) {
567	return;
568	}
569
570	$object = $this->_getSingleObject($objectType, $objectId, 'full');
571
572	if ($object !== null) {
573	if (isset($object->recursiveMember)
574	&& $withInfo
575	) {
576	return $object->recursiveMember;
577	}
578
579	return true;
580	}
581
582	return false;
583	}
584
585	/**
586	* Returns all objects of the given type.
587	*
588	* @param string $objectType The object type.
589	* @param string $type The return type, could be real or full.
590	*
591	* @return array
592	*/
593	function getObjectsFromType($objectType, $type = 'real')
594	{
595	if (!in_array($objectType, $this->getAllObjectTypes())) {
596	return;
597	}
598
599	if ($this->id == null) {
600	return array();
601	}
602
603	if ($type != 'real'
604	&& $type != 'full'
605	) {
606	return array();
607	}
608
609	if ($this->objects[$objectType][$type] != -1) {
610	return $this->objects[$objectType][$type];
611	} else {
612	$this->objects[$objectType][$type] = array();
613	}
614
615	global $wpdb;
616
617	$dbObjects = $wpdb->get_results(
618	$this->_getSqlQuery($objectType, 'select')
619	);
620
621	foreach ($dbObjects as $dbObject) {
622	$object = $this->_getSingleObject($objectType, $dbObject->id, $type);
623
624	if ($object !== null) {
625	$this->objects[$objectType][$type][$object->id] = $object;
626	}
627	}
628
629	if ($type == 'full'
630	&& $objectType != 'post'
631	&& $objectType != 'page'
632	&& $objectType != 'attachment'
633	&& $objectType != 'role'
634	) {
635	if ($objectType == 'category') {
636	$this->objects[$objectType][$type]
637	= $this->getFullCategories($this->objects[$objectType][$type]);
638	} elseif ($objectType == 'user') {
639	$this->objects[$objectType][$type] = $this->getFullUsers();
640	} else {
641	$plObject = $this->getAccessHandler()->getPlObject($objectType);
642	$this->objects[$objectType][$type]
643	= $plObject['reference']->{$plObject['getFullObjects']}(
644	$this->objects[$objectType][$type],
645	&$this
646	);
647	}
648	}
649
650	return $this->objects[$objectType][$type];
651	}
652
653	/**
654	* Returns a single object.
655	*
656	* @param string $objectType The object type.
657	* @param interger $objectId The id of the object which should be checked.
658	* @param string $type The return type. Can be real or full.
659	*
660	* @return object
661	*/
662	private function _getSingleObject($objectType, $objectId, $type)
663	{
664	if (isset($this->singleObjects[$objectType][$objectId])) {
665	return $this->singleObjects[$objectType][$objectId];
666	}
667
668	$isRecursiveMember = array();
669
670	if ($type == 'full'
671	&& $objectType != 'role'
672	) {
673	if ($objectType == 'post'
674	\|\| $objectType == 'page'
675	\|\| $objectType == 'attachment'
676	) {
677	$isRecursiveMember = $this->_getFullPost($objectType, $objectId);
678	} else if ($objectType == 'category') {
679	$isRecursiveMember = $this->_getFullCategory($objectId);
680	} else if ($objectType == 'user') {
681	$isRecursiveMember = $this->_getFullUser($objectId);
682	} else {
683	$isRecursiveMember = $this->_getFullPlObject($objectType, $objectId);
684	}
685	}
686
687	if ($this->_isObjectAssignedToGroup($objectType, $objectId)
688	\|\| $isRecursiveMember != array()
689	) {
690	$object = new stdClass;
691	$object->id = $objectId;
692
693	if ($isRecursiveMember != array()) {
694	$object->recursiveMember = $isRecursiveMember;
695	}
696
697	$this->singleObjects[$objectType][$objectId] = $object;
698	} else {
699	$this->singleObjects[$objectType][$objectId] = null;
700	}
701
702	return $this->singleObjects[$objectType][$objectId];
703	}
704
705
706	/*
707	* Group users functions.
708	*/
709
710	/**
711	* Returns a single user.
712	*
713	* @param integer $objectId The object id.
714	*
715	* @return object
716	*/
717	private function _getFullUser($objectId)
718	{
719	$isRecursiveMember = array();
720
721	global $wpdb;
722
723	$curUserdata = get_userdata($objectId);
724
725	if (isset($curUserdata->{$wpdb->prefix . "capabilities"})) {
726	$capabilities = $curUserdata->{$wpdb->prefix . "capabilities"};
727	} else {
728	$capabilities = null;
729	}
730
731	$role = is_array($capabilities) ?
732	array_keys($capabilities) : array('norole');
733
734	if (array_key_exists($role[0], $this->getObjectsFromType('role'))
735	) {
736	$roleObject->name = $role[0];
737
738	$isRecursiveMember = array('role' => array());
739	$isRecursiveMember['role'][] = $roleObject;
740	}
741
742	return $isRecursiveMember;
743	}
744
745	/**
746	* Returns the users in the group
747	*
748	* @return array
749	*/
750	public function getFullUsers()
751	{
752	global $wpdb;
753
754	$dbUsers = $wpdb->get_results(
755	"SELECT ID, user_nicename
756	FROM ".$wpdb->users
757	);
758
759	$fullUsers = array();
760
761	if (isset($dbUsers)) {
762	foreach ($dbUsers as $dbUser) {
763	$user = $this->_getSingleObject('user', $dbUser->ID, 'full');
764
765	if ($user !== null) {
766	$fullUsers[$user->id] = $user;
767	}
768	}
769	}
770
771	return $fullUsers;
772	}
773
774
775	/*
776	* Group categories functions.
777	*/
778
779	/**
780	* Returns a single category.
781	*
782	* @param integer $objectId The object id.
783	*
784	* @return object
785	*/
786	private function _getFullCategory($objectId)
787	{
788	$category = get_category($objectId);
789
790	$isRecursiveMember = array();
791
792	$userAccessManager = $this->getAccessHandler()->getUserAccessManager();
793	$uamOptions = $userAccessManager->getAdminOptions();
794
795	if ($uamOptions['lock_recursive'] == 'true') {
796	if (isset($category->parent)
797	&& !is_null($category->parent)
798	) {
799	$parentCategory = $this->_getSingleObject(
800	'category',
801	$category->parent,
802	'full'
803	);
804
805	if ($parentCategory !== null) {
806	$curCategory = get_category($objectId);
807	$parentCategory->name = $curCategory->name;
808
809	if (isset($parentCategory->recursiveMember)) {
810	$isRecursiveMember['category'][]
811	= $parentCategory;
812	} else {
813	$isRecursiveMember['category'][]
814	= $parentCategory;
815	}
816	}
817	}
818	}
819
820	return $isRecursiveMember;
821	}
822
823	/**
824	* Returns the categories in the group
825	*
826	* @param string $categories The real categories.
827	*
828	* @return array
829	*/
830	public function getFullCategories($categories)
831	{
832	$userAccessManager = $this->getAccessHandler()->getUserAccessManager();
833	$uamOptions = $userAccessManager->getAdminOptions();
834
835	foreach ($categories as $category) {
836	if ($category != null) {
837	if ($uamOptions['lock_recursive'] == 'true') {
838	//We have to remove the filter to get all categories
839	$removeSucc = remove_filter(
840	'get_terms',
841	array(
842	$this->getAccessHandler()->getUserAccessManager(),
843	'showCategory'
844	)
845	);
846
847	if ($removeSucc) {
848	$args = array(
849	'child_of' => $category->id,
850	'hide_empty' => false
851	);
852
853	$categoryChilds = get_categories($args);
854
855	add_filter(
856	'get_terms',
857	array(&$userAccessManager, 'showCategory')
858	);
859
860
861	foreach ($categoryChilds as $categoryChild) {
862	$curCategoryChild = new stdClass();
863	$curCategoryChild->id = $categoryChild->term_id;
864	$curCategoryChild->name = $categoryChild->name;
865
866	$curCategoryChild->recursiveMember
867	= array('category' => array());
868	$curCategoryChild->recursiveMember['category'][]
869	= $curCategoryChild;
870	$categories[$curCategoryChild->id]
871	= $curCategoryChild;
872	}
873	}
874	}
875
876	$categories[$category->id] = $category;
877	}
878	}
879
880	return $categories;
881	}
882
883
884	/*
885	* Group posts functions.
886	*/
887
888	/**
889	* Returns the membership of a single post.
890	*
891	* @param string $postType The post type needed for the intern representation.
892	* @param integer $objectId The object id.
893	*
894	* @return object
895	*/
896	private function _getFullPost($postType, $objectId)
897	{
898	$post = get_post($objectId);
899
900	$isRecursiveMember = array();
901
902	$userAccessManager = $this->getAccessHandler()->getUserAccessManager();
903	$uamOptions = $userAccessManager->getAdminOptions();
904
905	foreach ($this->getObjectsFromType('category', 'full') as $category) {
906	if (in_category($category->id, $post->ID)) {
907	$categoryObject = get_category($category->id);
908	$category->name = $categoryObject->name;
909
910	$isRecursiveMember['category'][] = $category;
911	}
912	}
913
914	if (get_option('show_on_front') == 'page'
915	&& $post->post_parent == 0
916	&& $post->post_type == 'post'
917	&& get_option('page_for_posts') != $objectId
918	) {
919	$parentId = get_option('page_for_posts');
920	} else {
921	$parentId = $post->post_parent;
922	}
923
924	if ($uamOptions['lock_recursive'] == 'true'
925	&& $parentId != 0
926	) {
927	$parent = get_post($parentId);
928
929	$parentPost = $this->_getSingleObject(
930	$parent->post_type,
931	$parentId,
932	'full'
933	);
934
935	if ($parentPost !== null) {
936	$postObject = get_post($parentPost->id);
937	$parentPost->name = $postObject->post_title;
938
939	$isRecursiveMember[$parent->post_type][] = $parentPost;
940	}
941	}
942
943	return $isRecursiveMember;
944	}
945
946
947	/*
948	* Group pluggable objects functions.
949	*/
950
951	/**
952	* Returns a the recursive membership for a pluggable object.
953	*
954	* @param string $objectType The pluggable object type.
955	* @param integer $objectId The object id.
956	*
957	* @return array
958	*/
959	private function _getFullPlObject($objectType, $objectId)
960	{
961	$isRecursiveMember = array();
962
963	$plObject = $this->getAccessHandler()->getPlObject($objectType);
964
965	if (isset($plObject['reference'])
966	&& isset($plObject['getFull'])
967	) {
968	$plRecMember = $plObject['reference']->{$plObject['getFull']}(
969	$objectId,
970	&$this
971	);
972
973	if (is_array($plRecMember)) {
974	$isRecursiveMember = $plRecMember;
975	}
976	}
977
978	return $isRecursiveMember;
979	}
980	}