Subversion Repositories general

Compare Revisions

Ignore whitespace Rev 1010 → Rev 1011

/hostadmiral/trunk/src/ak/hostadmiral/core/model/MailAliasManager.java
8,8 → 8,19
import ak.hostadmiral.util.ModelSecurityException;
 
public class MailAliasManager
implements UserBeforeDeleteListener
{
private static MailAliasManager mailAliasManager = null;
private static boolean registered = false;
 
public static MailAliasManager getInstance()
{
if(mailAliasManager == null)
mailAliasManager = new MailAliasManager();
 
return mailAliasManager;
}
 
protected static void register()
{
synchronized(MailAliasManager.class) {
31,8 → 42,14
register();
}
 
private Collection createdListeners = new ArrayList();
private Collection modifiedListeners = new ArrayList();
private Collection beforeDeleteListeners = new ArrayList();
private Collection deletedListeners = new ArrayList();
 
private MailAliasManager()
{
UserManager.getInstance().addBeforeDeleteListener(this);
}
 
public MailAlias create(User editor)
121,6 → 138,8
if(!mailAlias.editableBy(editor))
throw new ModelSecurityException();
 
boolean isNew = mailAlias.isNew();
 
//mailAlias.setModUser(editor); // FIXME
 
try {
130,14 → 149,90
{
throw new ModelException(ex);
}
 
// inform listeners
if(isNew) {
for(Iterator i = createdListeners.iterator(); i.hasNext(); ) {
MailAliasCreatedListener listener = (MailAliasCreatedListener)i.next();
listener.mailAliasCreated(editor, mailAlias);
}
}
else {
MailAlias oldMailAlias = mailAlias.getOrigin();
if(oldMailAlias == null) oldMailAlias = mailAlias;
for(Iterator i = modifiedListeners.iterator(); i.hasNext(); ) {
MailAliasModifiedListener listener = (MailAliasModifiedListener)i.next();
listener.mailAliasModified(editor, mailAlias, oldMailAlias);
}
}
}
 
public void addCreatedListener(MailAliasCreatedListener listener)
{
createdListeners.add(listener);
}
 
public void removeCreatedListener(MailAliasCreatedListener listener)
{
createdListeners.remove(listener);
}
 
public void addModifiedListener(MailAliasModifiedListener listener)
{
modifiedListeners.add(listener);
}
 
public void removeModifiedListener(MailAliasModifiedListener listener)
{
modifiedListeners.remove(listener);
}
 
public void addBeforeDeleteListener(MailAliasBeforeDeleteListener listener)
{
beforeDeleteListeners.add(listener);
}
 
public void removeBeforeDeleteListener(MailAliasBeforeDeleteListener listener)
{
beforeDeleteListeners.remove(listener);
}
 
public void addDeletedListener(MailAliasDeletedListener listener)
{
deletedListeners.add(listener);
}
 
public void removeDeletedListener(MailAliasDeletedListener listener)
{
deletedListeners.remove(listener);
}
 
public Collection beforeDelete(User editor, MailAlias mailAlias, Collection known)
throws ModelException
{
Collection cascade = new ArrayList();
 
for(Iterator i = beforeDeleteListeners.iterator(); i.hasNext(); ) {
MailAliasBeforeDeleteListener listener = (MailAliasBeforeDeleteListener)i.next();
Collection subcascade = listener.mailAliasBeforeDelete(editor, mailAlias, known);
if(subcascade != null)
cascade.addAll(subcascade);
}
 
return cascade;
}
 
public void delete(User editor, MailAlias mailAlias)
throws ModelException
{
// check rights
if(!mailAlias.deleteableBy(editor))
throw new ModelSecurityException();
 
// backup copy
MailAlias oldMailAlias = new MailAlias(mailAlias);
 
// delete it
try {
HibernateUtil.currentSession().delete(mailAlias);
}
145,6 → 240,12
{
throw new ModelException(ex);
}
 
// inform listeners
for(Iterator i = deletedListeners.iterator(); i.hasNext(); ) {
MailAliasDeletedListener listener = (MailAliasDeletedListener)i.next();
listener.mailAliasDeleted(editor, oldMailAlias);
}
}
 
public Collection listMailAliases(User editor)
190,14 → 291,45
}
}
 
private static MailAliasManager mailAliasManager = null;
public Collection userBeforeDelete(User editor, User user, Collection known)
throws ModelException
{
Collection mailAliases;
 
public static MailAliasManager getInstance()
try {
mailAliases = HibernateUtil.currentSession().find(
"from MailAlias where owner = ?",
user, Hibernate.entity(User.class) );
}
catch(HibernateException ex)
{
throw new ModelException(ex);
}
 
return iterateBeforeDelete(editor, mailAliases, known);
}
 
private Collection iterateBeforeDelete(User editor, Collection mailAliases, Collection known)
throws ModelException
{
if(mailAliasManager == null)
mailAliasManager = new MailAliasManager();
Collection cascade = new ArrayList();
for(Iterator i = mailAliases.iterator(); i.hasNext(); ) {
MailAlias mailAlias = (MailAlias)i.next();
if(mailAlias.viewableBy(editor)) {
if(mailAlias.deleteableBy(editor))
cascade.add(new CascadeDeleteElement(mailAlias, CascadeDeleteElement.DELETE,
this.beforeDelete(editor, mailAlias, known)));
else
cascade.add(new CascadeDeleteElement(mailAlias, CascadeDeleteElement.FORBIDDEN,
null));
}
else {
cascade.add(new CascadeDeleteElement(MailAlias.createLimitedCopy(mailAlias),
CascadeDeleteElement.FORBIDDEN, null));
}
}
 
return mailAliasManager;
return cascade;
}
 
public static final Comparator ADDRESS_COMPARATOR = new AddressComparator();