Rev 1062 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
924 | dev | 1 | package ak.hostadmiral.core.model; |
919 | dev | 2 | |
1041 | dev | 3 | import java.util.Collection; |
4 | import java.util.ArrayList; |
||
5 | import java.util.Iterator; |
||
6 | import java.util.Map; |
||
7 | import java.util.Comparator; |
||
8 | |||
9 | import ak.hostadmiral.util.ConfigInit; |
||
1028 | dev | 10 | import ak.hostadmiral.util.CollectionInfo; |
924 | dev | 11 | import ak.hostadmiral.util.ModelException; |
12 | import ak.hostadmiral.util.ModelSecurityException; |
||
1041 | dev | 13 | import ak.hostadmiral.core.model.store.MailAliasStore; |
919 | dev | 14 | |
15 | public class MailAliasManager |
||
1014 | dev | 16 | implements |
1041 | dev | 17 | ConfigInit, |
1014 | dev | 18 | UserBeforeDeleteListener, |
19 | UserDeletingListener, |
||
20 | InetDomainBeforeDeleteListener, |
||
21 | InetDomainDeletingListener |
||
919 | dev | 22 | { |
1041 | dev | 23 | private MailAliasStore store; |
1011 | dev | 24 | |
1062 | dev | 25 | private Collection validateListeners = new ArrayList(); |
1011 | dev | 26 | private Collection createdListeners = new ArrayList(); |
27 | private Collection modifiedListeners = new ArrayList(); |
||
28 | private Collection beforeDeleteListeners = new ArrayList(); |
||
1014 | dev | 29 | private Collection deletingListeners = new ArrayList(); |
1011 | dev | 30 | private Collection deletedListeners = new ArrayList(); |
31 | |||
1041 | dev | 32 | public MailAliasManager() |
33 | throws ModelException |
||
919 | dev | 34 | { |
1011 | dev | 35 | UserManager.getInstance().addBeforeDeleteListener(this); |
919 | dev | 36 | } |
37 | |||
38 | public MailAlias create(User editor) |
||
39 | throws ModelException |
||
40 | { |
||
41 | if(!allowedToCreate(editor)) throw new ModelSecurityException(); |
||
42 | |||
43 | MailAlias alias = new MailAlias(); |
||
44 | alias.setDestinations(new ArrayList()); |
||
45 | return alias; |
||
46 | } |
||
47 | |||
48 | public boolean allowedToCreate(User editor) |
||
49 | throws ModelException |
||
50 | { |
||
921 | dev | 51 | return MailAlias.allowedToCreate(this, editor); |
919 | dev | 52 | } |
53 | |||
54 | public MailAlias get(User editor, Long id) |
||
55 | throws ModelException |
||
56 | { |
||
1041 | dev | 57 | MailAlias alias = store.get(id); |
919 | dev | 58 | |
59 | if(!alias.viewableBy(editor)) |
||
60 | throw new ModelSecurityException(); |
||
61 | |||
62 | return alias; |
||
63 | } |
||
64 | |||
926 | dev | 65 | public boolean addressExists(User editor, MailAlias alias, String address) |
66 | throws ModelException |
||
67 | { |
||
68 | if(alias.getDomain() == null) |
||
69 | throw new ModelException("Cannot check unique address for mail alias without domain"); |
||
70 | |||
1041 | dev | 71 | return store.addressExists(alias, address); |
926 | dev | 72 | } |
73 | |||
1041 | dev | 74 | public MailAlias findForName(User editor, String name) |
919 | dev | 75 | throws ModelException |
76 | { |
||
1041 | dev | 77 | MailAlias alias = store.findForName(name); |
919 | dev | 78 | |
1041 | dev | 79 | if(!alias.viewableBy(editor)) |
80 | throw new ModelSecurityException(); |
||
81 | |||
82 | return alias; |
||
919 | dev | 83 | } |
84 | |||
85 | public void save(User editor, MailAlias mailAlias) |
||
86 | throws ModelException |
||
87 | { |
||
1062 | dev | 88 | // security check |
919 | dev | 89 | if(!mailAlias.editableBy(editor)) |
90 | throw new ModelSecurityException(); |
||
91 | |||
1062 | dev | 92 | //mailAlias.setModUser(editor); // FIXME |
93 | |||
1011 | dev | 94 | boolean isNew = mailAlias.isNew(); |
1062 | dev | 95 | MailAlias oldMailAlias = mailAlias.getOrigin(); |
96 | if(oldMailAlias == null) oldMailAlias = mailAlias; |
||
1011 | dev | 97 | |
1062 | dev | 98 | // validate |
99 | for(Iterator i = validateListeners.iterator(); i.hasNext(); ) { |
||
100 | MailAliasValidateListener listener = (MailAliasValidateListener)i.next(); |
||
101 | listener.mailAliasValidate(editor, mailAlias, oldMailAlias); |
||
102 | } |
||
919 | dev | 103 | |
1041 | dev | 104 | store.save(mailAlias); |
1011 | dev | 105 | |
106 | // inform listeners |
||
107 | if(isNew) { |
||
108 | for(Iterator i = createdListeners.iterator(); i.hasNext(); ) { |
||
109 | MailAliasCreatedListener listener = (MailAliasCreatedListener)i.next(); |
||
110 | listener.mailAliasCreated(editor, mailAlias); |
||
111 | } |
||
112 | } |
||
113 | else { |
||
114 | for(Iterator i = modifiedListeners.iterator(); i.hasNext(); ) { |
||
115 | MailAliasModifiedListener listener = (MailAliasModifiedListener)i.next(); |
||
116 | listener.mailAliasModified(editor, mailAlias, oldMailAlias); |
||
117 | } |
||
118 | } |
||
1045 | dev | 119 | |
120 | // reset backup |
||
121 | mailAlias.resetOrigin(); |
||
919 | dev | 122 | } |
123 | |||
1062 | dev | 124 | public void addValidateListener(MailAliasValidateListener listener) |
125 | { |
||
126 | validateListeners.add(listener); |
||
127 | } |
||
128 | |||
129 | public void removeValidateListener(MailAliasValidateListener listener) |
||
130 | { |
||
131 | validateListeners.remove(listener); |
||
132 | } |
||
133 | |||
1011 | dev | 134 | public void addCreatedListener(MailAliasCreatedListener listener) |
135 | { |
||
136 | createdListeners.add(listener); |
||
137 | } |
||
138 | |||
139 | public void removeCreatedListener(MailAliasCreatedListener listener) |
||
140 | { |
||
141 | createdListeners.remove(listener); |
||
142 | } |
||
143 | |||
144 | public void addModifiedListener(MailAliasModifiedListener listener) |
||
145 | { |
||
146 | modifiedListeners.add(listener); |
||
147 | } |
||
148 | |||
149 | public void removeModifiedListener(MailAliasModifiedListener listener) |
||
150 | { |
||
151 | modifiedListeners.remove(listener); |
||
152 | } |
||
153 | |||
154 | public void addBeforeDeleteListener(MailAliasBeforeDeleteListener listener) |
||
155 | { |
||
156 | beforeDeleteListeners.add(listener); |
||
157 | } |
||
158 | |||
159 | public void removeBeforeDeleteListener(MailAliasBeforeDeleteListener listener) |
||
160 | { |
||
161 | beforeDeleteListeners.remove(listener); |
||
162 | } |
||
163 | |||
1014 | dev | 164 | public void addDeletingListener(MailAliasDeletingListener listener) |
165 | { |
||
166 | deletingListeners.add(listener); |
||
167 | } |
||
168 | |||
169 | public void removeDeletingListener(MailAliasDeletingListener listener) |
||
170 | { |
||
171 | deletingListeners.remove(listener); |
||
172 | } |
||
173 | |||
1011 | dev | 174 | public void addDeletedListener(MailAliasDeletedListener listener) |
175 | { |
||
176 | deletedListeners.add(listener); |
||
177 | } |
||
178 | |||
179 | public void removeDeletedListener(MailAliasDeletedListener listener) |
||
180 | { |
||
181 | deletedListeners.remove(listener); |
||
182 | } |
||
183 | |||
184 | public Collection beforeDelete(User editor, MailAlias mailAlias, Collection known) |
||
185 | throws ModelException |
||
186 | { |
||
187 | Collection cascade = new ArrayList(); |
||
188 | |||
189 | for(Iterator i = beforeDeleteListeners.iterator(); i.hasNext(); ) { |
||
190 | MailAliasBeforeDeleteListener listener = (MailAliasBeforeDeleteListener)i.next(); |
||
191 | Collection subcascade = listener.mailAliasBeforeDelete(editor, mailAlias, known); |
||
192 | if(subcascade != null) |
||
193 | cascade.addAll(subcascade); |
||
194 | } |
||
195 | |||
196 | return cascade; |
||
197 | } |
||
198 | |||
919 | dev | 199 | public void delete(User editor, MailAlias mailAlias) |
200 | throws ModelException |
||
201 | { |
||
1011 | dev | 202 | // check rights |
919 | dev | 203 | if(!mailAlias.deleteableBy(editor)) |
204 | throw new ModelSecurityException(); |
||
205 | |||
1014 | dev | 206 | // inform deleting listeners |
207 | for(Iterator i = deletingListeners.iterator(); i.hasNext(); ) { |
||
208 | MailAliasDeletingListener listener = (MailAliasDeletingListener)i.next(); |
||
209 | listener.mailAliasDeleting(editor, mailAlias); |
||
210 | } |
||
211 | |||
1011 | dev | 212 | // backup copy |
213 | MailAlias oldMailAlias = new MailAlias(mailAlias); |
||
214 | |||
215 | // delete it |
||
1041 | dev | 216 | store.delete(mailAlias); |
1011 | dev | 217 | |
1014 | dev | 218 | // inform deleted listeners |
1011 | dev | 219 | for(Iterator i = deletedListeners.iterator(); i.hasNext(); ) { |
220 | MailAliasDeletedListener listener = (MailAliasDeletedListener)i.next(); |
||
221 | listener.mailAliasDeleted(editor, oldMailAlias); |
||
222 | } |
||
919 | dev | 223 | } |
224 | |||
225 | public Collection listMailAliases(User editor) |
||
226 | throws ModelException |
||
227 | { |
||
1028 | dev | 228 | return listMailAliases(null, 0, 0, null, editor); |
229 | } |
||
230 | |||
231 | public Collection listMailAliases(CollectionInfo info, int rowsPerPage, int pageNumber, |
||
232 | Integer[] sortingKeys, User editor) |
||
233 | throws ModelException |
||
234 | { |
||
1041 | dev | 235 | if(editor.isSuperuser()) |
236 | return store.listAllMailAliases(info, rowsPerPage, pageNumber, sortingKeys); |
||
237 | else |
||
238 | return store.listMailAliases(info, rowsPerPage, pageNumber, sortingKeys, editor); |
||
919 | dev | 239 | } |
240 | |||
241 | public boolean areMailAliasesAvailable(User editor) |
||
242 | throws ModelException |
||
243 | { |
||
1073 | dev | 244 | if(editor.isSuperuser() || InetDomainManager.getInstance().areInetDomainsAvailable(editor)) |
1041 | dev | 245 | return true; |
246 | else |
||
247 | return store.countMailAliasesAvailable(editor) > 0; |
||
919 | dev | 248 | } |
249 | |||
1011 | dev | 250 | public Collection userBeforeDelete(User editor, User user, Collection known) |
251 | throws ModelException |
||
252 | { |
||
1041 | dev | 253 | Collection mailAliases = store.listOwnMailAliases(user); |
919 | dev | 254 | |
1011 | dev | 255 | return iterateBeforeDelete(editor, mailAliases, known); |
256 | } |
||
257 | |||
1014 | dev | 258 | public void userDeleting(User editor, User user) |
259 | throws ModelException |
||
260 | { |
||
1041 | dev | 261 | Collection mailAliases = store.listOwnMailAliases(user); |
1014 | dev | 262 | |
263 | for(Iterator i = mailAliases.iterator(); i.hasNext(); ) { |
||
264 | delete(editor, (MailAlias)i.next()); |
||
265 | } |
||
266 | } |
||
267 | |||
268 | public Collection inetDomainBeforeDelete(User editor, InetDomain domain, Collection known) |
||
269 | throws ModelException |
||
270 | { |
||
1041 | dev | 271 | Collection mailAliases = store.listMailAliasesForDomain(domain); |
1014 | dev | 272 | |
273 | return iterateBeforeDelete(editor, mailAliases, known); |
||
274 | } |
||
275 | |||
276 | public void inetDomainDeleting(User editor, InetDomain domain) |
||
277 | throws ModelException |
||
278 | { |
||
1041 | dev | 279 | Collection mailAliases = store.listMailAliasesForDomain(domain); |
1014 | dev | 280 | |
281 | for(Iterator i = mailAliases.iterator(); i.hasNext(); ) { |
||
282 | delete(editor, (MailAlias)i.next()); |
||
283 | } |
||
284 | } |
||
285 | |||
1011 | dev | 286 | private Collection iterateBeforeDelete(User editor, Collection mailAliases, Collection known) |
287 | throws ModelException |
||
919 | dev | 288 | { |
1011 | dev | 289 | Collection cascade = new ArrayList(); |
290 | for(Iterator i = mailAliases.iterator(); i.hasNext(); ) { |
||
291 | MailAlias mailAlias = (MailAlias)i.next(); |
||
1058 | dev | 292 | if(known.contains(mailAlias)) continue; |
293 | |||
294 | known.add(mailAlias); |
||
1011 | dev | 295 | if(mailAlias.viewableBy(editor)) { |
296 | if(mailAlias.deleteableBy(editor)) |
||
297 | cascade.add(new CascadeDeleteElement(mailAlias, CascadeDeleteElement.DELETE, |
||
298 | this.beforeDelete(editor, mailAlias, known))); |
||
299 | else |
||
300 | cascade.add(new CascadeDeleteElement(mailAlias, CascadeDeleteElement.FORBIDDEN, |
||
301 | null)); |
||
302 | } |
||
303 | else { |
||
304 | cascade.add(new CascadeDeleteElement(MailAlias.createLimitedCopy(mailAlias), |
||
305 | CascadeDeleteElement.FORBIDDEN, null)); |
||
306 | } |
||
307 | } |
||
919 | dev | 308 | |
1011 | dev | 309 | return cascade; |
919 | dev | 310 | } |
311 | |||
1028 | dev | 312 | public static final Integer SORT_ADDRESS = new Integer(1); |
313 | public static final Integer SORT_DOMAIN = new Integer(2); |
||
314 | |||
919 | dev | 315 | public static final Comparator ADDRESS_COMPARATOR = new AddressComparator(); |
316 | |||
317 | private static class AddressComparator |
||
318 | implements Comparator |
||
319 | { |
||
320 | public int compare(Object o1, Object o2) |
||
321 | { |
||
322 | if(!(o1 instanceof MailAlias) || !(o2 instanceof MailAlias)) |
||
323 | throw new ClassCastException("not a MailAlias"); |
||
324 | |||
325 | MailAlias a1 = (MailAlias)o1; |
||
326 | MailAlias a2 = (MailAlias)o2; |
||
327 | |||
328 | if(a1 == null && a2 == null) |
||
329 | return 0; |
||
330 | else if(a1 == null && a2 != null) |
||
331 | return -1; |
||
332 | else if(a1 != null && a2 == null) |
||
333 | return 1; |
||
334 | else |
||
335 | return a1.getAddress().compareToIgnoreCase(a2.getAddress()); |
||
336 | } |
||
337 | |||
338 | public boolean equals(Object obj) |
||
339 | { |
||
340 | return (obj instanceof AddressComparator); |
||
341 | } |
||
342 | } |
||
1041 | dev | 343 | |
344 | public void init(Map params) |
||
345 | throws ModelException |
||
346 | { |
||
347 | try { |
||
348 | mailAliasManager = this; |
||
349 | |||
1046 | dev | 350 | Class c = Class.forName(((String[])params.get("store"))[0]); |
1041 | dev | 351 | store = (MailAliasStore)c.newInstance(); |
352 | } |
||
353 | catch(Exception ex) { |
||
354 | throw new ModelException(ex); |
||
355 | } |
||
356 | } |
||
357 | |||
358 | private static MailAliasManager mailAliasManager = null; |
||
359 | |||
360 | public static MailAliasManager getInstance() |
||
361 | { |
||
362 | return mailAliasManager; |
||
363 | } |
||
919 | dev | 364 | } |