1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.neo4j.examples;
21
22 import java.io.File;
23
24 import org.junit.AfterClass;
25 import org.junit.BeforeClass;
26 import org.junit.Test;
27 import org.neo4j.graphdb.Direction;
28 import org.neo4j.graphdb.GraphDatabaseService;
29 import org.neo4j.graphdb.Node;
30 import org.neo4j.graphdb.Relationship;
31 import org.neo4j.graphdb.RelationshipType;
32 import org.neo4j.graphdb.ReturnableEvaluator;
33 import org.neo4j.graphdb.StopEvaluator;
34 import org.neo4j.graphdb.Transaction;
35 import org.neo4j.graphdb.TraversalPosition;
36 import org.neo4j.graphdb.Traverser;
37 import org.neo4j.graphdb.index.Index;
38 import org.neo4j.kernel.EmbeddedGraphDatabase;
39
40 public class RolesOldTest
41 {
42 private static final String GROUP = "group";
43 private static final String USER = "user";
44 private static final String NAME = "name";
45
46 public enum RoleRels implements RelationshipType
47 {
48 ROOT,
49 PART_OF,
50 MEMBER_OF;
51 }
52
53 private static final String ROLES_DB = "target/roles-db";
54 private static GraphDatabaseService graphDb;
55 private static Index<Node> index;
56
57 @BeforeClass
58 public static void setUp()
59 {
60 deleteFileOrDirectory( new File( ROLES_DB ) );
61 graphDb = new EmbeddedGraphDatabase( ROLES_DB );
62 index = graphDb.index().forNodes( "nodes" );
63 registerShutdownHook();
64 createNodespace();
65 }
66
67 @AfterClass
68 public static void tearDown()
69 {
70 graphDb.shutdown();
71 }
72
73 private static void createNodespace()
74 {
75 Transaction tx = graphDb.beginTx();
76 try
77 {
78
79 Node admins = createTopLevelGroup( "Admins" );
80 Node users = createTopLevelGroup( "Users" );
81
82
83 Node helpDesk = createGroup( "HelpDesk", admins );
84 Node managers = createGroup( "Managers", users );
85 Node technicians = createGroup( "Technicians", users );
86 Node abcTechnicians = createGroup( "ABCTechnicians", technicians );
87
88
89 createUser( "Ali", admins, users );
90 createUser( "Burcu", users );
91 createUser( "Can", users );
92 createUser( "Demet", helpDesk );
93 createUser( "Engin", helpDesk, users );
94 createUser( "Fuat", managers );
95 createUser( "Gul", managers );
96 createUser( "Hakan", technicians );
97 createUser( "Irmak", technicians );
98 createUser( "Jale", abcTechnicians );
99
100 tx.success();
101 }
102 finally
103 {
104 tx.finish();
105 }
106 }
107
108 public static void createRoles()
109 {
110 Transaction tx = graphDb.beginTx();
111 try
112 {
113 tx.success();
114 }
115 finally
116 {
117 tx.finish();
118 }
119 }
120
121 private static Node createTopLevelGroup( final String name )
122 {
123 return createNode( name, RoleRels.ROOT, GROUP,
124 graphDb.getReferenceNode() );
125 }
126
127 private static Node createGroup( final String name,
128 final Node... containedIn )
129 {
130 return createNode( name, RoleRels.PART_OF, GROUP, containedIn );
131 }
132
133 private static Node createUser( final String name,
134 final Node... containedIn )
135 {
136 return createNode( name, RoleRels.MEMBER_OF, USER, containedIn );
137 }
138
139 private static Node createNode( final String name,
140 final RelationshipType relType, final String category,
141 final Node... containedIn )
142 {
143 Node node = graphDb.createNode();
144 node.setProperty( NAME, name );
145 index.add( node, category, name );
146 for ( Node parent : containedIn )
147 {
148 node.createRelationshipTo( parent, relType );
149 }
150 return node;
151 }
152
153 private static Node getUserByName( final String name )
154 {
155 return getNodeByName( USER, name );
156 }
157
158 private static Node getGroupByName( String name )
159 {
160 return getNodeByName( GROUP, name );
161 }
162
163 private static Node getNodeByName( final String category, final String name )
164 {
165 return index.get( category, name ).getSingle();
166 }
167
168 @Test
169 public void getAllAdmins()
170 {
171 Transaction tx = graphDb.beginTx();
172 try
173 {
174 System.out.println( "All admins:" );
175
176 Node admins = getGroupByName( "Admins" );
177 Traverser traverser = admins.traverse(
178 Traverser.Order.BREADTH_FIRST, StopEvaluator.END_OF_GRAPH,
179 ReturnableEvaluator.ALL_BUT_START_NODE, RoleRels.PART_OF,
180 Direction.INCOMING, RoleRels.MEMBER_OF, Direction.INCOMING );
181 for ( Node part : traverser )
182 {
183 System.out.println( part.getProperty( NAME )
184 + " "
185 + ( traverser.currentPosition().depth() - 1 ) );
186 }
187
188 tx.success();
189 }
190 finally
191 {
192 tx.finish();
193 }
194 }
195
196 @Test
197 public void getJalesMemberships() throws Exception
198 {
199 Transaction tx = graphDb.beginTx();
200 try
201 {
202 System.out.println( "Jale's memberships:" );
203
204 Node jale = getUserByName( "Jale" );
205 Traverser traverser = jale.traverse( Traverser.Order.DEPTH_FIRST,
206 StopEvaluator.END_OF_GRAPH,
207 ReturnableEvaluator.ALL_BUT_START_NODE, RoleRels.MEMBER_OF,
208 Direction.OUTGOING, RoleRels.PART_OF, Direction.OUTGOING );
209 for ( Node membership : traverser )
210 {
211 System.out.println( membership.getProperty( NAME )
212 + " "
213 + ( traverser.currentPosition().depth() - 1 ) );
214 }
215
216 tx.success();
217 }
218 finally
219 {
220 tx.finish();
221 }
222 }
223
224 @Test
225 public void getAllGroups() throws Exception
226 {
227 Transaction tx = graphDb.beginTx();
228 try
229 {
230 System.out.println( "All groups:" );
231
232 Node referenceNode = graphDb.getReferenceNode();
233 Traverser traverser = referenceNode.traverse(
234 Traverser.Order.BREADTH_FIRST, StopEvaluator.END_OF_GRAPH,
235 ReturnableEvaluator.ALL_BUT_START_NODE, RoleRels.ROOT,
236 Direction.INCOMING, RoleRels.PART_OF, Direction.INCOMING );
237 for ( Node group : traverser )
238 {
239 System.out.println( group.getProperty( NAME ) );
240 }
241
242 tx.success();
243 }
244 finally
245 {
246 tx.finish();
247 }
248 }
249
250 @Test
251 public void getAllMembers() throws Exception
252 {
253 Transaction tx = graphDb.beginTx();
254 try
255 {
256 System.out.println( "All members:" );
257
258 Node referenceNode = graphDb.getReferenceNode();
259 Traverser traverser = referenceNode.traverse(
260 Traverser.Order.BREADTH_FIRST, StopEvaluator.END_OF_GRAPH,
261 new ReturnableEvaluator()
262 {
263 public boolean isReturnableNode(
264 TraversalPosition currentPos )
265 {
266 if ( currentPos.isStartNode() )
267 {
268 return false;
269 }
270 Relationship rel = currentPos.lastRelationshipTraversed();
271 return rel.isType( RoleRels.MEMBER_OF );
272 }
273 }, RoleRels.ROOT,
274 Direction.INCOMING, RoleRels.PART_OF, Direction.INCOMING,
275 RoleRels.MEMBER_OF, Direction.INCOMING );
276 for ( Node group : traverser )
277 {
278 System.out.println( group.getProperty( NAME ) );
279 }
280
281 tx.success();
282 }
283 finally
284 {
285 tx.finish();
286 }
287 }
288
289 private static void registerShutdownHook()
290 {
291
292
293
294 Runtime.getRuntime().addShutdownHook( new Thread()
295 {
296 @Override
297 public void run()
298 {
299 graphDb.shutdown();
300 }
301 } );
302 }
303
304 private static void deleteFileOrDirectory( final File file )
305 {
306 if ( !file.exists() )
307 {
308 return;
309 }
310
311 if ( file.isDirectory() )
312 {
313 for ( File child : file.listFiles() )
314 {
315 deleteFileOrDirectory( child );
316 }
317 }
318 else
319 {
320 file.delete();
321 }
322 }
323 }