1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.templating.jsp.cmsfn;
35
36 import info.magnolia.cms.util.SiblingsHelper;
37 import info.magnolia.jcr.util.ContentMap;
38 import info.magnolia.objectfactory.Components;
39 import info.magnolia.templating.functions.TemplatingFunctions;
40
41 import java.util.Collection;
42 import java.util.List;
43
44 import javax.jcr.Node;
45 import javax.jcr.Property;
46 import javax.jcr.RepositoryException;
47
48 import org.apache.commons.lang.StringUtils;
49 import org.tldgen.annotations.Function;
50
51
52
53
54
55
56
57
58
59 public class JspTemplatingFunction {
60
61
62 private static TemplatingFunctions templatingFunctions ;
63
64
65
66
67
68
69
70
71 private static TemplatingFunctions getTemplatingFunctions() {
72 if( templatingFunctions==null ) {
73 templatingFunctions = Components.getComponent(TemplatingFunctions.class);
74 }
75 return templatingFunctions;
76 }
77
78 @Function
79 public static Node asJCRNode(ContentMap contentMap) {
80 return getTemplatingFunctions().asJCRNode(contentMap);
81 }
82
83 @Function
84 public static ContentMap asContentMap(Node content) {
85 return getTemplatingFunctions().asContentMap(content);
86 }
87
88 @Function
89 public static List<ContentMap> children(ContentMap content, String nodeTypeName) throws RepositoryException {
90 if(!nodeTypeName.isEmpty()){
91 return getTemplatingFunctions().children(content, nodeTypeName);
92 }
93 return getTemplatingFunctions().children(content);
94 }
95
96 @Function()
97 public static ContentMap root(ContentMap contentMap, String nodeTypeName) throws RepositoryException {
98 if(!nodeTypeName.isEmpty()) {
99 ContentMap root = getTemplatingFunctions().root(contentMap, nodeTypeName);
100 return root;
101 }
102 return getTemplatingFunctions().root(contentMap);
103 }
104
105 @Function
106 public static ContentMap parent(ContentMap contentMap, String nodeTypeName) throws RepositoryException {
107 if(!nodeTypeName.isEmpty()) {
108 return getTemplatingFunctions().parent(contentMap, nodeTypeName);
109 }
110 return getTemplatingFunctions().parent(contentMap);
111 }
112
113
114
115
116
117
118
119
120
121 @Function
122 public static ContentMap page(ContentMap content) throws RepositoryException {
123 return getTemplatingFunctions().page(content);
124 }
125
126
127 @Function
128 public static List<ContentMap> ancestors(ContentMap contentMap, String nodeTypeName) throws RepositoryException {
129 if(nodeTypeName.isEmpty()) {
130 return getTemplatingFunctions().ancestors(contentMap);
131 }
132 return getTemplatingFunctions().ancestors(contentMap, nodeTypeName);
133 }
134
135 @Function
136 public static ContentMap inherit(ContentMap content, String relPath) throws RepositoryException {
137 if(!relPath.isEmpty()) {
138 return getTemplatingFunctions().inherit(content, relPath);
139 }
140 return getTemplatingFunctions().inherit(content);
141 }
142
143 @Function
144 public static Property inheritProperty(ContentMap content, String relPath) throws RepositoryException {
145 return getTemplatingFunctions().inheritProperty(content, relPath);
146 }
147
148 @Function
149 public static List<ContentMap> inheritList(ContentMap content, String relPath) throws RepositoryException {
150 return getTemplatingFunctions().inheritList(content, relPath);
151 }
152
153 @Function
154 public static boolean isInherited(ContentMap content) {
155 return getTemplatingFunctions().isInherited(content);
156 }
157
158 @Function
159 public static boolean isFromCurrentPage(ContentMap content) {
160 return getTemplatingFunctions().isFromCurrentPage(content);
161 }
162
163
164
165
166 @Function
167 public static String linkForWorkspace(String workspace, String nodeIdentifier) {
168 return getTemplatingFunctions().link(workspace, nodeIdentifier);
169 }
170
171
172
173
174
175 @Function
176 public static String linkForProperty(Property property) {
177 return getTemplatingFunctions().link(property);
178 }
179
180
181 @Function
182 public static String link(ContentMap contentMap) throws RepositoryException {
183 return getTemplatingFunctions().link(contentMap);
184 }
185
186 @Function
187 public static String link(ContentMap contentMap, String propertyName) throws RepositoryException {
188 return getTemplatingFunctions().link(contentMap);
189 }
190
191
192
193
194
195 @Function
196 public static String language(){
197 return getTemplatingFunctions().language();
198 }
199
200
201
202
203
204
205
206
207
208 @Function
209 public static String externalLink(ContentMap content, String linkPropertyName) {
210 return getTemplatingFunctions().externalLink(content, linkPropertyName);
211 }
212
213
214
215
216
217
218
219
220
221
222
223 @Function
224 public static String externalLinkTitle(ContentMap content, String linkPropertyName, String linkTitlePropertyName) {
225 return getTemplatingFunctions().externalLinkTitle(content, linkPropertyName, linkTitlePropertyName);
226 }
227
228 @Function
229 public static boolean isEditMode() {
230 return getTemplatingFunctions().isEditMode();
231 }
232
233 @Function
234 public static boolean isPreviewMode() {
235 return getTemplatingFunctions().isPreviewMode();
236 }
237
238 @Function
239 public static boolean isAuthorInstance() {
240 return getTemplatingFunctions().isAuthorInstance();
241 }
242
243 @Function
244 public static boolean isPublicInstance() {
245 return getTemplatingFunctions().isPublicInstance();
246 }
247
248
249
250
251
252 @Function
253 public static String createHtmlAttribute(String name, String value) {
254 return getTemplatingFunctions().createHtmlAttribute(name, value);
255 }
256
257
258
259
260 @Function
261 public static SiblingsHelper siblings(ContentMap node) throws RepositoryException {
262 return getTemplatingFunctions().siblings(node);
263 }
264
265
266
267
268
269
270
271 @Function
272 public static Node content(String path,String repository){
273 if(StringUtils.isBlank(repository)) {
274 return getTemplatingFunctions().content(path);
275 }
276 return getTemplatingFunctions().content(repository, path);
277 }
278
279
280
281
282
283
284 @Function
285 public static Node contentByIdentifier(String id, String repository){
286 if(StringUtils.isBlank(repository)) {
287 return getTemplatingFunctions().contentByIdentifier(id);
288 }
289 return getTemplatingFunctions().contentByIdentifier(repository, id);
290 }
291
292 @Function
293 public static List<ContentMap> asContentMapList(Collection<Node> nodeList) {
294 return getTemplatingFunctions().asContentMapList(nodeList);
295 }
296
297 @Function
298 public static List<Node> asNodeList(Collection<ContentMap> contentMapList) {
299 return getTemplatingFunctions().asNodeList(contentMapList);
300 }
301
302
303
304
305 @Function
306 public static ContentMap decode(ContentMap content){
307 return getTemplatingFunctions().decode(content);
308 }
309
310
311
312
313 @Function
314 public static String metaData(ContentMap content, String property){
315 return getTemplatingFunctions().metaData(content, property);
316 }
317
318 @Function
319 public static Collection<Node> search(String workspace, String statement, String language, String returnItemType){
320 return getTemplatingFunctions().search(workspace, statement, language, returnItemType);
321 }
322
323 @Function
324 public static Collection<Node> simpleSearch(String workspace, String statement, String returnItemType, String startPath){
325 return getTemplatingFunctions().simpleSearch(workspace, statement, returnItemType, startPath);
326 }
327 }