| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/UserManager.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/MailAliasDestinationManager.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/Mailbox.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/MailAlias.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/MailAliasDestination.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/SystemUserManager.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/User.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/InetDomainManager.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/SystemUser.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/GeneralModelObject.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/MailboxManager.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/ModelObject.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/MailAliasManager.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/model/InetDomain.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/ModelObjectOptionsTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/DeleteableTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/NotDeleteableTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/RightTagBase.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/EditableTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/NotEditableTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/WriteTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/MethodTagBase.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/NoRightsTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/ViewableTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/NotViewableTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/taglib/RightsTag.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/CoreResources.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/form/MailAliasDestBean.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/form/UserPasswordForm.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/servlet/LoginFilter.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/servlet/HibernateFilter.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/servlet/EncodingFilter.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/SystemUserAction.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/InetDomainAction.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/IndexAction.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/LoginAction.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/ChangePasswordAction.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/LogoutAction.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/MailboxAction.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/MailAliasAction.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/UserExceptionHandler.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/action/UserAction.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/core/CoreResources.properties |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/util/HibernateUtil.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/util/ModelException.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/util/Digest.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/util/FormException.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/util/ModelSecurityException.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/util/UserException.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostcaptain/util/StringConverter.java |
|---|
| File deleted |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/CoreResources.properties |
|---|
| 0,0 → 1,300 |
| ak.hostadmiral.core.type.user=user |
| ak.hostadmiral.core.type.systemUser=system user |
| ak.hostadmiral.core.type.domain=domain |
| ak.hostadmiral.core.type.mailbox=mailbox |
| ak.hostadmiral.core.type.mailAlias=mail alias |
| ak.hostadmiral.core.type.mailAliasDestination=mail alias destination |
| ak.hostadmiral.core.ident.user={0} |
| ak.hostadmiral.core.ident.systemUser={0} ({1}) |
| ak.hostadmiral.core.ident.domain={0} |
| ak.hostadmiral.core.ident.mailbox={0}@{1} |
| ak.hostadmiral.core.ident.mailAlias={0}@{1} |
| ak.hostadmiral.core.ident.mailAliasDestination.external={0} |
| ak.hostadmiral.core.ident.mailAliasDestination.internal={0}@{1} |
| ak.hostadmiral.core.access.denied=Access to the object denied |
| ak.hostadmiral.core.login.failed=Wrong login or password or the user is disabled |
| ak.hostadmiral.core.login.required=You have to enter the login |
| ak.hostadmiral.core.password.required=You have to enter the password |
| ak.hostadmiral.core.oldpassword.required=You have to enter the old password |
| ak.hostadmiral.core.oldpassword.wrong=Wrong old password |
| ak.hostadmiral.core.password.dontMatch=The passwords you entered doesn't match |
| ak.hostadmiral.core.user.login.nonunique=The user login already exists |
| ak.hostadmiral.core.user.password.change.id.wrong=Please select an user from the list |
| ak.hostadmiral.core.user.deletemeself=Can not delete the user you are logged in |
| ak.hostadmiral.core.user.boss.id.wrong=Please select a boss from the list |
| ak.hostadmiral.core.user.system.uid.nonunique=The UID already exists |
| ak.hostadmiral.core.user.system.name.nonunique=The user name already exists |
| ak.hostadmiral.core.domain.name.nonunique=The domain name already exists |
| ak.hostadmiral.core.mailbox.edit.id.wrong=Please select a mailbox from the list |
| ak.hostadmiral.core.mailbox.edit.login.empty=You have to enter the login |
| ak.hostadmiral.core.mailbox.edit.domain.wrong=Please select a domain from the list |
| ak.hostadmiral.core.mailbox.edit.owner.wrong=Please select an owner from the list |
| ak.hostadmiral.core.mailbox.edit.systemuser.wrong=Please select a system user from the list |
| ak.hostadmiral.core.mail.alias.edit.id.wrong=Please select a mail alias from the list |
| ak.hostadmiral.core.mail.alias.edit.dest.id.wrong=Wrong ID |
| ak.hostadmiral.core.mail.alias.edit.mailbox.id.wrong=Please select a mailbox from the list |
| ak.hostadmiral.core.mail.alias.edit.email.wrong=Please enter an email |
| ak.hostadmiral.core.mail.alias.edit.address.empty=Please enter an address |
| ak.hostadmiral.core.mail.alias.edit.domain.wrong=Please select a domain from the list |
| ak.hostadmiral.core.mail.alias.edit.owner.wrong=Please select an owner from the list |
| ak.hostadmiral.core.user.system.edit.id.wrong=Please select an user from the list |
| ak.hostadmiral.core.user.system.edit.uid.wrong=Please enter the UID |
| ak.hostadmiral.core.user.system.edit.name.required=Please enter name of the user |
| ak.hostadmiral.core.user.system.edit.owner.wrong=Please select an owner from the list |
| ak.hostadmiral.core.domain.edit.id.wrong=Please select a domain from the list |
| ak.hostadmiral.core.domain.edit.owner.wrong=Please select an owner from the list |
| ak.hostadmiral.core.domain.edit.name.empty=Please enter domain name |
| ak.hostadmiral.core.mail.alias.edit.id.wrong=Please select an alias from the list |
| ak.hostadmiral.page.error.title=hostadmiral - error |
| ak.hostadmiral.page.error.back=back |
| ak.hostadmiral.page.generalError.title=hostadmiral - error |
| ak.hostadmiral.page.generalError.message=There is internal server error occured. Please go back and try again. If the error occurs again continue with the start page. |
| ak.hostadmiral.page.generalError.index=start page |
| ak.hostadmiral.page.generalError.back=back |
| ak.hostadmiral.page.index.title=hostadmiral |
| ak.hostadmiral.page.index.password_change=change password |
| ak.hostadmiral.page.index.user_list=users |
| ak.hostadmiral.page.index.system_user_list=system users |
| ak.hostadmiral.page.index.domain_list=domains |
| ak.hostadmiral.page.index.mail_alias_list=mail aliases |
| ak.hostadmiral.page.index.mail_box_list=mail boxes |
| ak.hostadmiral.page.index.logout=logout |
| ak.hostadmiral.page.index.login=Logged in as |
| ak.hostadmiral.page.system.login.title=hostadmiral - login |
| ak.hostadmiral.page.system.login.login=Login |
| ak.hostadmiral.page.system.login.password=Password |
| ak.hostadmiral.page.system.login.submit=Login |
| ak.hostadmiral.page.system.login.reset=Reset |
| ak.hostadmiral.page.system.logout.title=hostadmiral - logout |
| ak.hostadmiral.page.system.logout.message=You are logged out sucessfully. See you later! |
| ak.hostadmiral.page.system.logout.login=start new session |
| ak.hostadmiral.page.system.logout.back=return to system |
| ak.hostadmiral.page.user.password.change.title=hostadmiral - change password |
| ak.hostadmiral.page.user.password.change.old_password=Old password |
| ak.hostadmiral.page.user.password.change.new_password=New password |
| ak.hostadmiral.page.user.password.change.new_password_again=New password again |
| ak.hostadmiral.page.user.password.change.submit=submit |
| ak.hostadmiral.page.user.password.change.back=back |
| ak.hostadmiral.page.user.list.title=hostadmiral - users - list |
| ak.hostadmiral.page.user.list.login=Login |
| ak.hostadmiral.page.user.list.boss=Boss |
| ak.hostadmiral.page.user.list.superuser=Superuser |
| ak.hostadmiral.page.user.list.enabled=Enabled |
| ak.hostadmiral.page.user.list.delete=delete |
| ak.hostadmiral.page.user.list.edit=edit |
| ak.hostadmiral.page.user.list.view=view |
| ak.hostadmiral.page.user.list.add=add new user |
| ak.hostadmiral.page.user.list.back=back |
| ak.hostadmiral.page.user.edit.title=hostadmiral - user - edit |
| ak.hostadmiral.page.user.edit.login=Login |
| ak.hostadmiral.page.user.edit.password=Password |
| ak.hostadmiral.page.user.edit.password_again=Password again |
| ak.hostadmiral.page.user.edit.boss=Boss |
| ak.hostadmiral.page.user.edit.boss.empty=-- no boss -- |
| ak.hostadmiral.page.user.edit.superuser=Superuser |
| ak.hostadmiral.page.user.edit.superuser.true=yes |
| ak.hostadmiral.page.user.edit.superuser.false=no |
| ak.hostadmiral.page.user.edit.enabled=Enabled |
| ak.hostadmiral.page.user.edit.comment=Comment |
| ak.hostadmiral.page.user.edit.submit=submit |
| ak.hostadmiral.page.user.edit.back=back |
| ak.hostadmiral.page.user.view.title=hostadmiral - user - view |
| ak.hostadmiral.page.user.view.login=Login |
| ak.hostadmiral.page.user.view.boss=Boss |
| ak.hostadmiral.page.user.view.boss.empty=[no boss] |
| ak.hostadmiral.page.user.view.superuser=Superuser |
| ak.hostadmiral.page.user.view.superuser.true=yes |
| ak.hostadmiral.page.user.view.superuser.false=no |
| ak.hostadmiral.page.user.view.enabled=Enabled |
| ak.hostadmiral.page.user.view.enabled.true=yes |
| ak.hostadmiral.page.user.view.enabled.false=no |
| ak.hostadmiral.page.user.view.comment=Comment |
| ak.hostadmiral.page.user.view.back=back |
| ak.hostadmiral.page.user.system.list.title=hostadmiral - system users - list |
| ak.hostadmiral.page.user.system.list.uid=System ID |
| ak.hostadmiral.page.user.system.list.name=User name |
| ak.hostadmiral.page.user.system.list.owner=Owner |
| ak.hostadmiral.page.user.system.list.enabled=Enabled |
| ak.hostadmiral.page.user.system.list.delete=delete |
| ak.hostadmiral.page.user.system.list.edit=edit |
| ak.hostadmiral.page.user.system.list.view=view |
| ak.hostadmiral.page.user.system.list.add=add new user |
| ak.hostadmiral.page.user.system.list.back=back |
| ak.hostadmiral.page.user.system.edit.title=hostadmiral - system user - edit |
| ak.hostadmiral.page.user.system.edit.uid=System ID |
| ak.hostadmiral.page.user.system.edit.name=User name |
| ak.hostadmiral.page.user.system.edit.owner=Owner |
| ak.hostadmiral.page.user.system.edit.owner.empty=-- common user -- |
| ak.hostadmiral.page.user.system.edit.enabled=Enabled |
| ak.hostadmiral.page.user.system.edit.comment=Comment |
| ak.hostadmiral.page.user.system.edit.submit=submit |
| ak.hostadmiral.page.user.system.edit.back=back |
| ak.hostadmiral.page.user.system.view.title=hostadmiral - system user - view |
| ak.hostadmiral.page.user.system.view.uid=System ID |
| ak.hostadmiral.page.user.system.view.name=User name |
| ak.hostadmiral.page.user.system.view.owner=Owner |
| ak.hostadmiral.page.user.system.view.owner.empty=[common user] |
| ak.hostadmiral.page.user.system.view.enabled=Enabled |
| ak.hostadmiral.page.user.system.view.enabled.true=yes |
| ak.hostadmiral.page.user.system.view.enabled.false=no |
| ak.hostadmiral.page.user.system.view.comment=Comment |
| ak.hostadmiral.page.user.system.view.back=back |
| ak.hostadmiral.page.domain.list.title=hostadmiral - domains - list |
| ak.hostadmiral.page.domain.list.name=Name |
| ak.hostadmiral.page.domain.list.owner=Owner |
| ak.hostadmiral.page.domain.list.enabled=Enabled |
| ak.hostadmiral.page.domain.list.delete=delete |
| ak.hostadmiral.page.domain.list.view=view |
| ak.hostadmiral.page.domain.list.edit=edit |
| ak.hostadmiral.page.domain.list.add=add new domain |
| ak.hostadmiral.page.domain.list.back=back |
| ak.hostadmiral.page.domain.edit.title=hostadmiral - domain - edit |
| ak.hostadmiral.page.domain.edit.name=Name |
| ak.hostadmiral.page.domain.edit.owner=Owner |
| ak.hostadmiral.page.domain.edit.owner.empty=-- please select -- |
| ak.hostadmiral.page.domain.edit.enabled=Enabled |
| ak.hostadmiral.page.domain.edit.comment=Comment |
| ak.hostadmiral.page.domain.edit.submit=submit |
| ak.hostadmiral.page.domain.edit.back=back |
| ak.hostadmiral.page.domain.view.title=hostadmiral - domain - view |
| ak.hostadmiral.page.domain.view.name=Name |
| ak.hostadmiral.page.domain.view.owner=Owner |
| ak.hostadmiral.page.domain.view.enabled=Enabled |
| ak.hostadmiral.page.domain.view.enabled.true=yes |
| ak.hostadmiral.page.domain.view.enabled.false=no |
| ak.hostadmiral.page.domain.view.comment=Comment |
| ak.hostadmiral.page.domain.view.back=back |
| ak.hostadmiral.page.mail.box.list.title=hostadmiral - mail boxes - list |
| ak.hostadmiral.page.mail.box.list.login=Box |
| ak.hostadmiral.page.mail.box.list.domain=Domain |
| ak.hostadmiral.page.mail.box.list.owner=Owner |
| ak.hostadmiral.page.mail.box.list.enabled=Enabled |
| ak.hostadmiral.page.mail.box.list.edit=edit |
| ak.hostadmiral.page.mail.box.list.view=view |
| ak.hostadmiral.page.mail.box.list.delete=delete |
| ak.hostadmiral.page.mail.box.list.add=add new mail box |
| ak.hostadmiral.page.mail.box.list.back=back |
| ak.hostadmiral.page.mail.box.edit.title=hostadmiral - mail box - edit |
| ak.hostadmiral.page.mail.box.edit.login=Box |
| ak.hostadmiral.page.mail.box.edit.password=Password |
| ak.hostadmiral.page.mail.box.edit.password_again=Password again |
| ak.hostadmiral.page.mail.box.edit.domain=Domain |
| ak.hostadmiral.page.mail.box.edit.domain.empty=-- please select -- |
| ak.hostadmiral.page.mail.box.edit.owner=Owner |
| ak.hostadmiral.page.mail.box.edit.owner.empty=-- create an user -- |
| ak.hostadmiral.page.mail.box.edit.systemuser=System user |
| ak.hostadmiral.page.mail.box.edit.systemuser.empty=-- please select -- |
| ak.hostadmiral.page.mail.box.edit.viruscheck=check mails for viruses |
| ak.hostadmiral.page.mail.box.edit.spamcheck=check mails for spam |
| ak.hostadmiral.page.mail.box.edit.enabled=Enabled |
| ak.hostadmiral.page.mail.box.edit.comment=Comment |
| ak.hostadmiral.page.mail.box.edit.submit=submit |
| ak.hostadmiral.page.mail.box.edit.back=back |
| ak.hostadmiral.page.mail.box.view.title=hostadmiral - mail box - view |
| ak.hostadmiral.page.mail.box.view.login=Box |
| ak.hostadmiral.page.mail.box.view.domain=Domain |
| ak.hostadmiral.page.mail.box.view.owner=Owner |
| ak.hostadmiral.page.mail.box.view.systemuser=System user |
| ak.hostadmiral.page.mail.box.view.systemuser.empty=[default user] |
| ak.hostadmiral.page.mail.box.view.viruscheck=check mails for viruses |
| ak.hostadmiral.page.mail.box.view.viruscheck.true=yes |
| ak.hostadmiral.page.mail.box.view.viruscheck.false=no |
| ak.hostadmiral.page.mail.box.view.spamcheck=check mails for spam |
| ak.hostadmiral.page.mail.box.view.spamcheck.true=yes |
| ak.hostadmiral.page.mail.box.view.spamcheck.false=no |
| ak.hostadmiral.page.mail.box.view.enabled=Enabled |
| ak.hostadmiral.page.mail.box.view.enabled.true=yes |
| ak.hostadmiral.page.mail.box.view.enabled.false=no |
| ak.hostadmiral.page.mail.box.view.comment=Comment |
| ak.hostadmiral.page.mail.box.view.back=back |
| ak.hostadmiral.page.mail.alias.list.title=hostadmiral - mail aliases - list |
| ak.hostadmiral.page.mail.alias.list.alias=Alias |
| ak.hostadmiral.page.mail.alias.list.domain=Domain |
| ak.hostadmiral.page.mail.alias.list.owner=Owner |
| ak.hostadmiral.page.mail.alias.list.enabled=Enabled |
| ak.hostadmiral.page.mail.alias.list.edit=edit |
| ak.hostadmiral.page.mail.alias.list.editdests=edit |
| ak.hostadmiral.page.mail.alias.list.view=view |
| ak.hostadmiral.page.mail.alias.list.delete=delete |
| ak.hostadmiral.page.mail.alias.list.back=back |
| ak.hostadmiral.page.mail.alias.list.add=add new mail alias |
| ak.hostadmiral.page.mail.alias.edit.title=hostadmiral - mail alias - edit |
| ak.hostadmiral.page.mail.alias.edit.address=Address |
| ak.hostadmiral.page.mail.alias.edit.domain=Domain |
| ak.hostadmiral.page.mail.alias.edit.domain.empty=-- please select -- |
| ak.hostadmiral.page.mail.alias.edit.owner=Owner |
| ak.hostadmiral.page.mail.alias.edit.owner.empty=-- please select -- |
| ak.hostadmiral.page.mail.alias.edit.enabled=Enabled |
| ak.hostadmiral.page.mail.alias.edit.comment=Comment |
| ak.hostadmiral.page.mail.alias.edit.header.tomailbox=To mailbox |
| ak.hostadmiral.page.mail.alias.edit.header.toexternal=or to external email |
| ak.hostadmiral.page.mail.alias.edit.header.enabled=Enabled |
| ak.hostadmiral.page.mail.alias.edit.header.comment=Comment |
| ak.hostadmiral.page.mail.alias.edit.external=external redirect |
| ak.hostadmiral.page.mail.alias.edit.add=add new destination |
| ak.hostadmiral.page.mail.alias.edit.delete=delete |
| ak.hostadmiral.page.mail.alias.edit.submit=submit |
| ak.hostadmiral.page.mail.alias.edit.back=back |
| ak.hostadmiral.page.mail.alias.editdest.title=hostadmiral - mail alias - edit |
| ak.hostadmiral.page.mail.alias.editdest.address=Address |
| ak.hostadmiral.page.mail.alias.editdest.domain=Domain |
| ak.hostadmiral.page.mail.alias.editdest.owner=Owner |
| ak.hostadmiral.page.mail.alias.editdest.enabled=Enabled |
| ak.hostadmiral.page.mail.alias.editdest.enabled.true=yes |
| ak.hostadmiral.page.mail.alias.editdest.enabled.false=no |
| ak.hostadmiral.page.mail.alias.editdest.comment=Comment |
| ak.hostadmiral.page.mail.alias.editdest.header.tomailbox=To mailbox |
| ak.hostadmiral.page.mail.alias.editdest.header.toexternal=or to external email |
| ak.hostadmiral.page.mail.alias.editdest.header.enabled=Enabled |
| ak.hostadmiral.page.mail.alias.editdest.header.comment=Comment |
| ak.hostadmiral.page.mail.alias.editdest.external=external redirect |
| ak.hostadmiral.page.mail.alias.editdest.add=add new destination |
| ak.hostadmiral.page.mail.alias.editdest.delete=delete |
| ak.hostadmiral.page.mail.alias.editdest.submit=submit |
| ak.hostadmiral.page.mail.alias.editdest.back=back |
| ak.hostadmiral.page.mail.alias.view.title=hostadmiral - mail alias - view |
| ak.hostadmiral.page.mail.alias.view.address=Address |
| ak.hostadmiral.page.mail.alias.view.domain=Domain |
| ak.hostadmiral.page.mail.alias.view.owner=Owner |
| ak.hostadmiral.page.mail.alias.view.enabled=Enabled |
| ak.hostadmiral.page.mail.alias.view.enabled.true=yes |
| ak.hostadmiral.page.mail.alias.view.enabled.false=no |
| ak.hostadmiral.page.mail.alias.view.comment=Comment |
| ak.hostadmiral.page.mail.alias.view.header.tomailbox=To mailbox |
| ak.hostadmiral.page.mail.alias.view.header.toexternal=or to external email |
| ak.hostadmiral.page.mail.alias.view.header.enabled=Enabled |
| ak.hostadmiral.page.mail.alias.view.dest.enabled.true=yes |
| ak.hostadmiral.page.mail.alias.view.dest.enabled.false=no |
| ak.hostadmiral.page.mail.alias.view.header.comment=Comment |
| ak.hostadmiral.page.mail.alias.view.external=external redirect |
| ak.hostadmiral.page.mail.alias.view.back=back |
| /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); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/ViewableTag.java |
|---|
| 0,0 → 1,13 |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.jsp.JspException; |
| public class ViewableTag |
| extends RightTagBase |
| { |
| protected boolean condition() |
| throws JspException |
| { |
| return object.viewableBy(user); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/NotViewableTag.java |
|---|
| 0,0 → 1,13 |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.jsp.JspException; |
| public class NotViewableTag |
| extends RightTagBase |
| { |
| protected boolean condition() |
| throws JspException |
| { |
| return !object.viewableBy(user); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/RightsTag.java |
|---|
| 0,0 → 1,15 |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.jsp.JspException; |
| import org.apache.struts.util.RequestUtils; |
| public class RightsTag |
| extends MethodTagBase |
| { |
| protected boolean condition(boolean value) |
| throws JspException |
| { |
| return value; |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/ModelObjectOptionsTag.java |
|---|
| 0,0 → 1,71 |
| // based on jakarta struts taglib |
| package ak.hostadmiral.core.taglib; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.Iterator; |
| import javax.servlet.jsp.JspException; |
| import org.apache.commons.beanutils.PropertyUtils; |
| import org.apache.struts.taglib.html.Constants; |
| import org.apache.struts.taglib.html.SelectTag; |
| import org.apache.struts.taglib.html.OptionsTag; |
| import org.apache.struts.util.MessageResources; |
| import org.apache.struts.util.ResponseUtils; |
| import ak.hostadmiral.core.model.ModelObject; |
| public class ModelObjectOptionsTag extends OptionsTag |
| { |
| protected static MessageResources coreMessages = |
| MessageResources.getMessageResources("ak.hostadmiral.core.CoreResources"); |
| public int doEndTag() throws JspException |
| { |
| SelectTag selectTag = (SelectTag) pageContext.getAttribute(Constants.SELECT_KEY); |
| if (selectTag == null) { |
| throw new JspException(messages.getMessage("optionsTag.select")); |
| } |
| StringBuffer sb = new StringBuffer(); |
| if (collection != null) { |
| Iterator collIterator = getIterator(collection, null); |
| while (collIterator.hasNext()) { |
| Object bean = collIterator.next(); |
| Object value = null; |
| if(!(bean instanceof ModelObject)) |
| throw new JspException("Not a ModelObject"); |
| ModelObject model = (ModelObject)bean; |
| try { |
| value = PropertyUtils.getProperty(bean, property); |
| if (value == null) { |
| value = ""; |
| } |
| } catch (IllegalAccessException e) { |
| throw new JspException( |
| messages.getMessage("getter.access", property, collection)); |
| } catch (InvocationTargetException e) { |
| Throwable t = e.getTargetException(); |
| throw new JspException( |
| messages.getMessage("getter.result", property, t.toString())); |
| } catch (NoSuchMethodException e) { |
| throw new JspException( |
| messages.getMessage("getter.method", property, collection)); |
| } |
| String identKey = model.getIdentKey(); |
| Object[] identParams = model.getIdentParams(); |
| String label = coreMessages.getMessage(identKey, identParams); |
| String stringValue = value.toString(); |
| addOption(sb, stringValue, label, selectTag.isMatched(stringValue)); |
| } |
| } |
| ResponseUtils.write(pageContext, sb.toString()); |
| return EVAL_PAGE; |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/DeleteableTag.java |
|---|
| 0,0 → 1,13 |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.jsp.JspException; |
| public class DeleteableTag |
| extends RightTagBase |
| { |
| protected boolean condition() |
| throws JspException |
| { |
| return object.deleteableBy(user); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/NotDeleteableTag.java |
|---|
| 0,0 → 1,13 |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.jsp.JspException; |
| public class NotDeleteableTag |
| extends RightTagBase |
| { |
| protected boolean condition() |
| throws JspException |
| { |
| return !object.deleteableBy(user); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/RightTagBase.java |
|---|
| 0,0 → 1,64 |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.jsp.JspException; |
| import javax.servlet.jsp.tagext.TagSupport; |
| import org.apache.struts.util.RequestUtils; |
| import ak.hostadmiral.core.model.User; |
| import ak.hostadmiral.core.model.ModelObject; |
| public abstract class RightTagBase |
| extends TagSupport |
| { |
| protected User user; |
| protected ModelObject object; |
| protected String name; |
| public String getName() |
| { |
| return name; |
| } |
| public void setName(String name) |
| { |
| this.name = name; |
| } |
| public void release() |
| { |
| super.release(); |
| name = null; |
| user = null; |
| } |
| public int doStartTag() |
| throws JspException |
| { |
| user = (User)RequestUtils.lookup(pageContext, "user", "session"); |
| Object obj = RequestUtils.lookup(pageContext, name, null); |
| if(obj == null) |
| throw new JspException(name + " is null"); |
| if(!(obj instanceof ModelObject)) |
| throw new JspException(name + " must be a ModelObject, but is " + obj.getClass()); |
| object = (ModelObject)obj; |
| if(condition()) |
| return EVAL_BODY_INCLUDE; |
| else |
| return SKIP_BODY; |
| } |
| public int doEndTag() |
| throws JspException |
| { |
| return EVAL_PAGE; |
| } |
| protected abstract boolean condition() |
| throws JspException; |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/EditableTag.java |
|---|
| 0,0 → 1,13 |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.jsp.JspException; |
| public class EditableTag |
| extends RightTagBase |
| { |
| protected boolean condition() |
| throws JspException |
| { |
| return object.editableBy(user); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/NotEditableTag.java |
|---|
| 0,0 → 1,13 |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.jsp.JspException; |
| public class NotEditableTag |
| extends RightTagBase |
| { |
| protected boolean condition() |
| throws JspException |
| { |
| return !object.editableBy(user); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/WriteTag.java |
|---|
| 0,0 → 1,50 |
| // based on struts write tag |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.jsp.JspException; |
| import org.apache.struts.util.RequestUtils; |
| import org.apache.struts.util.ResponseUtils; |
| public class WriteTag |
| extends org.apache.struts.taglib.bean.WriteTag |
| { |
| protected String defValue; |
| public String getDefault() |
| { |
| return defValue; |
| } |
| public void setDefault(String defValue) |
| { |
| this.defValue = defValue; |
| } |
| public int doStartTag() |
| throws JspException |
| { |
| Object value; |
| if(ignore && RequestUtils.lookup(pageContext, name, scope) == null) |
| value = null; |
| else |
| value = RequestUtils.lookup(pageContext, name, property, scope); |
| if(value == null) value = defValue; |
| if(value != null) { |
| if(filter) |
| ResponseUtils.write(pageContext, ResponseUtils.filter(formatValue(value))); |
| else |
| ResponseUtils.write(pageContext, formatValue(value)); |
| } |
| return SKIP_BODY; |
| } |
| public void release() |
| { |
| super.release(); |
| defValue = null; |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/MethodTagBase.java |
|---|
| 0,0 → 1,63 |
| package ak.hostadmiral.core.taglib; |
| import java.lang.reflect.Method; |
| import javax.servlet.jsp.JspException; |
| import ak.hostadmiral.core.model.User; |
| import org.apache.struts.util.RequestUtils; |
| public abstract class MethodTagBase |
| extends RightTagBase |
| { |
| protected String method; |
| public String getMethod() |
| { |
| return method; |
| } |
| public void setMethod(String method) |
| { |
| this.method = method; |
| } |
| public void release() |
| { |
| super.release(); |
| method = null; |
| } |
| protected boolean condition() |
| throws JspException |
| { |
| Method m; |
| Object value; |
| // find method |
| try { |
| m = object.getClass().getMethod(method, new Class[] { User.class } ); |
| } |
| catch(NoSuchMethodException ex) { |
| throw new JspException("Method " + method |
| + " with parameter of type user not found"); |
| } |
| // invoke it |
| try { |
| value = m.invoke(object, new Object[] { user } ); |
| } |
| catch(Exception ex) { |
| throw new JspException("Cannot call " + method + ": " + ex.getMessage()); |
| } |
| // check value type |
| if(!(value instanceof Boolean)) |
| throw new JspException("Return type of method " + method |
| + " must be java.lang.Boolean"); |
| return condition(((Boolean)value).booleanValue()); |
| } |
| protected abstract boolean condition(boolean value) |
| throws JspException; |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/taglib/NoRightsTag.java |
|---|
| 0,0 → 1,15 |
| package ak.hostadmiral.core.taglib; |
| import javax.servlet.jsp.JspException; |
| import org.apache.struts.util.RequestUtils; |
| public class NoRightsTag |
| extends MethodTagBase |
| { |
| protected boolean condition(boolean value) |
| throws JspException |
| { |
| return !value; |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/CoreResources.java |
|---|
| 0,0 → 1,36 |
| package ak.hostadmiral.core; |
| public abstract class CoreResources |
| { |
| public static final String LOGIN_FAILED = "ak.hostadmiral.core.login.failed"; |
| public static final String OLD_PASSWORD_WRONG = "ak.hostadmiral.core.oldpassword.wrong"; |
| public static final String PASSWORD_REQUIRED = "ak.hostadmiral.core.password.required"; |
| public static final String PASSWORDS_DONT_MATCH = "ak.hostadmiral.core.password.dontMatch"; |
| public static final String DELETE_ME_SELF = "ak.hostadmiral.core.user.deletemeself"; |
| public static final String NONUNIQUE_USER_LOGIN = "ak.hostadmiral.core.user.login.nonunique"; |
| public static final String NONUNIQUE_SYSTEM_USER_UID |
| = "ak.hostadmiral.core.user.system.uid.nonunique"; |
| public static final String NONUNIQUE_SYSTEM_USER_NAME |
| = "ak.hostadmiral.core.user.system.name.nonunique"; |
| public static final String NONUNIQUE_DOMAIN_NAME |
| = "ak.hostadmiral.core.domain.name.nonunique"; |
| public static final String TYPE_USER = "ak.hostadmiral.core.type.user"; |
| public static final String TYPE_SYSTEM_USER = "ak.hostadmiral.core.type.systemUser"; |
| public static final String TYPE_DOMAIN = "ak.hostadmiral.core.type.domain"; |
| public static final String TYPE_MAILBOX = "ak.hostadmiral.core.type.mailbox"; |
| public static final String TYPE_MAIL_ALIAS = "ak.hostadmiral.core.type.mailAlias"; |
| public static final String TYPE_MAIL_ALIAS_DESTINATION |
| = "ak.hostadmiral.core.type.mailAliasDestination"; |
| public static final String IDENT_USER = "ak.hostadmiral.core.ident.user"; |
| public static final String IDENT_SYSTEM_USER = "ak.hostadmiral.core.ident.systemUser"; |
| public static final String IDENT_DOMAIN = "ak.hostadmiral.core.ident.domain"; |
| public static final String IDENT_MAILBOX = "ak.hostadmiral.core.ident.mailbox"; |
| public static final String IDENT_MAIL_ALIAS = "ak.hostadmiral.core.ident.mailAlias"; |
| public static final String IDENT_MAIL_ALIAS_DESTINATION_EXTERNAL |
| = "ak.hostadmiral.core.ident.mailAliasDestination.external"; |
| public static final String IDENT_MAIL_ALIAS_DESTINATION_INTERNAL |
| = "ak.hostadmiral.core.ident.mailAliasDestination.internal"; |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/form/MailAliasDestBean.java |
|---|
| 0,0 → 1,77 |
| package ak.hostadmiral.core.form; |
| import ak.hostadmiral.util.StringConverter; |
| import ak.hostadmiral.core.model.MailAliasDestination; |
| public final class MailAliasDestBean |
| { |
| private String id; |
| private String mailbox; |
| private String email; |
| private Boolean enabled; |
| private String comment; |
| public MailAliasDestBean() |
| { |
| } |
| public MailAliasDestBean(MailAliasDestination dest) |
| { |
| this.id = StringConverter.toString(dest.getId()); |
| this.mailbox = (dest.getMailbox() == null) |
| ? null : StringConverter.toString(dest.getMailbox().getId()); |
| this.email = dest.getEmail(); |
| this.enabled = dest.getEnabled(); |
| this.comment = dest.getComment(); |
| } |
| public String getId() |
| { |
| return id; |
| } |
| public void setId(String id) |
| { |
| this.id = id; |
| } |
| public String getMailbox() |
| { |
| return mailbox; |
| } |
| public void setMailbox(String mailbox) |
| { |
| this.mailbox = mailbox; |
| } |
| public String getEmail() |
| { |
| return email; |
| } |
| public void setEmail(String email) |
| { |
| this.email = email; |
| } |
| public Boolean getEnabled() |
| { |
| return enabled; |
| } |
| public void setEnabled(Boolean enabled) |
| { |
| this.enabled = enabled; |
| } |
| public String getComment() |
| { |
| return comment; |
| } |
| public void setComment(String comment) |
| { |
| this.comment = comment; |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/form/UserPasswordForm.java |
|---|
| 0,0 → 1,30 |
| package ak.hostadmiral.core.form; |
| import javax.servlet.http.HttpServletRequest; |
| import org.apache.struts.action.ActionError; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.ActionMapping; |
| import ak.hostadmiral.core.CoreResources; |
| public final class UserPasswordForm |
| extends org.apache.struts.validator.DynaValidatorForm |
| { |
| public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) |
| { |
| ActionErrors errors = super.validate(mapping, request); |
| if(errors == null || errors.size() == 0) { // if no errors in simple checks |
| String password = (String)get("password"); |
| String password2 = (String)get("password2"); |
| if(!password.equals(password2)) { |
| if(errors == null) errors = new ActionErrors(); |
| errors.add("password", new ActionError(CoreResources.PASSWORDS_DONT_MATCH)); |
| } |
| } |
| return errors; |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/servlet/EncodingFilter.java |
|---|
| 0,0 → 1,37 |
| package ak.hostadmiral.core.servlet; |
| import java.io.IOException; |
| import javax.servlet.Filter; |
| import javax.servlet.FilterChain; |
| import javax.servlet.FilterConfig; |
| import javax.servlet.ServletException; |
| import javax.servlet.ServletRequest; |
| import javax.servlet.ServletResponse; |
| public class EncodingFilter |
| implements Filter |
| { |
| public static final String ENCODING = "UTF-8"; |
| private FilterConfig filterConfig; |
| public void init(FilterConfig filterConfig) |
| throws ServletException |
| { |
| this.filterConfig = filterConfig; |
| } |
| public void doFilter(ServletRequest request, ServletResponse response, |
| FilterChain chain) |
| throws IOException, ServletException |
| { |
| if(request.getCharacterEncoding() == null) |
| request.setCharacterEncoding(ENCODING); |
| chain.doFilter(request, response); |
| } |
| public void destroy() |
| { |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/servlet/LoginFilter.java |
|---|
| 0,0 → 1,169 |
| package ak.hostadmiral.core.servlet; |
| import java.util.List; |
| import java.util.ArrayList; |
| import java.util.StringTokenizer; |
| import java.io.IOException; |
| import java.net.URLEncoder; |
| import java.security.Principal; |
| import java.security.AccessControlException; |
| import javax.servlet.Filter; |
| import javax.servlet.FilterChain; |
| import javax.servlet.FilterConfig; |
| import javax.servlet.ServletException; |
| import javax.servlet.ServletRequest; |
| import javax.servlet.ServletResponse; |
| import javax.servlet.http.HttpSession; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.log4j.Logger; |
| import ak.backpath.BackPath; |
| import ak.hostadmiral.core.model.User; |
| /** |
| * Ensures that user is logged in to the system to process its request. |
| */ |
| public class LoginFilter |
| implements Filter |
| { |
| private static final Logger logger = Logger.getLogger(LoginFilter.class); |
| private FilterConfig filterConfig; |
| private String loginUrl; |
| private String loginServlet; |
| private List passUrls = new ArrayList(); |
| private List passMasks = new ArrayList(); |
| public void init(FilterConfig filterConfig) |
| throws ServletException |
| { |
| // get config |
| this.filterConfig = filterConfig; |
| if(filterConfig == null) |
| throw new ServletException("No configuration for the filter"); |
| // get login url |
| loginUrl = filterConfig.getInitParameter("loginUrl"); |
| if(loginUrl == null) |
| throw new ServletException("No login URL specified"); |
| // ensure it's absolute path |
| if(!loginUrl.startsWith("/")) |
| loginUrl = "/" + loginUrl; |
| // get servlet part ot the url |
| int qPos = loginUrl.indexOf("?"); |
| if(qPos < 0) |
| loginServlet = loginUrl; |
| else |
| loginServlet = loginUrl.substring(0, qPos); |
| // get pass through URLs |
| String passUrlsStr = filterConfig.getInitParameter("passUrls"); |
| if(passUrlsStr != null) { |
| String[] urls = passUrlsStr.split("\\s*;\\s*"); |
| for(int i = 0; i < urls.length; i++) { |
| if(urls[i].endsWith("*")) { |
| passMasks.add(urls[i].substring(0, urls[i].length()-1)); |
| } |
| else { |
| passUrls.add(urls[i]); |
| } |
| } |
| } |
| // avoid loop |
| if(!isPassThrough(loginServlet)) { |
| passUrls.add(loginServlet); |
| } |
| } |
| private boolean isPassThrough(String url) |
| { |
| for(int i = 0; i < passUrls.size(); i++) { |
| if(url.equals((String)passUrls.get(i))) return true; |
| } |
| for(int i = 0; i < passMasks.size(); i++) { |
| if(url.startsWith((String)passMasks.get(i))) return true; |
| } |
| return false; |
| } |
| public void doFilter(ServletRequest request, ServletResponse response, |
| FilterChain chain) |
| throws IOException, ServletException |
| { |
| boolean processNext; |
| if(!(request instanceof HttpServletRequest)) |
| throw new ServletException("Do not know how to handle non-HTTP requests"); |
| if(!(response instanceof HttpServletResponse)) |
| throw new ServletException("Do not know how to handle non-HTTP response"); |
| HttpServletRequest httpRequest = (HttpServletRequest)request; |
| HttpServletResponse httpResponse = (HttpServletResponse)response; |
| logger.debug("Requested " + httpRequest.getServletPath()); |
| if(isPassThrough(httpRequest.getServletPath())) { |
| processNext = true; |
| logger.debug("pass through"); |
| } |
| else { |
| try { |
| HttpSession session = httpRequest.getSession(false); |
| if(session == null) |
| throw new AccessControlException("No session"); |
| Object userObj = session.getAttribute("user"); |
| if(userObj == null) |
| throw new AccessControlException("No user"); |
| if(!(userObj instanceof User)) |
| throw new ServletException( |
| "Wrong type of user information: " + userObj.getClass().getName()); |
| processNext = true; |
| logger.debug("User found - OK"); |
| } |
| catch(AccessControlException ex) { |
| String origin = httpRequest.getRequestURI(); |
| String originParams = httpRequest.getQueryString(); |
| String redirectUrl; |
| try { |
| redirectUrl = httpRequest.getContextPath() + loginUrl |
| + BackPath.findBackPath(httpRequest).getForwardParams(); |
| } |
| catch(Exception ex2) { |
| logger.error("Cannot get forward redirect", ex2); |
| redirectUrl = httpRequest.getContextPath() + loginUrl; |
| } |
| logger.info("Redirect because of '" + ex.getMessage() + "' to " + redirectUrl); |
| httpResponse.sendRedirect(httpResponse.encodeRedirectURL(redirectUrl)); |
| processNext = false; |
| } |
| } |
| if(processNext) { // no problems found |
| chain.doFilter(request, response); |
| } |
| } |
| public void destroy() |
| { |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/servlet/HibernateFilter.java |
|---|
| 0,0 → 1,106 |
| package ak.hostadmiral.core.servlet; |
| import java.util.List; |
| import java.util.ArrayList; |
| import java.util.StringTokenizer; |
| import java.io.IOException; |
| import java.net.URLEncoder; |
| import java.security.Principal; |
| import java.security.AccessControlException; |
| import javax.servlet.Filter; |
| import javax.servlet.FilterChain; |
| import javax.servlet.FilterConfig; |
| import javax.servlet.ServletException; |
| import javax.servlet.ServletRequest; |
| import javax.servlet.ServletResponse; |
| import javax.servlet.http.HttpSession; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.log4j.Logger; |
| import net.sf.hibernate.HibernateException; |
| import ak.hostadmiral.util.HibernateUtil; |
| import ak.hostadmiral.util.ModelException; |
| public class HibernateFilter |
| implements Filter |
| { |
| private static final Logger logger = Logger.getLogger(HibernateFilter.class); |
| private FilterConfig filterConfig; |
| public void init(FilterConfig filterConfig) |
| throws ServletException |
| { |
| // get config |
| this.filterConfig = filterConfig; |
| if(filterConfig != null) { |
| // register hibernate classes |
| String toRegister = filterConfig.getInitParameter("register"); |
| if(toRegister != null) { |
| String[] registers = toRegister.split("\\s*;\\s*"); |
| for(int i = 0; i < registers.length; i++) { |
| try { |
| String name = registers[i].trim(); |
| if(name.equals("")) continue; |
| Class cl = Class.forName(name); |
| } |
| catch(Exception ex) { |
| logger.error("cannot register class", ex); |
| } |
| } |
| } |
| } |
| } |
| public void doFilter(ServletRequest request, ServletResponse response, |
| FilterChain chain) |
| throws IOException, ServletException |
| { |
| try { |
| logger.info("begin transaction"); |
| HibernateUtil.beginTransaction(); |
| chain.doFilter(request, response); |
| if(HibernateUtil.isTransactionOpen()) { |
| logger.info("commit transaction"); |
| HibernateUtil.commitTransaction(); |
| } |
| } |
| catch(Exception ex) { |
| logger.error("exception by program execution", ex); |
| try { |
| if(HibernateUtil.isTransactionOpen()) { |
| logger.info("rollback transaction"); |
| HibernateUtil.rollbackTransaction(); |
| } |
| } |
| catch(Exception ex2) { |
| logger.error("cannot rollback transaction", ex2); |
| } |
| if(ex instanceof ServletException) |
| throw (ServletException)ex; |
| else |
| throw new ServletException("Internal server error"); |
| } |
| try { |
| HibernateUtil.closeSession(); |
| } |
| catch(Exception ex) { |
| logger.error("cannot close session", ex); |
| } |
| } |
| public void destroy() |
| { |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/MailboxAction.java |
|---|
| 0,0 → 1,171 |
| package ak.hostadmiral.core.action; |
| import java.util.List; |
| import java.util.Collections; |
| import java.util.ArrayList; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.DynaActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.action.ActionMessages; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionError; |
| import ak.strutsx.RequestUtilsX; |
| import ak.strutsx.ErrorHandlerX; |
| import ak.backpath.BackPath; |
| import ak.hostadmiral.util.StringConverter; |
| import ak.hostadmiral.util.UserException; |
| import ak.hostadmiral.core.CoreResources; |
| import ak.hostadmiral.core.model.User; |
| import ak.hostadmiral.core.model.UserManager; |
| import ak.hostadmiral.core.model.Mailbox; |
| import ak.hostadmiral.core.model.MailboxManager; |
| import ak.hostadmiral.core.model.SystemUserManager; |
| import ak.hostadmiral.core.model.InetDomainManager; |
| public final class MailboxAction |
| extends Action |
| implements ErrorHandlerX |
| { |
| public void handleErrors(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| if("submit".equals(mapping.getParameter())) { |
| User user = (User)request.getSession().getAttribute("user"); |
| initLists(request, user); |
| } |
| } |
| public ActionForward execute(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| User user = (User)request.getSession().getAttribute("user"); |
| if("list".equals(mapping.getParameter())) { |
| List list = new ArrayList(MailboxManager.getInstance().listMailboxes(user)); |
| Collections.sort(list, MailboxManager.LOGIN_COMPARATOR); |
| request.setAttribute("mailboxes", list); |
| request.setAttribute("allowedToCreate", |
| new Boolean(MailboxManager.getInstance().allowedToCreate(user))); |
| return mapping.findForward("default"); |
| } |
| else if("edit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long boxId = StringConverter.parseLong(theForm.get("id")); |
| Mailbox mailbox; |
| DynaActionForm showForm = (DynaActionForm)RequestUtilsX.populateActionForm( |
| this, request, "ak.hostadmiral.core.form.MailboxEditForm"); |
| if(boxId == null) { |
| mailbox = MailboxManager.getInstance().create(user); |
| showForm.set("enabled", new Boolean(true)); |
| showForm.set("viruscheck", new Boolean(true)); |
| showForm.set("spamcheck", new Boolean(true)); |
| } |
| else { |
| mailbox = MailboxManager.getInstance().get(user, boxId); |
| showForm.set("login", mailbox.getLogin()); |
| if(mailbox.getDomain() != null) |
| showForm.set("domain", StringConverter.toString(mailbox.getDomain().getId())); |
| if(mailbox.getOwner() != null) |
| showForm.set("owner", StringConverter.toString(mailbox.getOwner().getId())); |
| showForm.set("viruscheck", mailbox.getVirusCheck()); |
| showForm.set("spamcheck", mailbox.getSpamCheck()); |
| if(mailbox.getSystemUser() != null) |
| showForm.set("systemuser", StringConverter.toString(mailbox.getSystemUser().getId())); |
| showForm.set("enabled", mailbox.getEnabled()); |
| showForm.set("comment", mailbox.getComment()); |
| } |
| initLists(request, user); |
| request.setAttribute("mailbox", mailbox); |
| if(mailbox.editableBy(user)) |
| return mapping.findForward("default"); |
| else |
| return mapping.findForward("view"); |
| } |
| else if("delete".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long boxId = StringConverter.parseLong(theForm.get("id")); |
| Mailbox mailbox = MailboxManager.getInstance().get(user, boxId); |
| MailboxManager.getInstance().delete(user, mailbox); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else if("submit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long boxId = StringConverter.parseLong(theForm.get("id")); |
| Mailbox mailbox; |
| String password = (String)theForm.get("password"); |
| if(boxId == null) { |
| if(password == null || password.equals("")) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException(CoreResources.PASSWORD_REQUIRED); |
| } |
| mailbox = MailboxManager.getInstance().create(user); |
| // FIXME: create an user as owner of the new mailbox here |
| } |
| else { |
| mailbox = MailboxManager.getInstance().get(user, boxId); |
| } |
| mailbox.setLogin(user, (String)theForm.get("login")); |
| mailbox.setDomain(user, InetDomainManager.getInstance().get(user, |
| StringConverter.parseLong(theForm.get("domain")))); |
| mailbox.setOwner(user, UserManager.getInstance().get(user, |
| StringConverter.parseLong(theForm.get("owner")))); |
| mailbox.setVirusCheck(user, (Boolean)theForm.get("viruscheck")); |
| mailbox.setSpamCheck(user, (Boolean)theForm.get("spamcheck")); |
| Long systemUserId = StringConverter.parseLong(theForm.get("systemuser")); |
| if(systemUserId == null) { |
| mailbox.setSystemUser(user, null); |
| } |
| else { |
| mailbox.setSystemUser(user, SystemUserManager.getInstance().get(user, systemUserId)); |
| } |
| if(password != null && !password.equals("")) |
| mailbox.setPassword(user, password); |
| mailbox.setEnabled(user, (Boolean)theForm.get("enabled")); |
| mailbox.setComment(user, (String)theForm.get("comment")); |
| MailboxManager.getInstance().save(user, mailbox); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else { |
| throw new Exception("unknown mapping parameter"); |
| } |
| } |
| private void initLists(HttpServletRequest request, User user) |
| throws Exception |
| { |
| List users = new ArrayList(UserManager.getInstance().listUsers(user)); |
| Collections.sort(users, UserManager.LOGIN_COMPARATOR); |
| request.setAttribute("users", users); |
| List systemUsers = new ArrayList(SystemUserManager.getInstance().listSystemUsers(user)); |
| Collections.sort(systemUsers, SystemUserManager.UID_COMPARATOR); |
| request.setAttribute("systemusers", systemUsers); |
| List domains = new ArrayList(InetDomainManager.getInstance().listInetDomains(user)); |
| Collections.sort(domains, InetDomainManager.NAME_COMPARATOR); |
| request.setAttribute("domains", domains); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/MailAliasAction.java |
|---|
| 0,0 → 1,283 |
| package ak.hostadmiral.core.action; |
| import java.util.List; |
| import java.util.Iterator; |
| import java.util.Collections; |
| import java.util.ArrayList; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.commons.beanutils.BeanUtils; |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.DynaActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.action.ActionMessages; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionError; |
| import ak.strutsx.RequestUtilsX; |
| import ak.strutsx.ErrorHandlerX; |
| import ak.backpath.BackPath; |
| import ak.hostadmiral.util.StringConverter; |
| import ak.hostadmiral.util.UserException; |
| import ak.hostadmiral.core.model.User; |
| import ak.hostadmiral.core.model.UserManager; |
| import ak.hostadmiral.core.model.Mailbox; |
| import ak.hostadmiral.core.model.MailboxManager; |
| import ak.hostadmiral.core.model.MailAlias; |
| import ak.hostadmiral.core.model.MailAliasManager; |
| import ak.hostadmiral.core.model.MailAliasDestination; |
| import ak.hostadmiral.core.model.MailAliasDestinationManager; |
| import ak.hostadmiral.core.model.InetDomainManager; |
| import ak.hostadmiral.core.form.MailAliasDestBean; |
| public final class MailAliasAction |
| extends Action |
| implements ErrorHandlerX |
| { |
| public void handleErrors(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| if("submit".equals(mapping.getParameter())) { |
| User user = (User)request.getSession().getAttribute("user"); |
| initLists(request, user); |
| } |
| } |
| public ActionForward execute(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| User user = (User)request.getSession().getAttribute("user"); |
| if("list".equals(mapping.getParameter())) { |
| List list = new ArrayList(MailAliasManager.getInstance().listMailAliases(user)); |
| Collections.sort(list, MailAliasManager.ADDRESS_COMPARATOR); |
| request.setAttribute("aliases", list); |
| request.setAttribute("allowedToCreate", |
| new Boolean(MailAliasManager.getInstance().allowedToCreate(user))); |
| return mapping.findForward("default"); |
| } |
| else if("edit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| MailAlias alias; |
| Long aliasId = StringConverter.parseLong(theForm.get("id")); |
| List dests; |
| DynaActionForm showForm = (DynaActionForm)RequestUtilsX.populateActionForm( |
| this, request, "ak.hostadmiral.core.form.MailAliasEditForm"); |
| if(aliasId == null) { |
| alias = MailAliasManager.getInstance().create(user); |
| dests = new ArrayList(); |
| showForm.set("enabled", new Boolean(true)); |
| } |
| else { |
| alias = MailAliasManager.getInstance().get(user, aliasId); |
| dests = new ArrayList(MailAliasDestinationManager.getInstance() |
| .listMailAliasesDestination(alias)); |
| MailAliasDestBean[] d = new MailAliasDestBean[dests.size()]; |
| // FIXME: sort dests here |
| for(int i = 0; i < dests.size(); i++) { |
| d[i] = new MailAliasDestBean((MailAliasDestination)dests.get(i)); |
| } |
| showForm.set("dests", d); |
| showForm.set("address", alias.getAddress()); |
| if(alias.getDomain() != null) |
| showForm.set("domain", StringConverter.toString(alias.getDomain().getId())); |
| if(alias.getOwner() != null) |
| showForm.set("owner", StringConverter.toString(alias.getOwner().getId())); |
| showForm.set("enabled", alias.getEnabled()); |
| showForm.set("comment", alias.getComment()); |
| } |
| initLists(request, user); |
| request.setAttribute("alias", alias); |
| request.setAttribute("dests", dests); |
| if(alias.editableBy(user)) |
| return mapping.findForward("default"); |
| else if(alias.mayChangeDestinations(user)) |
| return mapping.findForward("editdests"); |
| else |
| return mapping.findForward("view"); |
| } |
| else if("delete".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long aliasId = StringConverter.parseLong(theForm.get("id")); |
| MailAlias alias = MailAliasManager.getInstance().get(user, aliasId); |
| MailAliasManager.getInstance().delete(user, alias); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else if("submit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long aliasId = StringConverter.parseLong(theForm.get("id")); |
| MailAlias alias = (aliasId == null) |
| ? MailAliasManager.getInstance().create(user) |
| : MailAliasManager.getInstance().get(user, aliasId); |
| MailAliasDestBean[] dests = (MailAliasDestBean[])theForm.get("dests"); |
| // submit |
| if(request.getParameter("submit") != null) { |
| // FIXME: if empty element of select box is active, it will be changed |
| // by submit |
| // validate required fields, because it cannot be done in general case |
| if(StringConverter.isEmpty(theForm.get("address"))) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException("ak.hostadmiral.core.mail.alias.edit.address.empty"); |
| } |
| if(StringConverter.isEmpty(theForm.get("domain"))) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException("ak.hostadmiral.core.mail.alias.edit.domain.wrong"); |
| } |
| if(StringConverter.isEmpty(theForm.get("owner"))) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException("ak.hostadmiral.core.mail.alias.edit.owner.wrong"); |
| } |
| alias.getDestinations(user).clear(); |
| for(int i = 0; i < dests.length; i++) { |
| // FIXME: validate dest id, mailbox id, email |
| // skip empty rows |
| if((dests[i].getMailbox() == null) |
| && (dests[i].getEmail() == null || dests[i].getEmail().equals(""))) |
| continue; |
| // get bean |
| Long destId = StringConverter.parseLong(dests[i].getId()); |
| Long mailboxId = StringConverter.parseLong(dests[i].getMailbox()); |
| MailAliasDestination dest; |
| if(destId == null) |
| dest = MailAliasDestinationManager.getInstance().create(user); |
| else |
| dest = MailAliasDestinationManager.getInstance().get(user, destId); |
| // connect |
| dest.setAlias(user, alias); |
| alias.getDestinations(user).add(dest); |
| // set mailbox or email |
| if(mailboxId != null) { |
| dest.setMailbox(user, MailboxManager.getInstance().get(user, mailboxId)); |
| dest.setEmail(user, null); |
| } |
| else if(dests[i].getEmail() != null && !dests[i].getEmail().equals("")) { |
| dest.setMailbox(user, null); |
| dest.setEmail(user, dests[i].getEmail()); |
| } |
| dest.setEnabled(user, dests[i].getEnabled()); |
| dest.setComment(user, dests[i].getComment()); |
| } |
| alias.setAddress(user, (String)theForm.get("address")); |
| alias.setDomain(user, InetDomainManager.getInstance().get(user, |
| StringConverter.parseLong(theForm.get("domain")))); |
| alias.setOwner(user, UserManager.getInstance().get(user, |
| StringConverter.parseLong(theForm.get("owner")))); |
| alias.setEnabled(user, (Boolean)theForm.get("enabled")); |
| alias.setComment(user, (String)theForm.get("comment")); |
| // update alias |
| MailAliasManager.getInstance().save(user, alias); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| // add |
| else if(request.getParameter("add") != null) { |
| // FIXME: if called when no entries defined two rows are created |
| MailAliasDestBean[] newDests = new MailAliasDestBean[dests.length+1]; |
| if(dests.length > 0) |
| System.arraycopy(dests, 0, newDests, 0, dests.length); |
| newDests[dests.length] = new MailAliasDestBean(); |
| newDests[dests.length].setEnabled(new Boolean(true)); |
| theForm.set("dests", newDests); |
| initLists(request, user); |
| request.setAttribute("alias", alias); |
| request.setAttribute("dests", newDests); |
| if(alias.editableBy(user)) |
| return mapping.findForward("default"); |
| else if(alias.mayChangeDestinations(user)) |
| return mapping.findForward("editdests"); |
| else |
| return mapping.findForward("view"); |
| } |
| // delete |
| else { |
| Iterator iter = request.getParameterMap().keySet().iterator(); |
| while(iter.hasNext()) { |
| String name = (String)iter.next(); |
| if(name.startsWith("delete.dests[")) { |
| int p = name.indexOf("]"); |
| if(p > 0) { |
| String index = name.substring("delete.dests[".length(), p); |
| try { |
| int n = Integer.parseInt(index); |
| if(n < 0 || n >= dests.length) break; |
| MailAliasDestBean[] newDests; |
| newDests = new MailAliasDestBean[dests.length-1]; |
| if(n > 0) |
| System.arraycopy(dests, 0, newDests, 0, n); |
| if(n < dests.length-1) |
| System.arraycopy(dests, n+1, newDests, |
| n, dests.length-n-1); |
| theForm.set("dests", newDests); |
| request.setAttribute("dests", newDests); |
| break; |
| } |
| catch(NumberFormatException ex) { |
| } |
| } |
| } |
| } |
| initLists(request, user); |
| request.setAttribute("alias", alias); |
| if(alias.editableBy(user)) |
| return mapping.findForward("default"); |
| else if(alias.mayChangeDestinations(user)) |
| return mapping.findForward("editdests"); |
| else |
| return mapping.findForward("view"); |
| } |
| } |
| else { |
| throw new Exception("unknown mapping parameter"); |
| } |
| } |
| private void initLists(HttpServletRequest request, User user) |
| throws Exception |
| { |
| // list of mailboxes to redirect to |
| List mailboxes = new ArrayList(MailboxManager.getInstance().listMailboxes(user)); |
| Collections.sort(mailboxes, MailboxManager.LOGIN_COMPARATOR); |
| request.setAttribute("mailboxes", mailboxes); |
| List users = new ArrayList(UserManager.getInstance().listUsers(user)); |
| Collections.sort(users, UserManager.LOGIN_COMPARATOR); |
| request.setAttribute("users", users); |
| List domains = new ArrayList(InetDomainManager.getInstance().listInetDomains(user)); |
| Collections.sort(domains, InetDomainManager.NAME_COMPARATOR); |
| request.setAttribute("domains", domains); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/UserExceptionHandler.java |
|---|
| 0,0 → 1,62 |
| package ak.hostadmiral.core.action; |
| import javax.servlet.ServletException; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.struts.Globals; |
| import org.apache.struts.action.ActionError; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionMessages; |
| import org.apache.struts.action.ExceptionHandler; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.config.ExceptionConfig; |
| import org.apache.log4j.Logger; |
| import ak.strutsx.ErrorHandlerX; |
| import ak.hostadmiral.util.UserException; |
| import ak.hostadmiral.util.FormException; |
| public final class UserExceptionHandler |
| extends ExceptionHandler |
| { |
| private static final Logger logger = Logger.getLogger(UserExceptionHandler.class); |
| public ActionForward execute(Exception ex, ExceptionConfig config, |
| ActionMapping mapping, ActionForm formInstance, |
| HttpServletRequest request, HttpServletResponse response) |
| throws ServletException |
| { |
| if(!(ex instanceof UserException)) |
| throw new ServletException("Unknown type of exception: " + ex.getClass()); |
| UserException userEx = (UserException)ex; |
| logger.info("begin exception handle:" + userEx.getMessage()); |
| // try to get property for this exception if any |
| String property = ActionMessages.GLOBAL_MESSAGE; |
| if(userEx instanceof FormException) { |
| FormException formEx = (FormException)userEx; |
| if(formEx.getProperty() != null) |
| property = formEx.getProperty(); |
| } |
| // create new error message |
| ActionErrors errors = (ActionErrors)request.getAttribute(Globals.ERROR_KEY); |
| if(errors == null) { |
| errors = new ActionErrors(); |
| request.setAttribute(Globals.ERROR_KEY, errors); |
| } |
| errors.add(property, new ActionError(userEx.getMessage(), userEx.getValues())); |
| // find forward |
| if(mapping.getInput() == null) |
| return mapping.findForward("error"); |
| else |
| return mapping.getInputForward(); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/UserAction.java |
|---|
| 0,0 → 1,183 |
| package ak.hostadmiral.core.action; |
| import java.util.List; |
| import java.util.Collections; |
| import java.util.ArrayList; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.DynaActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.action.ActionMessages; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionError; |
| import ak.strutsx.RequestUtilsX; |
| import ak.strutsx.ErrorHandlerX; |
| import ak.backpath.BackPath; |
| import ak.hostadmiral.util.StringConverter; |
| import ak.hostadmiral.util.UserException; |
| import ak.hostadmiral.core.CoreResources; |
| import ak.hostadmiral.core.model.User; |
| import ak.hostadmiral.core.model.UserManager; |
| public final class UserAction |
| extends Action |
| implements ErrorHandlerX |
| { |
| public void handleErrors(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| if("submit".equals(mapping.getParameter())) { |
| User user = (User)request.getSession().getAttribute("user"); |
| initUserList(request, user); |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long userId; |
| User u; |
| try { |
| userId = StringConverter.parseLong(theForm.get("id")); |
| } |
| catch(NumberFormatException ex) { |
| userId = null; |
| } |
| if(userId == null) |
| u = UserManager.getInstance().create(user); |
| else |
| u = UserManager.getInstance().get(user, userId); |
| request.setAttribute("u", u); |
| } |
| } |
| public ActionForward execute(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| User user = (User)request.getSession().getAttribute("user"); |
| if("list".equals(mapping.getParameter())) { |
| List list = new ArrayList(UserManager.getInstance().listUsers(user)); |
| Collections.sort(list, UserManager.LOGIN_COMPARATOR); |
| request.setAttribute("users", list); |
| return mapping.findForward("default"); |
| } |
| else if("edit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long userId = StringConverter.parseLong(theForm.get("id")); |
| User u; |
| DynaActionForm showForm = (DynaActionForm)RequestUtilsX.populateActionForm( |
| this, request, "ak.hostadmiral.core.form.UserEditForm"); |
| if(userId == null) { |
| u = UserManager.getInstance().create(user); |
| showForm.set("enabled", new Boolean(true)); |
| } |
| else { |
| u = UserManager.getInstance().get(user, userId); |
| showForm.set("login", u.getLogin()); |
| if(u.getBoss() != null) |
| showForm.set("boss", StringConverter.toString(u.getBoss().getId())); |
| showForm.set("superuser", u.getSuperuser()); |
| showForm.set("enabled", u.getEnabled()); |
| showForm.set("comment", u.getComment()); |
| } |
| initUserList(request, user); |
| request.setAttribute("u", u); |
| if(u.editableBy(user)) |
| return mapping.findForward("default"); |
| else |
| return mapping.findForward("view"); |
| } |
| else if("delete".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long userId = StringConverter.parseLong(theForm.get("id")); |
| User u = UserManager.getInstance().get(user, userId); |
| request.setAttribute("u", u); |
| if(u.equals(user)) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException(CoreResources.DELETE_ME_SELF); |
| } |
| // FIXME: invalidate session of deleted user if it is logged in |
| // FIXME: if two admins delete each other at the same time |
| UserManager.getInstance().delete(user, u); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else if("submit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long userId = StringConverter.parseLong(theForm.get("id")); |
| User u; |
| String password = (String)theForm.get("password"); |
| if(userId == null) { |
| if(password == null || password.equals("")) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException(CoreResources.PASSWORD_REQUIRED); |
| } |
| u = UserManager.getInstance().create(user); |
| } |
| else { |
| u = UserManager.getInstance().get(user, userId); |
| } |
| request.setAttribute("u", u); |
| String login = (String)theForm.get("login"); |
| if(UserManager.getInstance().loginExists(user, u, login)) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException(CoreResources.NONUNIQUE_USER_LOGIN); |
| } |
| u.setLogin(user, login); |
| if(u.editableBy(user)) { |
| Long bossId = StringConverter.parseLong(theForm.get("boss")); |
| if(bossId == null) |
| u.setBoss(user, null); |
| else |
| u.setBoss(user, UserManager.getInstance().get(user, bossId)); |
| u.setEnabled(user, (Boolean)theForm.get("enabled")); |
| u.setComment(user, (String)theForm.get("comment")); |
| } |
| if(u.mayChangeSuperuser(user)) |
| u.setSuperuser(user, (Boolean)theForm.get("superuser")); |
| if(password != null && !password.equals("") |
| && u.editableBy(user) // more strong condition, because normal |
| && u.mayChangePassword(user)) // user have to enter first the old password |
| { |
| u.setPassword(user, password); |
| } |
| UserManager.getInstance().save(user, u); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else { |
| throw new Exception("unknown mapping parameter"); |
| } |
| } |
| private void initUserList(HttpServletRequest request, User user) |
| throws Exception |
| { |
| List list = new ArrayList(UserManager.getInstance().listUsers(user)); |
| Collections.sort(list, UserManager.LOGIN_COMPARATOR); |
| request.setAttribute("users", list); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/SystemUserAction.java |
|---|
| 0,0 → 1,148 |
| package ak.hostadmiral.core.action; |
| import java.util.List; |
| import java.util.Collections; |
| import java.util.ArrayList; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.DynaActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.action.ActionMessages; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionError; |
| import ak.strutsx.RequestUtilsX; |
| import ak.strutsx.ErrorHandlerX; |
| import ak.backpath.BackPath; |
| import ak.hostadmiral.util.StringConverter; |
| import ak.hostadmiral.util.UserException; |
| import ak.hostadmiral.core.CoreResources; |
| import ak.hostadmiral.core.model.User; |
| import ak.hostadmiral.core.model.UserManager; |
| import ak.hostadmiral.core.model.SystemUser; |
| import ak.hostadmiral.core.model.SystemUserManager; |
| public final class SystemUserAction |
| extends Action |
| implements ErrorHandlerX |
| { |
| public void handleErrors(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| if("submit".equals(mapping.getParameter())) { |
| User user = (User)request.getSession().getAttribute("user"); |
| initUserList(request, user); |
| } |
| } |
| public ActionForward execute(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| User user = (User)request.getSession().getAttribute("user"); |
| if("list".equals(mapping.getParameter())) { |
| List list = new ArrayList(SystemUserManager.getInstance().listSystemUsers(user)); |
| Collections.sort(list, SystemUserManager.NAME_COMPARATOR); |
| request.setAttribute("users", list); |
| request.setAttribute("allowedToCreate", |
| new Boolean(SystemUserManager.getInstance().allowedToCreate(user))); |
| return mapping.findForward("default"); |
| } |
| else if("edit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long userId = StringConverter.parseLong(theForm.get("id")); |
| SystemUser u; |
| DynaActionForm showForm = (DynaActionForm)RequestUtilsX.populateActionForm( |
| this, request, "ak.hostadmiral.core.form.SystemUserEditForm"); |
| if(userId == null) { |
| u = SystemUserManager.getInstance().create(user); |
| showForm.set("enabled", new Boolean(true)); |
| } |
| else { |
| u = SystemUserManager.getInstance().get(user, userId); |
| showForm.set("uid", StringConverter.toString(u.getUid())); |
| showForm.set("name", u.getName()); |
| if(u.getOwner() != null) |
| showForm.set("owner", StringConverter.toString(u.getOwner().getId())); |
| showForm.set("enabled", u.getEnabled()); |
| showForm.set("comment", u.getComment()); |
| } |
| initUserList(request, user); |
| request.setAttribute("u", u); |
| if(u.editableBy(user)) |
| return mapping.findForward("default"); |
| else |
| return mapping.findForward("view"); |
| } |
| else if("delete".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long userId = StringConverter.parseLong(theForm.get("id")); |
| SystemUser u = SystemUserManager.getInstance().get(user, userId); |
| SystemUserManager.getInstance().delete(user, u); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else if("submit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long userId = StringConverter.parseLong(theForm.get("id")); |
| SystemUser u; |
| if(userId == null) { |
| u = SystemUserManager.getInstance().create(user); |
| } |
| else { |
| u = SystemUserManager.getInstance().get(user, userId); |
| } |
| Integer uid = StringConverter.parseInteger(theForm.get("uid")); |
| if(SystemUserManager.getInstance().uidExists(user, u, uid)) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException(CoreResources.NONUNIQUE_SYSTEM_USER_UID); |
| } |
| u.setUid(user, uid); |
| String name = (String)theForm.get("name"); |
| if(SystemUserManager.getInstance().nameExists(user, u, name)) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException(CoreResources.NONUNIQUE_SYSTEM_USER_NAME); |
| } |
| u.setName(user, name); |
| Long ownerId = StringConverter.parseLong(theForm.get("owner")); |
| if(ownerId == null) |
| u.setOwner(user, null); |
| else |
| u.setOwner(user, UserManager.getInstance().get(user, ownerId)); |
| u.setEnabled(user, (Boolean)theForm.get("enabled")); |
| u.setComment(user, (String)theForm.get("comment")); |
| SystemUserManager.getInstance().save(user, u); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else { |
| throw new Exception("unknown mapping parameter"); |
| } |
| } |
| private void initUserList(HttpServletRequest request, User user) |
| throws Exception |
| { |
| List list = new ArrayList(UserManager.getInstance().listUsers(user)); |
| Collections.sort(list, UserManager.LOGIN_COMPARATOR); |
| request.setAttribute("users", list); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/IndexAction.java |
|---|
| 0,0 → 1,37 |
| package ak.hostadmiral.core.action; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.ActionForward; |
| import ak.hostadmiral.core.model.User; |
| import ak.hostadmiral.core.model.SystemUserManager; |
| import ak.hostadmiral.core.model.InetDomainManager; |
| import ak.hostadmiral.core.model.MailboxManager; |
| import ak.hostadmiral.core.model.MailAliasManager; |
| public final class IndexAction |
| extends Action |
| { |
| public ActionForward execute(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| User user = (User)request.getSession().getAttribute("user"); |
| request.setAttribute("showSystemUsers", |
| new Boolean(SystemUserManager.getInstance().areSystemUsersAvailable(user))); |
| request.setAttribute("showInetDomains", |
| new Boolean(InetDomainManager.getInstance().areInetDomainsAvailable(user))); |
| request.setAttribute("showMailboxes", |
| new Boolean(MailboxManager.getInstance().areMailboxesAvailable(user))); |
| request.setAttribute("showMailAliases", |
| new Boolean(MailAliasManager.getInstance().areMailAliasesAvailable(user))); |
| return mapping.findForward("success"); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/InetDomainAction.java |
|---|
| 0,0 → 1,137 |
| package ak.hostadmiral.core.action; |
| import java.util.List; |
| import java.util.Collections; |
| import java.util.ArrayList; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.DynaActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.action.ActionMessages; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionError; |
| import ak.strutsx.RequestUtilsX; |
| import ak.strutsx.ErrorHandlerX; |
| import ak.backpath.BackPath; |
| import ak.hostadmiral.util.StringConverter; |
| import ak.hostadmiral.util.UserException; |
| import ak.hostadmiral.core.CoreResources; |
| import ak.hostadmiral.core.model.User; |
| import ak.hostadmiral.core.model.UserManager; |
| import ak.hostadmiral.core.model.InetDomain; |
| import ak.hostadmiral.core.model.InetDomainManager; |
| public final class InetDomainAction |
| extends Action |
| implements ErrorHandlerX |
| { |
| public void handleErrors(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| if("submit".equals(mapping.getParameter())) { |
| User user = (User)request.getSession().getAttribute("user"); |
| initUserList(request, user); |
| } |
| } |
| public ActionForward execute(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| User user = (User)request.getSession().getAttribute("user"); |
| if("list".equals(mapping.getParameter())) { |
| List list = new ArrayList(InetDomainManager.getInstance().listInetDomains(user)); |
| Collections.sort(list, InetDomainManager.NAME_COMPARATOR); |
| request.setAttribute("domains", list); |
| request.setAttribute("allowedToCreate", |
| new Boolean(InetDomainManager.getInstance().allowedToCreate(user))); |
| return mapping.findForward("default"); |
| } |
| else if("edit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long domainId = StringConverter.parseLong(theForm.get("id")); |
| InetDomain domain; |
| DynaActionForm showForm = (DynaActionForm)RequestUtilsX.populateActionForm( |
| this, request, "ak.hostadmiral.core.form.InetDomainEditForm"); |
| if(domainId == null) { |
| domain = InetDomainManager.getInstance().create(user); |
| showForm.set("enabled", new Boolean(true)); |
| } |
| else { |
| domain = InetDomainManager.getInstance().get(user, domainId); |
| showForm.set("name", domain.getName()); |
| if(domain.getOwner() != null) |
| showForm.set("owner", StringConverter.toString(domain.getOwner().getId())); |
| showForm.set("enabled", domain.getEnabled()); |
| showForm.set("comment", domain.getComment()); |
| } |
| initUserList(request, user); |
| request.setAttribute("domain", domain); |
| if(domain.editableBy(user)) |
| return mapping.findForward("default"); |
| else |
| return mapping.findForward("view"); |
| } |
| else if("delete".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long domainId = StringConverter.parseLong(theForm.get("id")); |
| InetDomain domain = InetDomainManager.getInstance().get(user, domainId); |
| InetDomainManager.getInstance().delete(user, domain); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else if("submit".equals(mapping.getParameter())) { |
| DynaActionForm theForm = (DynaActionForm)form; |
| Long domainId = StringConverter.parseLong(theForm.get("id")); |
| InetDomain domain; |
| if(domainId == null) { |
| domain = InetDomainManager.getInstance().create(user); |
| } |
| else { |
| domain = InetDomainManager.getInstance().get(user, domainId); |
| } |
| String name = (String)theForm.get("name"); |
| if(InetDomainManager.getInstance().nameExists(user, domain, name)) { |
| handleErrors(mapping, form, request, response); |
| throw new UserException(CoreResources.NONUNIQUE_DOMAIN_NAME); |
| } |
| domain.setName(user, name); |
| domain.setOwner(user, UserManager.getInstance().get(user, |
| StringConverter.parseLong(theForm.get("owner")))); |
| domain.setEnabled(user, (Boolean)theForm.get("enabled")); |
| domain.setComment(user, (String)theForm.get("comment")); |
| InetDomainManager.getInstance().save(user, domain); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else { |
| throw new Exception("unknown mapping parameter"); |
| } |
| } |
| private void initUserList(HttpServletRequest request, User user) |
| throws Exception |
| { |
| List list = new ArrayList(UserManager.getInstance().listUsers(user)); |
| Collections.sort(list, UserManager.LOGIN_COMPARATOR); |
| request.setAttribute("users", list); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/ChangePasswordAction.java |
|---|
| 0,0 → 1,51 |
| package ak.hostadmiral.core.action; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.DynaActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.action.ActionMessages; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionError; |
| import ak.backpath.BackPath; |
| import ak.hostadmiral.core.CoreResources; |
| import ak.hostadmiral.core.model.User; |
| import ak.hostadmiral.core.model.UserManager; |
| public final class ChangePasswordAction |
| extends Action |
| { |
| public ActionForward execute(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| if("first".equals(mapping.getParameter())) { |
| return mapping.findForward("default"); |
| } |
| else { |
| DynaActionForm theForm = (DynaActionForm)form; |
| User user = (User)request.getSession().getAttribute("user"); |
| if(user.checkPassword((String)theForm.get("oldpassword"))) { |
| user.setPassword(user, (String)theForm.get("password")); |
| UserManager.getInstance().save(user, user); |
| response.sendRedirect(BackPath.findBackPath(request).getBackwardUrl()); |
| return null; |
| } |
| else { |
| ActionErrors errors = new ActionErrors(); |
| errors.add(ActionMessages.GLOBAL_MESSAGE, |
| new ActionError(CoreResources.OLD_PASSWORD_WRONG)); |
| saveErrors(request, errors); |
| return mapping.getInputForward(); |
| } |
| } |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/LoginAction.java |
|---|
| 0,0 → 1,53 |
| package ak.hostadmiral.core.action; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.DynaActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.action.ActionMessages; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionError; |
| import ak.backpath.BackPath; |
| import ak.hostadmiral.core.CoreResources; |
| import ak.hostadmiral.core.model.User; |
| import ak.hostadmiral.core.model.UserManager; |
| public final class LoginAction |
| extends Action |
| { |
| public ActionForward execute(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| DynaActionForm theForm = (DynaActionForm)form; |
| User user = UserManager.getInstance().loginUser( |
| (String)theForm.get("login"), (String)theForm.get("password")); |
| if(user == null) { |
| ActionErrors errors = new ActionErrors(); |
| errors.add(ActionMessages.GLOBAL_MESSAGE, |
| new ActionError(CoreResources.LOGIN_FAILED)); |
| saveErrors(request, errors); |
| return mapping.getInputForward(); |
| } |
| else { |
| request.getSession().setAttribute("user", user); |
| String origin = BackPath.findBackPath(request).getBackwardUrl(); |
| if(origin == null || origin.length() <= 0) { |
| return mapping.findForward("default"); |
| } |
| else { |
| response.sendRedirect(origin); |
| return null; |
| } |
| } |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/core/action/LogoutAction.java |
|---|
| 0,0 → 1,27 |
| package ak.hostadmiral.core.action; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.DynaActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.action.ActionMessages; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionError; |
| public final class LogoutAction |
| extends Action |
| { |
| public ActionForward execute(ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws Exception |
| { |
| if(request.getSession() != null) |
| request.getSession().invalidate(); |
| return mapping.findForward("default"); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/util/ModelSecurityException.java |
|---|
| 0,0 → 1,10 |
| package ak.hostadmiral.util; |
| public class ModelSecurityException |
| extends ModelException |
| { |
| public ModelSecurityException() |
| { |
| super("ak.hostadmiral.core.access.denied"); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/util/UserException.java |
|---|
| 0,0 → 1,28 |
| package ak.hostadmiral.util; |
| public class UserException |
| extends Exception |
| { |
| private Object[] values; |
| public UserException() |
| { |
| this(null, null); |
| } |
| public UserException(String message) |
| { |
| this(message, null); |
| } |
| public UserException(String message, Object[] values) |
| { |
| super(message); |
| this.values = values; |
| } |
| public Object[] getValues() |
| { |
| return values; |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/util/StringConverter.java |
|---|
| 0,0 → 1,52 |
| package ak.hostadmiral.util; |
| public abstract class StringConverter |
| { |
| public static boolean isEmpty(Object o) |
| { |
| if(o == null) |
| return true; |
| else if((o instanceof String) && ((String)o).equals("")) |
| return true; |
| else |
| return false; |
| } |
| public static Long parseLong(Object o) |
| throws NumberFormatException |
| { |
| if(o instanceof String) { |
| String s = (String)o; |
| if(s == null || s.equals("")) |
| return null; |
| else |
| return new Long(s); |
| } |
| else { |
| throw new ClassCastException("String is expected, but it is " + o.getClass()); |
| } |
| } |
| public static Integer parseInteger(Object o) |
| throws NumberFormatException |
| { |
| if(o instanceof String) { |
| String s = (String)o; |
| if(s == null || s.equals("")) |
| return null; |
| else |
| return new Integer(s); |
| } |
| else { |
| throw new ClassCastException("String is expected, but it is " + o.getClass()); |
| } |
| } |
| public static String toString(Object o) |
| { |
| if(o == null) |
| return null; |
| else |
| return o.toString(); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/util/Digest.java |
|---|
| 0,0 → 1,51 |
| package ak.hostadmiral.util; |
| import java.security.MessageDigest; |
| import java.security.NoSuchAlgorithmException; |
| public class Digest |
| { |
| /** |
| * digest to encode passwords |
| */ |
| protected static MessageDigest digest = null; |
| private static final char[] hexDigits = { |
| '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' |
| }; |
| public static String encode(String password) |
| { |
| return bytesToHex(digest.digest(password.getBytes())); |
| } |
| /** |
| * converts password bytes to hex string |
| */ |
| protected static String bytesToHex(byte[] bytes) |
| { |
| char[] buffer = new char[bytes.length * 2]; |
| for (int i = 0; i < bytes.length; i++) { |
| int low = (int)( bytes[i] & 0x0f); |
| int high = (int)((bytes[i] & 0xf0) >> 4); |
| buffer[i * 2] = hexDigits[high]; |
| buffer[i * 2 + 1] = hexDigits[low]; |
| } |
| return new String(buffer); |
| } |
| /** |
| * digest initialization |
| */ |
| static { |
| try { |
| digest = MessageDigest.getInstance("MD5"); |
| } |
| catch(NoSuchAlgorithmException ex) { |
| ex.printStackTrace(); |
| } |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/util/HibernateUtil.java |
|---|
| 0,0 → 1,109 |
| package ak.hostadmiral.util; |
| import net.sf.hibernate.*; |
| import net.sf.hibernate.cfg.*; |
| public class HibernateUtil |
| { |
| private static Configuration configuration; |
| private static SessionFactory sessionFactory; |
| private static final ThreadLocal hibernateBean = new ThreadLocal(); |
| public static Configuration getConfiguration() |
| throws HibernateException |
| { |
| if(configuration == null) |
| configuration = new Configuration(); |
| return configuration; |
| } |
| public static SessionFactory getSessionFactory() |
| throws HibernateException |
| { |
| if(sessionFactory == null) |
| sessionFactory = getConfiguration().configure().buildSessionFactory(); |
| return sessionFactory; |
| } |
| private static HibernateBean currentBean() |
| throws HibernateException |
| { |
| HibernateBean hb = (HibernateBean)hibernateBean.get(); |
| if(hb == null) { |
| hb = new HibernateBean(); |
| hb.session = getSessionFactory().openSession(); |
| hibernateBean.set(hb); |
| } |
| return hb; |
| } |
| public static Session currentSession() |
| throws HibernateException |
| { |
| return currentBean().session; |
| } |
| public static void closeSession() |
| throws HibernateException, ModelException |
| { |
| HibernateBean hb = (HibernateBean)hibernateBean.get(); |
| if(hb == null) |
| throw new ModelException("No session found for this thread"); |
| hibernateBean.set(null); |
| hb.session.close(); |
| } |
| public static void beginTransaction() |
| throws HibernateException, ModelException |
| { |
| HibernateBean hb = (HibernateBean)hibernateBean.get(); |
| if(hb != null && hb.transaction != null) |
| throw new ModelException("Transaction is already open"); |
| currentBean().transaction = currentSession().beginTransaction(); |
| } |
| public static boolean isTransactionOpen() |
| throws HibernateException, ModelException |
| { |
| HibernateBean hb = (HibernateBean)hibernateBean.get(); |
| return (hb != null) && (hb.transaction != null); |
| } |
| public static void commitTransaction() |
| throws HibernateException, ModelException |
| { |
| HibernateBean hb = (HibernateBean)hibernateBean.get(); |
| if(hb == null || hb.transaction == null) |
| throw new ModelException("No open transaction"); |
| hb.transaction.commit(); |
| hb.transaction = null; |
| } |
| public static void rollbackTransaction() |
| throws HibernateException, ModelException |
| { |
| HibernateBean hb = (HibernateBean)hibernateBean.get(); |
| if(hb == null || hb.transaction == null) |
| throw new ModelException("No open transaction"); |
| hb.transaction.rollback(); |
| hb.transaction = null; |
| } |
| static class HibernateBean |
| { |
| public Session session; |
| public Transaction transaction; |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/util/ModelException.java |
|---|
| 0,0 → 1,44 |
| package ak.hostadmiral.util; |
| public class ModelException |
| extends Exception |
| { |
| private Exception chainedException; |
| public ModelException() |
| { |
| this(null, null); |
| } |
| public ModelException(String message) |
| { |
| this(message, null); |
| } |
| public ModelException(Exception chainedException) |
| { |
| this(null, chainedException); |
| } |
| public ModelException(String message, Exception chainedException) |
| { |
| super(message); |
| this.chainedException = chainedException; |
| } |
| public Exception getChainedException() |
| { |
| return chainedException; |
| } |
| public void setChainedException(Exception chainedException) |
| { |
| this.chainedException = chainedException; |
| } |
| public String toString() |
| { |
| return super.toString() |
| + (chainedException == null ? "" : "\n" + chainedException.toString()); |
| } |
| } |
| /sun/hostcaptain/trunk/src/ak/hostadmiral/util/FormException.java |
|---|
| 0,0 → 1,39 |
| package ak.hostadmiral.util; |
| public class FormException |
| extends UserException |
| { |
| private String property; |
| public FormException() |
| { |
| this(null, null, null); |
| } |
| public FormException(String message) |
| { |
| this(message, null, null); |
| } |
| public FormException(String message, String property) |
| { |
| this(message, property, null); |
| } |
| public FormException(String message, String property, Object[] values) |
| { |
| super(message, values); |
| this.property = property; |
| } |
| public String getProperty() |
| { |
| return property; |
| } |
| public String toString() |
| { |
| return super.toString() |
| + (property == null ? "" : " for " + property); |
| } |
| } |