KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > alfresco > repo > security > authority > AuthorityDAOImpl


1 /*
2  * Copyright (C) 2006 Alfresco, Inc.
3  *
4  * Licensed under the Mozilla Public License version 1.1
5  * with a permitted attribution clause. You may obtain a
6  * copy of the License at
7  *
8  * http://www.alfresco.org/legal/license.txt
9  *
10  * Unless required by applicable law or agreed to in writing,
11  * software distributed under the License is distributed on an
12  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
13  * either express or implied. See the License for the specific
14  * language governing permissions and limitations under the
15  * License.
16  */

17 package org.alfresco.repo.security.authority;
18
19 import java.io.Serializable JavaDoc;
20 import java.util.ArrayList JavaDoc;
21 import java.util.Collection JavaDoc;
22 import java.util.Collections JavaDoc;
23 import java.util.HashMap JavaDoc;
24 import java.util.HashSet JavaDoc;
25 import java.util.List JavaDoc;
26 import java.util.Set JavaDoc;
27
28 import org.alfresco.error.AlfrescoRuntimeException;
29 import org.alfresco.model.ContentModel;
30 import org.alfresco.repo.cache.SimpleCache;
31 import org.alfresco.repo.search.impl.lucene.QueryParser;
32 import org.alfresco.service.cmr.dictionary.DictionaryService;
33 import org.alfresco.service.cmr.repository.ChildAssociationRef;
34 import org.alfresco.service.cmr.repository.NodeRef;
35 import org.alfresco.service.cmr.repository.NodeService;
36 import org.alfresco.service.cmr.repository.StoreRef;
37 import org.alfresco.service.cmr.repository.datatype.DefaultTypeConverter;
38 import org.alfresco.service.cmr.search.ResultSet;
39 import org.alfresco.service.cmr.search.ResultSetRow;
40 import org.alfresco.service.cmr.search.SearchParameters;
41 import org.alfresco.service.cmr.search.SearchService;
42 import org.alfresco.service.cmr.security.AuthorityType;
43 import org.alfresco.service.namespace.NamespacePrefixResolver;
44 import org.alfresco.service.namespace.QName;
45 import org.alfresco.service.namespace.RegexQNamePattern;
46 import org.alfresco.util.ISO9075;
47
48 public class AuthorityDAOImpl implements AuthorityDAO
49 {
50     private static final StoreRef STOREREF_USERS = new StoreRef("user", "alfrescoUserStore");
51
52     private NodeService nodeService;
53     private NamespacePrefixResolver namespacePrefixResolver;
54     private QName qnameAssocSystem;
55     private QName qnameAssocAuthorities;
56     private SearchService searchService;
57     private DictionaryService dictionaryService;
58     private SimpleCache<String JavaDoc, ArrayList JavaDoc<NodeRef>> userToAuthorityCache;
59
60     public AuthorityDAOImpl()
61     {
62         super();
63     }
64
65     public void setDictionaryService(DictionaryService dictionaryService)
66     {
67         this.dictionaryService = dictionaryService;
68     }
69
70     public void setNamespacePrefixResolver(NamespacePrefixResolver namespacePrefixResolver)
71     {
72         this.namespacePrefixResolver = namespacePrefixResolver;
73         qnameAssocSystem = QName.createQName("sys", "system", namespacePrefixResolver);
74         qnameAssocAuthorities = QName.createQName("sys", "authorities", namespacePrefixResolver);
75     }
76
77     public void setNodeService(NodeService nodeService)
78     {
79         this.nodeService = nodeService;
80     }
81
82     public void setSearchService(SearchService searchService)
83     {
84         this.searchService = searchService;
85     }
86
87     public void setUserToAuthorityCache(SimpleCache<String JavaDoc, ArrayList JavaDoc<NodeRef>> userToAuthorityCache)
88     {
89         this.userToAuthorityCache = userToAuthorityCache;
90     }
91
92     public void addAuthority(String JavaDoc parentName, String JavaDoc childName)
93     {
94         NodeRef parentRef = getAuthorityOrNull(parentName);
95         if (parentRef == null)
96         {
97             throw new UnknownAuthorityException("An authority was not found for " + parentName);
98         }
99         if (AuthorityType.getAuthorityType(childName).equals(AuthorityType.USER))
100         {
101             Collection JavaDoc<String JavaDoc> memberCollection = DefaultTypeConverter.INSTANCE.getCollection(String JavaDoc.class, nodeService
102                     .getProperty(parentRef, ContentModel.PROP_MEMBERS));
103             HashSet JavaDoc<String JavaDoc> members = new HashSet JavaDoc<String JavaDoc>();
104             members.addAll(memberCollection);
105             members.add(childName);
106             nodeService.setProperty(parentRef, ContentModel.PROP_MEMBERS, members);
107             userToAuthorityCache.remove(childName);
108         }
109         else
110         {
111             NodeRef childRef = getAuthorityOrNull(childName);
112             if (childRef == null)
113             {
114                 throw new UnknownAuthorityException("An authority was not found for " + childName);
115             }
116             nodeService.addChild(
117                     parentRef,
118                     childRef,
119                     ContentModel.ASSOC_MEMBER,
120                     QName.createQName("usr", childName, namespacePrefixResolver));
121         }
122
123     }
124
125     public void createAuthority(String JavaDoc parentName, String JavaDoc name)
126     {
127         HashMap JavaDoc<QName, Serializable JavaDoc> props = new HashMap JavaDoc<QName, Serializable JavaDoc>();
128         props.put(ContentModel.PROP_AUTHORITY_NAME, name);
129         if (parentName != null)
130         {
131             NodeRef parentRef = getAuthorityOrNull(parentName);
132             if (parentRef == null)
133             {
134                 throw new UnknownAuthorityException("An authority was not found for " + parentName);
135             }
136             nodeService.createNode(
137                     parentRef,
138                     ContentModel.ASSOC_MEMBER,
139                     QName.createQName("usr", name, namespacePrefixResolver),
140                     ContentModel.TYPE_AUTHORITY_CONTAINER,
141                     props);
142         }
143         else
144         {
145             NodeRef authorityContainerRef = getAuthorityContainer();
146             nodeService.createNode(
147                     authorityContainerRef,
148                     ContentModel.ASSOC_MEMBER,
149                     QName.createQName("usr", name, namespacePrefixResolver),
150                     ContentModel.TYPE_AUTHORITY_CONTAINER,
151                     props);
152         }
153     }
154
155     public void deleteAuthority(String JavaDoc name)
156     {
157         NodeRef nodeRef = getAuthorityOrNull(name);
158         if (nodeRef == null)
159         {
160             throw new UnknownAuthorityException("An authority was not found for " + name);
161         }
162         nodeService.deleteNode(nodeRef);
163
164     }
165
166     public Set JavaDoc<String JavaDoc> getAllRootAuthorities(AuthorityType type)
167     {
168         HashSet JavaDoc<String JavaDoc> authorities = new HashSet JavaDoc<String JavaDoc>();
169         NodeRef container = getAuthorityContainer();
170         if (container != null)
171         {
172             findAuthorities(type, container, authorities, false, false, false);
173         }
174         return authorities;
175     }
176
177     public Set JavaDoc<String JavaDoc> getAllAuthorities(AuthorityType type)
178     {
179         HashSet JavaDoc<String JavaDoc> authorities = new HashSet JavaDoc<String JavaDoc>();
180         NodeRef container = getAuthorityContainer();
181         if (container != null)
182         {
183             findAuthorities(type, container, authorities, false, true, false);
184         }
185         return authorities;
186     }
187
188     public Set JavaDoc<String JavaDoc> getContainedAuthorities(AuthorityType type, String JavaDoc name, boolean immediate)
189     {
190         if (AuthorityType.getAuthorityType(name).equals(AuthorityType.USER))
191         {
192             return Collections.<String JavaDoc> emptySet();
193         }
194         else
195         {
196             NodeRef nodeRef = getAuthorityOrNull(name);
197             if (nodeRef == null)
198             {
199                 throw new UnknownAuthorityException("An authority was not found for " + name);
200             }
201             HashSet JavaDoc<String JavaDoc> authorities = new HashSet JavaDoc<String JavaDoc>();
202             findAuthorities(type, nodeRef, authorities, false, !immediate, false);
203             return authorities;
204         }
205     }
206
207     public void removeAuthority(String JavaDoc parentName, String JavaDoc childName)
208     {
209         NodeRef parentRef = getAuthorityOrNull(parentName);
210         if (parentRef == null)
211         {
212             throw new UnknownAuthorityException("An authority was not found for " + parentName);
213         }
214         if (AuthorityType.getAuthorityType(childName).equals(AuthorityType.USER))
215         {
216             Collection JavaDoc<String JavaDoc> memberCollection = DefaultTypeConverter.INSTANCE.getCollection(String JavaDoc.class, nodeService
217                     .getProperty(parentRef, ContentModel.PROP_MEMBERS));
218             HashSet JavaDoc<String JavaDoc> members = new HashSet JavaDoc<String JavaDoc>();
219             members.addAll(memberCollection);
220             members.remove(childName);
221             nodeService.setProperty(parentRef, ContentModel.PROP_MEMBERS, members);
222             userToAuthorityCache.remove(childName);
223         }
224         else
225         {
226             NodeRef childRef = getAuthorityOrNull(childName);
227             if (childRef == null)
228             {
229                 throw new UnknownAuthorityException("An authority was not found for " + childName);
230             }
231             nodeService.removeChild(parentRef, childRef);
232         }
233
234     }
235
236     public Set JavaDoc<String JavaDoc> getContainingAuthorities(AuthorityType type, String JavaDoc name, boolean immediate)
237     {
238         HashSet JavaDoc<String JavaDoc> authorities = new HashSet JavaDoc<String JavaDoc>();
239         findAuthorities(type, name, authorities, true, !immediate);
240         return authorities;
241     }
242
243     private void findAuthorities(AuthorityType type, String JavaDoc name, Set JavaDoc<String JavaDoc> authorities, boolean parents,
244             boolean recursive)
245     {
246         if (AuthorityType.getAuthorityType(name).equals(AuthorityType.GUEST))
247         {
248             // Nothing to do
249
}
250         else if (AuthorityType.getAuthorityType(name).equals(AuthorityType.USER))
251         {
252             for (NodeRef ref : getUserContainers(name))
253             {
254                 findAuthorities(type, ref, authorities, parents, recursive, true);
255             }
256
257         }
258         else
259         {
260             NodeRef ref = getAuthorityOrNull(name);
261
262             if (ref == null)
263             {
264                 throw new UnknownAuthorityException("An authority was not found for " + name);
265             }
266
267             findAuthorities(type, ref, authorities, parents, recursive, false);
268
269         }
270     }
271
272     private ArrayList JavaDoc<NodeRef> getUserContainers(String JavaDoc name)
273     {
274         ArrayList JavaDoc<NodeRef> containers = userToAuthorityCache.get(name);
275         if (containers == null)
276         {
277             containers = findUserContainers(name);
278             userToAuthorityCache.put(name, containers);
279         }
280         return containers;
281     }
282
283     private ArrayList JavaDoc<NodeRef> findUserContainers(String JavaDoc name)
284     {
285         SearchParameters sp = new SearchParameters();
286         sp.addStore(STOREREF_USERS);
287         sp.setLanguage("lucene");
288         sp.setQuery("+TYPE:\""
289                 + ContentModel.TYPE_AUTHORITY_CONTAINER
290                 + "\""
291                 + " +@"
292                 + QueryParser.escape("{"
293                         + ContentModel.PROP_MEMBERS.getNamespaceURI() + "}"
294                         + ISO9075.encode(ContentModel.PROP_MEMBERS.getLocalName())) + ":\"" + name + "\"");
295         ResultSet rs = null;
296         try
297         {
298             rs = searchService.query(sp);
299             ArrayList JavaDoc<NodeRef> answer = new ArrayList JavaDoc<NodeRef>(rs.length());
300             for (ResultSetRow row : rs)
301             {
302                 answer.add(row.getNodeRef());
303             }
304             return answer;
305         }
306         finally
307         {
308             if (rs != null)
309             {
310                 rs.close();
311             }
312         }
313
314     }
315
316     private void findAuthorities(AuthorityType type, NodeRef nodeRef, Set JavaDoc<String JavaDoc> authorities, boolean parents,
317             boolean recursive, boolean includeNode)
318     {
319         List JavaDoc<ChildAssociationRef> cars = parents ? nodeService.getParentAssocs(nodeRef) : nodeService
320                 .getChildAssocs(nodeRef);
321
322         if (includeNode)
323         {
324             String JavaDoc authorityName = DefaultTypeConverter.INSTANCE.convert(String JavaDoc.class, nodeService.getProperty(nodeRef,
325                     ContentModel.PROP_AUTHORITY_NAME));
326             if (type == null)
327             {
328                 authorities.add(authorityName);
329             }
330             else
331             {
332                 AuthorityType authorityType = AuthorityType.getAuthorityType(authorityName);
333                 if (authorityType.equals(type))
334                 {
335                     authorities.add(authorityName);
336                 }
337             }
338         }
339
340         // Loop over children
341
for (ChildAssociationRef car : cars)
342         {
343             NodeRef current = parents ? car.getParentRef() : car.getChildRef();
344             QName currentType = nodeService.getType(current);
345             if (dictionaryService.isSubClass(currentType, ContentModel.TYPE_AUTHORITY))
346             {
347
348                 String JavaDoc authorityName = DefaultTypeConverter.INSTANCE.convert(String JavaDoc.class, nodeService.getProperty(
349                         current, ContentModel.PROP_AUTHORITY_NAME));
350
351                 if (type == null)
352                 {
353                     authorities.add(authorityName);
354                     if (recursive)
355                     {
356                         findAuthorities(type, current, authorities, parents, recursive, false);
357                     }
358                 }
359                 else
360                 {
361                     AuthorityType authorityType = AuthorityType.getAuthorityType(authorityName);
362                     if (authorityType.equals(type))
363                     {
364                         authorities.add(authorityName);
365                     }
366                     if (recursive)
367                     {
368                         findAuthorities(type, current, authorities, parents, recursive, false);
369                     }
370                 }
371             }
372         }
373         // loop over properties
374
if (!parents)
375         {
376             Collection JavaDoc<String JavaDoc> members = DefaultTypeConverter.INSTANCE.getCollection(String JavaDoc.class, nodeService
377                     .getProperty(nodeRef, ContentModel.PROP_MEMBERS));
378             if (members != null)
379             {
380                 for (String JavaDoc user : members)
381                 {
382                     if (user != null)
383                     {
384                         if (type == null)
385                         {
386                             authorities.add(user);
387                         }
388                         else
389                         {
390                             AuthorityType authorityType = AuthorityType.getAuthorityType(user);
391                             if (authorityType.equals(type))
392                             {
393                                 authorities.add(user);
394                             }
395                         }
396                     }
397                 }
398             }
399         }
400     }
401
402     private NodeRef getAuthorityOrNull(String JavaDoc name)
403     {
404         SearchParameters sp = new SearchParameters();
405         sp.addStore(STOREREF_USERS);
406         sp.setLanguage("lucene");
407         sp.setQuery("+TYPE:\""
408                 + ContentModel.TYPE_AUTHORITY_CONTAINER
409                 + "\""
410                 + " +@"
411                 + QueryParser.escape("{"
412                         + ContentModel.PROP_AUTHORITY_NAME.getNamespaceURI() + "}"
413                         + ISO9075.encode(ContentModel.PROP_AUTHORITY_NAME.getLocalName())) + ":\"" + name + "\"");
414         ResultSet rs = null;
415         try
416         {
417             rs = searchService.query(sp);
418             if (rs.length() == 0)
419             {
420                 return null;
421             }
422             else
423             {
424                 for (ResultSetRow row : rs)
425                 {
426                     String JavaDoc test = DefaultTypeConverter.INSTANCE.convert(
427                             String JavaDoc.class,
428                             nodeService.getProperty(row.getNodeRef(), ContentModel.PROP_AUTHORITY_NAME));
429                     if (test.equals(name))
430                     {
431                         return row.getNodeRef();
432                     }
433                 }
434             }
435             return null;
436         }
437         finally
438         {
439             if (rs != null)
440             {
441                 rs.close();
442             }
443         }
444
445     }
446
447     /**
448      * @return Returns the authority container, <b>which must exist</b>
449      */

450     private NodeRef getAuthorityContainer()
451     {
452         NodeRef rootNodeRef = nodeService.getRootNode(STOREREF_USERS);
453         List JavaDoc<ChildAssociationRef> results = nodeService.getChildAssocs(
454                 rootNodeRef,
455                 RegexQNamePattern.MATCH_ALL,
456                 qnameAssocSystem);
457         NodeRef sysNodeRef = null;
458         if (results.size() == 0)
459         {
460             throw new AlfrescoRuntimeException("Required authority system path not found: " + qnameAssocSystem);
461         }
462         else
463         {
464             sysNodeRef = results.get(0).getChildRef();
465         }
466         results = nodeService.getChildAssocs(
467                 sysNodeRef,
468                 RegexQNamePattern.MATCH_ALL,
469                 qnameAssocAuthorities);
470         NodeRef authNodeRef = null;
471         if (results.size() == 0)
472         {
473             throw new AlfrescoRuntimeException("Required authority path not found: " + qnameAssocAuthorities);
474         }
475         else
476         {
477             authNodeRef = results.get(0).getChildRef();
478         }
479         return authNodeRef;
480     }
481 }
482
Popular Tags