jcr/terms/SuiteTermsManager.java

   1 package org.argeo.app.jcr.terms;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5 import java.util.List;
   6 import java.util.Map;
   7 import java.util.Set;
   8 import java.util.TreeSet;
   9
  10 import javax.jcr.Node;
  11 import javax.jcr.NodeIterator;
  12 import javax.jcr.Repository;
  13 import javax.jcr.RepositoryException;
  14 import javax.jcr.Session;
  15
  16 import org.argeo.api.cms.CmsConstants;
  17 import org.argeo.app.api.EntityNames;
  18 import org.argeo.app.api.EntityType;
  19 import org.argeo.app.api.Term;
  20 import org.argeo.app.api.TermsManager;
  21 import org.argeo.app.api.Typology;
  22 import org.argeo.cms.jcr.CmsJcrUtils;
  23 import org.argeo.jcr.Jcr;
  24 import org.argeo.jcr.JcrException;
  25
  26 /** Argeo Suite implementation of terms manager. */
  27 public class SuiteTermsManager implements TermsManager {
  28         private final Map<String, SuiteTerm> terms = new HashMap<>();
  29         private final Map<String, SuiteTypology> typologies = new HashMap<>();
  30
  31         // JCR
  32         private Repository repository;
  33         private Session adminSession;
  34
  35         public void init() {
  36                 adminSession = CmsJcrUtils.openDataAdminSession(repository, CmsConstants.SYS_WORKSPACE);
  37         }
  38
  39         @Override
  40         public List<Term> listAllTerms(String typology) {
  41                 List<Term> res = new ArrayList<>();
  42                 SuiteTypology t = getTypology(typology);
  43                 for (SuiteTerm term : t.getAllTerms()) {
  44                         res.add(term);
  45                 }
  46                 return res;
  47         }
  48
  49         @Override
  50         public SuiteTerm getTerm(String termId) {
  51                 return terms.get(termId);
  52         }
  53
  54         @Override
  55         public SuiteTypology getTypology(String typology) {
  56                 SuiteTypology t = typologies.get(typology);
  57                 if (t == null) {
  58                         Node termsNode = Jcr.getNode(adminSession, "SELECT * FROM [{0}] WHERE NAME()=\"{1}\"",
  59                                         EntityType.terms.get(), typology);
  60                         if (termsNode == null)
  61                                 throw new IllegalArgumentException("Typology " + typology + " not found.");
  62                         t = loadTypology(termsNode);
  63                 }
  64                 return t;
  65         }
  66
  67         @Override
  68         public Set<Typology> getTypologies() {
  69                 Set<Typology> res = new TreeSet<>((o1, o2) -> o1.getId().compareTo(o2.getId()));
  70                 NodeIterator termsNodes = Jcr.executeQuery(adminSession, "SELECT * FROM [{0}]", EntityType.terms.get());
  71                 for (Node termsNode : Jcr.iterate(termsNodes)) {
  72                         res.add(loadTypology(termsNode));
  73                 }
  74                 return res;
  75         }
  76
  77         SuiteTypology loadTypology(Node termsNode) {
  78                 try {
  79                         SuiteTypology typology = new SuiteTypology(termsNode);
  80                         for (Node termNode : Jcr.iterate(termsNode.getNodes())) {
  81                                 if (termNode.isNodeType(EntityType.term.get())) {
  82                                         SuiteTerm term = loadTerm(typology, termNode, null);
  83                                         if (!term.getSubTerms().isEmpty())
  84                                                 typology.markNotFlat();
  85                                         typology.getSubTerms().add(term);
  86                                 }
  87                         }
  88                         typologies.put(typology.getName(), typology);
  89                         return typology;
  90                 } catch (RepositoryException e) {
  91                         throw new JcrException("Cannot load typology from " + termsNode, e);
  92                 }
  93         }
  94
  95         SuiteTerm loadTerm(SuiteTypology typology, Node termNode, SuiteTerm parentTerm) throws RepositoryException {
  96                 String name = termNode.getProperty(EntityNames.NAME).getString();
  97                 String relativePath = parentTerm == null ? name : parentTerm.getRelativePath() + '/' + name;
  98                 SuiteTerm term = new SuiteTerm(typology, relativePath, parentTerm);
  99                 terms.put(term.getId(), term);
 100                 for (Node subTermNode : Jcr.iterate(termNode.getNodes())) {
 101                         if (termNode.isNodeType(EntityType.term.get())) {
 102                                 SuiteTerm subTerm = loadTerm(typology, subTermNode, term);
 103                                 term.getSubTerms().add(subTerm);
 104                         }
 105                 }
 106                 return term;
 107         }
 108
 109         public void destroy() {
 110                 Jcr.logout(adminSession);
 111         }
 112
 113         public void setRepository(Repository repository) {
 114                 this.repository = repository;
 115         }
 116
 117 }