|
0
|
1 package nabble.view.web.template;
|
|
|
2
|
|
|
3 import fschmidt.util.java.Filter;
|
|
|
4 import nabble.model.ModelHome;
|
|
|
5 import nabble.model.Node;
|
|
|
6 import nabble.model.NodeIterator;
|
|
|
7 import nabble.model.NodeSearcher;
|
|
|
8 import nabble.model.User;
|
|
|
9 import nabble.naml.compiler.Command;
|
|
|
10 import nabble.naml.compiler.CommandSpec;
|
|
|
11 import nabble.naml.compiler.IPrintWriter;
|
|
|
12 import nabble.naml.compiler.Interpreter;
|
|
|
13 import nabble.naml.compiler.Namespace;
|
|
|
14 import nabble.naml.compiler.ScopedInterpreter;
|
|
|
15 import nabble.naml.namespaces.ListSequence;
|
|
|
16
|
|
|
17 import java.util.ArrayList;
|
|
|
18 import java.util.Arrays;
|
|
|
19 import java.util.Collection;
|
|
|
20 import java.util.Collections;
|
|
|
21 import java.util.List;
|
|
|
22
|
|
|
23
|
|
|
24 @Namespace (
|
|
|
25 name = "node_list",
|
|
|
26 global = true
|
|
|
27 )
|
|
|
28 public final class NodeList extends ListSequence<Node> {
|
|
|
29
|
|
|
30 static void subapps(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,String filter) {
|
|
|
31 List<Node> nodes = loopNode.getChildApps(filter).get(0, 100);
|
|
|
32 NodeList loop = new NodeList(nodes, loopNode, false);
|
|
|
33 Object block = interp.getArg(loop,"do");
|
|
|
34 out.print(block);
|
|
|
35 }
|
|
|
36
|
|
|
37 static void descendantApps(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode) {
|
|
|
38 List<Node> nodes = loopNode.getDescendantApps().get(0, 1000);
|
|
|
39 NodeList loop = new NodeList(nodes, loopNode, false);
|
|
|
40 Object block = interp.getArg(loop,"do");
|
|
|
41 out.print(block);
|
|
|
42 }
|
|
|
43
|
|
|
44 static void ancestors(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,String order) {
|
|
|
45 Node parent = loopNode.getParent();
|
|
|
46 List<Node> nodes = parent != null? parent.getAncestors().get(0, 1000) : Collections.<Node>emptyList();
|
|
|
47 if ("reverse".equalsIgnoreCase(order) && nodes.size() > 1)
|
|
|
48 Collections.reverse(nodes);
|
|
|
49 NodeList loop = new NodeList(nodes, loopNode, false);
|
|
|
50 Object block = interp.getArg(loop,"do");
|
|
|
51 out.print(block);
|
|
|
52 }
|
|
|
53
|
|
|
54 private static boolean hasMore(List<Node> nodes,int size) {
|
|
|
55 if( nodes.size() <= size )
|
|
|
56 return false;
|
|
|
57 nodes.remove(size);
|
|
|
58 return true;
|
|
|
59 }
|
|
|
60
|
|
|
61 public static void children(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,NodeIterator<? extends Node> nodeIter,int indexRecord,int length) {
|
|
|
62 List<Node> nodes = nodeIter.get(indexRecord, length+1);
|
|
|
63 boolean hasMore = hasMore(nodes,length);
|
|
|
64 NodeList loop = new NodeList(nodes, loopNode, hasMore);
|
|
|
65 Object block = interp.getArg(loop,"do");
|
|
|
66 out.print(block);
|
|
|
67 }
|
|
|
68
|
|
|
69 public static void topics(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,NodeIterator<? extends Node> nodeIter,int indexRecord,int length) {
|
|
|
70 List<Node> nodes = nodeIter.get(indexRecord, length+1);
|
|
|
71 boolean hasMore = hasMore(nodes,length);
|
|
|
72 NodeList loop = new NodeList(nodes, loopNode, hasMore);
|
|
|
73 Object block = interp.getArg(loop,"do");
|
|
|
74 out.print(block);
|
|
|
75 }
|
|
|
76
|
|
|
77 public static void posts(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,int indexRecord,int length,String sortBy,Filter<Node> filter) {
|
|
|
78 List<Node> nodes;
|
|
|
79 if ("date-ascending".equals(sortBy)) {
|
|
|
80 nodes = loopNode.getPostsByDateAscending(filter).get(indexRecord, length+1);
|
|
|
81 } else if ("date-descending".equals(sortBy)) {
|
|
|
82 nodes = loopNode.getPostsByDate(filter).get(indexRecord, length+1);
|
|
|
83 } else {
|
|
|
84 throw new RuntimeException("'sort' attribute not set");
|
|
|
85 }
|
|
|
86 boolean hasMore = hasMore(nodes,length);
|
|
|
87 NodeList loop = new NodeList(nodes, loopNode, hasMore);
|
|
|
88 Object block = interp.getArg(loop,"do");
|
|
|
89 out.print(block);
|
|
|
90 }
|
|
|
91
|
|
|
92 static void userNodes(IPrintWriter out,ScopedInterpreter<NodeList> interp, NodeIterator<? extends Node> nodeIter, int indexRecord,int length) {
|
|
|
93 List<Node> nodes = nodeIter.get(indexRecord,length+1);
|
|
|
94 boolean hasMore = hasMore(nodes,length);
|
|
|
95 NodeList loop = new NodeList(nodes, null, hasMore);
|
|
|
96 Object block = interp.getArg(loop,"do");
|
|
|
97 out.print(block);
|
|
|
98 }
|
|
|
99
|
|
|
100
|
|
|
101 private final Node loopNode;
|
|
|
102 private final boolean hasMore;
|
|
|
103
|
|
|
104 /**
|
|
|
105 * Cache the lastNodes to prevent them from being
|
|
|
106 * garbage collected so that there aren't multiple
|
|
|
107 * database accesses. This is an optimization.
|
|
|
108 */
|
|
|
109 private final Collection<Node> lastNodes;
|
|
|
110
|
|
|
111 public NodeList(List<Node> nodes, Node loopNode,boolean hasMore) {
|
|
|
112 super(nodes);
|
|
|
113 this.loopNode = loopNode;
|
|
|
114 this.hasMore = hasMore;
|
|
|
115 lastNodes = NabbleNamespace.current().site().cacheLastNodes(nodes);
|
|
|
116 }
|
|
|
117
|
|
|
118 public static final CommandSpec preload_messages = CommandSpec.NO_OUTPUT;
|
|
|
119
|
|
|
120 @Command public void preload_messages(IPrintWriter out,Interpreter interp) {
|
|
|
121 ModelHome.preloadMessages(elements);
|
|
|
122 }
|
|
|
123
|
|
|
124 @Command public void there_is_more(IPrintWriter out,Interpreter interp) {
|
|
|
125 out.print( hasMore );
|
|
|
126 }
|
|
|
127
|
|
|
128 @Command public void has_loop_node(IPrintWriter out,Interpreter interp) {
|
|
|
129 out.print( loopNode != null );
|
|
|
130 }
|
|
|
131
|
|
|
132 public static final CommandSpec loop_node = CommandSpec.DO;
|
|
|
133
|
|
|
134 @Command public void loop_node(IPrintWriter out,ScopedInterpreter<NodeNamespace> interp) {
|
|
|
135 out.print( interp.getArg(new NodeNamespace(loopNode),"do") );
|
|
|
136 }
|
|
|
137
|
|
|
138 public static final CommandSpec current_node = CommandSpec.DO;
|
|
|
139
|
|
|
140 @Command public void current_node(IPrintWriter out,ScopedInterpreter<NodeNamespace> interp) {
|
|
|
141 NodeNamespace row = new NodeNamespace(get());
|
|
|
142 Object block = interp.getArg(row,"do");
|
|
|
143 out.print(block);
|
|
|
144 }
|
|
|
145
|
|
|
146 public static final CommandSpec node_at = CommandSpec.DO()
|
|
|
147 .parameters("index")
|
|
|
148 .build()
|
|
|
149 ;
|
|
|
150
|
|
|
151 @Command public void node_at(IPrintWriter out,ScopedInterpreter<NodeNamespace> interp) {
|
|
|
152 int index = interp.getArgAsInt("index");
|
|
|
153 NodeNamespace row = new NodeNamespace(elements.get(index));
|
|
|
154 Object block = interp.getArg(row,"do");
|
|
|
155 out.print(block);
|
|
|
156 }
|
|
|
157
|
|
|
158 @Command public void next_node(IPrintWriter out,Interpreter interp) {
|
|
|
159 next_element(out,interp);
|
|
|
160 }
|
|
|
161
|
|
|
162 @Command public void has_previous_node(IPrintWriter out,Interpreter interp) {
|
|
|
163 out.print( getPrevious() != null );
|
|
|
164 }
|
|
|
165
|
|
|
166 public static final CommandSpec previous_node = CommandSpec.DO;
|
|
|
167
|
|
|
168 @Command public void previous_node(IPrintWriter out,ScopedInterpreter<NodeNamespace> interp) {
|
|
|
169 NodeNamespace row = new NodeNamespace(getPrevious());
|
|
|
170 Object block = interp.getArg(row,"do");
|
|
|
171 out.print(block);
|
|
|
172 }
|
|
|
173
|
|
|
174 public static final CommandSpec sub_list = CommandSpec.DO()
|
|
|
175 .parameters("length")
|
|
|
176 .optionalParameters("start")
|
|
|
177 .build()
|
|
|
178 ;
|
|
|
179
|
|
|
180 @Command public void sub_list(IPrintWriter out,ScopedInterpreter<NodeList> interp) {
|
|
|
181 int start = interp.getArgAsInt("start",0);
|
|
|
182 int length = interp.getArgAsInt("length");
|
|
|
183 NodeList ns ;
|
|
|
184 if( start==0 && length >= elements.size() ) {
|
|
|
185 ns = this;
|
|
|
186 } else {
|
|
|
187 ns = new NodeList( elements.subList(start,Math.min(elements.size(),start+length)), loopNode, false );
|
|
|
188 }
|
|
|
189 out.print( interp.getArg(ns,"do") );
|
|
|
190 }
|
|
|
191
|
|
|
192 }
|
