Mercurial > hg > ChinaGisRestApi

comparison RestDbInterface.py @ 278:4ade9b80b563 default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
more cleanup. descriptions work better now.
author casties
date Fri, 24 Feb 2012 16:41:30 +0100
parents 9bfa7a6858f1
children
comparison
equal deleted inserted replaced
277:9bfa7a6858f1 278:4ade9b80b563
1 '''
2 Created on 19.5.2010
3
4 @author: casties
5 '''
6
7 from OFS.Folder import Folder
8 from Products.PageTemplates.PageTemplateFile import PageTemplateFile
9 from AccessControl import getSecurityManager, Unauthorized
10 from Products.ZSQLExtend import ZSQLExtend
11 import logging
12 import re
13 import json
14 import time
15 import psycopg2
16 import urllib
17
18 # make psycopg use unicode objects
19 import psycopg2.extensions
20 psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
21 psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY)
22
23 from zope.interface import implements
24 from zope.publisher.interfaces import IPublishTraverse
25 from ZPublisher.BaseRequest import DefaultPublishTraverse
26
27
28 def unicodify(s,alternate='latin-1'):
29 """decode str (utf-8 or latin-1 representation) into unicode object"""
30 if not s:
31 return u""
32 if isinstance(s, str):
33 try:
34 return s.decode('utf-8')
35 except:
36 return s.decode(alternate)
37 else:
38 return s
39
40 def utf8ify(s):
41 """encode unicode object or string into byte string in utf-8 representation.
42 assumes string objects to be utf-8"""
43 if not s:
44 return ""
45 if isinstance(s, str):
46 return s
47 else:
48 return s.encode('utf-8')
49
50 def getTextFromNode(node):
51 """get the cdata content of a XML node"""
52 if node is None:
53 return ""
54
55 if isinstance(node, list):
56 nodelist = node
57 else:
58 nodelist=node.childNodes
59
60 rc = ""
61 for node in nodelist:
62 if node.nodeType == node.TEXT_NODE:
63 rc = rc + node.data
64 return rc
65
66 def sqlName(s,lc=True):
67 """returns restricted ASCII-only version of string"""
68 if s is None:
69 return ""
70
71 # all else -> "_"
72 s = re.sub(r'[^A-Za-z0-9_]','_',s)
73 if lc:
74 return s.lower()
75
76 return s
77
78
79 class RestDbInterface(Folder):
80 """Object for RESTful database queries
81 path schema: /db/{schema}/{table}/
82 omitting table gives a list of schemas
83 omitting table and schema gives a list of schemas
84 """
85 implements(IPublishTraverse)
86
87 meta_type="RESTdb"
88 manage_options=Folder.manage_options+(
89 {'label':'Config','action':'manage_editRestDbInterfaceForm'},
90 )
91
92 # management templates
93 manage_editRestDbInterfaceForm=PageTemplateFile('zpt/editRestDbInterface',globals())
94
95 # data templates
96 XML_index = PageTemplateFile('zpt/XML_index', globals())
97 XML_schema = PageTemplateFile('zpt/XML_schema', globals())
98 XML_schema_table = PageTemplateFile('zpt/XML_schema_table', globals())
99 HTML_index = PageTemplateFile('zpt/HTML_index', globals())
100 HTML_schema = PageTemplateFile('zpt/HTML_schema', globals())
101 HTML_schema_table = PageTemplateFile('zpt/HTML_schema_table', globals())
102 GIS_schema_table = PageTemplateFile('zpt/GIS_schema_table', globals())
103 KML_schema_table = PageTemplateFile('zpt/KML_schema_table', globals())
104 HTML_schema_usertables = PageTemplateFile('zpt/HTML_schema_usertables', globals())
105
106
107
108 JSONHTML_index = PageTemplateFile('zpt/JSONHTML_index', globals())
109 JSONHTML_schema = PageTemplateFile('zpt/JSONHTML_schema', globals())
110 JSONHTML_schema_table = PageTemplateFile('zpt/JSONHTML_schema_table', globals())
111 # JSON_* templates are scripts
112
113
114 def JSON_index(self):
115 """JSON index function"""
116 self.REQUEST.RESPONSE.setHeader("Content-Type", "application/json")
117 json.dump(self.getListOfSchemas(), self.REQUEST.RESPONSE)
118
119 def JSON_schema(self,schema):
120 """JSON index function"""
121 self.REQUEST.RESPONSE.setHeader("Content-Type", "application/json")
122 json.dump(self.getListOfTables(schema), self.REQUEST.RESPONSE)
123
124 def JSON_schema_table(self,schema,table):
125 """JSON index function"""
126 logging.debug("start: json_schema")
127 self.REQUEST.RESPONSE.setHeader("Content-Type", "application/json")
128 json.dump(self.getTable(schema, table), self.REQUEST.RESPONSE)
129 logging.debug("end: json_schema")
130
131 def __init__(self, id, title, connection_id=None):
132 """init"""
133 self.id = id
134 self.title = title
135 # database connection id
136 self.connection_id = connection_id
137 # create template folder
138 self.manage_addFolder('template')
139
140
141 def getRestDbUrl(self):
142 """returns url to the RestDb instance"""
143 return self.absolute_url()
144
145 def getJsonString(self,object):
146 """returns a JSON formatted string from object"""
147 return json.dumps(object)
148
149 def getCursor(self,autocommit=True):
150 """returns fresh DB cursor"""
151 conn = getattr(self,"_v_database_connection",None)
152 if conn is None:
153 # create a new connection object
154 try:
155 if self.connection_id is None:
156 # try to take the first existing ID
157 connids = SQLConnectionIDs(self)
158 if len(connids) > 0:
159 connection_id = connids[0][0]
160 self.connection_id = connection_id
161 logging.debug("connection_id: %s"%repr(connection_id))
162
163 da = getattr(self, self.connection_id)
164 da.connect('')
165 # we copy the DAs database connection
166 conn = da._v_database_connection
167 #conn._register() # register with the Zope transaction system
168 self._v_database_connection = conn
169 except Exception, e:
170 raise IOError("No database connection! (%s)"%str(e))
171
172 cursor = conn.getcursor()
173 if autocommit:
174 # is there a better version to get to the connection?
175 cursor.connection.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
176
177 return cursor
178
179 def getFieldNameMap(self,fields):
180 """returns a dict mapping field names to row indexes"""
181 map = {}
182 i = 0
183 for f in fields:
184 map[f[0]] = i
185 i += 1
186
187 return map
188
189 def getFieldNames(self,fields):
190 """returns a dict mapping field names to row indexes"""
191 map = []
192 i = 0
193 for f in fields:
194 map.append(f[0])
195
196
197 return map
198
199 def executeSQL(self, query, args=None, hasResult=True, autocommit=True):
200 """execute query with args on database and return all results.
201 result format: {"fields":fields, "rows":data}"""
202 logging.debug("executeSQL query=%s args=%s"%(query,args))
203 cur = self.getCursor(autocommit=autocommit)
204 if args is not None:
205 # make sure args is a list
206 if isinstance(args,basestring):
207 args = (args,)
208
209 cur.execute(query, args)
210 # description of returned fields
211 fields = cur.description
212 if hasResult:
213 # get all data in an array
214 data = cur.fetchall()
215 cur.close()
216 #logging.debug("fields: %s"%repr(fields))
217 #logging.debug("rows: %s"%repr(data))
218 return {"fields":fields, "rows":data}
219 else:
220 cur.close()
221 return None
222
223 def isAllowed(self,action,schema,table,user=None):
224 """returns if the requested action on the table is allowed"""
225 if user is None:
226 user = self.REQUEST.get('AUTHENTICATED_USER',None)
227 logging.debug("isAllowed action=%s schema=%s table=%s user=%s"%(action,schema,table,user))
228 # no default policy!
229 return True
230
231
232 def publishTraverse(self,request,name):
233 """change the traversal"""
234 # get stored path
235 path = request.get('restdb_path', [])
236 logging.debug("publishtraverse: name=%s restdb_path=%s"%(name,path))
237
238 if name in ("index_html", "PUT"):
239 # end of traversal
240 if request.get("method") == "POST" and request.get("action",None) == "PUT":
241 # fake PUT by POST with action=PUT
242 name = "PUT"
243
244 return getattr(self, name)
245 #TODO: should we check more?
246 else:
247 # traverse
248 if len(path) == 0:
249 # first segment
250 if name == 'db':
251 # virtual path -- continue traversing
252 path = [name]
253 request['restdb_path'] = path
254 else:
255 # try real path
256 tr = DefaultPublishTraverse(self, request)
257 ob = tr.publishTraverse(request, name)
258 return ob
259 else:
260 path.append(name)
261
262 # continue traversing
263 return self
264
265
266 def index_html(self,REQUEST,RESPONSE):
267 """index method"""
268 # ReST path was stored in request
269 path = REQUEST.get('restdb_path',[])
270
271 # type and format are real parameter
272 resultFormat = REQUEST.get('format','HTML').upper()
273 queryType = REQUEST.get('type',None)
274 from_year_name = REQUEST.get('from_year_name',None)
275 until_year_name = REQUEST.get('until_year_name',None)
276
277 logging.debug("index_html path=%s resultFormat=%s queryType=%s"%(path,resultFormat,queryType))
278
279 if queryType is not None:
280 # non-empty queryType -- look for template
281 pt = getattr(self.template, "%s_%s"%(resultFormat,queryType), None)
282 if pt is not None:
283 return pt(format=resultFormat,type=queryType,path=path,from_year_name=from_year_name,until_year_name=until_year_name)
284
285 if len(path) == 1:
286 # list of schemas
287 return self.showListOfSchemas(format=resultFormat)
288 elif len(path) == 2:
289 # list of tables
290 return self.showListOfTables(format=resultFormat,schema=path[1])
291 elif len(path) == 3:
292 # table
293 if REQUEST.get("method") == "POST" and REQUEST.get("create_table_file",None) is not None:
294 # POST to table to check
295 return self.checkTable(format=resultFormat,schema=path[1],table=path[2])
296 # else show table
297 logging.debug("index_html:will showTable")
298 x= self.showTable(format=resultFormat,schema=path[1],table=path[2],REQUEST=REQUEST, RESPONSE=RESPONSE)
299 logging.debug("index_html:have done showTable")
300 return x
301 # don't know what to do
302 return str(REQUEST)
303
304 def PUT(self, REQUEST, RESPONSE):
305 """
306 Implement WebDAV/HTTP PUT/FTP put method for this object.
307 """
308 logging.debug("RestDbInterface PUT")
309 #logging.debug("req=%s"%REQUEST)
310 #self.dav__init(REQUEST, RESPONSE)
311 #self.dav__simpleifhandler(REQUEST, RESPONSE)
312 # ReST path was stored in request
313 path = REQUEST.get('restdb_path',[])
314 if len(path) == 3:
315 schema = path[1]
316 tablename = path[2]
317 file = REQUEST.get("create_table_file",None)
318 if file is None:
319 RESPONSE.setStatus(400)
320 return
321
322 fields = None
323 fieldsStr = REQUEST.get("create_table_fields",None)
324 logging.debug("put with schema=%s table=%s file=%s fields=%s"%(schema,tablename,file,repr(fieldsStr)))
325 if fieldsStr is not None:
326 # unpack fields
327 fields = [{"name":n, "type": t} for (n,t) in [f.split(":") for f in fieldsStr.split(",")]]
328
329 ret = self.createTableFromXML(schema, tablename, file, fields)
330 # return the result as JSON
331 format = REQUEST.get("format","JSON")
332 if format == "JSON":
333 RESPONSE.setHeader("Content-Type", "application/json")
334 json.dump(ret, RESPONSE)
335
336 elif format == "JSONHTML":
337 RESPONSE.setHeader("Content-Type", "text/html")
338 RESPONSE.write("<html>\n<body>\n<pre>")
339 json.dump(ret, RESPONSE)
340 RESPONSE.write("</pre>\n</body>\n</html>")
341
342 else:
343 # 400 Bad Request
344 RESPONSE.setStatus(400)
345 return
346 def getAttributeNames(self,schema='public',table=None):
347 return self.executeSQL("SELECT attname FROM pg_attribute, pg_class WHERE pg_class.oid = attrelid AND attnum>0 AND relname = '%s';"%(table))
348
349 def getAttributeTypes(self,schema='public',table=None):
350 return self.executeSQL("SELECT field_name, gis_type FROM public.gis_table_meta_rows WHERE table_name = '%s';"%(table))
351
352 def showTable(self,format='XML',schema='public',table=None,REQUEST=None,RESPONSE=None):
353 """returns PageTemplate with tables"""
354 logging.debug("showtable")
355 if REQUEST is None:
356 REQUEST = self.REQUEST
357 queryArgs={'doc':None,'id':None}
358 queryArgs['doc'] = REQUEST.get('doc')
359 queryArgs['id'] = REQUEST.get('id')
360
361 # should be cross-site accessible
362 if RESPONSE is None:
363 RESPONSE = self.REQUEST.RESPONSE
364
365 RESPONSE.setHeader('Access-Control-Allow-Origin', '*')
366
367 # everything else has its own template
368 pt = getattr(self.template, '%s_schema_table'%format, REQUEST)
369 logging.debug("showtable: gottemplate")
370 if pt is None:
371 return "ERROR!! template %s_schema_table not found at %s"%(format, self.template )
372 #data = self.getTable(schema,table)
373 logging.debug("table:"+repr(table))
374 #x = pt(schema=schema,table=table,args={})
375 x = pt(schema=schema,table=table,args=queryArgs)
376 logging.debug("showtable: executed Table")
377 return x
378
379 def getLiveUrl(self,schema,table,useTimestamp=True,REQUEST=None):
380 if REQUEST is None:
381 REQUEST = self.REQUEST
382 logging.debug("getLiveUrl")
383 baseUrl = self.absolute_url()
384 timestamp = time.time()
385 # filter parameters in URL and add to new URL
386 params = [p for p in REQUEST.form.items() if p[0] not in ('format','timestamp')]
387 params.append(('format','KML'))
388 if useTimestamp:
389 # add timestamp so URL changes every time
390 params.append(('timestamp',timestamp))
391 paramstr = urllib.urlencode(params)
392 return "%s/db/%s/%s?%s"%(baseUrl,schema,table,paramstr)
393
394
395
396 def getTable(self,schema='public',table=None,sortBy=1,username='guest'):
397 """return table data"""
398 logging.debug("gettable")
399 attrNames=self.getAttributeNames(schema,table)
400 attrTypes=self.getAttributeTypes(schema,table)
401 attrString=""
402 # try:
403 for name in attrNames['rows']:
404 logging.debug("name: "+repr( name[0]))
405 not_added=True
406 if name[0] == "the_geom": #FJK: the table column is "the_geom"
407 attrString=attrString+"ST_AsText("+name[0]+"),"
408 not_added=False
409 break
410 for a_iter in attrTypes['rows']:
411 not_added = True
412 logging.debug("attrTypes.field_name: "+ repr(a_iter[0]))
413 if a_iter[0]==name[0]:
414 logging.debug("attrTypes.gis_type: "+ repr(a_iter[1]))
415 if a_iter[1] == "the_geom": #FJK: the table column is registered in gis_table_meta_rows as type "the_geom"
416 attrString=attrString+"ST_AsText("+name[0]+"),"
417 not_added=False
418 if not_added:
419 if name[0].find('pg.dropped')==-1:
420 attrString=attrString+name[0]+","
421 attrString=str(attrString).rsplit(",",1)[0] #to remove last ","
422 if sortBy:
423 data = self.executeSQL('select %s from "%s"."%s" order by %s'%(attrString,schema,table,sortBy))
424 else:
425 data = self.executeSQL('select %s from "%s"."%s"'%(attrString,schema,table))
426 # except:
427 """ table does not exist """
428 # fields=self.get
429 # self.createEmptyTable(schema, table, fields)
430 logging.debug("getTable: done")
431 return data
432
433 def hasTable(self,schema='public',table=None,username='guest'):
434 """return if table exists"""
435 logging.debug("hastable")
436 data = self.executeSQL('select 1 from information_schema.tables where table_schema=%s and table_name=%s',(schema,table))
437 ret = bool(data['rows'])
438 return ret
439
440 def showListOfTables(self,format='XML',schema='public',REQUEST=None,RESPONSE=None):
441 """returns PageTemplate with list of tables"""
442 logging.debug("showlistoftables")
443 # should be cross-site accessible
444 if RESPONSE is None:
445 RESPONSE = self.REQUEST.RESPONSE
446 RESPONSE.setHeader('Access-Control-Allow-Origin', '*')
447
448 pt = getattr(self.template, '%s_schema'%format, None)
449 if pt is None:
450 return "ERROR!! template %s_schema not found"%format
451
452 #data = self.getListOfTables(schema)
453 return pt(schema=schema)
454
455 def getListOfTables(self,schema='public',username='guest'):
456 """return list of tables"""
457 logging.debug("getlistoftables")
458 # get list of fields and types of db table
459 #qstr="""SELECT c.relname AS tablename FROM pg_catalog.pg_class c
460 # LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
461 # WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
462 # AND pg_catalog.pg_table_is_visible(c.oid)
463 # AND c.relname ORDER BY 1"""
464 qstr = """SELECT table_name FROM information_schema.tables WHERE table_type = 'BASE TABLE'
465 AND table_schema = %s ORDER BY 1"""
466 data=self.executeSQL(qstr,(schema,))
467 return data
468
469 def showListOfSchemas(self,format='XML',REQUEST=None,RESPONSE=None):
470 """returns PageTemplate with list of schemas"""
471 logging.debug("showlistofschemas")
472 # should be cross-site accessible
473 if RESPONSE is None:
474 RESPONSE = self.REQUEST.RESPONSE
475 RESPONSE.setHeader('Access-Control-Allow-Origin', '*')
476
477 pt = getattr(self.template, '%s_index'%format, None)
478 if pt is None:
479 return "ERROR!! template %s_index not found"%format
480
481 #data = self.getListOfSchemas()
482 return pt()
483
484 def getListOfSchemas(self,username='guest'):
485 """return list of schemas"""
486 logging.debug("getlistofschemas")
487 # TODO: really look up schemas
488 data={'fields': (('schemas',),), 'rows': [('public',),]}
489 return data
490
491 def checkTable(self,format,schema,table,REQUEST=None,RESPONSE=None):
492 """check the table.
493 returns valid data fields and table name."""
494 if REQUEST is None:
495 REQUEST = self.REQUEST
496 RESPONSE = REQUEST.RESPONSE
497
498 file = REQUEST.get("create_table_file",None)
499 res = self.checkTableFromXML(schema, table, file)
500 logging.debug("checkTable result=%s"%repr(res))
501 # return the result as JSON
502 if format == "JSON":
503 RESPONSE.setHeader("Content-Type", "application/json")
504 json.dump(res, RESPONSE)
505
506 elif format == "JSONHTML":
507 RESPONSE.setHeader("Content-Type", "text/html")
508 RESPONSE.write("<html>\n<body>\n<pre>")
509 json.dump(res, RESPONSE)
510 RESPONSE.write("</pre>\n</body>\n</html>")
511
512 else:
513 return "ERROR: invalid format"
514
515 def checkTableFromXML(self,schema,table,data,REQUEST=None,RESPONSE=None):
516 """check the table with the given XML data.
517 returns valid data fields and table name."""
518 logging.debug("checkTableFromXML schema=%s table=%s"%(schema,table))
519 # clean table name
520 tablename = sqlName(table)
521 tableExists = self.hasTable(schema, table)
522 if data is None:
523 fieldNames = []
524 else:
525 # get list of field names from upload file
526 fields = self.importExcelXML(schema,tablename,data,fieldsOnly=True)
527
528 res = {'tablename': tablename, 'table_exists': tableExists}
529 res['fields'] = fields
530 return res
531
532 def createEmptyTable(self,schema,table,fields):
533 """create a table with the given fields
534 returns list of created fields"""
535 logging.debug("createEmptyTable")
536
537 sqlFields = []
538 for f in fields:
539 if isinstance(f,dict):
540 # {name: XX, type: YY}
541 name = sqlName(f['name'])
542 type = f['type']
543 if hasattr(self, 'toSqlTypeMap'):
544 sqltype = self.toSqlTypeMap[type]
545 else:
546 sqltype = 'text'
547
548 else:
549 # name only
550 name = sqlName(f)
551 type = 'text'
552 sqltype = 'text'
553
554 sqlFields.append({'name':name, 'type':type, 'sqltype':sqltype})
555
556 if self.hasTable(schema,table):
557 # TODO: find owner
558 if not self.isAllowed("update", schema, table):
559 raise Unauthorized
560 self.executeSQL('drop table "%s"."%s"'%(schema,table),hasResult=False)
561 else:
562 if not self.isAllowed("create", schema, table):
563 raise Unauthorized
564
565 fieldString = ", ".join(['"%s" %s'%(f['name'],f['sqltype']) for f in sqlFields])
566 sqlString = 'create table "%s"."%s" (%s)'%(schema,table,fieldString)
567 logging.debug("createemptytable: SQL=%s"%sqlString)
568 self.executeSQL(sqlString,hasResult=False)
569 self.setTableMetaTypes(schema,table,sqlFields)
570 return sqlFields
571
572 def createTableFromXML(self,schema,table,data, fields=None):
573 """create or replace a table with the given XML data"""
574 logging.debug("createTableFromXML schema=%s table=%s data=%s fields=%s"%(schema,table,data,fields))
575 tablename = sqlName(table)
576 self.importExcelXML(schema, tablename, data, fields)
577 return {"tablename": tablename}
578
579 def importExcelXML(self,schema,table,xmldata,fields=None,fieldsOnly=False):
580 '''
581 Import XML file in Excel format into the table
582 @param table: name of the table the xml shall be imported into
583 '''
584 from xml.dom.pulldom import parseString,parse
585
586 if not (fieldsOnly or self.isAllowed("create", schema, table)):
587 raise Unauthorized
588
589 namespace = "urn:schemas-microsoft-com:office:spreadsheet"
590 containerTagName = "Table"
591 rowTagName = "Row"
592 colTagName = "Cell"
593 dataTagName = "Data"
594 xmlFields = []
595 sqlFields = []
596 numFields = 0
597 sqlInsert = None
598
599 logging.debug("import excel xml")
600
601 ret=""
602 if isinstance(xmldata, str):
603 logging.debug("importXML reading string data")
604 doc=parseString(xmldata)
605 else:
606 logging.debug("importXML reading file data")
607 doc=parse(xmldata)
608
609 cnt = 0
610 while True:
611 node=doc.getEvent()
612
613 if node is None:
614 break
615
616 else:
617 #logging.debug("tag=%s"%node[1].localName)
618 if node[1].localName is not None:
619 tagName = node[1].localName.lower()
620 else:
621 # ignore non-tag nodes
622 continue
623
624 if tagName == rowTagName.lower():
625 # start of row
626 doc.expandNode(node[1])
627 cnt += 1
628 if cnt == 1:
629 # first row -- field names
630 names=node[1].getElementsByTagNameNS(namespace, dataTagName)
631 for name in names:
632 fn = getTextFromNode(name)
633 xmlFields.append({'name':sqlName(fn),'type':'text'})
634
635 if fieldsOnly:
636 # return just field names
637 return xmlFields
638
639 # create table
640 if fields is None:
641 fields = xmlFields
642
643 sqlFields = self.createEmptyTable(schema, table, fields)
644 numFields = len(sqlFields)
645 fieldString = ", ".join(['"%s"'%f['name'] for f in sqlFields])
646 valString = ", ".join(["%s" for f in sqlFields])
647 sqlInsert = 'insert into "%s"."%s" (%s) values (%s)'%(schema,table,fieldString,valString)
648 #logging.debug("importexcelsql: sqlInsert=%s"%sqlInsert)
649
650 else:
651 # following rows are data
652 colNodes=node[1].getElementsByTagNameNS(namespace, colTagName)
653 data = []
654 hasData = False
655 lineIndex=0
656 for colNode in colNodes:
657 lineIndex+=1
658 dataNodes=colNode.getElementsByTagNameNS(namespace, dataTagName)
659 if len(dataNodes) > 0:
660 dataIndex=0
661 if colNode.hasAttribute(u'ss:Index'):
662 dataIndex=int(colNode.getAttribute(u'ss:Index'))
663 while dataIndex>lineIndex:
664 data.append(None)
665 lineIndex+=1
666 else:
667 val = getTextFromNode(dataNodes[0])
668 hasData = True
669 else:
670 val = None
671
672 if val!=None:
673 a=val.rfind('.0')
674 b=len(val)
675 if a==b-2:
676 val=val.rpartition('.')[0]
677 data.append(val)
678
679 if not hasData:
680 # ignore empty rows
681 continue
682
683 # fix number of data fields
684 if len(data) > numFields:
685 del data[numFields:]
686 elif len(data) < numFields:
687 missFields = numFields - len(data)
688 data.extend(missFields * [None,])
689
690 logging.debug("importexcel sqlinsert=%s data=%s"%(sqlInsert,data))
691 self.executeSQL(sqlInsert, data, hasResult=False)
692
693 return cnt
694
695 def manage_editRestDbInterface(self, title=None, connection_id=None,
696 REQUEST=None):
697 """Change the object"""
698 if title is not None:
699 self.title = title
700
701 if connection_id is not None:
702 self.connection_id = connection_id
703
704 #checkPermission=getSecurityManager().checkPermission
705 REQUEST.RESPONSE.redirect('manage_main')
706
707
708 manage_addRestDbInterfaceForm=PageTemplateFile('zpt/addRestDbInterface',globals())
709
710 def manage_addRestDbInterface(self, id, title='', label='', description='',
711 createPublic=0,
712 createUserF=0,
713 REQUEST=None):
714 """Add a new object with id *id*."""
715
716 ob=RestDbInterface(str(id),title)
717 self._setObject(id, ob)
718
719 #checkPermission=getSecurityManager().checkPermission
720 REQUEST.RESPONSE.redirect('manage_main')
721
722