1 |
cvsjoko |
1.1 |
<? |
2 |
|
|
|
3 |
|
|
// ------------------------------------------------------------------------------------------------ |
4 |
|
|
class TrackingState { |
5 |
|
|
|
6 |
|
|
// some vars for storing some arguments |
7 |
|
|
var $args_input; |
8 |
|
|
var $args_main; |
9 |
|
|
|
10 |
|
|
// some vars holding metadata about the arguments |
11 |
|
|
var $metadata_arguments; |
12 |
|
|
var $meta_names_list; |
13 |
|
|
var $meta_input2main_map; |
14 |
|
|
var $meta_main2output_map; |
15 |
|
|
var $meta_persistent_lookup; |
16 |
|
|
|
17 |
|
|
// metadata about callbacks |
18 |
|
|
var $metadata_callbacks; |
19 |
|
|
|
20 |
|
|
var $ic_store; |
21 |
|
|
|
22 |
|
|
|
23 |
|
|
// ------------------------------------------------------------------------------------------------ |
24 |
|
|
function TrackingState($metadata_arguments, $metadata_callbacks = array()) { |
25 |
|
|
|
26 |
|
|
$this->args_input = array(); |
27 |
|
|
$this->args_main = array(); |
28 |
|
|
|
29 |
|
|
// this will initialize "TrackingState" with all common arguments used by the application |
30 |
|
|
// create proper arrays for input- and output- arguments and build lookup-hash for each argument being persistent |
31 |
|
|
$this->metadata_arguments = $metadata_arguments; |
32 |
|
|
$this->metadata_callbacks = $metadata_callbacks; |
33 |
|
|
|
34 |
|
|
$this->meta_names_list = array(); |
35 |
|
|
reset($this->metadata_arguments); |
36 |
|
|
while ( $entry = current($this->metadata_arguments) ) { |
37 |
|
|
|
38 |
|
|
$name_short = $entry['name_short']; |
39 |
|
|
$name_long = $entry['name_long']; |
40 |
|
|
$flags = $entry['flags']; |
41 |
|
|
|
42 |
|
|
array_push($this->meta_names_list, $name_long); |
43 |
|
|
|
44 |
|
|
if (stristr($flags, 'i')) { |
45 |
|
|
$this->meta_input2main_map[$name_short] = $name_long; |
46 |
|
|
} |
47 |
|
|
if (stristr($flags, 'o')) { |
48 |
|
|
$this->meta_main2output_map[$name_long] = $name_short; |
49 |
|
|
} |
50 |
|
|
if (stristr($flags, 'p')) { |
51 |
|
|
$this->meta_persistent_lookup[$name_long] = 1; |
52 |
|
|
} else { |
53 |
|
|
$this->meta_persistent_lookup[$name_long] = 0; |
54 |
|
|
} |
55 |
|
|
|
56 |
|
|
next($this->metadata_arguments); |
57 |
|
|
|
58 |
|
|
} |
59 |
|
|
|
60 |
|
|
// initialize information clusters from "Site" |
61 |
|
|
global $site; |
62 |
|
|
($this->ic_store = $site->getInformationCluster('tracking_store')) || trigger_error("could not load InformationCluster", E_USER_ERROR); |
63 |
|
|
|
64 |
|
|
// load persistent state |
65 |
|
|
$this->_persistency_load(); |
66 |
|
|
|
67 |
|
|
} |
68 |
|
|
|
69 |
|
|
// ----------------------------------------------------------- |
70 |
|
|
function _getVarname($name) { |
71 |
|
|
|
72 |
|
|
// if we know the variable, ... |
73 |
|
|
if (in_array($name, $this->meta_names_list)) { |
74 |
|
|
// ... we try to get it from namespace "main", ... |
75 |
|
|
$varname = '$this->args_main[\'main\']' . NameSpaceVarname2PhpVarnameHashPart($name); |
76 |
|
|
} else { |
77 |
|
|
// ... else we assume the main namespace (root) |
78 |
|
|
$varname = '$this->args_main' . NameSpaceVarname2PhpVarnameHashPart($name); |
79 |
|
|
} |
80 |
|
|
|
81 |
|
|
// return varname |
82 |
|
|
return $varname; |
83 |
|
|
} |
84 |
|
|
|
85 |
|
|
// ----------------------------------------------------------- |
86 |
|
|
function getAll() { |
87 |
|
|
return $this->args_main; |
88 |
|
|
} |
89 |
|
|
|
90 |
|
|
// ----------------------------------------------------------- |
91 |
|
|
function get($name) { |
92 |
|
|
$retval = ""; |
93 |
|
|
|
94 |
|
|
$varname = $this->_getVarname($name); |
95 |
|
|
$evstring = "if (isset($varname)) { return $varname; }"; |
96 |
|
|
$retval = eval($evstring); |
97 |
|
|
|
98 |
|
|
return $retval; |
99 |
|
|
} |
100 |
|
|
|
101 |
|
|
// ----------------------------------------------------------- |
102 |
|
|
function set($name, $value) { |
103 |
|
|
$varname = $this->_getVarname($name); |
104 |
|
|
$evstring = $varname . ' = $value;'; |
105 |
|
|
$retval = eval($evstring); |
106 |
|
|
$this->_persistency_save(); |
107 |
|
|
} |
108 |
|
|
|
109 |
|
|
// ----------------------------------------------------------- |
110 |
|
|
function unsetVar($name) { |
111 |
|
|
$varname = $this->_getVarname($name); |
112 |
|
|
$evstring = "if (isset($varname)) { unset($varname); }"; |
113 |
|
|
$retval = eval($evstring); |
114 |
|
|
$this->_persistency_save(); |
115 |
|
|
} |
116 |
|
|
|
117 |
|
|
// ----------------------------------------------------------- |
118 |
|
|
function clear() { |
119 |
|
|
$this->args_main = array(); |
120 |
|
|
$this->_persistency_save(); |
121 |
|
|
} |
122 |
|
|
|
123 |
|
|
|
124 |
|
|
|
125 |
|
|
// ------------------------------------------------------------------------------------------------ |
126 |
|
|
// collect all input-arguments "coming in" via GETs, POSTs or maybe other origins |
127 |
|
|
function collectInputArguments() { |
128 |
|
|
|
129 |
|
|
// merge together values from GET- or POST-requests |
130 |
|
|
global $HTTP_GET_VARS, $HTTP_POST_VARS; |
131 |
|
|
$request_data_arr = array_merge($HTTP_GET_VARS, $HTTP_POST_VARS); |
132 |
|
|
|
133 |
|
|
// TODO: |
134 |
|
|
// - kill all invalid arguments |
135 |
|
|
// - prevent hacker-attacks(!), (e.g. POST-floods) |
136 |
|
|
|
137 |
|
|
// do our work |
138 |
|
|
$this->_storeInputArguments($request_data_arr); |
139 |
|
|
$this->_processInputArguments(); |
140 |
|
|
$this->_processCallbackDomains(); |
141 |
|
|
$this->_persistency_save(); |
142 |
|
|
} |
143 |
|
|
|
144 |
|
|
// ------------------------------------------------------------------------------------------------ |
145 |
|
|
// store input-arguments |
146 |
|
|
function _storeInputArguments($args) { |
147 |
|
|
$this->args_input = $args; |
148 |
|
|
} |
149 |
|
|
|
150 |
|
|
// ------------------------------------------------------------------------------------------------ |
151 |
|
|
// translate valid input-arguments to main-arguments |
152 |
|
|
function _processInputArguments() { |
153 |
|
|
|
154 |
|
|
reset($this->meta_input2main_map); |
155 |
|
|
while( list($name_short, $name_long) = each($this->meta_input2main_map) ) { |
156 |
|
|
|
157 |
|
|
if (isset($this->args_input[$name_short])) { |
158 |
|
|
// write value to "main"-namespace of "args_main" |
159 |
|
|
$this->args_main['main'][$name_long] = $this->args_input[$name_short]; |
160 |
|
|
} |
161 |
|
|
|
162 |
|
|
} |
163 |
|
|
|
164 |
|
|
} |
165 |
|
|
|
166 |
|
|
// ------------------------------------------------------------------------------------------------ |
167 |
|
|
// process all registered callback-domains |
168 |
|
|
function _processCallbackDomains() { |
169 |
|
|
while (list($name_callbackdomain, $callback_list) = each($this->metadata_callbacks)) { |
170 |
|
|
// check if "$name_callbackdomain" exists as namespace |
171 |
|
|
$namespace = $name_callbackdomain; |
172 |
|
|
if (isset($this->args_main[$namespace])) { |
173 |
|
|
$this->_processCallbackList($namespace, $callback_list); |
174 |
|
|
} |
175 |
|
|
} |
176 |
|
|
} |
177 |
|
|
|
178 |
|
|
// ------------------------------------------------------------------------------------------------ |
179 |
|
|
// process a specified callback-domain |
180 |
|
|
function _processCallbackList($namespace, $callback_list = array()) { |
181 |
|
|
while (list($name_callback, $callback) = each($callback_list)) { |
182 |
|
|
// check if "$name_callback" exists as entry in given namespace |
183 |
|
|
$name_entry = $name_callback; |
184 |
|
|
if (isset($this->args_main[$namespace][$name_entry])) { |
185 |
|
|
$callbackdata = $this->args_main[$namespace][$name_entry]; |
186 |
|
|
$this->_processCallback($callback, $callbackdata); |
187 |
|
|
} |
188 |
|
|
} |
189 |
|
|
} |
190 |
|
|
|
191 |
|
|
// ------------------------------------------------------------------------------------------------ |
192 |
|
|
// process a callback |
193 |
|
|
function _processCallback($callback = array(), $data) { |
194 |
|
|
$func_name = ''; |
195 |
|
|
isset($callback['func_name']) && ($func_name = $callback['func_name']); |
196 |
|
|
if ($func_name) { |
197 |
|
|
call_user_func($func_name, $data); |
198 |
|
|
} |
199 |
|
|
} |
200 |
|
|
|
201 |
|
|
|
202 |
|
|
// ------------------------------------------------------------------------------------------------ |
203 |
|
|
// return valid output-arguments from main-arguments and state |
204 |
|
|
function getOutputArguments($args_additional) { |
205 |
|
|
|
206 |
|
|
// TODO: merge! |
207 |
|
|
// TODO: implement handling for "session not available - use querystring for state" here |
208 |
|
|
|
209 |
|
|
// get all arguments from "main"-namespace of "args_main" |
210 |
|
|
//$args_process = $this->args_main['main']; |
211 |
|
|
$args_process = array(); |
212 |
|
|
|
213 |
|
|
// merge these args with additional-args |
214 |
|
|
while( list($key, $value) = each($args_additional) ) { |
215 |
|
|
$args_process[$key] = $value; |
216 |
|
|
} |
217 |
|
|
|
218 |
|
|
// filter args just valid for output |
219 |
|
|
$retval = array(); |
220 |
|
|
reset($this->meta_main2output_map); |
221 |
|
|
while( list($name_long, $name_short) = each($this->meta_main2output_map) ) { |
222 |
|
|
if (isset($args_process[$name_long])) { |
223 |
|
|
//$retval[$this->meta_main2output_map[$key]] = $value; |
224 |
|
|
$retval[$name_short] = $args_process[$name_long]; |
225 |
|
|
} |
226 |
|
|
} |
227 |
|
|
return $retval; |
228 |
|
|
} |
229 |
|
|
|
230 |
|
|
// ------------------------------------------------------------------------------------------------ |
231 |
|
|
function _createOutputArguments() { |
232 |
|
|
} |
233 |
|
|
|
234 |
|
|
// ------------------------------------------------------------------------------------------------ |
235 |
|
|
function _persistency_load() { |
236 |
|
|
// TODO: merge! |
237 |
|
|
$this->args_main = $this->ic_store->load(); |
238 |
|
|
if (!$this->args_main) { $this->args_main = array(); } |
239 |
|
|
} |
240 |
|
|
|
241 |
|
|
// ------------------------------------------------------------------------------------------------ |
242 |
|
|
function _persistency_save() { |
243 |
|
|
|
244 |
|
|
// get "$this->args_main", ... |
245 |
|
|
$args_persistent = $this->args_main; |
246 |
|
|
|
247 |
|
|
// ... remove all elements from "main"-namespace which have the persistency-flag cleared/not set ... |
248 |
|
|
if (isset($args_persistent['main'])) { |
249 |
|
|
while(list($name_long, $value) = each($args_persistent['main'])) { |
250 |
|
|
//print "name_long: " . $name_long . "<br>"; |
251 |
|
|
if ( (isset($this->meta_persistent_lookup[$name_long])) && !($this->meta_persistent_lookup[$name_long]) ) { |
252 |
|
|
//print "unset(args_persistent['main'][$name_long])<br>"; |
253 |
|
|
unset($args_persistent['main'][$name_long]); |
254 |
|
|
} |
255 |
|
|
} |
256 |
|
|
} |
257 |
|
|
|
258 |
|
|
// ... and save the rest |
259 |
|
|
$this->ic_store->save($args_persistent); |
260 |
|
|
|
261 |
|
|
} |
262 |
|
|
|
263 |
|
|
|
264 |
|
|
// ------------------------------------------------------------------------------------------------ |
265 |
|
|
function dump() { |
266 |
|
|
print $this->dump_get(); |
267 |
|
|
} |
268 |
|
|
function dump_get() { |
269 |
|
|
return dumpVar_get($this->args_main, 'content of "$tracking->state->args_main"', 'html'); |
270 |
|
|
} |
271 |
|
|
|
272 |
|
|
|
273 |
|
|
} |
274 |
|
|
|
275 |
|
|
?> |