org.argeo.cms/src/org/argeo/cms/acr/CmsContentSession.java

   1 package org.argeo.cms.acr;
   2
   3 import java.util.Iterator;
   4 import java.util.Locale;
   5 import java.util.Map;
   6 import java.util.Set;
   7 import java.util.TreeSet;
   8 import java.util.concurrent.CompletableFuture;
   9 import java.util.concurrent.CompletionStage;
  10 import java.util.function.Consumer;
  11 import java.util.stream.Collectors;
  12
  13 import javax.security.auth.Subject;
  14
  15 import org.argeo.api.acr.Content;
  16 import org.argeo.api.acr.ContentSession;
  17 import org.argeo.api.acr.NamespaceUtils;
  18 import org.argeo.api.acr.spi.ContentProvider;
  19 import org.argeo.api.acr.spi.ProvidedContent;
  20 import org.argeo.api.acr.spi.ProvidedRepository;
  21 import org.argeo.api.acr.spi.ProvidedSession;
  22 import org.argeo.cms.acr.xml.DomContentProvider;
  23
  24 /** Implements {@link ProvidedSession}. */
  25 class CmsContentSession implements ProvidedSession {
  26         final private AbstractContentRepository contentRepository;
  27
  28         private Subject subject;
  29         private Locale locale;
  30
  31         private CompletableFuture<ProvidedSession> closed = new CompletableFuture<>();
  32
  33         private CompletableFuture<ContentSession> edition;
  34
  35         private Set<ContentProvider> modifiedProviders = new TreeSet<>();
  36
  37         public CmsContentSession(AbstractContentRepository contentRepository, Subject subject, Locale locale) {
  38                 this.contentRepository = contentRepository;
  39                 this.subject = subject;
  40                 this.locale = locale;
  41         }
  42
  43         public void close() {
  44                 closed.complete(this);
  45         }
  46
  47         @Override
  48         public CompletionStage<ProvidedSession> onClose() {
  49                 return closed.minimalCompletionStage();
  50         }
  51
  52         @Override
  53         public Content get(String path) {
  54                 ContentProvider contentProvider = contentRepository.getMountManager().findContentProvider(path);
  55                 String mountPath = contentProvider.getMountPath();
  56                 String relativePath = path.substring(mountPath.length());
  57                 if (relativePath.length() > 0 && relativePath.charAt(0) == '/')
  58                         relativePath = relativePath.substring(1);
  59                 ProvidedContent content = contentProvider.get(CmsContentSession.this, mountPath, relativePath);
  60                 return content;
  61         }
  62
  63         @Override
  64         public Subject getSubject() {
  65                 return subject;
  66         }
  67
  68         @Override
  69         public Locale getLocale() {
  70                 return locale;
  71         }
  72
  73         @Override
  74         public ProvidedRepository getRepository() {
  75                 return contentRepository;
  76         }
  77
  78         /*
  79          * MOUNT MANAGEMENT
  80          */
  81         @Override
  82         public Content getMountPoint(String path) {
  83                 String[] parent = ContentUtils.getParentPath(path);
  84                 ProvidedContent mountParent = (ProvidedContent) get(parent[0]);
  85 //                      Content mountPoint = mountParent.getProvider().get(CmsContentSession.this, null, path);
  86                 return mountParent.getMountPoint(parent[1]);
  87         }
  88
  89         /*
  90          * NAMESPACE CONTEXT
  91          */
  92
  93         @Override
  94         public String getNamespaceURI(String prefix) {
  95                 return NamespaceUtils.getNamespaceURI((p) -> contentRepository.getTypesManager().getPrefixes().get(p), prefix);
  96         }
  97
  98         @Override
  99         public Iterator<String> getPrefixes(String namespaceURI) {
 100                 return NamespaceUtils.getPrefixes((ns) -> contentRepository.getTypesManager().getPrefixes().entrySet().stream()
 101                                 .filter(e -> e.getValue().equals(ns)).map(Map.Entry::getKey).collect(Collectors.toUnmodifiableSet()),
 102                                 namespaceURI);
 103         }
 104
 105         @Override
 106         public CompletionStage<ContentSession> edit(Consumer<ContentSession> work) {
 107                 edition = CompletableFuture.supplyAsync(() -> {
 108                         work.accept(this);
 109                         return this;
 110                 }).thenApply((s) -> {
 111                         // TODO optimise
 112                         for (ContentProvider provider : modifiedProviders) {
 113                                 if (provider instanceof DomContentProvider) {
 114                                         ((DomContentProvider) provider).persist(s);
 115                                 }
 116                         }
 117                         return s;
 118                 });
 119                 return edition.minimalCompletionStage();
 120         }
 121
 122         @Override
 123         public boolean isEditing() {
 124                 return edition != null && !edition.isDone();
 125         }
 126
 127         @Override
 128         public void notifyModification(ProvidedContent content) {
 129                 ContentProvider contentProvider = content.getProvider();
 130                 modifiedProviders.add(contentProvider);
 131         }
 132
 133 //              @Override
 134 //              public String findNamespace(String prefix) {
 135 //                      return prefixes.get(prefix);
 136 //              }
 137 //
 138 //              @Override
 139 //              public Set<String> findPrefixes(String namespaceURI) {
 140 //                      Set<String> res = prefixes.entrySet().stream().filter(e -> e.getValue().equals(namespaceURI))
 141 //                                      .map(Map.Entry::getKey).collect(Collectors.toUnmodifiableSet());
 142 //
 143 //                      return res;
 144 //              }
 145 //
 146 //              @Override
 147 //              public String findPrefix(String namespaceURI) {
 148 //                      if (CrName.CR_NAMESPACE_URI.equals(namespaceURI) && prefixes.containsKey(CrName.CR_DEFAULT_PREFIX))
 149 //                              return CrName.CR_DEFAULT_PREFIX;
 150 //                      return ProvidedSession.super.findPrefix(namespaceURI);
 151 //              }
 152
 153 }