/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/MailAlias.java |
---|
0,0 → 1,182 |
package ak.hostadmiral.core.model; |
import java.util.Collection; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
/** |
* |
* @hibernate.class table="mailaliases" |
*/ |
public class MailAlias |
extends GeneralModelObject |
{ |
private Long id; |
private String address; |
private InetDomain domain; |
private User owner; |
private Collection destinations; // Collection(MailAliasDestintion) |
protected MailAlias() |
{ |
} |
/** |
* |
* @hibernate.id generator-class="native" |
*/ |
public Long getId() |
{ |
return id; |
} |
protected void setId(Long id) |
{ |
this.id = id; |
} |
/** |
* |
* @hibernate.property |
*/ |
public String getAddress() |
{ |
return address; |
} |
protected void setAddress(String address) |
{ |
this.address = address; |
} |
public void setAddress(User editor, String address) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.address = address; |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public InetDomain getDomain() |
{ |
return domain; |
} |
protected void setDomain(InetDomain domain) |
{ |
this.domain = domain; |
} |
public void setDomain(User editor, InetDomain domain) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.domain = domain; |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public User getOwner() |
{ |
return owner; |
} |
protected void setOwner(User owner) |
{ |
this.owner = owner; |
} |
public void setOwner(User editor, User owner) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.owner = owner; |
} |
/** |
* @return Collection(MailAliasDestination) |
* |
* @hibernate.bag inverse="true" cascade="all-delete-orphan" |
* @hibernate.collection-key column="alias" |
* @hibernate.collection-one-to-many class="ak.hostadmiral.core.model.MailAliasDestination" |
*/ |
protected Collection getDestinations() |
{ |
return destinations; |
} |
/** |
* @return Collection(MailAliasDestination) |
*/ |
public Collection getDestinations(User editor) |
throws ModelException |
{ |
if(mayChangeDestinations(editor)) |
return destinations; |
else if(viewableBy(editor)) |
return java.util.Collections.unmodifiableCollection(destinations); |
else |
throw new ModelSecurityException(); |
} |
/** |
* @param destinations Collection(MailAliasDestination) |
*/ |
protected void setDestinations(Collection destinations) |
{ |
this.destinations = destinations; |
} |
public String getTypeKey() |
{ |
return ak.hostadmiral.core.CoreResources.TYPE_MAIL_ALIAS; |
} |
public String getIdentKey() |
{ |
return ak.hostadmiral.core.CoreResources.IDENT_MAIL_ALIAS; |
} |
public Object[] getIdentParams() |
{ |
return new Object[] { getAddress(), getDomain().getName() }; |
} |
public boolean viewableBy(User user) |
{ |
return user.isSuperuser() || user.equals(domain.getOwner()) || user.equals(owner); |
} |
public boolean editableBy(User user) |
{ |
return user.isSuperuser() || user.equals(domain.getOwner()); |
} |
public boolean mayChangeDestinations(User user) |
{ |
return user.isSuperuser() || user.equals(domain.getOwner()) || user.equals(owner); |
} |
public boolean deleteableBy(User user) |
{ |
return user.isSuperuser() || user.equals(domain.getOwner()); |
} |
protected static boolean allowedToCreate(MailAliasManager manager, User editor) |
throws ModelException |
{ |
return editor.isSuperuser() |
|| InetDomainManager.getInstance().areInetDomainsAvailable(editor); |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/MailAliasDestination.java |
---|
0,0 → 1,147 |
package ak.hostadmiral.core.model; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
/** |
* |
* @hibernate.class table="mailaliasdests" |
*/ |
public class MailAliasDestination |
extends GeneralModelObject |
{ |
private Long id; |
private MailAlias alias; |
private Mailbox mailbox; |
private String email; |
protected MailAliasDestination() |
{ |
} |
/** |
* |
* @hibernate.id generator-class="native" |
*/ |
public Long getId() |
{ |
return id; |
} |
protected void setId(Long id) |
{ |
this.id = id; |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public MailAlias getAlias() |
{ |
return alias; |
} |
protected void setAlias(MailAlias alias) |
{ |
this.alias = alias; |
} |
public void setAlias(User editor, MailAlias alias) |
throws ModelException |
{ |
if(this.alias != null && !editableBy(editor)) |
throw new ModelSecurityException(); |
this.alias = alias; |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public Mailbox getMailbox() |
{ |
return mailbox; |
} |
protected void setMailbox(Mailbox mailbox) |
{ |
this.mailbox = mailbox; |
} |
public void setMailbox(User editor, Mailbox mailbox) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.mailbox = mailbox; |
} |
/** |
* |
* @hibernate.property |
*/ |
public String getEmail() |
{ |
return email; |
} |
protected void setEmail(String email) |
{ |
this.email = email; |
} |
public void setEmail(User editor, String email) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.email = email; |
} |
public String getTypeKey() |
{ |
return ak.hostadmiral.core.CoreResources.TYPE_MAIL_ALIAS_DESTINATION; |
} |
public String getIdentKey() |
{ |
if(getMailbox() == null) |
return ak.hostadmiral.core.CoreResources.IDENT_MAIL_ALIAS_DESTINATION_EXTERNAL; |
else |
return ak.hostadmiral.core.CoreResources.IDENT_MAIL_ALIAS_DESTINATION_INTERNAL; |
} |
public Object[] getIdentParams() |
{ |
if(getMailbox() == null) |
return new Object[] { getEmail() }; |
else |
return new Object[] { getMailbox().getLogin(), getMailbox().getDomain().getName() }; |
} |
public boolean viewableBy(User user) |
{ |
return alias.viewableBy(user); |
} |
public boolean editableBy(User user) |
{ |
return alias.mayChangeDestinations(user); |
} |
public boolean deleteableBy(User user) |
{ |
return alias.mayChangeDestinations(user); |
} |
protected static boolean allowedToCreate(MailAliasDestinationManager manager, User editor) |
throws ModelException |
{ |
return true; |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/SystemUserManager.java |
---|
0,0 → 1,285 |
package ak.hostadmiral.core.model; |
import java.util.*; |
import net.sf.hibernate.*; |
import net.sf.hibernate.type.Type; |
import ak.hostadmiral.util.HibernateUtil; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
public class SystemUserManager |
{ |
private static boolean registered = false; |
protected static void register() |
{ |
synchronized(SystemUserManager.class) { |
if(registered) return; |
registered = true; |
try { |
HibernateUtil.getConfiguration().addResource( |
"/ak/hostadmiral/core/model/SystemUser.hbm.xml"); |
} |
catch(Exception ex) { |
ex.printStackTrace(); |
throw new RuntimeException(ex.getMessage()); |
} |
} |
} |
static { |
register(); |
} |
private SystemUserManager() |
{ |
} |
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; |
try { |
user = (SystemUser)HibernateUtil.currentSession().load(SystemUser.class, id); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
if(!user.viewableBy(editor)) |
throw new ModelSecurityException(); |
return user; |
} |
public boolean nameExists(User editor, SystemUser user, String name) |
throws ModelException |
{ |
try { |
if(user.getId() == null) |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from SystemUser u where name = ?", |
name, Hibernate.STRING) |
.next()).intValue() > 0; |
else |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from SystemUser u where name = ? and u != ?", |
new Object[] { name, user }, |
new Type[] { Hibernate.STRING, Hibernate.entity(SystemUser.class) } ) |
.next()).intValue() > 0; |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public boolean uidExists(User editor, SystemUser user, Integer uid) |
throws ModelException |
{ |
try { |
if(user.getId() == null) |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from SystemUser u where uid = ?", |
uid, Hibernate.INTEGER) |
.next()).intValue() > 0; |
else |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from SystemUser u where uid = ? and u != ?", |
new Object[] { uid, user }, |
new Type[] { Hibernate.INTEGER, Hibernate.entity(SystemUser.class) } ) |
.next()).intValue() > 0; |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
protected SystemUser findForName(String name) |
throws ModelException |
{ |
try { |
List list = HibernateUtil.currentSession().find( |
"from SystemUser where name=?", name, Hibernate.STRING); |
if(list.size() == 0) |
return null; |
else |
return (SystemUser)list.get(0); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
protected SystemUser findForUid(Integer uid) |
throws ModelException |
{ |
try { |
List list = HibernateUtil.currentSession().find( |
"from SystemUser where uid=?", uid, Hibernate.INTEGER); |
if(list.size() == 0) |
return null; |
else |
return (SystemUser)list.get(0); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void save(User editor, SystemUser systemUser) |
throws ModelException |
{ |
if(!systemUser.editableBy(editor)) |
throw new ModelSecurityException(); |
systemUser.setModUser(editor); |
try { |
HibernateUtil.currentSession().saveOrUpdate(systemUser); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void delete(User editor, SystemUser systemUser) |
throws ModelException |
{ |
if(!systemUser.deleteableBy(editor)) |
throw new ModelSecurityException(); |
try { |
HibernateUtil.currentSession().delete(systemUser); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public Collection listSystemUsers(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser()) { |
return HibernateUtil.currentSession().find("from SystemUser"); |
} |
else { |
return HibernateUtil.currentSession().find( |
"select u from SystemUser u left join u.owner o where o is null or o=?", |
editor, Hibernate.entity(User.class)); |
} |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public boolean areSystemUsersAvailable(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser()) |
return true; |
else |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from SystemUser u left join u.owner o where o is null or o=?", |
editor, Hibernate.entity(User.class)).next()).intValue() > 0; |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
private static SystemUserManager systemUserManager = null; |
public static SystemUserManager getInstance() |
{ |
if(systemUserManager == null) |
systemUserManager = new SystemUserManager(); |
return systemUserManager; |
} |
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); |
} |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/User.java |
---|
0,0 → 1,212 |
package ak.hostadmiral.core.model; |
import ak.hostadmiral.util.Digest; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
/** |
* |
* @hibernate.class table="users" |
*/ |
public class User |
extends GeneralModelObject |
{ |
private Long id; |
private String login; |
private String password; |
private User boss; |
private Boolean superuser; |
protected User() |
{ |
} |
/** |
* |
* @hibernate.id generator-class="native" |
*/ |
public Long getId() |
{ |
return id; |
} |
protected void setId(Long id) |
{ |
this.id = id; |
} |
/** |
* |
* @hibernate.property |
*/ |
public String getLogin() |
{ |
return login; |
} |
protected void setLogin(String login) |
{ |
this.login = login; |
} |
public void setLogin(User editor, String login) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.login = login; |
} |
/** |
* |
* @hibernate.property |
*/ |
protected String getPassword() |
{ |
return password; |
} |
protected void setPassword(String password) |
{ |
this.password = password; |
} |
public void setPassword(User editor, String password) |
throws ModelException |
{ |
if(!mayChangePassword(editor)) |
throw new ModelSecurityException(); |
if(password == null) |
throw new NullPointerException("Null password"); |
this.password = Digest.encode(password); |
} |
public boolean checkPassword(String password) |
{ |
if(password == null) |
throw new NullPointerException("Null password"); |
return checkMd5Password(Digest.encode(password)); |
} |
public boolean checkMd5Password(String password) |
{ |
return this.password.equals(password); |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public User getBoss() |
{ |
return boss; |
} |
protected void setBoss(User boss) |
{ |
this.boss = boss; |
} |
public void setBoss(User editor, User boss) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.boss = boss; |
} |
/** |
* |
* @hibernate.property |
*/ |
public Boolean getSuperuser() |
{ |
return superuser; |
} |
public boolean isSuperuser() |
{ |
return (superuser != null) && superuser.booleanValue(); |
} |
protected void setSuperuser(Boolean superuser) |
{ |
this.superuser = superuser; |
} |
public void setSuperuser(User editor, Boolean superuser) |
throws ModelException |
{ |
if(!mayChangeSuperuser(editor)) |
throw new ModelSecurityException(); |
this.superuser = superuser; |
} |
public boolean equals(Object o) |
{ |
if(o == null || !(o instanceof User)) return false; |
User u = (User)o; |
return (id != null) && (u.getId() != null) && (id.equals(u.getId())); |
} |
public int hashCode() |
{ |
if(id == null) |
return 0; |
else |
return id.hashCode(); |
} |
public String getTypeKey() |
{ |
return ak.hostadmiral.core.CoreResources.TYPE_USER; |
} |
public String getIdentKey() |
{ |
return ak.hostadmiral.core.CoreResources.IDENT_USER; |
} |
public Object[] getIdentParams() |
{ |
return new Object[] { getLogin() }; |
} |
public boolean viewableBy(User user) |
{ |
return user.isSuperuser() || user.equals(boss) || user.equals(this); |
} |
public boolean editableBy(User user) |
{ |
return user.isSuperuser() || user.equals(boss); |
} |
public boolean deleteableBy(User user) |
{ |
return user.isSuperuser() || user.equals(boss); |
} |
public boolean mayChangePassword(User user) |
{ |
return user.isSuperuser() || user.equals(boss) || user.equals(this); |
} |
public boolean mayChangeSuperuser(User user) |
{ |
return user.isSuperuser() && !user.equals(this); |
} |
protected static boolean allowedToCreate(UserManager manager, User editor) |
throws ModelException |
{ |
return editor.isSuperuser(); |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/InetDomainManager.java |
---|
0,0 → 1,216 |
package ak.hostadmiral.core.model; |
import java.util.*; |
import net.sf.hibernate.*; |
import net.sf.hibernate.type.Type; |
import ak.hostadmiral.util.HibernateUtil; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
public class InetDomainManager |
{ |
private static boolean registered = false; |
protected static void register() |
{ |
synchronized(InetDomainManager.class) { |
if(registered) return; |
registered = true; |
try { |
HibernateUtil.getConfiguration().addResource( |
"/ak/hostadmiral/core/model/InetDomain.hbm.xml"); |
} |
catch(Exception ex) { |
ex.printStackTrace(); |
throw new RuntimeException(ex.getMessage()); |
} |
} |
} |
static { |
register(); |
} |
private InetDomainManager() |
{ |
} |
public InetDomain create(User editor) |
throws ModelException |
{ |
if(!allowedToCreate(editor)) throw new ModelSecurityException(); |
return new InetDomain(); |
} |
public boolean allowedToCreate(User editor) |
throws ModelException |
{ |
return InetDomain.allowedToCreate(this, editor); |
} |
public InetDomain get(User editor, Long id) |
throws ModelException |
{ |
InetDomain domain; |
try { |
domain = (InetDomain)HibernateUtil.currentSession().load( |
InetDomain.class, id); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
if(!domain.viewableBy(editor)) |
throw new ModelSecurityException(); |
return domain; |
} |
public boolean nameExists(User editor, InetDomain domain, String name) |
throws ModelException |
{ |
try { |
if(domain.getId() == null) |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from InetDomain d where name = ?", |
name, Hibernate.STRING) |
.next()).intValue() > 0; |
else |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from InetDomain d where name = ? and d != ?", |
new Object[] { name, domain }, |
new Type[] { Hibernate.STRING, Hibernate.entity(InetDomain.class) } ) |
.next()).intValue() > 0; |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
protected InetDomain findForName(String name) |
throws ModelException |
{ |
try { |
List list = HibernateUtil.currentSession().find( |
"from InetDomain where name=?", name, Hibernate.STRING); |
if(list.size() == 0) |
return null; |
else |
return (InetDomain)list.get(0); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void save(User editor, InetDomain inetDomain) |
throws ModelException |
{ |
if(!inetDomain.editableBy(editor)) |
throw new ModelSecurityException(); |
inetDomain.setModUser(editor); |
try { |
HibernateUtil.currentSession().saveOrUpdate(inetDomain); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void delete(User editor, InetDomain inetDomain) |
throws ModelException |
{ |
if(!inetDomain.deleteableBy(editor)) |
throw new ModelSecurityException(); |
try { |
HibernateUtil.currentSession().delete(inetDomain); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public Collection listInetDomains(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser()) |
return HibernateUtil.currentSession().find("from InetDomain"); |
else |
return HibernateUtil.currentSession().find( |
"from InetDomain where owner=?", editor, Hibernate.entity(User.class)); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public boolean areInetDomainsAvailable(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser()) |
return true; |
else |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from InetDomain where owner=?", |
editor, Hibernate.entity(User.class)).next()).intValue() > 0; |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
private static InetDomainManager inetDomainManager = null; |
public static InetDomainManager getInstance() |
{ |
if(inetDomainManager == null) |
inetDomainManager = new InetDomainManager(); |
return inetDomainManager; |
} |
public static final Comparator NAME_COMPARATOR = new NameComparator(); |
private static class NameComparator |
implements Comparator |
{ |
public int compare(Object o1, Object o2) |
{ |
if(!(o1 instanceof InetDomain) || !(o2 instanceof InetDomain)) |
throw new ClassCastException("not a InetDomain"); |
InetDomain a1 = (InetDomain)o1; |
InetDomain a2 = (InetDomain)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); |
} |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/SystemUser.java |
---|
0,0 → 1,142 |
package ak.hostadmiral.core.model; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
/** |
* |
* @hibernate.class table="systemusers" |
*/ |
public class SystemUser |
extends GeneralModelObject |
{ |
private Long id; |
/** user id in the OS */ |
private Integer uid; |
private String name; |
private User owner; |
protected SystemUser() |
{ |
} |
/** |
* |
* @hibernate.id generator-class="native" |
*/ |
public Long getId() |
{ |
return id; |
} |
protected void setId(Long id) |
{ |
this.id = id; |
} |
/** |
* |
* @hibernate.property |
*/ |
public Integer getUid() |
{ |
return uid; |
} |
protected void setUid(Integer uid) |
{ |
this.uid = uid; |
} |
public void setUid(User editor, Integer uid) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.uid = uid; |
} |
/** |
* |
* @hibernate.property |
*/ |
public String getName() |
{ |
return name; |
} |
protected void setName(String name) |
{ |
this.name = name; |
} |
public void setName(User editor, String name) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.name = name; |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public User getOwner() |
{ |
return owner; |
} |
protected void setOwner(User owner) |
{ |
this.owner = owner; |
} |
public void setOwner(User editor, User owner) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.owner = owner; |
} |
public String getTypeKey() |
{ |
return ak.hostadmiral.core.CoreResources.TYPE_SYSTEM_USER; |
} |
public String getIdentKey() |
{ |
return ak.hostadmiral.core.CoreResources.IDENT_SYSTEM_USER; |
} |
public Object[] getIdentParams() |
{ |
return new Object[] { getName(), getUid() }; |
} |
public boolean viewableBy(User user) |
{ |
return user.isSuperuser() || (owner == null) || user.equals(owner); |
} |
public boolean editableBy(User user) |
{ |
return user.isSuperuser(); |
} |
public boolean deleteableBy(User user) |
{ |
return user.isSuperuser(); |
} |
protected static boolean allowedToCreate(SystemUserManager manager, User editor) |
throws ModelException |
{ |
return editor.isSuperuser(); |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/GeneralModelObject.java |
---|
0,0 → 1,88 |
package ak.hostadmiral.core.model; |
import java.util.Date; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
public abstract class GeneralModelObject |
implements ModelObject |
{ |
private Boolean enabled; |
private String comment; |
private Date modStamp; |
private User modUser; |
/** |
* |
* @hibernate.property |
*/ |
public Boolean getEnabled() |
{ |
return enabled; |
} |
protected void setEnabled(Boolean enabled) |
{ |
this.enabled = enabled; |
} |
public void setEnabled(User editor, Boolean enabled) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.enabled = enabled; |
} |
/** |
* |
* @hibernate.property |
*/ |
public String getComment() |
{ |
return comment; |
} |
protected void setComment(String comment) |
{ |
this.comment = comment; |
} |
public void setComment(User editor, String comment) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.comment = comment; |
} |
/** |
* |
* @hibernate.timestamp column="mod_stamp" |
*/ |
public Date getModStamp() |
{ |
return modStamp; |
} |
protected void setModStamp(Date modStamp) |
{ |
this.modStamp = modStamp; |
} |
/** |
* |
* @hibernate.many-to-one column="mod_user" |
*/ |
public User getModUser() |
{ |
return modUser; |
} |
protected void setModUser(User modUser) |
{ |
this.modUser = modUser; |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/MailboxManager.java |
---|
0,0 → 1,202 |
package ak.hostadmiral.core.model; |
import java.util.*; |
import net.sf.hibernate.*; |
import net.sf.hibernate.type.Type; |
import ak.hostadmiral.util.HibernateUtil; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
public class MailboxManager |
{ |
private static boolean registered = false; |
protected static void register() |
{ |
synchronized(MailboxManager.class) { |
if(registered) return; |
registered = true; |
try { |
HibernateUtil.getConfiguration().addResource( |
"/ak/hostadmiral/core/model/Mailbox.hbm.xml"); |
} |
catch(Exception ex) { |
ex.printStackTrace(); |
throw new RuntimeException(ex.getMessage()); |
} |
} |
} |
static { |
register(); |
} |
private MailboxManager() |
{ |
} |
public Mailbox create(User editor) |
throws ModelException |
{ |
if(!allowedToCreate(editor)) throw new ModelSecurityException(); |
return new Mailbox(); |
} |
public boolean allowedToCreate(User editor) |
throws ModelException |
{ |
return Mailbox.allowedToCreate(this, editor); |
} |
public Mailbox get(User editor, Long id) |
throws ModelException |
{ |
Mailbox mailbox; |
try { |
mailbox = (Mailbox)HibernateUtil.currentSession().load(Mailbox.class, id); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
if(!mailbox.viewableBy(editor)) |
throw new ModelSecurityException(); |
return mailbox; |
} |
protected Mailbox findForLogin(String login) |
throws ModelException |
{ |
try { |
List list = HibernateUtil.currentSession().find( |
"from Mailbox where login=?", login, Hibernate.STRING); |
if(list.size() == 0) |
return null; |
else |
return (Mailbox)list.get(0); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void save(User editor, Mailbox mailbox) |
throws ModelException |
{ |
if(!mailbox.editableBy(editor)) |
throw new ModelSecurityException(); |
mailbox.setModUser(editor); |
try { |
HibernateUtil.currentSession().saveOrUpdate(mailbox); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void delete(User editor, Mailbox mailbox) |
throws ModelException |
{ |
if(!mailbox.deleteableBy(editor)) |
throw new ModelSecurityException(); |
try { |
HibernateUtil.currentSession().delete(mailbox); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public Collection listMailboxes(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser()) |
return HibernateUtil.currentSession().find("from Mailbox"); |
else |
return HibernateUtil.currentSession().find( |
"select mb from Mailbox mb left join mb.domain as d" |
+ " where d.owner=? or mb.owner=?", |
new Object[] { editor, editor }, |
new Type[] { Hibernate.entity(User.class), Hibernate.entity(User.class) } ); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public boolean areMailboxesAvailable(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser() |
|| InetDomainManager.getInstance().areInetDomainsAvailable(editor)) |
{ |
return true; |
} |
else { |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from Mailbox mb left join mb.domain as d" |
+ " where d.owner=? or mb.owner=?", |
new Object[] { editor, editor }, |
new Type[] { Hibernate.entity(User.class), Hibernate.entity(User.class) }) |
.next()).intValue() > 0; |
} |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
private static MailboxManager mailboxManager = null; |
public static MailboxManager getInstance() |
{ |
if(mailboxManager == null) |
mailboxManager = new MailboxManager(); |
return mailboxManager; |
} |
public static final Comparator LOGIN_COMPARATOR = new LoginComparator(); |
private static class LoginComparator |
implements Comparator |
{ |
public int compare(Object o1, Object o2) |
{ |
if(!(o1 instanceof Mailbox) || !(o2 instanceof Mailbox)) |
throw new ClassCastException("not a Mailbox"); |
Mailbox a1 = (Mailbox)o1; |
Mailbox a2 = (Mailbox)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.getLogin().compareToIgnoreCase(a2.getLogin()); |
} |
public boolean equals(Object obj) |
{ |
return (obj instanceof LoginComparator); |
} |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/InetDomain.java |
---|
0,0 → 1,116 |
package ak.hostadmiral.core.model; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
/** |
* |
* @hibernate.class table="domains" |
*/ |
public class InetDomain |
extends GeneralModelObject |
{ |
private Long id; |
private String name; |
private User owner; |
protected InetDomain() |
{ |
} |
/** |
* |
* @hibernate.id generator-class="native" |
*/ |
public Long getId() |
{ |
return id; |
} |
protected void setId(Long id) |
{ |
this.id = id; |
} |
/** |
* |
* @hibernate.property |
*/ |
public String getName() |
{ |
return name; |
} |
protected void setName(String name) |
{ |
this.name = name; |
} |
public void setName(User editor, String name) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.name = name; |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public User getOwner() |
{ |
return owner; |
} |
protected void setOwner(User owner) |
{ |
this.owner = owner; |
} |
public void setOwner(User editor, User owner) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.owner = owner; |
} |
public String getTypeKey() |
{ |
return ak.hostadmiral.core.CoreResources.TYPE_DOMAIN; |
} |
public String getIdentKey() |
{ |
return ak.hostadmiral.core.CoreResources.IDENT_DOMAIN; |
} |
public Object[] getIdentParams() |
{ |
return new Object[] { getName() }; |
} |
public boolean viewableBy(User user) |
{ |
return user.isSuperuser() || user.equals(owner); |
} |
public boolean editableBy(User user) |
{ |
return user.isSuperuser(); |
} |
public boolean deleteableBy(User user) |
{ |
return user.isSuperuser(); |
} |
protected static boolean allowedToCreate(InetDomainManager manager, User editor) |
throws ModelException |
{ |
return editor.isSuperuser(); |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/MailAliasManager.java |
---|
0,0 → 1,204 |
package ak.hostadmiral.core.model; |
import java.util.*; |
import net.sf.hibernate.*; |
import net.sf.hibernate.type.Type; |
import ak.hostadmiral.util.HibernateUtil; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
public class MailAliasManager |
{ |
private static boolean registered = false; |
protected static void register() |
{ |
synchronized(MailAliasManager.class) { |
if(registered) return; |
registered = true; |
try { |
HibernateUtil.getConfiguration().addResource( |
"/ak/hostadmiral/core/model/MailAlias.hbm.xml"); |
} |
catch(Exception ex) { |
ex.printStackTrace(); |
throw new RuntimeException(ex.getMessage()); |
} |
} |
} |
static { |
register(); |
} |
private MailAliasManager() |
{ |
} |
public MailAlias create(User editor) |
throws ModelException |
{ |
if(!allowedToCreate(editor)) throw new ModelSecurityException(); |
MailAlias alias = new MailAlias(); |
alias.setDestinations(new ArrayList()); |
return alias; |
} |
public boolean allowedToCreate(User editor) |
throws ModelException |
{ |
return MailAlias.allowedToCreate(this, editor); |
} |
public MailAlias get(User editor, Long id) |
throws ModelException |
{ |
MailAlias alias; |
try { |
alias = (MailAlias)HibernateUtil.currentSession().load(MailAlias.class, id); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
if(!alias.viewableBy(editor)) |
throw new ModelSecurityException(); |
return alias; |
} |
protected MailAlias findForName(String name) |
throws ModelException |
{ |
try { |
List list = HibernateUtil.currentSession().find( |
"from MailAlias where name=?", name, Hibernate.STRING); |
if(list.size() == 0) |
return null; |
else |
return (MailAlias)list.get(0); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void save(User editor, MailAlias mailAlias) |
throws ModelException |
{ |
if(!mailAlias.editableBy(editor)) |
throw new ModelSecurityException(); |
mailAlias.setModUser(editor); |
try { |
HibernateUtil.currentSession().saveOrUpdate(mailAlias); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void delete(User editor, MailAlias mailAlias) |
throws ModelException |
{ |
if(!mailAlias.deleteableBy(editor)) |
throw new ModelSecurityException(); |
try { |
HibernateUtil.currentSession().delete(mailAlias); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public Collection listMailAliases(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser()) |
return HibernateUtil.currentSession().find("from MailAlias"); |
else |
return HibernateUtil.currentSession().find( |
"select a from MailAlias a left join a.domain as d" |
+ " where d.owner=? or a.owner=?", |
new Object[] { editor, editor }, |
new Type[] { Hibernate.entity(User.class), Hibernate.entity(User.class) } ); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public boolean areMailAliasesAvailable(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser() |
|| InetDomainManager.getInstance().areInetDomainsAvailable(editor)) |
{ |
return true; |
} |
else { |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from MailAlias a left join a.domain as d" |
+ " where d.owner=? or a.owner=?", |
new Object[] { editor, editor }, |
new Type[] { Hibernate.entity(User.class), Hibernate.entity(User.class) }) |
.next()).intValue() > 0; |
} |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
private static MailAliasManager mailAliasManager = null; |
public static MailAliasManager getInstance() |
{ |
if(mailAliasManager == null) |
mailAliasManager = new MailAliasManager(); |
return mailAliasManager; |
} |
public static final Comparator ADDRESS_COMPARATOR = new AddressComparator(); |
private static class AddressComparator |
implements Comparator |
{ |
public int compare(Object o1, Object o2) |
{ |
if(!(o1 instanceof MailAlias) || !(o2 instanceof MailAlias)) |
throw new ClassCastException("not a MailAlias"); |
MailAlias a1 = (MailAlias)o1; |
MailAlias a2 = (MailAlias)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.getAddress().compareToIgnoreCase(a2.getAddress()); |
} |
public boolean equals(Object obj) |
{ |
return (obj instanceof AddressComparator); |
} |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/ModelObject.java |
---|
0,0 → 1,16 |
package ak.hostadmiral.core.model; |
public interface ModelObject |
{ |
public String getTypeKey(); |
public String getIdentKey(); |
public Object[] getIdentParams(); |
public boolean viewableBy(User user); |
public boolean editableBy(User user); |
public boolean deleteableBy(User user); |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/MailAliasDestinationManager.java |
---|
0,0 → 1,162 |
package ak.hostadmiral.core.model; |
import java.util.*; |
import net.sf.hibernate.*; |
import ak.hostadmiral.util.HibernateUtil; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
public class MailAliasDestinationManager |
{ |
private static boolean registered = false; |
protected static void register() |
{ |
synchronized(MailAliasDestinationManager.class) { |
if(registered) return; |
registered = true; |
try { |
HibernateUtil.getConfiguration().addResource( |
"/ak/hostadmiral/core/model/MailAliasDestination.hbm.xml"); |
} |
catch(Exception ex) { |
ex.printStackTrace(); |
throw new RuntimeException(ex.getMessage()); |
} |
} |
} |
static { |
register(); |
} |
private MailAliasDestinationManager() |
{ |
} |
public MailAliasDestination create(User editor) |
throws ModelException |
{ |
if(!allowedToCreate(editor)) throw new ModelSecurityException(); |
return new MailAliasDestination(); |
} |
public boolean allowedToCreate(User editor) |
throws ModelException |
{ |
return MailAliasDestination.allowedToCreate(this, editor); |
} |
public MailAliasDestination get(User editor, Long id) |
throws ModelException |
{ |
MailAliasDestination dest; |
try { |
dest = (MailAliasDestination)HibernateUtil.currentSession() |
.load(MailAliasDestination.class, id); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
if(!dest.viewableBy(editor)) |
throw new ModelSecurityException(); |
return dest; |
} |
public void save(User editor, MailAliasDestination mailAliasDestination) |
throws ModelException |
{ |
if(!mailAliasDestination.editableBy(editor)) |
throw new ModelSecurityException(); |
mailAliasDestination.setModUser(editor); |
// FIXME: the mod_user is not set when changing a destination as element of collection |
try { |
HibernateUtil.currentSession().saveOrUpdate(mailAliasDestination); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void delete(User editor, MailAliasDestination mailAliasDestination) |
throws ModelException |
{ |
if(!mailAliasDestination.deleteableBy(editor)) |
throw new ModelSecurityException(); |
try { |
HibernateUtil.currentSession().delete(mailAliasDestination); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public Collection listMailAliasesDestination(MailAlias alias) |
throws ModelException |
{ |
try { |
return HibernateUtil.currentSession().find( |
"from MailAliasDestination where alias=?", |
alias, Hibernate.entity(MailAlias.class)); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public boolean areMailAliasesDestinationsAvailable(User editor) |
throws ModelException |
{ |
return true; |
} |
private static MailAliasDestinationManager mailAliasDestinationManager = null; |
public static MailAliasDestinationManager getInstance() |
{ |
if(mailAliasDestinationManager == null) |
mailAliasDestinationManager = new MailAliasDestinationManager(); |
return mailAliasDestinationManager; |
} |
public static final Comparator EMAIL_COMPARATOR = new EmailComparator(); |
private static class EmailComparator |
implements Comparator |
{ |
public int compare(Object o1, Object o2) |
{ |
if(!(o1 instanceof MailAliasDestination) || !(o2 instanceof MailAliasDestination)) |
throw new ClassCastException("not a MailAliasDestination"); |
MailAliasDestination a1 = (MailAliasDestination)o1; |
MailAliasDestination a2 = (MailAliasDestination)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.getEmail().compareToIgnoreCase(a2.getEmail()); |
} |
public boolean equals(Object obj) |
{ |
return (obj instanceof EmailComparator); |
} |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/UserManager.java |
---|
0,0 → 1,242 |
package ak.hostadmiral.core.model; |
import java.util.*; |
import net.sf.hibernate.*; |
import net.sf.hibernate.type.Type; |
import ak.hostadmiral.util.HibernateUtil; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
public class UserManager |
{ |
private static boolean registered = false; |
protected static void register() |
{ |
synchronized(MailboxManager.class) { |
if(registered) return; |
registered = true; |
try { |
HibernateUtil.getConfiguration().addResource( |
"/ak/hostadmiral/core/model/User.hbm.xml"); |
} |
catch(Exception ex) { |
ex.printStackTrace(); |
throw new RuntimeException(ex.getMessage()); |
} |
} |
} |
static { |
register(); |
} |
private UserManager() |
{ |
} |
public User create(User editor) |
throws ModelException |
{ |
if(!allowedToCreate(editor)) throw new ModelSecurityException(); |
return new User(); |
} |
public boolean allowedToCreate(User editor) |
throws ModelException |
{ |
return User.allowedToCreate(this, editor); |
} |
public User get(User editor, Long id) |
throws ModelException |
{ |
User user; |
try { |
user = (User)HibernateUtil.currentSession().load(User.class, id); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
if(!user.viewableBy(editor)) |
throw new ModelSecurityException(); |
return user; |
} |
public boolean loginExists(User editor, User user, String login) |
throws ModelException |
{ |
try { |
if(user.getId() == null) |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from User u where login = ?", |
login, Hibernate.STRING) |
.next()).intValue() > 0; |
else |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from User u where login = ? and u != ?", |
new Object[] { login, user }, |
new Type[] { Hibernate.STRING, Hibernate.entity(User.class) } ) |
.next()).intValue() > 0; |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public User findForLogin(String login) |
throws ModelException |
{ |
try { |
List list = HibernateUtil.currentSession().find( |
"from User where login=? and enabled='1'", login, Hibernate.STRING); |
if(list.size() == 0) |
return null; |
else |
return (User)list.get(0); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void save(User editor, User user) |
throws ModelException |
{ |
if(!user.editableBy(editor) && !user.mayChangePassword(editor) |
&& !user.mayChangeSuperuser(editor)) |
{ |
throw new ModelSecurityException(); |
} |
user.setModUser(editor); |
try { |
HibernateUtil.currentSession().saveOrUpdate(user); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public void delete(User editor, User user) |
throws ModelException |
{ |
if(!user.deleteableBy(editor)) |
throw new ModelSecurityException(); |
try { |
HibernateUtil.currentSession().delete(user); |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public Collection listUsers(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser()) { |
return HibernateUtil.currentSession().find("from User"); |
} |
else { |
return HibernateUtil.currentSession().find( |
"from User u where u = ? or u.boss = ?", |
new Object[] { editor, editor}, |
new Type[] { Hibernate.entity(User.class), Hibernate.entity(User.class) } ); |
} |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public boolean areUsersAvailable(User editor) |
throws ModelException |
{ |
try { |
if(editor.isSuperuser()) { |
return true; |
} |
else { |
return ((Integer)HibernateUtil.currentSession().iterate( |
"select count(*) from User u where u = ? or u.boss = ?", |
new Object[] { editor, editor}, |
new Type[] { Hibernate.entity(User.class), Hibernate.entity(User.class) } ) |
.next()).intValue() > 0; |
} |
} |
catch(HibernateException ex) |
{ |
throw new ModelException(ex); |
} |
} |
public User loginUser(String login, String password) |
throws ModelException |
{ |
if(login == null || password == null) |
return null; |
User user = findForLogin(login); |
if(user != null) { |
if(user.checkPassword(password)) |
return user; |
} |
// wrong login or password |
return null; |
} |
private static UserManager userManager = null; |
public static UserManager getInstance() |
{ |
if(userManager == null) |
userManager = new UserManager(); |
return userManager; |
} |
public static final Comparator LOGIN_COMPARATOR = new LoginComparator(); |
private static class LoginComparator |
implements Comparator |
{ |
public int compare(Object o1, Object o2) |
{ |
if(!(o1 instanceof User) || !(o2 instanceof User)) |
throw new ClassCastException("not a User"); |
User a1 = (User)o1; |
User a2 = (User)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.getLogin().compareToIgnoreCase(a2.getLogin()); |
} |
public boolean equals(Object obj) |
{ |
return (obj instanceof LoginComparator); |
} |
} |
} |
/sun/hostcaptain/trunk/src/ak/hostadmiral/core/model/Mailbox.java |
---|
0,0 → 1,239 |
package ak.hostadmiral.core.model; |
import ak.hostadmiral.util.Digest; |
import ak.hostadmiral.util.ModelException; |
import ak.hostadmiral.util.ModelSecurityException; |
/** |
* |
* @hibernate.class table="mailboxes" |
*/ |
public class Mailbox |
extends GeneralModelObject |
{ |
private Long id; |
private String login; |
private String password; |
private InetDomain domain; |
private User owner; |
private Boolean virusCheck; |
private Boolean spamCheck; |
private SystemUser systemUser; |
protected Mailbox() |
{ |
} |
/** |
* |
* @hibernate.id generator-class="native" |
*/ |
public Long getId() |
{ |
return id; |
} |
protected void setId(Long id) |
{ |
this.id = id; |
} |
/** |
* |
* @hibernate.property |
*/ |
public String getLogin() |
{ |
return login; |
} |
protected void setLogin(String login) |
{ |
this.login = login; |
} |
public void setLogin(User editor, String login) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.login = login; |
} |
/** |
* |
* @hibernate.property |
*/ |
protected String getPassword() |
{ |
return password; |
} |
protected void setPassword(String password) |
{ |
this.password = password; |
} |
public void setPassword(User editor, String password) |
throws ModelException |
{ |
if(password == null) |
throw new NullPointerException("Null password"); |
this.password = Digest.encode(password); |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public InetDomain getDomain() |
{ |
return domain; |
} |
protected void setDomain(InetDomain domain) |
{ |
this.domain = domain; |
} |
public void setDomain(User editor, InetDomain domain) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.domain = domain; |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public User getOwner() |
{ |
return owner; |
} |
protected void setOwner(User owner) |
{ |
this.owner = owner; |
} |
public void setOwner(User editor, User owner) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.owner = owner; |
} |
/** |
* |
* @hibernate.property |
*/ |
public Boolean getVirusCheck() |
{ |
return virusCheck; |
} |
protected void setVirusCheck(Boolean virusCheck) |
{ |
this.virusCheck = virusCheck; |
} |
public void setVirusCheck(User editor, Boolean virusCheck) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.virusCheck = virusCheck; |
} |
/** |
* |
* @hibernate.property |
*/ |
public Boolean getSpamCheck() |
{ |
return spamCheck; |
} |
protected void setSpamCheck(Boolean spamCheck) |
{ |
this.spamCheck = spamCheck; |
} |
public void setSpamCheck(User editor, Boolean spamCheck) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.spamCheck = spamCheck; |
} |
/** |
* |
* @hibernate.many-to-one |
*/ |
public SystemUser getSystemUser() |
{ |
return systemUser; |
} |
protected void setSystemUser(SystemUser systemUser) |
{ |
this.systemUser = systemUser; |
} |
public void setSystemUser(User editor, SystemUser systemUser) |
throws ModelException |
{ |
if(!editableBy(editor)) |
throw new ModelSecurityException(); |
this.systemUser = systemUser; |
} |
public String getTypeKey() |
{ |
return ak.hostadmiral.core.CoreResources.TYPE_MAILBOX; |
} |
public String getIdentKey() |
{ |
return ak.hostadmiral.core.CoreResources.IDENT_MAILBOX; |
} |
public Object[] getIdentParams() |
{ |
return new Object[] { getLogin(), getDomain().getName() }; |
} |
public boolean viewableBy(User user) |
{ |
return user.isSuperuser() || user.equals(domain.getOwner()) || user.equals(owner); |
} |
public boolean editableBy(User user) |
{ |
return user.isSuperuser() || user.equals(domain.getOwner()); |
} |
public boolean deleteableBy(User user) |
{ |
return user.isSuperuser() || user.equals(domain.getOwner()); |
} |
protected static boolean allowedToCreate(MailboxManager manager, User editor) |
throws ModelException |
{ |
return editor.isSuperuser() |
|| InetDomainManager.getInstance().areInetDomainsAvailable(editor); |
} |
} |