KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > contineo > admin > dao > GroupDAO


1 package org.contineo.admin.dao;
2
3 import java.util.ArrayList JavaDoc;
4 import java.util.Collection JavaDoc;
5 import java.util.Iterator JavaDoc;
6 import org.apache.log4j.Level;
7 import org.apache.log4j.Logger;
8 import org.apache.ojb.broker.PBKey;
9 import org.apache.ojb.broker.PersistenceBroker;
10 import org.apache.ojb.broker.PersistenceBrokerFactory;
11 import org.apache.ojb.broker.query.Criteria;
12 import org.apache.ojb.broker.query.Query;
13 import org.apache.ojb.broker.query.QueryByCriteria;
14 import org.contineo.admin.Group;
15 import org.contineo.admin.MenuGroup;
16 import org.contineo.core.LoggingManager;
17
18 /**
19  * This class is a DAO-service for group objects.
20  * Created on 19. August 2003, 14:17
21  * @author Michael Scholz
22  * @version 1.0
23  */
24 public class GroupDAO {
25
26     /**
27      * @uml.property name="broker"
28      * @uml.associationEnd
29      */
30     private PersistenceBroker broker = null;
31
32     /**
33      * @uml.property name="pbkey"
34      * @uml.associationEnd
35      */
36     private PBKey pbkey;
37
38     /**
39      * @uml.property name="logger"
40      * @uml.associationEnd
41      */
42     private Logger logger;
43
44     
45     /** Creates a new instance of GroupDAO */
46     public GroupDAO() {
47         logger = LoggingManager.getLogger(this.getClass());
48         pbkey = new PBKey("contineo");
49     }
50
51     /** This method persists a new group object.
52      * @param group Group which should be stored in a database.
53      * @return True if successful stored in a database.
54      */
55     public boolean insert(Group group) {
56         boolean result = true;
57         if (group == null)
58             return false;
59         try {
60             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
61             MenuGroupDAO mgdao = new MenuGroupDAO();
62             String JavaDoc parentGroup = group.getParentGroup();
63             if (parentGroup != null && !parentGroup.equals("")) {
64                 Collection JavaDoc menus = mgdao.findByGroupName(parentGroup);
65                 Iterator JavaDoc miter = menus.iterator();
66                 broker.beginTransaction();
67                 broker.store(group);
68                 while (miter.hasNext()) {
69                     MenuGroup mg = (MenuGroup)miter.next();
70                     addGroupAccess(group, mg.getMenuId(), mg.getWriteEnable());
71                 }
72                 broker.commitTransaction();
73             } else {
74                 broker.beginTransaction();
75                 broker.store(group);
76                 
77                 // if no parent group was given, the new group will have default access rights
78 addGroupAccess(group, 1, 0); // home
79 addGroupAccess(group, 4, 0); // personal
80 addGroupAccess(group, 5, 1); // root folder for documents
81 addGroupAccess(group, 13, 0); // messages
82 addGroupAccess(group, 14, 0); // create messages
83 addGroupAccess(group, 15, 0); // read messages
84 addGroupAccess(group, 16, 0); // change password
85 addGroupAccess(group, 19, 0); // edit me
86 addGroupAccess(group, 20, 0); // emails
87 addGroupAccess(group, 21, 0); // inbox
88 addGroupAccess(group, 22, 0); // outbox
89 addGroupAccess(group, 23, 0); // addemail
90 addGroupAccess(group, 24, 0); // email accounts
91 addGroupAccess(group, 26, 1); // keywords
92 addGroupAccess(group, 28, 0); // search settings
93 broker.commitTransaction();
94             }
95         }
96         catch (Exception JavaDoc e) {
97             broker.abortTransaction();
98             if (logger.isEnabledFor(Level.ERROR))
99                 logger.error(e.getMessage());
100             result = false;
101         } finally {
102             if (broker != null) broker.close();
103         }
104         return result;
105     }
106
107     /**
108      * Assigns the given rights for a certain group to a menu
109      * @param group the group
110      * @param menuId the menu
111      * @param writeable the rights to assign (0=read; 1=read/write)
112      */
113     private void addGroupAccess(Group group, int menuId, int writeable) {
114         if (broker == null)
115             return;
116         MenuGroup mgroup = new MenuGroup();
117         mgroup.setMenuId(menuId);
118         mgroup.setGroupName(group.getGroupName());
119         mgroup.setWriteEnable(writeable);
120         broker.store(mgroup);
121     }
122
123     /** This method persists a group object.
124      * @param group Group which should be stored in a database.
125      * @return True if successful stored in a database.
126      */
127     public boolean store(Group group) {
128         boolean result = true;
129         try {
130             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
131             broker.beginTransaction();
132             broker.store(group);
133             broker.commitTransaction();
134         }
135         catch (Exception JavaDoc e) {
136             broker.abortTransaction();
137             if (logger.isEnabledFor(Level.ERROR))
138                 logger.error(e.getMessage());
139             result = false;
140         } finally {
141             if (broker != null) broker.close();
142         }
143         return result;
144     }
145
146     /**
147      * This method deletes a group in database.
148      * @param groupname Groupname of group to be deleted.
149      * @return True if successful deleted.
150      */
151     public boolean delete(String JavaDoc groupname) {
152         boolean result = true;
153         try {
154             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
155             Criteria crit = new Criteria();
156             crit.addEqualTo("co_groupname", groupname);
157             Query query = new QueryByCriteria(org.contineo.admin.Group.class, crit);
158             Query mgquery = new QueryByCriteria(org.contineo.admin.MenuGroup.class, crit);
159             Query ugquery = new QueryByCriteria(org.contineo.admin.UserGroup.class, crit);
160             broker.beginTransaction();
161             broker.deleteByQuery(ugquery);
162             broker.deleteByQuery(mgquery);
163             broker.deleteByQuery(query);
164             broker.commitTransaction();
165         }
166         catch (Exception JavaDoc e) {
167             broker.abortTransaction();
168             if (logger.isEnabledFor(Level.ERROR))
169                 logger.error(e.getMessage());
170             result = false;
171         } finally {
172             if (broker != null) broker.close();
173         }
174         return result;
175     }
176
177     /**
178      * Finds a group by primarykey.
179      * @param groupname Primarykey of wanted group.
180      * @return Wanted group or null.
181      */
182     public Group findByPrimaryKey(String JavaDoc groupname) {
183         Group group = new Group();
184         try {
185             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
186             Criteria crit = new Criteria();
187             crit.addEqualTo("co_groupname", groupname);
188             Query query = new QueryByCriteria(org.contineo.admin.Group.class, crit);
189             group = (Group)broker.getObjectByQuery(query);
190         }
191         catch (Exception JavaDoc e) {
192             if (logger.isEnabledFor(Level.ERROR))
193                 logger.error(e.getMessage());
194         } finally {
195             if (broker != null) broker.close();
196         }
197         return group;
198     }
199
200     /**
201      * Finds a group by groupname.
202      * @param groupname Groupname of wanted group.
203      * @return Collection of groups.
204      */
205     public Collection JavaDoc findByGroupName(String JavaDoc groupname) {
206         Collection JavaDoc coll = null;
207         try {
208             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
209             broker.clearCache();
210             Criteria crit = new Criteria();
211             crit.addLike("co_groupname", groupname);
212             Query query = new QueryByCriteria(org.contineo.admin.Group.class, crit);
213             coll = broker.getCollectionByQuery(query);
214         }
215         catch (Exception JavaDoc e) {
216             if (logger.isEnabledFor(Level.ERROR))
217                 logger.error(e.getMessage());
218         } finally {
219             if (broker != null) broker.close();
220         }
221         return coll;
222     }
223
224     /**
225      * This method selects all groups.
226      */
227     public Collection JavaDoc findAll() {
228         Collection JavaDoc coll = null;
229         try {
230             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
231             broker.clearCache();
232             Query query = new QueryByCriteria(org.contineo.admin.Group.class, new Criteria());
233             coll = broker.getCollectionByQuery(query);
234         }
235         catch (Exception JavaDoc e) {
236             if (logger.isEnabledFor(Level.ERROR))
237                 logger.error(e.getMessage());
238         } finally {
239             if (broker != null) broker.close();
240         }
241         return coll;
242     }
243     
244     /**
245      * This method selects all groupnames.
246      */
247     public Collection JavaDoc findAllGroupNames() {
248         Collection JavaDoc<String JavaDoc> coll = new ArrayList JavaDoc<String JavaDoc>();
249         try {
250             Collection JavaDoc coll2 = findAll();
251             Iterator JavaDoc iter = coll2.iterator();
252             while (iter.hasNext()) {
253                 Group group = (Group)iter.next();
254                 coll.add(group.getGroupName());
255             }
256         }
257         catch (Exception JavaDoc e) {
258             if (logger.isEnabledFor(Level.ERROR))
259                 logger.error(e.getMessage());
260         }
261         return coll;
262     }
263     
264     /**
265      * This method checks the exist of a group.
266      * @param groupname Groupname of the group.
267      */
268     public boolean existsGroup(String JavaDoc groupname) {
269         boolean result = false;
270         try {
271             Group group = findByPrimaryKey(groupname);
272             if (group != null && group.getGroupName().equals(groupname))
273                 result = true;
274         }
275         catch (Exception JavaDoc e) {
276             if (logger.isEnabledFor(Level.WARN))
277                 logger.warn(e.getMessage());
278             result = true;
279         }
280         return result;
281     }
282 }
283
Popular Tags