KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > mmbase > security > implementation > cloudcontext > builders > Groups


1 /*
2
3 This software is OSI Certified Open Source Software.
4 OSI Certified is a certification mark of the Open Source Initiative.
5
6 The license (Mozilla version 1.0) can be read at the MMBase site.
7 See http://www.MMBase.org/license
8
9 */

10 package org.mmbase.security.implementation.cloudcontext.builders;
11
12 import org.mmbase.security.implementation.cloudcontext.*;
13 import java.util.*;
14 import org.mmbase.module.core.*;
15 import org.mmbase.module.corebuilders.*;
16 import org.mmbase.cache.Cache;
17 import org.mmbase.util.logging.Logger;
18 import org.mmbase.util.logging.Logging;
19 import org.mmbase.storage.search.implementation.*;
20 import org.mmbase.storage.search.*;
21
22 /**
23  * Groups of users. A group can also contain other groups. Containing
24  * is arranged by the 'containsrel' relations type.
25  *
26  * @author Eduard Witteveen
27  * @author Pierre van Rooden
28  * @author Michiel Meeuwissen
29  * @version $Id: Groups.java,v 1.18 2006/07/17 07:19:15 pierre Exp $
30  */

31 public class Groups extends MMObjectBuilder {
32     private static final Logger log = Logging.getLoggerInstance(Groups.class);
33
34
35     protected static Cache containsCache = new Cache(500) {
36             public String JavaDoc getName() { return "CCS:ContainedBy"; }
37             public String JavaDoc getDescription() { return "group + group/user --> boolean"; }
38         };
39
40
41     // javadoc inherited
42
public boolean init() {
43         containsCache.putCache();
44         CacheInvalidator.getInstance().addCache(containsCache);
45         mmb.addLocalObserver(getTableName(), CacheInvalidator.getInstance());
46         mmb.addRemoteObserver(getTableName(), CacheInvalidator.getInstance());
47         return super.init();
48     }
49
50
51     /**
52      * @return the MMObjectBuilder mmbasegroups cast to a Groups
53      */

54     public static Groups getBuilder() {
55         return (Groups) MMBase.getMMBase().getBuilder("mmbasegroups");
56     }
57
58     /**
59      * Checks wether a a certain user is part of a certain group, either directly or indirectly.
60      * @todo This could perhaps be just as logicly be implemented in Users rather than Groups (and groups becomes Dummy).
61      */

62     public boolean contains(MMObjectNode group, User user) {
63         return contains(group, user.getNode());
64     }
65
66     protected boolean contains(MMObjectNode containingGroup, MMObjectNode groupOrUser) {
67         return contains(containingGroup, groupOrUser.getNumber());
68     }
69
70     /**
71      * Checks wether group or user identified by number is contained by group (also indirectly)
72      */

73     protected boolean contains(MMObjectNode containingGroupNode, int containedObject) {
74         return contains(containingGroupNode, containedObject, new HashSet());
75     }
76
77
78     /**
79      * Checks wether group or user identified by number is contained by group.
80      *
81      */

82     protected boolean contains(MMObjectNode containingGroupNode, int containedObject, Set recurse) {
83         int containingGroup = containingGroupNode.getNumber();
84         String JavaDoc key = "" + containingGroup + "/" + containedObject;
85         Boolean JavaDoc result = (Boolean JavaDoc) containsCache.get(key);
86
87         if (result == null) {
88             int role = mmb.getRelDef().getNumberByName("contains");
89             InsRel insrel = mmb.getRelDef().getBuilder(role);
90
91             MMObjectBuilder object = mmb.getBuilder("object");
92             BasicSearchQuery query = new BasicSearchQuery();
93             Step step = query.addStep(object);
94             BasicStepField numberStepField = new BasicStepField(step, object. getField("number"));
95             BasicFieldValueConstraint numberConstraint = new BasicFieldValueConstraint(numberStepField, new Integer JavaDoc(containedObject));
96
97             BasicRelationStep relationStep = query.addRelationStep(insrel, this);
98             relationStep.setDirectionality(RelationStep.DIRECTIONS_SOURCE);
99
100             query.setConstraint(numberConstraint);
101             query.addFields(relationStep.getNext());
102
103             List resultList;
104             try {
105                 resultList = storageConnector.getNodes(query, false);
106             } catch (SearchQueryException sqe) {
107                 log.error(sqe.getMessage());
108                 resultList = new ArrayList();
109             }
110
111             Iterator i = resultList.iterator();
112
113             result = Boolean.FALSE;
114             while (i.hasNext()) {
115                 MMObjectNode group = (MMObjectNode) i.next();
116
117                 if (group.getNumber() == containingGroup) {
118                     log.trace("yes!");
119                     result = Boolean.TRUE;
120                     break;
121                 } else if (recurse != null) {
122                     log.trace("recursively");
123                     Integer JavaDoc groupNumber = new Integer JavaDoc(group.getNumber());
124                     if (! recurse.contains(groupNumber)) {
125                         recurse.add(groupNumber);
126                         if (contains(containingGroupNode, group.getNumber(), recurse)) {
127                             result = Boolean.TRUE;
128                             break;
129                         }
130                     }
131                 }
132             }
133
134             containsCache.put(key, result);
135         }
136
137         return result.booleanValue();
138     }
139
140     /**
141      * Returns all groups, which are (directly or indirectly) containing the given object (user/group)
142      */

143
144     public SortedSet getGroups(int containedObject) {
145         SortedSet result = new TreeSet();
146         try {
147             Iterator nodes = getNodes(new NodeSearchQuery(this)).iterator();
148             while (nodes.hasNext()) {
149                 MMObjectNode group = (MMObjectNode) nodes.next();
150                 if (contains(group, containedObject)) {
151                     result.add(new Integer JavaDoc(group.getNumber()));
152                 } else {
153                 }
154             }
155         } catch (org.mmbase.storage.search.SearchQueryException sqe) {
156             log.error(sqe.toString());
157         }
158         return result;
159     }
160
161     /**
162      * unused, ie untested
163     public void addGroup(User user, MMObjectNode group, Verify verify) {
164         for (Enumeration enumeration = user.getNode().getRelations(); enumeration.hasMoreElements();) {
165             MMObjectNode relation = getNode(((MMObjectNode)enumeration.nextElement()).getNumber());
166             if (relation.parent instanceof ContainsRel) {
167                 MMObjectNode source = relation.getNodeValue("snumber");
168                 MMObjectNode destination = relation.getNodeValue("dnumber");
169                 if (destination.getNumber() == user.getNode().getNumber() && source.getBuilder() == this) {
170                     MMObjectNode newRelation = ContainsRel.getBuilder().grantRightsTo(group, source);
171                     verify.create(user, newRelation.getNumber());
172                 }
173             }
174         }
175     }
176      */

177
178     public void setDefaults(MMObjectNode node) {
179         setUniqueValue(node, "name", "group");
180     }
181
182
183     public String JavaDoc toString(MMObjectNode n) {
184         return n.getStringValue("name");
185     }
186
187
188     // needed to make SecurityOpeations Cache work?
189
public boolean equals(MMObjectNode o1, MMObjectNode o2) {
190         return o1.getNumber() == o2.getNumber();
191     }
192
193
194 }
195
Popular Tags