|
43
|
1 '''
|
|
|
2 Created on 2.9.2010
|
|
|
3
|
|
|
4 @author: casties, fknauft
|
|
|
5 '''
|
|
|
6
|
|
|
7 from OFS.Folder import Folder
|
|
|
8 from Products.PageTemplates.PageTemplateFile import PageTemplateFile
|
|
|
9 from Products.ZSQLExtend import ZSQLExtend
|
|
|
10 import logging
|
|
|
11 import re
|
|
|
12 import time
|
|
61
|
13 import datetime
|
|
57
|
14 import urllib
|
|
43
|
15
|
|
|
16 from RestDbInterface import *
|
|
|
17
|
|
|
18
|
|
|
19
|
|
55
|
20 def kmlEncode(s):
|
|
|
21 """returns string encoded for displaying in KML attribute"""
|
|
|
22 res = s.replace("'","__Apostroph__")
|
|
|
23 res = res.replace('"','__DoubleApostroph__')
|
|
|
24 res = res.replace(';','__$$__')
|
|
|
25 res = res.replace('&','&')
|
|
|
26 return res
|
|
|
27
|
|
|
28
|
|
43
|
29 class RestDbGisApi(RestDbInterface):
|
|
|
30 """Object for RESTful GIS database queries
|
|
|
31 path schema: /db/{schema}/{table}/
|
|
|
32 omitting table gives a list of schemas
|
|
|
33 omitting table and schema gives a list of schemas
|
|
|
34 """
|
|
|
35
|
|
|
36 meta_type="RESTgis"
|
|
|
37
|
|
|
38 # data templates
|
|
|
39 GIS_schema_table = PageTemplateFile('zpt/GIS_schema_table', globals())
|
|
55
|
40 KML_schema_table = PageTemplateFile('zpt/KML_schema_table', globals())
|
|
61
|
41 HTML_schema_usertables = PageTemplateFile('zpt/HTML_schema_usertables', globals())
|
|
55
|
42
|
|
44
|
43 # and scripts
|
|
|
44 def KML_URL_schema_table(self,schema,table):
|
|
|
45 """KML_URL table function"""
|
|
|
46 self.REQUEST.RESPONSE.setHeader("Content-Type", "text/plain")
|
|
|
47 id = self.REQUEST.get('id',[])
|
|
|
48 doc = self.REQUEST.get('doc',None)
|
|
57
|
49 return self.getLiveKmlUrl(schema=schema,table=table)
|
|
43
|
50
|
|
61
|
51 #
|
|
|
52 # database methods
|
|
|
53 #
|
|
70
|
54 toSqlTypeMap = {
|
|
|
55 "text": "text",
|
|
|
56 "number": "numeric",
|
|
|
57 "id": "text",
|
|
|
58 "gis_id": "text",
|
|
|
59 "coord_lat": "numeric",
|
|
|
60 "coord_lon": "numeric"
|
|
|
61 }
|
|
|
62
|
|
60
|
63 def getTableOwner(self,schema,table):
|
|
|
64 """returns the owner of the table"""
|
|
61
|
65 # what do we do with the schema?
|
|
|
66 sql = 'select table_owner from public.gis_table_meta where table_name = %s'
|
|
|
67 res = self.executeSQL(sql,(table,))
|
|
|
68 if len(res['rows']) > 0:
|
|
|
69 return res['rows'][0][0]
|
|
60
|
70 return None
|
|
|
71
|
|
|
72 def isAllowed(self,action,schema,table,user=None,owner=None):
|
|
43
|
73 """returns if the requested action on the table is allowed"""
|
|
|
74 if user is None:
|
|
|
75 user = self.REQUEST.get('AUTHENTICATED_USER',None)
|
|
60
|
76 logging.debug("isAllowed action=%s schema=%s table=%s user=%s"%(action,schema,table,user))
|
|
|
77 if action == "create":
|
|
|
78 if user is not None and str(user) != 'Anonymous User':
|
|
|
79 # any authenticated user can create
|
|
|
80 return True
|
|
|
81 else:
|
|
|
82 return False
|
|
|
83
|
|
|
84 if action == "update":
|
|
|
85 if owner is None:
|
|
|
86 owner = self.getTableOwner(schema,table)
|
|
61
|
87 logging.debug("isAllowed user=%s owner=%s"%(user,owner))
|
|
60
|
88 if user is not None and str(user) == str(owner):
|
|
|
89 # update only your own table
|
|
|
90 return True
|
|
|
91 else:
|
|
|
92 return False
|
|
|
93
|
|
62
|
94 # anything else is allowed
|
|
43
|
95 return True
|
|
|
96
|
|
61
|
97 def setTableMetaTypes(self,schema,table,fields,user=None):
|
|
43
|
98 """sets the GIS meta information for table"""
|
|
61
|
99 if user is None:
|
|
|
100 user = self.REQUEST.get('AUTHENTICATED_USER',None)
|
|
|
101
|
|
|
102 logging.debug("settablemetatypes schema=%s, table=%s, fields=%s user=%s"%(schema,table,fields,user))
|
|
43
|
103
|
|
61
|
104 today = datetime.date.today().isoformat()
|
|
|
105
|
|
|
106 res = self.executeSQL('select * from public.gis_table_meta where table_name = %s', (table,))
|
|
43
|
107 if len(res['rows']) > 0:
|
|
|
108 # meta record exists
|
|
61
|
109 sql = 'update public.gis_table_meta set table_owner=%s, table_modified=%s where table_name=%s'
|
|
|
110 self.executeSQL(sql, (str(user),today,table), hasResult=False)
|
|
43
|
111 else:
|
|
|
112 # new meta record
|
|
61
|
113 sql = 'insert into public.gis_table_meta (table_name,table_owner,table_created) values (%s,%s,%s)'
|
|
|
114 self.executeSQL(sql, (table,str(user),today), hasResult=False)
|
|
|
115
|
|
|
116 # update row info
|
|
|
117 sql = 'delete from public.gis_table_meta_rows where table_name=%s'
|
|
|
118 self.executeSQL(sql,(table,),hasResult=False)
|
|
|
119 sql = 'insert into public.gis_table_meta_rows (table_name,field_name,gis_type) values (%s,%s,%s)'
|
|
|
120 for f in fields:
|
|
|
121 t = f['type']
|
|
|
122 fn = f['name']
|
|
|
123 self.executeSQL(sql, (table,fn,t), hasResult=False)
|
|
43
|
124
|
|
|
125
|
|
61
|
126 def getListOfUserTables(self,schema='public',username='guest'):
|
|
|
127 """return list of tables"""
|
|
|
128 logging.debug("getlistofusertables")
|
|
|
129 # get list of db tables
|
|
100
|
130 # qstr = """SELECT t.table_name FROM information_schema.tables t, public.gis_table_meta m WHERE t.table_type = 'BASE TABLE'
|
|
|
131 # AND t.table_schema = %s AND t.table_name = m.table_name ORDER BY 1"""
|
|
|
132 qstr = """SELECT t.table_name FROM information_schema.tables t, public.gis_table_meta m
|
|
|
133 WHERE t.table_schema = %s AND t.table_name = m.table_name ORDER BY 1"""
|
|
43
|
134
|
|
61
|
135 data=self.executeSQL(qstr,(schema,))
|
|
|
136 return data
|
|
|
137
|
|
43
|
138
|
|
|
139 def createEmptyTable(self,schema,table,fields):
|
|
|
140 """create a table with the given fields
|
|
|
141 returns list of created fields"""
|
|
61
|
142 sqlFields = RestDbInterface.createEmptyTable(self,schema,table,fields)
|
|
|
143 if sqlFields is not None:
|
|
43
|
144 self.setTableMetaTypes(schema,table,sqlFields)
|
|
61
|
145
|
|
|
146 return sqlFields
|
|
43
|
147
|
|
|
148
|
|
59
|
149 def getLiveKmlUrl(self,schema,table,useTimestamp=True,REQUEST=None):
|
|
57
|
150 if REQUEST is None:
|
|
|
151 REQUEST = self.REQUEST
|
|
55
|
152 logging.debug("getLiveKmlUrl")
|
|
|
153 baseUrl = self.absolute_url()
|
|
57
|
154 timestamp = time.time()
|
|
59
|
155 # filter parameters in URL and add to new URL
|
|
57
|
156 params = [p for p in REQUEST.form.items() if p[0] not in ('format','timestamp')]
|
|
|
157 params.append(('format','KML'))
|
|
59
|
158 if useTimestamp:
|
|
|
159 # add timestamp so URL changes every time
|
|
|
160 params.append(('timestamp',timestamp))
|
|
57
|
161 paramstr = urllib.urlencode(params)
|
|
|
162 return "%s/db/%s/%s?%s"%(baseUrl,schema,table,paramstr)
|
|
55
|
163
|
|
127
|
164 def getKmlData(self, schema, table, ids=None, sortBy=1, gisIdField=None, latField=None, lonField=None, geomField="point", colorField="red"):
|
|
55
|
165 """returns data structure for KML template"""
|
|
148
|
166 logging.debug("getKMLdata gid=%s lat=%s lon=%s geom=%s color=%s"%(gisIdField,latField,lonField,geomField,colorField))
|
|
|
167 if geomField is None:
|
|
|
168 geomField="point"
|
|
|
169 if colorField is None:
|
|
|
170 colorField="red"
|
|
55
|
171 # Mapping a set of points from table-based SQL-query:
|
|
|
172 qstr='SELECT * FROM "%s"."%s"'%(schema,table)
|
|
|
173 idList = None
|
|
|
174 if ids is not None:
|
|
|
175 qstr += ' WHERE '
|
|
|
176 if table=='mpdl':
|
|
|
177 qstr += 'mpdl_xmlsource_id IN ('
|
|
|
178 else:
|
|
|
179 qstr += 'CAST(id AS text) IN ('
|
|
|
180
|
|
|
181 idList = ids.split(",")
|
|
|
182 qstr += ','.join(['%s' for i in idList])
|
|
|
183 qstr += ')'
|
|
|
184
|
|
58
|
185 if sortBy:
|
|
|
186 # add sort clause
|
|
59
|
187 if sortBy == 1:
|
|
|
188 qstr += ' ORDER BY 1'
|
|
|
189 else:
|
|
|
190 # TODO: proper quoting for names
|
|
|
191 qstr += ' ORDER BY "%s"'%sortBy.replace('"','')
|
|
|
192
|
|
55
|
193 data = self.executeSQL(qstr,idList)
|
|
|
194
|
|
|
195 fieldMap = self.getFieldNameMap(data['fields'])
|
|
117
|
196 try:
|
|
208
|
197 geomstr='select astext(st_simplify(transform(the_geom,4326),0.02)) from "%s"."%s"'%(schema,table)
|
|
117
|
198 geomdata=self.executeSQL(geomstr)
|
|
|
199 except:
|
|
207
|
200 try:
|
|
208
|
201 geomstr='select chgis.astext(chgis.st_simplify(chgis.transform(the_geom,4326),0.02)) from "%s"."%s"'%(schema,table)
|
|
207
|
202 geomdata=self.executeSQL(geomstr)
|
|
|
203 except:
|
|
|
204 geomdata=None
|
|
117
|
205
|
|
55
|
206 if (gisIdField is None) and (latField is None or lonField is None):
|
|
|
207 # no fields given - choose automagically
|
|
93
|
208 sql = 'SELECT field_name FROM public.gis_table_meta_rows WHERE table_name = %s and gis_type = %s'
|
|
55
|
209 # gis id in metadata first
|
|
61
|
210 res = self.executeSQL(sql, (table,'gis_id'))
|
|
55
|
211 if len(res['rows']) > 0:
|
|
|
212 gisIdField = res['rows'][0][0]
|
|
|
213 else:
|
|
93
|
214 # latitude in metadata
|
|
|
215 res = self.executeSQL(sql, (table,'coord_lat'))
|
|
|
216 if len(res['rows']) > 0:
|
|
|
217 latField = res['rows'][0][0]
|
|
|
218 # longitude in metadata
|
|
|
219 res = self.executeSQL(sql, (table,'coord_lon'))
|
|
|
220 if len(res['rows']) > 0:
|
|
|
221 lonField = res['rows'][0][0]
|
|
|
222
|
|
|
223 if (gisIdField is None) and (latField is None or lonField is None):
|
|
|
224 logging.warning("no entry in metadata table for table %s" % table)
|
|
|
225 # still no fields - try field names
|
|
|
226 if 'latitude' in fieldMap and 'longitude' in fieldMap:
|
|
|
227 latField = 'latitude'
|
|
|
228 lonField = 'longitude'
|
|
|
229 elif 'x_coord' in fieldMap and 'y_coord' in fieldMap:
|
|
|
230 latField = 'x_coord'
|
|
|
231 lonField = 'y_coord'
|
|
|
232 else:
|
|
|
233 logging.error("getKMLdata unable to find position fields")
|
|
|
234 return None
|
|
|
235
|
|
55
|
236
|
|
|
237 # convert field names to row indexes
|
|
|
238 gisIdIdx = fieldMap.get(gisIdField,None)
|
|
|
239 latIdx = fieldMap.get(latField,None)
|
|
|
240 lonIdx = fieldMap.get(lonField,None)
|
|
117
|
241 the_geom=fieldMap.get("the_geom",None)
|
|
55
|
242 logging.debug("gisidfield=%s idx=%s"%(gisIdField,gisIdIdx))
|
|
|
243
|
|
|
244 # convert data
|
|
|
245 kmlData = []
|
|
151
|
246 geom_list = {}
|
|
150
|
247 if geomField=='poly' and len(geomdata)>0:
|
|
|
248 geom_list=geomdata.values()[1]
|
|
|
249 data_list=data['rows']
|
|
|
250 for k in range (len(data_list)):
|
|
|
251 dataset = data_list[k]
|
|
|
252 if len(geom_list)>k:
|
|
|
253 geom_value = geom_list[k]
|
|
|
254
|
|
|
255
|
|
|
256
|
|
|
257 # for dataset in data['rows']:
|
|
65
|
258 xCoord = 0.0
|
|
|
259 yCoord = 0.0
|
|
55
|
260 if gisIdIdx is not None:
|
|
|
261 gisID = dataset[gisIdIdx]
|
|
58
|
262 coords=self.getPointForChGisId(gisID)
|
|
55
|
263 if coords!=None:
|
|
|
264 xCoord=coords[0]
|
|
|
265 yCoord=coords[1]
|
|
|
266
|
|
|
267 elif latIdx is not None:
|
|
|
268 xCoord = dataset[lonIdx]
|
|
|
269 yCoord = dataset[latIdx]
|
|
|
270
|
|
|
271 else:
|
|
|
272 logging.error("getKMLdata unable to find position")
|
|
|
273 return None
|
|
|
274
|
|
|
275 if float(xCoord) == 0.0:
|
|
|
276 continue
|
|
|
277
|
|
|
278 if float(yCoord) == 0.0:
|
|
|
279 continue
|
|
|
280
|
|
|
281 kmlPlace = {}
|
|
|
282
|
|
|
283 # description
|
|
|
284 desc = ''
|
|
150
|
285
|
|
|
286
|
|
|
287 for i in range (len(dataset)):
|
|
|
288 value = dataset[i]
|
|
|
289
|
|
55
|
290 name = data['fields'][i][0]
|
|
58
|
291 #logging.debug("value=%s"%value)
|
|
150
|
292 if name != 'the_geom':
|
|
|
293 if value != None:
|
|
57
|
294 #if name.find('name')>-1:
|
|
|
295 # desc += "<name>%s</name>\n"%value
|
|
|
296 # continue
|
|
|
297 #elif name.find('place')>-1:
|
|
|
298 # desc += "<name>%s</name>\n"%value
|
|
|
299 # continue
|
|
55
|
300
|
|
|
301 val = "%s: %s"%(name, value)
|
|
187
|
302 value=unicode(value)
|
|
188
|
303
|
|
|
304 # If there is a link within the description data, create a valid href
|
|
191
|
305 if value.find('http://')>-1:
|
|
|
306 link_str_beg=value.find('http://')
|
|
|
307 link_str_end = -1
|
|
|
308 link_str_end0=value.find(' ',link_str_beg)
|
|
|
309 link_str_end1=value.find('>',link_str_beg)
|
|
|
310 if link_str_end0 <link_str_end1:
|
|
|
311 link_str_end=link_str_end0
|
|
|
312 else:
|
|
|
313 link_str_end=link_str_end1
|
|
|
314 if link_str_end > -1:
|
|
|
315 link_str=value[link_str_beg:link_str_end]
|
|
207
|
316 val =name+": "+value[0:link_str_beg]+'<a href=' + link_str + '> ' + link_str.replace('http://','') + ' </a>' + value[link_str_end:]
|
|
191
|
317 else:
|
|
|
318 link_str=value[link_str_beg:]
|
|
207
|
319 val =name+': '+value[0:link_str_beg]+'<a href=' + link_str + '> ' + link_str.replace('http://','') + ' </a>'
|
|
188
|
320
|
|
|
321
|
|
57
|
322 #desc += kmlEncode(val)
|
|
|
323 desc += val
|
|
55
|
324 desc += '<br/>\n'
|
|
|
325
|
|
57
|
326 #kmlPlace['description'] = "<![CDATA[%s]]>"%desc
|
|
150
|
327
|
|
124
|
328
|
|
133
|
329 if geomField=='point':
|
|
207
|
330 kmlPlace['description'] = "<![CDATA[%s]]>"%desc
|
|
193
|
331
|
|
133
|
332 kmlPlace['icon'] = '#marker_icon_'+colorField
|
|
|
333 kmlPlace['coord_x'] = str(xCoord)
|
|
|
334 kmlPlace['coord_y'] = str(yCoord)
|
|
|
335 kmlPlace['coord_z'] = '0'
|
|
134
|
336 kmlData.append(kmlPlace)
|
|
135
|
337 if geomField=='poly' and len(geomdata)>0:
|
|
150
|
338 polys=str(geom_value).split('(')
|
|
144
|
339 aaa=len(polys)
|
|
142
|
340 for poly in polys:
|
|
150
|
341 kmlPlace = {}
|
|
|
342 kmlPlace['description'] = desc
|
|
152
|
343 coords=poly.replace(')','').replace("'","").split(',')
|
|
150
|
344 coord_string=''
|
|
144
|
345 if len(coords)>1:
|
|
146
|
346 for coord in coords:
|
|
|
347 coord=coord.split(' ')
|
|
|
348 try:
|
|
|
349 x_coord=coord[0]
|
|
|
350 y_coord=coord[1]
|
|
|
351 except:
|
|
|
352 break
|
|
150
|
353 coord_string+=x_coord+','+y_coord+','+'0 '
|
|
|
354 if coord_string != '':
|
|
|
355 kmlPlace['LinearRing']=coord_string
|
|
|
356 kmlPlace['LineColor']=colorField
|
|
|
357 kmlData.append(kmlPlace)
|
|
55
|
358 #logging.debug("kmlData=%s"%(repr(kmlData)))
|
|
|
359 return kmlData
|
|
58
|
360
|
|
|
361 def getPointForChGisId(self, gis_id):
|
|
|
362 """returns coordinate pair for given gis_id"""
|
|
59
|
363 def getPoint(id):
|
|
157
|
364 sql="SELECT x_coord,y_coord FROM chgis.chgis_coords WHERE gis_id = CAST(%s AS text)"
|
|
|
365 str_gis_id=str(gis_id).split('.')[0]
|
|
|
366 res = self.executeSQL(sql, (str_gis_id,))
|
|
59
|
367 if len(res['rows']) > 0:
|
|
|
368 return res['rows'][0]
|
|
|
369 return None
|
|
55
|
370
|
|
58
|
371 if gis_id is None or gis_id == "":
|
|
|
372 return None
|
|
|
373
|
|
59
|
374 # try gis_id
|
|
|
375 coords = getPoint(gis_id)
|
|
|
376 if coords is None:
|
|
58
|
377 # try to clean gis_id...
|
|
|
378 gis_id = re.sub(r'[^0-9]','',gis_id)
|
|
|
379 # try again
|
|
59
|
380 coords = getPoint(gis_id)
|
|
|
381 if coords is None:
|
|
58
|
382 logging.error("CH-GIS ID %s not found!"%repr(gis_id))
|
|
|
383
|
|
|
384 # TODO: do we need the getCoordsFromREST_gisID stuff?
|
|
|
385
|
|
59
|
386 return coords
|
|
|
387
|
|
55
|
388
|
|
59
|
389 ## legacy methods...
|
|
|
390
|
|
|
391 def getKmlUrl(self,schema='chgis',table='mpdl',id=[],doc=None):
|
|
|
392 logging.debug("getKmlUrl")
|
|
|
393 data = self.getDataForGoogleMap(schema,table,id,doc)
|
|
|
394 kml=self.getKMLname(data=data,table=table)
|
|
|
395 baseUrl = self.absolute_url()
|
|
|
396 return "%s/daten/%s"%(baseUrl,kml)
|
|
|
397
|
|
|
398 def getDataForGoogleMap(self,schema='chgis',table='mpdl',id=None,doc=None):
|
|
|
399 logging.debug("getDataForGoogleMap")
|
|
|
400 qstr="SELECT * FROM "+schema+"."+table
|
|
|
401 try:
|
|
|
402 if id is not None:
|
|
|
403 qstr=qstr+" WHERE "
|
|
|
404 for id_item in id.split(","):
|
|
|
405 if table=='mpdl':
|
|
|
406 qstr=qstr+" mpdl_xmlsource_id = '"+id_item+ "' OR"
|
|
|
407 else:
|
|
|
408 qstr=qstr+" cast(id as text) LIKE '"+id_item+ "' OR"
|
|
|
409 qstr=str(qstr).rsplit(" ",1)[0] #to remove last " and "
|
|
|
410 data=self.ZSQLSimpleSearch(qstr)
|
|
|
411 return data
|
|
|
412 except:
|
|
|
413 return qstr
|
|
55
|
414
|
|
|
415
|
|
43
|
416 def getKMLname(self,data=[],table=""):
|
|
|
417 logging.debug("getKMLname")
|
|
|
418 #session=context.REQUEST.SESSION
|
|
109
|
419 kml4Marker="<kml xmlns=\'http://www.opengis.net/kml/2.2\'><Document>"
|
|
|
420 kml4Marker+="<Style id=\'marker_icon_red\'><IconStyle><scale>15</scale><Icon><href>http://mappit.mpiwg-berlin.mpg.de/mappit/icons/dot_red.png</href></Icon></IconStyle></Style>\n"
|
|
|
421 kml4Marker+="<Style id=\'marker_icon_black\'><IconStyle><scale>15</scale><Icon><href>http://mappit.mpiwg-berlin.mpg.de/mappit/icons/dot_black.png</href></Icon></IconStyle></Style>\n"
|
|
|
422 kml4Marker+="<Style id=\'marker_icon_blue\'><IconStyle><scale>15</scale><Icon><href>http://mappit.mpiwg-berlin.mpg.de/mappit/icons/dot_blue.png</href></Icon></IconStyle></Style>\n"
|
|
|
423 kml4Marker+="<Style id=\'marker_icon_green\'><IconStyle><scale>15</scale><Icon><href>http://mappit.mpiwg-berlin.mpg.de/mappit/icons/dot_green.png</href></Icon></IconStyle></Style>\n"
|
|
|
424 kml4Marker+="<Style id=\'marker_icon_violett\'><IconStyle><scale>15</scale><Icon><href>http://mappit.mpiwg-berlin.mpg.de/mappit/icons/dot_violett.png</href></Icon></IconStyle></Style>\n"
|
|
43
|
425 initializeStringForGoogleMaps=""
|
|
|
426 #doLine=container.getVar('doLine')
|
|
|
427 # Mapping a set of points from table-based SQL-query:
|
|
|
428 if data!=None:
|
|
|
429 try:
|
|
|
430 SQL='SELECT "attribute with gis_id" FROM public.metadata WHERE tablename = %s'
|
|
|
431 res = self.executeSQL(SQL, (table,))
|
|
|
432 gisIDattribute = res['rows'][0][0]
|
|
|
433 except:
|
|
|
434 return "table not registered within metadata"
|
|
|
435
|
|
|
436 for dataset in data:
|
|
|
437 try:
|
|
|
438 xCoord=getattr(dataset,'longitude')
|
|
|
439 yCoord=getattr(dataset,'latitude')
|
|
|
440 except:
|
|
|
441 try:
|
|
|
442 xCoord=getattr(dataset,'x_coord')
|
|
|
443 yCoord=getattr(dataset,'y_coord')
|
|
|
444 except:
|
|
|
445 #try:
|
|
|
446 gisID=getattr(dataset,gisIDattribute)
|
|
|
447 coords=self.getPoint4GISid(gisID)
|
|
|
448 if coords!=None:
|
|
|
449 xCoord=coords[0]
|
|
|
450 yCoord=coords[1]
|
|
|
451 # except:
|
|
|
452 # return "no coordinates found"
|
|
|
453
|
|
|
454 if float(xCoord)!=0:
|
|
|
455 if float(yCoord)!=0:
|
|
|
456 kml4Marker=kml4Marker+"<Placemark>"
|
|
|
457 kml4Marker=kml4Marker+"<description> <![CDATA[<b>"
|
|
|
458 for values in dataset:
|
|
55
|
459 #logging.debug("values=%s"%repr(values))
|
|
43
|
460 if values != (None, None):
|
|
|
461 if str(values).find('name')>-1:
|
|
|
462 kml4Marker=kml4Marker+"<name>"+str(values[1])+"</name>\n"
|
|
|
463 continue
|
|
|
464 elif str(values).find('place')>-1:
|
|
|
465 kml4Marker=kml4Marker+"<name>"+str(values[1])+"</name>\n"
|
|
|
466 continue
|
|
|
467
|
|
|
468 kml4Marker=kml4Marker+str(values)+": "
|
|
|
469 attribute_string=str(values).replace("'","__Apostroph__")
|
|
|
470 attribute_string=str(attribute_string).replace('"','__DoubleApostroph__')
|
|
|
471 attribute_string=str(attribute_string).replace(';','__$$__')
|
|
|
472 attribute_string=str(attribute_string).replace('&','&')
|
|
|
473 if str(attribute_string).find('http')>-1:
|
|
207
|
474 attribute_string='<A HREF=' + str(attribute_string) + ' target="_blank">' + str(attribute_string) + '</A>'
|
|
43
|
475 kml4Marker=kml4Marker+attribute_string+"</a><br>\n"
|
|
|
476
|
|
|
477 kml4Marker=kml4Marker+"]]></description>\n"
|
|
117
|
478 kml4Marker=kml4Marker+"<styleURL>#marker_icon_red</styleURL>\n"
|
|
43
|
479 kml4Marker=kml4Marker+"<Point>"
|
|
|
480
|
|
|
481 kml4Marker=kml4Marker+"<coordinates>"+str(xCoord)+","+str(yCoord)+",0</coordinates>\n"
|
|
|
482 kml4Marker=kml4Marker+"</Point>\n"
|
|
|
483 kml4Marker=kml4Marker+"</Placemark>\n"
|
|
|
484
|
|
|
485 kml4Marker=kml4Marker+"</Document>\n</kml>"
|
|
|
486 kmlFileName="marker"+str(time.time())+".kml"
|
|
|
487
|
|
|
488 #kml4Marker=str(kml4Marker).replace('&','$$')
|
|
|
489 #kml4Marker=str(kml4Marker).replace(';','__$$__')
|
|
|
490 #kml4Marker=str(kml4Marker).replace('#','__SHARP__')
|
|
|
491 isLoadReady='false'
|
|
|
492 while isLoadReady=='false':
|
|
|
493 isLoadReady=self.RESTwrite2File(self.daten,kmlFileName,kml4Marker)
|
|
|
494
|
|
|
495 return kmlFileName
|
|
207
|
496
|
|
|
497 def trydatahas_key(self,data,index,key_string):
|
|
|
498 try:
|
|
|
499 return data[index].has_key(key_string)
|
|
|
500 except:
|
|
|
501 return 'false'
|
|
43
|
502
|
|
44
|
503 # def getGoogleMapString(self,kml):
|
|
|
504 # logging.debug("getGoogleMapString")
|
|
|
505 # printed= '<body %s> '%kml +"""\n <div id="map_canvas" style="width: 98%; height: 95%"> </div> \n </body>" \n </html>"""
|
|
|
506 # return printed
|
|
43
|
507
|
|
|
508 def getPoint4GISid(self,gis_id):
|
|
|
509 j=0
|
|
|
510 coords=(0,0)
|
|
|
511 if gis_id != None:
|
|
|
512 while (True):
|
|
|
513 j=j+1
|
|
|
514 if (j>100): # FJK: just to prevent endless loops
|
|
|
515 break
|
|
|
516 if (gis_id.isdigit()): # FJK: regular exit from while-loop
|
|
|
517 break
|
|
|
518 else:
|
|
|
519 gis_id=gis_id.strip('abcdefghijklmnopqrstuvwxyz_') # FJK: to strip all letters
|
|
|
520 gis_id=gis_id.strip() # FJK: to strip all whitespaces
|
|
|
521 resultpoint = [0,0]
|
|
|
522 results = None
|
|
|
523 try:
|
|
|
524 if int(gis_id)>0:
|
|
|
525 SQL="SELECT x_coord,y_coord FROM chgis.chgis_coords WHERE gis_id LIKE cast("+ str(gis_id) +" as text);"
|
|
|
526 results=self.ZSQLSimpleSearch(SQL)
|
|
|
527 #print results
|
|
|
528 if results != None:
|
|
|
529 for result in results:
|
|
|
530 resultpoint=[getattr(result,str('x_coord')),getattr(result,str('y_coord'))]
|
|
|
531 if resultpoint !=[0,0]:
|
|
|
532 return resultpoint
|
|
|
533 else:
|
|
|
534 coords=self.getCoordsFromREST_gisID(joinid)
|
|
|
535 SQL="INSERT INTO chgis.chgis_coords (gis_id,x_coord,y_coord) VALUES (" +gis_id+ "," +coords[0][1]+ "," +coords[0][0]+ "); ANALYZE chgis.chgis_coords;"
|
|
|
536 returnstring=self.ZSQLSimpleSearch(SQL)
|
|
|
537 return coords[0]
|
|
|
538 except:
|
|
|
539 return "gis_id not to interpretable:"+str(gis_id)
|
|
|
540 else:
|
|
|
541 return coords[0]
|
|
|
542
|
|
|
543 def getCoordsFromREST_gisID(self,gis_id):
|
|
|
544 coordlist=[]
|
|
|
545 i=0
|
|
|
546 while (i<5 and coordlist==[]):
|
|
|
547
|
|
|
548 urlresponse=container.urlFunctions.zUrlopenParseString(container.urlFunctions.zUrlopenRead("http://chgis.hmdc.harvard.edu/xml/id/"+gis_id))
|
|
|
549 baseDocElement=container.urlFunctions.zUrlopenDocumentElement(urlresponse)
|
|
|
550 childnodes=container.urlFunctions.zUrlopenChildNodes(baseDocElement)
|
|
|
551 itemnodes=container.urlFunctions.zUrlopenGetElementsByTagName(baseDocElement,'item')
|
|
|
552
|
|
|
553 for i in range(0,container.urlFunctions.zUrlopenLength(itemnodes)):
|
|
|
554 itemnode=container.urlFunctions.zUrlopenGetItem(itemnodes,i)
|
|
|
555 itemspatialnodes=container.urlFunctions.zUrlopenGetElementsByTagName(itemnode,'spatial')
|
|
|
556 for j in range(0,container.urlFunctions.zUrlopenLength(itemspatialnodes)):
|
|
|
557 coord=[]
|
|
|
558 itemspatialnode= container.urlFunctions.zUrlopenGetItem(itemspatialnodes,j)
|
|
|
559 itemspatiallatnodes=container.urlFunctions.zUrlopenGetElementsByTagName(itemspatialnode,'degrees_latitude')
|
|
|
560 for k in range(0,container.urlFunctions.zUrlopenLength(itemspatiallatnodes)):
|
|
|
561 itemspatiallatnode= container.urlFunctions.zUrlopenGetItem(itemspatiallatnodes,k)
|
|
|
562 coord.append(container.urlFunctions.zUrlopenGetTextData(itemspatiallatnode))
|
|
|
563 itemspatiallngnodes=container.urlFunctions.zUrlopenGetElementsByTagName(itemspatialnode,'degrees_longitude')
|
|
|
564 for k in range(0,container.urlFunctions.zUrlopenLength(itemspatiallngnodes)):
|
|
|
565 itemspatiallngnode= container.urlFunctions.zUrlopenGetItem(itemspatiallngnodes,k)
|
|
|
566 coord.append(container.urlFunctions.zUrlopenGetTextData(itemspatiallngnode))
|
|
|
567 coordlist.append(coord)
|
|
|
568 gis_id= "_"+gis_id
|
|
|
569 return coordlist
|
|
|
570
|
|
|
571 # End for GoogleMaps creation
|
|
|
572
|
|
|
573 def RESTwrite2File(self,datadir, name,text):
|
|
|
574 logging.debug("RESTwrite2File datadir=%s name=%s"%(datadir,name))
|
|
|
575 try:
|
|
|
576 import cStringIO as StringIO
|
|
|
577 except:
|
|
|
578 import StringIO
|
|
|
579
|
|
|
580 # make filehandle from string
|
|
|
581 textfile = StringIO.StringIO(text)
|
|
|
582 fileid=name
|
|
|
583 if fileid in datadir.objectIds():
|
|
|
584 datadir.manage_delObjects(fileid)
|
|
|
585 fileInZope=datadir.manage_addFile(id=fileid,file=textfile)
|
|
|
586 return "Write successful"
|
|
|
587
|
|
|
588 def manage_editRestDbGisApi(self, title=None, connection_id=None,
|
|
|
589 REQUEST=None):
|
|
|
590 """Change the object"""
|
|
|
591 if title is not None:
|
|
|
592 self.title = title
|
|
|
593
|
|
|
594 if connection_id is not None:
|
|
|
595 self.connection_id = connection_id
|
|
|
596
|
|
|
597 #checkPermission=getSecurityManager().checkPermission
|
|
|
598 REQUEST.RESPONSE.redirect('manage_main')
|
|
|
599
|
|
|
600
|
|
|
601 manage_addRestDbGisApiForm=PageTemplateFile('zpt/addRestDbGisApi',globals())
|
|
|
602
|
|
|
603 def manage_addRestDbGisApi(self, id, title='', label='', description='',
|
|
|
604 createPublic=0,
|
|
|
605 createUserF=0,
|
|
|
606 REQUEST=None):
|
|
|
607 """Add a new object with id *id*."""
|
|
|
608
|
|
|
609 ob=RestDbGisApi(str(id),title)
|
|
|
610 self._setObject(id, ob)
|
|
|
611
|
|
|
612 #checkPermission=getSecurityManager().checkPermission
|
|
|
613 REQUEST.RESPONSE.redirect('manage_main')
|
|
|
614
|
|
|
615
|
