jcr/JcrModel.java

   1 package org.argeo.fm.jcr;
   2
   3 import javax.jcr.Node;
   4 import javax.jcr.Property;
   5 import javax.jcr.PropertyIterator;
   6 import javax.jcr.RepositoryException;
   7 import javax.jcr.Value;
   8
   9 import freemarker.template.SimpleScalar;
  10 import freemarker.template.TemplateCollectionModel;
  11 import freemarker.template.TemplateHashModel;
  12 import freemarker.template.TemplateHashModelEx2;
  13 import freemarker.template.TemplateModel;
  14 import freemarker.template.TemplateModelException;
  15 import freemarker.template.TemplateModelIterator;
  16 import freemarker.template.TemplateNodeModel;
  17 import freemarker.template.TemplateSequenceModel;
  18
  19 public class JcrModel implements TemplateNodeModel, TemplateHashModel {
  20         private final Node node;
  21
  22         public JcrModel(Node node) {
  23                 this.node = node;
  24         }
  25
  26         @Override
  27         public TemplateSequenceModel getChildNodes() throws TemplateModelException {
  28                 try {
  29                         return new NodeIteratorModel(node.getNodes());
  30                 } catch (RepositoryException e) {
  31                         throw new TemplateModelException("Cannot list children of " + node, e);
  32                 }
  33         }
  34
  35         @Override
  36         public String getNodeName() throws TemplateModelException {
  37                 try {
  38                         return node.getName();
  39                 } catch (RepositoryException e) {
  40                         throw new TemplateModelException("Cannot get name of " + node, e);
  41                 }
  42         }
  43
  44         @Override
  45         public String getNodeNamespace() throws TemplateModelException {
  46                 // TODO find out namespace
  47                 return null;
  48         }
  49
  50         @Override
  51         public String getNodeType() throws TemplateModelException {
  52                 try {
  53                         return node.getPrimaryNodeType().getName();
  54                 } catch (RepositoryException e) {
  55                         throw new TemplateModelException("Cannot get node type of " + node, e);
  56                 }
  57         }
  58
  59         @Override
  60         public TemplateNodeModel getParentNode() throws TemplateModelException {
  61                 try {
  62                         Node parent = node.getParent();
  63                         if (parent == null)
  64                                 return null;
  65                         return new JcrModel(parent);
  66                 } catch (RepositoryException e) {
  67                         throw new TemplateModelException("Cannot get parent of " + node, e);
  68                 }
  69         }
  70
  71         // HASH
  72
  73         @Override
  74         public TemplateModel get(String key) throws TemplateModelException {
  75                 try {
  76                         if ("jcr:path".equals(key))
  77                                 return new SimpleScalar(node.getPath());
  78                         if ("jcr:name".equals(key))
  79                                 return new SimpleScalar(node.getName());
  80                         if ("jcr:properties".equals(key))
  81                                 return new PropertiesModel();
  82                         if ("jcr:parent".equals(key))
  83                                 return node.getParent() != null ? new JcrModel(node.getParent()) : null;
  84
  85                         Property property = node.getProperty(key);
  86                         if (property == null)
  87                                 return null;
  88                         return new SimpleScalar(property.getString());
  89                 } catch (RepositoryException e) {
  90                         throw new TemplateModelException("Cannot get property " + key + " of " + node, e);
  91                 }
  92         }
  93
  94         @Override
  95         public boolean isEmpty() throws TemplateModelException {
  96                 return false;
  97         }
  98
  99         public Node getNode() {
 100                 return node;
 101         }
 102
 103         protected TemplateModel propertyValues(Property property) throws RepositoryException {
 104                 if (!property.isMultiple())
 105                         return new SimpleScalar(property.getString());
 106                 Value[] values = property.getValues();
 107                 StringBuilder sb = new StringBuilder();
 108                 for (Value value : values) {
 109                         sb.append(value.getString()).append('\n');
 110                 }
 111                 return new SimpleScalar(sb.toString());
 112         }
 113
 114         class PropertiesModel implements TemplateHashModelEx2 {
 115                 @Override
 116                 public TemplateModel get(String key) throws TemplateModelException {
 117                         return JcrModel.this.get(key);
 118                 }
 119
 120                 @Override
 121                 public boolean isEmpty() throws TemplateModelException {
 122                         return false;
 123                 }
 124
 125                 @Override
 126                 public TemplateCollectionModel keys() throws TemplateModelException {
 127                         try {
 128                                 PropertyIterator pit = node.getProperties();
 129                                 return new TemplateCollectionModel() {
 130
 131                                         @Override
 132                                         public TemplateModelIterator iterator() throws TemplateModelException {
 133                                                 return new TemplateModelIterator() {
 134
 135                                                         @Override
 136                                                         public TemplateModel next() throws TemplateModelException {
 137                                                                 try {
 138                                                                         return new SimpleScalar(pit.nextProperty().getName());
 139                                                                 } catch (RepositoryException e) {
 140                                                                         throw new TemplateModelException("Cannot list properties of " + node, e);
 141                                                                 }
 142                                                         }
 143
 144                                                         @Override
 145                                                         public boolean hasNext() throws TemplateModelException {
 146                                                                 return pit.hasNext();
 147                                                         }
 148                                                 };
 149                                         }
 150                                 };
 151                         } catch (RepositoryException e) {
 152                                 throw new TemplateModelException("Cannot list properties of " + node, e);
 153                         }
 154                 }
 155
 156                 @Override
 157                 public int size() throws TemplateModelException {
 158                         try {
 159                                 PropertyIterator pit = node.getProperties();
 160                                 return (int) pit.getSize();
 161                         } catch (RepositoryException e) {
 162                                 throw new TemplateModelException("Cannot list properties of " + node, e);
 163                         }
 164                 }
 165
 166                 @Override
 167                 public TemplateCollectionModel values() throws TemplateModelException {
 168                         try {
 169                                 PropertyIterator pit = node.getProperties();
 170                                 return new TemplateCollectionModel() {
 171
 172                                         @Override
 173                                         public TemplateModelIterator iterator() throws TemplateModelException {
 174                                                 return new TemplateModelIterator() {
 175
 176                                                         @Override
 177                                                         public TemplateModel next() throws TemplateModelException {
 178                                                                 try {
 179                                                                         return propertyValues(pit.nextProperty());
 180                                                                 } catch (RepositoryException e) {
 181                                                                         throw new TemplateModelException("Cannot list properties of " + node, e);
 182                                                                 }
 183                                                         }
 184
 185                                                         @Override
 186                                                         public boolean hasNext() throws TemplateModelException {
 187                                                                 return pit.hasNext();
 188                                                         }
 189                                                 };
 190                                         }
 191                                 };
 192                         } catch (RepositoryException e) {
 193                                 throw new TemplateModelException("Cannot list properties of " + node, e);
 194                         }
 195                 }
 196
 197                 @Override
 198                 public KeyValuePairIterator keyValuePairIterator() throws TemplateModelException {
 199                         try {
 200                                 PropertyIterator pit = node.getProperties();
 201                                 return new KeyValuePairIterator() {
 202
 203                                         @Override
 204                                         public boolean hasNext() throws TemplateModelException {
 205                                                 return pit.hasNext();
 206                                         }
 207
 208                                         @Override
 209                                         public KeyValuePair next() throws TemplateModelException {
 210                                                 Property property = pit.nextProperty();
 211                                                 return new KeyValuePair() {
 212
 213                                                         @Override
 214                                                         public TemplateModel getValue() throws TemplateModelException {
 215                                                                 try {
 216                                                                         return propertyValues(property);
 217                                                                 } catch (RepositoryException e) {
 218                                                                         throw new TemplateModelException("Cannot list properties of " + node, e);
 219                                                                 }
 220                                                         }
 221
 222                                                         @Override
 223                                                         public TemplateModel getKey() throws TemplateModelException {
 224                                                                 try {
 225                                                                         return new SimpleScalar(property.getName());
 226                                                                 } catch (RepositoryException e) {
 227                                                                         throw new TemplateModelException("Cannot list properties of " + node, e);
 228                                                                 }
 229                                                         }
 230                                                 };
 231                                         }
 232                                 };
 233                         } catch (RepositoryException e) {
 234                                 throw new TemplateModelException("Cannot list properties of " + node, e);
 235                         }
 236                 }
 237
 238         }
 239 }