Rev 1045 | Rev 1058 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed
package ak.hostadmiral.core.model;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.Comparator;
import ak.hostadmiral.util.ConfigInit;
import ak.hostadmiral.util.CollectionInfo;
import ak.hostadmiral.util.ModelException;
import ak.hostadmiral.util.ModelSecurityException;
import ak.hostadmiral.core.model.store.SystemUserStore;
public class SystemUserManager
implements
ConfigInit,
UserBeforeDeleteListener,
UserDeletingListener
{
private SystemUserStore store;
private Collection createdListeners = new ArrayList();
private Collection modifiedListeners = new ArrayList();
private Collection beforeDeleteListeners = new ArrayList();
private Collection deletingListeners = new ArrayList();
private Collection deletedListeners = new ArrayList();
public SystemUserManager()
throws ModelException
{
UserManager.getInstance().addBeforeDeleteListener(this);
}
public SystemUser create(User editor)
throws ModelException
{
if(!allowedToCreate(editor)) throw new ModelSecurityException();
return new SystemUser();
}
public boolean allowedToCreate(User editor)
throws ModelException
{
return SystemUser.allowedToCreate(this, editor);
}
public SystemUser get(User editor, Long id)
throws ModelException
{
SystemUser user = store.get(id);
if(!user.viewableBy(editor))
throw new ModelSecurityException();
return user;
}
public boolean nameExists(User editor, SystemUser user, String name)
throws ModelException
{
return store.nameExists(user, name);
}
public boolean uidExists(User editor, SystemUser user, Integer uid)
throws ModelException
{
return store.uidExists(user, uid);
}
public SystemUser findForName(User editor, String name)
throws ModelException
{
SystemUser user = store.findForName(name);
if(user != null && !user.viewableBy(editor))
throw new ModelSecurityException();
return user;
}
public SystemUser findForUid(User editor, Integer uid)
throws ModelException
{
SystemUser user = store.findForUid(uid);
if(user != null && !user.viewableBy(editor))
throw new ModelSecurityException();
return user;
}
public void save(User editor, SystemUser systemUser)
throws ModelException
{
if(!systemUser.editableBy(editor))
throw new ModelSecurityException();
boolean isNew = systemUser.isNew();
//systemUser.setModUser(editor); // FIXME
store.save(systemUser);
// inform listeners
if(isNew) {
for(Iterator i = createdListeners.iterator(); i.hasNext(); ) {
SystemUserCreatedListener listener = (SystemUserCreatedListener)i.next();
listener.systemUserCreated(editor, systemUser);
}
}
else {
SystemUser oldSystemUser = systemUser.getOrigin();
if(oldSystemUser == null) oldSystemUser = systemUser;
for(Iterator i = modifiedListeners.iterator(); i.hasNext(); ) {
SystemUserModifiedListener listener = (SystemUserModifiedListener)i.next();
listener.systemUserModified(editor, systemUser, oldSystemUser);
}
}
// reset backup
systemUser.resetOrigin();
}
public void addCreatedListener(SystemUserCreatedListener listener)
{
createdListeners.add(listener);
}
public void removeCreatedListener(SystemUserCreatedListener listener)
{
createdListeners.remove(listener);
}
public void addModifiedListener(SystemUserModifiedListener listener)
{
modifiedListeners.add(listener);
}
public void removeModifiedListener(SystemUserModifiedListener listener)
{
modifiedListeners.remove(listener);
}
public void addBeforeDeleteListener(SystemUserBeforeDeleteListener listener)
{
beforeDeleteListeners.add(listener);
}
public void removeBeforeDeleteListener(SystemUserBeforeDeleteListener listener)
{
beforeDeleteListeners.remove(listener);
}
public void addDeletingListener(SystemUserDeletingListener listener)
{
deletingListeners.add(listener);
}
public void removeDeletingListener(SystemUserDeletingListener listener)
{
deletingListeners.remove(listener);
}
public void addDeletedListener(SystemUserDeletedListener listener)
{
deletedListeners.add(listener);
}
public void removeDeletedListener(SystemUserDeletedListener listener)
{
deletedListeners.remove(listener);
}
public Collection beforeDelete(User editor, SystemUser user, Collection known)
throws ModelException
{
Collection cascade = new ArrayList();
for(Iterator i = beforeDeleteListeners.iterator(); i.hasNext(); ) {
SystemUserBeforeDeleteListener listener = (SystemUserBeforeDeleteListener)i.next();
Collection subcascade = listener.systemUserBeforeDelete(editor, user, known);
if(subcascade != null)
cascade.addAll(subcascade);
}
return cascade;
}
public void delete(User editor, SystemUser systemUser)
throws ModelException
{
// check rights
if(!systemUser.deleteableBy(editor))
throw new ModelSecurityException();
// inform deleting listeners
for(Iterator i = deletingListeners.iterator(); i.hasNext(); ) {
SystemUserDeletingListener listener = (SystemUserDeletingListener)i.next();
listener.systemUserDeleting(editor, systemUser);
}
// backup copy
SystemUser oldSystemUser = new SystemUser(systemUser);
// delete it
store.delete(systemUser);
// inform deleted listeners
for(Iterator i = deletedListeners.iterator(); i.hasNext(); ) {
SystemUserDeletedListener listener = (SystemUserDeletedListener)i.next();
listener.systemUserDeleted(editor, oldSystemUser);
}
}
public Collection listSystemUsers(User editor)
throws ModelException
{
return listSystemUsers(null, 0, 0, null, editor);
}
public Collection listSystemUsers(CollectionInfo info, int rowsPerPage, int pageNumber,
Integer[] sortingKeys, User editor)
throws ModelException
{
if(editor.isSuperuser())
return store.listAllSystemUsers(info, rowsPerPage, pageNumber, sortingKeys);
else
return store.listSystemUsers(info, rowsPerPage, pageNumber, sortingKeys, editor);
}
public boolean areSystemUsersAvailable(User editor)
throws ModelException
{
if(editor.isSuperuser())
return true;
else
return store.countSystemUsersAvailable(editor) > 0;
}
public Collection userBeforeDelete(User editor, User user, Collection known)
throws ModelException
{
Collection systemUsers = store.listOwnSystemUsers(user);
Collection cascade = new ArrayList();
for(Iterator i = systemUsers.iterator(); i.hasNext(); ) {
SystemUser u = (SystemUser)i.next();
if(u.viewableBy(editor)) {
if(u.deleteableBy(editor))
cascade.add(new CascadeDeleteElement(u, CascadeDeleteElement.DELETE,
this.beforeDelete(editor, u, known)));
else
cascade.add(new CascadeDeleteElement(u, CascadeDeleteElement.FORBIDDEN, null));
}
else {
cascade.add(new CascadeDeleteElement(SystemUser.createLimitedCopy(u),
CascadeDeleteElement.FORBIDDEN, null));
}
}
return cascade;
}
public void userDeleting(User editor, User user)
throws ModelException
{
Collection systemUsers = store.listOwnSystemUsers(user);
for(Iterator i = systemUsers.iterator(); i.hasNext(); ) {
delete(editor, (SystemUser)i.next());
}
}
public static final Integer SORT_UID = new Integer(1);
public static final Integer SORT_NAME = new Integer(2);
public static final Comparator UID_COMPARATOR = new UidComparator();
public static final Comparator NAME_COMPARATOR = new NameComparator();
private static class UidComparator
implements Comparator
{
public int compare(Object o1, Object o2)
{
if(!(o1 instanceof SystemUser) || !(o2 instanceof SystemUser))
throw new ClassCastException("not a SystemUser");
SystemUser a1 = (SystemUser)o1;
SystemUser a2 = (SystemUser)o2;
if(a1 == null && a2 == null)
return 0;
else if(a1 == null && a2 != null)
return -1;
else if(a1 != null && a2 == null)
return 1;
else
return a1.getUid().compareTo(a2.getUid());
}
public boolean equals(Object obj)
{
return (obj instanceof UidComparator);
}
}
private static class NameComparator
implements Comparator
{
public int compare(Object o1, Object o2)
{
if(!(o1 instanceof SystemUser) || !(o2 instanceof SystemUser))
throw new ClassCastException("not a SystemUser");
SystemUser a1 = (SystemUser)o1;
SystemUser a2 = (SystemUser)o2;
if(a1 == null && a2 == null)
return 0;
else if(a1 == null && a2 != null)
return -1;
else if(a1 != null && a2 == null)
return 1;
else
return a1.getName().compareToIgnoreCase(a2.getName());
}
public boolean equals(Object obj)
{
return (obj instanceof NameComparator);
}
}
public void init(Map params)
throws ModelException
{
try {
systemUserManager = this;
Class c = Class.forName(((String[])params.get("store"))[0]);
store = (SystemUserStore)c.newInstance();
}
catch(Exception ex) {
throw new ModelException(ex);
}
}
private static SystemUserManager systemUserManager = null;
public static SystemUserManager getInstance()
{
return systemUserManager;
}
}