legacy/argeo-commons/org.argeo.cms.ui.workbench/src/org/argeo/cms/ui/workbench/internal/useradmin/commands/NewUser.java

   1 package org.argeo.cms.ui.workbench.internal.useradmin.commands;
   2
   3 import java.util.Dictionary;
   4 import java.util.List;
   5 import java.util.Map;
   6
   7 import javax.naming.InvalidNameException;
   8 import javax.naming.ldap.LdapName;
   9 import javax.naming.ldap.Rdn;
  10
  11 import org.argeo.cms.ArgeoNames;
  12 import org.argeo.cms.CmsException;
  13 import org.argeo.cms.ui.workbench.WorkbenchUiPlugin;
  14 import org.argeo.cms.ui.workbench.internal.useradmin.UiAdminUtils;
  15 import org.argeo.cms.ui.workbench.internal.useradmin.UserAdminWrapper;
  16 import org.argeo.cms.auth.UserAdminUtils;
  17 import org.argeo.eclipse.ui.EclipseUiUtils;
  18 import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
  19 import org.argeo.osgi.useradmin.UserAdminConf;
  20 import org.argeo.util.naming.LdapAttrs;
  21 import org.eclipse.core.commands.AbstractHandler;
  22 import org.eclipse.core.commands.ExecutionEvent;
  23 import org.eclipse.core.commands.ExecutionException;
  24 import org.eclipse.jface.wizard.Wizard;
  25 import org.eclipse.jface.wizard.WizardDialog;
  26 import org.eclipse.jface.wizard.WizardPage;
  27 import org.eclipse.swt.SWT;
  28 import org.eclipse.swt.events.ModifyEvent;
  29 import org.eclipse.swt.events.ModifyListener;
  30 import org.eclipse.swt.layout.GridData;
  31 import org.eclipse.swt.layout.GridLayout;
  32 import org.eclipse.swt.widgets.Combo;
  33 import org.eclipse.swt.widgets.Composite;
  34 import org.eclipse.swt.widgets.Label;
  35 import org.eclipse.swt.widgets.Text;
  36 import org.eclipse.ui.handlers.HandlerUtil;
  37 import org.osgi.service.useradmin.Role;
  38 import org.osgi.service.useradmin.User;
  39 import org.osgi.service.useradmin.UserAdminEvent;
  40
  41 /** Open a wizard that enables creation of a new user. */
  42 public class NewUser extends AbstractHandler {
  43         // private final static CmsLog log = CmsLog.getLog(NewUser.class);
  44         public final static String ID = WorkbenchUiPlugin.PLUGIN_ID + ".newUser";
  45
  46         /* DEPENDENCY INJECTION */
  47         private UserAdminWrapper userAdminWrapper;
  48
  49         public Object execute(ExecutionEvent event) throws ExecutionException {
  50                 NewUserWizard newUserWizard = new NewUserWizard();
  51                 newUserWizard.setWindowTitle("User creation");
  52                 WizardDialog dialog = new WizardDialog(
  53                                 HandlerUtil.getActiveShell(event), newUserWizard);
  54                 dialog.open();
  55                 return null;
  56         }
  57
  58         private class NewUserWizard extends Wizard {
  59
  60                 // pages
  61                 private MainUserInfoWizardPage mainUserInfo;
  62
  63                 // End user fields
  64                 private Text dNameTxt, usernameTxt, firstNameTxt, lastNameTxt,
  65                                 primaryMailTxt, pwd1Txt, pwd2Txt;
  66                 private Combo baseDnCmb;
  67
  68                 public NewUserWizard() {
  69
  70                 }
  71
  72                 @Override
  73                 public void addPages() {
  74                         mainUserInfo = new MainUserInfoWizardPage();
  75                         addPage(mainUserInfo);
  76                         String message = "Default wizard that also eases user creation tests:\n "
  77                                         + "Mail and last name are automatically "
  78                                         + "generated form the uid. Password are defauted to 'demo'.";
  79                         mainUserInfo.setMessage(message, WizardPage.WARNING);
  80                 }
  81
  82                 @SuppressWarnings({ "rawtypes", "unchecked" })
  83                 @Override
  84                 public boolean performFinish() {
  85                         if (!canFinish())
  86                                 return false;
  87                         String username = mainUserInfo.getUsername();
  88                         userAdminWrapper.beginTransactionIfNeeded();
  89                         try {
  90                                 User user = (User) userAdminWrapper.getUserAdmin().createRole(
  91                                                 getDn(username), Role.USER);
  92
  93                                 Dictionary props = user.getProperties();
  94
  95                                 String lastNameStr = lastNameTxt.getText();
  96                                 if (EclipseUiUtils.notEmpty(lastNameStr))
  97                                         props.put(LdapAttrs.sn.name(), lastNameStr);
  98
  99                                 String firstNameStr = firstNameTxt.getText();
 100                                 if (EclipseUiUtils.notEmpty(firstNameStr))
 101                                         props.put(LdapAttrs.givenName.name(), firstNameStr);
 102
 103                                 String cn = UserAdminUtils.buildDefaultCn(firstNameStr,
 104                                                 lastNameStr);
 105                                 if (EclipseUiUtils.notEmpty(cn))
 106                                         props.put(LdapAttrs.cn.name(), cn);
 107
 108                                 String mailStr = primaryMailTxt.getText();
 109                                 if (EclipseUiUtils.notEmpty(mailStr))
 110                                         props.put(LdapAttrs.mail.name(), mailStr);
 111
 112                                 char[] password = mainUserInfo.getPassword();
 113                                 user.getCredentials().put(null, password);
 114                                 userAdminWrapper.commitOrNotifyTransactionStateChange();
 115                                 userAdminWrapper.notifyListeners(new UserAdminEvent(null,
 116                                                 UserAdminEvent.ROLE_CREATED, user));
 117                                 return true;
 118                         } catch (Exception e) {
 119                                 ErrorFeedback.show("Cannot create new user " + username, e);
 120                                 return false;
 121                         }
 122                 }
 123
 124                 private class MainUserInfoWizardPage extends WizardPage implements
 125                                 ModifyListener, ArgeoNames {
 126                         private static final long serialVersionUID = -3150193365151601807L;
 127
 128                         public MainUserInfoWizardPage() {
 129                                 super("Main");
 130                                 setTitle("Required Information");
 131                         }
 132
 133                         @Override
 134                         public void createControl(Composite parent) {
 135                                 Composite composite = new Composite(parent, SWT.NONE);
 136                                 composite.setLayout(new GridLayout(2, false));
 137                                 dNameTxt = EclipseUiUtils.createGridLT(composite,
 138                                                 "Distinguished name", this);
 139                                 dNameTxt.setEnabled(false);
 140
 141                                 baseDnCmb = createGridLC(composite, "Base DN");
 142                                 initialiseDnCmb(baseDnCmb);
 143                                 baseDnCmb.addModifyListener(this);
 144                                 baseDnCmb.addModifyListener(new ModifyListener() {
 145                                         private static final long serialVersionUID = -1435351236582736843L;
 146
 147                                         @Override
 148                                         public void modifyText(ModifyEvent event) {
 149                                                 String name = usernameTxt.getText();
 150                                                 dNameTxt.setText(getDn(name));
 151                                         }
 152                                 });
 153
 154                                 usernameTxt = EclipseUiUtils.createGridLT(composite,
 155                                                 "Local ID", this);
 156                                 usernameTxt.addModifyListener(new ModifyListener() {
 157                                         private static final long serialVersionUID = -1435351236582736843L;
 158
 159                                         @Override
 160                                         public void modifyText(ModifyEvent event) {
 161                                                 String name = usernameTxt.getText();
 162                                                 if (name.trim().equals("")) {
 163                                                         dNameTxt.setText("");
 164                                                         lastNameTxt.setText("");
 165                                                         primaryMailTxt.setText("");
 166                                                         pwd1Txt.setText("");
 167                                                         pwd2Txt.setText("");
 168                                                 } else {
 169                                                         dNameTxt.setText(getDn(name));
 170                                                         lastNameTxt.setText(name.toUpperCase());
 171                                                         primaryMailTxt.setText(getMail(name));
 172                                                         pwd1Txt.setText("demo");
 173                                                         pwd2Txt.setText("demo");
 174                                                 }
 175                                         }
 176                                 });
 177
 178                                 primaryMailTxt = EclipseUiUtils.createGridLT(composite,
 179                                                 "Email", this);
 180                                 firstNameTxt = EclipseUiUtils.createGridLT(composite,
 181                                                 "First name", this);
 182                                 lastNameTxt = EclipseUiUtils.createGridLT(composite,
 183                                                 "Last name", this);
 184                                 pwd1Txt = EclipseUiUtils.createGridLP(composite, "Password",
 185                                                 this);
 186                                 pwd2Txt = EclipseUiUtils.createGridLP(composite,
 187                                                 "Repeat password", this);
 188                                 setControl(composite);
 189
 190                                 // Initialize buttons
 191                                 setPageComplete(false);
 192                                 getContainer().updateButtons();
 193                         }
 194
 195                         @Override
 196                         public void modifyText(ModifyEvent event) {
 197                                 String message = checkComplete();
 198                                 if (message != null) {
 199                                         setMessage(message, WizardPage.ERROR);
 200                                         setPageComplete(false);
 201                                 } else {
 202                                         setMessage("Complete", WizardPage.INFORMATION);
 203                                         setPageComplete(true);
 204                                 }
 205                                 getContainer().updateButtons();
 206                         }
 207
 208                         /** @return error message or null if complete */
 209                         protected String checkComplete() {
 210                                 String name = usernameTxt.getText();
 211
 212                                 if (name.trim().equals(""))
 213                                         return "User name must not be empty";
 214                                 Role role = userAdminWrapper.getUserAdmin()
 215                                                 .getRole(getDn(name));
 216                                 if (role != null)
 217                                         return "User " + name + " already exists";
 218                                 if (!primaryMailTxt.getText().matches(UiAdminUtils.EMAIL_PATTERN))
 219                                         return "Not a valid email address";
 220                                 if (lastNameTxt.getText().trim().equals(""))
 221                                         return "Specify a last name";
 222                                 if (pwd1Txt.getText().trim().equals(""))
 223                                         return "Specify a password";
 224                                 if (pwd2Txt.getText().trim().equals(""))
 225                                         return "Repeat the password";
 226                                 if (!pwd2Txt.getText().equals(pwd1Txt.getText()))
 227                                         return "Passwords are different";
 228                                 return null;
 229                         }
 230
 231                         @Override
 232                         public void setVisible(boolean visible) {
 233                                 super.setVisible(visible);
 234                                 if (visible)
 235                                         if (baseDnCmb.getSelectionIndex() == -1)
 236                                                 baseDnCmb.setFocus();
 237                                         else
 238                                                 usernameTxt.setFocus();
 239                         }
 240
 241                         public String getUsername() {
 242                                 return usernameTxt.getText();
 243                         }
 244
 245                         public char[] getPassword() {
 246                                 return pwd1Txt.getTextChars();
 247                         }
 248
 249                 }
 250
 251                 private Map<String, String> getDns() {
 252                         return userAdminWrapper.getKnownBaseDns(true);
 253                 }
 254
 255                 private String getDn(String uid) {
 256                         Map<String, String> dns = getDns();
 257                         String bdn = baseDnCmb.getText();
 258                         if (EclipseUiUtils.notEmpty(bdn)) {
 259                                 Dictionary<String, ?> props = UserAdminConf.uriAsProperties(dns
 260                                                 .get(bdn));
 261                                 String dn = LdapAttrs.uid.name() + "=" + uid + ","
 262                                                 + UserAdminConf.userBase.getValue(props) + "," + bdn;
 263                                 return dn;
 264                         }
 265                         return null;
 266                 }
 267
 268                 private void initialiseDnCmb(Combo combo) {
 269                         Map<String, String> dns = userAdminWrapper.getKnownBaseDns(true);
 270                         if (dns.isEmpty())
 271                                 throw new CmsException(
 272                                                 "No writable base dn found. Cannot create user");
 273                         combo.setItems(dns.keySet().toArray(new String[0]));
 274                         if (dns.size() == 1)
 275                                 combo.select(0);
 276                 }
 277
 278                 private String getMail(String username) {
 279                         if (baseDnCmb.getSelectionIndex() == -1)
 280                                 return null;
 281                         String baseDn = baseDnCmb.getText();
 282                         try {
 283                                 LdapName name = new LdapName(baseDn);
 284                                 List<Rdn> rdns = name.getRdns();
 285                                 return username + "@" + (String) rdns.get(1).getValue() + '.'
 286                                                 + (String) rdns.get(0).getValue();
 287                         } catch (InvalidNameException e) {
 288                                 throw new CmsException("Unable to generate mail for "
 289                                                 + username + " with base dn " + baseDn, e);
 290                         }
 291                 }
 292         }
 293
 294         private Combo createGridLC(Composite parent, String label) {
 295                 Label lbl = new Label(parent, SWT.LEAD);
 296                 lbl.setText(label);
 297                 lbl.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false));
 298                 Combo combo = new Combo(parent, SWT.LEAD | SWT.BORDER | SWT.READ_ONLY);
 299                 combo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
 300                 return combo;
 301         }
 302
 303         /* DEPENDENCY INJECTION */
 304         public void setUserAdminWrapper(UserAdminWrapper userAdminWrapper) {
 305                 this.userAdminWrapper = userAdminWrapper;
 306         }
 307 }