org.argeo.cms/src/org/argeo/cms/acr/directory/DirectoryContentProvider.java

   1 package org.argeo.cms.acr.directory;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collections;
   5 import java.util.Iterator;
   6 import java.util.List;
   7
   8 import javax.xml.namespace.QName;
   9
  10 import org.argeo.api.acr.ArgeoNamespace;
  11 import org.argeo.api.acr.Content;
  12 import org.argeo.api.acr.ContentName;
  13 import org.argeo.api.acr.ContentNotFoundException;
  14 import org.argeo.api.acr.spi.ContentProvider;
  15 import org.argeo.api.acr.spi.ProvidedContent;
  16 import org.argeo.api.acr.spi.ProvidedSession;
  17 import org.argeo.api.cms.directory.CmsUserManager;
  18 import org.argeo.api.cms.directory.HierarchyUnit;
  19 import org.argeo.api.cms.directory.UserDirectory;
  20 import org.argeo.cms.acr.AbstractContent;
  21 import org.argeo.cms.acr.ContentUtils;
  22 import org.osgi.service.useradmin.User;
  23
  24 public class DirectoryContentProvider implements ContentProvider {
  25         private String mountPath;
  26         private String mountName;
  27
  28         private CmsUserManager userManager;
  29
  30         public DirectoryContentProvider(String mountPath, CmsUserManager userManager) {
  31                 this.mountPath = mountPath;
  32                 List<String> mountSegments = ContentUtils.toPathSegments(mountPath);
  33                 this.mountName = mountSegments.get(mountSegments.size() - 1);
  34                 this.userManager = userManager;
  35         }
  36
  37         @Override
  38         public ProvidedContent get(ProvidedSession session, String relativePath) {
  39                 List<String> segments = ContentUtils.toPathSegments(relativePath);
  40                 if (segments.size() == 0)
  41                         return new UserManagerContent(session);
  42                 String userDirectoryName = segments.get(0);
  43                 UserDirectory userDirectory = null;
  44                 userDirectories: for (UserDirectory ud : userManager.getUserDirectories()) {
  45                         if (userDirectoryName.equals(ud.getName())) {
  46                                 userDirectory = ud;
  47                                 break userDirectories;
  48                         }
  49                 }
  50                 if (userDirectory == null)
  51                         throw new ContentNotFoundException(session, mountPath + "/" + relativePath,
  52                                         "Cannot find user directory " + userDirectoryName);
  53                 if (segments.size() == 1) {
  54                         return new DirectoryContent(session, this, userDirectory);
  55                 } else {
  56                         List<String> relSegments = new ArrayList<>(segments);
  57                         relSegments.remove(0);
  58                         String pathWithinUserDirectory = ContentUtils.toPath(relSegments);
  59 //                      LdapName dn;
  60 //                      try {
  61 //                              dn = LdapNameUtils.toLdapName(userDirectoryDn);
  62 //                              for (int i = 1; i < segments.size(); i++) {
  63 //                                      dn.add(segments.get(i));
  64 //                              }
  65 //                      } catch (InvalidNameException e) {
  66 //                              throw new IllegalStateException("Cannot interpret " + segments + " as DN", e);
  67 //                      }
  68                         User user = (User) userDirectory.getRoleByPath(pathWithinUserDirectory);
  69                         if (user != null) {
  70                                 HierarchyUnit parent = userDirectory.getHierarchyUnit(user);
  71                                 return new RoleContent(session, this, new HierarchyUnitContent(session, this, parent), user);
  72                         }
  73                         HierarchyUnit hierarchyUnit = userDirectory.getHierarchyUnit(pathWithinUserDirectory);
  74                         if (hierarchyUnit == null)
  75                                 throw new ContentNotFoundException(session,
  76                                                 mountPath + "/" + relativePath + "/" + pathWithinUserDirectory,
  77                                                 "Cannot find " + pathWithinUserDirectory + " within " + userDirectoryName);
  78                         return new HierarchyUnitContent(session, this, hierarchyUnit);
  79                 }
  80         }
  81
  82         @Override
  83         public boolean exists(ProvidedSession session, String relativePath) {
  84                 // TODO Auto-generated method stub
  85                 return false;
  86         }
  87
  88         @Override
  89         public String getMountPath() {
  90                 return mountPath;
  91         }
  92
  93         @Override
  94         public String getNamespaceURI(String prefix) {
  95                 if (ArgeoNamespace.LDAP_DEFAULT_PREFIX.equals(prefix))
  96                         return ArgeoNamespace.LDAP_NAMESPACE_URI;
  97                 throw new IllegalArgumentException("Only prefix " + ArgeoNamespace.LDAP_DEFAULT_PREFIX + " is supported");
  98         }
  99
 100         @Override
 101         public Iterator<String> getPrefixes(String namespaceURI) {
 102                 if (ArgeoNamespace.LDAP_NAMESPACE_URI.equals(namespaceURI))
 103                         return Collections.singletonList(ArgeoNamespace.LDAP_DEFAULT_PREFIX).iterator();
 104                 throw new IllegalArgumentException("Only namespace URI " + ArgeoNamespace.LDAP_NAMESPACE_URI + " is supported");
 105         }
 106
 107         public void setUserManager(CmsUserManager userManager) {
 108                 this.userManager = userManager;
 109         }
 110
 111         public CmsUserManager getUserManager() {
 112                 return userManager;
 113         }
 114
 115         UserManagerContent getRootContent(ProvidedSession session) {
 116                 return new UserManagerContent(session);
 117         }
 118
 119         /*
 120          * COMMON UTILITIES
 121          */
 122         class UserManagerContent extends AbstractContent {
 123
 124                 public UserManagerContent(ProvidedSession session) {
 125                         super(session);
 126                 }
 127
 128                 @Override
 129                 public ContentProvider getProvider() {
 130                         return DirectoryContentProvider.this;
 131                 }
 132
 133                 @Override
 134                 public QName getName() {
 135                         return new ContentName(mountName);
 136                 }
 137
 138                 @Override
 139                 public Content getParent() {
 140                         return null;
 141                 }
 142
 143                 @Override
 144                 public Iterator<Content> iterator() {
 145                         List<Content> res = new ArrayList<>();
 146                         for (UserDirectory userDirectory : userManager.getUserDirectories()) {
 147                                 DirectoryContent content = new DirectoryContent(getSession(), DirectoryContentProvider.this,
 148                                                 userDirectory);
 149                                 res.add(content);
 150                         }
 151                         return res.iterator();
 152                 }
 153
 154         }
 155 }