Context Navigation

rest.py @ 1503:232940f4bcd5

Revision 1503:232940f4bcd5, 112.3 kB (checked in by Fritz, 6 months ago)
REST : get ip:port values from ~/domogik.cfg and update domogik.cfg exampel
Property exe set to ``*

Line
1	#!/usr/bin/python
2	# -- coding: utf-8 --
3
4	""" This file is part of B{Domogik} project (U{http://www.domogik.org}).
5
6	License
7	=======
8
9	B{Domogik} is free software: you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation, either version 3 of the License, or
12	(at your option) any later version.
13
14	B{Domogik} is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.
18
19	You should have received a copy of the GNU General Public License
20	along with Domogik. If not, see U{http://www.gnu.org/licenses}.
21
22	Module purpose
23	==============
24
25	REST support for Domogik project
26
27	Implements
28	==========
29
30	TODO when finished ;)
31
32
33
34	@author: Friz <fritz.smh@gmail.com>
35	@copyright: (C) 2007-2009 Domogik project
36	@license: GPL(v3)
37	@organization: Domogik
38	"""
39	from domogik.xpl.lib.xplconnector import Listener
40	from domogik.xpl.common.xplmessage import XplMessage
41	from domogik.xpl.lib.module import xPLModule
42	from domogik.common import logger
43	from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
44	from domogik.common.database import DbHelper
45	from domogik.common.configloader import Loader
46	from xml.dom import minidom
47	import time
48	import urllib
49	import sys
50	import locale
51	from socket import gethostname
52	from Queue import *
53	from domogik.xpl.lib.queryconfig import Query
54	from domogik.xpl.lib.module import xPLResult
55	import re
56	import traceback
57	import datetime
58
59
60
61
62
63	QUEUE_TIMEOUT = 10
64	QUEUE_SIZE = 10
65	QUEUE_LIFE_EXPECTANCY = 3
66
67
68
69	################################################################################
70	class Rest(xPLModule):
71	""" REST Server
72	- create a HTTP server
73	- process REST requests
74	"""
75
76
77	def __init__(self, server_ip, server_port):
78	""" Initiate DbHelper, Logs and config
79	Then, start HTTP server and give it initialized data
80	@param server_ip : ip of HTTP server
81	@param server_port : port of HTTP server
82	"""
83	xPLModule.__init__(self, name = 'rest')
84
85	# logging initialization
86	log = logger.Logger('REST')
87	self._log = log.get_logger()
88	self._log.info("Rest Server initialisation...")
89	self._log.debug("locale : %s %s" % locale.getdefaultlocale())
90	# DB Helper
91	self._db = DbHelper()
92
93	### Config
94
95	# directory data in ~/.domogik.cfg
96	cfg = Loader('domogik')
97	config = cfg.load()
98	conf = dict(config[1])
99	self._xml_directory = "%s/share/domogik/rest/" % conf['custom_prefix']
100
101	# HTTP server ip and port
102	try:
103	cfg_rest = Loader('rest')
104	config_rest = cfg_rest.load()
105	conf_rest = dict(config_rest[1])
106	self.server_ip = conf_rest['rest_server_ip']
107	self.server_port = conf_rest['rest_server_port']
108	except KeyError:
109	# default parameters
110	self.server_ip = server_ip
111	self.server_port = server_port
112
113
114	# Queues config
115	self._config = Query(self._myxpl)
116	res = xPLResult()
117	self._config.query('rest', 'queue-timeout', res)
118	self._queue_timeout = res.get_value()['queue-timeout']
119	if self._queue_timeout == "None":
120	self._queue_timeout = QUEUE_TIMEOUT
121	self._queue_timeout = float(self._queue_timeout)
122	self._config = Query(self._myxpl)
123	res = xPLResult()
124	self._config.query('rest', 'queue-size', res)
125	self._queue_size = res.get_value()['queue-size']
126	if self._queue_size == "None":
127	self._queue_size = QUEUE_SIZE
128	self._queue_size = float(self._queue_size)
129	self._config = Query(self._myxpl)
130	res = xPLResult()
131	self._config.query('rest', 'queue-life-exp', res)
132	self._queue_life_expectancy = res.get_value()['queue-life-exp']
133	if self._queue_life_expectancy == "None":
134	self._queue_life_expectancy = QUEUE_LIFE_EXPECTANCY
135	self._queue_life_expectancy = float(self._queue_life_expectancy)
136
137	# Queues for xPL
138	self._queue_system_list = Queue(self._queue_size)
139	self._queue_system_detail = Queue(self._queue_size)
140	self._queue_system_start = Queue(self._queue_size)
141	self._queue_system_stop = Queue(self._queue_size)
142
143	# define listeners for queues
144	Listener(self._add_to_queue_system_list, self._myxpl, \
145	{'schema': 'domogik.system',
146	'xpltype': 'xpl-trig',
147	'command' : 'list',
148	'host' : gethostname()})
149	Listener(self._add_to_queue_system_detail, self._myxpl, \
150	{'schema': 'domogik.system',
151	'xpltype': 'xpl-trig',
152	'command' : 'detail',
153	'host' : gethostname()})
154	Listener(self._add_to_queue_system_start, self._myxpl, \
155	{'schema': 'domogik.system',
156	'xpltype': 'xpl-trig',
157	'command' : 'start',
158	'host' : gethostname()})
159	Listener(self._add_to_queue_system_stop, self._myxpl, \
160	{'schema': 'domogik.system',
161	'xpltype': 'xpl-trig',
162	'command' : 'stop',
163	'host' : gethostname()})
164
165
166	def _add_to_queue_system_list(self, message):
167	self._put_in_queue(self._queue_system_list, message)
168
169	def _add_to_queue_system_detail(self, message):
170	self._put_in_queue(self._queue_system_detail, message)
171
172	def _add_to_queue_system_start(self, message):
173	self._put_in_queue(self._queue_system_start, message)
174
175	def _add_to_queue_system_stop(self, message):
176	self._put_in_queue(self._queue_system_stop, message)
177
178	def _get_from_queue(self, my_queue, filter = None, nb_rec = 0):
179	""" Get an item from queue (recursive function)
180	Checks are made on :
181	- life expectancy of message
182	- filter given
183	- size of queue
184	If necessary, each item of queue is read.
185	@param my_queue : queue to get data from
186	@param filter : dictionnay of filters. Examples :
187	- {"command" : "start", ...}
188	- {"module" : "wol%", ...} : here "%" indicate that we search for something starting with "wol"
189	@param nb_rec : internal parameter (do not use it for first call). Used to check recursivity VS queue size
190	"""
191	# check if recursivity doesn't exceed queue size
192	if nb_rec > self._queue_size:
193	print "_get_from_queue : number of call exceed queue size (%s) : return None" % self._queue_size
194	# we raise an "Empty" exception because we consider that if we don't find
195	# the good data, it is as if it was "empty"
196	raise Empty
197
198	msg_time, message = my_queue.get(True, self._queue_timeout)
199
200	# if message not too old, we process it
201	if time.time() - msg_time < self._queue_life_expectancy:
202	# no filter defined
203	if filter == None:
204	return message
205
206	# we want to filter data
207	else:
208	keep_data = True
209	for key in filter:
210	# take care of final "%" in order to search data starting by filter[key]
211	if filter[key][-1] == "%":
212	msg_data = str(message.data[key])
213	filter_data = str(filter[key])
214	len_data = len(filter_data) - 1
215	if msg_data[0:len_data] != filter_data[0:-1]:
216	print "Bad data!"
217	keep_data = False
218	# normal search
219	else:
220	if message.data[key] != filter[key]:
221	print "Bad data!"
222	keep_data = False
223
224	# if message is ok for us, return it
225	if keep_data == True:
226	return message
227
228	# else, message get back in queue and get another one
229	else:
230	self._put_in_queue(my_queue, message)
231	return self._get_from_queue(my_queue, filter, nb_rec + 1)
232
233	# if message too old : get an other message
234	else:
235	return self._get_from_queue(my_queue, filter, nb_rec + 1)
236
237	def _put_in_queue(self, my_queue, message):
238	my_queue.put((time.time(), message), True, self._queue_timeout)
239
240
241
242	def start(self):
243	""" Start HTTP Server
244	"""
245	# Start HTTP server
246	server = HTTPServerWithParam((self.server_ip, int(self.server_port)), RestHandler, \
247	handler_params = [self])
248	print 'Start REST server on %s:%s...' % (self.server_ip, self.server_port)
249	server.serve_forever()
250
251
252
253
254	################################################################################
255	class HTTPServerWithParam(HTTPServer):
256	""" Extends HTTPServer to allow send params to the Handler.
257	"""
258
259	def __init__(self, server_address, request_handler_class, \
260	bind_and_activate=True, handler_params = []):
261	HTTPServer.__init__(self, server_address, request_handler_class, \
262	bind_and_activate)
263	self.handler_params = handler_params
264	# dirty issue
265	self.timeout = None
266
267
268
269
270
271
272	################################################################################
273	class RestHandler(BaseHTTPRequestHandler):
274	""" Class/object called for each request to HTTP server
275	Here we will process use GET/POST/OPTION HTTP methods
276	and then create a REST request
277	"""
278
279
280	######
281	# GET/POST/OPTIONS processing
282	######
283
284	def do_GET(self):
285	""" Process GET requests
286	Call directly .do_for_all_methods()
287	"""
288	print "==== GET ============================================"
289	self.do_for_all_methods()
290
291	def do_POST(self):
292	""" Process POST requests
293	Call directly .do_for_all_methods()
294	"""
295	print "==== POST ==========================================="
296	self.do_for_all_methods()
297
298	def do_OPTIONS(self):
299	""" Process OPTIONS requests
300	Call directly .do_for_all_methods()
301	"""
302	print "==== OPTIONS ==========================================="
303	self.do_for_all_methods()
304
305	def do_for_all_methods(self):
306	""" Create an object for each request. This object will process
307	the REST url
308	"""
309
310	# dirty issue to force HTTP/1.1
311	self.protocol_version = 'HTTP/1.1'
312	self.request_version = 'HTTP/1.1'
313
314
315	request = ProcessRequest(self.server.handler_params, self.path, \
316	self.send_http_response_ok, \
317	self.send_http_response_error)
318	request.do_for_all_methods()
319
320
321
322
323	######
324	# HTTP return
325	######
326
327	def send_http_response_ok(self, data = ""):
328	""" Send to browser a HTTP 200 responde
329	200 is the code for "no problem"
330	Send also json data
331	@param data : json data to display
332	"""
333	self.send_response(200)
334	self.send_header('Content-type', 'application/json')
335	self.send_header('Expires', '-1')
336	self.send_header('Cache-control', 'no-cache')
337	self.send_header('Content-Length', len(data.encode("utf-8")))
338	self.end_headers()
339	if data:
340	self.wfile.write(data.encode("utf-8"))
341
342
343	def send_http_response_error(self, err_code, err_msg, jsonp, jsonp_cb):
344	""" Send to browser a HTTP 200 responde
345	200 is the code for "no problem" but we send error status in
346	json data, so we use 200 code
347	Send also json data
348	@param err_code : error code. 999 : generic error
349	@param err_msg : error description
350	@param jsonp : True/False. True : use jsonp format
351	@param jsonp_cb : if jsonp is True, name of callback to use
352	in jsonp format
353	"""
354	self.send_response(200)
355	self.send_header('Content-type', 'text/html')
356	self.end_headers()
357	json_data = JSonHelper("ERROR", err_code, err_msg)
358	json_data.set_jsonp(jsonp, jsonp_cb)
359	self.wfile.write(json_data.get())
360
361
362
363
364	################################################################################
365	class ProcessRequest():
366	""" Class for processing a request
367	"""
368
369	######
370	# init namespace
371	######
372
373
374	def __init__(self, handler_params, path, cb_send_http_response_ok, \
375	cb_send_http_response_error):
376	""" Create shorter access : self.server.handler_params[0].* => self.*
377	First processing on url given
378	@param handler_params : parameters given to HTTPHandler
379	@param path : path given to HTTP server : /base/area/... for example
380	@param cb_send_http_response_ok : callback for function
381	REST.send_http_response_ok
382	@param cb_send_http_response_error : callback for function
383	REST.send_http_response_error
384	"""
385
386	self.handler_params = handler_params
387	self.path = path
388	self.send_http_response_ok = cb_send_http_response_ok
389	self.send_http_response_error = cb_send_http_response_error
390
391	# shorter access
392	self._db = self.handler_params[0]._db
393	self._myxpl = self.handler_params[0]._myxpl
394	self._log = self.handler_params[0]._log
395	self._xml_directory = self.handler_params[0]._xml_directory
396
397	self._queue_timeout = self.handler_params[0]._queue_timeout
398	self._queue_size = self.handler_params[0]._queue_size
399	self._queue_life_expectancy = self.handler_params[0]._queue_life_expectancy
400
401	self._get_from_queue = self.handler_params[0]._get_from_queue
402	self._put_in_queue = self.handler_params[0]._put_in_queue
403
404	self._queue_system_list = self.handler_params[0]._queue_system_list
405	self._queue_system_detail = self.handler_params[0]._queue_system_detail
406	self._queue_system_start = self.handler_params[0]._queue_system_start
407	self._queue_system_stop = self.handler_params[0]._queue_system_stop
408
409	# global init
410	self.jsonp = False
411	self.jsonp_cb = ""
412
413	# url processing
414	print type(self.path).__name__
415	print self.path
416	#self.path = str(urllib.unquote(self.path))
417	self.path = urllib.unquote(unicode(self.path))
418	print type(self.path).__name__
419	print self.path
420	#self.path = unicode(self.path, "utf-8")
421
422	tab_url = self.path.split("?")
423	self.path = tab_url[0]
424	if len(tab_url) > 1:
425	self.parameters = tab_url[1]
426	self._parse_options()
427
428	if self.path[-1:] == "/":
429	self.path = self.path[0:len(self.path)-1]
430	print "PATH : " + self.path
431	tab_path = self.path.split("/")
432
433	# Get type of request : /command, /xpl-cmnd, /base, etc
434	if len(tab_path) < 2:
435	self.rest_type = None
436	# Display an information json if no request done in do_for_all_methods
437	return
438	self.rest_type = tab_path[1].lower()
439	if len(tab_path) > 2:
440	self.rest_request = tab_path[2:]
441	else:
442	self.rest_request = []
443	print "TYPE : " + self.rest_type
444	print "Request : " + str(self.rest_request)
445
446
447
448
449
450
451
452
453
454	def do_for_all_methods(self):
455	""" Process request
456	This function call appropriate functions for processing path
457	"""
458	if self.rest_type == "command":
459	self.rest_command()
460	elif self.rest_type == "xpl-cmnd":
461	self.rest_xpl_cmnd()
462	elif self.rest_type == "base":
463	self.rest_base()
464	elif self.rest_type == "module":
465	self.rest_module()
466	elif self.rest_type == "account":
467	self.rest_account()
468	elif self.rest_type == None:
469	self.rest_status()
470	else:
471	self.send_http_response_error(999, "Type [" + str(self.rest_type) + \
472	"] is not supported", \
473	self.jsonp, self.jsonp_cb)
474
475
476	def _parse_options(self):
477	""" Process parameters : ...?param1=val1&param2=val2&....
478	"""
479
480	# for each debug option
481	for opt in self.parameters.split("&"):
482	print "OPT :" + opt
483	tab_opt = opt.split("=")
484	opt_key = tab_opt[0]
485	if len(tab_opt) > 1:
486	opt_value = tab_opt[1]
487	else:
488	opt_value = None
489
490	# call json specific options
491	if opt_key == "callback" and opt_value != None:
492	self.jsonp = True
493	self.jsonp_cb = opt_value
494
495	# call debug functions
496	elif opt_key == "debug-sleep" and opt_value != None:
497	self._debug_sleep(opt_value)
498
499
500
501	def _debug_sleep(self, duration):
502	""" Sleep process for 15 seconds
503	"""
504	print "DEBUG : start sleeping for " + str(duration)
505	time.sleep(float(duration))
506	print "DEBUG : end sleeping"
507
508
509
510
511
512	######
513	# / processing
514	######
515
516	def rest_status(self):
517	json_data = JSonHelper("OK", 0, "REST server available")
518	json_data.set_data_type("rest")
519	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
520	# TODO : get version by a better way
521	json_data.add_data(("Version : 0.1.x", "Status : UP"))
522	self.send_http_response_ok(json_data.get())
523
524
525
526
527
528
529
530	######
531	# /command processing
532	######
533
534	def rest_command(self):
535	""" Process /command url
536	- decode request
537	- call a xml parser for the technology (self.rest_request[0])
538	- send appropriate xPL message on network
539	"""
540	print "Call rest_command"
541
542	# parse data in URL
543	if len(self.rest_request) >= 3:
544	techno = self.rest_request[0]
545	address = self.rest_request[1]
546	order = self.rest_request[2]
547	if len(self.rest_request) > 3:
548	others = self.rest_request[3:]
549	else:
550	others = None
551	else:
552	json_data = JSonHelper("ERROR", 999, "Url too short for /command")
553	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
554	self.send_http_response_ok(json_data.get())
555	return
556	print "Techno : %s" % techno
557	print "Address : %s" % address
558	print "Order : %s" % order
559	print "Others : %s" % str(others)
560
561	# open xml file
562	xml_file = "%s/%s.xml" % (self._xml_directory, techno)
563	#xml_file = "%s/%s.xml" % ("../xml/", techno)
564	# process xml
565	message = self._parse_xml(xml_file, techno, address, order, others)
566	if message == None:
567	return
568
569	print "Send message : %s" % message
570	self._myxpl.send(message)
571
572	# REST processing finished and OK
573	json_data = JSonHelper("OK")
574	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
575	self.send_http_response_ok(json_data.get())
576
577
578
579
580
581
582
583	def _parse_xml(self, xml_file, techno, address, order, others):
584	""" xml parser for a technology file
585	Generation of a xPL message by processing REST request and XML file
586	@param xml_file : xml file defining how to construct message
587	@param techno : technology (x10, etc)
588	@param address : address of device
589	@param order : order to send
590	@param others : other parameters
591	@return None if a problem occurs or a xPL message if ok
592	"""
593	try:
594	xml_doc = minidom.parse(xml_file)
595	except:
596	json_data = JSonHelper("ERROR", 999, \
597	"Error while reading xml file : " + xml_file)
598	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
599	self.send_http_response_ok(json_data.get())
600	return None
601
602	mapping = xml_doc.documentElement
603	if mapping.getElementsByTagName("technology")[0].attributes.get("name").value != techno:
604	self.send_http_response_error(999, "'technology' attribute must be the same as file name !", \
605	self.jsonp, self.jsonp_cb)
606	return
607
608	#Schema
609	schema = mapping.getElementsByTagName("schema")[0].firstChild.nodeValue
610
611	#Device key name
612	device = mapping.getElementsByTagName("device")[0]
613	if device.getElementsByTagName("key") != []:
614	device_address_key = device.getElementsByTagName("key")[0].firstChild.nodeValue
615	else:
616	device_address_key = None
617
618	#Orders
619	orders = mapping.getElementsByTagName("orders")[0]
620	order_key = orders.getElementsByTagName("key")[0].firstChild.nodeValue
621
622	#Get the good order bloc :
623	the_order = None
624	for an_order in orders.getElementsByTagName("order"):
625	if an_order.getElementsByTagName("name")[0].firstChild.nodeValue == order:
626	the_order = an_order
627	if the_order == None:
628	self.send_http_response_error(999, "Order can't be found", self.jsonp, self.jsonp_cb)
629	return
630
631	#Parse the order bloc
632	order_value = the_order.getElementsByTagName("value")[0].firstChild.nodeValue
633	#mandatory parameters
634	mandatory_parameters_value = {}
635	optional_parameters_value = {}
636	if the_order.getElementsByTagName("parameters")[0].hasChildNodes():
637	mandatory_parameters = the_order.getElementsByTagName("parameters")[0].getElementsByTagName("mandatory")[0]
638	count_mandatory_parameters = len(mandatory_parameters.getElementsByTagName("parameter"))
639	mandatory_parameters_from_url = others[3:3+count_mandatory_parameters]
640	for mandatory_param in mandatory_parameters.getElementsByTagName("parameter"):
641	key = mandatory_param.attributes.get("key").value
642	value = mandatory_parameters_from_url[int(mandatory_param.attributes.get("location").value) - 1]
643	mandatory_parameters_value[key] = value
644	#optional parameters
645	if the_order.getElementsByTagName("parameters")[0].getElementsByTagName("optional") != []:
646	optional_parameters = the_order.getElementsByTagName( \
647	"parameters")[0].getElementsByTagName("optional")[0]
648	for opt_param in optional_parameters.getElementsByTagName("parameter"):
649	ind = others.index(opt_param.getElementsByTagName("name")[0])
650	optional_parameters_value[url[ind]] = url[ind + 1]
651
652	return self._forge_msg(schema, device_address_key, address, order_key, order_value, \
653	mandatory_parameters_value, optional_parameters_value)
654
655
656
657
658
659	def _forge_msg(self, schema, device_address_key, address, order_key, order_value, \
660	mandatory_parameters_value, optional_parameters_value):
661	""" forge xpl message
662	@param schema : xpl schema
663	@param device_address_key : key for address in xpl message
664	@param address : value for address in xpl message
665	@param order_key : key for order in xpl message
666	@param order_value : value for order in xpl message
667	@param mandatory_parameters_value : mandatory params
668	@param optional_parameters_value : optionnal params
669	@return xPL message
670	"""
671	msg = """xpl-cmnd
672	{
673	hop=1
674	source=rest
675	target=*
676	}
677	%s
678	{
679	%s=%s
680	%s=%s
681	""" % (schema, device_address_key, address, order_key, order_value)
682	for m_param in mandatory_parameters_value.keys():
683	msg += "%s=%s\n" % (m_param, mandatory_parameters_value[m_param])
684	for o_param in optional_parameters_value.keys():
685	msg += "%s=%s\n" % (o_param, optional_parameters_value[o_param])
686	msg += "}"
687	return msg
688
689
690
691
692
693
694
695
696
697	######
698	# /xpl-cmnd processing
699	######
700
701	def rest_xpl_cmnd(self):
702	""" Send xPL message given in REST url
703	- Decode and check URL
704	- Send message
705	"""
706
707	print "Call rest_xpl_cmnd"
708	if len(self.rest_request) == 0:
709	self.send_http_response_error(999, "Schema not given", self.jsonp, self.jsonp_cb)
710	return
711	self.xpl_cmnd_schema = self.rest_request[0]
712
713	# Init xpl message
714	message = XplMessage()
715	message.set_type('xpl-cmnd')
716	if self.xpl_target.lower() != "all":
717	message.set_header(target=self.xpl_target)
718	message.set_schema(self.xpl_cmnd_schema)
719
720	iii = 0
721	for val in self.rest_request:
722	# We pass target and schema
723	if iii > 0:
724	# Parameter
725	if iii % 2 == 1:
726	param = val
727	# Value
728	else:
729	value = val
730	message.add_data({param : value})
731	iii = iii + 1
732
733	# no parameters
734	if iii == 1:
735	self.send_http_response_error(999, "No parameters specified", self.jsonp, self.jsonp_cb)
736	return
737	# no value for last parameter
738	if iii % 2 == 0:
739	self.send_http_response_error(999, "Value missing for last parameter", self.jsonp, self.jsonp_cb)
740	return
741
742	print "Send message : %s" % message
743	self._myxpl.send(message)
744
745	# REST processing finished and OK
746	json_data = JSonHelper("OK")
747	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
748	self.send_http_response_ok(json_data.get())
749
750
751
752
753	######
754	# /base processing
755	######
756
757	def rest_base(self):
758	""" Get data in database
759	- Decode and check URL format
760	- call the good fonction to get data from database
761	"""
762	print "Call rest_base_get"
763	# parameters initialisation
764	self.parameters = {}
765
766	# Check url length
767	if len(self.rest_request) < 2:
768	self.send_http_response_error(999, "Url too short", self.jsonp, self.jsonp_cb)
769	return
770
771	### area #####################################
772	if self.rest_request[0] == "area":
773
774	### list
775	if self.rest_request[1] == "list":
776	if len(self.rest_request) == 2:
777	self._rest_base_area_list()
778	elif len(self.rest_request) == 3:
779	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
780	self.jsonp, self.jsonp_cb)
781	else:
782	if self.rest_request[2] == "by-id":
783	self._rest_base_area_list(area_id=self.rest_request[3])
784	else:
785	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
786	self.jsonp, self.jsonp_cb)
787	elif self.rest_request[1] == "list-with-rooms":
788	if len(self.rest_request) == 2:
789	self._rest_base_area_list_with_rooms()
790	else:
791	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
792	self.jsonp, self.jsonp_cb)
793
794
795	### add
796	elif self.rest_request[1] == "add":
797	offset = 2
798	if self.set_parameters(offset):
799	self._rest_base_area_add()
800	else:
801	self.send_http_response_error(999, "Error in parameters", \
802	self.jsonp, self.jsonp_cb)
803
804	### update
805	elif self.rest_request[1] == "update":
806	offset = 2
807	if self.set_parameters(offset):
808	self._rest_base_area_update()
809	else:
810	self.send_http_response_error(999, "Error in parameters", \
811	self.jsonp, self.jsonp_cb)
812
813	### del
814	elif self.rest_request[1] == "del":
815	if len(self.rest_request) == 3:
816	self._rest_base_area_del(area_id=self.rest_request[2])
817	else:
818	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
819	self.jsonp, self.jsonp_cb)
820
821	### others
822	else:
823	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
824	self.jsonp, self.jsonp_cb)
825	return
826
827	### room #####################################
828	elif self.rest_request[0] == "room":
829
830	### list
831	if self.rest_request[1] == "list":
832	if len(self.rest_request) == 2:
833	self._rest_base_room_list()
834	elif len(self.rest_request) == 3:
835	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
836	self.jsonp, self.jsonp_cb)
837	else:
838	if self.rest_request[2] == "by-id":
839	self._rest_base_room_list(room_id=self.rest_request[3])
840	elif self.rest_request[2] == "by-area":
841	self._rest_base_room_list(area_id=self.rest_request[3])
842	else:
843	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
844	self.jsonp, self.jsonp_cb)
845	elif self.rest_request[1] == "list-with-devices":
846	if len(self.rest_request) == 2:
847	self._rest_base_room_list_with_devices()
848	else:
849	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
850	self.jsonp, self.jsonp_cb)
851
852
853	### add
854	elif self.rest_request[1] == "add":
855	offset = 2
856	if self.set_parameters(offset):
857	self._rest_base_room_add()
858	else:
859	self.send_http_response_error(999, "Error in parameters", \
860	self.jsonp, self.jsonp_cb)
861
862	### update
863	elif self.rest_request[1] == "update":
864	offset = 2
865	if self.set_parameters(offset):
866	self._rest_base_room_update()
867	else:
868	self.send_http_response_error(999, "Error in parameters", \
869	self.jsonp, self.jsonp_cb)
870
871	### del
872	elif self.rest_request[1] == "del":
873	if len(self.rest_request) == 3:
874	self._rest_base_room_del(room_id=self.rest_request[2])
875	else:
876	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
877	self.jsonp, self.jsonp_cb)
878
879	### others
880	else:
881	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
882	self.jsonp, self.jsonp_cb)
883	return
884
885	### ui_config ################################
886	elif self.rest_request[0] == "ui_config":
887
888	### list
889	if self.rest_request[1] == "list":
890	if len(self.rest_request) == 2:
891	self._rest_base_ui_item_config_list()
892	elif len(self.rest_request) >= 3 and len(self.rest_request) <=4:
893	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
894	self.jsonp, self.jsonp_cb)
895	elif len(self.rest_request) == 5:
896	if self.rest_request[2] == "by-key":
897	self._rest_base_ui_item_config_list(name = self.rest_request[3], key = self.rest_request[4])
898	elif self.rest_request[2] == "by-reference":
899	self._rest_base_ui_item_config_list(name = self.rest_request[3], reference = self.rest_request[4])
900	else:
901	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
902	self.jsonp, self.jsonp_cb)
903	elif len(self.rest_request) == 6:
904	if self.rest_request[2] == "by-element":
905	self._rest_base_ui_item_config_list(name = self.rest_request[3], reference = self.rest_request[4], key = self.rest_request[5])
906	else:
907	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
908	self.jsonp, self.jsonp_cb)
909	else:
910	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
911	self.jsonp, self.jsonp_cb)
912
913	### set
914	elif self.rest_request[1] == "set":
915	offset = 2
916	if self.set_parameters(offset):
917	self._rest_base_ui_item_config_set()
918	else:
919	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
920
921	### delete
922	elif self.rest_request[1] == "del":
923	offset = 2
924	if self.set_parameters(offset):
925	self._rest_base_ui_item_config_del()
926	else:
927	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
928
929	### others
930	else:
931	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
932	self.jsonp, self.jsonp_cb)
933	return
934
935
936	### device_usage #############################
937	elif self.rest_request[0] == "device_usage":
938
939	### list
940	if self.rest_request[1] == "list":
941	if len(self.rest_request) == 2:
942	self._rest_base_device_usage_list()
943	elif len(self.rest_request) == 3:
944	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
945	self.jsonp, self.jsonp_cb)
946	else:
947	if self.rest_request[2] == "by-name":
948	self._rest_base_device_usage_list(self.rest_request[3])
949	else:
950	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
951	self.jsonp, self.jsonp_cb)
952
953	### add
954	elif self.rest_request[1] == "add":
955	offset = 2
956	if self.set_parameters(offset):
957	self._rest_base_device_usage_add()
958	else:
959	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
960
961	### update
962	elif self.rest_request[1] == "update":
963	offset = 2
964	if self.set_parameters(offset):
965	self._rest_base_device_usage_update()
966	else:
967	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
968
969	### del
970	elif self.rest_request[1] == "del":
971	if len(self.rest_request) == 3:
972	self._rest_base_device_usage_del(du_id=self.rest_request[2])
973	else:
974	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
975	self.jsonp, self.jsonp_cb)
976
977	### others
978	else:
979	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
980	self.jsonp, self.jsonp_cb)
981	return
982
983
984	### device_type ##############################
985	elif self.rest_request[0] == "device_type":
986
987	### list
988	if self.rest_request[1] == "list":
989	if len(self.rest_request) == 2:
990	self._rest_base_device_type_list()
991	else:
992	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
993	self.jsonp, self.jsonp_cb)
994
995	### add
996	elif self.rest_request[1] == "add":
997	offset = 2
998	if self.set_parameters(offset):
999	self._rest_base_area_add()
1000	else:
1001	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1002
1003	### update
1004	elif self.rest_request[1] == "update":
1005	offset = 2
1006	if self.set_parameters(offset):
1007	self._rest_base_area_update()
1008	else:
1009	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1010
1011	### del
1012	elif self.rest_request[1] == "del":
1013	if len(self.rest_request) == 3:
1014	self._rest_base_area_del(dt_id=self.rest_request[2])
1015	else:
1016	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1017	self.jsonp, self.jsonp_cb)
1018
1019	### others
1020	else:
1021	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
1022	self.jsonp, self.jsonp_cb)
1023	return
1024
1025	### sensor reference #########################
1026	elif self.rest_request[0] == "sensor_reference":
1027
1028	### list
1029	if self.rest_request[1] == "list":
1030	if len(self.rest_request) == 2:
1031	self._rest_base_sensor_reference_list()
1032	elif len(self.rest_request) == 3:
1033	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1034	self.jsonp, self.jsonp_cb)
1035	else:
1036	if self.rest_request[2] == "by-type_id":
1037	self._rest_base_sensor_reference_list(type_id=self.rest_request[3])
1038	else:
1039	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1040	self.jsonp, self.jsonp_cb)
1041
1042	### add
1043	elif self.rest_request[1] == "add_OFF":
1044	offset = 2
1045	if self.set_parameters(offset):
1046	self._rest_base_sensor_reference_add()
1047	else:
1048	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1049
1050	### update
1051	elif self.rest_request[1] == "update_OFF":
1052	offset = 2
1053	if self.set_parameters(offset):
1054	self._rest_base_sensor_reference_update()
1055	else:
1056	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1057
1058	### del
1059	elif self.rest_request[1] == "del_OFF":
1060	if len(self.rest_request) == 3:
1061	self._rest_base_sensor_reference_del(sr_id=self.rest_request[2])
1062	else:
1063	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1064	self.jsonp, self.jsonp_cb)
1065
1066	### others
1067	else:
1068	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
1069	self.jsonp, self.jsonp_cb)
1070	return
1071
1072
1073	### actuator feature #########################
1074	elif self.rest_request[0] == "actuator_feature":
1075
1076	### list
1077	if self.rest_request[1] == "list":
1078	if len(self.rest_request) == 2:
1079	self._rest_base_actuator_feature_list()
1080	elif len(self.rest_request) == 3:
1081	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1082	self.jsonp, self.jsonp_cb)
1083	else:
1084	if self.rest_request[2] == "by-type_id":
1085	self._rest_base_actuator_feature_list(type_id=self.rest_request[3])
1086	else:
1087	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1088	self.jsonp, self.jsonp_cb)
1089
1090	### add
1091	elif self.rest_request[1] == "add_OFF":
1092	offset = 2
1093	if self.set_parameters(offset):
1094	self._rest_base_actuator_feature_add()
1095	else:
1096	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1097
1098	### update
1099	elif self.rest_request[1] == "update_OFF":
1100	offset = 2
1101	if self.set_parameters(offset):
1102	self._rest_base_actuator_feature_update()
1103	else:
1104	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1105
1106	### del
1107	elif self.rest_request[1] == "del_OFF":
1108	if len(self.rest_request) == 3:
1109	self._rest_base_actuator_feature__del(af_id=self.rest_request[2])
1110	else:
1111	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1112	self.jsonp, self.jsonp_cb)
1113
1114	### others
1115	else:
1116	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
1117	self.jsonp, self.jsonp_cb)
1118	return
1119
1120
1121	### device technology ########################
1122	elif self.rest_request[0] == "device_technology":
1123
1124	### list
1125	if self.rest_request[1] == "list":
1126	if len(self.rest_request) == 2:
1127	self._rest_base_device_technology_list()
1128	elif len(self.rest_request) == 3:
1129	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1130	self.jsonp, self.jsonp_cb)
1131	else:
1132	if self.rest_request[2] == "by-name":
1133	self._rest_base_device_technology_list(name=self.rest_request[3])
1134	else:
1135	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1136	self.jsonp, self.jsonp_cb)
1137
1138	### add
1139	elif self.rest_request[1] == "add":
1140	offset = 2
1141	if self.set_parameters(offset):
1142	self._rest_base_device_technology_add()
1143	else:
1144	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1145
1146	### update
1147	elif self.rest_request[1] == "update":
1148	offset = 2
1149	if self.set_parameters(offset):
1150	self._rest_base_device_technology_update()
1151	else:
1152	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1153
1154	### del
1155	elif self.rest_request[1] == "del":
1156	if len(self.rest_request) == 3:
1157	self._rest_base_device_technology__del(dt_id=self.rest_request[2])
1158	else:
1159	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1160	self.jsonp, self.jsonp_cb)
1161
1162	### others
1163	else:
1164	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
1165	self.jsonp, self.jsonp_cb)
1166	return
1167
1168
1169	### device technology config #################
1170	elif self.rest_request[0] == "device_technology_config":
1171
1172	### list
1173	if self.rest_request[1] == "list":
1174	if len(self.rest_request) == 2:
1175	self._rest_base_device_technology_config_list()
1176	elif len(self.rest_request) == 3 or len(self.rest_request) == 5:
1177	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1178	self.jsonp, self.jsonp_cb)
1179	elif len(self.rest_request) == 4:
1180	if self.rest_request[2] == "by-technology-id":
1181	self._rest_base_device_technology_config_list(technology_id=self.rest_request[3])
1182	elif len(self.rest_request) == 6:
1183	if self.rest_request[2] == "by-technology-id" and self.rest_request[4] == "by-key":
1184	self._rest_base_device_technology_config_list(technology_id = self.rest_request[3], key = self.rest_request[5])
1185	else:
1186	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1187	self.jsonp, self.jsonp_cb)
1188	else:
1189	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1190	self.jsonp, self.jsonp_cb)
1191
1192	### add
1193	elif self.rest_request[1] == "add":
1194	offset = 2
1195	if self.set_parameters(offset):
1196	self._rest_base_device_technology_config_add()
1197	else:
1198	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1199
1200	### update
1201	elif self.rest_request[1] == "update":
1202	offset = 2
1203	if self.set_parameters(offset):
1204	self._rest_base_device_technology_config_update()
1205	else:
1206	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1207
1208	### del
1209	elif self.rest_request[1] == "del":
1210	if len(self.rest_request) == 3:
1211	self._rest_base_device_technology_config_del(tc_id=self.rest_request[2])
1212	else:
1213	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1214	self.jsonp, self.jsonp_cb)
1215
1216	### others
1217	else:
1218	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
1219	self.jsonp, self.jsonp_cb)
1220	return
1221
1222
1223
1224
1225
1226	### device #####################################
1227	elif self.rest_request[0] == "device":
1228	### list
1229	if self.rest_request[1] == "list":
1230	if len(self.rest_request) == 2:
1231	self._rest_base_device_list()
1232	elif len(self.rest_request) == 3:
1233	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1234	self.jsonp, self.jsonp_cb)
1235	else:
1236	if self.rest_request[2] == "by-room":
1237	self._rest_base_device_list(room_id=self.rest_request[3])
1238	else:
1239	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1240	self.jsonp, self.jsonp_cb)
1241
1242
1243	### add
1244	elif self.rest_request[1] == "add":
1245	offset = 2
1246	if self.set_parameters(offset):
1247	self._rest_base_device_add()
1248	else:
1249	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1250
1251	### update
1252	elif self.rest_request[1] == "update":
1253	offset = 2
1254	if self.set_parameters(offset):
1255	self._rest_base_device_update()
1256	else:
1257	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
1258
1259	### del
1260	elif self.rest_request[1] == "del":
1261	if len(self.rest_request) == 3:
1262	self._rest_base_device_del(id=self.rest_request[2])
1263	else:
1264	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
1265	self.jsonp, self.jsonp_cb)
1266
1267	### others
1268	else:
1269	self.send_http_response_error(999, self.rest_request[1] + " not allowed for " + self.rest_request[0], \
1270	self.jsonp, self.jsonp_cb)
1271	return
1272
1273
1274	### others ###################################
1275	else:
1276	self.send_http_response_error(999, self.rest_request[0] + " not allowed", self.jsonp, self.jsonp_cb)
1277	return
1278
1279
1280
1281	def set_parameters(self, offset):
1282	""" define parameters as key => value
1283	@param offset : number of item to pass before getting key/values in REST request
1284	@return value if OK. False if no parameters or missing value
1285	"""
1286	iii = 0
1287	while offset + iii < len(self.rest_request):
1288	key = self.rest_request[offset + iii]
1289	if offset + iii + 1 < len(self.rest_request):
1290	value = self.rest_request[offset + iii + 1]
1291	else:
1292	# wrong number of arguments
1293	return False
1294	# specific process for False
1295	if value == "False":
1296	self.parameters[key] = False
1297	else:
1298	self.parameters[key] = value
1299	iii += 2
1300	# no parameters
1301	if iii == 0:
1302	return False
1303	# ok
1304	else:
1305	return True
1306
1307
1308
1309	def get_parameters(self, name):
1310	""" Getter for parameters. If parameter doesn't exist, return None
1311	@param name : name of parameter to get
1312	@return parameter value or None if parameter doesn't exist
1313	"""
1314	try:
1315	return self.parameters[name]
1316	except KeyError:
1317	return None
1318
1319
1320
1321	def to_date(self, date):
1322	""" Transform YYYYMMDD date in datatime object
1323	@param date : date
1324	"""
1325	if date == None:
1326	return None
1327	year = int(date[0:4])
1328	month = int(date[4:6])
1329	day = int(date[6:8])
1330	my_date = datetime.date(year, month, day)
1331	return my_date
1332
1333
1334
1335
1336
1337	######
1338	# /base/area processing
1339	######
1340
1341	def _rest_base_area_list(self, area_id = None):
1342	""" list areas
1343	@param area_id : id of area
1344	"""
1345	json_data = JSonHelper("OK")
1346	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1347	json_data.set_data_type("area")
1348	if area_id == None:
1349	for area in self._db.list_areas():
1350	json_data.add_data(area)
1351	else:
1352	area = self._db.get_area_by_id(area_id)
1353	if area is not None:
1354	json_data.add_data(area)
1355	self.send_http_response_ok(json_data.get())
1356
1357
1358
1359	def _rest_base_area_list_with_rooms(self):
1360	""" list areas and associated rooms
1361	"""
1362	json_data = JSonHelper("OK")
1363	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1364	json_data.set_data_type("area")
1365	for area in self._db.list_areas_with_rooms():
1366	json_data.add_data(area)
1367	self.send_http_response_ok(json_data.get())
1368
1369
1370
1371	def _rest_base_area_add(self):
1372	""" add areas
1373	"""
1374	json_data = JSonHelper("OK")
1375	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1376	json_data.set_data_type("area")
1377	try:
1378	area = self._db.add_area(self.get_parameters("name"), self.get_parameters("description"))
1379	json_data.add_data(area)
1380	except:
1381	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1382	self.send_http_response_ok(json_data.get())
1383
1384
1385
1386
1387	def _rest_base_area_update(self):
1388	""" update areas
1389	"""
1390	json_data = JSonHelper("OK")
1391	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1392	json_data.set_data_type("area")
1393	try:
1394	area = self._db.update_area(self.get_parameters("id"), self.get_parameters("name"), \
1395	self.get_parameters("description"))
1396	json_data.add_data(area)
1397	except:
1398	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1399	self.send_http_response_ok(json_data.get())
1400
1401
1402
1403
1404	def _rest_base_area_del(self, area_id=None):
1405	""" delete areas
1406	@param area_id : id of area
1407	"""
1408	json_data = JSonHelper("OK")
1409	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1410	json_data.set_data_type("area")
1411	try:
1412	area = self._db.del_area(area_id)
1413	json_data.add_data(area)
1414	except:
1415	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1416	self.send_http_response_ok(json_data.get())
1417
1418
1419
1420	######
1421	# /base/room processing
1422	######
1423
1424	def _rest_base_room_list(self, room_id = None, area_id = None):
1425	""" list rooms
1426	@param room_id : id of room
1427	@param area_id : id of area
1428	"""
1429	json_data = JSonHelper("OK")
1430	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1431	json_data.set_data_type("room")
1432	try:
1433	if room_id == None and area_id == None:
1434	for room in self._db.list_rooms():
1435	json_data.add_data(room)
1436	elif room_id != None:
1437	room = self._db.get_room_by_id(room_id)
1438	if room is not None:
1439	json_data.add_data(room)
1440	elif area_id != None:
1441	if area_id == "":
1442	area_id = None
1443	for room in self._db.get_all_rooms_of_area(area_id):
1444	json_data.add_data(room)
1445	self.send_http_response_ok(json_data.get())
1446	except:
1447	self._log.error("Exception : %s" % traceback.format_exc())
1448
1449
1450
1451	def _rest_base_room_list_with_devices(self):
1452	""" list rooms and associated devices
1453	"""
1454	json_data = JSonHelper("OK")
1455	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1456	json_data.set_data_type("room")
1457	for room in self._db.list_rooms_with_devices():
1458	json_data.add_data(room)
1459	self.send_http_response_ok(json_data.get())
1460
1461
1462
1463	def _rest_base_room_add(self):
1464	""" add rooms
1465	"""
1466	json_data = JSonHelper("OK")
1467	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1468	json_data.set_data_type("room")
1469	try:
1470	room = self._db.add_room(self.get_parameters("name"), self.get_parameters("area_id"), \
1471	self.get_parameters("description"))
1472	json_data.add_data(room)
1473	except:
1474	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1475	self.send_http_response_ok(json_data.get())
1476
1477
1478
1479	def _rest_base_room_update(self):
1480	""" update rooms
1481	"""
1482	json_data = JSonHelper("OK")
1483	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1484	json_data.set_data_type("room")
1485	try:
1486	room = self._db.update_room(self.get_parameters("id"), self.get_parameters("name"), \
1487	self.get_parameters("area_id"), self.get_parameters("description"))
1488	json_data.add_data(room)
1489	except:
1490	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1491	self.send_http_response_ok(json_data.get())
1492
1493
1494
1495	def _rest_base_room_del(self, room_id=None):
1496	""" delete rooms
1497	@param room_id : room id
1498	"""
1499	json_data = JSonHelper("OK")
1500	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1501	json_data.set_data_type("room")
1502	try:
1503	room = self._db.del_room(room_id)
1504	json_data.add_data(room)
1505	except:
1506	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1507	self.send_http_response_ok(json_data.get())
1508
1509
1510	######
1511	# /base/ui_config processing
1512	######
1513
1514	def _rest_base_ui_item_config_list(self, name = None, reference = None, key = None):
1515	""" list ui_item_config
1516	@param name : ui item config name
1517	@param reference : ui item config reference
1518	@param key : ui item config key
1519	"""
1520	json_data = JSonHelper("OK")
1521	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1522	json_data.set_data_type("ui_config")
1523	if name == None and reference == None and key == None:
1524	for ui_item_config in self._db.list_all_ui_item_config():
1525	json_data.add_data(ui_item_config)
1526	elif name != None and reference != None:
1527	if key == None:
1528	# by-reference
1529	for ui_item_config in self._db.list_ui_item_config_by_ref(ui_item_name = name, ui_item_reference = reference):
1530	json_data.add_data(ui_item_config)
1531	else:
1532	# by-key
1533	for ui_item_config in self._db.list_ui_item_config_by_key(ui_item_name = name, ui_item_key= key):
1534	json_data.add_data(ui_item_config)
1535	elif name != None and key != None and reference != None:
1536	# by-element
1537	ui_item_config = self._db.get_ui_item_config(self, ui_item_name = name, \
1538	ui_item_reference = reference, ui_key = key)
1539	if ui_item_config is not None:
1540	json_data.add_data(ui_item_config)
1541	self.send_http_response_ok(json_data.get())
1542
1543
1544
1545	def _rest_base_ui_item_config_set(self):
1546	""" set ui_item_config (add if it doesn't exists, update else)
1547	"""
1548	json_data = JSonHelper("OK")
1549	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1550	json_data.set_data_type("ui_config")
1551	try:
1552	ui_item_config = self._db.set_ui_item_config(self.get_parameters("name"), \
1553	self.get_parameters("reference"), \
1554	self.get_parameters("key"), \
1555	self.get_parameters("value"))
1556	json_data.add_data(ui_item_config)
1557	except:
1558	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1559	self.send_http_response_ok(json_data.get())
1560
1561
1562
1563	def _rest_base_ui_item_config_del(self):
1564	""" del ui_item_config
1565	"""
1566	json_data = JSonHelper("OK")
1567	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1568	json_data.set_data_type("ui_config")
1569	try:
1570	for ui_item_config in self._db.delete_ui_item_config(ui_name = name, \
1571	ui_reference = reference, ui_key = key):
1572	json_data.add_data(ui_item_config)
1573	except:
1574	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1575	self.send_http_response_ok(json_data.get())
1576
1577
1578
1579
1580	######
1581	# /base/device_usage processing
1582	######
1583
1584	def _rest_base_device_usage_list(self, name = None):
1585	""" list device usages
1586	@param name : name of device usage
1587	"""
1588	json_data = JSonHelper("OK")
1589	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1590	json_data.set_data_type("device_usage")
1591	if name == None:
1592	for device_usage in self._db.list_device_usages():
1593	json_data.add_data(device_usage)
1594	else:
1595	device_usage = self._db.get_device_usage_by_name(name)
1596	if device_usage is not None:
1597	json_data.add_data(device_usage)
1598	self.send_http_response_ok(json_data.get())
1599
1600
1601
1602	def _rest_base_device_usage_add(self):
1603	""" add device_usage
1604	"""
1605	json_data = JSonHelper("OK")
1606	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1607	json_data.set_data_type("device_usage")
1608	try:
1609	device_usage = self._db.add_device_usage(self.get_parameters("name"), \
1610	self.get_parameters("description"))
1611	json_data.add_data(device_usage)
1612	except:
1613	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1614	self.send_http_response_ok(json_data.get())
1615
1616
1617
1618	def _rest_base_device_usage_update(self):
1619	""" update device usage
1620	"""
1621	json_data = JSonHelper("OK")
1622	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1623	json_data.set_data_type("device_usage")
1624	try:
1625	device_usage = self._db.update_device_usage(self.get_parameters("id"), \
1626	self.get_parameters("name"), \
1627	self.get_parameters("description"))
1628	json_data.add_data(device_usage)
1629	except:
1630	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1631	self.send_http_response_ok(json_data.get())
1632
1633
1634
1635
1636	def _rest_base_device_usage_del(self, du_id=None):
1637	""" delete device usage
1638	@param du_id : device usage id
1639	"""
1640	json_data = JSonHelper("OK")
1641	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1642	json_data.set_data_type("device_usage")
1643	try:
1644	device_usage = self._db.del_device_usage(du_id)
1645	json_data.add_data(device_usage)
1646	except:
1647	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1648	self.send_http_response_ok(json_data.get())
1649
1650
1651
1652	######
1653	# /base/device_type processing
1654	######
1655
1656	def _rest_base_device_type_list(self):
1657	""" list device types
1658	"""
1659	json_data = JSonHelper("OK")
1660	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1661	json_data.set_data_type("device_type")
1662	for device_type in self._db.list_device_types():
1663	json_data.add_data(device_type)
1664	self.send_http_response_ok(json_data.get())
1665
1666
1667	def _rest_base_device_type_add(self):
1668	""" add device type
1669	"""
1670	json_data = JSonHelper("OK")
1671	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1672	json_data.set_data_type("device_type")
1673	try:
1674	device_type = self._db.add_device_type(self.get_parameters("name"), \
1675	self.get_parameters("technology_id"), \
1676	self.get_parameters("description"))
1677	json_data.add_data(device_type)
1678	except:
1679	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1680	self.send_http_response_ok(json_data.get())
1681
1682
1683
1684	def _rest_base_device_type_update(self):
1685	""" update device_type
1686	"""
1687	json_data = JSonHelper("OK")
1688	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1689	json_data.set_data_type("device_type")
1690	try:
1691	area = self._db.update_device_type(self.get_parameters("id"), \
1692	self.get_parameters("name"), \
1693	self.get_parameters("technology_id"), \
1694	self.get_parameters("description"))
1695	json_data.add_data(area)
1696	except:
1697	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1698	self.send_http_response_ok(json_data.get())
1699
1700
1701
1702
1703	def _rest_base_device_type_del(self, dt_id=None):
1704	""" delete device_type
1705	@param dt_id : device type id to delete
1706	"""
1707	json_data = JSonHelper("OK")
1708	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1709	json_data.set_data_type("device_type")
1710	try:
1711	device_type = self._db.del_device_type(dt_id)
1712	json_data.add_data(device_type)
1713	except:
1714	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1715	self.send_http_response_ok(json_data.get())
1716
1717
1718
1719	######
1720	# /base/sensor_reference processing
1721	######
1722
1723	def _rest_base_sensor_reference_list(self, type_id = None):
1724	""" list sensor references
1725	@param name : sensor reference name
1726	"""
1727	json_data = JSonHelper("OK")
1728	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1729	json_data.set_data_type("sensor_reference")
1730	if type_id == None:
1731	for sensor_reference in self._db.list_sensor_reference_data():
1732	json_data.add_data(sensor_reference)
1733	else:
1734	sensor_reference = self._db.get_sensor_reference_data_by_typeid(type_id)
1735	if sensor_reference is not None:
1736	json_data.add_data(sensor_reference)
1737	self.send_http_response_ok(json_data.get())
1738
1739
1740
1741	def _rest_base_sensor_reference_add(self):
1742	""" add sensor reference
1743	"""
1744	json_data = JSonHelper("OK")
1745	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1746	json_data.set_data_type("sensor_reference")
1747	try:
1748	sensor_reference = self._db.add_sensor_reference_data(self.get_parameters("name"), \
1749	self.get_parameters("value"), \
1750	self.get_parameters("type_id"), \
1751	self.get_parameters("unit"), \
1752	self.get_parameters("stat_key"))
1753	json_data.add_data(sensor_reference)
1754	except:
1755	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1756	self.send_http_response_ok(json_data.get())
1757
1758
1759
1760	def _rest_base_sensor_reference_update(self):
1761	""" update sensor_reference
1762	"""
1763	json_data = JSonHelper("OK")
1764	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1765	json_data.set_data_type("sensor_reference")
1766	try:
1767	sensor_reference = self._db.update_sensor_reference_data(self.get_parameters("id"), \
1768	self.get_parameters("name"), \
1769	self.get_parameters("value"), \
1770	self.get_parameters("type_id"), \
1771	self.get_parameters("unit"), \
1772	self.get_parameters("stat_key"))
1773	json_data.add_data(sensor_reference)
1774	except:
1775	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1776	self.send_http_response_ok(json_data.get())
1777
1778
1779
1780
1781	def _rest_base_sensor_reference_del(self, sr_id=None):
1782	""" delete sensor reference
1783	@param sr_id : sensor reference id to delete
1784	"""
1785	json_data = JSonHelper("OK")
1786	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1787	json_data.set_data_type("sensor_reference")
1788	try:
1789	sensor_reference = self._db.del_sensor_reference_data(sr_id)
1790	json_data.add_data(sensor_reference)
1791	except:
1792	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1793	self.send_http_response_ok(json_data.get())
1794
1795
1796
1797	######
1798	# /base/actuator_feature processing
1799	######
1800
1801	def _rest_base_actuator_feature_list(self, type_id = None):
1802	""" list actuator features
1803	@param name : actuator feature name
1804	"""
1805	json_data = JSonHelper("OK")
1806	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1807	json_data.set_data_type("actuator_feature")
1808	if type_id == None:
1809	for actuator_feature in self._db.list_actuator_features():
1810	json_data.add_data(actuator_feature)
1811	else:
1812	actuator_feature = self._db.get_actuator_feature_by_typeid(type_id)
1813	if actuator_feature is not None:
1814	json_data.add_data(actuator_feature)
1815	self.send_http_response_ok(json_data.get())
1816
1817
1818
1819	def _rest_base_actuator_feature_add(self):
1820	""" add actuator feature
1821	"""
1822	json_data = JSonHelper("OK")
1823	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1824	json_data.set_data_type("actuator_feature")
1825	try:
1826	actuator_feature = self._db.add_actuator_feature(self.get_parameters("name"), \
1827	self.get_parameters("value"), \
1828	self.get_parameters("type_id"), \
1829	self.get_parameters("unit"), \
1830	self.get_parameters("configurable_states"), \
1831	self.get_parameters("return_confirmation"))
1832	json_data.add_data(actuator_feature)
1833	except:
1834	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1835	self.send_http_response_ok(json_data.get())
1836
1837
1838	def _rest_base_actuator_feature_update(self):
1839	""" update actuator feature
1840	"""
1841	json_data = JSonHelper("OK")
1842	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1843	json_data.set_data_type("actuator_feature")
1844	try:
1845	actuator_feature = self._db.update_actuator_feature(self.get_parameters("id"), \
1846	self.get_parameters("name"), \
1847	self.get_parameters("value"), \
1848	self.get_parameters("type_id"), \
1849	self.get_parameters("unit"), \
1850	self.get_parameters("configurable_states"), \
1851	self.get_parameters("return_confirmation"))
1852	json_data.add_data(actuator_feature)
1853	except:
1854	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1855	self.send_http_response_ok(json_data.get())
1856
1857
1858	def _rest_base_actuator_feature_del(self, af_id=None):
1859	""" delete actuator feature
1860	@param af_id : actuator feature id to delete
1861	"""
1862	json_data = JSonHelper("OK")
1863	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1864	json_data.set_data_type("actuator_feature")
1865	try:
1866	actuator_feature = self._db.del_actuator_feature(af_id)
1867	json_data.add_data(actuator_feature)
1868	except:
1869	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1870	self.send_http_response_ok(json_data.get())
1871
1872
1873
1874	######
1875	# /base/device_technology processing
1876	######
1877
1878	def _rest_base_device_technology_list(self, name = None):
1879	""" list device technologies
1880	@param name : device technology name
1881	"""
1882	json_data = JSonHelper("OK")
1883	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1884	json_data.set_data_type("device_technology")
1885	if name == None:
1886	for device_technology in self._db.list_device_technologies():
1887	json_data.add_data(device_technology)
1888	else:
1889	device_technology = self._db.get_device_technology_by_name(name)
1890	if device_technology is not None:
1891	json_data.add_data(device_technology)
1892	self.send_http_response_ok(json_data.get())
1893
1894
1895
1896	def _rest_base_device_technology_add(self):
1897	""" add device technology
1898	"""
1899	json_data = JSonHelper("OK")
1900	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1901	json_data.set_data_type("device_technology")
1902	try:
1903	device_technology = self._db.add_device_technology(self.get_parameters("name"), \
1904	self.get_parameters("description"))
1905	json_data.add_data(device_technology)
1906	except:
1907	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1908	self.send_http_response_ok(json_data.get())
1909
1910
1911	def _rest_base_device_technology_update(self):
1912	""" update device technology
1913	"""
1914	json_data = JSonHelper("OK")
1915	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1916	json_data.set_data_type("device_technology")
1917	try:
1918	device_technology = self._db.update_device_technology(self.get_parameters("id"), \
1919	self.get_parameters("name"), \
1920	self.get_parameters("description"))
1921	json_data.add_data(device_technology)
1922	except:
1923	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1924	self.send_http_response_ok(json_data.get())
1925
1926
1927	def _rest_base_device_technology_del(self, dt_id=None):
1928	""" delete device technology
1929	@param dt_id : device tehcnology id
1930	"""
1931	json_data = JSonHelper("OK")
1932	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1933	json_data.set_data_type("device_technology")
1934	try:
1935	device_technology = self._db.del_device_technology(dt_id)
1936	json_data.add_data(device_technology)
1937	except:
1938	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1939	self.send_http_response_ok(json_data.get())
1940
1941
1942
1943	######
1944	# /base/device_technology_config processing
1945	######
1946
1947	def _rest_base_device_technology_config_list(self, technology_id = None, key = None):
1948	""" list device technology config
1949	@param technology_id : device technology config id
1950	@param key : key of config
1951	"""
1952	json_data = JSonHelper("OK")
1953	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1954	json_data.set_data_type("device_technology_config")
1955	if technology_id == None:
1956	for device_technology_config in self._db.list_all_device_technology_config():
1957	json_data.add_data(device_technology_config)
1958	elif key == None:
1959	for device_technology_config in self._db.list_device_technology_config(technology_id):
1960	json_data.add_data(device_technology_config)
1961	else:
1962	device_technology_config = self._db.get_device_technology_config(technology_id, key)
1963	if device_technology_config is not None:
1964	json_data.add_data(device_technology_config)
1965	self.send_http_response_ok(json_data.get())
1966
1967
1968
1969	def _rest_base_device_technology_config_add(self):
1970	""" add device technology config
1971	"""
1972	json_data = JSonHelper("OK")
1973	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1974	json_data.set_data_type("device_technology_config")
1975	try:
1976	device_technology_config = self._db.add_device_technology_config(self.get_parameters("technology_id"), \
1977	self.get_parameters("key"), \
1978	self.get_parameters("value"), \
1979	self.get_parameters("description"))
1980	json_data.add_data(device_technology_config)
1981	except:
1982	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
1983	self.send_http_response_ok(json_data.get())
1984
1985
1986	def _rest_base_device_technology_config_update(self):
1987	""" update device technology config
1988	"""
1989	json_data = JSonHelper("OK")
1990	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
1991	json_data.set_data_type("device_technology_config")
1992	try:
1993	device_technology_config = self._db.update_device_technology_config(self.get_parameters("id"), \
1994	self.get_parameters("technology_id"), \
1995	self.get_parameters("key"), \
1996	self.get_parameters("value"), \
1997	self.get_parameters("description"))
1998	json_data.add_data(device_technology_config)
1999	except:
2000	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2001	self.send_http_response_ok(json_data.get())
2002
2003
2004	def _rest_base_device_technology_config_del(self, tc_id=None):
2005	""" delete device technology config
2006	@param tc_id : device technology config id
2007	"""
2008	json_data = JSonHelper("OK")
2009	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2010	json_data.set_data_type("device_technology_config")
2011	try:
2012	device_technology_config = self._db.del_device_technology_config(tc_id)
2013	json_data.add_data(device_technology_config)
2014	except:
2015	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2016	self.send_http_response_ok(json_data.get())
2017
2018
2019
2020	######
2021	# /base/device processing
2022	######
2023
2024	def _rest_base_device_list(self, room_id = None, device_id = None):
2025	""" list devices
2026	"""
2027	json_data = JSonHelper("OK")
2028	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2029	json_data.set_data_type("device")
2030	if room_id == None and device_id == None:
2031	for device in self._db.list_devices():
2032	json_data.add_data(device)
2033	elif device_id == None:
2034	# by-room
2035	if room_id == "":
2036	room_id = None
2037	for device in self._db.get_all_devices_of_room(room_id):
2038	json_data.add_data(device)
2039	elif room_id == None:
2040	# by-device
2041	for device in self._db.get_all_devices_of_room(room_id):
2042	json_data.add_data(device)
2043	self.send_http_response_ok(json_data.get())
2044
2045
2046
2047	def _rest_base_device_add(self):
2048	""" add devices
2049	"""
2050	json_data = JSonHelper("OK")
2051	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2052	json_data.set_data_type("device")
2053	try:
2054	device = self._db.add_device(self.get_parameters("name"), \
2055	self.get_parameters("address"), \
2056	self.get_parameters("type_id"), \
2057	self.get_parameters("usage_id"), \
2058	self.get_parameters("room_id"), \
2059	self.get_parameters("description"), \
2060	self.get_parameters("reference"))
2061	json_data.add_data(device)
2062	except:
2063	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2064	self.send_http_response_ok(json_data.get())
2065
2066
2067	def _rest_base_device_update(self):
2068	""" update devices
2069	"""
2070	json_data = JSonHelper("OK")
2071	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2072	json_data.set_data_type("device")
2073	try:
2074	device = self._db.update_device(self.get_parameters("id"), \
2075	self.get_parameters("name"), \
2076	self.get_parameters("address"), \
2077	self.get_parameters("type_id"), \
2078	self.get_parameters("usage_id"), \
2079	self.get_parameters("room_id"), \
2080	self.get_parameters("description"), \
2081	self.get_parameters("reference"))
2082	json_data.add_data(device)
2083	except:
2084	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2085	self.send_http_response_ok(json_data.get())
2086
2087
2088	def _rest_base_device_del(self, id):
2089	""" delete device
2090	@param id : device id
2091	"""
2092	json_data = JSonHelper("OK")
2093	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2094	json_data.set_data_type("device")
2095	try:
2096	device = self._db.del_device(id)
2097	json_data.add_data(device)
2098	except:
2099	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2100	self.send_http_response_ok(json_data.get())
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111	######
2112	# /module processing
2113	######
2114
2115	def rest_module(self):
2116	""" /module processing
2117	"""
2118	print "Call rest_module"
2119	if len(self.rest_request) < 1:
2120	self.send_http_response_error(999, "Url too short", self.jsonp, self.jsonp_cb)
2121	return
2122
2123	### list ######################################
2124	if self.rest_request[0] == "list":
2125
2126	if len(self.rest_request) == 1:
2127	self._rest_module_list()
2128	elif len(self.rest_request) == 2:
2129	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[0], \
2130	self.jsonp, self.jsonp_cb)
2131	else:
2132	if self.rest_request[1] == "by-name":
2133	self._rest_module_list(name=self.rest_request[2])
2134	else:
2135	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
2136	self.jsonp, self.jsonp_cb)
2137	return
2138
2139	### detail ####################################
2140	elif self.rest_request[0] == "detail":
2141	if len(self.rest_request) < 2:
2142	self.send_http_response_error(999, "Url too short", self.jsonp, self.jsonp_cb)
2143	return
2144	self._rest_module_detail(self.rest_request[1])
2145
2146
2147	### start #####################################
2148	elif self.rest_request[0] == "start":
2149	if len(self.rest_request) < 2:
2150	self.send_http_response_error(999, "Url too short", self.jsonp, self.jsonp_cb)
2151	return
2152	self._rest_module_start_stop(module = self.rest_request[1], \
2153	command = "start")
2154
2155	### stop ######################################
2156	elif self.rest_request[0] == "stop":
2157	if len(self.rest_request) < 2:
2158	self.send_http_response_error(999, "Url too short", self.jsonp, self.jsonp_cb)
2159	return
2160	self._rest_module_start_stop(module = self.rest_request[1], \
2161	command = "stop")
2162
2163	### others ####################################
2164	else:
2165	self.send_http_response_error(999, "Bad operation for /module", self.jsonp, self.jsonp_cb)
2166	return
2167
2168
2169
2170	def _rest_module_list(self, name = None):
2171	""" Send a xpl message to manager to get module list
2172	Display this list as json
2173	@param name : name of module
2174	"""
2175	print "Call rest_module_list"
2176
2177	### Send xpl message to get list
2178	message = XplMessage()
2179	message.set_type("xpl-cmnd")
2180	message.set_schema("domogik.system")
2181	message.add_data({"command" : "list"})
2182	# TODO : ask for good host
2183	message.add_data({"host" : gethostname()})
2184	self._myxpl.send(message)
2185	print "Message sent : " + str(message)
2186
2187	### Wait for answer
2188	# get xpl message from queue
2189	try:
2190	message = self._get_from_queue(self._queue_system_list)
2191	except Empty:
2192	json_data = JSonHelper("ERROR", 999, "No data or timeout on getting module list")
2193	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2194	json_data.set_data_type("module")
2195	self.send_http_response_ok(json_data.get())
2196	return
2197
2198	print "Message received : " + str(message)
2199
2200	# process message
2201	cmd = message.data['command']
2202	host = message.data["host"]
2203
2204
2205	json_data = JSonHelper("OK")
2206	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2207	json_data.set_data_type("module")
2208
2209	idx = 0
2210	loop_again = True
2211	while loop_again:
2212	try:
2213	data = message.data["module"+str(idx)].split(",")
2214	if name == None or name == data[0]:
2215	json_data.add_data({"name" : data[0], "description" : data[2], "status" : data[1], "host" : host})
2216	idx += 1
2217	except:
2218	loop_again = False
2219
2220	self.send_http_response_ok(json_data.get())
2221
2222
2223
2224	def _rest_module_detail(self, name, host = gethostname()):
2225	""" Send a xpl message to manager to get module list
2226	Display this list as json
2227	@param name : name of module
2228	"""
2229	print "Call rest_module_detail"
2230
2231	### Send xpl message to get detail
2232	message = XplMessage()
2233	message.set_type("xpl-cmnd")
2234	message.set_schema("domogik.system")
2235	message.add_data({"command" : "detail"})
2236	message.add_data({"module" : name})
2237	# TODO : ask for good host
2238	message.add_data({"host" : host})
2239	self._myxpl.send(message)
2240	print "Message sent : " + str(message)
2241
2242	### Wait for answer
2243	# get xpl message from queue
2244	try:
2245	# in filter, "%" means, that we check for something starting with name
2246	message = self._get_from_queue(self._queue_system_detail, filter = {"command" : "detail", "module" : name + "%"})
2247	except Empty:
2248	json_data = JSonHelper("ERROR", 999, "No data or timeout on getting module detail for %s" % name)
2249	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2250	json_data.set_data_type("module")
2251	self.send_http_response_ok(json_data.get())
2252	return
2253
2254	print "Message received : " + str(message)
2255
2256	# process message
2257	cmd = message.data['command']
2258	host = message.data["host"]
2259	modinfo = message.data["module"]
2260	data = message.data["module"].split(",")
2261	json_data = JSonHelper("OK")
2262	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2263	json_data.set_data_type("module")
2264
2265	idx = 0
2266	loop_again = True
2267	config_data = []
2268	while loop_again:
2269	try:
2270	data_conf = message.data["config"+str(idx)].split(",")
2271	config_data.append({"id" : idx+1, "key" : data_conf[0], "description" : data_conf[1], "default" : data_conf[2]})
2272	idx += 1
2273	except:
2274	loop_again = False
2275
2276	json_data.add_data({"name" : data[0], "description" : data[2], "status" : data[1], "host" : host, "configuration" : config_data})
2277	self.send_http_response_ok(json_data.get())
2278
2279
2280
2281
2282	def _rest_module_start_stop(self, command, host = gethostname(), module = None, force = 0):
2283	""" Send start xpl message to manager
2284	Then, listen for a response
2285	@param host : host to which we send command
2286	@param module : name of module
2287	@param force : force (or not) action. 0/1. 1 : force
2288	"""
2289
2290	### Send xpl message
2291	cmd_message = XplMessage()
2292	cmd_message.set_type("xpl-cmnd")
2293	cmd_message.set_schema("domogik.system")
2294	cmd_message.add_data({"command" : command})
2295	cmd_message.add_data({"host" : host})
2296	cmd_message.add_data({"module" : module})
2297	cmd_message.add_data({"force" : force})
2298	self._myxpl.send(cmd_message)
2299	print "Message sent : " + str(cmd_message)
2300
2301	### Listen for response
2302	# get xpl message from queue
2303	try:
2304	if command == "start":
2305	message = self._get_from_queue(self._queue_system_start, filter = {"command" : "start", "module" : module})
2306	elif command == "stop":
2307	message = self._get_from_queue(self._queue_system_stop, filter= {"command" : "stop", "module" : module})
2308	except Empty:
2309	json_data = JSonHelper("ERROR", 999, "No data or timeout on %s module %s" % (command, module))
2310	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2311	json_data.set_data_type("module")
2312	self.send_http_response_ok(json_data.get())
2313	return
2314
2315	print "Message received : " + str(message)
2316
2317	# an error happens
2318	if 'error' in message.data:
2319	error_msg = message.data['error']
2320	json_data = JSonHelper("ERROR", 999, error_msg)
2321	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2322	self.send_http_response_ok(json_data.get())
2323
2324
2325	# no error
2326	else:
2327	json_data = JSonHelper("OK")
2328	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2329	self.send_http_response_ok(json_data.get())
2330
2331
2332
2333	######
2334	# /account processing
2335	######
2336
2337	def rest_account(self):
2338	print "Call rest_action"
2339
2340	# Check url length
2341	if len(self.rest_request) < 2:
2342	self.send_http_response_error(999, "Url too short", self.jsonp, self.jsonp_cb)
2343	return
2344
2345	# parameters initialisation
2346	self.parameters = {}
2347
2348	### user #####################################
2349	if self.rest_request[0] == "user":
2350
2351	### list
2352	if self.rest_request[1] == "list":
2353	if len(self.rest_request) == 2:
2354	self._rest_account_user_list()
2355	elif len(self.rest_request) == 3:
2356	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
2357	self.jsonp, self.jsonp_cb)
2358	else:
2359	if self.rest_request[2] == "by-id":
2360	self._rest_account_user_list(id=self.rest_request[3])
2361	else:
2362	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
2363	self.jsonp, self.jsonp_cb)
2364
2365
2366	### auth
2367	elif self.rest_request[1] == "auth":
2368	if len(self.rest_request) == 4:
2369	self._rest_account_auth(self.rest_request[2], self.rest_request[3])
2370	else:
2371	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
2372	self.jsonp, self.jsonp_cb)
2373	return
2374
2375	### add
2376	elif self.rest_request[1] == "add":
2377	offset = 2
2378	if self.set_parameters(offset):
2379	self._rest_account_user_add()
2380	else:
2381	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
2382
2383	### update
2384	elif self.rest_request[1] == "update":
2385	offset = 2
2386	if self.set_parameters(offset):
2387	self._rest_account_user_update()
2388	else:
2389	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
2390
2391	### password
2392	elif self.res2_request[1] == "password":
2393	offset = 2
2394	if self.set_parameters(offset):
2395	self._rest_account_password()
2396	else:
2397	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
2398
2399	### del
2400	elif self.rest_request[1] == "del":
2401	if len(self.rest_request) == 3:
2402	self._rest_account_user_del(id=self.rest_request[2])
2403	else:
2404	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
2405	self.jsonp, self.jsonp_cb)
2406
2407	### others ###################################
2408	else:
2409	self.send_http_response_error(999, self.rest_request[1] + " not allowed", self.jsonp, self.jsonp_cb)
2410	return
2411
2412	### person ###################################
2413	elif self.rest_request[0] == "person":
2414
2415	### list #####################################
2416	if self.rest_request[1] == "list":
2417	if len(self.rest_request) == 2:
2418	self._rest_account_person_list()
2419	elif len(self.rest_request) == 3:
2420	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
2421	self.jsonp, self.jsonp_cb)
2422	else:
2423	if self.rest_request[2] == "by-id":
2424	self._rest_account_person_list(id=self.rest_request[3])
2425	else:
2426	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
2427	self.jsonp, self.jsonp_cb)
2428
2429	### add
2430	elif self.rest_request[1] == "add":
2431	offset = 2
2432	if self.set_parameters(offset):
2433	self._rest_account_person_add()
2434	else:
2435	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
2436
2437	### update
2438	elif self.rest_request[1] == "update":
2439	offset = 2
2440	if self.set_parameters(offset):
2441	self._rest_account_person_update()
2442	else:
2443	self.send_http_response_error(999, "Error in parameters", self.jsonp, self.jsonp_cb)
2444
2445	### del
2446	elif self.rest_request[1] == "del":
2447	if len(self.rest_request) == 3:
2448	self._rest_account_person_del(id=self.rest_request[2])
2449	else:
2450	self.send_http_response_error(999, "Wrong syntax for " + self.rest_request[1], \
2451	self.jsonp, self.jsonp_cb)
2452
2453	### others ###################################
2454	else:
2455	self.send_http_response_error(999, self.rest_request[1] + " not allowed", self.jsonp, self.jsonp_cb)
2456	return
2457
2458	### others ###################################
2459	else:
2460	self.send_http_response_error(999, self.rest_request[0] + " not allowed", self.jsonp, self.jsonp_cb)
2461	return
2462
2463
2464
2465	def _rest_account_user_list(self, id = None):
2466	""" list accounts
2467	@param id : id of account
2468	"""
2469	json_data = JSonHelper("OK")
2470	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2471	json_data.set_data_type("account")
2472	if id == None:
2473	for account in self._db.list_user_accounts():
2474	json_data.add_data(account)
2475	else:
2476	account = self._db.get_user_account(id)
2477	if account is not None:
2478	json_data.add_data(account)
2479	self.send_http_response_ok(json_data.get())
2480
2481
2482	def _rest_account_auth(self, login, password):
2483	""" check authentification
2484	@param login : login
2485	@param password : password
2486	"""
2487	json_data = JSonHelper("OK")
2488	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2489	login_ok = self._db.authenticate(login, password)
2490	if login_ok == True:
2491	json_data.set_ok(description = "Authentification granted")
2492	json_data.set_data_type("account")
2493	account = self._db.get_user_account_by_login(login)
2494	if account is not None:
2495	json_data.add_data(account)
2496	else:
2497	json_data.set_error(999, "Authentification refused")
2498	self.send_http_response_ok(json_data.get())
2499
2500
2501	def _rest_account_user_add(self):
2502	""" add user account
2503	"""
2504	json_data = JSonHelper("OK")
2505	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2506	json_data.set_data_type("account")
2507	try:
2508	# create user and person
2509	if self.get_parameters("person_id") == None:
2510	account = self._db.add_user_account_with_person(self.get_parameters("login"), \
2511	self.get_parameters("password"), \
2512	self.get_parameters("first_name"), \
2513	self.get_parameters("last_name"), \
2514	self.to_date(self.get_parameters("birthday")), \
2515	self.get_parameters("is_admin"), \
2516	self.get_parameters("skin_used"))
2517	json_data.add_data(account)
2518	# create an user and attach it to a person
2519	else:
2520	account = self._db.add_user_account_with_person(self.get_parameters("login"), \
2521	self.get_parameters("password"), \
2522	self.get_parameters("person_id"), \
2523	self.get_parameters("is_admin"), \
2524	self.get_parameters("skin_used"))
2525	json_data.add_data(account)
2526	except:
2527	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2528	self.send_http_response_ok(json_data.get())
2529
2530
2531
2532	def _rest_account_user_update(self):
2533	""" update user account
2534	"""
2535	json_data = JSonHelper("OK")
2536	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2537	json_data.set_data_type("account")
2538	try:
2539	account = self._db.update_user_account(self.get_parameters("id"), \
2540	self.get_parameters("login"), \
2541	self.get_parameters("is_admin"), \
2542	self.get_parameters("skin_used"))
2543	json_data.add_data(account)
2544	except:
2545	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2546	self.send_http_response_ok(json_data.get())
2547
2548
2549
2550	def _rest_account_password(self):
2551	""" update user password
2552	"""
2553	json_data = JSonHelper("OK")
2554	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2555	json_data.set_data_type("account")
2556	change_ok = self._db.change_password(self.get_parameters("id"), \
2557	self.get_parameters("old"), \
2558	self.get_parameters("new"))
2559	if change_ok == True:
2560	json_data.set_ok(description = "Password updated")
2561	json_data.set_data_type("account")
2562	account = self._db.get_user_account(self.get_parameters("id"))
2563	if account is not None:
2564	json_data.add_data(account)
2565	else:
2566	json_data.set_error(999, "Error in updating password")
2567	self.send_http_response_ok(json_data.get())
2568
2569
2570
2571	def _rest_account_user_del(self, id):
2572	""" delete user account
2573	@param id : account id
2574	"""
2575	json_data = JSonHelper("OK")
2576	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2577	json_data.set_data_type("account")
2578	try:
2579	account = self._db.del_user_account(id)
2580	json_data.add_data(account)
2581	except:
2582	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2583	self.send_http_response_ok(json_data.get())
2584
2585
2586
2587	def _rest_account_person_list(self, id = None):
2588	""" list persons
2589	@param id : id of person
2590	"""
2591	json_data = JSonHelper("OK")
2592	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2593	json_data.set_data_type("person")
2594	if id == None:
2595	for person in self._db.list_persons():
2596	json_data.add_data(person)
2597	else:
2598	person = self._db.get_person(id)
2599	if person is not None:
2600	json_data.add_data(person)
2601	self.send_http_response_ok(json_data.get())
2602
2603
2604
2605	def _rest_account_person_add(self):
2606	""" add person
2607	"""
2608	json_data = JSonHelper("OK")
2609	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2610	json_data.set_data_type("person")
2611	try:
2612	person = self._db.add_person(self.get_parameters("first_name"), \
2613	self.get_parameters("last_name"), \
2614	self.to_date(self.get_parameters("birthday")))
2615	json_data.add_data(person)
2616	except:
2617	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2618	self.send_http_response_ok(json_data.get())
2619
2620
2621
2622	def _rest_account_person_update(self):
2623	""" update person
2624	"""
2625	json_data = JSonHelper("OK")
2626	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2627	json_data.set_data_type("person")
2628	try:
2629	person = self._db.update_person(self.get_parameters("id"), \
2630	self.get_parameters("first_name"), \
2631	self.get_parameters("last_name"), \
2632	self.to_date(self.get_parameters("birthday")))
2633	json_data.add_data(person)
2634	except:
2635	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2636	self.send_http_response_ok(json_data.get())
2637
2638
2639
2640	def _rest_account_person_del(self, id):
2641	""" delete person
2642	@param id : person id
2643	"""
2644	json_data = JSonHelper("OK")
2645	json_data.set_jsonp(self.jsonp, self.jsonp_cb)
2646	json_data.set_data_type("person")
2647	try:
2648	person = self._db.del_person(id)
2649	json_data.add_data(person)
2650	except:
2651	json_data.set_error(code = 999, description = str(sys.exc_info()[1]).replace('"', "'"))
2652	self.send_http_response_ok(json_data.get())
2653
2654
2655
2656
2657
2658
2659
2660
2661	################################################################################
2662	class JSonHelper():
2663	""" Easy way to create a json or jsonp structure
2664	"""
2665
2666	def __init__(self, status = "OK", code = 0, description = ""):
2667	""" Init json structure
2668	@param status : OK/ERROR
2669	@param code : 0...999 : error code. If error no referenced, 999
2670	@param description : error description
2671	"""
2672	if status == "OK":
2673	self.set_ok()
2674	else:
2675	self.set_error(code, description)
2676	self._data_type = ""
2677	self._data_values = ""
2678	self._nb_data_values = 0
2679
2680	def set_jsonp(self, jsonp, jsonp_cb):
2681	""" define jsonp mode
2682	@param jsonp : True/False : True : jsonp mode
2683	@param jsonp_cb : name of jsonp callback
2684	"""
2685	self._jsonp = jsonp
2686	self._jsonp_cb = jsonp_cb
2687
2688	def set_ok(self, code=0, description=None):
2689	""" set ok status
2690	"""
2691	self._status = '"status" : "OK", "code" : ' + str(code) + ', "description" : "' + str(description) + '",'
2692
2693	def set_error(self, code=0, description=None):
2694	""" set error status
2695	@param code : error code
2696	@param description : error description
2697	"""
2698	self._status = '"status" : "ERROR", "code" : ' + str(code) + ', "description" : "' + str(description) + '",'
2699
2700	def set_data_type(self, type):
2701	""" set data type
2702	@param type : data type
2703	"""
2704	self._data_type = type
2705
2706	def add_data(self, data):
2707	""" add data to json structure in 'type' table
2708	@param data : data to add
2709	"""
2710	data_out = ""
2711	self._nb_data_values += 1
2712
2713	# dirty issue to force data not to be in cache
2714	if hasattr(data, 'id') or hasattr(data, 'item_reference'): # for all
2715	pass
2716	if hasattr(data, 'area'): # for room
2717	pass
2718
2719	#print "T=" + str(type(data))
2720	if data == None:
2721	return
2722
2723	data_out += self._process_data(data)
2724	self._data_values += data_out
2725
2726
2727
2728
2729
2730	def _process_data(self, data, idx = 0, key = None):
2731	#print "==== PROCESS DATA " + str(idx) + " ===="
2732
2733	# check deepth in recursivity
2734	if idx > 2:
2735	return "#MAX_DEPTH#"
2736
2737	# define data types
2738	db_type = ("ActuatorFeature", "Area", "Device", "DeviceUsage", \
2739	"DeviceConfig", "DeviceStats", "DeviceStatsValue", \
2740	"DeviceTechnology", "DeviceTechnologyConfig", \
2741	"DeviceType", "UIItemConfig", "Room", "UserAccount", \
2742	"SensorReferenceData", "Person", "SystemConfig", \
2743	"SystemStats", "SystemStatsValue", "Trigger")
2744	instance_type = ("instance")
2745	num_type = ("int", "float")
2746	str_type = ("str", "unicode", "bool", "datetime", "date")
2747	none_type = ("NoneType")
2748	tuple_type = ("tuple")
2749	list_type = ("list")
2750	dict_type = ("dict")
2751
2752	data_json = ""
2753
2754	# get data type
2755	data_type = type(data).__name__
2756
2757	# dirty issue to force cache of __dict__ (done for ui_config)
2758	if hasattr(data, 'reference'):
2759	pass
2760	if hasattr(data, 'id'):
2761	pass
2762	print "DATA : " + unicode(data).encode('utf-8')
2763	#print "DATA TYPE : " + data_type
2764
2765
2766	### type instance (sql object)
2767	if data_type in instance_type:
2768	# get <object>._type value
2769	try:
2770	sub_data_type = data._type.lower()
2771	except:
2772	sub_data_type = "???"
2773	print "SUB TYPE = %s" % sub_data_type
2774
2775	if idx == 0:
2776	data_json += "{"
2777	else:
2778	data_json += '"%s" : {' % sub_data_type
2779
2780	for key in data.__dict__:
2781	sub_data_key = key
2782	sub_data = data.__dict__[key]
2783	sub_data_type = type(sub_data).__name__
2784	#print " DATA KEY : " + str(sub_data_key)
2785	#print " DATA : " + str(sub_data)
2786	#print " DATA TYPE : " + str(sub_data_type)
2787	data_json += self._process_sub_data(idx + 1, False, sub_data_key, sub_data, sub_data_type, db_type, instance_type, num_type, str_type, none_type, tuple_type, list_type, dict_type)
2788	data_json = data_json[0:len(data_json)-1] + "},"
2789
2790	### type : SQL table
2791	elif data_type in db_type:
2792	data_json += "{"
2793	for key in data.__dict__:
2794	sub_data_key = key
2795	sub_data = data.__dict__[key]
2796	sub_data_type = type(sub_data).__name__
2797	#print " DATA KEY : " + str(sub_data_key)
2798	#print " DATA : " + unicode(sub_data)
2799	#print " DATA TYPE : " + str(sub_data_type)
2800	buffer = self._process_sub_data(idx + 1, False, sub_data_key, sub_data, sub_data_type, db_type, instance_type, num_type, str_type, none_type, tuple_type, list_type, dict_type)
2801	# if max depth in recursivity, we don't display "foo : {}"
2802	if re.match(".#MAX_DEPTH#.", buffer) is None:
2803	data_json += buffer
2804	data_json = data_json[0:len(data_json)-1] + "},"
2805
2806	### type : tuple
2807	elif data_type in tuple_type:
2808	if idx > 0:
2809	data_json += "{"
2810	for idy in range(len(data)):
2811	sub_data_key = "???"
2812	sub_data = data[idy]
2813	sub_data_type = type(data[idy]).__name__
2814	#print " DATA KEY : " + str(sub_data_key)
2815	#print " DATA : " + str(sub_data)
2816	#print " DATA TYPE : " + str(sub_data_type)
2817	data_json += self._process_sub_data(idx + 1, False, sub_data_key, sub_data, sub_data_type, db_type, instance_type, num_type, str_type, none_type, tuple_type, list_type, dict_type)
2818	if idx > 0:
2819	data_json = data_json[0:len(data_json)-1] + "},"
2820
2821
2822	### type : list
2823	elif data_type in list_type:
2824	# get first data type
2825	if len(data) > 0:
2826	sub_data_elt0_type = type(data[0]).__name__
2827	else:
2828	return data_json
2829
2830	# start table
2831	if sub_data_elt0_type == "dict":
2832	data_json += '"%s" : [' % key
2833	else:
2834	data_json += '"%s" : [' % sub_data_elt0_type.lower()
2835
2836	# process each data
2837	for sub_data in data:
2838	sub_data_key = "???(2)"
2839	sub_data_type = type(sub_data).__name__
2840	#print " DATA KEY : " + str(sub_data_key)
2841	#print " DATA : " + str(sub_data)
2842	#print " DATA TYPE : " + str(sub_data_type)
2843	data_json += self._process_sub_data(idx + 1, True, sub_data_key, sub_data, sub_data_type, db_type, instance_type, num_type, str_type, none_type, tuple_type, list_type, dict_type)
2844	# finish table
2845	data_json = data_json[0:len(data_json)-1] + "],"
2846
2847
2848	### type : dict
2849	elif data_type in dict_type:
2850	data_json += "{"
2851	for key in data:
2852	sub_data_key = key
2853	sub_data = data[key]
2854	sub_data_type = type(sub_data).__name__
2855	#print " DATA KEY : " + str(sub_data_key)
2856	#print " DATA : " + str(sub_data)
2857	#print " DATA TYPE : " + str(sub_data_type)
2858	data_json += self._process_sub_data(idx + 1, False, sub_data_key, sub_data, sub_data_type, db_type, instance_type, num_type, str_type, none_type, tuple_type, list_type, dict_type)
2859	data_json = data_json[0:len(data_json)-1] + "},"
2860
2861	return data_json
2862
2863
2864
2865	def _process_sub_data(self, idx, is_table, sub_data_key, sub_data, sub_data_type, db_type, instance_type, num_type, str_type, none_type, tuple_type, list_type, dict_type):
2866	data_tmp = ""
2867	if sub_data_type in db_type:
2868	if is_table is False: # and idx != 0:
2869	data_tmp = '"%s" : ' % sub_data_type.lower()
2870	data_tmp += self._process_data(sub_data, idx)
2871	elif sub_data_type in instance_type:
2872	data_tmp += self._process_data(sub_data, idx)
2873	elif sub_data_type in list_type:
2874	data_tmp += self._process_data(sub_data, idx, sub_data_key)
2875	elif sub_data_type in dict_type:
2876	data_tmp += self._process_data(sub_data, idx)
2877	elif sub_data_type in num_type:
2878	data_tmp = '"%s" : %s,' % (sub_data_key, sub_data)
2879	elif sub_data_type in str_type:
2880	data_tmp = '"%s" : "%s",' % (sub_data_key, sub_data)
2881	elif sub_data_type in none_type:
2882	data_tmp = '"%s" : "None",' % (sub_data_key)
2883	else:
2884	data_tmp = ""
2885
2886	return data_tmp
2887
2888
2889
2890
2891
2892
2893	def get(self):
2894	""" getter for all json data created
2895	@return json or jsonp data
2896	"""
2897	if self._jsonp is True and self._jsonp_cb != "":
2898	json_buf = "%s (" % self._jsonp_cb
2899	else:
2900	json_buf = ""
2901
2902	if self._data_type != "":
2903	json_buf += '{%s "%s" : [%s]}' % (self._status, self._data_type, self._data_values[0:len(self._data_values)-1])
2904	else:
2905	json_buf += '{%s}' % self._status[0:len(self._status)-1]
2906
2907	if self._jsonp is True and self._jsonp_cb != "":
2908	json_buf += ")"
2909	print json_buf.encode("utf-8")
2910	return json_buf
2911
2912
2913
2914
2915
2916	if __name__ == '__main__':
2917	# Create REST server with default values (overriden by ~/.domogik.cfg)
2918	http_server = Rest("127.0.0.1", "8080")
2919	http_server.start()
2920
2921

Note: See TracBrowser for help on using the browser.

Context Navigation

root/src/domogik/xpl/bin/rest.py @ 1503:232940f4bcd5

Download in other formats: